00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <os2win.h>
00023 #include <odin.h>
00024 #include <odinwrap.h>
00025 #include <stdlib.h>
00026 #include <string.h>
00027 #include <win32wbase.h>
00028 #include "oslibmenu.h"
00029 #include "oslibwin.h"
00030 #include "winmenudef.h"
00031
00032 ODINDEBUGCHANNEL(USER32)
00033
00034 BOOL ODIN_INTERNAL ODIN_InsertMenuA(HMENU,UINT,UINT,UINT,LPCSTR);
00035 BOOL ODIN_INTERNAL ODIN_InsertMenuW(HMENU,UINT,UINT,UINT,LPCWSTR);
00036 BOOL ODIN_INTERNAL ODIN_InsertMenuItemA(HMENU,UINT,BOOL,const MENUITEMINFOA*);
00037 BOOL ODIN_INTERNAL ODIN_InsertMenuItemW(HMENU,UINT,BOOL,const MENUITEMINFOW*);
00038 BOOL ODIN_INTERNAL ODIN_AppendMenuA(HMENU,UINT,UINT,LPCSTR);
00039 BOOL ODIN_INTERNAL ODIN_AppendMenuW(HMENU,UINT,UINT,LPCWSTR);
00040 HMENU ODIN_INTERNAL ODIN_CreateMenu(void);
00041 HMENU ODIN_INTERNAL ODIN_CreatePopupMenu(void);
00042 BOOL ODIN_INTERNAL ODIN_DestroyMenu(HMENU);
00043 BOOL ODIN_INTERNAL ODIN_DeleteMenu(HMENU, UINT, UINT);
00044
00045
00046 #include <heapstring.h>
00047 #define MENU_ITEM_TYPE(flags) \
00048 ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
00049
00050 #define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
00051 #define IS_BITMAP_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_BITMAP)
00052
00053
00054
00055
00056
00057
00058
00059 static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu)
00060 {
00061 WORD flags, id = 0;
00062 LPCSTR str;
00063
00064 do
00065 {
00066 flags = GET_WORD(res);
00067 res += sizeof(WORD);
00068 if (!(flags & MF_POPUP))
00069 {
00070 id = GET_WORD(res);
00071 res += sizeof(WORD);
00072 }
00073 if (!IS_STRING_ITEM(flags))
00074 dprintf(("USER32: WinMenu: MENU_ParseResource: not a string item %04x\n", flags ));
00075 str = res;
00076
00077 res += (lstrlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
00078 if (flags & MF_POPUP)
00079 {
00080 HMENU hSubMenu = ODIN_CreatePopupMenu();
00081 if (!hSubMenu) return NULL;
00082 if (!(res = MENU_ParseResource( res, hSubMenu)))
00083 return NULL;
00084 ODIN_AppendMenuW( hMenu, flags, (UINT)hSubMenu, (LPCWSTR)str );
00085 }
00086 else
00087 {
00088 ODIN_AppendMenuW( hMenu, flags, id, *(LPCWSTR)str ? (LPCWSTR)str : NULL );
00089 }
00090 } while (!(flags & MF_END));
00091 return res;
00092 }
00093
00094
00095
00096
00097
00098
00099
00100
00101 static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
00102 {
00103 WORD resinfo;
00104
00105 do {
00106 MENUITEMINFOW mii;
00107
00108 mii.cbSize = sizeof(mii);
00109 mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
00110 mii.fType = GET_DWORD(res);
00111 res += sizeof(DWORD);
00112 mii.fState = GET_DWORD(res);
00113 res += sizeof(DWORD);
00114 mii.wID = GET_DWORD(res);
00115 res += sizeof(DWORD);
00116 resinfo = GET_WORD(res);
00117 res += sizeof(WORD);
00118
00119
00120 res += (~((int)res - 1)) & 1;
00121 mii.dwTypeData = (LPWSTR) res;
00122 res += (1 + lstrlenW(mii.dwTypeData)) * sizeof(WCHAR);
00123
00124 res += (~((int)res - 1)) & 3;
00125
00126
00127 {
00128 LPSTR newstr = HEAP_strdupWtoA(GetProcessHeap(), 0, mii.dwTypeData);
00129
00130 dprintf(("USER32:WinMenu:MENUEX_ParseResource Menu item: [%08x,%08x,%04x,%04x,%s]\n",
00131 mii.fType, mii.fState, mii.wID, resinfo, newstr));
00132 HeapFree( GetProcessHeap(), 0, newstr );
00133 }
00134
00135 if (resinfo & 1) {
00136
00137 res += sizeof(DWORD);
00138 mii.hSubMenu = ODIN_CreatePopupMenu();
00139 if (!mii.hSubMenu)
00140 return NULL;
00141 if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
00142 DestroyMenu(mii.hSubMenu);
00143 return NULL;
00144 }
00145 mii.fMask |= MIIM_SUBMENU;
00146 mii.fType |= MF_POPUP;
00147 }
00148 ODIN_InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
00149 }
00150 while (!(resinfo & MF_END));
00151
00152 return res;
00153 }
00154
00155
00156
00157 HMENU myLoadMenuIndirect(LPCVOID pMenuTemplate)
00158 {
00159 HMENU hMenu;
00160 WORD version,
00161 offset;
00162 LPCSTR p = (LPCSTR)pMenuTemplate;
00163
00164 version = GET_WORD(p);
00165 p += sizeof(WORD);
00166
00167 switch (version)
00168 {
00169 case 0:
00170 offset = GET_WORD(p);
00171 p += sizeof(WORD) + offset;
00172 if (!(hMenu = ODIN_CreateMenu()))
00173 return 0;
00174 if (!MENU_ParseResource( p, hMenu))
00175 {
00176 DestroyMenu( hMenu );
00177 return 0;
00178 }
00179 return hMenu;
00180
00181 case 1:
00182 offset = GET_WORD(p);
00183 p += sizeof(WORD) + offset;
00184 if (!(hMenu = ODIN_CreateMenu()))
00185 return 0;
00186 if (!MENUEX_ParseResource( p, hMenu))
00187 {
00188 ODIN_DestroyMenu( hMenu );
00189 return 0;
00190 }
00191 return hMenu;
00192
00193 default:
00194 dprintf(("USER32: LoadMenuIndirectA: version %d not supported.\n", version));
00195 return 0;
00196 }
00197 }
00198
00199
00200 void SetInternalMenuInfo(HMENU hMenu)
00201 {
00202 LPPOPUPMENU lpMenuInfo;
00203
00204 lpMenuInfo = (LPPOPUPMENU)malloc(sizeof(*lpMenuInfo));
00205 memset(lpMenuInfo, 0, sizeof(*lpMenuInfo));
00206 OSLibWinSetWindowULong(hMenu, OSLIB_QWL_USER, (ULONG)lpMenuInfo);
00207 }
00208
00209
00210 LPPOPUPMENU GetInternalMenuInfo(HMENU hMenu)
00211 {
00212 return (LPPOPUPMENU)OSLibWinGetWindowULong(hMenu, OSLIB_QWL_USER);
00213 }
00214
00215
00216 void DeleteInternalMenuInfo(HMENU hMenu)
00217 {
00218 LPPOPUPMENU lpMenuInfo;
00219
00220 lpMenuInfo = (LPPOPUPMENU)OSLibWinGetWindowULong(hMenu, OSLIB_QWL_USER);
00221 if(lpMenuInfo) {
00222 free(lpMenuInfo);
00223 OSLibWinSetWindowULong(hMenu, OSLIB_QWL_USER, 0);
00224 }
00225 }
00226
00227
00228 ODINFUNCTION0(HMENU, CreateMenu)
00229 {
00230 HMENU hMenu;
00231
00232 dprintf(("USER32: CreateMenu\n"));
00233
00234 hMenu = OSLibWinCreateEmptyMenu();
00235 if(hMenu) {
00236 SetInternalMenuInfo(hMenu);
00237 }
00238 else SetLastError(ERROR_INVALID_PARAMETER);
00239
00240 return hMenu;
00241 }
00242
00243
00244 ODINFUNCTION0(HMENU, CreatePopupMenu)
00245 {
00246 HMENU hMenu;
00247
00248 dprintf(("USER32: CreatePopupMenu\n"));
00249
00250 hMenu = OSLibWinCreateEmptyPopupMenu();
00251 if(hMenu) {
00252 SetInternalMenuInfo(hMenu);
00253 }
00254 else SetLastError(ERROR_INVALID_PARAMETER);
00255
00256 return hMenu;
00257 }
00258
00259
00260 ODINFUNCTION2(HMENU, LoadMenuA,
00261 HINSTANCE, hinst,
00262 LPCSTR, lpszMenu)
00263 {
00264 Win32Resource *winres;
00265 HMENU hMenu;
00266
00267 winres = (Win32Resource *)FindResourceA(hinst, lpszMenu, RT_MENUA);
00268 if(winres)
00269 {
00270 hMenu = myLoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockResource());
00271 if(hMenu) {
00272 SetInternalMenuInfo(hMenu);
00273 }
00274 else SetLastError(ERROR_INVALID_PARAMETER);
00275
00276 delete winres;
00277 return hMenu;
00278 }
00279 return 0;
00280 }
00281
00282
00283 ODINFUNCTION2(HMENU, LoadMenuW,
00284 HINSTANCE, hinst,
00285 LPCWSTR, lpszMenu)
00286 {
00287 Win32Resource *winres;
00288 HMENU hMenu;
00289
00290 winres = (Win32Resource *)FindResourceW(hinst, lpszMenu, RT_MENUW);
00291 if(winres) {
00292 hMenu = myLoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockResource());
00293 if(hMenu) {
00294 SetInternalMenuInfo(hMenu);
00295 }
00296 else SetLastError(ERROR_INVALID_PARAMETER);
00297
00298 delete winres;
00299 return hMenu;
00300 }
00301 return 0;
00302 }
00303
00304
00305
00306 ODINFUNCTION1(HMENU, LoadMenuIndirectW,
00307 const MENUITEMTEMPLATEHEADER *, menuTemplate)
00308 {
00309 HMENU hMenu;
00310
00311 hMenu = myLoadMenuIndirect(menuTemplate);
00312 if(hMenu) {
00313 SetInternalMenuInfo(hMenu);
00314 }
00315 else SetLastError(ERROR_INVALID_PARAMETER);
00316
00317 return (HMENU)hMenu;
00318 }
00319
00320
00321 ODINFUNCTION1(BOOL, DestroyMenu,
00322 HMENU, hMenu)
00323 {
00324 if(hMenu == 0)
00325 {
00326 SetLastError(ERROR_INVALID_PARAMETER);
00327 return 0;
00328 }
00329 DeleteInternalMenuInfo(hMenu);
00330 return O32_DestroyMenu(hMenu);
00331 }
00332
00333
00334 ODINFUNCTION1(HMENU, GetMenu,
00335 HWND, hwnd)
00336 {
00337 Win32BaseWindow *window;
00338
00339 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
00340 if(!window)
00341 {
00342 dprintf(("GetMenu, window %x not found", hwnd));
00343 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
00344 return 0;
00345 }
00346
00347 return window->GetMenu();
00348 }
00349
00350
00351 ODINFUNCTION2(BOOL, SetMenu,
00352 HWND, hwnd,
00353 HMENU, hMenu)
00354 {
00355 Win32BaseWindow *window;
00356
00357 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
00358 if(!window)
00359 {
00360 dprintf(("SetMenu, window %x not found", hwnd));
00361 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
00362 return 0;
00363 }
00364
00365 window->SetMenu(hMenu);
00366 return TRUE;
00367 }
00368
00369
00370 ODINFUNCTION0(DWORD, GetMenuCheckMarkDimensions)
00371 {
00372 return O32_GetMenuCheckMarkDimensions();
00373 }
00374
00375
00376 ODINFUNCTION1(int, GetMenuItemCount,
00377 HMENU, hMenu)
00378 {
00379 if(hMenu == 0)
00380 {
00381 SetLastError(ERROR_INVALID_PARAMETER);
00382 return 0;
00383 }
00384 return OSLibGetMenuItemCount(hMenu);
00385 }
00386
00387
00388 ODINFUNCTION2(UINT, GetMenuItemID,
00389 HMENU, hMenu,
00390 int, nPos)
00391 {
00392 if(hMenu == 0)
00393 {
00394 SetLastError(ERROR_INVALID_PARAMETER);
00395 return 0;
00396 }
00397 return O32_GetMenuItemID(hMenu, nPos);
00398 }
00399
00400
00401 ODINFUNCTION3(UINT, GetMenuState,
00402 HMENU, hMenu,
00403 UINT, arg2,
00404 UINT, arg3)
00405 {
00406 if(hMenu == 0)
00407 {
00408 SetLastError(ERROR_INVALID_PARAMETER);
00409 return 0;
00410 }
00411
00412 return O32_GetMenuState(hMenu, arg2, arg3);
00413 }
00414
00415
00416 ODINFUNCTION5(int, GetMenuStringA,
00417 HMENU, hMenu,
00418 UINT, idItem,
00419 LPSTR, lpsz,
00420 int, cchMax,
00421 UINT, fuFlags)
00422 {
00423 int rc, nritems;
00424
00425 if(hMenu == 0)
00426 {
00427 SetLastError(ERROR_INVALID_PARAMETER);
00428 return 0;
00429 }
00430 if(!lpsz || !cchMax) {
00431 char menustr[256];
00432 rc = O32_GetMenuString(hMenu, idItem, menustr, sizeof(menustr), fuFlags);
00433
00434 return (rc == -1) ? 0 : rc;
00435 }
00436 rc = O32_GetMenuString(hMenu, idItem, lpsz, cchMax, fuFlags);
00437
00438 return (rc == -1) ? 0 : rc;
00439 }
00440
00441
00442 ODINFUNCTION5(int, GetMenuStringW,
00443 HMENU, hMenu,
00444 UINT, idItem,
00445 LPWSTR,lpsz,
00446 int, cchMax,
00447 UINT, fuFlags)
00448 {
00449 char *astring = (char *)malloc(cchMax);
00450 int rc;
00451
00452 rc = ODIN_GetMenuStringA(hMenu, idItem, astring, cchMax, fuFlags);
00453 if(rc)
00454 {
00455 dprintf(("USER32: GetMenuStringW %s\n", astring));
00456 AsciiToUnicode(astring, lpsz);
00457 }
00458 else lpsz[0] = 0;
00459 free(astring);
00460
00461 return(rc);
00462 }
00463
00464
00465 ODINFUNCTION5(BOOL, SetMenuItemBitmaps,
00466 HMENU, hMenu,
00467 UINT, arg2,
00468 UINT, arg3,
00469 HBITMAP, arg4,
00470 HBITMAP, arg5)
00471 {
00472 dprintf(("USER32: SetMenuItemBitmaps\n"));
00473 if(hMenu == 0)
00474 {
00475 SetLastError(ERROR_INVALID_PARAMETER);
00476 return 0;
00477 }
00478 return O32_SetMenuItemBitmaps(hMenu, arg2, arg3, arg4, arg5);
00479 }
00480
00481
00482 ODINFUNCTION2(HMENU, GetSubMenu,
00483 HWND, hMenu,
00484 int, arg2)
00485 {
00486 if(hMenu == 0)
00487 {
00488 SetLastError(ERROR_INVALID_PARAMETER);
00489 return 0;
00490 }
00491
00492 return O32_GetSubMenu(hMenu, arg2);
00493 }
00494
00495
00496 ODINFUNCTION2(HMENU, GetSystemMenu,
00497 HWND, hSystemWindow,
00498 BOOL, bRevert)
00499 {
00500 Win32BaseWindow *window;
00501
00502 window = Win32BaseWindow::GetWindowFromHandle(hSystemWindow);
00503 if(!window)
00504 {
00505 dprintf(("GetSystemMenu, window %x not found", hSystemWindow));
00506 return 0;
00507 }
00508
00509 return window->GetSystemMenu(bRevert);
00510 }
00511
00512
00513 ODINFUNCTION1(BOOL, IsMenu,
00514 HMENU, hMenu)
00515 {
00516 dprintf(("USER32: IsMenu\n"));
00517 return O32_IsMenu(hMenu);
00518 }
00519
00520
00521 ODINFUNCTION7(BOOL, TrackPopupMenu,
00522 HMENU, hMenu,
00523 UINT, arg2,
00524 int, arg3,
00525 int, arg4,
00526 int, arg5,
00527 HWND, arg6,
00528 const RECT *, arg7)
00529 {
00530 Win32BaseWindow *window;
00531
00532 window = Win32BaseWindow::GetWindowFromHandle(arg6);
00533 if(!window)
00534 {
00535 dprintf(("TrackPopupMenu, window %x not found", arg6));
00536 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
00537 return 0;
00538 }
00539 dprintf(("USER32: TrackPopupMenu\n"));
00540 if(hMenu == 0)
00541 {
00542 SetLastError(ERROR_INVALID_PARAMETER);
00543 return 0;
00544 }
00545 return O32_TrackPopupMenu(hMenu, arg2, arg3, arg4, arg5, window->getOS2WindowHandle(),
00546 arg7);
00547 }
00548
00549
00550 ODINFUNCTION6(BOOL, TrackPopupMenuEx,
00551 HMENU, hMenu,
00552 UINT, flags,
00553 int, X,
00554 int, Y,
00555 HWND, hwnd,
00556 LPTPMPARAMS, lpPM)
00557 {
00558 RECT *rect = NULL;
00559 Win32BaseWindow *window;
00560
00561 window = Win32BaseWindow::GetWindowFromHandle(hwnd);
00562 if(!window)
00563 {
00564 dprintf(("TrackPopupMenu, window %x not found", hwnd));
00565 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
00566 return 0;
00567 }
00568
00569 dprintf(("USER32: TrackPopupMenuEx, not completely implemented\n"));
00570
00571 if (lpPM != NULL)
00572 if(lpPM->cbSize != 0)
00573 rect = &lpPM->rcExclude;
00574
00575 if(hMenu == 0)
00576 {
00577 SetLastError(ERROR_INVALID_PARAMETER);
00578 return 0;
00579 }
00580 return O32_TrackPopupMenu(hMenu, flags, X, Y, 0, window->getOS2WindowHandle(), rect);
00581 }
00582
00583
00584 ODINFUNCTION4(BOOL, AppendMenuA,
00585 HMENU, hMenu,
00586 UINT, uFlags,
00587 UINT, id,
00588 LPCSTR, lpNewItem)
00589 {
00590 return ODIN_InsertMenuA( hMenu, -1, uFlags | MF_BYPOSITION, id, lpNewItem );
00591 }
00592
00593
00594 ODINFUNCTION4(BOOL, AppendMenuW,
00595 HMENU, hMenu,
00596 UINT, uFlags,
00597 UINT, id,
00598 LPCWSTR, lpNewItem)
00599 {
00600 return ODIN_InsertMenuW( hMenu, -1, uFlags | MF_BYPOSITION, id, lpNewItem );
00601 }
00602
00603
00604 ODINFUNCTION3(DWORD, CheckMenuItem,
00605 HMENU, hMenu,
00606 UINT, arg2,
00607 UINT, arg3)
00608 {
00609 if(hMenu == 0)
00610 {
00611 SetLastError(ERROR_INVALID_PARAMETER);
00612 return 0;
00613 }
00614 return O32_CheckMenuItem(hMenu, arg2, arg3);
00615 }
00616
00617
00618 ODINFUNCTION3(BOOL,EnableMenuItem,HMENU,hMenu,
00619 UINT, uIDEnableItem,
00620 UINT, uEnable)
00621 {
00622 if(hMenu == 0)
00623 {
00624 SetLastError(ERROR_INVALID_PARAMETER);
00625 return 0;
00626 }
00627
00628 return O32_EnableMenuItem(hMenu,
00629 uIDEnableItem,
00630 uEnable);
00631 }
00632
00633
00634 ODINFUNCTION5(BOOL, ModifyMenuA,
00635 HMENU, hMenu,
00636 UINT, uItem,
00637 UINT, fuFlags,
00638 UINT, idNewItem,
00639 LPCSTR, lpszNewItem)
00640 {
00641 if(hMenu == 0)
00642 {
00643 SetLastError(ERROR_INVALID_PARAMETER);
00644 return 0;
00645 }
00646 if(IS_STRING_ITEM(fuFlags) && HIWORD(lpszNewItem) != 0) {
00647 dprintf(("ModifyMenuA %s", lpszNewItem));
00648 }
00649
00650
00651
00652
00653
00654
00655
00656 return O32_ModifyMenu(hMenu, uItem, fuFlags, idNewItem, lpszNewItem);
00657 }
00658
00659
00660 ODINFUNCTION5(BOOL, ModifyMenuW,
00661 HMENU, hMenu,
00662 UINT, arg2,
00663 UINT, arg3,
00664 UINT, arg4,
00665 LPCWSTR, arg5)
00666 {
00667 BOOL rc;
00668 char *astring = NULL;
00669
00670 if(hMenu == 0)
00671 {
00672 SetLastError(ERROR_INVALID_PARAMETER);
00673 return 0;
00674 }
00675
00676 if(IS_STRING_ITEM(arg3) && HIWORD(arg5) != 0)
00677 astring = UnicodeToAsciiString((LPWSTR)arg5);
00678 else
00679 astring = (char *) arg5;
00680
00681 rc = ODIN_ModifyMenuA(hMenu, arg2, arg3, arg4, astring);
00682 if(IS_STRING_ITEM(arg3) && HIWORD(arg5) != 0)
00683 FreeAsciiString(astring);
00684
00685 return(rc);
00686 }
00687
00688
00689 ODINFUNCTION3(BOOL, RemoveMenu,
00690 HMENU, hMenu,
00691 UINT, arg2,
00692 UINT, arg3)
00693 {
00694 if(hMenu == 0)
00695 {
00696 SetLastError(ERROR_INVALID_PARAMETER);
00697 return 0;
00698 }
00699
00700 return O32_RemoveMenu(hMenu, arg2, arg3);
00701 }
00702
00703
00704 ODINFUNCTION3(BOOL, DeleteMenu,
00705 HMENU, hMenu,
00706 UINT, arg2,
00707 UINT, arg3)
00708 {
00709 if(hMenu == 0)
00710 {
00711 SetLastError(ERROR_INVALID_PARAMETER);
00712 return 0;
00713 }
00714
00715 return O32_DeleteMenu(hMenu, arg2, arg3);
00716 }
00717
00718
00719 ODINFUNCTION4(BOOL, HiliteMenuItem,
00720 HWND, hMenu,
00721 HMENU, arg2,
00722 UINT, arg3,
00723 UINT, arg4)
00724 {
00725 dprintf(("USER32: OS2HiliteMenuItem\n"));
00726 if(hMenu == 0)
00727 {
00728 SetLastError(ERROR_INVALID_PARAMETER);
00729 return 0;
00730 }
00731
00732 return O32_HiliteMenuItem(hMenu, arg2, arg3, arg4);
00733 }
00734
00735
00736 ODINFUNCTION5(BOOL, InsertMenuA,
00737 HMENU, hMenu,
00738 UINT, pos,
00739 UINT, flags,
00740 UINT, id,
00741 LPCSTR, str)
00742 {
00743 if(IS_STRING_ITEM(flags) && HIWORD(str)) {
00744 dprintf(("USER32: InsertMenuA %x %d %x %d %s", hMenu, pos, flags, id, str));
00745 }
00746 else dprintf(("USER32: InsertMenuA %x %d %x %d %x", hMenu, pos, flags, id, str));
00747
00748 if(hMenu == 0)
00749 {
00750 SetLastError(ERROR_INVALID_PARAMETER);
00751 return 0;
00752 }
00753
00754 if(IS_STRING_ITEM(flags) && (!str || *str == NULL)) {
00755 flags |= MF_SEPARATOR;
00756 }
00757
00758 if((flags & (MF_BYCOMMAND|MF_BYPOSITION)) == 0 && (pos == 0xffffffff))
00759 flags |= MF_BYPOSITION;
00760
00761 return O32_InsertMenu(hMenu, pos, flags, id, str);
00762 }
00763
00764
00765 ODINFUNCTION5(BOOL, InsertMenuW,
00766 HMENU, hMenu,
00767 UINT, arg2,
00768 UINT, arg3,
00769 UINT, arg4,
00770 LPCWSTR, arg5)
00771 {
00772 BOOL rc;
00773 char *astring = NULL;
00774
00775 if(IS_STRING_ITEM(arg3) && HIWORD(arg5) != 0)
00776 astring = UnicodeToAsciiString((LPWSTR)arg5);
00777 else
00778 astring = (char *) arg5;
00779
00780 rc = ODIN_InsertMenuA(hMenu, arg2, arg3, arg4, astring);
00781
00782 if(IS_STRING_ITEM(arg3) && HIWORD(arg5) != 0)
00783 FreeAsciiString(astring);
00784
00785 return(rc);
00786 }
00787
00788
00789 ODINFUNCTION2(BOOL, SetMenuContextHelpId,
00790 HMENU, hMenu,
00791 DWORD, dwContextHelpId)
00792 {
00793 POPUPMENU *menu;
00794
00795 menu = GetInternalMenuInfo(hMenu);
00796 if(menu == NULL) {
00797 dprintf(("USER32: SetMenuContextHelpId(%x) No POPUPMENU structure found!", hMenu));
00798 SetLastError(ERROR_INVALID_PARAMETER);
00799 return FALSE;
00800 }
00801 dprintf(("USER32: SetMenuContextHelpId %x %d", hMenu, dwContextHelpId));
00802 menu->dwContextHelpID = dwContextHelpId;
00803 return(TRUE);
00804 }
00805
00806
00807 ODINFUNCTION1(DWORD, GetMenuContextHelpId,
00808 HMENU, hMenu)
00809 {
00810 POPUPMENU *menu;
00811
00812 menu = GetInternalMenuInfo(hMenu);
00813 if(menu == NULL) {
00814 dprintf(("USER32: GetMenuContextHelpId(%x) No POPUPMENU structure found!", hMenu));
00815 SetLastError(ERROR_INVALID_PARAMETER);
00816 return 0;
00817 }
00818 dprintf(("USER32: GetMenuContextHelpId %x %d", hMenu, menu->dwContextHelpID));
00819 return menu->dwContextHelpID;
00820 }
00821
00822
00823 ODINFUNCTION5(BOOL, CheckMenuRadioItem,
00824 HMENU, hMenu,
00825 UINT, idFirst,
00826 UINT, idLast,
00827 UINT, idCheck,
00828 UINT, uFlags)
00829 {
00830 dprintf(("USER32: OS2CheckMenuRadioItem, not implemented\n"));
00831 return(TRUE);
00832 }
00833
00834
00835 ODINFUNCTION5(BOOL, ChangeMenuA,
00836 HMENU, hMenu,
00837 UINT, pos,
00838 LPCSTR, data,
00839 UINT, id,
00840 UINT, flags)
00841 {
00842 dprintf(("USER32: ChangeMenuA flags %X\n", flags));
00843
00844 if (flags & MF_APPEND) return ODIN_AppendMenuA(hMenu, flags & ~MF_APPEND,
00845 id, data );
00846 if (flags & MF_DELETE) return ODIN_DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
00847 if (flags & MF_CHANGE) return ODIN_ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
00848 id, data );
00849 if (flags & MF_REMOVE) return ODIN_RemoveMenu(hMenu,
00850 flags & MF_BYPOSITION ? pos : id,
00851 flags & ~MF_REMOVE );
00852
00853 return InsertMenuA( hMenu, pos, flags, id, data );
00854 }
00855
00856
00857 ODINFUNCTION5(BOOL, ChangeMenuW,
00858 HMENU, hMenu,
00859 UINT, pos,
00860 LPCWSTR, data,
00861 UINT, id,
00862 UINT, flags)
00863 {
00864 dprintf(("USER32: ChangeMenuW flags %X\n", flags));
00865
00866 if (flags & MF_APPEND) return ODIN_AppendMenuW(hMenu, flags & ~MF_APPEND,
00867 id, data );
00868 if (flags & MF_DELETE) return ODIN_DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
00869 if (flags & MF_CHANGE) return ODIN_ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
00870 id, data );
00871 if (flags & MF_REMOVE) return ODIN_RemoveMenu(hMenu,
00872 flags & MF_BYPOSITION ? pos : id,
00873 flags & ~MF_REMOVE );
00874
00875 return InsertMenuW(hMenu, pos, flags, id, data);
00876 }
00877
00878
00879 ODINFUNCTION4(BOOL, SetMenuItemInfoA,
00880 HMENU, hMenu,
00881 UINT, par1,
00882 BOOL, par2,
00883 const MENUITEMINFOA *, lpmii)
00884 {
00885 dprintf(("USER32: SetMenuItemInfoA faked %x", hMenu));
00886
00887 if (!hMenu) {
00888 SetLastError(ERROR_INVALID_PARAMETER);
00889 return FALSE;
00890 }
00891 return TRUE;
00892 }
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907 ODINFUNCTION4(BOOL, SetMenuItemInfoW,
00908 HMENU, hMenu,
00909 UINT, uItem,
00910 BOOL, fByPosition,
00911 const MENUITEMINFOW *, lpmmi)
00912 {
00913 dprintf(("USER32:SetMenuItemInfoW (%08xh,%08xh,%08xh,%08x) not implemented.\n",
00914 hMenu,
00915 uItem,
00916 fByPosition,
00917 lpmmi));
00918
00919 return (SetMenuItemInfoA(hMenu,
00920 uItem,
00921 fByPosition,
00922 (const MENUITEMINFOA *)lpmmi));
00923 }
00924
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939 ODINFUNCTION3(UINT, GetMenuDefaultItem,
00940 HMENU, hMenu,
00941 UINT, fByPos,
00942 UINT, gmdiFlags)
00943 {
00944 dprintf(("USER32:GetMenuDefaultItem (%08xh,%u,%08x) not implemented.\n",
00945 hMenu,
00946 fByPos,
00947 gmdiFlags));
00948
00949 return (-1);
00950 }
00951
00952
00953 ODINFUNCTION3(BOOL, SetMenuDefaultItem,
00954 HMENU, hMenu,
00955 UINT, uItem,
00956 UINT, fByPos)
00957 {
00958 dprintf(("USER32: SetMenuDefaultItem, faked\n"));
00959 return(TRUE);
00960 }
00961
00962
00963 BOOL GetMenuItemInfoAW(HMENU hMenu, UINT uItem, BOOL byPos, MENUITEMINFOA *lpmii, BOOL unicode)
00964 {
00965 if(byPos) {
00966 uItem = GetMenuItemID(hMenu, uItem);
00967 }
00968 if(ODIN_GetMenuState(hMenu, uItem, MF_BYCOMMAND) == -1) {
00969
00970 dprintf(("USER32: GetMenuItemInfoAW %x item %d doesn't exist", hMenu, uItem));
00971 SetLastError(ERROR_INVALID_PARAMETER);
00972 return FALSE;
00973 }
00974 if (lpmii->fMask & MIIM_TYPE)
00975 {
00976 lpmii->fType = ODIN_GetMenuState(hMenu, uItem, MF_BYCOMMAND);
00977
00978 if (unicode) {
00979 lpmii->cch = ODIN_GetMenuStringW(hMenu, uItem, (LPWSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
00980 }
00981 else {
00982 lpmii->cch = ODIN_GetMenuStringA(hMenu, uItem, (LPSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
00983 }
00984
00985 #if 0
00986 switch (MENU_ITEM_TYPE(menu->fType)) {
00987 case MF_STRING:
00988 if (menu->text && lpmii->dwTypeData && lpmii->cch) {
00989 if (unicode) {
00990 lstrcpynAtoW((LPWSTR) lpmii->dwTypeData, menu->text, lpmii->cch);
00991 lpmii->cch = lstrlenW((LPWSTR)menu->text);
00992 }
00993 else {
00994 lstrcpynA(lpmii->dwTypeData, menu->text, lpmii->cch);
00995 lpmii->cch = lstrlenA(menu->text);
00996 }
00997 }
00998 break;
00999 case MF_OWNERDRAW:
01000 case MF_BITMAP:
01001 lpmii->dwTypeData = menu->text;
01002
01003 default:
01004 lpmii->cch = 0;
01005 }
01006 #endif
01007 }
01008
01009 if (lpmii->fMask & MIIM_STRING) {
01010 if (unicode) {
01011 lpmii->cch = ODIN_GetMenuStringW(hMenu, uItem, (LPWSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
01012 }
01013 else {
01014 lpmii->cch = ODIN_GetMenuStringA(hMenu, uItem, (LPSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
01015 }
01016 }
01017
01018
01019 #if 0
01020 if (lpmii->fMask & MIIM_FTYPE)
01021 lpmii->fType = menu->fType;
01022
01023 if (lpmii->fMask & MIIM_BITMAP)
01024 lpmii->hbmpItem = menu->hbmpItem;
01025 #endif
01026
01027 if (lpmii->fMask & MIIM_STATE)
01028 lpmii->fState = ODIN_GetMenuState(hMenu, uItem, MF_BYCOMMAND);
01029
01030 if (lpmii->fMask & MIIM_ID)
01031 lpmii->wID = uItem;
01032
01033
01034 #if 1
01035 lpmii->hSubMenu = 0;
01036 lpmii->hbmpChecked = 0;
01037 lpmii->hbmpUnchecked = 0;
01038 lpmii->dwItemData = 0;
01039 #else
01040 if (lpmii->fMask & MIIM_SUBMENU)
01041 lpmii->hSubMenu = ODIN_GetSubMenu(hMenu, uItem);
01042
01043 if (lpmii->fMask & MIIM_CHECKMARKS) {
01044 lpmii->hbmpChecked = menu->hCheckBit;
01045 lpmii->hbmpUnchecked = menu->hUnCheckBit;
01046 }
01047 if (lpmii->fMask & MIIM_DATA)
01048 lpmii->dwItemData = menu->dwItemData;
01049 #endif
01050
01051 return(FALSE);
01052 }
01053
01054
01055 ODINFUNCTION4(BOOL, GetMenuItemInfoA,
01056 HMENU, hMenu,
01057 UINT, uItem,
01058 BOOL, byPos,
01059 MENUITEMINFOA *, lpMenuItemInfo)
01060 {
01061 return GetMenuItemInfoAW(hMenu, uItem, byPos, lpMenuItemInfo, FALSE);
01062 }
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077 ODINFUNCTION4(BOOL, GetMenuItemInfoW,
01078 HMENU, hMenu,
01079 UINT, uItem,
01080 BOOL, byPos,
01081 MENUITEMINFOW *, lpMenuItemInfo)
01082 {
01083 return GetMenuItemInfoAW(hMenu, uItem, byPos, (MENUITEMINFOA*)lpMenuItemInfo, TRUE);
01084 }
01085
01086
01087
01088
01089
01090
01091
01092
01093
01094
01095
01096
01097
01098
01099
01100 BOOL GetMenuItemRect(HWND hwnd, HMENU hMenu, UINT uItem, LPRECT lprcItem)
01101 {
01102 BOOL rc;
01103
01104 rc = OSLibGetMenuItemRect(hMenu, uItem, lprcItem);
01105 dprintf(("GetMenuItemRect %x %x %x (%d,%d)(%d,%d)", hwnd, hMenu, uItem, lprcItem->top, lprcItem->left, lprcItem->bottom, lprcItem->right));
01106 return rc;
01107 }
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123 ODINFUNCTION4(BOOL, InsertMenuItemA,
01124 HMENU, hMenu,
01125 UINT, uItem,
01126 BOOL, fByPosition,
01127 const MENUITEMINFOA*, lpmii)
01128 {
01129 DWORD dwType;
01130 BOOL rc;
01131
01132 dprintf(("USER32:InsertMenuItemA (%08xh,%08xh,%u,%08x) not correctly implemented.\n",
01133 hMenu,
01134 uItem,
01135 fByPosition,
01136 lpmii));
01137
01138 if(fByPosition) {
01139 dwType = lpmii->fType | MF_BYPOSITION;
01140 }
01141 else dwType = lpmii->fType | MF_BYCOMMAND;
01142
01143 if(lpmii->fMask & MIIM_SUBMENU && lpmii->hSubMenu) {
01144 rc &= ODIN_InsertMenuA(hMenu, uItem, dwType | MF_POPUP, lpmii->hSubMenu, lpmii->dwTypeData);
01145 }
01146 else
01147 if(lpmii->fMask & MIIM_ID) {
01148 rc = ODIN_InsertMenuA(hMenu, uItem, dwType, lpmii->wID, lpmii->dwTypeData);
01149 }
01150 if(lpmii->fMask & MIIM_STATE) {
01151
01152 }
01153 return rc;
01154 }
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172 ODINFUNCTION4(BOOL, InsertMenuItemW,
01173 HMENU, hMenu,
01174 UINT, uItem,
01175 BOOL, fByPosition,
01176 const MENUITEMINFOW *, lpmii)
01177 {
01178 dprintf(("USER32:InsertMenuItemW (%08xh,%08xh,%u,%08x) not correctly implemented.\n",
01179 hMenu,
01180 uItem,
01181 fByPosition,
01182 lpmii));
01183
01184 if(fByPosition) {
01185 return ODIN_InsertMenuW(hMenu, uItem, lpmii->fType | MF_BYPOSITION, (lpmii->fType & MF_POPUP) ? lpmii->hSubMenu : lpmii->wID, lpmii->dwTypeData);
01186 }
01187 else return ODIN_InsertMenuW(hMenu, uItem, lpmii->fType | MF_BYCOMMAND, (lpmii->fType & MF_POPUP) ? lpmii->hSubMenu : lpmii->wID, lpmii->dwTypeData);
01188 }
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201
01202
01203 ODINFUNCTION3(UINT, MenuItemFromPoint,
01204 HWND, hWnd,
01205 HMENU, hMenu,
01206 POINT, ptScreen)
01207 {
01208 dprintf(("USER32:MenuItemFromPoint (%08xh,%08xh,%u) not implemented.\n",
01209 hWnd,
01210 hMenu,
01211 ptScreen));
01212
01213 return (-1);
01214 }
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228 ODINFUNCTION2(BOOL, GetMenuInfo,
01229 HMENU, hMenu,
01230 LPMENUINFO, lpmi)
01231 {
01232 POPUPMENU *menu;
01233
01234 menu = GetInternalMenuInfo(hMenu);
01235 if(menu == NULL) {
01236 dprintf(("USER32: GetMenuInfo(%08xh,%08xh) No POPUPMENU structure found!", hMenu, lpmi));
01237 SetLastError(ERROR_INVALID_PARAMETER);
01238 return FALSE;
01239 }
01240 dprintf(("USER32: GetMenuInfo(%08xh,%08xh)", hMenu, lpmi));
01241
01242 if (lpmi)
01243 {
01244 if (lpmi->fMask & MIM_BACKGROUND)
01245 lpmi->hbrBack = menu->hbrBack;
01246
01247 if (lpmi->fMask & MIM_HELPID)
01248 lpmi->dwContextHelpID = menu->dwContextHelpID;
01249
01250 if (lpmi->fMask & MIM_MAXHEIGHT)
01251 lpmi->cyMax = menu->cyMax;
01252
01253 if (lpmi->fMask & MIM_MENUDATA)
01254 lpmi->dwMenuData = menu->dwMenuData;
01255
01256 if (lpmi->fMask & MIM_STYLE)
01257 lpmi->dwStyle = menu->dwStyle;
01258
01259 return TRUE;
01260 }
01261 SetLastError(ERROR_INVALID_PARAMETER);
01262 return FALSE;
01263 }
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279 ODINFUNCTION2(BOOL, SetMenuInfo,
01280 HMENU, hMenu,
01281 LPCMENUINFO, lpmi)
01282 {
01283 POPUPMENU *menu;
01284
01285 menu = GetInternalMenuInfo(hMenu);
01286 if(menu == NULL) {
01287 dprintf(("USER32: SetMenuInfo(%08xh,%08xh) No POPUPMENU structure found!", hMenu, lpmi));
01288 SetLastError(ERROR_INVALID_PARAMETER);
01289 return FALSE;
01290 }
01291
01292 dprintf(("USER32: SetMenuInfo(%08xh,%08xh)", hMenu, lpmi));
01293
01294 if (lpmi && (lpmi->cbSize==sizeof(MENUINFO)))
01295 {
01296 if (lpmi->fMask & MIM_BACKGROUND)
01297 menu->hbrBack = lpmi->hbrBack;
01298
01299 if (lpmi->fMask & MIM_HELPID)
01300 menu->dwContextHelpID = lpmi->dwContextHelpID;
01301
01302 if (lpmi->fMask & MIM_MAXHEIGHT)
01303 menu->cyMax = lpmi->cyMax;
01304
01305 if (lpmi->fMask & MIM_MENUDATA)
01306 menu->dwMenuData = lpmi->dwMenuData;
01307
01308 if (lpmi->fMask & MIM_STYLE)
01309 menu->dwStyle = lpmi->dwStyle;
01310
01311 return TRUE;
01312 }
01313 SetLastError(ERROR_INVALID_PARAMETER);
01314 return FALSE;
01315 }
01316
01317
01318