Mercurial > projects > dwt-win
view dwt/widgets/Menu.d @ 213:36f5cb12e1a2
Update to SWT 3.4M7
author | Frank Benoit <benoit@tionex.de> |
---|---|
date | Sat, 17 May 2008 17:34:28 +0200 |
parents | ab60f3309436 |
children | fd9c62a2998e |
line wrap: on
line source
/******************************************************************************* * Copyright (c) 2000, 2007 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.Menu; import dwt.DWT; import dwt.DWTException; import dwt.events.HelpListener; import dwt.events.MenuListener; import dwt.graphics.Color; import dwt.graphics.Image; import dwt.graphics.Point; import dwt.graphics.Rectangle; import dwt.internal.ImageList; import dwt.internal.win32.OS; import dwt.widgets.Widget; import dwt.widgets.Decorations; import dwt.widgets.MenuItem; import dwt.widgets.Control; import dwt.widgets.Shell; import dwt.widgets.TypedListener; import dwt.dwthelper.utils; /** * Instances of this class are user interface objects that contain * menu items. * <dl> * <dt><b>Styles:</b></dt> * <dd>BAR, DROP_DOWN, POP_UP, NO_RADIO_GROUP</dd> * <dd>LEFT_TO_RIGHT, RIGHT_TO_LEFT</dd> * <dt><b>Events:</b></dt> * <dd>Help, Hide, Show </dd> * </dl> * <p> * Note: Only one of BAR, DROP_DOWN and POP_UP may be specified. * Only one of LEFT_TO_RIGHT or RIGHT_TO_LEFT may be specified. * </p><p> * IMPORTANT: This class is <em>not</em> intended to be subclassed. * </p> */ public class Menu : Widget { /** * the handle to the OS resource * (Warning: This field is platform dependent) * <p> * <b>IMPORTANT:</b> This field is <em>not</em> part of the DWT * public API. It is marked public only so that it can be shared * within the packages provided by DWT. It is not available on all * platforms and should never be accessed from application code. * </p> */ public HMENU handle; int x, y; HBRUSH hBrush; HWND hwndCB; int id0, id1; int foreground = -1, background = -1; Image backgroundImage; bool hasLocation; MenuItem cascade; Decorations parent; ImageList imageList; /* Resource ID for SHMENUBARINFO */ static const int ID_PPC = 100; /* SmartPhone SoftKeyBar resource ids */ static const int ID_SPMM = 102; static const int ID_SPBM = 103; static const int ID_SPMB = 104; static const int ID_SPBB = 105; static const int ID_SPSOFTKEY0 = 106; static const int ID_SPSOFTKEY1 = 107; /** * Constructs a new instance of this class given its parent, * and sets the style for the instance so that the instance * will be a popup menu on the given parent's shell. * <p> * After constructing a menu, it can be set into its parent * using <code>parent.setMenu(menu)</code>. In this case, the parent may * be any control in the same widget tree as the parent. * </p> * * @param parent a control which will be the parent of the new instance (cannot be null) * * @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#POP_UP * @see Widget#checkSubclass * @see Widget#getStyle */ public this (Control parent) { this (checkNull (parent).menuShell (), DWT.POP_UP); } /** * Constructs a new instance of this class given its parent * (which must be a <code>Decorations</code>) 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><p> * After constructing a menu or menuBar, it can be set into its parent * using <code>parent.setMenu(menu)</code> or <code>parent.setMenuBar(menuBar)</code>. * </p> * * @param parent a decorations control which will be the parent of the new instance (cannot be null) * @param style the style of menu 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#BAR * @see DWT#DROP_DOWN * @see DWT#POP_UP * @see Widget#checkSubclass * @see Widget#getStyle */ public this (Decorations parent, int style) { this (parent, checkStyle (style), null); } /** * Constructs a new instance of this class given its parent * (which must be a <code>Menu</code>) and sets the style * for the instance so that the instance will be a drop-down * menu on the given parent's parent. * <p> * After constructing a drop-down menu, it can be set into its parentMenu * using <code>parentMenu.setMenu(menu)</code>. * </p> * * @param parentMenu a menu which will be the parent of the new instance (cannot be null) * * @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 Widget#checkSubclass * @see Widget#getStyle */ public this (Menu parentMenu) { this (checkNull (parentMenu).parent, DWT.DROP_DOWN); } /** * Constructs a new instance of this class given its parent * (which must be a <code>MenuItem</code>) and sets the style * for the instance so that the instance will be a drop-down * menu on the given parent's parent menu. * <p> * After constructing a drop-down menu, it can be set into its parentItem * using <code>parentItem.setMenu(menu)</code>. * </p> * * @param parentItem a menu item which will be the parent of the new instance (cannot be null) * * @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 Widget#checkSubclass * @see Widget#getStyle */ public this (MenuItem parentItem) { this (checkNull (parentItem).parent); } this (Decorations parent, int style, HWND handle) { super (parent, checkStyle (style)); this.parent = parent; this.handle = handle; /* * Bug in IBM JVM 1.3.1. For some reason, when the checkOrientation() is * called from createWidget(), the JVM issues this error: * * JVM Exception 0x2 (subcode 0x0) occurred in thread "main" (TID:0x9F19D8) * * In addition, on Windows XP, a dialog appears with following error message, * indicating that the problem may be in the JIT: * * AppName: java.exe AppVer: 0.0.0.0 ModName: jitc.dll * ModVer: 0.0.0.0 Offset: 000b6912 * * The fix is to call checkOrientation() from here. */ checkOrientation (parent); createWidget (); } void _setVisible (bool visible) { if ((style & (DWT.BAR | DWT.DROP_DOWN)) !is 0) return; auto hwndParent = parent.handle; if (visible) { int flags = OS.TPM_LEFTBUTTON; if (OS.GetKeyState (OS.VK_LBUTTON) >= 0) flags |= OS.TPM_RIGHTBUTTON; if ((style & DWT.RIGHT_TO_LEFT) !is 0) flags |= OS.TPM_RIGHTALIGN; if ((parent.style & DWT.MIRRORED) !is 0) { flags &= ~OS.TPM_RIGHTALIGN; if ((style & DWT.LEFT_TO_RIGHT) !is 0) flags |= OS.TPM_RIGHTALIGN; } int nX = x, nY = y; if (!hasLocation) { int pos = OS.GetMessagePos (); nX = OS.GET_X_LPARAM (pos); nY = OS.GET_Y_LPARAM (pos); } /* * Feature in Windows. It is legal use TrackPopupMenu() * to display an empty menu as long as menu items are added * inside of WM_INITPOPUPMENU. If no items are added, then * TrackPopupMenu() fails and does not send an indication * that the menu has been closed. This is not strictly a * bug but leads to unwanted behavior when application code * assumes that every WM_INITPOPUPMENU will eventually result * in a WM_MENUSELECT, wParam=MAKEWPARAM (0, 0xFFFF), lParam=0 to * indicate that the menu has been closed. The fix is to detect * the case when TrackPopupMenu() fails and the number of items in * the menu is zero and issue a fake WM_MENUSELECT. */ bool success = cast(bool) OS.TrackPopupMenu (handle, flags, nX, nY, 0, hwndParent, null); if (!success && GetMenuItemCount (handle) is 0) { OS.SendMessage (hwndParent, OS.WM_MENUSELECT, OS.MAKEWPARAM (0, 0xFFFF), 0); } } else { OS.SendMessage (hwndParent, OS.WM_CANCELMODE, 0, 0); } } /** * Adds the listener to the collection of listeners who will * be notified when help events are generated for the control, * by sending it one of the messages defined in the * <code>HelpListener</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 HelpListener * @see #removeHelpListener */ public void addHelpListener (HelpListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.Help, typedListener); } /** * Adds the listener to the collection of listeners who will * be notified when menus are hidden or shown, by sending it * one of the messages defined in the <code>MenuListener</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 MenuListener * @see #removeMenuListener */ public void addMenuListener (MenuListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); TypedListener typedListener = new TypedListener (listener); addListener (DWT.Hide,typedListener); addListener (DWT.Show,typedListener); } static Control checkNull (Control control) { if (control is null) DWT.error (DWT.ERROR_NULL_ARGUMENT); return control; } static Menu checkNull (Menu menu) { if (menu is null) DWT.error (DWT.ERROR_NULL_ARGUMENT); return menu; } static MenuItem checkNull (MenuItem item) { if (item is null) DWT.error (DWT.ERROR_NULL_ARGUMENT); return item; } static int checkStyle (int style) { return checkBits (style, DWT.POP_UP, DWT.BAR, DWT.DROP_DOWN, 0, 0, 0); } void createHandle () { if (handle !is null) return; if ((style & DWT.BAR) !is 0) { static if( OS.IsWinCE ) if (OS.IsPPC) { auto hwndShell = parent.handle; SHMENUBARINFO mbi; mbi.cbSize = SHMENUBARINFO.sizeof; mbi.hwndParent = hwndShell; mbi.dwFlags = OS.SHCMBF_HIDDEN; mbi.nToolBarId = ID_PPC; mbi.hInstRes = OS.GetLibraryHandle (); bool success = cast(bool) OS.SHCreateMenuBar (&mbi); hwndCB = mbi.hwndMB; if (!success) error (DWT.ERROR_NO_HANDLES); /* Remove the item from the resource file */ OS.SendMessage (hwndCB, OS.TB_DELETEBUTTON, 0, 0); return; } /* * Note in WinCE SmartPhone. The SoftBar contains only 2 items. * An item can either be a menu or a button. * DWT.BAR: creates a SoftBar with 2 menus * DWT.BAR | DWT.BUTTON1: creates a SoftBar with 1 button * for button1, and a menu for button2 * DWT.BAR | DWT.BUTTON1 | DWT.BUTTON2: creates a SoftBar with * 2 buttons */ static if (OS.IsSP) { /* Determine type of menubar */ int nToolBarId; if ((style & DWT.BUTTON1) !is 0) { nToolBarId = ((style & DWT.BUTTON2) !is 0) ? ID_SPBB : ID_SPBM; } else { nToolBarId = ((style & DWT.BUTTON2) !is 0) ? ID_SPMB : ID_SPMM; } /* Create SHMENUBAR */ SHMENUBARINFO mbi; mbi.cbSize = SHMENUBARINFO.sizeof; mbi.hwndParent = parent.handle; mbi.dwFlags = OS.SHCMBF_HIDDEN; mbi.nToolBarId = nToolBarId; /* as defined in .rc file */ mbi.hInstRes = OS.GetLibraryHandle (); if (!OS.SHCreateMenuBar (&mbi)) error (DWT.ERROR_NO_HANDLES); hwndCB = mbi.hwndMB; /* * Feature on WinCE SmartPhone. The SHCMBF_HIDDEN flag causes the * SHMENUBAR to not be drawn. However the keyboard events still go * through it. The workaround is to also hide the SHMENUBAR with * ShowWindow (). */ OS.ShowWindow (hwndCB, OS.SW_HIDE); TBBUTTONINFO info = new TBBUTTONINFO (); info.cbSize = TBBUTTONINFO.sizeof; info.dwMask = OS.TBIF_COMMAND; MenuItem item; /* Set first item */ if (nToolBarId is ID_SPMM || nToolBarId is ID_SPMB) { int /*long*/ hMenu = OS.SendMessage (hwndCB, OS.SHCMBM_GETSUBMENU, 0, ID_SPSOFTKEY0); /* Remove the item from the resource file */ OS.RemoveMenu (hMenu, 0, OS.MF_BYPOSITION); Menu menu = new Menu (parent, DWT.DROP_DOWN, hMenu); item = new MenuItem (this, menu, DWT.CASCADE, 0); } else { item = new MenuItem (this, null, DWT.PUSH, 0); } info.idCommand = id0 = item.id; OS.SendMessage (hwndCB, OS.TB_SETBUTTONINFO, ID_SPSOFTKEY0, info); /* Set second item */ if (nToolBarId is ID_SPMM || nToolBarId is ID_SPBM) { int /*long*/ hMenu = OS.SendMessage (hwndCB, OS.SHCMBM_GETSUBMENU, 0, ID_SPSOFTKEY1); OS.RemoveMenu (hMenu, 0, OS.MF_BYPOSITION); Menu menu = new Menu (parent, DWT.DROP_DOWN, hMenu); item = new MenuItem (this, menu, DWT.CASCADE, 1); } else { item = new MenuItem (this, null, DWT.PUSH, 1); } info.idCommand = id1 = item.id; OS.SendMessage (hwndCB, OS.TB_SETBUTTONINFO, ID_SPSOFTKEY1, info); /* * Override the Back key. For some reason, the owner of the menubar * must be a Dialog or it won't receive the WM_HOTKEY message. As * a result, Shell on WinCE SP must use the class Dialog. */ int dwMask = OS.SHMBOF_NODEFAULT | OS.SHMBOF_NOTIFY; int /*long*/ lParam = OS.MAKELPARAM (dwMask, dwMask); OS.SendMessage (hwndCB, OS.SHCMBM_OVERRIDEKEY, OS.VK_ESCAPE, lParam); return; } handle = OS.CreateMenu (); if (handle is null) error (DWT.ERROR_NO_HANDLES); static if (OS.IsHPC) { auto hwndShell = parent.handle; hwndCB = OS.CommandBar_Create (OS.GetModuleHandle (null), hwndShell, 1); if (hwndCB is null) error (DWT.ERROR_NO_HANDLES); OS.CommandBar_Show (hwndCB, false); OS.CommandBar_InsertMenubarEx (hwndCB, 0, handle, 0); /* * The command bar hosts the 'close' button when the window does not * have a caption. */ if ((parent.style & DWT.CLOSE) !is 0 && (parent.style & DWT.TITLE) is 0) { OS.CommandBar_AddAdornments (hwndCB, 0, 0); } } } else { handle = OS.CreatePopupMenu (); if (handle is null) error (DWT.ERROR_NO_HANDLES); } } void createItem (MenuItem item, int index) { int count = GetMenuItemCount (handle); if (!(0 <= index && index <= count)) error (DWT.ERROR_INVALID_RANGE); display.addMenuItem (item); bool success = false; if ((OS.IsPPC || OS.IsSP) && hwndCB !is null) { if (OS.IsSP) return; TBBUTTON lpButton; lpButton.idCommand = item.id; lpButton.fsStyle = cast(byte) OS.TBSTYLE_AUTOSIZE; if ((item.style & DWT.CASCADE) !is 0) lpButton.fsStyle |= OS.TBSTYLE_DROPDOWN | 0x80; if ((item.style & DWT.SEPARATOR) !is 0) lpButton.fsStyle = cast(byte) OS.BTNS_SEP; lpButton.fsState = cast(byte) OS.TBSTATE_ENABLED; lpButton.iBitmap = OS.I_IMAGENONE; success = OS.SendMessage (hwndCB, OS.TB_INSERTBUTTON, index, &lpButton) !is 0; } else { static if (OS.IsWinCE) { int uFlags = OS.MF_BYPOSITION; TCHAR lpNewItem = null; if ((item.style & DWT.SEPARATOR) !is 0) { uFlags |= OS.MF_SEPARATOR; } else { lpNewItem = new TCHAR (0, " ", true); } success = OS.InsertMenu (handle, index, uFlags, item.id, lpNewItem); if (success) { MENUITEMINFO info = new MENUITEMINFO (); info.cbSize = MENUITEMINFO.sizeof; info.fMask = OS.MIIM_DATA; info.dwItemData = item.id; success = OS.SetMenuItemInfo (handle, index, true, info); } } else { /* * Bug in Windows. For some reason, when InsertMenuItem() * is used to insert an item without text, it is not possible * to use SetMenuItemInfo() to set the text at a later time. * The fix is to insert the item with some text. * * Feature in Windows. When an empty string is used instead * of a space and InsertMenuItem() is used to set a submenu * before setting text to a non-empty string, the menu item * becomes unexpectedly disabled. The fix is to insert a * space. */ auto hHeap = OS.GetProcessHeap (); TCHAR[] buffer = StrToTCHARs (0, " \0"); int byteCount = (buffer.length-1) * TCHAR.sizeof; auto pszText = cast(TCHAR*) OS.HeapAlloc (hHeap, OS.HEAP_ZERO_MEMORY, byteCount); OS.MoveMemory (pszText, buffer.ptr, byteCount); MENUITEMINFO info; info.cbSize = MENUITEMINFO.sizeof; info.fMask = OS.MIIM_ID | OS.MIIM_TYPE | OS.MIIM_DATA; info.wID = item.id; info.dwItemData = item.id; info.fType = item.widgetStyle (); info.dwTypeData = pszText; success = cast(bool) OS.InsertMenuItem (handle, index, true, &info); if (pszText !is null) OS.HeapFree (hHeap, 0, pszText); } } if (!success) { display.removeMenuItem (item); error (DWT.ERROR_ITEM_NOT_ADDED); } redraw (); } void createWidget () { /* * Bug in IBM JVM 1.3.1. For some reason, when the following code is called * from this method, the JVM issues this error: * * JVM Exception 0x2 (subcode 0x0) occurred in thread "main" (TID:0x9F19D8) * * In addition, on Windows XP, a dialog appears with following error message, * indicating that the problem may be in the JIT: * * AppName: java.exe AppVer: 0.0.0.0 ModName: jitc.dll * ModVer: 0.0.0.0 Offset: 000b6912 * * The fix is to move the code to the caller of this method. */ // checkOrientation (parent); createHandle (); parent.addMenu (this); } int defaultBackground () { return OS.GetSysColor (OS.COLOR_MENU); } int defaultForeground () { return OS.GetSysColor (OS.COLOR_MENUTEXT); } void destroyAccelerators () { parent.destroyAccelerators (); } void destroyItem (MenuItem item) { static if (OS.IsWinCE) { if ((OS.IsPPC || OS.IsSP) && hwndCB !is null) { if (OS.IsSP) { redraw(); return; } int index = OS.SendMessage (hwndCB, OS.TB_COMMANDTOINDEX, item.id, 0); if (OS.SendMessage (hwndCB, OS.TB_DELETEBUTTON, index, 0) is 0) { error (DWT.ERROR_ITEM_NOT_REMOVED); } int count = OS.SendMessage (hwndCB, OS.TB_BUTTONCOUNT, 0, 0); if (count is 0) { if (imageList !is null) { OS.SendMessage (handle, OS.TB_SETIMAGELIST, 0, 0); display.releaseImageList (imageList); imageList = null; } } } else { int index = 0; MENUITEMINFO info; info.cbSize = MENUITEMINFO.sizeof; info.fMask = OS.MIIM_DATA; while (OS.GetMenuItemInfo (handle, index, true, &info)) { if (info.dwItemData is item.id) break; index++; } if (info.dwItemData !is item.id) { error (DWT.ERROR_ITEM_NOT_REMOVED); } if (!OS.DeleteMenu (handle, index, OS.MF_BYPOSITION)) { error (DWT.ERROR_ITEM_NOT_REMOVED); } } } else { if (!OS.DeleteMenu (handle, item.id, OS.MF_BYCOMMAND)) { error (DWT.ERROR_ITEM_NOT_REMOVED); } } redraw (); } override void destroyWidget () { MenuItem cascade = this.cascade; HMENU hMenu = handle; HWND hCB = hwndCB; releaseHandle (); static if (OS.IsWinCE) { if( hCB !is null ){ OS.CommandBar_Destroy (hCB); } } else { if (cascade !is null) { if (!OS.IsSP) cascade.setMenu (null, true); } else { if (hMenu !is null) OS.DestroyMenu (hMenu); } } } void fixMenus (Decorations newParent) { MenuItem [] items = getItems (); for (int i=0; i<items.length; i++) { items [i].fixMenus (newParent); } parent.removeMenu (this); newParent.addMenu (this); this.parent = newParent; } /** * Returns the receiver's background color. * * @return the background color * * @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 3.3 */ /*public*/ Color getBackground () { checkWidget (); return Color.win32_new (display, background !is -1 ? background : defaultBackground ()); } /** * Returns the receiver's background image. * * @return the background image * * @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 3.3 */ /*public*/ Image getBackgroundImage () { checkWidget (); return backgroundImage; } /** * Returns a rectangle describing the receiver's size and location * relative to its parent (or its display if its parent is null), * unless the receiver is a menu or a shell. In this case, the * location is relative to the display. * <p> * Note that the bounds of a menu or menu item are undefined when * the menu is not visible. This is because most platforms compute * the bounds of a menu dynamically just before it is displayed. * </p> * * @return the receiver's bounding rectangle * * @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 3.1 */ /*public*/ Rectangle getBounds () { checkWidget (); static if (OS.IsWinCE) return new Rectangle (0, 0, 0, 0); if ((style & DWT.BAR) !is 0) { if (parent.menuBar !is this) { return new Rectangle (0, 0, 0, 0); } auto hwndShell = parent.handle; MENUBARINFO info; info.cbSize = MENUBARINFO.sizeof; if (OS.GetMenuBarInfo (hwndShell, OS.OBJID_MENU, 0, &info)) { int width = info.rcBar.right - info.rcBar.left; int height = info.rcBar.bottom - info.rcBar.top; return new Rectangle (info.rcBar.left, info.rcBar.top, width, height); } } else { int count = GetMenuItemCount (handle); if (count !is 0) { RECT rect1; if (OS.GetMenuItemRect (null, handle, 0, &rect1)) { RECT rect2; if (OS.GetMenuItemRect (null, handle, count - 1, &rect2)) { int x = rect1.left - 2, y = rect1.top - 2; int width = (rect2.right - rect2.left) + 4; int height = (rect2.bottom - rect1.top) + 4; return new Rectangle (x, y, width, height); } } } } return new Rectangle (0, 0, 0, 0); } /** * Returns the default menu item or null if none has * been previously set. * * @return the default menu item. * * </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 MenuItem getDefaultItem () { checkWidget (); static if (OS.IsWinCE) return null; int id = OS.GetMenuDefaultItem (handle, OS.MF_BYCOMMAND, OS.GMDI_USEDISABLED); if (id is -1) return null; MENUITEMINFO info; info.cbSize = MENUITEMINFO.sizeof; info.fMask = OS.MIIM_ID; if (OS.GetMenuItemInfo (handle, id, false, &info)) { return display.getMenuItem (info.wID); } return null; } /** * Returns <code>true</code> if the receiver is enabled, and * <code>false</code> otherwise. A disabled menu is typically * not selectable from the user interface and draws with an * inactive or "grayed" look. * * @return the receiver's enabled state * * @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 #isEnabled */ public bool getEnabled () { checkWidget (); return (state & DISABLED) is 0; } /** * Returns the foreground color that the receiver will use to draw. * * @return the receiver's foreground color * * @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*/ Color getForeground () { checkWidget (); return Color.win32_new (display, foreground !is -1 ? foreground : defaultForeground ()); } /** * 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 MenuItem getItem (int index) { checkWidget (); int id = 0; if ((OS.IsPPC || OS.IsSP) && hwndCB !is null) { static if (OS.IsPPC) { TBBUTTON lpButton; int result = OS.SendMessage (hwndCB, OS.TB_GETBUTTON, index, &lpButton); if (result is 0) error (DWT.ERROR_CANNOT_GET_ITEM); id = lpButton.idCommand; } if (OS.IsSP) { if (!(0 <= index && index <= 1)) error (DWT.ERROR_CANNOT_GET_ITEM); id = index is 0 ? id0 : id1; } } else { MENUITEMINFO info; info.cbSize = MENUITEMINFO.sizeof; info.fMask = OS.MIIM_DATA; if (!OS.GetMenuItemInfo (handle, index, true, &info)) { error (DWT.ERROR_INVALID_RANGE); } id = info.dwItemData; } return display.getMenuItem (id); } /** * 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 (); return GetMenuItemCount (handle); } /** * Returns a (possibly empty) array of <code>MenuItem</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 * * @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 MenuItem [] getItems () { checkWidget (); if ((OS.IsPPC || OS.IsSP) && hwndCB !is null) { if (OS.IsSP) { MenuItem [] result = new MenuItem [2]; result[0] = display.getMenuItem (id0); result[1] = display.getMenuItem (id1); return result; } int count = OS.SendMessage (hwndCB, OS.TB_BUTTONCOUNT, 0, 0); TBBUTTON lpButton; MenuItem [] result = new MenuItem [count]; for (int i=0; i<count; i++) { OS.SendMessage (hwndCB, OS.TB_GETBUTTON, i, &lpButton); result [i] = display.getMenuItem (lpButton.idCommand); } return result; } int index = 0, count = 0; int length = OS.IsWinCE ? 4 : OS.GetMenuItemCount (handle); MenuItem [] items = new MenuItem [length]; MENUITEMINFO info; info.cbSize = MENUITEMINFO.sizeof; info.fMask = OS.MIIM_DATA; while (OS.GetMenuItemInfo (handle, index, true, &info)) { if (count is items.length) { MenuItem [] newItems = new MenuItem [count + 4]; System.arraycopy (items, 0, newItems, 0, count); items = newItems; } MenuItem item = display.getMenuItem (info.dwItemData); if (item !is null) items [count++] = item; index++; } if (count is items.length) return items; MenuItem [] result = new MenuItem [count]; System.arraycopy (items, 0, result, 0, count); return result; } int GetMenuItemCount (HANDLE handle) { static if (OS.IsWinCE) { if ((OS.IsPPC || OS.IsSP) && hwndCB !is null) { return OS.IsSP ? 2 : OS.SendMessage (hwndCB, OS.TB_BUTTONCOUNT, 0, 0); } int count = 0; MENUITEMINFO info; info.cbSize = MENUITEMINFO.sizeof; while (OS.GetMenuItemInfo (handle, count, true, &info)) count++; return count; } return OS.GetMenuItemCount (handle); } override String getNameText () { String result = ""; MenuItem [] items = getItems (); int length_ = items.length; if (length_ > 0) { for (int i=0; i<length_-1; i++) { result = result ~ items [i].getNameText() ~ ", "; } result = result ~ items [length_-1].getNameText (); } return result; } /** * Returns the receiver's parent, which must be a <code>Decorations</code>. * * @return the receiver's parent * * @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 Decorations getParent () { checkWidget (); return parent; } /** * Returns the receiver's parent item, which must be a * <code>MenuItem</code> or null when the receiver is a * root. * * @return the receiver's parent 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 MenuItem getParentItem () { checkWidget (); return cascade; } /** * Returns the receiver's parent item, which must be a * <code>Menu</code> or null when the receiver is a * root. * * @return the receiver's parent 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 Menu getParentMenu () { checkWidget (); if (cascade !is null) return cascade.parent; return null; } /** * Returns the receiver's shell. For all controls other than * shells, this simply returns the control's nearest ancestor * shell. Shells return themselves, even if they are children * of other shells. * * @return the receiver's shell * * @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 #getParent */ public Shell getShell () { checkWidget (); return parent.getShell (); } /** * Returns <code>true</code> if the receiver is visible, and * <code>false</code> otherwise. * <p> * If one of the receiver's ancestors is not visible or some * other condition makes the receiver not visible, this method * may still indicate that it is considered visible even though * it may not actually be showing. * </p> * * @return the receiver's visibility state * * @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 bool getVisible () { checkWidget (); if ((style & DWT.BAR) !is 0) { return this is parent.menuShell ().menuBar; } if ((style & DWT.POP_UP) !is 0) { Menu [] popups = display.popups; if (popups is null) return false; for (int i=0; i<popups.length; i++) { if (popups [i] is this) return true; } } Shell shell = getShell (); Menu menu = shell.activeMenu; while (menu !is null && menu !is this) { menu = menu.getParentMenu (); } return this is menu; } int imageIndex (Image image) { if (hwndCB is null || image is null) return OS.I_IMAGENONE; if (imageList is null) { Rectangle bounds = image.getBounds (); imageList = display.getImageList (style & DWT.RIGHT_TO_LEFT, bounds.width, bounds.height); int index = imageList.add (image); HANDLE hImageList = imageList.getHandle (); OS.SendMessage (hwndCB, OS.TB_SETIMAGELIST, 0, hImageList); return index; } int index = imageList.indexOf (image); if (index is -1) { index = imageList.add (image); } else { imageList.put (index, image); } return index; } /** * Searches the receiver's list starting at the first item * (index 0) until an item is found that is equal to the * argument, and returns the index of that item. If no item * is found, returns -1. * * @param item the search item * @return the index of the item * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the item 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> */ public int indexOf (MenuItem item) { checkWidget (); if (item is null) error (DWT.ERROR_NULL_ARGUMENT); if (item.isDisposed()) error(DWT.ERROR_INVALID_ARGUMENT); if (item.parent !is this) return -1; if ((OS.IsPPC || OS.IsSP) && hwndCB !is null) { if (OS.IsPPC) { return OS.SendMessage (hwndCB, OS.TB_COMMANDTOINDEX, item.id, 0); } if (OS.IsSP) { if (item.id is id0) return 0; if (item.id is id1) return 1; return -1; } } int index = 0; MENUITEMINFO info; info.cbSize = MENUITEMINFO.sizeof; info.fMask = OS.MIIM_DATA; while (OS.GetMenuItemInfo (handle, index, true, &info)) { if (info.dwItemData is item.id) return index; index++; } return -1; } /** * Returns <code>true</code> if the receiver is enabled and all * of the receiver's ancestors are enabled, and <code>false</code> * otherwise. A disabled menu is typically not selectable from the * user interface and draws with an inactive or "grayed" look. * * @return the receiver's enabled state * * @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 #getEnabled */ public bool isEnabled () { checkWidget (); Menu parentMenu = getParentMenu (); if (parentMenu is null) { return getEnabled () && parent.isEnabled (); } return getEnabled () && parentMenu.isEnabled (); } /** * Returns <code>true</code> if the receiver is visible and all * of the receiver's ancestors are visible and <code>false</code> * otherwise. * * @return the receiver's visibility state * * @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 #getVisible */ public bool isVisible () { checkWidget (); return getVisible (); } void redraw () { if (!isVisible ()) return; if ((style & DWT.BAR) !is 0) { display.addBar (this); } else { update (); } } override void releaseHandle () { super.releaseHandle (); handle = null; cascade = null; } override void releaseChildren (bool destroy) { MenuItem [] items = getItems (); for (int i=0; i<items.length; i++) { MenuItem item = items [i]; if (item !is null && !item.isDisposed ()) { if (OS.IsPPC && hwndCB !is null) { item.dispose (); } else { item.release (false); } } } super.releaseChildren (destroy); } override void releaseParent () { super.releaseParent (); if ((style & DWT.BAR) !is 0) { display.removeBar (this); if (this is parent.menuBar) { parent.setMenuBar (null); } } else { if ((style & DWT.POP_UP) !is 0) { display.removePopup (this); } } } override void releaseWidget () { super.releaseWidget (); backgroundImage = null; if (hBrush is null) OS.DeleteObject (hBrush); hBrush = null; if (OS.IsPPC && hwndCB !is null) { if (imageList !is null) { OS.SendMessage (hwndCB, OS.TB_SETIMAGELIST, 0, 0); display.releaseToolImageList (imageList); imageList = null; } } if (parent !is null) parent.removeMenu (this); parent = null; } /** * Removes the listener from the collection of listeners who will * be notified when the help events are generated for the control. * * @param listener the listener which should no longer 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 HelpListener * @see #addHelpListener */ public void removeHelpListener (HelpListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.Help, listener); } /** * Removes the listener from the collection of listeners who will * be notified when the menu events are generated for the control. * * @param listener the listener which should no longer 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 MenuListener * @see #addMenuListener */ public void removeMenuListener (MenuListener listener) { checkWidget (); if (listener is null) error (DWT.ERROR_NULL_ARGUMENT); if (eventTable is null) return; eventTable.unhook (DWT.Hide, listener); eventTable.unhook (DWT.Show, listener); } /** * Sets the receiver's background color to the color specified * by the argument, or to the default system color for the control * 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 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 3.3 */ /*public*/ void setBackground (Color color) { checkWidget (); int pixel = -1; if (color !is null) { if (color.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT); pixel = color.handle; } if (pixel is background) return; background = pixel; updateBackground (); } /** * Sets the receiver's background image to the image specified * by the argument, or to the default system color for the control * if the argument is null. The background image is tiled to fill * the available space. * * @param image the new image (or null) * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> * <li>ERROR_INVALID_ARGUMENT - if the argument is not a bitmap</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> * * @since 3.3 */ /*public*/ void setBackgroundImage (Image image) { checkWidget (); if (image !is null) { if (image.isDisposed ()) error (DWT.ERROR_INVALID_ARGUMENT); if (image.type !is DWT.BITMAP) error (DWT.ERROR_INVALID_ARGUMENT); } if (backgroundImage is image) return; backgroundImage = image; updateBackground (); } /** * Sets the receiver's foreground color to the color specified * by the argument, or to the default system color for the control * 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 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 3.3 */ /*public*/ void setForeground (Color color) { checkWidget (); int pixel = -1; if (color !is null) { if (color.isDisposed()) DWT.error(DWT.ERROR_INVALID_ARGUMENT); pixel = color.handle; } if (pixel is foreground) return; foreground = pixel; updateForeground (); } /** * Sets the default menu item to the argument or removes * the default emphasis when the argument is <code>null</code>. * * @param item the default menu item or null * * @exception IllegalArgumentException <ul> * <li>ERROR_INVALID_ARGUMENT - if the menu item has been disposed</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 void setDefaultItem (MenuItem item) { checkWidget (); int newID = -1; if (item !is null) { if (item.isDisposed()) error(DWT.ERROR_INVALID_ARGUMENT); if (item.parent !is this) return; newID = item.id; } static if (OS.IsWinCE) return; int oldID = OS.GetMenuDefaultItem (handle, OS.MF_BYCOMMAND, OS.GMDI_USEDISABLED); if (newID is oldID) return; OS.SetMenuDefaultItem (handle, newID, OS.MF_BYCOMMAND); redraw (); } /** * Enables the receiver if the argument is <code>true</code>, * and disables it otherwise. A disabled menu is typically * not selectable from the user interface and draws with an * inactive or "grayed" look. * * @param enabled the new enabled state * * @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 setEnabled (bool enabled) { checkWidget (); state &= ~DISABLED; if (!enabled) state |= DISABLED; } /** * Sets the location of the receiver, which must be a popup, * to the point specified by the arguments which are relative * to the display. * <p> * Note that this is different from most widgets where the * location of the widget is relative to the parent. * </p><p> * Note that the platform window manager ultimately has control * over the location of popup menus. * </p> * * @param x the new x coordinate for the receiver * @param y the new y coordinate for 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 setLocation (int x, int y) { checkWidget (); if ((style & (DWT.BAR | DWT.DROP_DOWN)) !is 0) return; this.x = x; this.y = y; hasLocation = true; } /** * Sets the location of the receiver, which must be a popup, * to the point specified by the argument which is relative * to the display. * <p> * Note that this is different from most widgets where the * location of the widget is relative to the parent. * </p><p> * Note that the platform window manager ultimately has control * over the location of popup menus. * </p> * * @param location the new location for the receiver * * @exception IllegalArgumentException <ul> * <li>ERROR_NULL_ARGUMENT - if the point 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> * * @since 2.1 */ public void setLocation (Point location) { checkWidget (); if (location is null) DWT.error (DWT.ERROR_NULL_ARGUMENT); setLocation (location.x, location.y); } /** * Marks the receiver as visible if the argument is <code>true</code>, * and marks it invisible otherwise. * <p> * If one of the receiver's ancestors is not visible or some * other condition makes the receiver not visible, marking * it visible may not actually cause it to be displayed. * </p> * * @param visible the new visibility state * * @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 setVisible (bool visible) { checkWidget (); if ((style & (DWT.BAR | DWT.DROP_DOWN)) !is 0) return; if (visible) { display.addPopup (this); } else { display.removePopup (this); _setVisible (false); } } void update () { if (OS.IsPPC || OS.IsSP) return; static if (OS.IsHPC) { /* * Each time a menu has been modified, the command menu bar * must be redrawn or it won't update properly. For example, * a submenu will not drop down. */ Menu menuBar = parent.menuBar; if (menuBar !is null) { Menu menu = this; while (menu !is null && menu !is menuBar) { menu = menu.getParentMenu (); } if (menu is menuBar) { OS.CommandBar_DrawMenuBar (menuBar.hwndCB, 0); OS.CommandBar_Show (menuBar.hwndCB, true); } } return; } static if (OS.IsWinCE) return; if ((style & DWT.BAR) !is 0) { if (this is parent.menuBar) OS.DrawMenuBar (parent.handle); return; } if (OS.WIN32_VERSION < OS.VERSION (4, 10)) { return; } bool hasCheck = false, hasImage = false; MenuItem [] items = getItems (); for (int i=0; i<items.length; i++) { MenuItem item = items [i]; if (item.image !is null) { hasImage = true; if (hasCheck) break; } if ((item.style & (DWT.CHECK | DWT.RADIO)) !is 0) { hasCheck = true; if ( hasImage) break; } } /* * Bug in Windows. If a menu contains items that have * images and can be checked, Windows does not include * the width of the image and the width of the check when * computing the width of the menu. When the longest item * does not have an image, the label and the accelerator * text can overlap. The fix is to use SetMenuItemInfo() * to indicate that all items have a bitmap and then include * the width of the widest bitmap in WM_MEASURECHILD. * * NOTE: This work around causes problems on Windows 98. * Under certain circumstances that have yet to be isolated, * some menus can become huge and blank. For now, do not * run the code on Windows 98. * * NOTE: This work around doesn't run on Vista because * WM_MEASURECHILD and WM_DRAWITEM cause Vista to lose * the menu theme. */ if (!OS.IsWin95) { if (OS.WIN32_VERSION < OS.VERSION (6, 0)) { MENUITEMINFO info; info.cbSize = MENUITEMINFO.sizeof; info.fMask = OS.MIIM_BITMAP; for (int i=0; i<items.length; i++) { MenuItem item = items [i]; if ((style & DWT.SEPARATOR) is 0) { if (item.image is null || foreground !is -1) { info.hbmpItem = hasImage || foreground !is -1 ? OS.HBMMENU_CALLBACK : null; OS.SetMenuItemInfo (handle, item.id, false, &info); } } } } } /* Update the menu to hide or show the space for bitmaps */ MENUINFO lpcmi; lpcmi.cbSize = MENUINFO.sizeof; lpcmi.fMask = OS.MIM_STYLE; OS.GetMenuInfo (handle, &lpcmi); if (hasImage && !hasCheck) { lpcmi.dwStyle |= OS.MNS_CHECKORBMP; } else { lpcmi.dwStyle &= ~OS.MNS_CHECKORBMP; } OS.SetMenuInfo (handle, &lpcmi); } void updateBackground () { if (hBrush is null) OS.DeleteObject (hBrush); hBrush = null; if (backgroundImage !is null) { hBrush = OS.CreatePatternBrush (backgroundImage.handle); } else { if (background !is -1) hBrush = OS.CreateSolidBrush (background); } MENUINFO lpcmi; lpcmi.cbSize = MENUINFO.sizeof; lpcmi.fMask = OS.MIM_BACKGROUND; lpcmi.hbrBack = hBrush; OS.SetMenuInfo (handle, &lpcmi); } void updateForeground () { if (OS.WIN32_VERSION < OS.VERSION (4, 10)) return; MENUITEMINFO info; info.cbSize = MENUITEMINFO.sizeof; int index = 0; while (OS.GetMenuItemInfo (handle, index, true, &info)) { info.fMask = OS.MIIM_BITMAP; info.hbmpItem = OS.HBMMENU_CALLBACK; OS.SetMenuItemInfo (handle, index, true, &info); index++; } redraw (); } }