| /******************************************************************************* |
| * Copyright (c) 2000, 2004 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.swt.widgets; |
| |
| |
| import org.eclipse.swt.internal.win32.*; |
| import org.eclipse.swt.*; |
| import org.eclipse.swt.graphics.*; |
| |
| /** |
| * Instances of this class represent a selectable user interface object |
| * that represents a hierarchy of tree items in a tree widget. |
| * |
| * <dl> |
| * <dt><b>Styles:</b></dt> |
| * <dd>(none)</dd> |
| * <dt><b>Events:</b></dt> |
| * <dd>(none)</dd> |
| * </dl> |
| * <p> |
| * IMPORTANT: This class is <em>not</em> intended to be subclassed. |
| * </p> |
| */ |
| |
| public class TreeItem extends Item { |
| /** |
| * the handle to the OS resource |
| * (Warning: This field is platform dependent) |
| */ |
| public int handle; |
| |
| Tree parent; |
| int background, foreground; |
| int font; |
| |
| /** |
| * Constructs a new instance of this class given its parent |
| * (which must be a <code>Tree</code> or a <code>TreeItem</code>) |
| * and a style value describing its behavior and appearance. |
| * The item is added to the end of the items maintained by its parent. |
| * <p> |
| * The style value is either one of the style constants defined in |
| * class <code>SWT</code> which is applicable to instances of this |
| * class, or must be built by <em>bitwise OR</em>'ing together |
| * (that is, using the <code>int</code> "|" operator) two or more |
| * of those <code>SWT</code> style constants. The class description |
| * lists the style constants that are applicable to the class. |
| * Style bits are also inherited from superclasses. |
| * </p> |
| * |
| * @param parent a composite control which will be the parent of the new instance (cannot be null) |
| * @param style the style of control to construct |
| * |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_NULL_ARGUMENT - if the parent is null</li> |
| * </ul> |
| * @exception SWTException <ul> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> |
| * <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li> |
| * </ul> |
| * |
| * @see SWT |
| * @see Widget#checkSubclass |
| * @see Widget#getStyle |
| */ |
| public TreeItem (Tree parent, int style) { |
| super (parent, style); |
| this.parent = parent; |
| parent.createItem (this, 0, OS.TVI_LAST); |
| } |
| |
| /** |
| * Constructs a new instance of this class given its parent |
| * (which must be a <code>Tree</code> or a <code>TreeItem</code>), |
| * a style value describing its behavior and appearance, and the index |
| * at which to place it in the items maintained by its parent. |
| * <p> |
| * The style value is either one of the style constants defined in |
| * class <code>SWT</code> which is applicable to instances of this |
| * class, or must be built by <em>bitwise OR</em>'ing together |
| * (that is, using the <code>int</code> "|" operator) two or more |
| * of those <code>SWT</code> style constants. The class description |
| * lists the style constants that are applicable to the class. |
| * Style bits are also inherited from superclasses. |
| * </p> |
| * |
| * @param parent a composite control which will be the parent of the new instance (cannot be null) |
| * @param style the style of control to construct |
| * @param index the index to store the receiver in its parent |
| * |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_NULL_ARGUMENT - if the parent is null</li> |
| * </ul> |
| * @exception SWTException <ul> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> |
| * <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li> |
| * </ul> |
| * |
| * @see SWT |
| * @see Widget#checkSubclass |
| * @see Widget#getStyle |
| */ |
| public TreeItem (Tree parent, int style, int index) { |
| super (parent, style); |
| if (index < 0) error (SWT.ERROR_INVALID_RANGE); |
| this.parent = parent; |
| int hItem = OS.TVI_FIRST; |
| if (index != 0) { |
| int count = 1, hwnd = parent.handle; |
| hItem = OS.SendMessage (hwnd, OS.TVM_GETNEXTITEM, OS.TVGN_ROOT, 0); |
| while (hItem != 0 && count < index) { |
| hItem = OS.SendMessage (hwnd, OS.TVM_GETNEXTITEM, OS.TVGN_NEXT, hItem); |
| count++; |
| } |
| if (hItem == 0) error (SWT.ERROR_INVALID_RANGE); |
| } |
| parent.createItem (this, 0, hItem); |
| } |
| |
| /** |
| * Constructs a new instance of this class given its parent |
| * (which must be a <code>Tree</code> or a <code>TreeItem</code>) |
| * and a style value describing its behavior and appearance. |
| * The item is added to the end of the items maintained by its parent. |
| * <p> |
| * The style value is either one of the style constants defined in |
| * class <code>SWT</code> which is applicable to instances of this |
| * class, or must be built by <em>bitwise OR</em>'ing together |
| * (that is, using the <code>int</code> "|" operator) two or more |
| * of those <code>SWT</code> style constants. The class description |
| * lists the style constants that are applicable to the class. |
| * Style bits are also inherited from superclasses. |
| * </p> |
| * |
| * @param parentItem a composite control which will be the parent of the new instance (cannot be null) |
| * @param style the style of control to construct |
| * |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_NULL_ARGUMENT - if the parent is null</li> |
| * </ul> |
| * @exception SWTException <ul> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> |
| * <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li> |
| * </ul> |
| * |
| * @see SWT |
| * @see Widget#checkSubclass |
| * @see Widget#getStyle |
| */ |
| public TreeItem (TreeItem parentItem, int style) { |
| super (checkNull (parentItem).parent, style); |
| parent = parentItem.parent; |
| int hItem = parentItem.handle; |
| parent.createItem (this, hItem, OS.TVI_LAST); |
| } |
| |
| /** |
| * Constructs a new instance of this class given its parent |
| * (which must be a <code>Tree</code> or a <code>TreeItem</code>), |
| * a style value describing its behavior and appearance, and the index |
| * at which to place it in the items maintained by its parent. |
| * <p> |
| * The style value is either one of the style constants defined in |
| * class <code>SWT</code> which is applicable to instances of this |
| * class, or must be built by <em>bitwise OR</em>'ing together |
| * (that is, using the <code>int</code> "|" operator) two or more |
| * of those <code>SWT</code> style constants. The class description |
| * lists the style constants that are applicable to the class. |
| * Style bits are also inherited from superclasses. |
| * </p> |
| * |
| * @param parentItem a composite control which will be the parent of the new instance (cannot be null) |
| * @param style the style of control to construct |
| * @param index the index to store the receiver in its parent |
| * |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_NULL_ARGUMENT - if the parent is null</li> |
| * </ul> |
| * @exception SWTException <ul> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> |
| * <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li> |
| * </ul> |
| * |
| * @see SWT |
| * @see Widget#checkSubclass |
| * @see Widget#getStyle |
| */ |
| public TreeItem (TreeItem parentItem, int style, int index) { |
| super (checkNull (parentItem).parent, style); |
| if (index < 0) error (SWT.ERROR_INVALID_RANGE); |
| parent = parentItem.parent; |
| int hItem = OS.TVI_FIRST; |
| int hParent = parentItem.handle; |
| if (index != 0) { |
| int count = 1, hwnd = parent.handle; |
| hItem = OS.SendMessage (hwnd, OS.TVM_GETNEXTITEM, OS.TVGN_CHILD, hParent); |
| while (hItem != 0 && count < index) { |
| hItem = OS.SendMessage (hwnd, OS.TVM_GETNEXTITEM, OS.TVGN_NEXT, hItem); |
| count++; |
| } |
| if (hItem == 0) error (SWT.ERROR_INVALID_RANGE); |
| } |
| parent.createItem (this, hParent, hItem); |
| } |
| |
| static TreeItem checkNull (TreeItem item) { |
| if (item == null) SWT.error (SWT.ERROR_NULL_ARGUMENT); |
| return item; |
| } |
| |
| void _setText (String string) { |
| int hwnd = parent.handle; |
| int hHeap = OS.GetProcessHeap (); |
| TCHAR buffer = new TCHAR (parent.getCodePage (), string, true); |
| int byteCount = buffer.length () * TCHAR.sizeof; |
| int pszText = OS.HeapAlloc (hHeap, OS.HEAP_ZERO_MEMORY, byteCount); |
| OS.MoveMemory (pszText, buffer, byteCount); |
| TVITEM tvItem = new TVITEM (); |
| tvItem.mask = OS.TVIF_HANDLE | OS.TVIF_TEXT; |
| tvItem.hItem = handle; |
| tvItem.pszText = pszText; |
| OS.SendMessage (hwnd, OS.TVM_SETITEM, 0, tvItem); |
| OS.HeapFree (hHeap, 0, pszText); |
| } |
| |
| protected void checkSubclass () { |
| if (!isValidSubclass ()) error (SWT.ERROR_INVALID_SUBCLASS); |
| } |
| |
| /** |
| * Returns the receiver's background color. |
| * |
| * @return the background color |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| * |
| * @since 2.0 |
| * |
| */ |
| public Color getBackground () { |
| checkWidget (); |
| int pixel = (background == -1) ? parent.getBackgroundPixel() : background; |
| return Color.win32_new (display, pixel); |
| } |
| |
| /** |
| * Returns a rectangle describing the receiver's size and location |
| * relative to its parent. |
| * |
| * @return the receiver's bounding rectangle |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public Rectangle getBounds () { |
| checkWidget (); |
| int hwnd = parent.handle; |
| RECT rect = new RECT (); |
| rect.left = handle; |
| if (OS.SendMessage (hwnd, OS.TVM_GETITEMRECT, 1, rect) == 0) { |
| return new Rectangle (0, 0, 0, 0); |
| } |
| int width = rect.right - rect.left; |
| int height = rect.bottom - rect.top; |
| return new Rectangle (rect.left, rect.top, width, height); |
| } |
| |
| /** |
| * Returns <code>true</code> if the receiver is checked, |
| * and false otherwise. When the parent does not have |
| * the <code>CHECK style, return false. |
| * <p> |
| * |
| * @return the checked state |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public boolean getChecked () { |
| checkWidget (); |
| if ((parent.style & SWT.CHECK) == 0) return false; |
| int hwnd = parent.handle; |
| TVITEM tvItem = new TVITEM (); |
| tvItem.mask = OS.TVIF_HANDLE | OS.TVIF_STATE; |
| tvItem.stateMask = OS.TVIS_STATEIMAGEMASK; |
| tvItem.hItem = handle; |
| int result = OS.SendMessage (hwnd, OS.TVM_GETITEM, 0, tvItem); |
| return (result != 0) && (((tvItem.state >> 12) & 1) == 0); |
| } |
| |
| /** |
| * Returns <code>true</code> if the receiver is expanded, |
| * and false otherwise. |
| * <p> |
| * |
| * @return the expanded state |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public boolean getExpanded () { |
| checkWidget (); |
| int hwnd = parent.handle; |
| TVITEM tvItem = new TVITEM (); |
| tvItem.hItem = handle; |
| tvItem.mask = OS.TVIF_STATE; |
| OS.SendMessage (hwnd, OS.TVM_GETITEM, 0, tvItem); |
| return (tvItem.state & OS.TVIS_EXPANDED) != 0; |
| } |
| |
| /** |
| * Returns the font that the receiver will use to paint textual information for this item. |
| * |
| * @return the receiver's font |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| * |
| * @since 3.0 |
| */ |
| public Font getFont () { |
| checkWidget (); |
| return (font == -1) ? parent.getFont () : Font.win32_new (display, font); |
| } |
| |
| /** |
| * Returns the foreground color that the receiver will use to draw. |
| * |
| * @return the receiver's foreground color |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| * |
| * @since 2.0 |
| * |
| */ |
| public Color getForeground () { |
| checkWidget (); |
| int pixel = (foreground == -1) ? parent.getForegroundPixel() : foreground; |
| return Color.win32_new (display, pixel); |
| } |
| |
| /** |
| * Returns <code>true</code> if the receiver is grayed, |
| * and false otherwise. When the parent does not have |
| * the <code>CHECK style, return false. |
| * <p> |
| * |
| * @return the grayed state |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public boolean getGrayed () { |
| checkWidget (); |
| if ((parent.style & SWT.CHECK) == 0) return false; |
| int hwnd = parent.handle; |
| TVITEM tvItem = new TVITEM (); |
| tvItem.mask = OS.TVIF_HANDLE | OS.TVIF_STATE; |
| tvItem.stateMask = OS.TVIS_STATEIMAGEMASK; |
| tvItem.hItem = handle; |
| int result = OS.SendMessage (hwnd, OS.TVM_GETITEM, 0, tvItem); |
| return (result != 0) && ((tvItem.state >> 12) > 2); |
| } |
| |
| /** |
| * Returns the number of items contained in the receiver |
| * that are direct item children of the receiver. |
| * |
| * @return the number of items |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public int getItemCount () { |
| checkWidget (); |
| int hwnd = parent.handle; |
| int hItem = OS.SendMessage (hwnd, OS.TVM_GETNEXTITEM, OS.TVGN_CHILD, handle); |
| if (hItem == 0) return 0; |
| return parent.getItemCount (hItem); |
| } |
| |
| /** |
| * Returns an array of <code>TreeItem</code>s which are the |
| * direct item children of the receiver. |
| * <p> |
| * Note: This is not the actual structure used by the receiver |
| * to maintain its list of items, so modifying the array will |
| * not affect the receiver. |
| * </p> |
| * |
| * @return the receiver's items |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public TreeItem [] getItems () { |
| checkWidget (); |
| int hwnd = parent.handle; |
| int hItem = OS.SendMessage (hwnd, OS.TVM_GETNEXTITEM, OS.TVGN_CHILD, handle); |
| if (hItem == 0) return new TreeItem [0]; |
| return parent.getItems (hItem); |
| } |
| |
| /** |
| * Returns the receiver's parent, which must be a <code>Tree</code>. |
| * |
| * @return the receiver's parent |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public Tree getParent () { |
| checkWidget (); |
| return parent; |
| } |
| |
| /** |
| * Returns the receiver's parent item, which must be a |
| * <code>TreeItem</code> or null when the receiver is a |
| * root. |
| * |
| * @return the receiver's parent item |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public TreeItem getParentItem () { |
| checkWidget (); |
| int hwnd = parent.handle; |
| TVITEM tvItem = new TVITEM (); |
| tvItem.mask = OS.TVIF_HANDLE | OS.TVIF_PARAM; |
| tvItem.hItem = OS.SendMessage (hwnd, OS.TVM_GETNEXTITEM, OS.TVGN_PARENT, handle); |
| if (tvItem.hItem == 0) return null; |
| OS.SendMessage (hwnd, OS.TVM_GETITEM, 0, tvItem); |
| return parent.items [tvItem.lParam]; |
| } |
| |
| void redraw () { |
| if (parent.drawCount > 0) return; |
| int hwnd = parent.handle; |
| if (!OS.IsWindowVisible (hwnd)) return; |
| RECT rect = new RECT (); |
| rect.left = handle; |
| if (OS.SendMessage (hwnd, OS.TVM_GETITEMRECT, 1, rect) != 0) { |
| OS.InvalidateRect (hwnd, rect, true); |
| } |
| } |
| |
| void releaseChild () { |
| super.releaseChild (); |
| parent.destroyItem (this); |
| } |
| |
| void releaseHandle () { |
| super.releaseHandle (); |
| handle = 0; |
| } |
| |
| void releaseWidget () { |
| super.releaseWidget (); |
| parent = null; |
| } |
| |
| /** |
| * Sets the receiver's background color to the color specified |
| * by the argument, or to the default system color for the item |
| * if the argument is null. |
| * |
| * @param color the new color (or null) |
| * |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> |
| * </ul> |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| * |
| * @since 2.0 |
| * |
| */ |
| public void setBackground (Color color) { |
| checkWidget (); |
| if (color != null && color.isDisposed ()) { |
| SWT.error (SWT.ERROR_INVALID_ARGUMENT); |
| } |
| int pixel = -1; |
| if (color != null) { |
| parent.customDraw = true; |
| pixel = color.handle; |
| } |
| if (background == pixel) return; |
| background = pixel; |
| redraw (); |
| } |
| |
| /** |
| * Sets the checked state of the receiver. |
| * <p> |
| * |
| * @param checked the new checked state |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public void setChecked (boolean checked) { |
| checkWidget (); |
| if ((parent.style & SWT.CHECK) == 0) return; |
| int hwnd = parent.handle; |
| TVITEM tvItem = new TVITEM (); |
| tvItem.mask = OS.TVIF_HANDLE | OS.TVIF_STATE; |
| tvItem.stateMask = OS.TVIS_STATEIMAGEMASK; |
| tvItem.hItem = handle; |
| OS.SendMessage (hwnd, OS.TVM_GETITEM, 0, tvItem); |
| int state = tvItem.state >> 12; |
| if (checked) { |
| if ((state & 0x1) != 0) state++; |
| } else { |
| if ((state & 0x1) == 0) --state; |
| } |
| tvItem.state = state << 12; |
| OS.SendMessage (hwnd, OS.TVM_SETITEM, 0, tvItem); |
| } |
| |
| /** |
| * Sets the expanded state of the receiver. |
| * <p> |
| * |
| * @param expanded the new expanded state |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public void setExpanded (boolean expanded) { |
| checkWidget (); |
| /* |
| * Feature in Windows. When the user collapses the root |
| * of a subtree that has the focus item, Windows moves |
| * the selection to the root of the subtree and issues |
| * a TVN_SELCHANGED to inform the programmer that the |
| * seletion has changed. When the programmer collapses |
| * the same subtree using TVM_EXPAND, Windows does not |
| * send the selection changed notification. This is not |
| * strictly wrong but is inconsistent. The fix is to notice |
| * that the selection has changed and issue the event. |
| */ |
| int hwnd = parent.handle; |
| int hOldItem = OS.SendMessage (hwnd, OS.TVM_GETNEXTITEM, OS.TVGN_CARET, 0); |
| parent.ignoreExpand = true; |
| OS.SendMessage (hwnd, OS.TVM_EXPAND, expanded ? OS.TVE_EXPAND : OS.TVE_COLLAPSE, handle); |
| parent.ignoreExpand = false; |
| int hNewItem = OS.SendMessage (hwnd, OS.TVM_GETNEXTITEM, OS.TVGN_CARET, 0); |
| if (hNewItem != hOldItem) { |
| Event event = new Event (); |
| if (hNewItem != 0) { |
| TVITEM tvItem = new TVITEM (); |
| tvItem.mask = OS.TVIF_HANDLE | OS.TVIF_PARAM; |
| tvItem.hItem = hNewItem; |
| if (OS.SendMessage (hwnd, OS.TVM_GETITEM, 0, tvItem) != 0) { |
| event.item = parent.items [tvItem.lParam]; |
| } |
| parent.hAnchor = hNewItem; |
| } |
| parent.sendEvent (SWT.Selection, event); |
| } |
| } |
| |
| /** |
| * Sets the font that the receiver will use to paint textual information |
| * for this item to the font specified by the argument, or to the default font |
| * for that kind of control if the argument is null. |
| * |
| * @param font the new font (or null) |
| * |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> |
| * </ul> |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| * |
| * @since 3.0 |
| */ |
| public void setFont (Font font){ |
| checkWidget (); |
| if (font != null && font.isDisposed ()) { |
| SWT.error (SWT.ERROR_INVALID_ARGUMENT); |
| } |
| int hFont = -1; |
| if (font != null) { |
| parent.customDraw = true; |
| hFont = font.handle; |
| } |
| if (this.font == hFont) return; |
| this.font = hFont; |
| |
| /* |
| * Bug in Windows. When the font is changed for an item, |
| * the bounds for the item are not updated, causing the text |
| * to be clipped. The fix is to reset the text, causing |
| * Windows to compute the new bounds using the new font. |
| */ |
| _setText (text); |
| redraw (); |
| } |
| |
| /** |
| * Sets the receiver's foreground color to the color specified |
| * by the argument, or to the default system color for the item |
| * if the argument is null. |
| * |
| * @param color the new color (or null) |
| * |
| * @since 2.0 |
| * |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> |
| * </ul> |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| * |
| * @since 2.0 |
| * |
| */ |
| public void setForeground (Color color) { |
| checkWidget (); |
| if (color != null && color.isDisposed ()) { |
| SWT.error (SWT.ERROR_INVALID_ARGUMENT); |
| } |
| int pixel = -1; |
| if (color != null) { |
| parent.customDraw = true; |
| pixel = color.handle; |
| } |
| if (foreground == pixel) return; |
| foreground = pixel; |
| redraw (); |
| } |
| |
| /** |
| * Sets the grayed state of the receiver. |
| * <p> |
| * |
| * @param grayed the new grayed state |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> |
| * </ul> |
| */ |
| public void setGrayed (boolean grayed) { |
| checkWidget (); |
| if ((parent.style & SWT.CHECK) == 0) return; |
| int hwnd = parent.handle; |
| TVITEM tvItem = new TVITEM (); |
| tvItem.mask = OS.TVIF_HANDLE | OS.TVIF_STATE; |
| tvItem.stateMask = OS.TVIS_STATEIMAGEMASK; |
| tvItem.hItem = handle; |
| OS.SendMessage (hwnd, OS.TVM_GETITEM, 0, tvItem); |
| int state = tvItem.state >> 12; |
| if (grayed) { |
| if (state <= 2) state +=2; |
| } else { |
| if (state > 2) state -=2; |
| } |
| tvItem.state = state << 12; |
| OS.SendMessage (hwnd, OS.TVM_SETITEM, 0, tvItem); |
| } |
| |
| public void setImage (Image image) { |
| checkWidget (); |
| /* |
| * Feature in Windows. When TVM_SETITEM is used to set |
| * an image for an item, the item redraws. This happens |
| * because there is no easy way to know when a program |
| * has drawn on an image that is already in the control. |
| * However, an image that is an icon cannot be modified. |
| * The fix is to check for the same image when the image |
| * is an icon. |
| */ |
| if (image != null && image.type == SWT.ICON) { |
| if (image.equals (this.image)) return; |
| } |
| super.setImage (image); |
| int hwnd = parent.handle; |
| TVITEM tvItem = new TVITEM (); |
| tvItem.mask = OS.TVIF_HANDLE | OS.TVIF_IMAGE | OS.TVIF_SELECTEDIMAGE; |
| tvItem.iImage = parent.imageIndex (image); |
| tvItem.iSelectedImage = tvItem.iImage; |
| tvItem.hItem = handle; |
| OS.SendMessage (hwnd, OS.TVM_SETITEM, 0, tvItem); |
| } |
| |
| public void setText (String string) { |
| checkWidget (); |
| if (string == null) error (SWT.ERROR_NULL_ARGUMENT); |
| /* |
| * Feature in Windows. When TVM_SETITEM is used to set |
| * a string for an item that is equal to the string that |
| * is already there, the item redraws. The fix is to |
| * check for this case and do nothing. |
| */ |
| if (string.equals (text)) return; |
| super.setText (string); |
| _setText (string); |
| } |
| |
| } |