root/dwt/widgets/Combo.d

/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwt.widgets.Combo;

import dwt.widgets.Composite;

import dwt.DWT;
import dwt.DWTException;
import dwt.events.ModifyListener;
import dwt.events.SelectionEvent;
import dwt.events.SelectionListener;
import dwt.events.VerifyListener;
import dwt.graphics.Font;
import dwt.graphics.Point;
import dwt.internal.win32.OS;

import dwt.widgets.TypedListener;
import dwt.widgets.Event;
import dwt.widgets.Composite;
import dwt.widgets.Shell;
import dwt.widgets.Display;

import dwt.dwthelper.utils;

/**
 * Instances of this class are controls that allow the user
 * to choose an item from a list of items, or optionally
 * enter a new value by typing it into an editable text
 * field. Often, <code>Combo</code>s are used in the same place
 * where a single selection <code>List</code> widget could
 * be used but space is limited. A <code>Combo</code> takes
 * less space than a <code>List</code> widget and shows
 * similar information.
 * <p>
 * Note: Since <code>Combo</code>s can contain both a list
 * and an editable text field, it is possible to confuse methods
 * which access one versus the other (compare for example,
 * <code>clearSelection()</code> and <code>deselectAll()</code>).
 * The API documentation is careful to indicate either "the
 * receiver's list" or the "the receiver's text field" to
 * distinguish between the two cases.
 * </p><p>
 * Note that although this class is a subclass of <code>Composite</code>,
 * it does not make sense to add children to it, or set a layout on it.
 * </p>
 * <dl>
 * <dt><b>Styles:</b></dt>
 * <dd>DROP_DOWN, READ_ONLY, SIMPLE</dd>
 * <dt><b>Events:</b></dt>
 * <dd>DefaultSelection, Modify, Selection, Verify</dd>
 * </dl>
 * <p>
 * Note: Only one of the styles DROP_DOWN and SIMPLE may be specified.
 * </p><p>
 * IMPORTANT: This class is <em>not</em> intended to be subclassed.
 * </p>
 *
 * @see List
 * @see <a href="http://www.eclipse.org/swt/snippets/#combo">Combo snippets</a>
 * @see <a href="http://www.eclipse.org/swt/examples.php">DWT Example: ControlExample</a>
 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a>
 */

public class Combo : Composite {

    alias Composite.computeSize computeSize;
    alias Composite.dragDetect dragDetect;
    alias Composite.sendKeyEvent sendKeyEvent;
    alias Composite.setBackgroundImage setBackgroundImage;
    alias Composite.setBounds setBounds;
    alias Composite.setToolTipText setToolTipText;

    private static Combo pThis;
    bool noSelection, ignoreDefaultSelection, ignoreCharacter, ignoreModify, ignoreResize;
    HHOOK cbtHook;
    int scrollWidth, visibleCount = 5;

    /**
     * the operating system limit for the number of characters
     * that the text field in an instance of this class can hold
     */
    private static int LIMIT_ = 0;

    /*
     * These values can be different on different platforms.
     * Therefore they are not initialized in the declaration
     * to stop the compiler from inlining.
     */
    public static int LIMIT(){
        if( LIMIT_ is 0 ){
            synchronized {
                LIMIT_ = OS.IsWinNT ? 0x7FFFFFFF : 0x7FFF;
            }
        }
        return LIMIT_;
    }
    /*
     * These are the undocumented control id's for the children of
     * a combo box.  Since there are no constants for these values,
     * they may change with different versions of Windows (but have
     * been the same since Windows 3.0).
     */
    static const int CBID_LIST = 1000;
    static const int CBID_EDIT = 1001;
    static /*final*/ WNDPROC EditProc, ListProc;

    static /+const+/ WNDPROC ComboProc;
    static const TCHAR* ComboClass = "COMBOBOX\0";

    private static bool static_this_completed = false;
    private static void static_this() {
        if( static_this_completed ){
            return;
        }
        synchronized {
            if( static_this_completed ){
                return;
            }
            WNDCLASS lpWndClass;
            OS.GetClassInfo (null, ComboClass, &lpWndClass);
            ComboProc = lpWndClass.lpfnWndProc;
            static_this_completed = true;
        }
    }


/**
 * Constructs a new instance of this class given its parent
 * and a style value describing its behavior and appearance.
 * <p>
 * The style value is either one of the style constants defined in
 * class <code>DWT</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>DWT</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 DWTException <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 DWT#DROP_DOWN
 * @see DWT#READ_ONLY
 * @see DWT#SIMPLE
 * @see Widget#checkSubclass
 * @see Widget#getStyle
 */
public this (Composite parent, int style) {
    static_this();
    super (parent, checkStyle (style));
    /* This code is intentionally commented */
    //if ((style & DWT.H_SCROLL) !is 0) this.style |= DWT.H_SCROLL;
    this.style |= DWT.H_SCROLL;
}

/**
 * Adds the argument to the end of the receiver's list.
 *
 * @param string the new item
 *
 * @exception DWTException <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>
 *
 * @see #add(String,int)
 */
public void add (String string) {
    checkWidget ();
    // DWT extension: allow null string
    //if (string is null) error (DWT.ERROR_NULL_ARGUMENT);
    auto buffer = StrToTCHARs( getCodePage(), string, true );
    int result = OS.SendMessage (handle, OS.CB_ADDSTRING, 0, buffer.ptr );
    if (result is OS.CB_ERR) error (DWT.ERROR_ITEM_NOT_ADDED);
    if (result is OS.CB_ERRSPACE) error (DWT.ERROR_ITEM_NOT_ADDED);
    if ((style & DWT.H_SCROLL) !is 0) setScrollWidth (buffer, true);
}

/**
 * Adds the argument to the receiver's list at the given
 * zero-relative index.
 * <p>
 * Note: To add an item at the end of the list, use the
 * result of calling <code>getItemCount()</code> as the
 * index or use <code>add(String)</code>.
 * </p>
 *
 * @param string the new item
 * @param index the index for the item
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list (inclusive)</li>
 * </ul>
 * @exception DWTException <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>
 *
 * @see #add(String)
 */
public void add (String string, int index) {
    checkWidget ();
    // DWT extension: allow null string
    //if (string is null) error (DWT.ERROR_NULL_ARGUMENT);
    int count = OS.SendMessage (handle, OS.CB_GETCOUNT, 0, 0);
    if (!(0 <= index && index <= count)) {
        error (DWT.ERROR_INVALID_RANGE);
    }
    auto buffer = StrToTCHARs( getCodePage(), string, true );
    int result = OS.SendMessage (handle, OS.CB_INSERTSTRING, index, buffer.ptr);
    if (result is OS.CB_ERRSPACE || result is OS.CB_ERR) {
        error (DWT.ERROR_ITEM_NOT_ADDED);
    }
    if ((style & DWT.H_SCROLL) !is 0) setScrollWidth (buffer, true);
}

/**
 * Adds the listener to the collection of listeners who will
 * be notified when the receiver's text is modified, by sending
 * it one of the messages defined in the <code>ModifyListener</code>
 * interface.
 *
 * @param listener the listener which should be notified
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
 * </ul>
 * @exception DWTException <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>
 *
 * @see ModifyListener
 * @see #removeModifyListener
 */
public void addModifyListener (ModifyListener listener) {
    checkWidget ();
    if (listener is null) error (DWT.ERROR_NULL_ARGUMENT);
    TypedListener typedListener = new TypedListener (listener);
    addListener (DWT.Modify, typedListener);
}

/**
 * Adds the listener to the collection of listeners who will
 * be notified when the user changes the receiver's selection, by sending
 * it one of the messages defined in the <code>SelectionListener</code>
 * interface.
 * <p>
 * <code>widgetSelected</code> is called when the user changes the combo's list selection.
 * <code>widgetDefaultSelected</code> is typically called when ENTER is pressed the combo's text area.
 * </p>
 *
 * @param listener the listener which should be notified
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
 * </ul>
 * @exception DWTException <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>
 *
 * @see SelectionListener
 * @see #removeSelectionListener
 * @see SelectionEvent
 */
public void addSelectionListener(SelectionListener listener) {
    checkWidget ();
    if (listener is null) error (DWT.ERROR_NULL_ARGUMENT);
    TypedListener typedListener = new TypedListener (listener);
    addListener (DWT.Selection,typedListener);
    addListener (DWT.DefaultSelection,typedListener);
}

/**
 * Adds the listener to the collection of listeners who will
 * be notified when the receiver's text is verified, by sending
 * it one of the messages defined in the <code>VerifyListener</code>
 * interface.
 *
 * @param listener the listener which should be notified
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
 * </ul>
 * @exception DWTException <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>
 *
 * @see VerifyListener
 * @see #removeVerifyListener
 *
 * @since 3.1
 */
public void addVerifyListener (VerifyListener listener) {
    checkWidget ();
    if (listener is null) error (DWT.ERROR_NULL_ARGUMENT);
    TypedListener typedListener = new TypedListener (listener);
    addListener (DWT.Verify, typedListener);
}

override int callWindowProc (HWND hwnd, int msg, int wParam, int lParam) {
    if (handle is null) return 0;
    if (hwnd is handle) {
        switch (msg) {
            case OS.WM_SIZE: {
                ignoreResize = true;
                int /*long*/ result = OS.CallWindowProc (ComboProc, hwnd, msg, wParam, lParam);
                ignoreResize = false;
                return result;
            default:
            }
        }
        return OS.CallWindowProc( ComboProc, hwnd, msg, wParam, lParam);
    }
    auto hwndText = OS.GetDlgItem (handle, CBID_EDIT);
    if (hwnd is hwndText) {
        return OS.CallWindowProc( EditProc, hwnd, msg, wParam, lParam);
    }
    auto hwndList = OS.GetDlgItem (handle, CBID_LIST);
    if (hwnd is hwndList) {
        return OS.CallWindowProc( ListProc, hwnd, msg, wParam, lParam);
    }
    return OS.DefWindowProc (hwnd, msg, wParam, lParam);
}

private static extern(Windows) int CBTFunc (int nCode, uint wParam, int lParam) {
    return pThis.CBTProc( nCode, wParam, lParam );
}

int CBTProc (int nCode, int wParam, int lParam) {
    if (nCode is OS.HCBT_CREATEWND) {
        TCHAR[128] buffer = 0;
        OS.GetClassName (cast(HANDLE)wParam, buffer.ptr, buffer.length );
        String className = TCHARzToStr(buffer.ptr);
        if (className=="Edit" || className=="EDIT") { //$NON-NLS-1$  //$NON-NLS-2$
            int bits = OS.GetWindowLong (cast(HANDLE)wParam, OS.GWL_STYLE);
            OS.SetWindowLong (cast(HANDLE)wParam, OS.GWL_STYLE, bits & ~OS.ES_NOHIDESEL);
        }
    }
    return OS.CallNextHookEx (cbtHook, nCode, wParam, lParam);
}

override bool checkHandle (HWND hwnd) {
    return hwnd is handle || hwnd is OS.GetDlgItem (handle, CBID_EDIT) || hwnd is OS.GetDlgItem (handle, CBID_LIST);
}

override protected void checkSubclass () {
    if (!isValidSubclass ()) error (DWT.ERROR_INVALID_SUBCLASS);
}

static int checkStyle (int style) {
    /*
     * Feature in Windows.  It is not possible to create
     * a combo box that has a border using Windows style
     * bits.  All combo boxes draw their own border and
     * do not use the standard Windows border styles.
     * Therefore, no matter what style bits are specified,
     * clear the BORDER bits so that the DWT style will
     * match the Windows widget.
     *
     * The Windows behavior is currently implemented on
     * all platforms.
     */
    style &= ~DWT.BORDER;

    /*
     * Even though it is legal to create this widget
     * with scroll bars, they serve no useful purpose
     * because they do not automatically scroll the
     * widget's client area.  The fix is to clear
     * the DWT style.
     */
    style &= ~(DWT.H_SCROLL | DWT.V_SCROLL);
    style = checkBits (style, DWT.DROP_DOWN, DWT.SIMPLE, 0, 0, 0, 0);
    if ((style & DWT.SIMPLE) !is 0) return style & ~DWT.READ_ONLY;
    return style;
}

/**
 * Sets the selection in the receiver's text field to an empty
 * selection starting just before the first character. If the
 * text field is editable, this has the effect of placing the
 * i-beam at the start of the text.
 * <p>
 * Note: To clear the selected items in the receiver's list,
 * use <code>deselectAll()</code>.
 * </p>
 *
 * @exception DWTException <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>
 *
 * @see #deselectAll
 */
public void clearSelection () {
    checkWidget ();
    OS.SendMessage (handle, OS.CB_SETEDITSEL, 0, -1);
}

override public Point computeSize (int wHint, int hHint, bool changed) {
    checkWidget ();
    int width = 0, height = 0;
    if (wHint is DWT.DEFAULT) {
        HFONT newFont, oldFont;
        auto hDC = OS.GetDC (handle);
        newFont = cast(HFONT) OS.SendMessage (handle, OS.WM_GETFONT, 0, 0);
        if (newFont !is null) oldFont = OS.SelectObject (hDC, newFont);
        int count = OS.SendMessage (handle, OS.CB_GETCOUNT, 0, 0);
        RECT rect;
        int flags = OS.DT_CALCRECT | OS.DT_NOPREFIX;
        if ((style & DWT.READ_ONLY) is 0) flags |= OS.DT_EDITCONTROL;
        int length_ = OS.GetWindowTextLength (handle);
        int cp = getCodePage ();
        TCHAR[] buffer = new TCHAR[ length_ + 1];
        buffer[] = 0;
        OS.GetWindowText (handle, buffer.ptr, length_ + 1);
        OS.DrawText (hDC, buffer.ptr, length_, &rect, flags);
        width = Math.max (width, rect.right - rect.left);
        if ((style & DWT.H_SCROLL) !is 0) {
            width = Math.max (width, scrollWidth);
        } else {
            for (int i=0; i<count; i++) {
                length_ = OS.SendMessage (handle, OS.CB_GETLBTEXTLEN, i, 0);
                if (length_ !is OS.CB_ERR) {
                    if (length_ + 1 > buffer.length ) buffer = new TCHAR[ length_ + 1 ], buffer[] =0;
                    int result = OS.SendMessage (handle, OS.CB_GETLBTEXT, i, buffer.ptr);
                    if (result !is OS.CB_ERR) {
                        OS.DrawText (hDC, buffer.ptr, length_, &rect, flags);
                        width = Math.max (width, rect.right - rect.left);
                    }
                }
            }
        }
        if (newFont !is null) OS.SelectObject (hDC, oldFont);
        OS.ReleaseDC (handle, hDC);
    }
    if (hHint is DWT.DEFAULT) {
        if ((style & DWT.SIMPLE) !is 0) {
            int count = OS.SendMessage (handle, OS.CB_GETCOUNT, 0, 0);
            int itemHeight = OS.SendMessage (handle, OS.CB_GETITEMHEIGHT, 0, 0);
            height = count * itemHeight;
        }
    }
    if (width is 0) width = DEFAULT_WIDTH;
    if (height is 0) height = DEFAULT_HEIGHT;
    if (wHint !is DWT.DEFAULT) width = wHint;
    if (hHint !is DWT.DEFAULT) height = hHint;
    if ((style & DWT.READ_ONLY) !is 0) {
        width += 8;
    } else {
        auto hwndText = OS.GetDlgItem (handle, CBID_EDIT);
        if (hwndText !is null) {
            int /*long*/ margins = OS.SendMessage (hwndText, OS.EM_GETMARGINS, 0, 0);
            int marginWidth = OS.LOWORD (margins) + OS.HIWORD (margins);
            width += marginWidth + 3;
        }
    }
    COMBOBOXINFO pcbi;
    pcbi.cbSize = COMBOBOXINFO.sizeof;
    if (((style & DWT.SIMPLE) is 0) && !OS.IsWinCE && OS.GetComboBoxInfo (handle, &pcbi)) {
        width += pcbi.rcItem.left + (pcbi.rcButton.right - pcbi.rcButton.left);
        height = (pcbi.rcButton.bottom - pcbi.rcButton.top) + pcbi.rcButton.top * 2;
    } else {
        int border = OS.GetSystemMetrics (OS.SM_CXEDGE);
        width += OS.GetSystemMetrics (OS.SM_CXVSCROLL) + border * 2;
        int textHeight = OS.SendMessage (handle, OS.CB_GETITEMHEIGHT, -1, 0);
        if ((style & DWT.DROP_DOWN) !is 0) {
            height = textHeight + 6;
        } else {
            height += textHeight + 10;
        }
    }
    if ((style & DWT.SIMPLE) !is 0 && (style & DWT.H_SCROLL) !is 0) {
        height += OS.GetSystemMetrics (OS.SM_CYHSCROLL);
    }
    return new Point (width, height);
}

/**
 * Copies the selected text.
 * <p>
 * The current selection is copied to the clipboard.
 * </p>
 *
 * @exception DWTException <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.1
 */
public void copy () {
    checkWidget ();
    OS.SendMessage (handle, OS.WM_COPY, 0, 0);
}

override void createHandle () {
    /*
    * Feature in Windows.  When the selection changes in a combo box,
    * Windows draws the selection, even when the combo box does not
    * have focus.  Strictly speaking, this is the correct Windows
    * behavior because the combo box sets ES_NOHIDESEL on the text
    * control that it creates.  Despite this, it looks strange because
    * Windows also clears the selection and selects all the text when
    * the combo box gets focus.  The fix is use the CBT hook to clear
    * the ES_NOHIDESEL style bit when the text control is created.
    */
    if (OS.IsWinCE || (style & (DWT.READ_ONLY | DWT.SIMPLE)) !is 0) {
        super.createHandle ();
    } else {
        int threadId = OS.GetCurrentThreadId ();
        //Callback cbtCallback = new Callback (this, "CBTProc", 3); //$NON-NLS-1$
        //int cbtProc = cbtCallback.getAddress ();
        //if (cbtProc is 0) error (DWT.ERROR_NO_MORE_CALLBACKS);
        pThis = this;
        cbtHook = OS.SetWindowsHookEx (OS.WH_CBT, &CBTFunc, null, threadId);
        super.createHandle ();
        if (cbtHook !is null) OS.UnhookWindowsHookEx (cbtHook);
        pThis = null;
        //cbtHook = 0;
        //cbtCallback.dispose ();
    }
    state &= ~(CANVAS | THEME_BACKGROUND);

    /* Get the text and list window procs */
    auto hwndText = OS.GetDlgItem (handle, CBID_EDIT);
    if (hwndText !is null && EditProc is null) {
        EditProc = cast(WNDPROC) OS.GetWindowLongPtr (hwndText, OS.GWLP_WNDPROC);
    }
    auto hwndList = OS.GetDlgItem (handle, CBID_LIST);
    if (hwndList !is null && ListProc is null) {
        ListProc = cast(WNDPROC) OS.GetWindowLongPtr (hwndList, OS.GWLP_WNDPROC);
    }

    /*
    * Bug in Windows.  If the combo box has the CBS_SIMPLE style,
    * the list portion of the combo box is not drawn correctly the
    * first time, causing pixel corruption.  The fix is to ensure
    * that the combo box has been resized more than once.
    */
    if ((style & DWT.SIMPLE) !is 0) {
        int flags = OS.SWP_NOZORDER | OS.SWP_DRAWFRAME | OS.SWP_NOACTIVATE;
        SetWindowPos (handle, null, 0, 0, 0x3FFF, 0x3FFF, flags);
        SetWindowPos (handle, null, 0, 0, 0, 0, flags);
    }
}

/**
 * Cuts the selected text.
 * <p>
 * The current selection is first copied to the
 * clipboard and then deleted from the widget.
 * </p>
 *
 * @exception DWTException <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.1
 */
public void cut () {
    checkWidget ();
    if ((style & DWT.READ_ONLY) !is 0) return;
    OS.SendMessage (handle, OS.WM_CUT, 0, 0);
}

override int defaultBackground () {
    return OS.GetSysColor (OS.COLOR_WINDOW);
}

override void deregister () {
    super.deregister ();
    auto hwndText = OS.GetDlgItem (handle, CBID_EDIT);
    if (hwndText !is null) display.removeControl (hwndText);
    auto hwndList = OS.GetDlgItem (handle, CBID_LIST);
    if (hwndList !is null) display.</