Attachment #64101 for bug #182110

Lines 191-197 Link Here

(-)src/org/eclipse/jface/viewers/ComboBoxCellEditor.java (-2 / +2 lines)
191	* this <code>CellEditor</code> framework method sets the	191	* this <code>CellEditor</code> framework method sets the
192	* minimum width of the cell. The minimum width is 10 characters	192	* minimum width of the cell. The minimum width is 10 characters
193	* if <code>comboBox</code> is not <code>null</code> or <code>disposed</code>	193	* if <code>comboBox</code> is not <code>null</code> or <code>disposed</code>
194	* eles it is 60 pixels to make sure the arrow button and some text is visible.	194	* else it is 60 pixels to make sure the arrow button and some text is visible.
195	* The list of CCombo will be wide enough to show its longest item.	195	* The list of CCombo will be wide enough to show its longest item.
196	*/	196	*/
197	public LayoutData getLayoutData() {	197	public LayoutData getLayoutData() {
Lines 238-244 Link Here
238	}	238	}
239		239
240	/**	240	/**
241	* Applies the currently selected value and deactiavates the cell editor	241	* Applies the currently selected value and deactivates the cell editor
242	*/	242	*/
243	void applyEditorValueAndDeactivate() {	243	void applyEditorValueAndDeactivate() {
244	// must set the selection before getting value	244	// must set the selection before getting value




	 * EXPERIMENTAL. Not to be used except by JDT. This method was added to
	 * support JDT's explorations into grouping by working sets, which requires
	 * viewers to support multiple equal elements. See bug 76482 for more
	 * details. This support will likely be removed in Eclipse 3.2 in favor of
	 * proper support for multiple equal elements.
	 * </p>
	 * 

	 *            The comparator to use.
	 * @param lastInsertion
	 *            the start index to start search for position from this allows
	 *            optimizing search for multiple elements that are sorted
	 *            themselves.
	 * @param element
	 *            element to find position for.
	 * @param parentPath

	 *            The sorter to use.
	 * @param startIndex
	 *            the start index to start search for position from this allows
	 *            optimizing search for multiple elements that are sorted
	 *            themselves.
	 * @param element
	 *            element to find position for.
	 * @param currentSize

	 * @param e1
	 *            the first element
	 * @param e2
	 *            the second element
	 * @return the result of comparing the two elements
	 */
	private int internalCompare(ViewerComparator comparator,


	/**
	 * Get the child for the widget at index. Note that the default
	 * implementation is not very efficient and should be overridden if this
	 * class is implemented.
	 * 
	 * @param widget

	 * EXPERIMENTAL. Not to be used except by JDT. This method was added to
	 * support JDT's explorations into grouping by working sets, which requires
	 * viewers to support multiple equal elements. See bug 76482 for more
	 * details. This support will likely be removed in Eclipse 3.2 in favor of
	 * proper support for multiple equal elements.
	 * </p>
	 * 

	 * EXPERIMENTAL. Not to be used except by JDT. This method was added to
	 * support JDT's explorations into grouping by working sets, which requires
	 * viewers to support multiple equal elements. See bug 76482 for more
	 * details. This support will likely be removed in Eclipse 3.2 in favor of
	 * proper support for multiple equal elements.
	 * </p>
	 * 


	/**
	 * Return whether the tree node representing the given element or path can
	 * be expanded. Clients should query expandability by path if the viewer's
	 * content provider is an {@link ITreePathContentProvider}.
	 * <p>
	 * The default implementation of this framework method calls

	 * @param item
	 *            the tree item for the element
	 * @param parentPath
	 *            the parent path if it is known or <code>null</code> if it
	 *            needs to be determines
	 * @param element
	 *            the element

	 * 
	 * @param item
	 *            the item to compute the descendent of
	 * @return the rightmost visible descendent or the item itself if it has no
	 *         children
	 */
	private Item rightMostVisibleDescendent(Item item) {

	/**
	 * Returns the number of columns of this viewer.
	 * <p><b>Subclasses should overwrite this method, which has a default
	 * implementation (returning 0) for API backwards compatibility reasons</b></p>
	 *
	 * @return the number of columns
	 *

Lines 18-24 Link Here

(-)src/org/eclipse/jface/viewers/IColorDecorator.java (-1 / +1 lines)
18	* an object.	18	* an object.
19	*	19	*
20	* If an IColorDecorator decorates a foreground or background in an object	20	* If an IColorDecorator decorates a foreground or background in an object
21	* that also has an IColorProvider the IColorDecorator will take precendence.	21	* that also has an IColorProvider the IColorDecorator will take precedence.
22	* @see IColorProvider	22	* @see IColorProvider
23	*	23	*
24	* @since 3.1	24	* @since 3.1

Lines 13-19 Link Here

(-)src/org/eclipse/jface/viewers/ILazyContentProvider.java (-2 / +2 lines)
13	/**	13	/**
14	* The ILazyContentProvider is the content provider	14	* The ILazyContentProvider is the content provider
15	* for table viewers created using the SWT.VIRTUAL flag that	15	* for table viewers created using the SWT.VIRTUAL flag that
16	* only wish to return thier contents as they are queried.	16	* only wish to return their contents as they are queried.
17	*	17	*
18	* <strong>NOTE:</strong> As the ILazyContentProvider does	18	* <strong>NOTE:</strong> As the ILazyContentProvider does
19	* not have API for determining the total item count any	19	* not have API for determining the total item count any
Lines 34-40 Link Here
34	* In this situation it is suggested that the selection is asked	34	* In this situation it is suggested that the selection is asked
35	* for again after he update.	35	* for again after he update.
36	*	36	*
37	* @param index The index that is being updateed in the	37	* @param index The index that is being updated in the
38	* table.	38	* table.
39	*/	39	*/
40	public void updateElement(int index);	40	public void updateElement(int index);

Lines 17-23 Link Here

(-)src/org/eclipse/jface/viewers/IFontDecorator.java (-1 / +1 lines)
17	* decorate an object.	17	* decorate an object.
18	*	18	*
19	* If an IFontDecorator decorates a font in an object that also has	19	* If an IFontDecorator decorates a font in an object that also has
20	* an IFontProvider the IFontDecorator will take precendence.	20	* an IFontProvider the IFontDecorator will take precedence.
21	* @see IFontProvider	21	* @see IFontProvider
22	*	22	*
23	* @since 3.1	23	* @since 3.1

Lines 78-84 Link Here

(-)src/org/eclipse/jface/viewers/StructuredSelection.java (-1 / +1 lines)
78		78
79	/**	79	/**
80	* Returns whether this structured selection is equal to the given object.	80	* Returns whether this structured selection is equal to the given object.
81	* Two structured selections are equal iff they contain the same elements	81	* Two structured selections are equal if they contain the same elements
82	* in the same order.	82	* in the same order.
83	*	83	*
84	* @param o the other object	84	* @param o the other object




 * 
 * @since 3.3
 */
public abstract class CellLabelProvider extends BaseLabelProvider {


	/**
	 * Create a new instance of the receiver.

	 *            The labelProvider to convert
	 * @return ViewerLabelProvider
	 */
	/* package */static CellLabelProvider createViewerLabelProvider(
			IBaseLabelProvider labelProvider) {

		if (labelProvider instanceof ITableLabelProvider


	}

	
	/**
	 * Get the image displayed in the tool tip for object.
	 * 
	 * <p>
	 * <b>If {@link #getToolTipText(Object)} and
	 * {@link #getToolTipImage(Object)} both return <code>null</code> the
	 * control is set back to standard behavior</b>
	 * </p>
	 * 
	 * @param object
	 *            the element for which the tool tip is shown

	}

	/**
	 * Get the text displayed in the tool tip for object.
	 * <code>null</code> if a custom tool tip should not be displayed.
	 * 
	 * <p>
	 * <b>If {@link #getToolTipText(Object)} and
	 * {@link #getToolTipImage(Object)} both return <code>null</code> the
	 * control is set back to standard behavior</b>
	 * </p>
	 * 
	 * @param element
	 *            the element for which the tool tip is shown
	 * @return the {@link String} or <code>null</code> if there is not text to
	 *         display
	 */
	public String getToolTipText(Object element) {
		return null;

	 *            the {@link Object} for which the tool tip is shown
	 * 
	 * @return the {@link Color} used or <code>null</code> if you want to use
	 *         the default color {@link SWT#COLOR_INFO_BACKGROUND}
	 * @see SWT#COLOR_INFO_BACKGROUND
	 */
	public Color getToolTipBackgroundColor(Object object) {
		return null;

	 * 
	 * @param object
	 *            the element for which the tool tip is shown
	 * @return {@link Point} to shift of the tool tip or <code>null</code> if the
	 *         default shift should be used.
	 */
	public Point getToolTipShift(Object object) {

	}

	/**
	 * Return whether or not to use the native tool tip. If you switch to native
	 * tool tips only the value from {@link #getToolTipText(Object)} is used all
	 * other features from custom tool tips are not supported.
	 * 
	 * <p>
	 * To reset the control to native behavior you should return
	 * <code>true</code> from this method and <code>null</code> from
	 * {@link #getToolTipText(Object)} or <code>null</code> from
	 * {@link #getToolTipText(Object)} and {@link #getToolTipImage(Object)} at
	 * the same time
	 * </p>
	 * 
	 * @param object
	 *            the {@link Object} for which the tool tip is shown

	 * 
	 * @param object
	 *            the {@link Object} for which the tool tip is shown
	 * @return time in milliseconds the tool tip is shown for
	 */
	public int getToolTipTimeDisplayed(Object object) {
		return 0;
	}

	/**
	 * The time in milliseconds until the tool tip is displayed.
	 * 
	 * @param object
	 *            the {@link Object} for which the tool tip is shown
	 * @return time in milliseconds until the tool tip is displayed
	 */
	public int getToolTipDisplayDelayTime(Object object) {
		return 0;
	}

	/**
	 * The {@link SWT} style used to create the {@link CLabel} (see there for
	 * supported styles). By default {@link SWT#SHADOW_NONE} is used.
	 * 
	 * @param object
	 *            the element for which the tool tip is shown
	 * @return the style used to create the label
	 * @see CLabel
	 */
	public int getToolTipStyle(Object object) {

	/**
	 * Update the label for cell.
	 * 
	 * @param cell
	 *            {@link ViewerCell}
	 */
	public abstract void update(ViewerCell cell);


Lines 104-110 Link Here

(-)src/org/eclipse/jface/viewers/ViewerColumn.java (-2 / +2 lines)
104	}	104	}
105		105
106	/**	106	/**
107	* Return the editing support for the reciever.	107	* Return the editing support for the receiver.
108	*	108	*
109	* @return {@link EditingSupport}	109	* @return {@link EditingSupport}
110	*/	110	*/
Lines 136-142 Link Here
136	}	136	}
137		137
138	/**	138	/**
139	* Disposes of the label provider (if set), deregisters the listener and	139	* Disposes of the label provider (if set), unregisters the listener and
140	* nulls the references to the label provider and editing support. This	140	* nulls the references to the label provider and editing support. This
141	* method is called when the underlying widget is disposed. Subclasses may	141	* method is called when the underlying widget is disposed. Subclasses may
142	* extend but must call the super implementation.	142	* extend but must call the super implementation.




import org.eclipse.swt.widgets.Event;

/**
 * The ColumnViewerTooltipSupport is the class that provides tool tips for ColumnViewers.
 * 
 * @since 3.3
 * 

	 * 
	 * @param viewer
	 *            the viewer the support is attached to
	 * @param style style passed to control tool tip behavior
	 * 
	 * @param manualActivation
	 *            <code>true</code> if the activation is done manually using

	 * 
	 * @param viewer
	 *            the viewer the support is attached to
	 * @param style style passed to control tool tip behavior
	 * 
	 * @see ToolTip#RECREATE
	 * @see ToolTip#NO_RECREATE

Lines 50-56 Link Here

(-)src/org/eclipse/jface/viewers/ICellEditorListener.java (-1 / +1 lines)
50	* notification is normally sent only by text-based editors in response to a	50	* notification is normally sent only by text-based editors in response to a
51	* keystroke, so that the listener may show an error message reflecting the	51	* keystroke, so that the listener may show an error message reflecting the
52	* current valid state. This notification is sent while the value is being	52	* current valid state. This notification is sent while the value is being
53	* actively edited, before the value is applied or cancelled. A listener should	53	* actively edited, before the value is applied or canceled. A listener should
54	* <b>not</b> update the model based on this notification; see	54	* <b>not</b> update the model based on this notification; see
55	* <code>applyEditorValue</code>.	55	* <code>applyEditorValue</code>.
56	* <p>	56	* <p>




     * Gathers the checked and grayed states of the given widget and its
     * descendents.
     *
     * @param checked a writable set of elements (element type: <code>Object</code>) 
     * @param grayed a writable set of elements (element type: <code>Object</code>) 
     * @param widget the widget
     */
    private void gatherState(CustomHashtable checked, CustomHashtable grayed,

     * Gathers the checked states of the given widget and its
     * descendents, following a pre-order traversal of the tree.
     *
     * @param result a writable list of elements (element type: <code>Object</code>)
     * @param widget the widget
     */
    private void internalCollectChecked(List result, Widget widget) {

     * Gathers the grayed states of the given widget and its
     * descendents, following a pre-order traversal of the tree.
     *
     * @param result a writable list of elements (element type: <code>Object</code>)
     * @param widget the widget
     */
    private void internalCollectGrayed(List result, Widget widget) {

	}

	/**
	 * Set the checked state of items and their children to state.
	 * @param state
	 * @param items
	 */

Lines 12-18 Link Here

(-)src/org/eclipse/jface/viewers/IDelayedLabelDecorator.java (-1 / +1 lines)
12		12
13	/**	13	/**
14	* A delayed label decorator is a label decorator that may not have a	14	* A delayed label decorator is a label decorator that may not have a
15	* decoration available immidiately. This interface defines the methods for	15	* decoration available immediately. This interface defines the methods for
16	* requesting the preparation of a decorator for an object and for querying	16	* requesting the preparation of a decorator for an object and for querying
17	* if the decorator is ready. Interested parties should register an	17	* if the decorator is ready. Interested parties should register an
18	* ILabelProviderListener with a delayed label decorator in order to be informed	18	* ILabelProviderListener with a delayed label decorator in order to be informed




	 * @param cellToExpand
	 *            the cell the user wants to expand
	 * @param event
	 *            the event triggering the expansion
	 */
	public void expand(ColumnViewer viewer, ViewerCell cellToExpand, Event event) {


	 * @param cellToCollapse
	 *            the cell the user wants to collapse
	 * @param event
	 *            the event triggering the expansion
	 */
	public void collapse(ColumnViewer viewer, ViewerCell cellToCollapse,
			Event event) {

	}

	/**
	 * This method is consulted to decide whether an event has to be canceled or
	 * not. By default events who collapse/expand tree-nodes are canceled
	 * 
	 * @param viewer
	 *            the viewer working for
	 * @param event
	 *            the event
	 * @return <code>true</code> if the event has to be canceled
	 */
	public boolean shouldCancelEvent(ColumnViewer viewer, Event event) {
		return event.keyCode == SWT.ARROW_LEFT




	private ColumnViewerEditorActivationStrategy editorActivationStrategy;

	/**
	 * Tabbing from cell to cell is turned off
	 */
	public static final int DEFAULT = 1;


	public static final int TABBING_CYCLE_IN_ROW = 1 << 2;

	/**
	 * Support tabbing to Cell above/below the current cell
	 */
	public static final int TABBING_VERTICAL = 1 << 3;

	/**
	 * Should tabbing from column to column with in one row be supported
	 */
	public static final int TABBING_HORIZONTAL = 1 << 4;


	}

	/**
	 * Cancel editing
	 */
	void cancelEditing() {
		if (cellEditor != null) {

	}

	/**
	 * Process the traverse event and opens the next available editor depending
	 * of the implemented strategy. The default implementation uses the style
	 * constants
	 * <ul>

	 * @param row
	 *            the current row - may only be used for the duration of this method call
	 * @param event
	 *            the traverse event
	 */
	protected void processTraverseEvent(int columnIndex, ViewerRow row,
			TraverseEvent event) {

Lines 15-21 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewerEditorActivationStrategy.java (-3 / +3 lines)
15	import org.eclipse.swt.events.KeyListener;	15	import org.eclipse.swt.events.KeyListener;
16		16
17	/**	17	/**
18	* This class is responsible to determin if a cell selection event is triggers	18	* This class is responsible to determine if a cell selection event is triggers
19	* an editor activation	19	* an editor activation
20	*	20	*
21	* @since 3.3	21	* @since 3.3
Lines 33-40 Link Here
33	}	33	}
34		34
35	/**	35	/**
36	* @param event	36	* @param event the event triggering the action
37	* @return bla bl	37	* @return <code>true</code> if this event should open the editor
38	*/	38	*/
39	protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {	39	protected boolean isEditorActivationEvent(ColumnViewerEditorActivationEvent event) {
40	return event.eventType == ColumnViewerEditorActivationEvent.MOUSE_CLICK_SELECTION	40	return event.eventType == ColumnViewerEditorActivationEvent.MOUSE_CLICK_SELECTION

Lines 53-60 Link Here

(-)src/org/eclipse/jface/viewers/DecorationContext.java (-2 / +2 lines)
53	}	53	}
54		54
55	/**	55	/**
56	* Set the pgiven roperty to the given value. Setting the value of	56	* Set the given property to the given value. Setting the value of
57	* a propert to <code>null</code> removes the property from	57	* a property to <code>null</code> removes the property from
58	* the context.	58	* the context.
59	* @param property the property	59	* @param property the property
60	* @param value the value of the property or <code>null</code>	60	* @param value the value of the property or <code>null</code>




    }

    /**
     * Checks to see if the "deletable" state (can delete/
     * nothing to delete) has changed and if so fire an
     * enablement changed notification.
     */

                if ((getControl() == null) || getControl().isDisposed()) {
					return;
				}
                checkSelection(); // see explanation below
                checkDeleteable();
                checkSelectable();
            }

        });
        // We really want a selection listener but it is not supported so we
        // use a key listener and a mouse listener to know when selection changes
        // may have occurred
        text.addMouseListener(new MouseAdapter() {
            public void mouseUp(MouseEvent e) {
                checkSelection();

Lines 15-21 Link Here

(-)src/org/eclipse/jface/viewers/TreePathViewerSorter.java (-2 / +2 lines)
15	import java.util.Comparator;	15	import java.util.Comparator;
16		16
17	/**	17	/**
18	* A viewer sorter that is provded extra context in the form of the path of the	18	* A viewer sorter that is provided extra context in the form of the path of the
19	* parent element of the elements being sorted.	19	* parent element of the elements being sorted.
20	*	20	*
21	* @since 3.2	21	* @since 3.2
Lines 42-48 Link Here
42	}	42	}
43		43
44	/**	44	/**
45	* Compare the givcen elements that will have the given parent	45	* Compare the given elements that will have the given parent
46	* path when they are added to the viewer. The provided path is	46	* path when they are added to the viewer. The provided path is
47	* relative to the viewer input. The parent path will	47	* relative to the viewer input. The parent path will
48	* be <code>null</code> when the elements are root elements.	48	* be <code>null</code> when the elements are root elements.

Lines 68-74 Link Here

(-)src/org/eclipse/jface/viewers/ViewerCell.java (-1 / +1 lines)
68	/**	68	/**
69	* Get the index of the cell.	69	* Get the index of the cell.
70	*	70	*
71	* @return int	71	* @return the index
72	*/	72	*/
73	public int getColumnIndex() {	73	public int getColumnIndex() {
74	return columnIndex;	74	return columnIndex;

Lines 71-77 Link Here

(-)src/org/eclipse/jface/viewers/ViewerRow.java (-1 / +1 lines)
71	/**	71	/**
72	* Return the number of columns for the receiver.	72	* Return the number of columns for the receiver.
73	*	73	*
74	* @return int	74	* @return the number of columns
75	*/	75	*/
76	public abstract int getColumnCount();	76	public abstract int getColumnCount();
77		77

Lines 830-836 Link Here

(-)src/org/eclipse/jface/viewers/CellEditor.java (-1 / +1 lines)
830	* The default value is false.	830	* The default value is false.
831	* Subclasses should call this method on construction.	831	* Subclasses should call this method on construction.
832	*	832	*
833	* @param valid <code>true</code> if the current valie is valid,	833	* @param valid <code>true</code> if the current value is valid,
834	* and <code>false</code> if invalid	834	* and <code>false</code> if invalid
835	*	835	*
836	* @see #isValueValid	836	* @see #isValueValid

Lines 72-79 Link Here

(-)src/org/eclipse/jface/viewers/TableTreeViewer.java (-2 / +2 lines)
72	private TableTreeEditor tableTreeEditor;	72	private TableTreeEditor tableTreeEditor;
73		73
74	/**	74	/**
75	* Copied from originial TableEditorImpl and moved here since refactoring	75	* Copied from original TableEditorImpl and moved here since refactoring
76	* completly wiped out the original impl in 3.3	76	* completely wiped out the original implementation in 3.3
77	*	77	*
78	* @since 3.1	78	* @since 3.1
79	*/	79	*/

Lines 345-351 Link Here

(-)src/org/eclipse/jface/viewers/DialogCellEditor.java (-2 / +2 lines)
345	/**	345	/**
346	* Opens a dialog box under the given parent control and returns the	346	* Opens a dialog box under the given parent control and returns the
347	* dialog's value when it closes, or <code>null</code> if the dialog	347	* dialog's value when it closes, or <code>null</code> if the dialog
348	* was cancelled or no selection was made in the dialog.	348	* was canceled or no selection was made in the dialog.
349	* <p>	349	* <p>
350	* This framework method must be implemented by concrete subclasses.	350	* This framework method must be implemented by concrete subclasses.
351	* It is called when the user has pressed the button and the dialog	351	* It is called when the user has pressed the button and the dialog
Lines 355-361 Link Here
355	* @param cellEditorWindow the parent control cell editor's window	355	* @param cellEditorWindow the parent control cell editor's window
356	* so that a subclass can adjust the dialog box accordingly	356	* so that a subclass can adjust the dialog box accordingly
357	* @return the selected value, or <code>null</code> if the dialog was	357	* @return the selected value, or <code>null</code> if the dialog was
358	* cancelled or no selection was made in the dialog	358	* canceled or no selection was made in the dialog
359	*/	359	*/
360	protected abstract Object openDialogBox(Control cellEditorWindow);	360	protected abstract Object openDialogBox(Control cellEditorWindow);
361		361

Lines 229-235 Link Here

(-)src/org/eclipse/jface/viewers/ViewerDropAdapter.java (-1 / +1 lines)
229	public void drop(DropTargetEvent event) {	229	public void drop(DropTargetEvent event) {
230	currentLocation = determineLocation(event);	230	currentLocation = determineLocation(event);
231		231
232	//perform the drop behaviour	232	//perform the drop behavior
233	if (!performDrop(event.data)) {	233	if (!performDrop(event.data)) {
234	event.detail = DND.DROP_NONE;	234	event.detail = DND.DROP_NONE;
235	}	235	}




	private Table table;
	
	/**
	 * The cached row which is reused all over
	 */
	private TableViewerRow cachedRow;


	/**
	 * <p>
	 * Sets a new selection for this viewer and optionally makes it visible. The
	 * TableViewer implementation of this method is inefficient for the
	 * ILazyContentProvider as lookup is done by indices rather than elements
	 * and may require population of the entire table in worse case.
	 * </p>
	 * <p>
	 * Use Table#setSelection(int[] indices) and Table#showSelection() if you
	 * wish to set selection more efficiently when using a ILazyContentProvider.
	 * </p>
	 * 
	 * @param selection

Lines 105-111 Link Here

(-)src/org/eclipse/jface/viewers/OwnerDrawLabelProvider.java (-1 / +1 lines)
105	}	105	}
106		106
107	/**	107	/**
108	* Handle the erase event. The default implementation colours the background of selected areas with	108	* Handle the erase event. The default implementation colors the background of selected areas with
109	* {@link SWT#COLOR_LIST_SELECTION} and foregrounds with {@link SWT#COLOR_LIST_SELECTION_TEXT}	109	* {@link SWT#COLOR_LIST_SELECTION} and foregrounds with {@link SWT#COLOR_LIST_SELECTION_TEXT}
110	*	110	*
111	* @param event	111	* @param event

Lines 21-27 Link Here

(-)src/org/eclipse/jface/viewers/IFilter.java (-1 / +1 lines)
21	*	21	*
22	* @param toTest object to compare against the filter	22	* @param toTest object to compare against the filter
23	*	23	*
24	* @return true iff the object is accepted by the filter.	24	* @return <code>true</code> if the object is accepted by the filter.
25	*/	25	*/
26	public boolean select(Object toTest);	26	public boolean select(Object toTest);
27	}	27	}

Lines 149-155 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewerEditorActivationEvent.java (-1 / +1 lines)
149	}	149	}
150		150
151	/**	151	/**
152	* This constructur is used to mark the activation triggered by a traversal	152	* This constructor is used to mark the activation triggered by a traversal
153	*	153	*
154	* @param cell	154	* @param cell
155	* the cell source of the event	155	* the cell source of the event




	/**
	 * Returns the tooltipText.
	 * 
	 * @return {@link String} or <code>null</code> if the tool tip text was
	 *         never set.
	 * 
	 * @since 3.3

	}

	/**
	 * Set the tool tip text.
	 * 
	 * @param tooltipText
	 *            The tooltipText {@link String} to set. This value should not

	}

	/**
	 * Return whether or not the tool tip text has been set.
	 * 
	 * @return <code>boolean</code>. <code>true</code> if the tool tip text
	 *         has been set.
	 * 
	 * @since 3.3

	}

	/**
	 * Return the tool tip background color.
	 * 
	 * @return {@link Color} or <code>null</code> if the tool tip background
	 *         color has not been set.
	 * 
	 * @since 3.3

	}

	/**
	 * Set the background {@link Color} for tool tip.
	 * 
	 * @param tooltipBackgroundColor
	 *            The {@link Color} to set. This value should not be

	}

	/**
	 * Return whether or not the tool tip background color has been set.
	 * 
	 * @return <code>boolean</code>. <code>true</code> if the tool tip text
	 *         has been set.
	 * 
	 * @since 3.3

	/**
	 * Return the foreground {@link Color}.
	 * 
	 * @return Returns {@link Color} or <code>null</code> if the tool tip
	 *         foreground color has not been set.
	 * 
	 * @since 3.3

	}

	/**
	 * Set the foreground {@link Color} for tool tip.
	 * 
	 * @param tooltipForegroundColor
	 *            The tooltipForegroundColor to set.


	/**
	 * 
	 * Return whether or not the tool tip foreground color has been set.
	 * 
	 * @return <code>boolean</code>. <code>true</code> if the tool tip foreground
	 *         has been set.
	 * 
	 * @since 3.3

	}

	/**
	 * @return Return whether or not the tool tip shift has been set.
	 */
	public boolean hasTooltipShift() {
		return this.tooltipShift != null;





		/**
		 * Create a new instance of the receiver with
		 * no color and font provider.	
		 */
		public ColorAndFontCollector(){
			super();

	 * Specifying which properties are affected may allow the viewer to optimize
	 * the update. For example, if the label provider is not affected by changes
	 * to any of these properties, an update may not actually be required.
	 * Specifying <code>properties</code> as <code>null</code> forces a full
	 * update of the given elements.
	 * </p>
	 * <p>

	 * Specifying which properties are affected may allow the viewer to optimize
	 * the update. For example, if the label provider is not affected by changes
	 * to any of these properties, an update may not actually be required.
	 * Specifying <code>properties</code> as <code>null</code> forces a full
	 * update of the element.
	 * </p>
	 * <p>

     * This method was added to support JDT's explorations
     * into grouping by working sets, which requires viewers to support multiple 
     * equal elements.  See bug 76482 for more details.  This support will
     * likely be removed in Eclipse 3.3 in favor of proper support for
     * multiple equal elements (which was implemented for AbtractTreeViewer in 3.2). 
     * </p>
     * @param widget

Return to bug 182110

Lines 193-199 Link Here

(-)src/org/eclipse/jface/viewers/AbstractTreeViewer.java (-13 / +13 lines)
193	* EXPERIMENTAL. Not to be used except by JDT. This method was added to	193	* EXPERIMENTAL. Not to be used except by JDT. This method was added to
194	* support JDT's explorations into grouping by working sets, which requires	194	* support JDT's explorations into grouping by working sets, which requires
195	* viewers to support multiple equal elements. See bug 76482 for more	195	* viewers to support multiple equal elements. See bug 76482 for more
196	* details. This support will likely be removed in Eclipse 3.2 in favour of	196	* details. This support will likely be removed in Eclipse 3.2 in favor of
197	* proper support for multiple equal elements.	197	* proper support for multiple equal elements.
198	* </p>	198	* </p>
199	*	199	*
Lines 414-421 Link Here
414	* The comparator to use.	414	* The comparator to use.
415	* @param lastInsertion	415	* @param lastInsertion
416	* the start index to start search for position from this allows	416	* the start index to start search for position from this allows
417	* optimising search for multiple elements that are sorted	417	* optimizing search for multiple elements that are sorted
418	* themself.	418	* themselves.
419	* @param element	419	* @param element
420	* element to find position for.	420	* element to find position for.
421	* @param parentPath	421	* @param parentPath
Lines 463-470 Link Here
463	* The sorter to use.	463	* The sorter to use.
464	* @param startIndex	464	* @param startIndex
465	* the start index to start search for position from this allows	465	* the start index to start search for position from this allows
466	* optimising search for multiple elements that are sorted	466	* optimizing search for multiple elements that are sorted
467	* themself.	467	* themselves.
468	* @param element	468	* @param element
469	* element to find position for.	469	* element to find position for.
470	* @param currentSize	470	* @param currentSize
Lines 559-565 Link Here
559	* @param e1	559	* @param e1
560	* the first element	560	* the first element
561	* @param e2	561	* @param e2
562	* the seocnd element	562	* the second element
563	* @return the result of comparing the two elements	563	* @return the result of comparing the two elements
564	*/	564	*/
565	private int internalCompare(ViewerComparator comparator,	565	private int internalCompare(ViewerComparator comparator,
Lines 1064-1070 Link Here
1064		1064
1065	/**	1065	/**
1066	* Get the child for the widget at index. Note that the default	1066	* Get the child for the widget at index. Note that the default
1067	* implementation is not very effecient and should be overridden if this	1067	* implementation is not very efficient and should be overridden if this
1068	* class is implemented.	1068	* class is implemented.
1069	*	1069	*
1070	* @param widget	1070	* @param widget
Lines 1728-1734 Link Here
1728	* EXPERIMENTAL. Not to be used except by JDT. This method was added to	1728	* EXPERIMENTAL. Not to be used except by JDT. This method was added to
1729	* support JDT's explorations into grouping by working sets, which requires	1729	* support JDT's explorations into grouping by working sets, which requires
1730	* viewers to support multiple equal elements. See bug 76482 for more	1730	* viewers to support multiple equal elements. See bug 76482 for more
1731	* details. This support will likely be removed in Eclipse 3.2 in favour of	1731	* details. This support will likely be removed in Eclipse 3.2 in favor of
1732	* proper support for multiple equal elements.	1732	* proper support for multiple equal elements.
1733	* </p>	1733	* </p>
1734	*	1734	*
Lines 1805-1811 Link Here
1805	* EXPERIMENTAL. Not to be used except by JDT. This method was added to	1805	* EXPERIMENTAL. Not to be used except by JDT. This method was added to
1806	* support JDT's explorations into grouping by working sets, which requires	1806	* support JDT's explorations into grouping by working sets, which requires
1807	* viewers to support multiple equal elements. See bug 76482 for more	1807	* viewers to support multiple equal elements. See bug 76482 for more
1808	* details. This support will likely be removed in Eclipse 3.2 in favour of	1808	* details. This support will likely be removed in Eclipse 3.2 in favor of
1809	* proper support for multiple equal elements.	1809	* proper support for multiple equal elements.
1810	* </p>	1810	* </p>
1811	*	1811	*
Lines 1937-1943 Link Here
1937		1937
1938	/**	1938	/**
1939	* Return whether the tree node representing the given element or path can	1939	* Return whether the tree node representing the given element or path can
1940	* be expanded. Clients should query expandablity by path if the viewer's	1940	* be expanded. Clients should query expandability by path if the viewer's
1941	* content provider is an {@link ITreePathContentProvider}.	1941	* content provider is an {@link ITreePathContentProvider}.
1942	* <p>	1942	* <p>
1943	* The default implementation of this framework method calls	1943	* The default implementation of this framework method calls
Lines 1989-1995 Link Here
1989	* @param item	1989	* @param item
1990	* the tree item for the element	1990	* the tree item for the element
1991	* @param parentPath	1991	* @param parentPath
1992	* the parent path if it is knwon or <code>null</code> if it	1992	* the parent path if it is known or <code>null</code> if it
1993	* needs to be determines	1993	* needs to be determines
1994	* @param element	1994	* @param element
1995	* the element	1995	* the element
Lines 2139-2145 Link Here
2139	*	2139	*
2140	* @param item	2140	* @param item
2141	* the item to compute the descendent of	2141	* the item to compute the descendent of
2142	* @return the rightmost visible descendent or the item iself if it has no	2142	* @return the rightmost visible descendent or the item itself if it has no
2143	* children	2143	* children
2144	*/	2144	*/
2145	private Item rightMostVisibleDescendent(Item item) {	2145	private Item rightMostVisibleDescendent(Item item) {
Lines 2862-2868 Link Here
2862	/**	2862	/**
2863	* Returns the number of columns of this viewer.	2863	* Returns the number of columns of this viewer.
2864	* <p><b>Subclasses should overwrite this method, which has a default	2864	* <p><b>Subclasses should overwrite this method, which has a default
2865	* implementation (returning 0) for API backwards compatility reasons</b></p>	2865	* implementation (returning 0) for API backwards compatibility reasons</b></p>
2866	*	2866	*
2867	* @return the number of columns	2867	* @return the number of columns
2868	*	2868	*

Lines 141-148 Link Here

(-)src/org/eclipse/jface/viewers/CheckboxTreeViewer.java (-5 / +5 lines)
141	* Gathers the checked and grayed states of the given widget and its	141	* Gathers the checked and grayed states of the given widget and its
142	* descendents.	142	* descendents.
143	*	143	*
144	* @param checked a writeable set of elements (element type: <code>Object</code>)	144	* @param checked a writable set of elements (element type: <code>Object</code>)
145	* @param grayed a writeable set of elements (element type: <code>Object</code>)	145	* @param grayed a writable set of elements (element type: <code>Object</code>)
146	* @param widget the widget	146	* @param widget the widget
147	*/	147	*/
148	private void gatherState(CustomHashtable checked, CustomHashtable grayed,	148	private void gatherState(CustomHashtable checked, CustomHashtable grayed,
Lines 276-282 Link Here
276	* Gathers the checked states of the given widget and its	276	* Gathers the checked states of the given widget and its
277	* descendents, following a pre-order traversal of the tree.	277	* descendents, following a pre-order traversal of the tree.
278	*	278	*
279	* @param result a writeable list of elements (element type: <code>Object</code>)	279	* @param result a writable list of elements (element type: <code>Object</code>)
280	* @param widget the widget	280	* @param widget the widget
281	*/	281	*/
282	private void internalCollectChecked(List result, Widget widget) {	282	private void internalCollectChecked(List result, Widget widget) {
Lines 297-303 Link Here
297	* Gathers the grayed states of the given widget and its	297	* Gathers the grayed states of the given widget and its
298	* descendents, following a pre-order traversal of the tree.	298	* descendents, following a pre-order traversal of the tree.
299	*	299	*
300	* @param result a writeable list of elements (element type: <code>Object</code>)	300	* @param result a writable list of elements (element type: <code>Object</code>)
301	* @param widget the widget	301	* @param widget the widget
302	*/	302	*/
303	private void internalCollectGrayed(List result, Widget widget) {	303	private void internalCollectGrayed(List result, Widget widget) {
Lines 577-583 Link Here
577	}	577	}
578		578
579	/**	579	/**
580	* Set the checked state of items and thier children to state.	580	* Set the checked state of items and their children to state.
581	* @param state	581	* @param state
582	* @param items	582	* @param items
583	*/	583	*/

Lines 99-105 Link Here

(-)src/org/eclipse/jface/viewers/TextCellEditor.java (-3 / +3 lines)
99	}	99	}
100		100
101	/**	101	/**
102	* Checks to see if the "deleteable" state (can delete/	102	* Checks to see if the "deletable" state (can delete/
103	* nothing to delete) has changed and if so fire an	103	* nothing to delete) has changed and if so fire an
104	* enablement changed notification.	104	* enablement changed notification.
105	*/	105	*/
Lines 157-163 Link Here
157	if ((getControl() == null) \|\| getControl().isDisposed()) {	157	if ((getControl() == null) \|\| getControl().isDisposed()) {
158	return;	158	return;
159	}	159	}
160	checkSelection(); // see explaination below	160	checkSelection(); // see explanation below
161	checkDeleteable();	161	checkDeleteable();
162	checkSelectable();	162	checkSelectable();
163	}	163	}
Lines 172-178 Link Here
172	});	172	});
173	// We really want a selection listener but it is not supported so we	173	// We really want a selection listener but it is not supported so we
174	// use a key listener and a mouse listener to know when selection changes	174	// use a key listener and a mouse listener to know when selection changes
175	// may have occured	175	// may have occurred
176	text.addMouseListener(new MouseAdapter() {	176	text.addMouseListener(new MouseAdapter() {
177	public void mouseUp(MouseEvent e) {	177	public void mouseUp(MouseEvent e) {
178	checkSelection();	178	checkSelection();

Lines 279-285 Link Here

(-)src/org/eclipse/jface/viewers/ViewerLabel.java (-14 / +14 lines)
279	/**	279	/**
280	* Returns the tooltipText.	280	* Returns the tooltipText.
281	*	281	*
282	* @return {@link String} or <code>null</code> if the tooltip text was	282	* @return {@link String} or <code>null</code> if the tool tip text was
283	* never set.	283	* never set.
284	*	284	*
285	* @since 3.3	285	* @since 3.3
Lines 289-295 Link Here
289	}	289	}
290		290
291	/**	291	/**
292	* Set the tooltip text.	292	* Set the tool tip text.
293	*	293	*
294	* @param tooltipText	294	* @param tooltipText
295	* The tooltipText {@link String} to set. This value should not	295	* The tooltipText {@link String} to set. This value should not
Lines 302-310 Link Here
302	}	302	}
303		303
304	/**	304	/**
305	* Return whether or not the tooltip text has been set.	305	* Return whether or not the tool tip text has been set.
306	*	306	*
307	* @return <code>boolean</code>. <code>true</code> if the tooltip text	307	* @return <code>boolean</code>. <code>true</code> if the tool tip text
308	* has been set.	308	* has been set.
309	*	309	*
310	* @since 3.3	310	* @since 3.3
Lines 314-322 Link Here
314	}	314	}
315		315
316	/**	316	/**
317	* Return the tooltip background color.	317	* Return the tool tip background color.
318	*	318	*
319	* @return {@link Color} or <code>null</code> if the tooltip background	319	* @return {@link Color} or <code>null</code> if the tool tip background
320	* color has not been set.	320	* color has not been set.
321	*	321	*
322	* @since 3.3	322	* @since 3.3
Lines 326-332 Link Here
326	}	326	}
327		327
328	/**	328	/**
329	* Set the background {@link Color} for tooltip.	329	* Set the background {@link Color} for tool tip.
330	*	330	*
331	* @param tooltipBackgroundColor	331	* @param tooltipBackgroundColor
332	* The {@link Color} to set. This value should not be	332	* The {@link Color} to set. This value should not be
Lines 339-347 Link Here
339	}	339	}
340		340
341	/**	341	/**
342	* Return whether or not the tooltip background color has been set.	342	* Return whether or not the tool tip background color has been set.
343	*	343	*
344	* @return <code>boolean</code>. <code>true</code> if the tooltip text	344	* @return <code>boolean</code>. <code>true</code> if the tool tip text
345	* has been set.	345	* has been set.
346	*	346	*
347	* @since 3.3	347	* @since 3.3
Lines 353-359 Link Here
353	/**	353	/**
354	* Return the foreground {@link Color}.	354	* Return the foreground {@link Color}.
355	*	355	*
356	* @return Returns {@link Color} or <code>null</code> if the tooltip	356	* @return Returns {@link Color} or <code>null</code> if the tool tip
357	* foreground color has not been set.	357	* foreground color has not been set.
358	*	358	*
359	* @since 3.3	359	* @since 3.3
Lines 363-369 Link Here
363	}	363	}
364		364
365	/**	365	/**
366	* Set the foreground {@link Color} for tooltip.	366	* Set the foreground {@link Color} for tool tip.
367	*	367	*
368	* @param tooltipForegroundColor	368	* @param tooltipForegroundColor
369	* The tooltipForegroundColor to set.	369	* The tooltipForegroundColor to set.
Lines 376-384 Link Here
376		376
377	/**	377	/**
378	*	378	*
379	* Return whether or not the tooltip foreground color has been set.	379	* Return whether or not the tool tip foreground color has been set.
380	*	380	*
381	* @return <code>boolean</code>. <code>true</code> if the tooltip foreground	381	* @return <code>boolean</code>. <code>true</code> if the tool tip foreground
382	* has been set.	382	* has been set.
383	*	383	*
384	* @since 3.3	384	* @since 3.3
Lines 403-409 Link Here
403	}	403	}
404		404
405	/**	405	/**
406	* @return Return whether or not the tooltip shift has been set.	406	* @return Return whether or not the tool tip shift has been set.
407	*/	407	*/
408	public boolean hasTooltipShift() {	408	public boolean hasTooltipShift() {
409	return this.tooltipShift != null;	409	return this.tooltipShift != null;

Lines 317-323 Link Here

(-)src/org/eclipse/jface/viewers/StructuredViewer.java (-4 / +4 lines)
317		317
318	/**	318	/**
319	* Create a new instance of the receiver with	319	* Create a new instance of the receiver with
320	* no colour and font provider.	320	* no color and font provider.
321	*/	321	*/
322	public ColorAndFontCollector(){	322	public ColorAndFontCollector(){
323	super();	323	super();
Lines 1897-1903 Link Here
1897	* Specifying which properties are affected may allow the viewer to optimize	1897	* Specifying which properties are affected may allow the viewer to optimize
1898	* the update. For example, if the label provider is not affected by changes	1898	* the update. For example, if the label provider is not affected by changes
1899	* to any of these properties, an update may not actually be required.	1899	* to any of these properties, an update may not actually be required.
1900	* Specifing <code>properties</code> as <code>null</code> forces a full	1900	* Specifying <code>properties</code> as <code>null</code> forces a full
1901	* update of the given elements.	1901	* update of the given elements.
1902	* </p>	1902	* </p>
1903	* <p>	1903	* <p>
Lines 1941-1947 Link Here
1941	* Specifying which properties are affected may allow the viewer to optimize	1941	* Specifying which properties are affected may allow the viewer to optimize
1942	* the update. For example, if the label provider is not affected by changes	1942	* the update. For example, if the label provider is not affected by changes
1943	* to any of these properties, an update may not actually be required.	1943	* to any of these properties, an update may not actually be required.
1944	* Specifing <code>properties</code> as <code>null</code> forces a full	1944	* Specifying <code>properties</code> as <code>null</code> forces a full
1945	* update of the element.	1945	* update of the element.
1946	* </p>	1946	* </p>
1947	* <p>	1947	* <p>
Lines 1977-1983 Link Here
1977	* This method was added to support JDT's explorations	1977	* This method was added to support JDT's explorations
1978	* into grouping by working sets, which requires viewers to support multiple	1978	* into grouping by working sets, which requires viewers to support multiple
1979	* equal elements. See bug 76482 for more details. This support will	1979	* equal elements. See bug 76482 for more details. This support will
1980	* likely be removed in Eclipse 3.3 in favour of proper support for	1980	* likely be removed in Eclipse 3.3 in favor of proper support for
1981	* multiple equal elements (which was implemented for AbtractTreeViewer in 3.2).	1981	* multiple equal elements (which was implemented for AbtractTreeViewer in 3.2).
1982	* </p>	1982	* </p>
1983	* @param widget	1983	* @param widget

Lines 26-33 Link Here

(-)src/org/eclipse/jface/viewers/CellLabelProvider.java (-29 / +37 lines)
26	*	26	*
27	* @since 3.3	27	* @since 3.3
28	*/	28	*/
29	public abstract class CellLabelProvider extends BaseLabelProvider {	29	public abstract class CellLabelProvider extends BaseLabelProvider {
30
31		30
32	/**	31	/**
33	* Create a new instance of the receiver.	32	* Create a new instance of the receiver.
Lines 43-49 Link Here
43	* The labelProvider to convert	42	* The labelProvider to convert
44	* @return ViewerLabelProvider	43	* @return ViewerLabelProvider
45	*/	44	*/
46	/* package */ static CellLabelProvider createViewerLabelProvider(	45	/* package */static CellLabelProvider createViewerLabelProvider(
47	IBaseLabelProvider labelProvider) {	46	IBaseLabelProvider labelProvider) {
48		47
49	if (labelProvider instanceof ITableLabelProvider	48	if (labelProvider instanceof ITableLabelProvider
Lines 56-67 Link Here
56		55
57	}	56	}
58		57
59
60	/**	58	/**
61	* Get the image displayed in the tool tip for object.	59	* Get the image displayed in the tool tip for object.
62	*	60	*
63	* <p><b>if both methods {@link #getToolTipText(Object)} and {@link #getToolTipImage(Object)}	61	* <p>
64	* both return <code>null</code> the control is set back to standard behaviour</b></p>	62	* <b>If {@link #getToolTipText(Object)} and
		63	* {@link #getToolTipImage(Object)} both return <code>null</code> the
		64	* control is set back to standard behavior</b>
		65	* </p>
65	*	66	*
66	* @param object	67	* @param object
67	* the element for which the tool tip is shown	68	* the element for which the tool tip is shown
Lines 73-88 Link Here
73	}	74	}
74		75
75	/**	76	/**
76	* Returns the tool tip text for the given element and column index, or	77	* Get the text displayed in the tool tip for object.
77	* <code>null</code> if a custom tool tip should not be displayed.
78	*	78	*
79	* <p><b>if both methods {@link #getToolTipText(Object)} and {@link #getToolTipImage(Object)}	79	* <p>
80	* both return <code>null</code> the control is set back to standard behaviour</b></p>	80	* <b>If {@link #getToolTipText(Object)} and
		81	* {@link #getToolTipImage(Object)} both return <code>null</code> the
		82	* control is set back to standard behavior</b>
		83	* </p>
81	*	84	*
82	* @param element	85	* @param element
83	* the element for which the tool tip is shown	86	* the element for which the tool tip is shown
84	* @return the {@link String} to be displayed in the tool tip, or	87	* @return the {@link String} or <code>null</code> if there is not text to
85	* <code>null</code> if a custom tool tip should not be displayed	88	* display
86	*/	89	*/
87	public String getToolTipText(Object element) {	90	public String getToolTipText(Object element) {
88	return null;	91	return null;
Lines 95-101 Link Here
95	* the {@link Object} for which the tool tip is shown	98	* the {@link Object} for which the tool tip is shown
96	*	99	*
97	* @return the {@link Color} used or <code>null</code> if you want to use	100	* @return the {@link Color} used or <code>null</code> if you want to use
98	* the	101	* the default color {@link SWT#COLOR_INFO_BACKGROUND}
		102	* @see SWT#COLOR_INFO_BACKGROUND
99	*/	103	*/
100	public Color getToolTipBackgroundColor(Object object) {	104	public Color getToolTipBackgroundColor(Object object) {
101	return null;	105	return null;
Lines 135-141 Link Here
135	*	139	*
136	* @param object	140	* @param object
137	* the element for which the tool tip is shown	141	* the element for which the tool tip is shown
138	* @return {@link Point} shift of the tool tip or <code>null</code> if the	142	* @return {@link Point} to shift of the tool tip or <code>null</code> if the
139	* default shift should be used.	143	* default shift should be used.
140	*/	144	*/
141	public Point getToolTipShift(Object object) {	145	public Point getToolTipShift(Object object) {
Lines 143-156 Link Here
143	}	147	}
144		148
145	/**	149	/**
146	* Return whether or not to use the native tool tip. If you switch to native tool tips	150	* Return whether or not to use the native tool tip. If you switch to native
147	* only the value from {@link #getToolTipText(Object)} is used all other features from	151	* tool tips only the value from {@link #getToolTipText(Object)} is used all
148	* custom tooltips are not supported.	152	* other features from custom tool tips are not supported.
149	*	153	*
150	* <p>To reset the control to native behaviour you should return <code>true</code> from this method	154	* <p>
151	* and <code>null</code> from {@link #getToolTipText(Object)} or <code>null</code>	155	* To reset the control to native behavior you should return
152	* from {@link #getToolTipText(Object)} and {@link #getToolTipImage(Object)}	156	* <code>true</code> from this method and <code>null</code> from
153	* at the same time</p>	157	* {@link #getToolTipText(Object)} or <code>null</code> from
		158	* {@link #getToolTipText(Object)} and {@link #getToolTipImage(Object)} at
		159	* the same time
		160	* </p>
154	*	161	*
155	* @param object	162	* @param object
156	* the {@link Object} for which the tool tip is shown	163	* the {@link Object} for which the tool tip is shown
Lines 165-194 Link Here
165	*	172	*
166	* @param object	173	* @param object
167	* the {@link Object} for which the tool tip is shown	174	* the {@link Object} for which the tool tip is shown
168	* @return <code>int<code>	175	* @return time in milliseconds the tool tip is shown for
169	*/	176	*/
170	public int getToolTipTimeDisplayed(Object object) {	177	public int getToolTipTimeDisplayed(Object object) {
171	return 0;	178	return 0;
172	}	179	}
173		180
174	/**	181	/**
175	* The time in milliseconds until the tool tip is displaued.	182	* The time in milliseconds until the tool tip is displayed.
176	*	183	*
177	* @param object	184	* @param object
178	* the {@link Object} for which the tool tip is shown	185	* the {@link Object} for which the tool tip is shown
179	* @return int	186	* @return time in milliseconds until the tool tip is displayed
180	*/	187	*/
181	public int getToolTipDisplayDelayTime(Object object) {	188	public int getToolTipDisplayDelayTime(Object object) {
182	return 0;	189	return 0;
183	}	190	}
184		191
185	/**	192	/**
186	* The {@link SWT} style used to create the {@link CLabel} (see there for supported styles).	193	* The {@link SWT} style used to create the {@link CLabel} (see there for
187	* By default {@link SWT#SHADOW_NONE} is used.	194	* supported styles). By default {@link SWT#SHADOW_NONE} is used.
188	*	195	*
189	* @param object	196	* @param object
190	* the element for which the tool tip is shown	197	* the element for which the tool tip is shown
191	* @return int	198	* @return the style used to create the label
192	* @see CLabel	199	* @see CLabel
193	*/	200	*/
194	public int getToolTipStyle(Object object) {	201	public int getToolTipStyle(Object object) {
Lines 198-204 Link Here
198	/**	205	/**
199	* Update the label for cell.	206	* Update the label for cell.
200	*	207	*
201	* @param cell {@link ViewerCell}	208	* @param cell
		209	* {@link ViewerCell}
202	*/	210	*/
203	public abstract void update(ViewerCell cell);	211	public abstract void update(ViewerCell cell);
204		212

Lines 23-29 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewerToolTipSupport.java (-3 / +3 lines)
23	import org.eclipse.swt.widgets.Event;	23	import org.eclipse.swt.widgets.Event;
24		24
25	/**	25	/**
26	* The ColumnViewerTooltipSupport is the class that provides tooltips for ColumnViewers.	26	* The ColumnViewerTooltipSupport is the class that provides tool tips for ColumnViewers.
27	*	27	*
28	* @since 3.3	28	* @since 3.3
29	*	29	*
Lines 47-53 Link Here
47	*	47	*
48	* @param viewer	48	* @param viewer
49	* the viewer the support is attached to	49	* the viewer the support is attached to
50	* @param style style passed to control tooltip behaviour	50	* @param style style passed to control tool tip behavior
51	*	51	*
52	* @param manualActivation	52	* @param manualActivation
53	* <code>true</code> if the activation is done manually using	53	* <code>true</code> if the activation is done manually using
Lines 77-83 Link Here
77	*	77	*
78	* @param viewer	78	* @param viewer
79	* the viewer the support is attached to	79	* the viewer the support is attached to
80	* @param style style passed to control tooltip behaviour	80	* @param style style passed to control tool tip behavior
81	*	81	*
82	* @see ToolTip#RECREATE	82	* @see ToolTip#RECREATE
83	* @see ToolTip#NO_RECREATE	83	* @see ToolTip#NO_RECREATE

Lines 75-81 Link Here

(-)src/org/eclipse/jface/viewers/CellNavigationStrategy.java (-5 / +5 lines)
75	* @param cellToExpand	75	* @param cellToExpand
76	* the cell the user wants to expand	76	* the cell the user wants to expand
77	* @param event	77	* @param event
78	* the event triggering the exansion	78	* the event triggering the expansion
79	*/	79	*/
80	public void expand(ColumnViewer viewer, ViewerCell cellToExpand, Event event) {	80	public void expand(ColumnViewer viewer, ViewerCell cellToExpand, Event event) {
81		81
Lines 87-93 Link Here
87	* @param cellToCollapse	87	* @param cellToCollapse
88	* the cell the user wants to collapse	88	* the cell the user wants to collapse
89	* @param event	89	* @param event
90	* the event triggering the exansion	90	* the event triggering the expansion
91	*/	91	*/
92	public void collapse(ColumnViewer viewer, ViewerCell cellToCollapse,	92	public void collapse(ColumnViewer viewer, ViewerCell cellToCollapse,
93	Event event) {	93	Event event) {
Lines 135-148 Link Here
135	}	135	}
136		136
137	/**	137	/**
138	* This method is consulted to decide whether an event has to be cancled or	138	* This method is consulted to decide whether an event has to be canceled or
139	* not. By default events who collapse/expand tree-nodes are cancled	139	* not. By default events who collapse/expand tree-nodes are canceled
140	*	140	*
141	* @param viewer	141	* @param viewer
142	* the viewer working for	142	* the viewer working for
143	* @param event	143	* @param event
144	* the event	144	* the event
145	* @return <code>true</code> if the event has to be cancled	145	* @return <code>true</code> if the event has to be canceled
146	*/	146	*/
147	public boolean shouldCancelEvent(ColumnViewer viewer, Event event) {	147	public boolean shouldCancelEvent(ColumnViewer viewer, Event event) {
148	return event.keyCode == SWT.ARROW_LEFT	148	return event.keyCode == SWT.ARROW_LEFT

Lines 60-66 Link Here

(-)src/org/eclipse/jface/viewers/ColumnViewerEditor.java (-6 / +6 lines)
60	private ColumnViewerEditorActivationStrategy editorActivationStrategy;	60	private ColumnViewerEditorActivationStrategy editorActivationStrategy;
61		61
62	/**	62	/**
63	* Tabing from cell to cell is turned off	63	* Tabbing from cell to cell is turned off
64	*/	64	*/
65	public static final int DEFAULT = 1;	65	public static final int DEFAULT = 1;
66		66
Lines 77-88 Link Here
77	public static final int TABBING_CYCLE_IN_ROW = 1 << 2;	77	public static final int TABBING_CYCLE_IN_ROW = 1 << 2;
78		78
79	/**	79	/**
80	* Support tabing to Cell above/below the current cell	80	* Support tabbing to Cell above/below the current cell
81	*/	81	*/
82	public static final int TABBING_VERTICAL = 1 << 3;	82	public static final int TABBING_VERTICAL = 1 << 3;
83		83
84	/**	84	/**
85	* Should tabing from column to column with in one row be supported	85	* Should tabbing from column to column with in one row be supported
86	*/	86	*/
87	public static final int TABBING_HORIZONTAL = 1 << 4;	87	public static final int TABBING_HORIZONTAL = 1 << 4;
88		88
Lines 280-286 Link Here
280	}	280	}
281		281
282	/**	282	/**
283	* Cancle editing	283	* Cancel editing
284	*/	284	*/
285	void cancelEditing() {	285	void cancelEditing() {
286	if (cellEditor != null) {	286	if (cellEditor != null) {
Lines 404-410 Link Here
404	}	404	}
405		405
406	/**	406	/**
407	* Process the travers event and opens the next available editor depending	407	* Process the traverse event and opens the next available editor depending
408	* of the implemented strategy. The default implementation uses the style	408	* of the implemented strategy. The default implementation uses the style
409	* constants	409	* constants
410	* <ul>	410	* <ul>
Lines 424-430 Link Here
424	* @param row	424	* @param row
425	* the current row - may only be used for the duration of this method call	425	* the current row - may only be used for the duration of this method call
426	* @param event	426	* @param event
427	* the travers event	427	* the traverse event
428	*/	428	*/
429	protected void processTraverseEvent(int columnIndex, ViewerRow row,	429	protected void processTraverseEvent(int columnIndex, ViewerRow row,
430	TraverseEvent event) {	430	TraverseEvent event) {

Lines 65-71 Link Here

(-)src/org/eclipse/jface/viewers/TableViewer.java (-3 / +3 lines)
65	private Table table;	65	private Table table;
66		66
67	/**	67	/**
68	* The cached row which is resused all over	68	* The cached row which is reused all over
69	*/	69	*/
70	private TableViewerRow cachedRow;	70	private TableViewerRow cachedRow;
71		71
Lines 131-143 Link Here
131	/**	131	/**
132	* <p>	132	* <p>
133	* Sets a new selection for this viewer and optionally makes it visible. The	133	* Sets a new selection for this viewer and optionally makes it visible. The
134	* TableViewer implmentation of this method is ineffecient for the	134	* TableViewer implementation of this method is inefficient for the
135	* ILazyContentProvider as lookup is done by indices rather than elements	135	* ILazyContentProvider as lookup is done by indices rather than elements
136	* and may require population of the entire table in worse case.	136	* and may require population of the entire table in worse case.
137	* </p>	137	* </p>
138	* <p>	138	* <p>
139	* Use Table#setSelection(int[] indices) and Table#showSelection() if you	139	* Use Table#setSelection(int[] indices) and Table#showSelection() if you
140	* wish to set selection more effeciently when using a ILazyContentProvider.	140	* wish to set selection more efficiently when using a ILazyContentProvider.
141	* </p>	141	* </p>
142	*	142	*
143	* @param selection	143	* @param selection