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

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

import dwt.widgets.TypedListener;

import dwt.dwthelper.utils;

import Integer = tango.text.convert.Integer;
import tango.text.convert.Format;

//TODO - features not yet implemented: read-only, drop-down calendar for date
//TODO - font, colors, background image not yet implemented (works on some platforms)

/**
 * Instances of this class are selectable user interface
 * objects that allow the user to enter and modify date
 * or time values.
 * <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>DATE, TIME, CALENDAR, SHORT, MEDIUM, LONG</dd>
 * <dt><b>Events:</b></dt>
 * <dd>Selection</dd>
 * </dl>
 * <p>
 * Note: Only one of the styles DATE, TIME, or CALENDAR may be specified,
 * and only one of the styles SHORT, MEDIUM, or LONG 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/#datetime">DateTime 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>
 *
 * @since 3.3
 */

public class DateTime : Composite {

    alias Composite.computeSize computeSize;
    alias Composite.windowProc windowProc;

    bool ignoreSelection;
    SYSTEMTIME* lastSystemTime;
    SYSTEMTIME time; // only used in calendar mode
    static /+const+/ WNDPROC DateTimeProc;
    static const TCHAR[] DateTimeClass = OS.DATETIMEPICK_CLASS;
    static /+const+/ WNDPROC CalendarProc;
    static const TCHAR[] CalendarClass = OS.MONTHCAL_CLASS;

    private static bool static_this_completed = false;
    private static void static_this() {
        if( static_this_completed ){
            return;
        }
        synchronized {
            if( static_this_completed ){
                return;
            }
            INITCOMMONCONTROLSEX icex;
            icex.dwSize = INITCOMMONCONTROLSEX.sizeof;
            icex.dwICC = OS.ICC_DATE_CLASSES;
            OS.InitCommonControlsEx (&icex);
            WNDCLASS lpWndClass;
            OS.GetClassInfo (null, DateTimeClass.ptr, &lpWndClass);
            DateTimeProc = lpWndClass.lpfnWndProc;
            /*
            * Feature in Windows.  The date time window class
            * does not include CS_DBLCLKS.  This means that these
            * controls will not get double click messages such as
            * WM_LBUTTONDBLCLK.  The fix is to register a new 
            * window class with CS_DBLCLKS.
            * 
            * NOTE:  Screen readers look for the exact class name
            * of the control in order to provide the correct kind
            * of assistance.  Therefore, it is critical that the
            * new window class have the same name.  It is possible
            * to register a local window class with the same name
            * as a global class.  Since bits that affect the class
            * are being changed, it is possible that other native
            * code, other than DWT, could create a control with
            * this class name, and fail unexpectedly.
            */
            auto hInstance = OS.GetModuleHandle (null);
            auto hHeap = OS.GetProcessHeap ();
            lpWndClass.hInstance = hInstance;
            lpWndClass.style &= ~OS.CS_GLOBALCLASS;
            lpWndClass.style |= OS.CS_DBLCLKS;
            int byteCount = DateTimeClass.length * TCHAR.sizeof;
            auto lpszClassName = cast(TCHAR*) OS.HeapAlloc (hHeap, OS.HEAP_ZERO_MEMORY, byteCount);
            OS.MoveMemory (lpszClassName, DateTimeClass.ptr, byteCount);
            lpWndClass.lpszClassName = lpszClassName;
            OS.RegisterClass (&lpWndClass);
            OS.HeapFree (hHeap, 0, lpszClassName);
            OS.GetClassInfo (null, CalendarClass.ptr, &lpWndClass);
            CalendarProc = lpWndClass.lpfnWndProc;
            /*
            * Feature in Windows.  The date time window class
            * does not include CS_DBLCLKS.  This means that these
            * controls will not get double click messages such as
            * WM_LBUTTONDBLCLK.  The fix is to register a new 
            * window class with CS_DBLCLKS.
            * 
            * NOTE:  Screen readers look for the exact class name
            * of the control in order to provide the correct kind
            * of assistance.  Therefore, it is critical that the
            * new window class have the same name.  It is possible
            * to register a local window class with the same name
            * as a global class.  Since bits that affect the class
            * are being changed, it is possible that other native
            * code, other than DWT, could create a control with
            * this class name, and fail unexpectedly.
            */
            hInstance = OS.GetModuleHandle (null);
            hHeap = OS.GetProcessHeap ();
            lpWndClass.hInstance = hInstance;
            lpWndClass.style &= ~OS.CS_GLOBALCLASS;
            lpWndClass.style |= OS.CS_DBLCLKS;
            byteCount = CalendarClass.length * TCHAR.sizeof;
            lpszClassName = cast(TCHAR*)OS.HeapAlloc (hHeap, OS.HEAP_ZERO_MEMORY, byteCount);
            OS.MoveMemory (lpszClassName, CalendarClass.ptr, byteCount);
            lpWndClass.lpszClassName = lpszClassName;
            OS.RegisterClass (&lpWndClass);
            OS.HeapFree (hHeap, 0, lpszClassName);
            static_this_completed = true;
        }
    }

    static const int MARGIN = 4;
    static const int MAX_DIGIT = 9;
    static const int MAX_DAY = 31;
    static const int MAX_12HOUR = 12;
    static const int MAX_24HOUR = 24;
    static const int MAX_MINUTE = 60;
    static const int MONTH_DAY_YEAR = 0;
    static const int DAY_MONTH_YEAR = 1;
    static const int YEAR_MONTH_DAY = 2;
    static const char SINGLE_QUOTE = '\''; //$NON-NLS-1$ short date format may include quoted text
    static const char DAY_FORMAT_CONSTANT = 'd'; //$NON-NLS-1$ 1-4 lowercase 'd's represent day
    static const char MONTH_FORMAT_CONSTANT = 'M'; //$NON-NLS-1$ 1-4 uppercase 'M's represent month
    static const char YEAR_FORMAT_CONSTANT = 'y'; //$NON-NLS-1$ 1-5 lowercase 'y's represent year
    static const char HOURS_FORMAT_CONSTANT = 'h'; //$NON-NLS-1$ 1-2 upper or lowercase 'h's represent hours
    static const char MINUTES_FORMAT_CONSTANT = 'm'; //$NON-NLS-1$ 1-2 lowercase 'm's represent minutes
    static const char SECONDS_FORMAT_CONSTANT = 's'; //$NON-NLS-1$ 1-2 lowercase 's's represent seconds
    static const char AMPM_FORMAT_CONSTANT = 't'; //$NON-NLS-1$ 1-2 lowercase 't's represent am/pm
    static const int[] MONTH_NAMES = [OS.LOCALE_SMONTHNAME1, OS.LOCALE_SMONTHNAME2, OS.LOCALE_SMONTHNAME3, OS.LOCALE_SMONTHNAME4, OS.LOCALE_SMONTHNAME5, OS.LOCALE_SMONTHNAME6, OS.LOCALE_SMONTHNAME7, OS.LOCALE_SMONTHNAME8, OS.LOCALE_SMONTHNAME9, OS.LOCALE_SMONTHNAME10, OS.LOCALE_SMONTHNAME11, OS.LOCALE_SMONTHNAME12];


/**
 * 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#DATE
 * @see DWT#TIME
 * @see DWT#CALENDAR
 * @see Widget#checkSubclass
 * @see Widget#getStyle
 */
public this (Composite parent, int style) {
    static_this();
    super (parent, checkStyle (style));
    if ((this.style & DWT.SHORT) !is 0) {
        String buffer = ((this.style & DWT.DATE) !is 0) ? getCustomShortDateFormat() : getCustomShortTimeFormat();
        TCHAR[] lpszFormat = StrToTCHARs (0, buffer, true);
        OS.SendMessage (handle, OS.DTM_SETFORMAT, 0, lpszFormat.ptr);
    }
}

/**
 * Adds the listener to the collection of listeners who will
 * be notified when the control is selected by the user, 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 control's value.
 * <code>widgetDefaultSelected</code> is not called.
 * </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);
}

override int callWindowProc (HWND hwnd, int msg, int wParam, int lParam) {
    if (handle is null) return 0;
    return OS.CallWindowProc ( cast(WNDPROC)windowProc(), hwnd, msg, wParam, lParam);
}

static int checkStyle (int style) {
    /*
    * 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.DATE, DWT.TIME, DWT.CALENDAR, 0, 0, 0);
    return checkBits (style, DWT.MEDIUM, DWT.SHORT, DWT.LONG, 0, 0, 0);
}

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

override public Point computeSize (int wHint, int hHint, bool changed) {
    checkWidget ();
    int width = 0, height = 0;
    if (wHint is DWT.DEFAULT || hHint is DWT.DEFAULT) {
        if ((style & DWT.CALENDAR) !is 0) {
            RECT rect;
            OS.SendMessage(handle, OS.MCM_GETMINREQRECT, 0, &rect);
            width = rect.right;
            height = rect.bottom;
        } else {
            TCHAR[] buffer = new TCHAR[128];
            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_EDITCONTROL | OS.DT_NOPREFIX;
            SYSTEMTIME systime;
            if ((style & DWT.DATE) !is 0) {
                /* Determine the widest/tallest year string. */
                systime.wMonth = 1;
                systime.wDay = 1;
                int widest = 0, secondWidest = 0, thirdWidest = 0;
                for (int i = 0; i <= MAX_DIGIT; i++) {
                    systime.wYear = cast(short) (2000 + i); // year 2000 + i is guaranteed to exist
                    int size = OS.GetDateFormat(OS.LOCALE_USER_DEFAULT, OS.DATE_SHORTDATE, &systime, null, buffer.ptr, buffer.length);
                    if (size is 0) {
                        buffer = new TCHAR[size];
                        OS.GetDateFormat(OS.LOCALE_USER_DEFAULT, OS.DATE_SHORTDATE, &systime, null, buffer.ptr, buffer.length);
                    }
                    rect.left = rect.top = rect.right = rect.bottom = 0;
                    OS.DrawText (hDC, buffer.ptr, size, &rect, flags);
                    if (rect.right - rect.left >= width) {
                        width = rect.right - rect.left;
                        thirdWidest = secondWidest;
                        secondWidest = widest;
                        widest = i;
                    }
                    height = Math.max(height, rect.bottom - rect.top);
                }
                if (widest > 1) widest = widest * 1000 + widest * 100 + widest * 10 + widest;
                else if (secondWidest > 1) widest = secondWidest * 1000 + widest * 100 + widest * 10 + widest;
                else widest = thirdWidest * 1000 + widest * 100 + widest * 10 + widest;
                systime.wYear = cast(short) widest;

                /* Determine the widest/tallest month name string. */
                width = widest = 0;
                for (short i = 0; i < MONTH_NAMES.length; i++) {
                    int name = MONTH_NAMES [i];
                    int size = OS.GetLocaleInfo (OS.LOCALE_USER_DEFAULT, name, buffer.ptr, buffer.length);
                    if (size is 0) {
                        buffer = new TCHAR[size];
                        OS.GetLocaleInfo (OS.LOCALE_USER_DEFAULT, name, buffer.ptr, buffer.length);
                    }
                    rect.left = rect.top = rect.right = rect.bottom = 0;
                    OS.DrawText (hDC, buffer.ptr, size, &rect, flags);
                    if (rect.right - rect.left > width) {
                        width = rect.right - rect.left;
                        widest = i;
                    }
                    height = Math.max(height, rect.bottom - rect.top);
                }
                systime.wMonth = cast(short) (widest + 1);

                /* Determine the widest/tallest date string in the widest month of the widest year. */
                int dwFlags = ((style & DWT.MEDIUM) !is 0) ? OS.DATE_SHORTDATE : ((style & DWT.SHORT) !is 0) ? OS.DATE_YEARMONTH : OS.DATE_LONGDATE;
                width = 0;
                for (short i = 1; i <= MAX_DAY; i++) {
                    systime.wDay = i;
                    int size = OS.GetDateFormat(OS.LOCALE_USER_DEFAULT, dwFlags, &systime, null, buffer.ptr, buffer.length);
                    if (size is 0) {
                        buffer = new TCHAR[size];
                        OS.GetDateFormat(OS.LOCALE_USER_DEFAULT, dwFlags, &systime, null, buffer.ptr, buffer.length);
                    }
                    rect.left = rect.top = rect.right = rect.bottom = 0;
                    OS.DrawText (hDC, buffer.ptr, size, &rect, flags);
                    width = Math.max(width, rect.right - rect.left);
                    height = Math.max(height, rect.bottom - rect.top);
                    if ((style & DWT.SHORT) !is 0) break;
                }
            } else if ((style & DWT.TIME) !is 0) {
                /* Determine the widest/tallest hour string. This code allows for the possibility of ligatures. */
                int dwFlags = ((style & DWT.SHORT) !is 0) ? OS.TIME_NOSECONDS : 0;
                short widest = 0;
                int max = is24HourTime () ? MAX_24HOUR : MAX_12HOUR;
                for (short i = 0; i < max; i++) {
                    systime.wHour = i;
                    int size = OS.GetTimeFormat(OS.LOCALE_USER_DEFAULT, dwFlags, &systime, null, buffer.ptr, buffer.length);
                    if (size is 0) {
                        buffer = new TCHAR[size];
                        OS.GetTimeFormat(OS.LOCALE_USER_DEFAULT, dwFlags, &systime, null, buffer.ptr, buffer.length);
                    }
                    rect.left = rect.top = rect.right = rect.bottom = 0;
                    OS.DrawText (hDC, buffer.ptr, size, &rect, flags);
                    if (rect.right - rect.left > width) {
                        width = rect.right - rect.left;
                        widest = i;
                    }
                    height = Math.max(height, rect.bottom - rect.top);
                }
                systime.wHour = widest;

                /* Determine the widest/tallest minute and second string. */
                width = widest = 0;
                for (short i = 0; i < MAX_MINUTE; i++) {
                    systime.wMinute = i;
                    int size = OS.GetTimeFormat(OS.LOCALE_USER_DEFAULT, dwFlags, &systime, null, buffer.ptr, buffer.length);
                    if (size is 0) {
                        buffer = new TCHAR[size];
                        OS.GetTimeFormat(OS.LOCALE_USER_DEFAULT, dwFlags, &systime, null, buffer.ptr, buffer.length);
                    }
                    rect.left = rect.top = rect.right = rect.bottom = 0;
                    OS.DrawText (hDC, buffer.ptr, size, &rect, flags);
                    if (rect.right - rect.left > width) {
                        width = rect.right - rect.left;
                        widest = i;
                    }
                    height = Math.max(height, rect.bottom - rect.top);
                }
                systime.wMinute = widest;
                systime.wSecond = widest;

                /* Determine the widest/tallest time string for the widest hour, widest minute, and if applicable, widest second. */
                int size = OS.GetTimeFormat(OS.LOCALE_USER_DEFAULT, dwFlags, &systime, null, buffer.ptr, buffer.length);
                if (size is 0) {
                    buffer = new TCHAR[size];
                    OS.GetTimeFormat(OS.LOCALE_USER_DEFAULT, dwFlags, &systime, null, buffer.ptr, buffer.length);
                }
                rect.left = rect.top = rect.right = rect.bottom = 0;
                OS.DrawText (hDC, buffer.ptr, size, &rect, flags);
                width = rect.right - rect.left;
                height = Math.max(height, rect.bottom - rect.top);
            }
            if (newFont !is null) OS.SelectObject (hDC, oldFont);
            OS.ReleaseDC (handle, hDC);
            int upDownWidth = OS.GetSystemMetrics (OS.SM_CXVSCROLL);
            width += upDownWidth + MARGIN;
            int upDownHeight = OS.GetSystemMetrics (OS.SM_CYVSCROLL);
            // TODO: On Vista, can send DTM_GETDATETIMEPICKERINFO to ask the Edit control what its margins are
            if (!OS.IsWinCE && OS.WIN32_VERSION >= OS.VERSION (6, 0)) upDownHeight += 7;
            height = Math.max (height, upDownHeight);
        }
    }
    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;
    height += border * 2;
    return new Point (width, height);
}

override void createHandle () {
    super.createHandle ();
    state &= ~(CANVAS | THEME_BACKGROUND);

    if ((style & DWT.BORDER) is 0) {
        int bits = OS.GetWindowLong (handle, OS.GWL_EXSTYLE);
        bits &= ~(OS.WS_EX_CLIENTEDGE | OS.WS_EX_STATICEDGE);
        OS.SetWindowLong (handle, OS.GWL_EXSTYLE, bits);
    }
}

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

String getComputeSizeString () {
    // TODO: Not currently used but might need for WinCE
    if ((style & DWT.DATE) !is 0) {
        if ((style & DWT.SHORT) !is 0) return getCustomShortDateFormat ();
        if ((style & DWT.MEDIUM) !is 0) return getShortDateFormat ();
        if ((style & DWT.LONG) !is 0) return getLongDateFormat ();
    }
    if ((style & DWT.TIME) !is 0) {
        if ((style & DWT.SHORT) !is 0) return getCustomShortTimeFormat ();
        return getTimeFormat ();
    }
    return "";
}

String getCustomShortDateFormat () {
    if (true) {
        TCHAR[] tchar = new TCHAR[80];
        int size = OS.GetLocaleInfo (OS.LOCALE_USER_DEFAULT, OS.LOCALE_SYEARMONTH, tchar.ptr, 80);
        return size !is 0 ? TCHARsToStr(tchar[0..size - 1])  : "M/yyyy"; //$NON-NLS-1$
    }

    //TODO: Not currently used, but may need for WinCE (or if numeric short date is required)
    String buffer = getShortDateFormat ();
    int length = buffer.length;
    bool inQuotes = false;
    int