root/dwt/widgets/List.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.List;


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

import dwt.widgets.Scrollable;
import dwt.widgets.Composite;
import dwt.widgets.TypedListener;

import dwt.dwthelper.utils;

/**
 * Instances of this class represent a selectable user interface
 * object that displays a list of strings and issues notification
 * when a string is selected.  A list may be single or multi select.
 * <p>
 * <dl>
 * <dt><b>Styles:</b></dt>
 * <dd>SINGLE, MULTI</dd>
 * <dt><b>Events:</b></dt>
 * <dd>Selection, DefaultSelection</dd>
 * </dl>
 * <p>
 * Note: Only one of SINGLE and MULTI may be specified.
 * </p><p>
 * IMPORTANT: This class is <em>not</em> intended to be subclassed.
 * </p>
 *
 * @see <a href="http://www.eclipse.org/swt/snippets/#list">List 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 List : Scrollable {

    alias Scrollable.computeSize computeSize;
    alias Scrollable.windowProc windowProc;

    static const int INSET = 3;
    private static /+const+/ WNDPROC ListProc;
    static const TCHAR[] ListClass = "LISTBOX";

    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, ListClass.ptr, &lpWndClass);
            ListProc = 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#SINGLE
 * @see DWT#MULTI
 * @see Widget#checkSubclass
 * @see Widget#getStyle
 */
public this (Composite parent, int style) {
    static_this();
    super (parent, checkStyle (style));
}
/**
 * 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);
    TCHAR* buffer = StrToTCHARz ( getCodePage (), string);
    int result = OS.SendMessage (handle, OS.LB_ADDSTRING, 0, buffer);
    if (result is OS.LB_ERR) error (DWT.ERROR_ITEM_NOT_ADDED);
    if (result is OS.LB_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);
    if (index is -1) error (DWT.ERROR_INVALID_RANGE);
    TCHAR* buffer = StrToTCHARz(getCodePage (), string);
    int result = OS.SendMessage (handle, OS.LB_INSERTSTRING, index, buffer);
    if (result is OS.LB_ERRSPACE) error (DWT.ERROR_ITEM_NOT_ADDED);
    if (result is OS.LB_ERR) {
        int count = OS.SendMessage (handle, OS.LB_GETCOUNT, 0, 0);
        if (0 <= index && index <= count) {
            error (DWT.ERROR_ITEM_NOT_ADDED);
        } else {
            error (DWT.ERROR_INVALID_RANGE);
        }
    }
    if ((style & DWT.H_SCROLL) !is 0) setScrollWidth (buffer, true);
}

/**
 * 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 selection changes.
 * <code>widgetDefaultSelected</code> is typically called when an item is double-clicked.
 * </p>
 *
 * @param listener the listener which should be notified when the user changes the receiver's selection
 *
 * @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);
}

override int callWindowProc (HWND hwnd, int msg, int wParam, int lParam) {
    if (handle is null) return 0;
    bool redraw = false;
    switch (msg) {
        case OS.WM_HSCROLL:
        case OS.WM_VSCROLL: {
            redraw = findImageControl () !is null && drawCount is 0 && OS.IsWindowVisible (handle);
            if (redraw) OS.DefWindowProc (handle, OS.WM_SETREDRAW, 0, 0);
            break;
        }
        default:
    }
    int /*long*/ code = OS.CallWindowProc (ListProc, hwnd, msg, wParam, lParam);
    switch (msg) {
        case OS.WM_HSCROLL:
        case OS.WM_VSCROLL: {
            if (redraw) {
                OS.DefWindowProc (handle, OS.WM_SETREDRAW, 1, 0);
                OS.InvalidateRect (handle, null, true);
            }
            break;
        }
        default:
    }
    return code;
}

static int checkStyle (int style) {
    return checkBits (style, DWT.SINGLE, DWT.MULTI, 0, 0, 0, 0);
}

override public Point computeSize (int wHint, int hHint, bool changed) {
    checkWidget ();
    int width = 0, height = 0;
    if (wHint is DWT.DEFAULT) {
        if ((style & DWT.H_SCROLL) !is 0) {
            width = OS.SendMessage (handle, OS.LB_GETHORIZONTALEXTENT, 0, 0);
            width -= INSET;
        } else {
            int count = OS.SendMessage (handle, OS.LB_GETCOUNT, 0, 0);
            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);
            RECT rect;
            int flags = OS.DT_CALCRECT | OS.DT_SINGLELINE | OS.DT_NOPREFIX;
            int cp = getCodePage ();
            TCHAR[] buffer = NewTCHARs (cp, 64 + 1);
            for (int i=0; i<count; i++) {
                int length = OS.SendMessage (handle, OS.LB_GETTEXTLEN, i, 0);
                if (length !is OS.LB_ERR) {
                    if (length + 1 > buffer.length) {
                        buffer = NewTCHARs (cp, length + 1);
                    }
                    int result = OS.SendMessage (handle, OS.LB_GETTEXT, i, buffer.ptr);
                    if (result !is OS.LB_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) {
        int count = OS.SendMessage (handle, OS.LB_GETCOUNT, 0, 0);
        int itemHeight = OS.SendMessage (handle, OS.LB_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;
    int border = getBorderWidth ();
    width += border * 2 + INSET;
    height += border * 2;
    if ((style & DWT.V_SCROLL) !is 0) {
        width += OS.GetSystemMetrics (OS.SM_CXVSCROLL);
    }
    if ((style & DWT.H_SCROLL) !is 0) {
        height += OS.GetSystemMetrics (OS.SM_CYHSCROLL);
    }
    return new Point (width, height);
}

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

/**
 * Deselects the items at the given zero-relative indices in the receiver.
 * If the item at the given zero-relative index in the receiver
 * is selected, it is deselected.  If the item at the index
 * was not selected, it remains deselected. Indices that are out
 * of range and duplicate indices are ignored.
 *
 * @param indices the array of indices for the items to deselect
 *
 * @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>
 */
public void deselect (int [] indices) {
    checkWidget ();
    // DWT extension: allow null array
    //if (indices is null) error (DWT.ERROR_NULL_ARGUMENT);
    if (indices.length is 0) return;
    if ((style & DWT.SINGLE) !is 0) {
        int oldIndex = OS.SendMessage (handle, OS.LB_GETCURSEL, 0, 0);
        if (oldIndex is OS.LB_ERR) return;
        for (int i=0; i<indices.length; i++) {
            if (oldIndex is indices [i]) {
                OS.SendMessage (handle, OS.LB_SETCURSEL, -1, 0);
                return;
            }
        }
        return;
    }
    for (int i=0; i<indices.length; i++) {
        int index = indices [i];
        if (index !is -1) {
            OS.SendMessage (handle, OS.LB_SETSEL, 0, index);
        }
    }
}

/**
 * Deselects the item at the given zero-relative index in the receiver.
 * If the item at the index was already deselected, it remains
 * deselected. Indices that are out of range are ignored.
 *
 * @param index the index of the item to deselect
 *
 * @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>
 */
public void deselect (int index) {
    checkWidget ();
    if (index is -1) return;
    if ((style & DWT.SINGLE) !is 0) {
        int oldIndex = OS.SendMessage (handle, OS.LB_GETCURSEL, 0, 0);
        if (oldIndex is OS.LB_ERR) return;
        if (oldIndex is index) OS.SendMessage (handle, OS.LB_SETCURSEL, -1, 0);
        return;
    }
    OS.SendMessage (handle, OS.LB_SETSEL, 0, index);
}

/**
 * Deselects the items at the given zero-relative indices in the receiver.
 * If the item at the given zero-relative index in the receiver
 * is selected, it is deselected.  If the item at the index
 * was not selected, it remains deselected.  The range of the
 * indices is inclusive. Indices that are out of range are ignored.
 *
 * @param start the start index of the items to deselect
 * @param end the end index of the items to deselect
 *
 * @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>
 */
public void deselect (int start, int end) {
    checkWidget ();
    if (start > end) return;
    if ((style & DWT.SINGLE) !is 0) {
        int oldIndex = OS.SendMessage (handle, OS.LB_GETCURSEL, 0, 0);
        if (oldIndex is OS.LB_ERR) return;
        if (start <= oldIndex && oldIndex <= end) {
            OS.SendMessage (handle, OS.LB_SETCURSEL, -1, 0);
        }
        return;
    }
    /*
    * Ensure that at least one item is contained in
    * the range from start to end.  Note that when
    * start = end, LB_SELITEMRANGEEX deselects the
    * item.
    */
    int count = OS.SendMessage (handle, OS.LB_GETCOUNT, 0, 0);
    if (start < 0 && end < 0) return;
    if (start >= count && end >= count) return;
    start = Math.min (count - 1, Math.max (0, start));
    end = Math.min (count - 1, Math.max (0, end));
    OS.SendMessage (handle, OS.LB_SELITEMRANGEEX, end, start);
}

/**
 * Deselects all selected items in the receiver.
 *
 * @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>
 */
public void deselectAll () {
    checkWidget ();
    if ((style & DWT.SINGLE) !is 0) {
        OS.SendMessage (handle, OS.LB_SETCURSEL, -1, 0);
    } else {
        OS.SendMessage (handle, OS.LB_SETSEL, 0, -1);
    }
}

/**
 * Returns the zero-relative index of the item which currently
 * has the focus in the receiver, or -1 if no item has focus.
 *
 * @return the index of the selected 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>
 */
public int getFocusIndex () {
    checkWidget ();
    int result = OS.SendMessage (handle, OS.LB_GETCARETINDEX, 0, 0);
    if (result is 0) {
        int count = OS.SendMessage (handle, OS.LB_GETCOUNT, 0, 0);
        if (count is 0) return -1;
    }
    return result;
}

/**
 * Returns the item at the given, zero-relative index in the
 * receiver. Throws an exception if the index is out of range.
 *
 * @param index the index of the item to return
 * @return the item at the given index
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_INVALID_RANGE - if the index is not between 0 and the number of elements in the list minus 1 (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>
 */
public String getItem (int index) {
    checkWidget ();
    int length_ = OS.SendMessage (handle, OS.LB_GETTEXTLEN, index, 0);
    if (length_ !is OS.LB_ERR) {
        TCHAR[] buffer = NewTCHARs (getCodePage (), length_ + 1);
        int result = OS.SendMessage (handle, OS.LB_GETTEXT, index, buffer.ptr);
        if (result !is OS.LB_ERR) return TCHARsToStr( buffer[0 .. length_] );
    }
    int count = OS.SendMessage (handle, OS.LB_GETCOUNT, 0, 0);
    if (0 <= index && index < count) error (DWT.ERROR_CANNOT_GET_ITEM);
    error (DWT.ERROR_INVALID_RANGE);
    return "";
}

/**
 * Returns the number of items contained in the receiver.
 *
 * @return the number of items
 *
 * @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>
 */
public int getItemCount () {
    checkWidget ();
    int result = OS.SendMessage (handle, OS.LB_GETCOUNT, 0, 0);
    if (result is OS.LB_ERR) error (DWT.ERROR_CANNOT_GET_COUNT);
    return result;
}

/**
 * Returns the height of the area which would be used to
 * display <em>one</em> of the items in the list.
 *
 * @return the height of one 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>
 */
public int getItemHeight () {
    checkWidget ();
    int result = OS.SendMessage (handle, OS.LB_GETITEMHEIGHT, 0, 0);
    if (result is OS.LB_ERR) error (DWT.ERROR_CANNOT_GET_ITEM_HEIGHT);
    return result;
}

/**
 * Returns a (possibly empty) array of <code>String</code>s which
 * are the items in 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 items in the receiver's list
 *
 * @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>
 */
public String [] getItems () {
    checkWidget ();
    int count = getItemCount ();
    String [] result = new String [count];
    for (int i=0; i<count; i++) result [i] = getItem (i);
    return result;
}

/**
 * Returns an array of <code>String</code>s that are currently
 * selected in the receiver.  The order of the items is unspecified.
 * An empty array indicates that no items are selected.
 * <p>
 * Note: This is not the actual structure used by the receiver
 * to maintain its selection, so modifying the array will
 * not affect the receiver.
 * </p>
 * @return an array representing the selection
 *
 * @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>
 */
public String [] getSelection () {
    checkWidget ();
    int [] indices = getSelectionIndices ();
    String [] result = new String [indices.length];
    for (int i=0; i<indices.length; i++) {
        result [i] = getItem (indices [i]);
    }
    return result;
}

/**
 * Returns the number of selected items contained in the receiver.
 *
 * @return the number of selected items
 *
 * @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>
 */
public int getSelectionCount () {
    checkWidget ();
    if ((style & DWT.SINGLE) !is 0) {
        int result = OS.SendMessage (handle, OS.LB_GETCURSEL, 0, 0);
        if (result is OS.LB_ERR) return 0;
        return 1;
    }
    int result = OS.SendMessage (handle, OS.LB_GETSELCOUNT, 0, 0);
    if (result is OS.LB_ERR) error (DWT.ERROR_CANNOT_GET_COUNT);
    return result;
}

/**
 * Returns the zero-relative index of the item which is currently
 * selected in the receiver, or -1 if no item is selected.
 *
 * @return the index of the selected item or -1
 *
 * @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>
 */
public int getSelectionIndex () {
    checkWidget ();
    if ((style & DWT.SINGLE) !is 0) {
        return OS.SendMessage (handle, OS.LB_GETCURSEL, 0, 0);
    }
    int count = OS.SendMessage (handle, OS.LB_GETSELCOUNT, 0, 0);
    if (count is OS.LB_ERR) error (DWT.ERROR_CANNOT_GET_SELECTION);
    if (count is 0) return -1;
    int index = OS.SendMessage (handle, OS.LB_GETCARETINDEX, 0, 0);
    int result = OS.SendMessage (handle, OS.LB_GETSEL, index, 0);
    if (result is OS.LB_ERR) error (DWT.ERROR_CANNOT_GET_SELECTION);
    if (result !is 0) return index;
    int buffer;
    result = OS.SendMessage (handle, OS.LB_GETSELITEMS, 1, &buffer);
    if (result !is 1) error (DWT.ERROR_CANNOT_GET_SELECTION);
    return buffer;
}

/**
 * Returns the zero-relative indices of the items which are currently
 * selected in the receiver.  The order of the indices is unspecified.