bool PopupMenu::handleSelect(U32 command, const char *text /* = NULL */)
{
// [tom, 8/20/2006] Pass off to a sub menu if it's for them
for(S32 i = 0;i < mSubmenus->size();i++)
{
PopupMenu *subM = dynamic_cast<PopupMenu *>((*mSubmenus)[i]);
if(subM == NULL)
continue;
if(subM->canHandleID(command))
{
return subM->handleSelect(command, text);
}
}
// [tom, 8/21/2006] Cheesey hack to find the position based on ID
char buf[512];
MENUITEMINFOA mi;
mi.cbSize = sizeof(mi);
mi.dwTypeData = NULL;
S32 numItems = GetMenuItemCount(mData->mMenu);
S32 pos = -1;
for(S32 i = 0;i < numItems;i++)
{
mi.fMask = MIIM_ID|MIIM_STRING|MIIM_STATE;
if(GetMenuItemInfoA(mData->mMenu, i, TRUE, &mi))
{
if(mi.wID == command)
{
if(text == NULL)
{
mi.dwTypeData = buf;
mi.cch++;
GetMenuItemInfoA(mData->mMenu, i, TRUE, &mi);
// [tom, 5/11/2007] Don't do anything if the menu item is disabled
if(mi.fState & MFS_DISABLED)
return false;
text = StringTable->insert(mi.dwTypeData);
}
pos = i;
break;
}
}
}
if(pos == -1)
{
Con::errorf("PopupMenu::handleSelect - Could not find menu item position for ID %d ... this shouldn't happen!", command);
return false;
}
// [tom, 8/20/2006] Wasn't handled by a submenu, pass off to script
return dAtob(Con::executef(this, "onSelectItem", Con::getIntArg(pos), text ? text : ""));
}
S32 PopupMenu::getPosOnMenuBar()
{
if(mCanvas == NULL)
return -1;
Win32Window *pWindow = mCanvas ? dynamic_cast<Win32Window*>(mCanvas->getPlatformWindow()) : NULL;
if(pWindow == NULL)
return -1;
HMENU hMenuHandle = pWindow->getMenuHandle();
S32 numItems = GetMenuItemCount(hMenuHandle);
S32 pos = -1;
for(S32 i = 0;i < numItems;i++)
{
MENUITEMINFOA mi;
mi.cbSize = sizeof(mi);
mi.fMask = MIIM_DATA;
if(GetMenuItemInfoA(hMenuHandle, i, TRUE, &mi))
{
if(mi.fMask & MIIM_DATA)
{
PopupMenu *mnu = (PopupMenu *)mi.dwItemData;
if(mnu == this)
{
pos = i;
break;
}
}
}
}
return pos;
}
void PopupMenu::removeItem(S32 itemPos)
{
Win32Window *pWindow = mCanvas ? dynamic_cast<Win32Window*>(mCanvas->getPlatformWindow()) : NULL;
bool isAttached = isAttachedToMenuBar();
if(isAttached && pWindow == NULL)
return;
MENUITEMINFOA mi;
mi.cbSize = sizeof(mi);
mi.fMask = MIIM_DATA|MIIM_ID;
if(GetMenuItemInfoA(mData->mMenu, itemPos, TRUE, &mi))
{
bool submenu = false;
// Update list of submenus if this is a submenu
if(mi.fMask & MIIM_DATA)
{
PopupMenu *mnu = (PopupMenu *)mi.dwItemData;
if( mnu != NULL )
{
if(isAttached)
pWindow->removeAccelerators(mnu->mData->mAccelerators);
mSubmenus->removeObject(mnu);
submenu = true;
}
}
if(! submenu)
{
// Update accelerators if this has an accelerator and wasn't a sub menu
for(S32 i = 0;i < mData->mAccelerators.size();++i)
{
if(mData->mAccelerators[i].mID == mi.wID)
{
if(isAttached)
pWindow->removeAccelerators(mData->mAccelerators);
mData->mAccelerators.erase(i);
if(isAttached)
pWindow->addAccelerators(mData->mAccelerators);
break;
}
}
}
}
else
return;
RemoveMenu(mData->mMenu, itemPos, MF_BYPOSITION);
if(isAttached)
{
HWND hWindow = pWindow->getHWND();
DrawMenuBar(hWindow);
}
}
bool PopupMenu::isItemChecked(S32 pos)
{
MENUITEMINFOA mi;
mi.cbSize = sizeof(mi);
mi.fMask = MIIM_STATE;
if(GetMenuItemInfoA(mData->mMenu, pos, TRUE, &mi) && (mi.fState & MFS_CHECKED))
return true;
return false;
}
void CWindowsFunctions::RecursiveTranslateMenu(HMENU menu)
{
int items = GetMenuItemCount(menu);
if (items > 0)
{
for (int i = 0; i < items; i++)
{
// Get menu type and text length
MENUITEMINFOA info;
info.cbSize = sizeof(MENUITEMINFOA);
info.dwTypeData = NULL;
info.fMask = MIIM_FTYPE | MIIM_STRING;
GetMenuItemInfoA(menu, i, true, &info);
// Ignore seperators and other junk we don't need to translate
if (info.fType & ~MFT_STRING || info.cch == 1) continue;
// Get submenu and text
info.cch += 1;
info.dwTypeData = new char[info.cch];
info.fMask = MIIM_SUBMENU | MIIM_STRING;
GetMenuItemInfoA(menu, i, true, &info);
// Recursion
if (info.hSubMenu != NULL)
{
RecursiveTranslateMenu(info.hSubMenu);
}
// Translation
bool result = m_resources->TranslateUserInterface(info.dwTypeData, m_uiBuffer, UI_BUFFER);
delete[] info.dwTypeData;
if (result)
{
// info.cch = strnlen(m_uiBuffer, UI_BUFFER - 1) + 1;
info.dwTypeData = m_uiBuffer;
info.fMask = MIIM_STRING;
SetMenuItemInfoA(menu, i, true, &info);
}
}
}
}
VDStringW VDGetMenuItemTextByCommandW32(HMENU hmenu, UINT cmd) {
VDStringW s;
if (VDIsWindowsNT()) {
MENUITEMINFOW mmiW;
vdfastfixedvector<wchar_t, 256> bufW;
mmiW.cbSize = MENUITEMINFO_SIZE_VERSION_400W;
mmiW.fMask = MIIM_TYPE;
mmiW.fType = MFT_STRING;
mmiW.dwTypeData = NULL;
mmiW.cch = 0; // required to avoid crash on NT4
if (GetMenuItemInfoW(hmenu, cmd, FALSE, &mmiW)) {
bufW.resize(mmiW.cch + 1, 0);
++mmiW.cch;
mmiW.dwTypeData = bufW.data();
if (GetMenuItemInfoW(hmenu, cmd, FALSE, &mmiW))
s = bufW.data();
}
} else {
MENUITEMINFOA mmiA;
vdfastfixedvector<char, 256> bufA;
mmiA.cbSize = MENUITEMINFO_SIZE_VERSION_400A;
mmiA.fMask = MIIM_TYPE;
mmiA.fType = MFT_STRING;
mmiA.dwTypeData = NULL;
if (GetMenuItemInfoA(hmenu, cmd, FALSE, &mmiA)) {
bufA.resize(mmiA.cch + 1, 0);
++mmiA.cch;
mmiA.dwTypeData = bufA.data();
if (GetMenuItemInfoA(hmenu, cmd, FALSE, &mmiA))
s = VDTextAToW(bufA.data());
}
}
return s;
}
void setMenuCommand(HMENU& menu, int i, eMenu cmd) {
static char title[256];
MENUITEMINFOA item;
item.cbSize = sizeof(MENUITEMINFOA);
item.cch = 255;
item.dwTypeData = title;
item.fMask = MIIM_ID | MIIM_FTYPE | MIIM_STRING;
GetMenuItemInfoA(menu, i++, true, &item);
if(item.fType == MFT_SEPARATOR) return;
menuChoices[item.wID] = cmd;
// Now set up the accelerator, if any
std::string item_name = item.dwTypeData;
size_t pos = item_name.find_last_of('\t');
if(pos == std::string::npos) return;
pos++;
if(pos >= item_name.size()) return;
std::string key_name = item_name.substr(pos);
accel.add(item.wID, key_name);
}
BOOL GetMenuItemInfoUTF8( HMENU hMenu,UINT uItem, BOOL fByPosition, LPMENUITEMINFO lpmii)
{
if (!lpmii) return FALSE;
if ((lpmii->fMask & MIIM_TYPE) && lpmii->dwTypeData && lpmii->cch AND_IS_NOT_WIN9X)
{
MENUITEMINFOW tmp = *(MENUITEMINFOW*)lpmii;
WIDETOMB_ALLOC(wbuf,lpmii->cch);
if (wbuf)
{
BOOL rv;
char *otd=lpmii->dwTypeData;
int osz=lpmii->cbSize;
tmp.cbSize=sizeof(tmp);
tmp.dwTypeData = wbuf;
tmp.cch = (UINT)(wbuf_size/sizeof(WCHAR));
rv=GetMenuItemInfoW(hMenu,uItem,fByPosition,&tmp);
if (rv && (tmp.fType&(MFT_SEPARATOR|MFT_STRING|MFT_BITMAP)) == MFT_STRING)
{
if (!WideCharToMultiByte(CP_UTF8,0,wbuf,-1,lpmii->dwTypeData,lpmii->cch,NULL,NULL) && GetLastError()==ERROR_INSUFFICIENT_BUFFER)
{
lpmii->dwTypeData[lpmii->cch-1]=0;
}
*lpmii = *(MENUITEMINFO*)&tmp; // copy results
lpmii->cbSize=osz; // restore old stuff
lpmii->dwTypeData = otd;
}
else rv=0;
WIDETOMB_FREE(wbuf);
if (rv)return rv;
}
}
return GetMenuItemInfoA(hMenu,uItem,fByPosition,lpmii);
}
/* MAKE_EXPORT GetMenuItemInfoW_new=GetMenuItemInfoW */
BOOL WINAPI GetMenuItemInfoW_new(HMENU hMenu, UINT uItem, BOOL fByPosition, LPMENUITEMINFOW lpmii)
{
MENUITEMINFOA mii;
LPWSTR lpTypeData;
BOOL result;
if(IsBadWritePtr(lpmii, sizeof(MENUITEMINFOW)))
return FALSE;
memcpy(&mii, lpmii, sizeof(MENUITEMINFOA));
result = GetMenuItemInfoA(hMenu, uItem, fByPosition, &mii);
if(!result)
return FALSE;
STACK_AtoW(mii.dwTypeData, lpTypeData);
memcpy(lpmii, &mii, sizeof(MENUITEMINFOW));
lpmii->dwTypeData = lpTypeData;
return result;
}
LONG_PTR CALLBACK HotkeyHandlerDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static POINT ptLast;
static int iMousedown;
if (msg == WM_TASKBARCREATED) {
CreateSystrayIcon(FALSE);
if (nen_options.bTraySupport)
CreateSystrayIcon(TRUE);
return 0;
}
switch (msg) {
case WM_CREATE:
int i;
for(i = 0; i < safe_sizeof(_hotkeydescs); i++) {
_hotkeydescs[i].cbSize = sizeof(HOTKEYDESC);
CallService(MS_HOTKEY_REGISTER, 0, (LPARAM)&_hotkeydescs[i]);
}
WM_TASKBARCREATED = RegisterWindowMessageA("TaskbarCreated");
ShowWindow(hwndDlg, SW_HIDE);
hSvcHotkeyProcessor = CreateServiceFunction(MS_TABMSG_HOTKEYPROCESS, HotkeyProcessor);
SetTimer(hwndDlg, TIMERID_SENDLATER, TIMEOUT_SENDLATER, NULL);
break;
case WM_HOTKEY: {
CLISTEVENT *cli = 0;
cli = (CLISTEVENT *)CallService(MS_CLIST_GETEVENT, (WPARAM)INVALID_HANDLE_VALUE, (LPARAM)0);
if (cli != NULL) {
if (strncmp(cli->pszService, "SRMsg/TypingMessage", strlen(cli->pszService))) {
CallService(cli->pszService, 0, (LPARAM)cli);
break;
}
}
if (wParam == 0xc001)
SendMessage(hwndDlg, DM_TRAYICONNOTIFY, 101, WM_MBUTTONDOWN);
break;
}
/*
* handle the popup menus (session list, favorites, recents...
* just draw some icons, nothing more :)
*/
case WM_MEASUREITEM: {
LPMEASUREITEMSTRUCT lpmi = (LPMEASUREITEMSTRUCT) lParam;
lpmi->itemHeight = 0;
lpmi->itemWidth = 6;
return TRUE;
}
case WM_DRAWITEM: {
LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT) lParam;
struct TWindowData *dat = 0;
if (dis->CtlType == ODT_MENU && (dis->hwndItem == (HWND)PluginConfig.g_hMenuFavorites || dis->hwndItem == (HWND)PluginConfig.g_hMenuRecent)) {
HICON hIcon = (HICON)dis->itemData;
DrawMenuItem(dis, hIcon, 0);
return TRUE;
} else if (dis->CtlType == ODT_MENU) {
HWND hWnd = M->FindWindow((HANDLE)dis->itemID);
DWORD idle = 0;
if (hWnd == NULL) {
SESSION_INFO *si = SM_FindSessionByHCONTACT((HANDLE)dis->itemID);
hWnd = si ? si->hWnd : 0;
}
if (hWnd)
dat = (struct TWindowData *)GetWindowLongPtr(hWnd, GWLP_USERDATA);
if (dis->itemData >= 0) {
HICON hIcon;
BOOL fNeedFree = FALSE;
if (dis->itemData > 0)
hIcon = dis->itemData & 0x10000000 ? hIcons[ICON_HIGHLIGHT] : PluginConfig.g_IconMsgEvent;
else if (dat != NULL) {
hIcon = MY_GetContactIcon(dat);
idle = dat->idle;
} else
hIcon = PluginConfig.g_iconContainer;
DrawMenuItem(dis, hIcon, idle);
if (fNeedFree)
DestroyIcon(hIcon);
return TRUE;
}
}
}
break;
case DM_TRAYICONNOTIFY: {
int iSelection;
if (wParam == 100 || wParam == 101) {
switch (lParam) {
case WM_LBUTTONUP: {
POINT pt;
GetCursorPos(&pt);
if (wParam == 100)
SetForegroundWindow(hwndDlg);
if (GetMenuItemCount(PluginConfig.g_hMenuTrayUnread) > 0) {
iSelection = TrackPopupMenu(PluginConfig.g_hMenuTrayUnread, TPM_RETURNCMD, pt.x, pt.y, 0, hwndDlg, NULL);
HandleMenuEntryFromhContact(iSelection);
} else
TrackPopupMenu(GetSubMenu(PluginConfig.g_hMenuContext, 8), TPM_RETURNCMD, pt.x, pt.y, 0, hwndDlg, NULL);
if (wParam == 100)
PostMessage(hwndDlg, WM_NULL, 0, 0);
break;
}
case WM_MBUTTONDOWN: {
MENUITEMINFOA mii = {0};
int i, iCount = GetMenuItemCount(PluginConfig.g_hMenuTrayUnread);
if (wParam == 100)
SetForegroundWindow(hwndDlg);
if (iCount > 0) {
UINT uid = 0;
mii.fMask = MIIM_DATA;
mii.cbSize = sizeof(mii);
i = iCount - 1;
do {
GetMenuItemInfoA(PluginConfig.g_hMenuTrayUnread, i, TRUE, &mii);
if (mii.dwItemData > 0) {
uid = GetMenuItemID(PluginConfig.g_hMenuTrayUnread, i);
HandleMenuEntryFromhContact(uid);
break;
}
} while (--i >= 0);
if (uid == 0 && pLastActiveContainer != NULL) { // no session found, restore last active container
if (IsIconic(pLastActiveContainer->hwnd) || !IsWindowVisible(pLastActiveContainer->hwnd)) {
SendMessage(pLastActiveContainer->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
SetForegroundWindow(pLastActiveContainer->hwnd);
} else {
if(PluginConfig.m_HideOnClose)
ShowWindow(pLastActiveContainer->hwnd, SW_HIDE);
else
SendMessage(pLastActiveContainer->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 0);
}
}
}
if (wParam == 100)
PostMessage(hwndDlg, WM_NULL, 0, 0);
break;
}
case WM_RBUTTONUP: {
HMENU submenu = PluginConfig.g_hMenuTrayContext;
POINT pt;
if (wParam == 100)
SetForegroundWindow(hwndDlg);
GetCursorPos(&pt);
CheckMenuItem(submenu, ID_TRAYCONTEXT_DISABLEALLPOPUPS, MF_BYCOMMAND | (nen_options.iDisable ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(submenu, ID_TRAYCONTEXT_DON40223, MF_BYCOMMAND | (nen_options.iNoSounds ? MF_CHECKED : MF_UNCHECKED));
CheckMenuItem(submenu, ID_TRAYCONTEXT_DON, MF_BYCOMMAND | (nen_options.iNoAutoPopup ? MF_CHECKED : MF_UNCHECKED));
EnableMenuItem(submenu, ID_TRAYCONTEXT_HIDEALLMESSAGECONTAINERS, MF_BYCOMMAND | (nen_options.bTraySupport) ? MF_ENABLED : MF_GRAYED);
CheckMenuItem(submenu, ID_TRAYCONTEXT_SHOWTHETRAYICON, MF_BYCOMMAND | (nen_options.bTraySupport ? MF_CHECKED : MF_UNCHECKED));
iSelection = TrackPopupMenu(submenu, TPM_RETURNCMD, pt.x, pt.y, 0, hwndDlg, NULL);
if (iSelection) {
MENUITEMINFO mii = {0};
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA | MIIM_ID;
GetMenuItemInfo(submenu, (UINT_PTR)iSelection, FALSE, &mii);
if (mii.dwItemData != 0) { // this must be an itm of the fav or recent menu
HandleMenuEntryFromhContact(iSelection);
} else {
switch (iSelection) {
case ID_TRAYCONTEXT_SHOWTHETRAYICON:
nen_options.bTraySupport = !nen_options.bTraySupport;
CreateSystrayIcon(nen_options.bTraySupport ? TRUE : FALSE);
break;
case ID_TRAYCONTEXT_DISABLEALLPOPUPS:
nen_options.iDisable ^= 1;
break;
case ID_TRAYCONTEXT_DON40223:
nen_options.iNoSounds ^= 1;
break;
case ID_TRAYCONTEXT_DON:
nen_options.iNoAutoPopup ^= 1;
break;
case ID_TRAYCONTEXT_HIDEALLMESSAGECONTAINERS: {
struct TContainerData *pContainer = pFirstContainer;
while (pContainer) {
ShowWindow(pContainer->hwnd, SW_HIDE);
pContainer = pContainer->pNextContainer;
}
break;
}
case ID_TRAYCONTEXT_RESTOREALLMESSAGECONTAINERS: {
struct TContainerData *pContainer = pFirstContainer;
while (pContainer) {
ShowWindow(pContainer->hwnd, SW_SHOW);
pContainer = pContainer->pNextContainer;
}
break;
}
case ID_TRAYCONTEXT_BE: {
struct TContainerData *pContainer = pFirstContainer;
nen_options.iDisable = 1;
nen_options.iNoSounds = 1;
nen_options.iNoAutoPopup = 1;
while (pContainer) {
SendMessage(pContainer->hwnd, WM_SYSCOMMAND, SC_MINIMIZE, 1);
pContainer = pContainer->pNextContainer;
}
break;
}
}
}
}
if (wParam == 100)
PostMessage(hwndDlg, WM_NULL, 0, 0);
break;
}
default:
break;
}
}
break;
}
/*
* handle an event from the popup module (mostly window activation). Since popups may run in different threads, the message
* is posted to our invisible hotkey handler which does always run within the main thread.
* wParam is the hContact
* lParam the event handle
*/
case DM_HANDLECLISTEVENT: {
CLISTEVENT *cle = (CLISTEVENT *)CallService(MS_CLIST_GETEVENT, wParam, 0);
/*
* if lParam == NULL, don't consider clist events, just open the message tab
*/
if(lParam == 0) {
HandleMenuEntryFromhContact((int)wParam);
break;
}
/*
* first try, if the clist returned an event...
*/
if (cle) {
if (ServiceExists(cle->pszService)) {
CallService(cle->pszService, (WPARAM)NULL, (LPARAM)cle);
CallService(MS_CLIST_REMOVEEVENT, (WPARAM)cle->hContact, (LPARAM)cle->hDbEvent);
}
} else { // still, we got that message posted.. the event may be waiting in tabSRMMs tray...
HandleMenuEntryFromhContact((int)wParam);
}
break;
}
case DM_DOCREATETAB: {
HWND hWnd = M->FindWindow((HANDLE)lParam);
if (hWnd && IsWindow(hWnd)) {
struct TContainerData *pContainer = 0;
SendMessage(hWnd, DM_QUERYCONTAINER, 0, (LPARAM)&pContainer);
if (pContainer) {
int iTabs = TabCtrl_GetItemCount(GetDlgItem(pContainer->hwnd, IDC_MSGTABS));
if (iTabs == 1)
SendMessage(pContainer->hwnd, WM_CLOSE, 0, 1);
else
SendMessage(hWnd, WM_CLOSE, 0, 1);
CreateNewTabForContact((struct TContainerData *)wParam, (HANDLE)lParam, 0, NULL, TRUE, TRUE, FALSE, 0);
}
}
break;
}
case DM_DOCREATETAB_CHAT: {
SESSION_INFO *si = SM_FindSessionByHWND((HWND)lParam);
if (si && IsWindow(si->hWnd)) {
struct TContainerData *pContainer = 0;
SendMessage(si->hWnd, DM_QUERYCONTAINER, 0, (LPARAM)&pContainer);
if (pContainer) {
int iTabs = TabCtrl_GetItemCount(GetDlgItem(pContainer->hwnd, 1159));
if (iTabs == 1)
SendMessage(pContainer->hwnd, WM_CLOSE, 0, 1);
else
SendMessage(si->hWnd, WM_CLOSE, 0, 1);
si->hWnd = CreateNewRoom((struct TContainerData *)wParam, si, TRUE, 0, 0);
}
}
break;
}
case DM_SENDMESSAGECOMMANDW:
SendMessageCommand_W(wParam, lParam);
if (lParam)
free((void *)lParam);
return(0);
case DM_SENDMESSAGECOMMAND:
SendMessageCommand(wParam, lParam);
if (lParam)
free((void *)lParam);
return(0);
/*
* sent from the popup to "dismiss" the event. we should do this in the main thread
*/
case DM_REMOVECLISTEVENT:
CallService(MS_CLIST_REMOVEEVENT, wParam, lParam);
CallService(MS_DB_EVENT_MARKREAD, wParam, lParam);
return(0);
case DM_SETLOCALE: {
HKL hkl = (HKL)lParam;
HANDLE hContact = (HANDLE)wParam;
HWND hWnd = M->FindWindow(hContact);
if(hWnd) {
TWindowData *dat = (TWindowData *)GetWindowLongPtr(hWnd, GWLP_USERDATA);
if(dat) {
DBVARIANT dbv;
if(hkl) {
dat->hkl = hkl;
PostMessage(dat->hwnd, DM_SETLOCALE, 0, 0);
}
if(0 == M->GetTString(hContact, SRMSGMOD_T, "locale", &dbv)) {
GetLocaleID(dat, dbv.ptszVal);
DBFreeVariant(&dbv);
UpdateReadChars(dat);
}
}
}
return(0);
}
/*
* react to changes in the desktop composition state
* (enable/disable DWM, change to a non-aero visual style
* or classic Windows theme
*/
case WM_DWMCOMPOSITIONCHANGED: {
bool fNewAero = M->getAeroState(); // refresh dwm state
SendMessage(hwndDlg, WM_THEMECHANGED, 0, 0);
TContainerData *pContainer = pFirstContainer;
while (pContainer) {
if(fNewAero)
SetAeroMargins(pContainer);
else {
MARGINS m = {0};
if(M->m_pfnDwmExtendFrameIntoClientArea)
M->m_pfnDwmExtendFrameIntoClientArea(pContainer->hwnd, &m);
}
if(pContainer->SideBar->isActive())
RedrawWindow(GetDlgItem(pContainer->hwnd, 5000), NULL, NULL, RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW); // the container for the sidebar buttons
RedrawWindow(pContainer->hwnd, NULL, NULL, RDW_ERASE|RDW_INVALIDATE|RDW_UPDATENOW|RDW_ALLCHILDREN);
pContainer = pContainer->pNextContainer;
}
M->BroadcastMessage(WM_DWMCOMPOSITIONCHANGED, 0, 0);
break;
}
/*
* this message is fired when the user changes desktop color
* settings (Desktop->personalize)
* the handler reconfigures the aero-related skin images for
* tabs and buttons to match the new desktop color theme.
*/
case WM_DWMCOLORIZATIONCOLORCHANGED: {
M->getAeroState();
Skin->setupAeroSkins();
CSkin::initAeroEffect();
break;
}
/*
* user has changed the visual style or switched to/from
* classic Windows theme
*/
case WM_THEMECHANGED: {
struct TContainerData *pContainer = pFirstContainer;
M->getAeroState();
Skin->setupTabCloseBitmap();
CSkin::initAeroEffect();
PluginConfig.m_ncm.cbSize = sizeof(NONCLIENTMETRICS);
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &PluginConfig.m_ncm, 0);
FreeTabConfig();
ReloadTabConfig();
while (pContainer) {
SendMessage(GetDlgItem(pContainer->hwnd, IDC_MSGTABS), EM_THEMECHANGED, 0, 0);
BroadCastContainer(pContainer, EM_THEMECHANGED, 0, 0);
pContainer = pContainer->pNextContainer;
}
break;
}
case DM_SPLITSENDACK: {
ACKDATA ack = {0};
struct SendJob *job = sendQueue->getJobByIndex((int)wParam);
ack.hContact = job->hOwner;
ack.hProcess = job->hSendId;
ack.type = ACKTYPE_MESSAGE;
ack.result = ACKRESULT_SUCCESS;
if (job->hOwner && job->iAcksNeeded && job->hOwner && job->iStatus == SendQueue::SQ_INPROGRESS) {
if (IsWindow(job->hwndOwner))
::SendMessage(job->hwndOwner, HM_EVENTSENT, (WPARAM)MAKELONG(wParam, 0), (LPARAM)&ack);
else
sendQueue->ackMessage(0, (WPARAM)MAKELONG(wParam, 0), (LPARAM)&ack);
}
return 0;
}
case DM_LOGSTATUSCHANGE:
CGlobals::logStatusChange(wParam, reinterpret_cast<CContactCache *>(lParam));
return(0);
case DM_MUCFLASHWORKER: {
FLASH_PARAMS *p = reinterpret_cast<FLASH_PARAMS*>(lParam);
if(1 == wParam) {
CallService(MS_CLIST_CONTACTDOUBLECLICKED, (WPARAM)p->hContact, 1);
p->bActiveTab = TRUE;
p->bInactive = FALSE;
p->bMustAutoswitch = p->bMustFlash = FALSE;
}
if(2 == wParam) {
p->bActiveTab = TRUE;
p->bInactive = FALSE;
p->bMustAutoswitch = p->bMustFlash = FALSE;
SendMessage(p->hWnd, DM_ACTIVATEME, 0, 0);
}
DoFlashAndSoundWorker(p);
return(0);
}
case WM_POWERBROADCAST:
case WM_DISPLAYCHANGE: {
struct TContainerData *pContainer = pFirstContainer;
while (pContainer) {
if (CSkin::m_skinEnabled) { // invalidate cached background DCs for skinned containers
pContainer->oldDCSize.cx = pContainer->oldDCSize.cy = 0;
SelectObject(pContainer->cachedDC, pContainer->oldHBM);
DeleteObject(pContainer->cachedHBM);
DeleteDC(pContainer->cachedDC);
pContainer->cachedDC = 0;
RedrawWindow(pContainer->hwnd, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_FRAME);
}
pContainer = pContainer->pNextContainer;
}
break;
}
case WM_ACTIVATE:
if (LOWORD(wParam) != WA_ACTIVE)
SetWindowPos(hwndDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
return 0;
case WM_CLOSE:
return 0;
case WM_TIMER:
if(wParam == TIMERID_SENDLATER) {
/*
* send heartbeat to each open container (to manage autoclose
* feature)
*/
TContainerData *pContainer = pFirstContainer;
/*
* send heartbeat to each container, they use this to update
* dynamic content (i.e. local time in the info panel).
*/
while(pContainer) {
SendMessage(pContainer->hwnd, WM_TIMER, TIMERID_HEARTBEAT, 0);
pContainer = pContainer->pNextContainer;
}
/*
* process send later contacts and jobs, if enough time has elapsed
*/
if(sendLater->isAvail() && !sendLater->isInteractive() && (time(0) - sendLater->lastProcessed()) > CSendLater::SENDLATER_PROCESS_INTERVAL) {
sendLater->setLastProcessed(time(0));
/*
* check the list of contacts that may have new send later jobs
* (added on user's request)
*/
sendLater->processContacts();
/*
* start processing the job list
*/
if(!sendLater->isJobListEmpty()) {
KillTimer(hwndDlg, wParam);
sendLater->startJobListProcess();
SetTimer(hwndDlg, TIMERID_SENDLATER_TICK, TIMEOUT_SENDLATER_TICK, 0);
}
}
}
/*
* process one entry per tick (default: 200ms)
* TODO better timings, possibly slow down when many jobs are in the
* queue.
*/
else if(wParam == TIMERID_SENDLATER_TICK) {
if(!sendLater->haveJobs()) {
KillTimer(hwndDlg, wParam);
SetTimer(hwndDlg, TIMERID_SENDLATER, TIMEOUT_SENDLATER, 0);
sendLater->qMgrUpdate(true);
}
else
sendLater->processCurrentJob();
}
break;
case WM_DESTROY: {
KillTimer(hwndDlg, TIMERID_SENDLATER_TICK);
KillTimer(hwndDlg, TIMERID_SENDLATER);
DestroyServiceFunction(hSvcHotkeyProcessor);
break;
}
}
return(DefWindowProc(hwndDlg, msg, wParam, lParam));
}
static LRESULT CALLBACK EventArea_WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg) {
case WM_MEASUREITEM:
{
MEASUREITEMSTRUCT *lpi = (LPMEASUREITEMSTRUCT) lParam;
MENUITEMINFOA mii = {0};
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA | MIIM_ID;
if (GetMenuItemInfoA(g_CluiData.hMenuNotify, lpi->itemID, FALSE, &mii) != 0) {
if (mii.dwItemData == lpi->itemData) {
lpi->itemWidth = 8 + 16;
lpi->itemHeight = 0;
return TRUE;
}
}
}
break;
case WM_DRAWITEM:
{
LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT) lParam;
if (dis->hwndItem == (HWND) g_CluiData.hMenuNotify) {
NotifyMenuItemExData *nmi = 0;
MENUITEMINFOA mii = {0};
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA;
if (GetMenuItemInfoA(g_CluiData.hMenuNotify, (UINT) dis->itemID, FALSE, &mii) != 0) {
nmi = (NotifyMenuItemExData *) mii.dwItemData;
if (nmi) {
int iIcon = cli_GetContactIcon(nmi->hContact);
ske_ImageList_DrawEx(g_himlCListClc, nmi->iIcon, dis->hDC, 2, (dis->rcItem.bottom + dis->rcItem.top - GetSystemMetrics(SM_CYSMICON)) / 2, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), CLR_NONE, CLR_NONE, ILD_NORMAL);
ske_ImageList_DrawEx(g_himlCListClc, iIcon, dis->hDC, 2+GetSystemMetrics(SM_CXSMICON)+2, (dis->rcItem.bottom + dis->rcItem.top - GetSystemMetrics(SM_CYSMICON)) / 2, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), CLR_NONE, CLR_NONE, ILD_NORMAL);
return TRUE;
}
}
}
break;
}
case WM_LBUTTONUP:
if (g_CluiData.bEventAreaEnabled)
SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDC_NOTIFYBUTTON, 0), 0);
break;
case WM_COMMAND:
if (LOWORD(wParam) == IDC_NOTIFYBUTTON) {
int iSelection;
MENUITEMINFO mii = {0};
POINT pt;
struct NotifyMenuItemExData *nmi = 0;
int iCount = GetMenuItemCount(g_CluiData.hMenuNotify);
BOOL result;
GetCursorPos(&pt);
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA;
if (iCount > 1)
iSelection = TrackPopupMenu(g_CluiData.hMenuNotify, TPM_RETURNCMD, pt.x, pt.y, 0, hwnd, NULL);
else
iSelection = GetMenuItemID(g_CluiData.hMenuNotify, 0);
result = GetMenuItemInfo(g_CluiData.hMenuNotify, (UINT) iSelection, FALSE, &mii);
if (result != 0) {
nmi = (struct NotifyMenuItemExData *) mii.dwItemData;
if (nmi) {
CLISTEVENT *cle = MyGetEvent(iSelection);
if (cle) {
CLISTEVENT *cle1 = NULL;
CallService(cle->pszService, (WPARAM) NULL, (LPARAM) cle);
// re-obtain the pointer, it may already be invalid/point to another event if the
// event we're interested in was removed by the service (nasty one...)
cle1 = MyGetEvent(iSelection);
if (cle1 != NULL)
CallService(MS_CLIST_REMOVEEVENT, (WPARAM) cle->hContact, (LPARAM) cle->hDbEvent);
}
}
}
break;
}
break;
case WM_SIZE:
if (!g_CluiData.fLayered)
InvalidateRect(hwnd,NULL,FALSE);
return DefWindowProc(hwnd, msg, wParam, lParam);
case WM_ERASEBKGND:
return 1;
case WM_PAINT:
if (GetParent(hwnd) == pcli->hwndContactList && g_CluiData.fLayered)
CallService(MS_SKINENG_INVALIDATEFRAMEIMAGE,(WPARAM)hwnd,0);
else if (GetParent(hwnd) == pcli->hwndContactList && !g_CluiData.fLayered) {
HDC hdc, hdc2;
HBITMAP hbmp,hbmpo;
RECT rc = {0};
GetClientRect(hwnd,&rc);
rc.right++;
rc.bottom++;
hdc = GetDC(hwnd);
hdc2 = CreateCompatibleDC(hdc);
hbmp = ske_CreateDIB32(rc.right,rc.bottom);
hbmpo = (HBITMAP)SelectObject(hdc2,hbmp);
ske_BltBackImage(hwnd,hdc2,&rc);
EventArea_DrawWorker(hwnd,hdc2);
BitBlt(hdc,rc.left,rc.top,rc.right-rc.left,rc.bottom-rc.top,
hdc2,rc.left,rc.top,SRCCOPY);
SelectObject(hdc2,hbmpo);
DeleteObject(hbmp);
DeleteDC(hdc2);
SelectObject(hdc,GetStockObject(DEFAULT_GUI_FONT));
ReleaseDC(hwnd,hdc);
ValidateRect(hwnd,NULL);
}
else {
HDC hdc, hdc2;
HBITMAP hbmp, hbmpo;
RECT rc;
PAINTSTRUCT ps;
HBRUSH br = GetSysColorBrush(COLOR_3DFACE);
GetClientRect(hwnd,&rc);
hdc = BeginPaint(hwnd,&ps);
hdc2 = CreateCompatibleDC(hdc);
hbmp = ske_CreateDIB32(rc.right,rc.bottom);
hbmpo = (HBITMAP)SelectObject(hdc2,hbmp);
FillRect(hdc2,&ps.rcPaint,br);
EventArea_DrawWorker(hwnd,hdc2);
BitBlt(hdc,ps.rcPaint.left,ps.rcPaint.top,ps.rcPaint.right-ps.rcPaint.left,ps.rcPaint.bottom-ps.rcPaint.top,
hdc2,ps.rcPaint.left,ps.rcPaint.top,SRCCOPY);
SelectObject(hdc2,hbmpo);
DeleteObject(hbmp);
DeleteDC(hdc2);
ps.fErase = FALSE;
EndPaint(hwnd,&ps);
}
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return TRUE;
}
HRESULT CMayaManager::Create(MObject obj)
{
HRESULT hr= S_OK;
MStatus stat= MS::kSuccess;
//MItDag FindRoot;
D3DPRESENT_PARAMETERS pp = {0};
HWND hShell;
HMENU hMenu;
int iMenu;
MArgList args;
const MString DirectXShader_UserClassify( "shader/surface" );
MFnPlugin plugin(obj, "Microsoft", "6.0", "Any");
MGlobal::displayInfo("DirectX Extensions for Maya - Initialization Beginning");
MGlobal::displayInfo("DirectX Extensions for Maya - DXCC Initialization Beginning");
CStringA pathChangeErr;
if(!AddDxccDllPath(pathChangeErr))
{
MString errStr= MString("DirectX Extensions for Maya - Error loading DXCC: ") + pathChangeErr.GetString();
MGlobal::displayInfo(errStr);
MessageBoxA((HWND)M3dView::applicationShell(), errStr.asChar(), "DirectX Extensions for Maya - Critical Error", MB_ICONEXCLAMATION);
DXCC_GOTO_EXIT(e_Exit, false);
}
#if defined(DEBUG) | defined(_DEBUG)
DXCCSetDebugPrintfACallback( MayaDebugPrintfACallback ) ;
DXCCSetDebugPrintfWCallback( MayaDebugPrintfWCallback ) ;
DXCCSetBreakPointCallback( DXCCBreakPointDefaultCallback ) ;
//g_DebugBasic= true;
//g_DebugExtreme= true;
#endif
MGlobal::displayInfo("DirectX Extensions for Maya - DXCC Initialization Complete");
MGlobal::displayInfo("DirectX Extensions for Maya - DXUT Initialization Beginning");
if( NULL == DXUTGetD3DObject() )
{
if(DXCC_FAILED( DXUTInit( false, false, false ) ))
{
MString errStr= MString("DirectX Extensions for Maya - Error loading DXUT: Most likely caused by D3D or D3DX DLL miss-match.");
MGlobal::displayInfo(errStr);
MessageBoxA((HWND)M3dView::applicationShell(), errStr.asChar(), "DirectX Extensions for Maya - Critical Error", MB_ICONEXCLAMATION);
DXCC_GOTO_EXIT(e_Exit, false);
}
DXCC_ASSERT( DXUTGetD3DObject() != NULL );
}
MGlobal::displayInfo("DirectX Extensions for Maya - DXUT Initialization Complete");
//-----------------------INITIALIZATION ------------------------//
hr= CManager::Create();
if(DXCC_FAILED(hr))
{
MGlobal::displayError("DirectX Extensions for Maya - Error");
MGlobal::displayError("Could not initialize base plugin manager");
DXCC_GOTO_EXIT(e_Exit, false);
}
DeviceCreatedEvent= CreateEventA(NULL, FALSE, FALSE, "DXCCManager_DeviceCreated");
InitializeCriticalSection(&DeviceAndViewerSection);
MGlobal::displayInfo("DirectX Extensions for Maya - Engine/Device Initialization Beginning");
g_Engine.Create(this);
MGlobal::displayInfo("DirectX Extensions for Maya - Engine/Device Initialization Complete");
SetEngine(&g_Engine);
pp.BackBufferWidth = 640;
pp.BackBufferHeight = 480;
pp.BackBufferCount = 1;
pp.MultiSampleType = D3DMULTISAMPLE_NONE;
pp.MultiSampleQuality = 0;
pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
pp.hDeviceWindow = NULL;
pp.Windowed = true;
pp.EnableAutoDepthStencil = true;
pp.AutoDepthStencilFormat = D3DFMT_D16;
pp.FullScreen_RefreshRateInHz = 0;
pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
MGlobal::displayInfo("DirectX Extensions for Maya - Viewer Initialization Beginning");
g_Viewer.Create( &g_PreviewPipeline, &pp );
MGlobal::displayInfo("DirectX Extensions for Maya - Viewer Initialization Complete");
MGlobal::displayInfo("DirectX Extensions for Maya - SyncGraph Initialization Beginning");
TagGraph.Initialize("DirectXTag", "DxTag");
TagGraph.AddAdapter(&TagGraphLayerAdapter);
TagGraph.AddAdapter(&TagGraphDagAdapter);
TagGraph.AddAdapter(&TagGraphMeshAdapter);
TagGraph.AddAdapter(&TagGraphShaderAdapter);
TagGraph.AddAdapter(&TagGraphStdMtlAdapter);
TagGraph.SetCallbackState(true);
TagGraph.RegisterNodes();
MGlobal::displayInfo("DirectX Extensions for Maya - SyncGraph Initialization Complete");
MGlobal::displayInfo("DirectX Extensions for Maya - DirectXShader Initialization Beginning");
DirectXShader::StaticInitialize();
stat= plugin.registerNode(
"DirectXShader",
DirectXShader::id,
DirectXShader::creator,
DirectXShader::initialize,
MPxNode::kDependNode,
&DirectXShader_UserClassify );
DXCHECK_MSTATUS(stat);
MGlobal::displayInfo("DirectX Extensions for Maya - DirectXShader Initialization Complete");
MGlobal::displayInfo("DirectX Extensions for Maya - XFileTranslator Initialization Beginning");
// register the translator
stat = plugin.registerFileTranslator(DXCC_EXPORTER, // name
NULL, // icon
XFileTranslator::creator,
NULL, // script
NULL,
false);
DXCHECK_MSTATUS(stat);
MGlobal::displayInfo("DirectX Extensions for Maya - XFileTranslator Initialization Complete");
/*
//DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_EXPORT_SELECTED, DXCCExportSelectedCommand::creator ));
*/
CallbackId_Exiting= MSceneMessage::addCallback( MSceneMessage::kMayaExiting, CMayaManager::Callback_MayaExiting, NULL, NULL);
CallbackId_TimeChanged= MEventMessage::addEventCallback ( "timeChanged", CMayaManager::DispatchTimeChanged, NULL, NULL);
MGlobal::displayInfo("DirectX Extensions for Maya - MenuCommands Initialization Beginning");
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXM_UIHELP , DXMUiHelpCommand::creator ));
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_PREVIEW_CHANGED , DXCCPreviewChangedCommand::creator ));
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_EXPORT_SCENE, DXCCExportSceneCommand::creator ));
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_EXPORT_OPTIONS, DXCCExportOptionsCommand::creator ));
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_REBUILD_SCENE, DXCCRebuildSceneCommand::creator ));
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_REBUILD_DIRTY, DCCRebuildDirtyCommand::creator ));
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_VIEW_FLOATING, DXCCFloatingViewCommand::creator ));
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_VIEW_CLOSE, DXCCCloseViewCommand::creator ));
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_VIEW_FRONT, DXCCFrontViewCommand::creator ));
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_VIEW_SIDE, DXCCSideViewCommand::creator ));
DXCHECK_MSTATUS(stat= plugin.registerCommand( DXCC_VIEW_TOP, DXCCTopViewCommand::creator ));
MGlobal::displayInfo("DirectX Extensions for Maya - MenuCommands Initialization Complete");
//Menu Creation
MGlobal::displayInfo("DirectX Extensions for Maya - Menu Initialization Beginning");
MGlobal::executeCommand("eval( \"source DirectX\" )", true, true);
MGlobal::displayInfo("DirectX Extensions for Maya - Menu Initialization Complete");
//Menu Capture IDs
MGlobal::displayInfo("DirectX Extensions for Maya - UpdateTimer Initialization Beginning");
hShell= (HWND)M3dView::applicationShell();
hMenu= GetMenu(hShell);
for(iMenu= 0; iMenu < GetMenuItemCount(hMenu); iMenu++)
{
char szMenu[MAX_PATH];
MENUITEMINFOA info;
ZeroMemory(&info, sizeof(MENUITEMINFO));
info.cbSize= sizeof(MENUITEMINFO);
info.fMask= MIIM_STRING|MIIM_SUBMENU;
info.dwTypeData= szMenu;
info.cch= MAX_PATH;
GetMenuItemInfoA(hMenu, iMenu, TRUE, &info);
szMenu[MAX_PATH-1]= '\0';
if(0 == lstrcmpiA(szMenu, "DirectX"))
{
HMENU hDirectXMenu= info.hSubMenu ;
for(iMenu= 0; iMenu < GetMenuItemCount(hDirectXMenu); iMenu++)
{
ZeroMemory(&info, sizeof(MENUITEMINFO));
info.cbSize= sizeof(MENUITEMINFO);
info.fMask= MIIM_STRING|MIIM_SUBMENU;
info.dwTypeData= szMenu;
info.cch= MAX_PATH;
GetMenuItemInfoA(hDirectXMenu, iMenu, TRUE, &info);
szMenu[MAX_PATH-1]= '\0';
if(0 == lstrcmpiA(szMenu, "Rebuild Dirty"))
{
m_RebuildDirty_MenuId= (WPARAM)MAKELONG(GetMenuItemID(hDirectXMenu, iMenu), 0);
m_RebuildDirtyTimer= SetTimer(NULL, NULL, 200, CMayaManager::TimerProc);
break;
}
}
break;
}
}
MGlobal::displayInfo("DirectX Extensions for Maya - UpdateTimer Initialization Complete");
MGlobal::displayInfo("DirectX Extensions for Maya - UI Options Loading Beginning");
UI_LoadOptions();
MGlobal::displayInfo("DirectX Extensions for Maya - UI Options Loading Complete");
MGlobal::displayInfo("DirectX Extensions for Maya - State Query Command Registration Beginning");
DXMUnitTests::RegisterCommands(plugin);
MGlobal::displayInfo("DirectX Extensions for Maya - State Query Command Registration Complete");
MGlobal::displayInfo("DirectX Extensions for Maya - Initialization Complete");
e_Exit:
return hr;
}
LRESULT CALLBACK EventAreaWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_CREATE:
hwndEventFrame = hwnd;
return FALSE;
case WM_MEASUREITEM:
{
MEASUREITEMSTRUCT *lpi = (LPMEASUREITEMSTRUCT)lParam;
MENUITEMINFOA mii = { 0 };
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA | MIIM_ID;
if (GetMenuItemInfoA(cfg::dat.hMenuNotify, lpi->itemID, FALSE, &mii) != 0) {
if (mii.dwItemData == lpi->itemData) {
lpi->itemWidth = 8 + 16;
lpi->itemHeight = 0;
return TRUE;
}
}
break;
}
case WM_NCCALCSIZE:
return FrameNCCalcSize(hwnd, DefWindowProc, wParam, lParam,
wndFrameEventArea ? wndFrameEventArea->TitleBar.ShowTitleBar : 0);
case WM_NCPAINT:
return FrameNCPaint(hwnd, DefWindowProc, wParam, lParam,
wndFrameEventArea ? wndFrameEventArea->TitleBar.ShowTitleBar : 0);
case WM_DRAWITEM:
{
LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT)lParam;
if (dis->hwndItem == (HWND)cfg::dat.hMenuNotify) {
MENUITEMINFOA mii = { 0 };
struct NotifyMenuItemExData *nmi = 0;
int iIcon;
HICON hIcon;
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA;
if (GetMenuItemInfoA(cfg::dat.hMenuNotify, (UINT)dis->itemID, FALSE, &mii) != 0) {
nmi = (struct NotifyMenuItemExData *) mii.dwItemData;
if (nmi) {
iIcon = pcli->pfnGetContactIcon(nmi->hContact);
hIcon = ImageList_GetIcon(hCListImages, iIcon, ILD_NORMAL);
pcli->pfnDrawMenuItem(dis, hIcon, nmi->hIcon);
return TRUE;
}
}
}
break;
}
case WM_LBUTTONUP:
if (cfg::dat.bEventAreaEnabled)
SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDC_NOTIFYBUTTON, 0), 0);
break;
case WM_COMMAND:
if (LOWORD(wParam) == IDC_NOTIFYBUTTON) {
int iSelection;
struct NotifyMenuItemExData *nmi = 0;
int iCount = GetMenuItemCount(cfg::dat.hMenuNotify);
POINT pt;
GetCursorPos(&pt);
MENUITEMINFO mii = { 0 };
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_DATA;
if (iCount > 1)
iSelection = TrackPopupMenu(cfg::dat.hMenuNotify, TPM_RETURNCMD, pt.x, pt.y, 0, hwnd, NULL);
else
iSelection = GetMenuItemID(cfg::dat.hMenuNotify, 0);
BOOL result = GetMenuItemInfo(cfg::dat.hMenuNotify, (UINT)iSelection, FALSE, &mii);
if (result != 0) {
nmi = (struct NotifyMenuItemExData *) mii.dwItemData;
if (nmi) {
CLISTEVENT *cle = MyGetEvent(iSelection);
if (cle) {
CLISTEVENT *cle1 = NULL;
CallService(cle->pszService, (WPARAM)NULL, (LPARAM)cle);
// re-obtain the pointer, it may already be invalid/point to another event if the
// event we're interested in was removed by the service (nasty one...)
cle1 = MyGetEvent(iSelection);
if (cle1 != NULL)
CallService(MS_CLIST_REMOVEEVENT, (WPARAM)cle->hContact, (LPARAM)cle->hDbEvent);
}
}
}
}
break;
case WM_ERASEBKGND:
return TRUE;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hwnd, &ps);
RECT rc, rcClient;
GetClientRect(hwnd, &rc);
rcClient = rc;
HDC hdcMem = CreateCompatibleDC(hdc);
HBITMAP hbm = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);
HBITMAP hbmold = reinterpret_cast<HBITMAP>(SelectObject(hdcMem, hbm));
SetBkMode(hdcMem, TRANSPARENT);
HFONT hFontOld = 0;
if (cfg::clcdat) {
int height;
hFontOld = ChangeToFont(hdcMem, cfg::clcdat, FONTID_EVENTAREA, &height);
}
if (cfg::dat.bWallpaperMode)
SkinDrawBg(hwnd, hdcMem);
StatusItems_t *item = arStatusItems[ID_EXTBKEVTAREA - ID_STATUS_OFFLINE];
if (item->IGNORED)
FillRect(hdcMem, &rc, GetSysColorBrush(COLOR_3DFACE));
else {
rc.top += item->MARGIN_TOP; rc.bottom -= item->MARGIN_BOTTOM;
rc.left += item->MARGIN_LEFT; rc.right -= item->MARGIN_RIGHT;
DrawAlpha(hdcMem, &rc, item->COLOR, item->ALPHA, item->COLOR2, item->COLOR2_TRANSPARENT,
item->GRADIENT, item->CORNER, item->BORDERSTYLE, item->imageItem);
SetTextColor(hdcMem, item->TEXTCOLOR);
}
LONG dwLeft = rc.left;
PaintNotifyArea(hdcMem, &rc);
if (cfg::dat.dwFlags & CLUI_FRAME_EVENTAREASUNKEN) {
rc.left = dwLeft;
InflateRect(&rc, -2, -2);
DrawEdge(hdcMem, &rc, BDR_SUNKENOUTER, BF_RECT);
}
BitBlt(hdc, 0, 0, rcClient.right, rcClient.bottom, hdcMem, 0, 0, SRCCOPY);
SelectObject(hdcMem, hbmold);
if (hFontOld)
SelectObject(hdcMem, hFontOld);
DeleteObject(hbm);
DeleteDC(hdcMem);
ps.fErase = FALSE;
EndPaint(hwnd, &ps);
}
return 0;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return TRUE;
}
HRESULT RequestTransfer(TShellExt *Self, int idxCmd)
{
// get the contact information
MENUITEMINFOA mii = { 0 };
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID | MIIM_DATA;
if ( !GetMenuItemInfoA(Self->hRootMenu, Self->idCmdFirst + idxCmd, false, &mii))
return E_INVALIDARG;
// get the pointer
TMenuDrawInfo *psd = (TMenuDrawInfo*)mii.dwItemData;
// the ID stored in the item pointer and the ID for the menu must match
if (psd == NULL || psd->wID != mii.wID)
return E_INVALIDARG;
// is there an IDataObject instance?
HRESULT hr = E_INVALIDARG;
if (Self->pDataObject != NULL) {
// OpenEvent() the work object to see if the instance is still around
char szBuf[100];
HANDLE hTransfer = OpenEventA(EVENT_ALL_ACCESS, false, CreateProcessUID(psd->pid, szBuf, sizeof(szBuf)));
if (hTransfer != 0) {
// map the ipc file again
HANDLE hMap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, IPC_PACKET_SIZE, IPC_PACKET_NAME);
if (hMap != 0 && GetLastError() != ERROR_ALREADY_EXISTS) {
// map it to process
THeaderIPC *pipch = (THeaderIPC*)MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
if (pipch != NULL) {
// create the name of the object to be signalled by the ST
lstrcpyA(pipch->SignalEventName, CreateUID(szBuf, sizeof(szBuf)));
// create it
HANDLE hReply = CreateEventA(NULL, false, false, pipch->SignalEventName);
if (hReply != 0) {
if (psd->fTypes & dtCommand) {
if (psd->MenuCommandCallback)
hr = psd->MenuCommandCallback(pipch, hTransfer, hReply);
}
else {
// prepare the buffer
ipcPrepareRequests(IPC_PACKET_SIZE, pipch, REQUEST_XFRFILES);
// get all the files into the packet
if (ipcGetFiles(pipch, Self->pDataObject, psd->hContact) == S_OK) {
// need to wait for the ST to open the mapping object
// since if we close it before it's opened it the data it
// has will be undefined
int replyBits = ipcSendRequest(hTransfer, hReply, pipch, 200);
if (replyBits != REPLY_FAIL) // they got the files!
hr = S_OK;
}
}
// close the work object name
CloseHandle(hReply);
}
// unmap it from this process
UnmapViewOfFile(pipch);
}
// close the map
CloseHandle(hMap);
}
// close the handle to the ST object name
CloseHandle(hTransfer);
}
}
return hr;
}