Changeset 1453 for trunk/src


Ignore:
Timestamp:
Oct 26, 1999, 1:14:52 PM (26 years ago)
Author:
sandervl
Message:

Menu changes + fixes

Location:
trunk/src/user32
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/Makefile

    r1446 r1453  
    1 # $Id: Makefile,v 1.36 1999-10-25 20:17:16 sandervl Exp $
     1# $Id: Makefile,v 1.37 1999-10-26 11:14:51 sandervl Exp $
    22
    33#
    … …  
    8585loadres.obj: loadres.cpp user32.h dib.h
    8686icon.obj: icon.cpp $(PDWIN32_INCLUDE)\winicon.h
    87 winmenu.obj: winmenu.cpp user32.h $(PDWIN32_INCLUDE)\winres.h $(PDWIN32_INCLUDE)\winresmenu.h win32wbase.h winmenudef.h oslibwin.h oslibmenu.h
     87winmenu.obj: winmenu.cpp user32.h $(PDWIN32_INCLUDE)\winres.h win32wbase.h winmenudef.h oslibwin.h oslibmenu.h
    8888syscolor.obj: syscolor.cpp syscolor.h
    8989dde.obj: dde.cpp

  • trunk/src/user32/USER32.DEF

    r1425 r1453  
    1 ; $Id: USER32.DEF,v 1.16 1999-10-23 23:04:32 sandervl Exp $
     1; $Id: USER32.DEF,v 1.17 1999-10-26 11:14:52 sandervl Exp $
    22
    33;Created by BLAST for IBM's compiler
    … …  
    394394    LoadKeyboardLayoutW        = _LoadKeyboardLayoutW@8      @368
    395395    LoadMenuA                  = _LoadMenuA@8                @369
    396     LoadMenuIndirectA          = _LoadMenuIndirectA@4        @370
     396;Menu resources are always in Unicode format
     397    LoadMenuIndirectA          = _LoadMenuIndirectW@4        @370
    397398    LoadMenuIndirectW          = _LoadMenuIndirectW@4        @371
    398399    LoadMenuW                  = _LoadMenuW@8                @372

  • trunk/src/user32/winmenu.cpp

    r1446 r1453  
    1 /* $Id: winmenu.cpp,v 1.10 1999-10-25 20:17:21 sandervl Exp $ */
     1/* $Id: winmenu.cpp,v 1.11 1999-10-26 11:14:52 sandervl Exp $ */
    22
    33/*
    … …  
    2828#include "oslibmenu.h"
    2929#include "oslibwin.h"
    30 #include <winresmenu.h>
    3130#include "winmenudef.h"
    3231
    3332ODINDEBUGCHANNEL(USER32)
    3433
     34BOOL  ODIN_INTERNAL ODIN_InsertMenuA(HMENU,UINT,UINT,UINT,LPCSTR);
     35BOOL  ODIN_INTERNAL ODIN_InsertMenuW(HMENU,UINT,UINT,UINT,LPCWSTR);
     36BOOL  ODIN_INTERNAL ODIN_InsertMenuItemA(HMENU,UINT,BOOL,const MENUITEMINFOA*);
     37BOOL  ODIN_INTERNAL ODIN_InsertMenuItemW(HMENU,UINT,BOOL,const MENUITEMINFOW*);
     38BOOL  ODIN_INTERNAL ODIN_AppendMenuA(HMENU,UINT,UINT,LPCSTR);
     39BOOL  ODIN_INTERNAL ODIN_AppendMenuW(HMENU,UINT,UINT,LPCWSTR);
     40HMENU ODIN_INTERNAL ODIN_CreateMenu(void);
     41HMENU ODIN_INTERNAL ODIN_CreatePopupMenu(void);
     42BOOL  ODIN_INTERNAL ODIN_DestroyMenu(HMENU);
     43
     44
     45//@@@PH: experiment with WINE LoadMenuIndirect code
     46#include <heapstring.h>
     47#define MENU_ITEM_TYPE(flags) \
     48  ((flags) & (MF_STRING | MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))
     49
     50#define IS_STRING_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_STRING)
     51#define IS_BITMAP_ITEM(flags) (MENU_ITEM_TYPE ((flags)) == MF_BITMAP)
     52
     53/**********************************************************************
     54 *         MENU_ParseResource
     55 *
     56 * Parse a standard menu resource and add items to the menu.
     57 * Return a pointer to the end of the resource.
     58 */
     59static LPCSTR MENU_ParseResource( LPCSTR res, HMENU hMenu)
     60{
     61    WORD flags, id = 0;
     62    LPCSTR str;
     63
     64    do
     65    {
     66        flags = GET_WORD(res);
     67        res += sizeof(WORD);
     68        if (!(flags & MF_POPUP))
     69        {
     70            id = GET_WORD(res);
     71            res += sizeof(WORD);
     72        }
     73        if (!IS_STRING_ITEM(flags))
     74            dprintf(("USER32: WinMenu: MENU_ParseResource: not a string item %04x\n", flags ));
     75        str = res;
     76
     77        res += (lstrlenW((LPCWSTR)str) + 1) * sizeof(WCHAR);
     78        if (flags & MF_POPUP)
     79        {
     80            HMENU hSubMenu = ODIN_CreatePopupMenu();
     81            if (!hSubMenu) return NULL;
     82            if (!(res = MENU_ParseResource( res, hSubMenu)))
     83                return NULL;
     84            ODIN_AppendMenuW( hMenu, flags, (UINT)hSubMenu, (LPCWSTR)str );
     85        }
     86        else  /* Not a popup */
     87        {
     88            ODIN_AppendMenuW( hMenu, flags, id, *(LPCWSTR)str ? (LPCWSTR)str : NULL );
     89        }
     90    } while (!(flags & MF_END));
     91    return res;
     92}
     93
     94
     95/**********************************************************************
     96 *         MENUEX_ParseResource
     97 *
     98 * Parse an extended menu resource and add items to the menu.
     99 * Return a pointer to the end of the resource.
     100 */
     101static LPCSTR MENUEX_ParseResource( LPCSTR res, HMENU hMenu)
     102{
     103   WORD resinfo;
     104
     105    do {
     106        MENUITEMINFOW mii;
     107
     108        mii.cbSize = sizeof(mii);
     109        mii.fMask = MIIM_STATE | MIIM_ID | MIIM_TYPE;
     110        mii.fType = GET_DWORD(res);
     111        res += sizeof(DWORD);
     112        mii.fState = GET_DWORD(res);
     113        res += sizeof(DWORD);
     114        mii.wID = GET_DWORD(res);
     115        res += sizeof(DWORD);
     116        resinfo = GET_WORD(res); /* FIXME: for 16-bit apps this is a byte.  */
     117        res += sizeof(WORD);
     118
     119        /* Align the text on a word boundary.  */
     120        res += (~((int)res - 1)) & 1;
     121        mii.dwTypeData = (LPWSTR) res;
     122        res += (1 + lstrlenW(mii.dwTypeData)) * sizeof(WCHAR);
     123        /* Align the following fields on a dword boundary.  */
     124        res += (~((int)res - 1)) & 3;
     125
     126        /* FIXME: This is inefficient and cannot be optimised away by gcc.  */
     127        {
     128            LPSTR newstr = HEAP_strdupWtoA(GetProcessHeap(), 0, mii.dwTypeData);
     129
     130            dprintf(("USER32:WinMenu:MENUEX_ParseResource Menu item: [%08x,%08x,%04x,%04x,%s]\n",
     131                     mii.fType, mii.fState, mii.wID, resinfo, newstr));
     132            HeapFree( GetProcessHeap(), 0, newstr );
     133        }
     134
     135        if (resinfo & 1) {                    /* Pop-up? */
     136            /* DWORD helpid = GET_DWORD(res); FIXME: use this.  */
     137            res += sizeof(DWORD);
     138            mii.hSubMenu = ODIN_CreatePopupMenu();
     139            if (!mii.hSubMenu)
     140                return NULL;
     141            if (!(res = MENUEX_ParseResource(res, mii.hSubMenu))) {
     142                DestroyMenu(mii.hSubMenu);
     143                return NULL;
     144            }
     145            mii.fMask |= MIIM_SUBMENU;
     146            mii.fType |= MF_POPUP;
     147        }
     148        ODIN_InsertMenuItemW(hMenu, -1, MF_BYPOSITION, &mii);
     149    }
     150    while (!(resinfo & MF_END));
     151
     152    return res;
     153}
     154/**********************************************************************
     155 *    myLoadMenuIndirect
     156 */
     157HMENU myLoadMenuIndirect(LPCVOID pMenuTemplate)
     158{
     159  HMENU hMenu;
     160  WORD  version,
     161        offset;
     162  LPCSTR p = (LPCSTR)pMenuTemplate;
     163
     164    version = GET_WORD(p);
     165    p += sizeof(WORD);
     166
     167    switch (version)
     168    {
     169    case 0:
     170        offset = GET_WORD(p);
     171        p += sizeof(WORD) + offset;
     172        if (!(hMenu = ODIN_CreateMenu()))
     173            return 0;
     174        if (!MENU_ParseResource( p, hMenu))
     175        {
     176            DestroyMenu( hMenu );
     177            return 0;
     178        }
     179        return hMenu;
     180
     181    case 1:
     182        offset = GET_WORD(p);
     183        p += sizeof(WORD) + offset;
     184        if (!(hMenu = ODIN_CreateMenu()))
     185            return 0;
     186        if (!MENUEX_ParseResource( p, hMenu))
     187        {
     188            ODIN_DestroyMenu( hMenu );
     189            return 0;
     190        }
     191        return hMenu;
     192
     193    default:
     194        dprintf(("USER32: LoadMenuIndirectA: version %d not supported.\n", version));
     195        return 0;
     196    }
     197}
    35198//******************************************************************************
    36199//******************************************************************************
    … …  
    99262              LPCSTR,    lpszMenu)
    100263{
    101   Win32MenuRes *winres;
     264  Win32Resource *winres;
    102265  HMENU hMenu;
    103266
    104     winres = (Win32MenuRes *)FindResourceA(hinst, lpszMenu, RT_MENUA);
     267    winres = (Win32Resource *)FindResourceA(hinst, lpszMenu, RT_MENUA);
    105268    if(winres)
    106269    {
    107         hMenu = OSLibWinCreateMenu(winres->lockOS2Resource());
     270        hMenu = myLoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockResource());
    108271        if(hMenu) {
    109272                SetInternalMenuInfo(hMenu);
    … …  
    122285              LPCWSTR, lpszMenu)
    123286{
    124   Win32MenuRes *winres;
     287  Win32Resource *winres;
    125288  HMENU hMenu;
    126289
    127     winres = (Win32MenuRes *)FindResourceW(hinst, lpszMenu, RT_MENUW);
     290    winres = (Win32Resource *)FindResourceW(hinst, lpszMenu, RT_MENUW);
    128291    if(winres) {
    129         hMenu = OSLibWinCreateMenu(winres->lockOS2Resource());
     292        hMenu = myLoadMenuIndirect((MENUITEMTEMPLATEHEADER *)winres->lockResource());
    130293        if(hMenu) {
    131294                SetInternalMenuInfo(hMenu);
    … …  
    141304//NOTE: menutemplate strings are always in Unicode format
    142305//******************************************************************************
    143 ODINFUNCTION1(HMENU, LoadMenuIndirectA,
     306ODINFUNCTION1(HMENU, LoadMenuIndirectW,
    144307              const MENUITEMTEMPLATEHEADER *, menuTemplate)
    145308{
    146   Win32MenuRes *winres;
    147309  HMENU hMenu;
    148310
    149     winres = new Win32MenuRes((LPVOID)menuTemplate);
    150     if(winres == NULL)
    151         return 0;
    152 
    153     hMenu = OSLibWinCreateMenu(winres->lockOS2Resource());
     311    hMenu = O32_LoadMenuIndirect(menuTemplate);
    154312    if(hMenu) {
    155313            SetInternalMenuInfo(hMenu);
    … …  
    157315    else    SetLastError(ERROR_INVALID_PARAMETER);
    158316
    159     delete winres;
    160     return (HMENU)winres;
    161 }
    162 //******************************************************************************
    163 //******************************************************************************
    164 ODINFUNCTION1(HMENU, LoadMenuIndirectW,
    165               const MENUITEMTEMPLATEHEADER *, menuTemplate)
    166 {
    167   Win32MenuRes *winres;
    168   HMENU hMenu;
    169 
    170     winres = new Win32MenuRes((LPVOID)menuTemplate);
    171     if(winres == NULL)
    172         return 0;
    173 
    174     hMenu = OSLibWinCreateMenu(winres->lockOS2Resource());
    175     if(hMenu) {
    176             SetInternalMenuInfo(hMenu);
    177     }
    178     else    SetLastError(ERROR_INVALID_PARAMETER);
    179 
    180     delete winres;
    181     return (HMENU)winres;
     317    return (HMENU)hMenu;
    182318}
    183319//******************************************************************************
    … …  
    305441  int   rc;
    306442
    307     if(hMenu == 0)
    308     {
    309         SetLastError(ERROR_INVALID_PARAMETER);
    310         return 0;
    311     }
    312 
    313     rc = O32_GetMenuString(hMenu, idItem, astring, cchMax, fuFlags);
     443    rc = ODIN_GetMenuStringA(hMenu, idItem, astring, cchMax, fuFlags);
    314444    free(astring);
    315445    if(rc)
    … …  
    444574              HMENU, hMenu,
    445575              UINT, uFlags,
    446               UINT, ulDNewItem,
     576              UINT, id,
    447577              LPCSTR, lpNewItem)
    448578{
    449  BOOL rc;
    450 
    451     dprintf(("USER32:  OS2AppendMenuA uFlags = %X\n", uFlags));
    452 
    453     if(uFlags & MF_STRING || uFlags == 0)
    454             dprintf(("USER32:  OS2AppendMenuA %s\n", lpNewItem));
    455 
    456     if(hMenu == 0)
    457     {
    458         SetLastError(ERROR_INVALID_PARAMETER);
    459         return 0;
    460     }
    461     rc = O32_AppendMenu(hMenu, uFlags, ulDNewItem, lpNewItem);
    462     dprintf(("USER32:  AppendMenuA returned %d\n", rc));
    463     return rc;
     579     return ODIN_InsertMenuA( hMenu, -1, uFlags | MF_BYPOSITION, id, lpNewItem );
    464580}
    465581//******************************************************************************
    … …  
    467583ODINFUNCTION4(BOOL, AppendMenuW,
    468584              HMENU, hMenu,
    469               UINT, arg2,
    470               UINT, arg3,
    471               LPCWSTR, arg4)
    472 {
    473     BOOL  rc;
    474     char *astring = NULL;
    475 
    476     dprintf(("USER32:  OS2AppendMenuW\n"));
    477 
    478     if(arg2 & MF_STRING  && (int)arg4 >> 16 != 0)
    479       astring = UnicodeToAsciiString((LPWSTR)arg4);
    480     else
    481       astring = (char *) arg4;
    482 
    483     if(hMenu == 0)
    484     {
    485         SetLastError(ERROR_INVALID_PARAMETER);
    486         return 0;
    487     }
    488     rc = O32_AppendMenu(hMenu, arg2, arg3, astring);
    489     if(arg2 & MF_STRING  && (int)arg4 >> 16 != 0)
    490       FreeAsciiString(astring);
    491     return(rc);
     585              UINT, uFlags,
     586              UINT, id,
     587              LPCWSTR, lpNewItem)
     588{
     589     return ODIN_InsertMenuW( hMenu, -1, uFlags | MF_BYPOSITION, id, lpNewItem );
    492590}
    493591//******************************************************************************
    … …  
    551649 char *astring = NULL;
    552650
    553     dprintf(("USER32: OS2ModifyMenuW %s\n", astring));
    554 
    555     if(hMenu == 0)
    556     {
    557         SetLastError(ERROR_INVALID_PARAMETER);
    558         return 0;
    559     }
    560 
    561     if(arg3 & MF_STRING  && (int)arg5 >> 16 != 0)
     651    if(hMenu == 0)
     652    {
     653        SetLastError(ERROR_INVALID_PARAMETER);
     654        return 0;
     655    }
     656
     657    if(HIWORD(arg5) != 0)
    562658      astring = UnicodeToAsciiString((LPWSTR)arg5);
    563659    else
    564660      astring = (char *) arg5;
    565661
    566     rc = O32_ModifyMenu(hMenu, arg2, arg3, arg4, astring);
    567     if(arg3 & MF_STRING  && (int)arg5 >> 16 != 0)
     662    rc = ODIN_ModifyMenuA(hMenu, arg2, arg3, arg4, astring);
     663    if(HIWORD(arg5) != 0)
    568664      FreeAsciiString(astring);
     665
    569666    return(rc);
    570667}
    … …  
    622719ODINFUNCTION5(BOOL, InsertMenuA,
    623720              HMENU, hMenu,
    624               UINT, arg2,
    625               UINT, arg3,
    626               UINT, arg4,
    627               LPCSTR, arg5)
    628 {
    629     dprintf(("USER32:  OS2InsertMenuA\n"));
    630     if(hMenu == 0)
    631     {
    632         SetLastError(ERROR_INVALID_PARAMETER);
    633         return 0;
    634     }
    635 
    636     return O32_InsertMenu(hMenu, arg2, arg3, arg4, arg5);
     721              UINT, pos,
     722              UINT, flags,
     723              UINT, id,
     724              LPCSTR, str)
     725{
     726    dprintf(("USER32: InsertMenuA %x %d %x %d %s", hMenu, pos, flags, id, str));
     727    if(hMenu == 0)
     728    {
     729        SetLastError(ERROR_INVALID_PARAMETER);
     730        return 0;
     731    }
     732
     733    if(!str || *str == NULL) {
     734        flags |= MF_SEPARATOR;
     735    }
     736    return O32_InsertMenu(hMenu, pos, flags, id, str);
    637737}
    638738//******************************************************************************
    … …  
    648748 char *astring = NULL;
    649749
    650     dprintf(("USER32:  OS2InsertMenuW %s\n", astring));
    651 
    652     if(arg3 & MF_STRING  && (int)arg5 >> 16 != 0)
     750    if(HIWORD(arg5) != 0)
    653751      astring = UnicodeToAsciiString((LPWSTR)arg5);
    654752    else
    655753      astring = (char *) arg5;
    656754
    657     rc = O32_InsertMenu(hMenu, arg2, arg3, arg4, astring);
    658     if(arg3 & MF_STRING  && (int)arg5 >> 16 != 0)
     755    rc = ODIN_InsertMenuA(hMenu, arg2, arg3, arg4, astring);
     756
     757    if(HIWORD(arg5) != 0)
    659758      FreeAsciiString(astring);
     759
    660760    return(rc);
    661761}
    … …  
    717817    dprintf(("USER32:  ChangeMenuA flags %X\n", flags));
    718818
    719     if (flags & MF_APPEND) return AppendMenuA(hMenu, flags & ~MF_APPEND,
    720                                              id, data );
    721     if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
    722     if (flags & MF_CHANGE) return ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
    723                                              id, data );
    724     if (flags & MF_REMOVE) return RemoveMenu(hMenu,
    725                                              flags & MF_BYPOSITION ? pos : id,
    726                                              flags & ~MF_REMOVE );
     819    if (flags & MF_APPEND) return ODIN_AppendMenuA(hMenu, flags & ~MF_APPEND,
     820                                                   id, data );
     821    if (flags & MF_DELETE) return ODIN_DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
     822    if (flags & MF_CHANGE) return ODIN_ModifyMenuA(hMenu, pos, flags & ~MF_CHANGE,
     823                                                   id, data );
     824    if (flags & MF_REMOVE) return ODIN_RemoveMenu(hMenu,
     825                                                  flags & MF_BYPOSITION ? pos : id,
     826                                                  flags & ~MF_REMOVE );
    727827    /* Default: MF_INSERT */
    728828    return InsertMenuA( hMenu, pos, flags, id, data );
    … …  
    739839    dprintf(("USER32:  ChangeMenuW flags %X\n", flags));
    740840
    741     if (flags & MF_APPEND) return AppendMenuW(hMenu, flags & ~MF_APPEND,
    742                                                  id, data );
    743     if (flags & MF_DELETE) return DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
    744     if (flags & MF_CHANGE) return ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
    745                                                  id, data );
    746     if (flags & MF_REMOVE) return RemoveMenu(hMenu,
    747                                              flags & MF_BYPOSITION ? pos : id,
    748                                              flags & ~MF_REMOVE );
     841    if (flags & MF_APPEND) return ODIN_AppendMenuW(hMenu, flags & ~MF_APPEND,
     842                                                   id, data );
     843    if (flags & MF_DELETE) return ODIN_DeleteMenu(hMenu, pos, flags & ~MF_DELETE);
     844    if (flags & MF_CHANGE) return ODIN_ModifyMenuW(hMenu, pos, flags & ~MF_CHANGE,
     845                                                   id, data );
     846    if (flags & MF_REMOVE) return ODIN_RemoveMenu(hMenu,
     847                                                  flags & MF_BYPOSITION ? pos : id,
     848                                                     flags & ~MF_REMOVE );
    749849    /* Default: MF_INSERT */
    750850    return InsertMenuW(hMenu, pos, flags, id, data);
    … …  
    761861
    762862    if (!hMenu) {
    763     SetLastError(ERROR_INVALID_PARAMETER);
    764     return FALSE;
     863        SetLastError(ERROR_INVALID_PARAMETER);
     864        return FALSE;
    765865    }
    766866    return TRUE;
    … …  
    841941        uItem = GetMenuItemID(hMenu, uItem);
    842942    }
    843     if(GetMenuState(hMenu, uItem, MF_BYCOMMAND) == -1) {
     943    if(ODIN_GetMenuState(hMenu, uItem, MF_BYCOMMAND) == -1) {
    844944        //item doesn't exist
    845945        dprintf(("USER32:  GetMenuItemInfoAW %x item %d doesn't exist", hMenu, uItem));
    … …  
    849949    if (lpmii->fMask & MIIM_TYPE)
    850950    {
    851         lpmii->fType = GetMenuState(hMenu, uItem, MF_BYCOMMAND); //not correct
    852 //      lpmii->fType = menu->fType;
    853             if (unicode) {
    854                 lpmii->cch = GetMenuStringW(hMenu, uItem, (LPWSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
    855             }
    856             else {
    857                 lpmii->cch = GetMenuStringA(hMenu, uItem, (LPSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
    858             }
    859 //TODO: 
    860 #if 0   
    861         switch (MENU_ITEM_TYPE(menu->fType)) {
    862                 case MF_STRING:
    863                     if (menu->text && lpmii->dwTypeData && lpmii->cch) {
    864                             if (unicode) {
    865                             lstrcpynAtoW((LPWSTR) lpmii->dwTypeData, menu->text, lpmii->cch);
    866                             lpmii->cch = lstrlenW((LPWSTR)menu->text);
    867                         }
    868                         else {
    869                             lstrcpynA(lpmii->dwTypeData, menu->text, lpmii->cch);
    870                             lpmii->cch = lstrlenA(menu->text);
    871                         }
    872                     }
    873                     break;
    874                 case MF_OWNERDRAW:
    875                 case MF_BITMAP:
    876                     lpmii->dwTypeData = menu->text;
    877                     /* fall through */
    878                 default:
    879                     lpmii->cch = 0;
    880             }
     951        lpmii->fType = ODIN_GetMenuState(hMenu, uItem, MF_BYCOMMAND); //not correct
     952//      lpmii->fType = menu->fType;
     953        if (unicode) {
     954            lpmii->cch = ODIN_GetMenuStringW(hMenu, uItem, (LPWSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
     955        }
     956        else {
     957            lpmii->cch = ODIN_GetMenuStringA(hMenu, uItem, (LPSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
     958        }
     959//TODO:
     960#if 0
     961        switch (MENU_ITEM_TYPE(menu->fType)) {
     962        case MF_STRING:
     963            if (menu->text && lpmii->dwTypeData && lpmii->cch) {
     964                if (unicode) {
     965                    lstrcpynAtoW((LPWSTR) lpmii->dwTypeData, menu->text, lpmii->cch);
     966                    lpmii->cch = lstrlenW((LPWSTR)menu->text);
     967                }
     968                else {
     969                    lstrcpynA(lpmii->dwTypeData, menu->text, lpmii->cch);
     970                    lpmii->cch = lstrlenA(menu->text);
     971                }
     972            }
     973            break;
     974        case MF_OWNERDRAW:
     975        case MF_BITMAP:
     976            lpmii->dwTypeData = menu->text;
     977            /* fall through */
     978        default:
     979            lpmii->cch = 0;
     980        }
    881981#endif
    882982    }
    883983
    884984    if (lpmii->fMask & MIIM_STRING) {
    885             if (unicode) {
    886                 lpmii->cch = GetMenuStringW(hMenu, uItem, (LPWSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
    887             }
    888             else {
    889                 lpmii->cch = GetMenuStringA(hMenu, uItem, (LPSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
    890             }
     985        if (unicode) {
     986            lpmii->cch = ODIN_GetMenuStringW(hMenu, uItem, (LPWSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
     987        }
     988        else {
     989            lpmii->cch = ODIN_GetMenuStringA(hMenu, uItem, (LPSTR)lpmii->dwTypeData, lpmii->cch, MF_BYCOMMAND);
     990        }
    891991    }
    892992
    … …  
    894994#if 0
    895995    if (lpmii->fMask & MIIM_FTYPE)
    896             lpmii->fType = menu->fType;
     996        lpmii->fType = menu->fType;
    897997
    898998    if (lpmii->fMask & MIIM_BITMAP)
    899             lpmii->hbmpItem = menu->hbmpItem;
     999        lpmii->hbmpItem = menu->hbmpItem;
    9001000#endif
    9011001
    9021002    if (lpmii->fMask & MIIM_STATE)
    903             lpmii->fState = GetMenuState(hMenu, uItem, MF_BYCOMMAND);
     1003        lpmii->fState = ODIN_GetMenuState(hMenu, uItem, MF_BYCOMMAND);
    9041004
    9051005    if (lpmii->fMask & MIIM_ID)
    906             lpmii->wID = uItem;
     1006        lpmii->wID = uItem;
    9071007
    9081008//TODO:
    … …  
    9141014#else
    9151015    if (lpmii->fMask & MIIM_SUBMENU)
    916             lpmii->hSubMenu = GetSubMenu(hMenu, uItem); //need index, not id
     1016        lpmii->hSubMenu = ODIN_GetSubMenu(hMenu, uItem); //need index, not id
    9171017
    9181018    if (lpmii->fMask & MIIM_CHECKMARKS) {
    919             lpmii->hbmpChecked = menu->hCheckBit;
    920             lpmii->hbmpUnchecked = menu->hUnCheckBit;
     1019        lpmii->hbmpChecked = menu->hCheckBit;
     1020        lpmii->hbmpUnchecked = menu->hUnCheckBit;
    9211021    }
    9221022    if (lpmii->fMask & MIIM_DATA)
    923             lpmii->dwItemData = menu->dwItemData;
     1023        lpmii->dwItemData = menu->dwItemData;
    9241024#endif
    9251025
    … …  
    10081108              const MENUITEMINFOA*, lpmii)
    10091109{
    1010   dprintf(("USER32:InsertMenuItemA (%08xh,%08xh,%u,%08x) not implemented.\n",
     1110    dprintf(("USER32:InsertMenuItemA (%08xh,%08xh,%u,%08x) not correctly implemented.\n",
    10111111         hMenu,
    10121112         uItem,
    … …  
    10141114         lpmii));
    10151115
    1016    return (FALSE);
     1116    if(fByPosition) {
     1117            return ODIN_InsertMenuA(hMenu, uItem, lpmii->fType | MF_BYPOSITION, (lpmii->fType & MF_POPUP) ? lpmii->hSubMenu : lpmii->wID, lpmii->dwTypeData);
     1118    }
     1119    else    return ODIN_InsertMenuA(hMenu, uItem, lpmii->fType | MF_BYCOMMAND, (lpmii->fType & MF_POPUP) ? lpmii->hSubMenu : lpmii->wID, lpmii->dwTypeData);
    10171120}
    10181121
    … …  
    10391142              const MENUITEMINFOW *, lpmii)
    10401143{
    1041   dprintf(("USER32:InsertMenuItemW (%08xh,%08xh,%u,%08x) not implemented.\n",
     1144    dprintf(("USER32:InsertMenuItemW (%08xh,%08xh,%u,%08x) not correctly implemented.\n",
    10421145         hMenu,
    10431146         uItem,
    … …  
    10451148         lpmii));
    10461149
    1047    return (FALSE);
     1150    if(fByPosition) {
     1151            return ODIN_InsertMenuW(hMenu, uItem, lpmii->fType | MF_BYPOSITION, (lpmii->fType & MF_POPUP) ? lpmii->hSubMenu : lpmii->wID, lpmii->dwTypeData);
     1152    }
     1153    else    return ODIN_InsertMenuW(hMenu, uItem, lpmii->fType | MF_BYCOMMAND, (lpmii->fType & MF_POPUP) ? lpmii->hSubMenu : lpmii->wID, lpmii->dwTypeData);
    10481154}
    10491155/*****************************************************************************
Note: See TracChangeset for help on using the changeset viewer.