imemenu.c File Reference

#include "kbswitch.h"
#include "imemenu.h"
#include <wine/debug.h>

Include dependency graph for imemenu.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (internat)
static BOOL	MakeImeMenu (_In_ HMENU hMenu, _In_ const IMEMENUNODE *pMenu)
static VOID	AddImeMenuNode (_In_ PIMEMENUNODE pMenu)
static PIMEMENUNODE	AllocateImeMenu (_In_ DWORD itemCount)
static VOID	GetImeMenuItem (_In_ HIMC hIMC, _Out_ PIMEMENUITEMINFO lpImeParentMenu, _In_ BOOL bRightMenu, _Out_ PIMEMENUITEM pItem)
PIMEMENUNODE	CreateImeMenu (_In_ HIMC hIMC, _Inout_opt_ PIMEMENUITEMINFO lpImeParentMenu, _In_ BOOL bRightMenu)
static BOOL	FillImeMenuItem (_Out_ LPMENUITEMINFO pItemInfo, _In_ const IMEMENUITEM *pItem)
HMENU	MenuFromImeMenu (_In_ const IMEMENUNODE *pMenu)
INT	GetRealImeMenuID (_In_ const IMEMENUNODE *pMenu, _In_ INT nFakeID)
static BOOL	FreeMenuNode (_In_ PIMEMENUNODE pMenuNode)
VOID	CleanupImeMenus (VOID)

Variables
PIMEMENUNODE	g_pMenuList = NULL
INT	g_nNextMenuID = 0

Function Documentation

AddImeMenuNode()

static VOID AddImeMenuNode ( _In_ PIMEMENUNODE  pMenu )

static

Definition at line 20 of file imemenu.c.

{
    if (!g_pMenuList)
    {
        g_pMenuList = pMenu;
        return;
    }
 
    pMenu->m_pNext = g_pMenuList;
    g_pMenuList = pMenu;
}

Referenced by AllocateImeMenu().

AllocateImeMenu()

static PIMEMENUNODE AllocateImeMenu ( _In_ DWORD  itemCount )

static

Definition at line 33 of file imemenu.c.

{
    SIZE_T cbMenu = sizeof(IMEMENUNODE) + (itemCount - 1) * sizeof(IMEMENUITEM);
    PIMEMENUNODE pMenu = LocalAlloc(LPTR, cbMenu);
    if (!pMenu)
        return NULL;
    pMenu->m_nItems = itemCount;
    AddImeMenuNode(pMenu);
    return pMenu;
}

Referenced by CreateImeMenu().

CleanupImeMenus()

VOID CleanupImeMenus

(

VOID

)

Definition at line 246 of file imemenu.c.

{
    if (!g_pMenuList)
        return;
 
    PIMEMENUNODE pNext;
    for (PIMEMENUNODE pNode = g_pMenuList; pNode; pNode = pNext)
    {
        pNext = pNode->m_pNext;
        FreeMenuNode(pNode);
    }
 
    g_pMenuList = NULL;
    g_nNextMenuID = 0;
}

Referenced by KbSwitch_OnPenIconMsg().

CreateImeMenu()

PIMEMENUNODE CreateImeMenu	(	_In_ HIMC	hIMC,
		_Inout_opt_ PIMEMENUITEMINFO	lpImeParentMenu,
		_In_ BOOL	bRightMenu
	)

Definition at line 62 of file imemenu.c.

{
    const DWORD dwFlags = (bRightMenu ? IGIMIF_RIGHTMENU : 0);
    const DWORD dwTypes = IGIMII_CMODE     |
                          IGIMII_SMODE     |
                          IGIMII_CONFIGURE |
                          IGIMII_TOOLS     |
                          IGIMII_HELP      |
                          IGIMII_OTHER;
    DWORD itemCount = ImmGetImeMenuItems(hIMC, dwFlags, dwTypes, lpImeParentMenu, NULL, 0);
    if (!itemCount)
        return NULL;
 
    PIMEMENUNODE pMenu = AllocateImeMenu(itemCount);
    if (!pMenu)
        return NULL;
 
    DWORD cbItems = sizeof(IMEMENUITEMINFO) * itemCount;
    PIMEMENUITEMINFO pImeMenuItems = LocalAlloc(LPTR, cbItems);
    if (!pImeMenuItems)
    {
        LocalFree(pMenu);
        return NULL;
    }
 
    itemCount = ImmGetImeMenuItems(hIMC, dwFlags, dwTypes, lpImeParentMenu, pImeMenuItems, cbItems);
    if (!itemCount)
    {
        LocalFree(pImeMenuItems);
        LocalFree(pMenu);
        return NULL;
    }
 
    PIMEMENUITEM pItems = pMenu->m_Items;
    for (DWORD iItem = 0; iItem < itemCount; ++iItem)
    {
        GetImeMenuItem(hIMC, &pImeMenuItems[iItem], bRightMenu, &pItems[iItem]);
    }
 
    LocalFree(pImeMenuItems);
    return pMenu;
}

Referenced by GetImeMenuItem(), and KbSwitch_OnPenIconMsg().

FillImeMenuItem()

static BOOL FillImeMenuItem ( _Out_ LPMENUITEMINFO  pItemInfo, _In_ const IMEMENUITEM *  pItem  )

static

Definition at line 109 of file imemenu.c.

{
    ZeroMemory(pItemInfo, sizeof(MENUITEMINFO));
    pItemInfo->cbSize = sizeof(MENUITEMINFO);
    pItemInfo->fMask = MIIM_ID | MIIM_STATE | MIIM_DATA;
    pItemInfo->wID = pItem->m_Info.wID;
    pItemInfo->fState = pItem->m_Info.fState;
    pItemInfo->dwItemData = pItem->m_Info.dwItemData;
 
    if (pItem->m_Info.fType)
    {
        pItemInfo->fMask |= MIIM_FTYPE;
        pItemInfo->fType = 0;
        if (pItem->m_Info.fType & IMFT_RADIOCHECK)
            pItemInfo->fType |= MFT_RADIOCHECK;
        if (pItem->m_Info.fType & IMFT_SEPARATOR)
            pItemInfo->fType |= MFT_SEPARATOR;
    }
 
    if (pItem->m_Info.fType & IMFT_SUBMENU)
    {
        pItemInfo->fMask |= MIIM_SUBMENU;
        pItemInfo->hSubMenu = CreatePopupMenu();
        if (!MakeImeMenu(pItemInfo->hSubMenu, pItem->m_pSubMenu))
        {
            DestroyMenu(pItemInfo->hSubMenu);
            pItemInfo->hSubMenu = NULL;
            return FALSE;
        }
    }
 
    if (pItem->m_Info.hbmpChecked && pItem->m_Info.hbmpUnchecked)
    {
        pItemInfo->fMask |= MIIM_CHECKMARKS;
        pItemInfo->hbmpChecked = pItem->m_Info.hbmpChecked;
        pItemInfo->hbmpUnchecked = pItem->m_Info.hbmpUnchecked;
    }
 
    if (pItem->m_Info.hbmpItem)
    {
        pItemInfo->fMask |= MIIM_BITMAP;
        pItemInfo->hbmpItem = pItem->m_Info.hbmpItem;
    }
 
    PCTSTR szString = pItem->m_Info.szString;
    if (szString && szString[0])
    {
        pItemInfo->fMask |= MIIM_STRING;
        pItemInfo->dwTypeData = (PTSTR)szString;
        pItemInfo->cch = lstrlen(szString);
    }
 
    return TRUE;
}

Referenced by MakeImeMenu().

FreeMenuNode()

static BOOL FreeMenuNode ( _In_ PIMEMENUNODE  pMenuNode )

static

Definition at line 225 of file imemenu.c.

{
    if (!pMenuNode)
        return FALSE;
 
    for (INT iItem = 0; iItem < pMenuNode->m_nItems; ++iItem)
    {
        PIMEMENUITEM pItem = &pMenuNode->m_Items[iItem];
        if (pItem->m_Info.hbmpChecked)
            DeleteObject(pItem->m_Info.hbmpChecked);
        if (pItem->m_Info.hbmpUnchecked)
            DeleteObject(pItem->m_Info.hbmpUnchecked);
        if (pItem->m_Info.hbmpItem)
            DeleteObject(pItem->m_Info.hbmpItem);
    }
 
    LocalFree(pMenuNode);
    return TRUE;
}

Referenced by CleanupImeMenus().

GetImeMenuItem()

static VOID GetImeMenuItem ( _In_ HIMC  hIMC, _Out_ PIMEMENUITEMINFO  lpImeParentMenu, _In_ BOOL  bRightMenu, _Out_ PIMEMENUITEM  pItem  )

static

Definition at line 45 of file imemenu.c.

{
    ZeroMemory(pItem, sizeof(IMEMENUITEM));
    pItem->m_Info = *lpImeParentMenu;
 
    if (lpImeParentMenu->fType & IMFT_SUBMENU)
        pItem->m_pSubMenu = CreateImeMenu(hIMC, lpImeParentMenu, bRightMenu);
 
    pItem->m_nRealID = pItem->m_Info.wID;
    pItem->m_Info.wID = ID_STARTIMEMENU + g_nNextMenuID++;
}

Referenced by CreateImeMenu().

GetRealImeMenuID()

INT GetRealImeMenuID	(	_In_ const IMEMENUNODE *	pMenu,
		_In_ INT	nFakeID
	)

Definition at line 202 of file imemenu.c.

{
    if (!pMenu || !pMenu->m_nItems || nFakeID < ID_STARTIMEMENU)
        return 0;
 
    for (INT iItem = 0; iItem < pMenu->m_nItems; ++iItem)
    {
        const IMEMENUITEM *pItem = &pMenu->m_Items[iItem];
        if (pItem->m_Info.wID == nFakeID)
            return pItem->m_nRealID;
 
        if (pItem->m_pSubMenu)
        {
            INT nRealID = GetRealImeMenuID(pItem->m_pSubMenu, nFakeID);
            if (nRealID)
                return nRealID;
        }
    }
 
    return 0;
}

Referenced by GetRealImeMenuID(), and KbSwitch_OnPenIconMsg().

MakeImeMenu()

static BOOL MakeImeMenu ( _In_ HMENU  hMenu, _In_ const IMEMENUNODE *  pMenu  )

static

Definition at line 165 of file imemenu.c.

{
    if (!pMenu || !pMenu->m_nItems)
        return FALSE;
 
    for (INT iItem = 0; iItem < pMenu->m_nItems; ++iItem)
    {
        MENUITEMINFO mi = { sizeof(mi) };
        if (!FillImeMenuItem(&mi, &pMenu->m_Items[iItem]))
        {
            ERR("FillImeMenuItem failed\n");
            return FALSE;
        }
        if (!InsertMenuItem(hMenu, iItem, TRUE, &mi))
        {
            ERR("InsertMenuItem failed\n");
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by FillImeMenuItem(), and MenuFromImeMenu().

MenuFromImeMenu()

HMENU MenuFromImeMenu

(

_In_ const IMEMENUNODE *

pMenu

)

Definition at line 188 of file imemenu.c.

{
    HMENU hMenu = CreatePopupMenu();
    if (!pMenu)
        return hMenu;
    if (!MakeImeMenu(hMenu, pMenu))
    {
        DestroyMenu(hMenu);
        return NULL;
    }
    return hMenu;
}

Referenced by KbSwitch_OnPenIconMsg().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

internat

)

Variable Documentation

g_nNextMenuID

INT g_nNextMenuID = 0

Definition at line 15 of file imemenu.c.

Referenced by CleanupImeMenus(), and GetImeMenuItem().

g_pMenuList

PIMEMENUNODE g_pMenuList = NULL

Definition at line 14 of file imemenu.c.

Referenced by AddImeMenuNode(), and CleanupImeMenus().