/* AbiSource Program Utilities
* Copyright (C) 1998 AbiSource, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
/*
In versions previous to Windows Vista we use owner-draw menus.
In Vista we use SetMenuItemBitmaps that is more powerful that previous Windows editions
*/
#include <wchar.h>
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include "ut_types.h"
#include "ut_stack.h"
#include "ut_string.h"
#include "ut_string_class.h"
#include "ut_debugmsg.h"
#include "ut_Language.h"
#include "xap_Types.h"
#include "ev_Win32Menu.h"
#include "xap_Win32App.h"
#include "ev_Menu_Layouts.h"
#include "ev_Menu_Actions.h"
#include "ev_Menu_Labels.h"
#include "ev_EditEventMapper.h"
#include "xap_Frame.h"
#include "ap_Win32Resources.rc2"
#include "ap_Menu_Id.h"
#include "xap_App.h"
#include "xap_Win32App.h"
#include "xap_Win32Toolbar_Icons.h"
#include "ap_Win32App.h"
#include "ut_Win32OS.h"
#include "ut_Win32LocaleString.h"
#define SPACE_ICONTEXT 4 // Pixels between the icon and the text
#define BITMAP_WITDH 16
#define BITMAP_HEIGHT 16
/*
This table assigns an icon to every menu entry
*/
static const EV_Menu_Bitmap s_bitmaps[] =
{
// File
{AP_MENU_ID_FILE_CLOSE, "Menu_AbiWord_Close"},
{AP_MENU_ID_FILE_EXIT, "Menu_AbiWord_Exit"},
{AP_MENU_ID_FILE_EXPORT, "Menu_AbiWord_Export"},
{AP_MENU_ID_FILE_IMPORT, "Menu_AbiWord_Import"},
{AP_MENU_ID_FILE_NEW, "Menu_AbiWord_New"},
{AP_MENU_ID_FILE_OPEN, "Menu_AbiWord_Open"},
{AP_MENU_ID_FILE_PRINT, "Menu_AbiWord_Print"},
{AP_MENU_ID_FILE_SAVE, "Menu_AbiWord_Save"},
{AP_MENU_ID_FILE_SAVEAS, "Menu_AbiWord_SaveAs"},
{AP_MENU_ID_FILE_REVERT, "Menu_AbiWord_Revert"},
{AP_MENU_ID_FILE_PROPERTIES, "Menu_AbiWord_Properties"},
{AP_MENU_ID_FILE_PAGESETUP, "Menu_AbiWord_Print_Setup"},
// Edit
{AP_MENU_ID_EDIT_PASTE, "Menu_AbiWord_Paste"},
{AP_MENU_ID_EDIT_CUT, "Menu_AbiWord_Cut"},
{AP_MENU_ID_EDIT_COPY, "Menu_AbiWord_Copy"},
{AP_MENU_ID_EDIT_UNDO, "Menu_AbiWord_Undo"},
{AP_MENU_ID_EDIT_REDO, "Menu_AbiWord_Redo"},
{AP_MENU_ID_EDIT_PASTE_SPECIAL, "Menu_AbiWord_Paste"},
{AP_MENU_ID_EDIT_CLEAR, "Menu_AbiWord_Clear"},
{AP_MENU_ID_EDIT_FIND, "Menu_AbiWord_Search"},
{AP_MENU_ID_EDIT_REPLACE, "Menu_AbiWord_Replace"},
{AP_MENU_ID_EDIT_GOTO, "Menu_AbiWord_Goto"},
// Insert
{AP_MENU_ID_INSERT_SYMBOL, "Menu_AbiWord_Insert_Symbol"},
{AP_MENU_ID_INSERT_GRAPHIC, "Menu_AbiWord_Img"},
{AP_MENU_ID_INSERT_HYPERLINK, "Menu_AbiWord_Hyperlink"},
// Format
{AP_MENU_ID_FMT_FONT, "Menu_AbiWord_Font"},
{AP_MENU_ID_TABLE_INSERT_TABLE, "Menu_AbiWord_Insert_Table"},
{AP_MENU_ID_TOOLS_SPELL, "Menu_AbiWord_Spellcheck"},
{AP_MENU_ID_TOOLS_OPTIONS, "Menu_AbiWord_Preferences"},
{AP_MENU_ID_TOOLS_SCRIPTS, "Menu_AbiWord_Execute"},
{AP_MENU_ID_TOOLS_LANGUAGE, "Menu_AbiWord_Book"},
{AP_MENU_ID_FMT_LANGUAGE, "Menu_AbiWord_Book"},
// Table
{AP_MENU_ID_TABLE_INSERT_TABLE, "Menu_AbiWord_Insert_Table"},
{AP_MENU_ID_TABLE_DELETE_TABLE, "Menu_AbiWord_Delete_Table"},
{AP_MENU_ID_TABLE_INSERTTABLE, "Menu_AbiWord_Insert_Table"},
{AP_MENU_ID_TABLE_DELETETABLE, "Menu_AbiWord_Delete_Table"},
{AP_MENU_ID_TABLE_MERGE_CELLS, "Menu_AbiWord_Merge_Cells"},
{AP_MENU_ID_TABLE_SPLIT_CELLS, "Menu_AbiWord_Split_Cells"},
{AP_MENU_ID_TABLE_INSERTCOLUMN, "Menu_AbiWord_Add_Column"},
{AP_MENU_ID_TABLE_INSERTROW, "Menu_AbiWord_Add_Row"},
{AP_MENU_ID_TABLE_DELETECOLUMN, "Menu_AbiWord_Delete_Column"},
{AP_MENU_ID_TABLE_DELETEROW, "Menu_AbiWord_Delete_Row"},
{AP_MENU_ID_TABLE_DELETE_COLUMNS, "Menu_AbiWord_Delete_Column"},
{AP_MENU_ID_TABLE_DELETE_ROWS, "Menu_AbiWord_Delete_Row"},
// Help
{AP_MENU_ID_HELP_SEARCH, "Menu_AbiWord_Search"},
{AP_MENU_ID_HELP_ABOUT, "Menu_AbiWord_About"},
{AP_MENU_ID_HELP_CREDITS, "Menu_AbiWord_Credits"},
{0, NULL}
};
/*
*/
static const wchar_t * _ev_GetLabelName(XAP_Win32App * pWin32App,
XAP_Frame * /*pFrame*/,
const EV_EditEventMapper * pEEM,
const EV_Menu_Action * pAction,
EV_Menu_Label * pLabel)
{
const wchar_t * szLabelName;
const char * szLabelName_utf8;
if (pAction->hasDynamicLabel())
szLabelName_utf8 = pAction->getDynamicLabel(pLabel);
else
szLabelName_utf8 = pLabel->getMenuLabel();
if (!szLabelName_utf8 || !*szLabelName_utf8)
return NULL;
UT_Win32LocaleString str;
str.fromUTF8 (szLabelName_utf8);
szLabelName = str.c_str();
const char * szShortcut_ascii = NULL;
const wchar_t * szShortcut = NULL;
UT_Win32LocaleString shortcut;
int len = 0;
if (pEEM)
{
// see if this has an associated keybinding
const char * szMethodName = pAction->getMethodName();
if (szMethodName)
{
const EV_EditMethodContainer * pEMC = pWin32App->getEditMethodContainer();
UT_return_val_if_fail(pEMC, NULL);
EV_EditMethod * pEM = pEMC->findEditMethodByName(szMethodName);
UT_ASSERT(pEM); // make sure it's bound to something
szShortcut_ascii = pEEM->getShortcutFor(pEM);
if (szShortcut_ascii && *szShortcut_ascii)
len = strlen(szShortcut_ascii) + 1; // extra char is for the tab
}
}
if (szShortcut && *szShortcut) {
shortcut.fromASCII (szShortcut_ascii);
}
if (pAction->raisesDialog())
len += 4;
if (!len)
{
static wchar_t buf[128];
wcscpy(buf,szLabelName);
return buf;
}
static wchar_t buf[128];
int l = G_N_ELEMENTS(buf);
memset(buf,0,l);
wcscpy(buf,szLabelName); //strncpy
// append "..." to menu item if it raises a dialog
if (pAction->raisesDialog())
wcscat(buf, L"..."); //todo
// append shortcut mnemonic, if any
if (shortcut.length())
{
wcscat(buf, L"\t"); //todo
wcscat(buf, shortcut.c_str());
}
return buf;
}
/*****************************************************************/
EV_Win32Menu::EV_Win32Menu(XAP_Win32App * pWin32App,
const EV_EditEventMapper * pEEM,
const char * szMenuLayoutName,
const char * szMenuLabelSetName)
: EV_Menu(pWin32App, pWin32App->getEditMethodContainer(), szMenuLayoutName, szMenuLabelSetName),
m_pWin32App(pWin32App),
m_pEEM(pEEM),
m_myMenu(NULL),
m_iDIR(0)
{
NONCLIENTMETRICSA ncm;
ncm.cbSize = sizeof (NONCLIENTMETRICSA);
m_bTrack = false;
SystemParametersInfoA(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICSA), &ncm, 0);
m_hFont = CreateFontIndirectA(&ncm.lfMenuFont);
m_nBitmapCX = BITMAP_WITDH + 2;
m_nBitmapCY = BITMAP_HEIGHT + 2;
UT_return_if_fail( m_pMenuLabelSet );
UT_Language l;
if(l.getDirFromCode(m_pMenuLabelSet->getLanguage()) == UTLANG_RTL)
m_iDIR = DT_RTLREADING;
}
void EV_Win32Menu::destroy()
{
UT_VECTOR_PURGEALL(EV_Menu_Item*,m_vecItems);
if (m_myMenu)
{
DestroyMenu(m_myMenu);
m_myMenu = 0;
}
if (m_hFont)
DeleteObject(m_hFont);
}
EV_Win32Menu::~EV_Win32Menu()
{
// we let the derived classes handle destruction of m_myMenu if appropriate.
// TODO: this is never colld
for (std::vector<HBITMAP>::const_iterator i = m_vechBitmaps.begin();
i != m_vechBitmaps.end(); i++)
{
DeleteObject (*i);
}
}
bool EV_Win32Menu::onCommand(AV_View * pView,
HWND /*hWnd*/, WPARAM wParam)
{
// TODO do we need the hWnd parameter....
// map the windows WM_COMMAND command-id into one of our XAP_Menu_Id.
// we don't need to range check it, getAction() will puke if it's
// out of range.
XAP_Menu_Id id = MenuIdFromWmCommand(LOWORD(wParam));
// user selected something from the menu.
// invoke the appropriate function.
// return true iff handled.
const EV_Menu_ActionSet * pMenuActionSet = m_pWin32App->getMenuActionSet();
UT_return_val_if_fail(pMenuActionSet, false);
const EV_Menu_Action * pAction = pMenuActionSet->getAction(id);
if (!pAction)
return false;
const char * szMethodName = pAction->getMethodName();
UT_return_val_if_fail(szMethodName, false);
const EV_EditMethodContainer * pEMC = m_pWin32App->getEditMethodContainer();
UT_return_val_if_fail(pEMC, false);
EV_EditMethod * pEM = pEMC->findEditMethodByName(szMethodName);
UT_ASSERT(pEM); // make sure it's bound to something
UT_String script_name(pAction->getScriptName());
invokeMenuMethod(pView, pEM, script_name);
return true;
}
/*
Create a Win32 menu from the info provided.
*/
bool EV_Win32Menu::synthesizeMenu(XAP_Frame * pFrame, HMENU menuRoot)
{
bool bResult;
const EV_Menu_ActionSet * pMenuActionSet = m_pWin32App->getMenuActionSet();
UT_ASSERT(pMenuActionSet);
const UT_uint32 nrLabelItemsInLayout = m_pMenuLayout->getLayoutItemCount();
UT_ASSERT(nrLabelItemsInLayout > 0);
// we keep a stack of the submenus so that we can properly
// parent the menu items and deal with nested pull-rights.
UT_Stack stack;
stack.push(menuRoot);
//UT_DEBUGMSG(("Menu::synthesize [menuRoot 0x%08lx]\n",menuRoot));
for (UT_uint32 k=0; (k < nrLabelItemsInLayout); k++)
{
EV_Menu_LayoutItem * pLayoutItem = m_pMenuLayout->getLayoutItem(k);
UT_continue_if_fail(pLayoutItem);
XAP_Menu_Id id = pLayoutItem->getMenuId();
const EV_Menu_Action * pAction = pMenuActionSet->getAction(id);
UT_ASSERT(pAction);
EV_Menu_Label * pLabel = m_pMenuLabelSet->getLabel(id);
UT_ASSERT(pLabel);
// get the name for the menu item
const wchar_t * szLabelName = _ev_GetLabelName(m_pWin32App,pFrame,m_pEEM,pAction,pLabel);
switch (pLayoutItem->getMenuLayoutFlags())
{
case EV_MLF_BeginSubMenu:
UT_ASSERT(szLabelName && *szLabelName);
// Fall Thru Intended
case EV_MLF_Normal:
{
UT_DEBUGMSG(("menu::synthesize [name %s]\n",szLabelName));
HMENU m;
bResult = stack.viewTop((void **)&m);
UT_ASSERT(bResult);
// set standard flags on the item, we'll update the
// state on an onInitMenu().
// map our XAP_Menu_Id into a windows WM_COMMAND id.
UINT flags = MF_STRING | MF_ENABLED | MF_UNCHECKED;
UINT u = WmCommandFromMenuId(id);
/*
This a menu bar
*/
if (pLayoutItem->getMenuLayoutFlags() == EV_MLF_BeginSubMenu)
{
HMENU sub = CreateMenu(); // TODO NOTE: Leaking handle!
UT_ASSERT(sub);
UT_DEBUGMSG(("menu::synthesize [name %s][subMenu 0x%08lx] %u\n",szLabelName,u, stack.getDepth()));
flags |= MF_POPUP;
stack.push(sub);
u = (size_t) sub;
if (szLabelName && *szLabelName)
{
EV_Menu_Item* item = new EV_Menu_Item;
item->id = id;
item->pMenu= this;
wcscpy (item->szText, szLabelName);
m_vecItems.addItem(item);
if (!m_bTrack && stack.getDepth()==2)
AppendMenuW(m, flags,u, szLabelName);
else {
if (UT_IsWinVista()) {
AppendMenuW(m, flags|MF_STRING,u, szLabelName);
_setBitmapforID(m, id, u);
}
else
AppendMenuW(m, flags|MF_OWNERDRAW,u, (const wchar_t*) item);
}
}
}
else
{
if (szLabelName && *szLabelName)
{
EV_Menu_Item* item = new EV_Menu_Item;
item->id = id;
item->pMenu= this;
wcscpy (item->szText, szLabelName);
m_vecItems.addItem(item);
if (UT_IsWinVista()) { //todo: code for windows vista : investigate this
AppendMenuW(m, MF_STRING, u, szLabelName);
_setBitmapforID (m, id, u);
}
else
AppendMenuW(m, MF_OWNERDRAW, u, (const wchar_t*) item);
}
}
}
break;
case EV_MLF_EndSubMenu:
{
HMENU m = NULL;
bResult = stack.pop((void **)&m);
UT_ASSERT(bResult);
UT_DEBUGMSG(("menu::synthesize [endSubMenu 0x%08lx]\n",m));
}
break;
case EV_MLF_Separator:
{
HMENU m;
bResult = stack.viewTop((void **)&m);
UT_ASSERT(bResult);
UT_ASSERT(m);
AppendMenuW(m, MF_SEPARATOR, 0, NULL);
UT_DEBUGMSG(("menu::synthesize [separator appended to submenu 0x%08lx]\n",m));
}
break;
case EV_MLF_BeginPopupMenu:
case EV_MLF_EndPopupMenu:
break;
default:
UT_ASSERT_HARMLESS(0);
break;
}
}
#ifdef DEBUG
HMENU wDbg = NULL;
bResult = stack.pop((void **)&wDbg);
UT_ASSERT(bResult);
UT_ASSERT(wDbg == menuRoot);
#endif
return true;
}
bool EV_Win32Menu::onInitMenu(XAP_Frame * pFrame, AV_View * pView, HWND /*hWnd*/, HMENU hMenuBar)
{
// deal with WM_INITMENU.
if (hMenuBar != m_myMenu) // these are not different when they
return false; // right-click on us on the menu bar.
const EV_Menu_ActionSet * pMenuActionSet = m_pWin32App->getMenuActionSet();
UT_uint32 nrLabelItemsInLayout = m_pMenuLayout->getLayoutItemCount();
UT_uintptr pos = 0;
bool bResult;
UT_Stack stackPos;
stackPos.push((void*)pos);
UT_Stack stackMenu;
stackMenu.push(hMenuBar);
HMENU mTemp;
HMENU m = hMenuBar;
//UT_DEBUGMSG(("menu::onInitMenu: [menubar 0x%08lx]\n",m));
for (UT_uint32 k=0; (k < nrLabelItemsInLayout); k++)
{
EV_Menu_LayoutItem * pLayoutItem = m_pMenuLayout->getLayoutItem(k);
XAP_Menu_Id id = pLayoutItem->getMenuId();
const EV_Menu_Action * pAction = pMenuActionSet->getAction(id);
EV_Menu_Label * pLabel = m_pMenuLabelSet->getLabel(id);
UINT cmd = WmCommandFromMenuId(id);
switch (pLayoutItem->getMenuLayoutFlags())
{
case EV_MLF_Normal:
{
// see if we need to enable/disable and/or check/uncheck it.
UINT uEnable = MF_BYCOMMAND | MF_ENABLED;
UINT uCheck = MF_BYCOMMAND | MF_UNCHECKED;
UINT uBold = 0;
if (pAction->hasGetStateFunction())
{
EV_Menu_ItemState mis = pAction->getMenuItemState(pView);
if (mis & EV_MIS_Gray)
uEnable |= MF_GRAYED;
if (mis & EV_MIS_Toggled)
uCheck |= MF_CHECKED;
if (mis & EV_MIS_Bold)
uBold = MFS_DEFAULT;
}
if (!pAction->hasDynamicLabel())
{
// if no dynamic label, all we need to do
// is enable/disable and/or check/uncheck it.
pos++;
// need to check before disabling ...
CheckMenuItem(hMenuBar,cmd,uCheck);
EnableMenuItem(hMenuBar,cmd,uEnable);
break;
}
// get the current menu info for this item.
MENUITEMINFOW mif;
wchar_t bufMIF[128];
mif.cbSize = sizeof(mif);
mif.dwTypeData = bufMIF;
mif.cch = G_N_ELEMENTS(bufMIF)-1;
mif.fMask = MIIM_STATE | MIIM_TYPE | MIIM_ID;
BOOL bPresent = GetMenuItemInfoW(hMenuBar,cmd,FALSE,&mif);
// this item has a dynamic label...
// compute the value for the label.
// if it is blank, we remove the item from the menu.
const wchar_t * szLabelName = _ev_GetLabelName(m_pWin32App,pFrame,m_pEEM,pAction,pLabel);
BOOL bRemoveIt = (!szLabelName || !*szLabelName);
if (bRemoveIt) // we don't want it to be there
{
if (bPresent)
RemoveMenu(hMenuBar,cmd,MF_BYCOMMAND);
break;
}
// we want the item in the menu.
pos++;
if (bPresent) // just update the label on the item.
{
// dynamic label has changed
XAP_Menu_Id id = MenuIdFromWmCommand(cmd);
EV_Menu_Item* item;
for(UT_sint32 i = 0; i< m_vecItems.getItemCount(); i++)
{
item = (EV_Menu_Item*)m_vecItems.getNthItem(i);
if (id==item->id)
{
wcscpy (item->szText, szLabelName);
//UT_DEBUGMSG(("Menu changing text->%s\n",szLabelName));
if (UT_IsWinVista())
{
mif.fState = uCheck | uEnable | uBold;
mif.fType = MFT_STRING;
mif.dwTypeData = (LPWSTR)szLabelName;
SetMenuItemInfoW (hMenuBar,cmd,FALSE,&mif);
}
break;
}
}
}
else
{
EV_Menu_Item* item = new EV_Menu_Item;
item->id = id;
item->pMenu= this;
wcscpy (item->szText, szLabelName);
m_vecItems.addItem(item);
//UT_DEBUGMSG(("Menu adding menu->%s\n",szLabelName));
if (UT_IsWinVista()) {
AppendMenuW(m, MF_STRING, cmd, szLabelName);
_setBitmapforID(m, id, cmd);
}
else
AppendMenuW(m, MF_OWNERDRAW,cmd, (const wchar_t*) item);
}
EV_Menu_ItemState mis = pAction->getMenuItemState(pView);
if (mis & EV_MIS_Gray)
uEnable |= MF_GRAYED;
if (mis & EV_MIS_Toggled)
uCheck |= MF_CHECKED;
EnableMenuItem(m,cmd,uEnable);
CheckMenuItem(m,cmd,uCheck);
}
break;
case EV_MLF_Separator:
pos++;
break;
case EV_MLF_BeginSubMenu:
mTemp = m;
pos++;
stackMenu.push(mTemp);
stackPos.push((void*)pos);
m = GetSubMenu(mTemp, pos-1);
//UT_DEBUGMSG(("menu::onInitMenu: [menu 0x%08lx] at [pos %d] has [submenu 0x%08lx]\n",mTemp,pos-1,m));
//UT_ASSERT(m);
pos = 0;
break;
case EV_MLF_EndSubMenu:
bResult = stackMenu.pop((void **)&mTemp);
UT_ASSERT(bResult);
bResult = stackPos.pop((void **)&pos);
UT_ASSERT(bResult);
//UT_DEBUGMSG(("menu::onInitMenu: endSubMenu [popping to menu 0x%08lx pos %d] from 0x%08lx\n",mTemp,pos,m));
m = mTemp;
break;
case EV_MLF_BeginPopupMenu:
case EV_MLF_EndPopupMenu:
break;
default:
UT_ASSERT_HARMLESS(0);
break;
}
}
#ifdef DEBUG
HMENU wDbg = NULL;
bResult = stackMenu.pop((void **)&wDbg);
UT_ASSERT(bResult);
UT_ASSERT(wDbg == hMenuBar);
#endif
return true;
}
/*
Caller should DeleteObject the handle returned
*/
HBITMAP EV_Win32Menu::_loadBitmap(XAP_Menu_Id id, int width, int height, UT_RGBColor color)
{
HBITMAP hBitmap = NULL;
EV_Menu_Bitmap* pBitmaps = (EV_Menu_Bitmap*)&s_bitmaps;
for (; pBitmaps->id;pBitmaps++)
{
if (pBitmaps->id==id)
break;
}
if (!pBitmaps->id) return hBitmap;
if (!color.isTransparent())
XAP_Win32Toolbar_Icons::getBitmapForIcon(GetDesktopWindow(), width, height, &color, pBitmaps->szName, &hBitmap);
else XAP_Win32Toolbar_Icons::getAlphaBitmapForIcon(GetDesktopWindow(), width, height, pBitmaps->szName, &hBitmap);
return hBitmap;
}
// Sets the Bitmap in Windows Vista
void EV_Win32Menu::_setBitmapforID (HMENU hMenu, XAP_Menu_Id id, UINT cmd)
{
UT_RGBColor Color;
Color.m_bIsTransparent=true;
HBITMAP hBitmap = EV_Win32Menu::_loadBitmap(id, BITMAP_WITDH, BITMAP_HEIGHT, Color);
if (hBitmap != NULL) {
SetMenuItemBitmaps (hMenu, cmd, MF_BYCOMMAND, hBitmap, hBitmap);
m_vechBitmaps.push_back (hBitmap);
}
}
/*
It tells us which are menu bars
*/
bool EV_Win32Menu::_isAMenuBar(XAP_Menu_Id id, HMENU hMenu)
{
XAP_Menu_Id ids[] = { AP_MENU_ID_FILE, AP_MENU_ID_EDIT, AP_MENU_ID_VIEW,AP_MENU_ID_INSERT,
AP_MENU_ID_TOOLS, AP_MENU_ID_WINDOW, AP_MENU_ID_HELP,AP_MENU_ID_TABLE, AP_MENU_ID_FORMAT, NULL};
for (UT_uint32 i=0; i<(sizeof(ids)/sizeof(XAP_Menu_Id)); i++)
{
if (ids[i]==id)
{
MENUITEMINFOW menuInfo;
memset (&menuInfo, 0, sizeof(MENUITEMINFOW));
menuInfo.cbSize = sizeof(MENUITEMINFOW);
menuInfo.fMask = MIIM_DATA;
GetMenuItemInfoW(hMenu, 0, TRUE, &menuInfo);
EV_Menu_Item* item = (EV_Menu_Item *) menuInfo.dwItemData;
if (item && id==item->id)
{
UT_DEBUGMSG(("EV_Win32Menu::_isAMenuBar->%s, 1\n", item->szText));
return true;
}
}
}
UT_DEBUGMSG(("EV_Win32Menu::_isAMenuBar-> 0\n"));
return false;
}
/*
Process message WM_MEASUREITEM
*/
void EV_Win32Menu::onMeasureItem(HWND hwnd, WPARAM /*wParam*/, LPARAM lParam)
{
SIZE size;
LPMEASUREITEMSTRUCT lpmis = (LPMEASUREITEMSTRUCT) lParam;
HDC hdc = GetDC(hwnd);
EV_Menu_Item* item = (EV_Menu_Item *) lpmis->itemData;
HFONT hfontOld = (HFONT) SelectObject(hdc, m_hFont);
// Retrieve the width and height of the item's string
GetTextExtentPoint32W(hdc, item->szText, lstrlenW(item->szText), &size);
if (size.cy < item->pMenu->m_nBitmapCY)
lpmis->itemHeight = item->pMenu->m_nBitmapCY;
else
lpmis->itemHeight = size.cy;
lpmis->itemWidth = size.cx + item->pMenu->m_nBitmapCX + SPACE_ICONTEXT;
SelectObject(hdc, hfontOld);
ReleaseDC(hwnd, hdc);
}
/*
Process message WM_MENUCHAR. Process the hotkey messages
*/
LPARAM EV_Win32Menu::onMenuChar(HWND /*hwnd*/, WPARAM wParam, LPARAM lParam)
{
HMENU hMenu = (HMENU) lParam;
MENUITEMINFOW menuInfo;
int nItems = GetMenuItemCount(hMenu);
wchar_t szBuff[1024];
for (int i=0; i<nItems; i++)
{
memset (&menuInfo, 0, sizeof(MENUITEMINFOW));
menuInfo.cbSize = sizeof(MENUITEMINFOW);
menuInfo.fMask = MIIM_DATA;
GetMenuItemInfoW(hMenu, i, TRUE, &menuInfo);
EV_Menu_Item* item = (EV_Menu_Item *) menuInfo.dwItemData;
if (item)
{
wcscpy (szBuff, item->szText);
_wcslwr(szBuff);
wchar_t* pHotKeyPos = wcschr (szBuff, L'&');
if (pHotKeyPos)
{
wchar_t n = (wchar_t)wParam & 0x000000ff;
pHotKeyPos++;
if (toupper(*pHotKeyPos)==toupper(n))
return MAKELRESULT(i, MNC_EXECUTE);
}
}
}
return MNC_IGNORE;
}
/*
Process message WM_DRAWITEM
*/
void EV_Win32Menu::onDrawItem(HWND /*hwnd*/, WPARAM /*wParam*/, LPARAM lParam)
{
LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) lParam;
EV_Menu_Item* item = (EV_Menu_Item *) lpdis->itemData;
COLORREF crText;
COLORREF crBkgnd;
DWORD dwColor;
RECT rect;
HBITMAP hBitmap;
int colorID;
UT_ASSERT(lpdis->CtlType==ODT_MENU);
UT_Win32LocaleString sTextRight, sTextLeft;
/* Rect to draw the text */
rect.top = lpdis->rcItem.top;
rect.bottom = lpdis->rcItem.bottom;
if(m_iDIR)
{
rect.right = lpdis->rcItem.right - 20;
rect.left = lpdis->rcItem.left;
}
else
{
rect.right = lpdis->rcItem.right;
rect.left = /*m_nBitmapCX*/ 20 + lpdis->rcItem.left;
}
if (lpdis->itemState & ODS_GRAYED)
crText = SetTextColor(lpdis->hDC, GetSysColor(COLOR_GRAYTEXT));
else
if (lpdis->itemState & ODS_SELECTED)
crText = SetTextColor(lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
else
crText = SetTextColor(lpdis->hDC, GetSysColor(COLOR_MENUTEXT));
if (lpdis->itemState & ODS_SELECTED)
colorID = COLOR_HIGHLIGHT;
else
colorID = COLOR_MENU;
dwColor = GetSysColor(colorID);
UT_RGBColor Color(GetRValue(dwColor),GetGValue(dwColor),GetBValue(dwColor));
hBitmap = EV_Win32Menu::_loadBitmap(item->id, BITMAP_WITDH, BITMAP_HEIGHT, Color);
if (hBitmap)
{
BITMAP bitmap;
GetObjectA(hBitmap, sizeof(BITMAP), &bitmap);
}
/*Draw the background of the item*/
FillRect(lpdis->hDC, &lpdis->rcItem, GetSysColorBrush(colorID));
if(m_iDIR)
rect.right = rect.right - SPACE_ICONTEXT;
else
rect.left = rect.left;
// Select the font associated with the item into the
// item's device context, and then draw the string.
HFONT hfontOld = (HFONT) SelectObject(lpdis->hDC, item->pMenu->m_hFont);
/*
Process tabs
*/
wchar_t* pTabPos = wcschr (item->szText, L'\t');
if (pTabPos)
{
wchar_t szTmp[255];
wchar_t* pTmp;
wcsncpy (szTmp, item->szText, pTabPos-item->szText);
pTmp = szTmp; pTmp+=pTabPos-item->szText; *pTmp=NULL;
sTextLeft.fromLocale (szTmp);
wcscpy (szTmp, pTabPos+1);
sTextRight.fromLocale (szTmp);
sTextRight.appendASCII (" ");
}
else
sTextLeft.fromLocale (item->szText);
if (lpdis->itemState & ODS_SELECTED)
crBkgnd = SetBkColor(lpdis->hDC, GetSysColor(COLOR_HIGHLIGHT));
/* Draw text*/
if(m_iDIR)
{
DrawTextW(lpdis->hDC, sTextLeft.c_str(), sTextLeft.length() , &rect,
DT_RIGHT | DT_VCENTER | DT_SINGLELINE | m_iDIR);
if (sTextRight.length())
DrawTextW(lpdis->hDC, sTextRight.c_str(), sTextRight.length(), &rect,
DT_LEFT | DT_VCENTER | DT_SINGLELINE | m_iDIR);
}
else
{
DrawTextW(lpdis->hDC, sTextLeft.c_str(), sTextLeft.length() , &rect,
DT_LEFT | DT_VCENTER | DT_SINGLELINE | m_iDIR);
if (sTextRight.length())
DrawTextW(lpdis->hDC, sTextRight.c_str(), sTextRight.length(), &rect,
DT_RIGHT | DT_VCENTER | DT_SINGLELINE | m_iDIR);
}
if (lpdis->itemState & ODS_SELECTED)
SetBkColor(lpdis->hDC, crBkgnd);
/* Draw bitmap*/
if (hBitmap)
{
HDC hdcMem = CreateCompatibleDC(lpdis->hDC);
SelectObject(hdcMem,(void *)hBitmap);
if(m_iDIR)
BitBlt(lpdis->hDC, lpdis->rcItem.right - 20, lpdis->rcItem.top+1, BITMAP_WITDH, BITMAP_HEIGHT, hdcMem, 0, 0, SRCCOPY );
else
BitBlt(lpdis->hDC, lpdis->rcItem.left+1, lpdis->rcItem.top+1, BITMAP_WITDH, BITMAP_HEIGHT, hdcMem, 0, 0, SRCCOPY );
DeleteDC(hdcMem);
}
else
if (lpdis->itemState & ODS_CHECKED)
{
UINT nWidth = GetSystemMetrics(SM_CXMENUCHECK);
UINT nHeight = GetSystemMetrics(SM_CYMENUCHECK);
RECT r;
HBITMAP bm = CreateBitmap(nWidth, nHeight, 1, 1, NULL );
HDC hdcMem = CreateCompatibleDC(lpdis->hDC);
SetBkColor(lpdis->hDC, GetSysColor(colorID));
SelectObject(hdcMem, bm);
SetRect(&r, 0, 0, nWidth, nHeight);
DrawFrameControl(hdcMem, &r, DFC_MENU,DFCS_MENUCHECK);
if(m_iDIR)
BitBlt(lpdis->hDC, lpdis->rcItem.right - 20, lpdis->rcItem.top+2, nWidth, nHeight,
hdcMem, 0, 0, SRCCOPY);
else
BitBlt(lpdis->hDC, lpdis->rcItem.left+2, lpdis->rcItem.top+2, nWidth, nHeight,
hdcMem, 0, 0, SRCCOPY);
DeleteDC(hdcMem);
DeleteObject(bm);
}
SelectObject(lpdis->hDC, hfontOld);
SetTextColor(lpdis->hDC, crText);
if (hBitmap)
DeleteObject(hBitmap);
}
bool EV_Win32Menu::onMenuSelect(XAP_Frame * pFrame, AV_View * /*pView*/,
HWND /*hWnd*/, HMENU hMenu, WPARAM wParam)
{
UINT nItemID = (UINT)LOWORD(wParam);
UINT nFlags = (UINT)HIWORD(wParam);
if ( (nFlags==0xffff) && (hMenu==0) )
{
//UT_DEBUGMSG(("ClearMessage 1\n"));
pFrame->setStatusMessage(NULL);
return true;
}
if ( (nItemID==0) || (nFlags & (MF_SEPARATOR|MF_POPUP)) )
{
//UT_DEBUGMSG(("ClearMessage 2\n"));
pFrame->setStatusMessage(NULL);
return true;
}
if (nFlags & (MF_SYSMENU))
{
//UT_DEBUGMSG(("SysMenu [%x]\n",nItemID));
pFrame->setStatusMessage(NULL);
return true;
}
XAP_Menu_Id id = MenuIdFromWmCommand(nItemID);
EV_Menu_Label * pLabel = m_pMenuLabelSet->getLabel(id);
if (!pLabel)
{
//UT_DEBUGMSG(("ClearMessage 3 [%d %d]\n",nItemID,id));
pFrame->setStatusMessage(NULL);
return true;
}
const char * szMsg = pLabel->getMenuStatusMessage();
if (!szMsg || !*szMsg)
szMsg = "TODO This menu item doesn't have a StatusMessage defined.";
pFrame->setStatusMessage(szMsg);
return true;
}
/*****************************************************************/
/*****************************************************************/
EV_Win32MenuBar::EV_Win32MenuBar(XAP_Win32App * pWin32App,
const EV_EditEventMapper * pEEM,
const char * szMenuLayoutName,
const char * szMenuLabelSetName)
: EV_Win32Menu(pWin32App,pEEM,szMenuLayoutName,szMenuLabelSetName)
{
}
EV_Win32MenuBar::~EV_Win32MenuBar(void)
{
destroy();
// TODO should we destroy m_myMenu if set ??
}
bool EV_Win32MenuBar::synthesizeMenuBar(XAP_Frame * pFrame)
{
m_myMenu = CreateMenu();
bool bRet = synthesizeMenu(pFrame, m_myMenu);
// when dealing with RTL interface language, we need to tell do some tricks here to
// make the menubar to layout RTL
// see http://www.microsoft.com/middleeast/msdn/faq.aspx
MENUITEMINFOW mii;
wchar_t buff[81];
memset(buff, 0, 80 * sizeof (wchar_t));
buff[80] = 0;
mii.cbSize = sizeof(mii);
mii.dwTypeData = buff;
mii.fType = MF_STRING;
mii.cch = 80* sizeof (wchar_t);
mii.fState = MFS_DEFAULT;
mii.fMask = MIIM_ID | MIIM_DATA | MIIM_TYPE | MIIM_SUBMENU;
if(m_iDIR && GetMenuItemInfoW(m_myMenu, 0, 1, &mii))
{
mii.fType |= MFT_RIGHTORDER;
SetMenuItemInfoW(m_myMenu, 0, 1, &mii);
}
return bRet;
}
/*****************************************************************/
/*****************************************************************/
EV_Win32MenuPopup::EV_Win32MenuPopup(XAP_Win32App * pWin32App,
const char * szMenuLayoutName,
const char * szMenuLabelSetName)
: EV_Win32Menu(pWin32App,NULL,szMenuLayoutName,szMenuLabelSetName)
{
}
EV_Win32MenuPopup::~EV_Win32MenuPopup(void)
{
destroy();
if (m_myMenu)
DestroyMenu(m_myMenu);
}
bool EV_Win32MenuPopup::synthesizeMenuPopup(XAP_Frame * pFrame)
{
m_myMenu = CreatePopupMenu();
bool bRet = synthesizeMenu(pFrame, m_myMenu);
// when dealing with RTL interface language, we need to tell do some tricks here to
// make the menubar to layout RTL
// see http://www.microsoft.com/middleeast/msdn/faq.aspx
MENUITEMINFOW mii;
wchar_t buff[81];
memset(buff, 80 * sizeof (wchar_t), L' ');
buff[80* sizeof (wchar_t)] = 0;
mii.cbSize = sizeof(mii);
mii.dwTypeData = buff;
mii.fType = MF_STRING;
mii.cch = 80* sizeof (wchar_t);
mii.fState = MFS_DEFAULT;
mii.fMask = MIIM_ID | MIIM_DATA | MIIM_TYPE | MIIM_SUBMENU;
if(m_iDIR && GetMenuItemInfoW(m_myMenu, 0, 1, &mii))
{
mii.fType |= MFT_RIGHTORDER;
SetMenuItemInfoW(m_myMenu, 0, 1, &mii);
}
return bRet;
}