BOOL Columns_OnApply (HWND hDlg, LPVIEWINFO lpviDefault)
{
BOOL fPostMessage = FALSE;
for (size_t iCol = 0; iCol < nCOLUMNS; ++iCol)
{
if (COLUMNS[ iCol ].fChanged)
{
CHILDTAB iTab = (CHILDTAB)-1;
int idcList;
VIEWINFO vi;
memcpy (&vi, &COLUMNS[ iCol ].vi, sizeof(VIEWINFO));
LPVIEWINFO lpviTarget = NULL;
switch (iCol)
{
case ceSERVERS:
if (gr.fPreview && !gr.fVert)
lpviTarget = &gr.diHorz.viewSvr;
else
lpviTarget = &gr.diVert.viewSvr;
FL_RestoreView (GetDlgItem (g.hMain, IDC_SERVERS), &COLUMNS[ iCol ].vi);
UpdateDisplay_Servers (FALSE, NULL, 0);
break;
case ceFILESETS:
lpviTarget = &gr.viewSet;
iTab = tabFILESETS;
idcList = IDC_SET_LIST;
break;
case ceAGGREGATES:
lpviTarget = &gr.viewAgg;
iTab = tabAGGREGATES;
idcList = IDC_AGG_LIST;
break;
case ceSERVICES:
lpviTarget = &gr.viewSvc;
iTab = tabSERVICES;
idcList = IDC_SVC_LIST;
break;
case ceREPLICAS:
lpviTarget = &gr.viewRep;
break;
case ceAGGS_MOVE:
lpviTarget = &gr.viewAggMove;
break;
case ceAGGS_CREATE:
lpviTarget = &gr.viewAggCreate;
break;
case ceAGGS_RESTORE:
lpviTarget = &gr.viewAggRestore;
break;
}
if (lpviTarget != NULL)
{
memcpy (lpviTarget, &COLUMNS[ iCol ].vi, sizeof(VIEWINFO));
if (lpviDefault == &COLUMNS[ iCol ].vi)
fPostMessage = TRUE;
}
if (iTab != (CHILDTAB)-1)
{
for (HWND hServer = g.hMain;
hServer != NULL;
hServer = PropCache_Search (pcSERVER, ANYVALUE, hServer))
{
HWND hTab = GetDlgItem (hServer, IDC_TABS);
int iTabShown = TabCtrl_GetCurSel (hTab);
if (iTab == iTabShown)
{
HWND hChild = Server_GetCurrentTab (hServer);
HWND hList = GetDlgItem (hChild, idcList);
TCHAR szClassName[ cchRESOURCE ];
if (GetClassName (hList, szClassName, cchRESOURCE))
{
if (lstrcmp (szClassName, WC_FASTLIST))
continue;
}
FL_StoreView (hList, &vi);
COLUMNS[ iCol ].vi.lvsView = vi.lvsView;
FL_RestoreView (hList, &COLUMNS[ iCol ].vi);
Server_ForceRedraw (hServer);
}
if (hServer == g.hMain)
hServer = NULL;
}
}
}
}
return fPostMessage;
}
int CTabPanelWin::GetCurSelInt()
{
int nCurSel = mh_Tabbar ? TabCtrl_GetCurSel(mh_Tabbar) : 0;
return nCurSel;
}
HWND GetCurFindTab(HWND hwndFindDlg)
{
int i = TabCtrl_GetCurSel(GetDlgItem(hwndFindDlg, IDC_TAB1));
return g_hwndFindPane[i];
}
BOOL CDisasm::DlgProc(UINT message, WPARAM wParam, LPARAM lParam)
{
//if (!m_hDlg) return FALSE;
switch(message)
{
case WM_INITDIALOG:
{
return TRUE;
}
break;
case WM_TIMER:
{
int iPage = TabCtrl_GetCurSel (GetDlgItem(m_hDlg, IDC_LEFTTABS));
ShowWindow(GetDlgItem(m_hDlg, IDC_FUNCTIONLIST), iPage?SW_NORMAL:SW_HIDE);
ShowWindow(GetDlgItem(m_hDlg, IDC_REGLIST), iPage?SW_HIDE:SW_NORMAL);
}
break;
case WM_NOTIFY:
{
HWND tabs = GetDlgItem(m_hDlg, IDC_LEFTTABS);
NMHDR* pNotifyMessage = NULL;
pNotifyMessage = (LPNMHDR)lParam;
if (pNotifyMessage->hwndFrom == tabs)
{
int iPage = TabCtrl_GetCurSel (tabs);
ShowWindow(GetDlgItem(m_hDlg, IDC_FUNCTIONLIST), iPage?SW_NORMAL:SW_HIDE);
ShowWindow(GetDlgItem(m_hDlg, IDC_REGLIST), iPage?SW_HIDE:SW_NORMAL);
}
break;
}
case WM_COMMAND:
{
CtrlDisAsmView *ptr = CtrlDisAsmView::getFrom(GetDlgItem(m_hDlg,IDC_DISASMVIEW));
CtrlRegisterList *reglist = CtrlRegisterList::getFrom(GetDlgItem(m_hDlg,IDC_REGLIST));
switch(LOWORD(wParam))
{
case IDC_SHOWVFPU:
vfpudlg->Show(true);
break;
case IDC_FUNCTIONLIST:
switch (HIWORD(wParam))
{
case CBN_DBLCLK:
case CBN_SELCHANGE:
{
HWND lb = GetDlgItem(m_hDlg,LOWORD(wParam));
int n = ListBox_GetCurSel(lb);
if (n!=-1)
{
unsigned int addr = (unsigned int)ListBox_GetItemData(lb,n);
ptr->gotoAddr(addr);
}
}
break;
};
break;
case IDC_GOTOINT:
switch (HIWORD(wParam))
{
case LBN_SELCHANGE:
{
HWND lb =GetDlgItem(m_hDlg,LOWORD(wParam));
int n = ComboBox_GetCurSel(lb);
unsigned int addr = (unsigned int)ComboBox_GetItemData(lb,n);
if (addr != 0xFFFFFFFF)
ptr->gotoAddr(addr);
}
break;
};
break;
case IDC_GO:
{
SetDebugMode(false);
Core_EnableStepping(false);
MainWindow::UpdateMenus();
}
break;
case IDC_STEP:
{
Core_DoSingleStep();
Sleep(1);
_dbg_update_();
ptr->gotoPC();
UpdateDialog();
vfpudlg->Update();
}
break;
case IDC_STEPOVER:
{
SetDebugMode(false);
CBreakPoints::AddBreakPoint(cpu->GetPC()+cpu->getInstructionSize(0),true);
_dbg_update_();
Core_EnableStepping(false);
MainWindow::UpdateMenus();
Sleep(1);
ptr->gotoPC();
UpdateDialog();
}
break;
case IDC_STEPHLE:
{
hleDebugBreak();
SetDebugMode(false);
_dbg_update_();
Core_EnableStepping(false);
MainWindow::UpdateMenus();
}
break;
case IDC_STOP:
{
SetDebugMode(true);
Core_EnableStepping(true);
_dbg_update_();
MainWindow::UpdateMenus();
Sleep(1); //let cpu catch up
ptr->gotoPC();
UpdateDialog();
vfpudlg->Update();
}
break;
case IDC_SKIP:
{
cpu->SetPC(cpu->GetPC() + cpu->getInstructionSize(0));
Sleep(1);
ptr->gotoPC();
UpdateDialog();
}
break;
case IDC_ADDRESS:
{
if (HIWORD(wParam) == EN_CHANGE )
{
char szBuffer[32];
GetWindowText ((HWND)lParam, szBuffer, 32);
ptr->gotoAddr(parseHex(szBuffer));
UpdateDialog();
}
}
break;
case IDC_UPDATECALLSTACK:
{
HWND hDlg = m_hDlg;
HWND list = GetDlgItem(hDlg,IDC_CALLSTACK);
ComboBox_ResetContent(list);
u32 pc = currentMIPS->pc;
u32 ra = currentMIPS->r[MIPS_REG_RA];
DWORD addr = Memory::ReadUnchecked_U32(pc);
int count=1;
ComboBox_SetItemData(list,ComboBox_AddString(list,symbolMap.GetDescription(pc)),pc);
if (symbolMap.GetDescription(pc) != symbolMap.GetDescription(ra))
{
ComboBox_SetItemData(list,ComboBox_AddString(list,symbolMap.GetDescription(ra)),ra);
count++;
}
//walk the stack chain
while (addr != 0xFFFFFFFF && addr!=0 && count++<20)
{
DWORD fun = Memory::ReadUnchecked_U32(addr+4);
char *str = symbolMap.GetDescription(fun);
if (strlen(str)==0)
str = "(unknown)";
ComboBox_SetItemData(list, ComboBox_AddString(list,str), fun);
addr = Memory::ReadUnchecked_U32(addr);
}
ComboBox_SetCurSel(list,0);
}
break;
case IDC_GOTOPC:
{
ptr->gotoPC();
UpdateDialog();
}
break;
case IDC_GOTOLR:
{
ptr->gotoAddr(cpu->GetLR());
}
break;
case IDC_BACKWARDLINKS:
{
HWND box = GetDlgItem(m_hDlg, IDC_FUNCTIONLIST);
int funcnum = symbolMap.GetSymbolNum(ListBox_GetItemData(box,ListBox_GetCurSel(box)));
if (funcnum!=-1)
symbolMap.FillListBoxBLinks(box,funcnum);
break;
}
case IDC_ALLFUNCTIONS:
{
symbolMap.FillSymbolListBox(GetDlgItem(m_hDlg, IDC_FUNCTIONLIST),ST_FUNCTION);
break;
}
default:
return FALSE;
}
return TRUE;
}
case WM_USER+1:
NotifyMapLoaded();
break;
case WM_SIZE:
{
HWND disasm = GetDlgItem(m_hDlg, IDC_DISASMVIEW);
HWND funclist = GetDlgItem(m_hDlg, IDC_FUNCTIONLIST);
HWND regList = GetDlgItem(m_hDlg, IDC_REGLIST);
int wf = regRect.right-regRect.left;
int top = 138;
MoveWindow(regList,8,top,wf,HIWORD(lParam)-top-8,TRUE);
MoveWindow(funclist,8,top,wf,HIWORD(lParam)-top-8,TRUE);
int w = LOWORD(lParam)-wf;
top = 25;
MoveWindow(disasm,wf+15,top, w-20,HIWORD(lParam)-top-8,TRUE);
return TRUE;
}
case WM_GETMINMAXINFO:
{
MINMAXINFO *m = (MINMAXINFO *)lParam;
m->ptMinTrackSize.x=minRect.right-minRect.left;
//m->ptMaxTrackSize.x=m->ptMinTrackSize.x;
m->ptMinTrackSize.y=minRect.bottom-minRect.top;
}
return TRUE;
case WM_CLOSE:
Show(false);
return TRUE;
}
return FALSE;
}
static INT_PTR CALLBACK ConsoleDlgProc(HWND hwndDlg,UINT message,WPARAM wParam,LPARAM lParam)
{
switch(message) {
case WM_INITDIALOG:
{
TCHAR title[MAX_PATH];
TCHAR name[MAX_PATH] = {0};
TCHAR path[MAX_PATH] = {0};
hTabs = GetDlgItem(hwndDlg, IDC_TABS);
//TabCtrl_SetMinTabWidth(hTabs, 100);
// restore position
Utils_RestoreWindowPositionEx(hwndDlg,RWPF_HIDDEN,NULL,"Console","Console");
CallService(MS_DB_GETPROFILENAMET,(WPARAM)SIZEOF(name),(LPARAM)name);
CallService(MS_DB_GETPROFILEPATHT,(WPARAM)SIZEOF(path),(LPARAM)path);
mir_sntprintf(title, SIZEOF(title), _T("%s - %s\\%s"), TranslateT("Miranda Console"), path, name);
SetWindowText(hwndDlg, title);
SendMessage(hwndDlg,WM_SETICON,ICON_BIG,(LPARAM)hIcons[0]);
hwndConsole = hwndDlg;
SendMessage(hwndDlg, HM_ADD, 0, 0);
PostMessage(hwndDlg, WM_SIZE, 0, 0);
break;
}
case HM_DUMP:
{
// lParam = DUMPMSG
int idx;
LOGWIN *lw;
LOGWIN lw2;
DUMPMSG *dumpMsg = (DUMPMSG*)lParam;
if (!pActive) {
mir_free(dumpMsg);
break;
}
if (!gSingleMode)
{
lw2.Module = dumpMsg->szModule;
if (!List_GetIndex(&lModules, &lw2, &idx))
SendMessage(hwndDlg, HM_ADD, (WPARAM)idx, (LPARAM)dumpMsg->szModule);
lw = (LOGWIN*)lModules.items[idx];
}
else
lw = pActive;
if (lw->hwnd)
SendMessage(lw->hwnd, HM_DUMP, wParam, lParam);
else
PostMessage(hwndDlg, HM_DUMP, wParam, lParam); // loop msg until window will be ready
return TRUE;
}
case HM_ADD:
{
// wParam = index, lParam = module name
LOGWIN *lw;
COLORREF col;
TCITEM tci = {0};
int idx = (int)wParam;
char *str = (char*)lParam;
if (!str) str = ""; // startup window
lw = (LOGWIN*)mir_calloc( sizeof(LOGWIN));
lw->Module = (char*)mir_strdup(str);
List_Insert(&lModules, lw, idx);
if (!gSingleMode && lParam)
{
tci.mask = TCIF_PARAM | TCIF_TEXT;
tci.lParam = (LPARAM)lw;
tci.pszText = mir_a2u(lw->Module);
idx = TabCtrl_InsertItem(hTabs, tabCount, &tci);
mir_free(tci.pszText);
tabCount++;
}
GetClientRect(hTabs, &rcTabs);
TabCtrl_AdjustRect(hTabs, FALSE, &rcTabs);
CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_LOG), hwndDlg, LogDlgProc, (LPARAM)lw);
ShowWindow(lw->hwnd, (tabCount > 1)?SW_HIDE:SW_SHOWNOACTIVATE);
if (pActive)
{
col = ListView_GetBkColor(pActive->hList);
ListView_SetBkColor(lw->hList, col);
ListView_SetTextBkColor(lw->hList, col);
col = ListView_GetTextColor(pActive->hList);
ListView_SetTextColor(lw->hList, col);
if (hfLogFont)
SendMessage(lw->hList, WM_SETFONT, (WPARAM)hfLogFont, TRUE);
}
// hide startup window
if (tabCount == 1)
{
ShowWindow(pActive->hwnd, SW_HIDE);
PostMessage(pActive->hwnd, WM_CLOSE, 0, 0);
pActive = lw;
}
if (!pActive)
pActive = lw;
return TRUE;
}
case HM_REMOVE:
{
// lParam = LOGWIN
LOGWIN *lw = (LOGWIN*)lParam;
if (!lw) break;
if (lw == pActive)
{
int tab = TabCtrl_GetCurSel(hTabs);
if (tab >= 0)
{
TCITEM tci={0};
TabCtrl_DeleteItem(hTabs, tab);
tabCount--;
if (tabCount)
{
tab--;
if (tab < 0 ) tab = 0;
TabCtrl_SetCurSel(hTabs, tab);
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(hTabs, tab, &tci);
pActive = (LOGWIN*)tci.lParam;
SendMessage(pActive->hwnd, WM_SIZE, 0, 0);
ScrollDown(pActive);
ShowWindow(pActive->hwnd, SW_SHOWNOACTIVATE);
SetFocus(pActive->hList);
}
else
pActive = NULL;
}
}
List_RemovePtr(&lModules, lw);
mir_free(lw->Module);
mir_free(lw);
return TRUE;
}
case HM_SETFONT:
{
// wParam = font, lParam = font color
int i;
LOGWIN *lw;
for ( i = 0; i < lModules.realCount; i++ )
{
lw = (LOGWIN*)lModules.items[i];
ListView_SetTextColor(lw->hList, (COLORREF)lParam);
if (wParam)
SendMessage(lw->hList, WM_SETFONT, wParam, TRUE);
}
return TRUE;
}
case HM_SETCOLOR:
{
// wParam = font, lParam = background color
int i;
LOGWIN *lw;
for ( i = 0; i < lModules.realCount; i++ )
{
lw = (LOGWIN*)lModules.items[i];
ListView_SetBkColor(lw->hList, (COLORREF)lParam);
ListView_SetTextBkColor(lw->hList, (COLORREF)lParam);
if (wParam)
SendMessage(lw->hList, WM_SETFONT, wParam, TRUE);
}
return TRUE;
}
case HM_PAUSEALL:
{
// lParam = 1 to pause, 0 to start
int i;
LOGWIN *lw;
for ( i = 0; i < lModules.realCount; i++ )
{
lw = (LOGWIN*)lModules.items[i];
if (lw->Paused != (int)lParam)
SendMessage(lw->hwnd, WM_COMMAND, IDC_PAUSE, 0);
}
return TRUE;
}
case HM_RESTART:
{
if (pActive)
{
pActive = NULL;
PostMessage(hwndDlg, HM_RESTART, 0, 0);
return TRUE;
}
// close all tabs
if (!lParam)
{
LOGWIN *lw;
TabCtrl_DeleteAllItems(hTabs);
while ( lModules.realCount )
{
lw = (LOGWIN*)lModules.items[0];
SendMessage(lw->hwnd, WM_CLOSE, 0, 0);
}
tabCount = 0;
PostMessage(hwndDlg, HM_RESTART, 0, 1);
return TRUE;
}
LoadSettings();
SendMessage(hwndDlg, HM_ADD, 0, 0);
PostMessage(hwndDlg, WM_SIZE, 0, 0);
return TRUE;
}
case WM_SETFOCUS:
if (pActive) {
SetFocus(pActive->hList);
}
return TRUE;
case WM_NOTIFY:
switch(wParam) {
case IDC_TABS:
{
LPNMHDR lpnmhdr = (LPNMHDR)lParam;
if (lpnmhdr->code == TCN_SELCHANGE)
{
int newTab = TabCtrl_GetCurSel(hTabs);
if (newTab >= 0 )
{
TCITEM tci={0};
HWND hOld = pActive->hwnd;
tci.mask = TCIF_PARAM;
if (!TabCtrl_GetItem(hTabs, newTab, &tci)) break;
pActive = (LOGWIN*)tci.lParam;
SendMessage(pActive->hwnd, WM_SIZE, 0, 0);
ScrollDown(pActive);
ShowWindow(hOld, SW_HIDE);
ShowWindow(pActive->hwnd, SW_SHOWNOACTIVATE);
SetFocus(pActive->hList);
} else
SendMessage(pActive->hwnd, WM_SIZE, 0, 0);
}
break;
}
}
break;
case WM_SIZE:
{
UTILRESIZEDIALOG urd={0};
urd.cbSize=sizeof(urd);
urd.hInstance=hInst;
urd.hwndDlg=hwndDlg;
urd.lpTemplate=MAKEINTRESOURCEA(IDD_CONSOLE);
urd.pfnResizer=ConsoleResize;
CallService(MS_UTILS_RESIZEDIALOG,0,(LPARAM)&urd);
GetClientRect(hTabs, &rcTabs);
TabCtrl_AdjustRect(hTabs, FALSE, &rcTabs);
if ( pActive )
SendMessage(pActive->hwnd, WM_SIZE, 0, 0);
break;
}
case WM_GETMINMAXINFO:
{
MINMAXINFO *mmi=(MINMAXINFO*)lParam;
mmi->ptMinTrackSize.x=400;
mmi->ptMinTrackSize.y=200;
break;
}
case WM_CLOSE:
if ( lParam != 1 ) {
Utils_SaveWindowPosition(hwndDlg,NULL,"Console","Console");
ShowConsole(0);
return TRUE;
} else
DestroyWindow(hwndDlg);
break;
case WM_DESTROY:
pActive = NULL;
if (hfLogFont) DeleteObject(hfLogFont);
PostQuitMessage(0);
break;
}
return FALSE;
}
static BOOL CALLBACK OptionsDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
//static int iInit = TRUE;
//LocalOptions_t* lot=networkmap[(CNetwork*)GetWindowLong(hwnd,GWL_USERDATA)];
CNetwork* network=(CNetwork*)GetWindowLong(hwnd,GWL_USERDATA);
switch(msg) {
case WM_INITDIALOG:
{
//LocalOptions_t* lot=networkmap[(CNetwork*)lParam];
SetWindowLong(hwnd,GWL_USERDATA,lParam);
network=(CNetwork*)lParam;
//lot->fInit=true;
network->opt_fInit=true;
int iExpert = SendMessage(GetParent(hwnd), PSM_ISEXPERT, 0, 0);
network->opt_hwndAcc=network->opt_hwndSettings=network->opt_hwndQun=NULL;
//lot->hwndAcc=lot->hwndQun=lot->hwndSettings=NULL;
SetOptionsDlgToType(hwnd, iExpert);
//lot->fInit=false;
network->opt_fInit=false;
return FALSE;
}
case WM_DESTROY:
//if (lot) {
if (network) {
if (network->opt_hwndAcc) DestroyWindow(network->opt_hwndAcc);
if (network->opt_hwndQun) DestroyWindow(network->opt_hwndQun);
if (network->opt_hwndSettings) DestroyWindow(network->opt_hwndSettings);
if (network->opt_hwndAcc) DestroyWindow(network->opt_hwndAcc);
/*
if (lot->hwndQun) DestroyWindow(lot->hwndQun);
if (lot->hwndSettings) DestroyWindow(lot->hwndSettings);
delete lot;
networkmap.erase((CNetwork*)GetWindowLong(hwnd,GWL_USERDATA));
*/
hwndHelper=0;
}
break;
case PSM_CHANGED: // used so tabs dont have to call SendMessage(GetParent(GetParent(hwnd)), PSM_CHANGED, 0, 0);
if(network && !network->opt_fInit) {
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
}
break;
case WM_NOTIFY:
switch(((LPNMHDR)lParam)->idFrom) {
case 0:
switch (((LPNMHDR)lParam)->code) {
case PSN_APPLY:
{
TCITEM tci;
int i,count;
tci.mask = TCIF_PARAM;
count = TabCtrl_GetItemCount(GetDlgItem(hwnd,IDC_OPTIONSTAB));
for (i=0;i<count;i++)
{
TabCtrl_GetItem(GetDlgItem(hwnd,IDC_OPTIONSTAB),i,&tci);
SendMessage((HWND)tci.lParam,WM_NOTIFY,0,lParam);
}
}
break;
case PSN_EXPERTCHANGED:
{
int iExpert = SendMessage(GetParent(hwnd), PSM_ISEXPERT, 0, 0);
SetOptionsDlgToType(hwnd, iExpert);
}
break;
}
break;
case IDC_OPTIONSTAB:
switch (((LPNMHDR)lParam)->code) {
case TCN_SELCHANGING:
{
TCITEM tci;
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(GetDlgItem(hwnd,IDC_OPTIONSTAB),TabCtrl_GetCurSel(GetDlgItem(hwnd,IDC_OPTIONSTAB)),&tci);
ShowWindow((HWND)tci.lParam,SW_HIDE);
}
break;
case TCN_SELCHANGE:
{
TCITEM tci;
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(GetDlgItem(hwnd,IDC_OPTIONSTAB),TabCtrl_GetCurSel(GetDlgItem(hwnd,IDC_OPTIONSTAB)),&tci);
ShowWindow((HWND)tci.lParam,SW_SHOW);
}
break;
}
break;
}
break;
}
return FALSE;
}
void ConEmuAbout::searchProc(HWND hDlg, HWND hSearch, bool bReentr)
{
HWND hEdit = GetDlgItem(hDlg, tAboutText);
wchar_t* pszPart = GetDlgItemTextPtr(hSearch, 0);
wchar_t* pszText = GetDlgItemTextPtr(hEdit, 0);
bool bRetry = false;
if (pszPart && *pszPart && pszText && *pszText)
{
LPCWSTR pszFrom = pszText;
DWORD nStart = 0, nEnd = 0;
SendMessage(hEdit, EM_GETSEL, (WPARAM)&nStart, (LPARAM)&nEnd);
size_t cchMax = wcslen(pszText);
size_t cchFrom = max(nStart,nEnd);
if (cchMax > cchFrom)
pszFrom += cchFrom;
LPCWSTR pszFind = StrStrI(pszFrom, pszPart);
if (!pszFind && bReentr && (pszFrom != pszText))
pszFind = StrStrI(pszText, pszPart);
if (pszFind)
{
const wchar_t szBrkChars[] = L"()[]<>{}:;,.-=\\/ \t\r\n";
LPCWSTR pszEnd = wcspbrk(pszFind, szBrkChars);
INT_PTR nPartLen = wcslen(pszPart);
if (!pszEnd || ((pszEnd - pszFind) > max(nPartLen,60)))
pszEnd = pszFind + nPartLen;
while ((pszFind > pszFrom) && !wcschr(szBrkChars, *(pszFind-1)))
pszFind--;
//SetFocus(hEdit);
nTextSelStart = (DWORD)(pszEnd-pszText);
nTextSelEnd = (DWORD)(pszFind-pszText);
SendMessage(hEdit, EM_SETSEL, nTextSelStart, nTextSelEnd);
SendMessage(hEdit, EM_SCROLLCARET, 0, 0);
}
else if (!bReentr)
{
HWND hTab = GetDlgItem(hDlg, tbAboutTabs);
int iPage = TabCtrl_GetCurSel(hTab);
int iFound = -1;
for (int s = 0; (iFound == -1) && (s <= 1); s++)
{
int iFrom = (s == 0) ? (iPage+1) : 0;
int iTo = (s == 0) ? (int)countof(Pages) : (iPage-1);
for (int i = iFrom; i < iTo; i++)
{
if (StrStrI(Pages[i].Title, pszPart)
|| StrStrI(Pages[i].Text, pszPart))
{
iFound = i; break;
}
}
}
if (iFound >= 0)
{
TabSelected(hDlg, iFound);
TabCtrl_SetCurSel(hTab, iFound);
//SetFocus(hEdit);
bRetry = true;
}
}
}
SafeFree(pszPart);
SafeFree(pszText);
if (bRetry)
{
searchProc(hDlg, hSearch, true);
}
}
//获取当前Item
int SiTabCtl_GetCurItem(void)
{
return TabCtrl_GetCurSel(hwnd_tab_ctl);
}
INT_PTR WINAPI ConEmuAbout::aboutProc(HWND hDlg, UINT messg, WPARAM wParam, LPARAM lParam)
{
static struct {LPCWSTR Title; LPCWSTR Text;} Pages[] =
{
{L"About", pAbout},
{L"Command line", pCmdLine},
{L"Macro", pGuiMacro},
{L"Console", pConsoleHelpFull},
{L"-new_console", pNewConsoleHelpFull},
{L"DosBox", pDosBoxHelpFull},
{L"Contributors", pAboutContributors},
{L"License", pAboutLicense},
};
INT_PTR lRc = 0;
if (DonateBtns_Process(hDlg, messg, wParam, lParam, lRc))
{
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, lRc);
return TRUE;
}
switch (messg)
{
case WM_INITDIALOG:
{
gpConEmu->OnOurDialogOpened();
mh_AboutDlg = hDlg;
if ((ghOpWnd && IsWindow(ghOpWnd)) || (WS_EX_TOPMOST & GetWindowLongPtr(ghWnd, GWL_EXSTYLE)))
{
SetWindowPos(hDlg, HWND_TOPMOST, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE);
}
LPCWSTR pszActivePage = (LPCWSTR)lParam;
WCHAR szTitle[255];
LPCWSTR pszBits = WIN3264TEST(L"x86",L"x64");
LPCWSTR pszDebug = L"";
#ifdef _DEBUG
pszDebug = L"[DEBUG] ";
#endif
_wsprintf(szTitle, SKIPLEN(countof(szTitle)) L"About ConEmu (%02u%02u%02u%s %s%s)",
(MVV_1%100),MVV_2,MVV_3,_T(MVV_4a), pszDebug, pszBits);
SetWindowText(hDlg, szTitle);
if (hClassIcon)
{
SendMessage(hDlg, WM_SETICON, ICON_BIG, (LPARAM)hClassIcon);
SendMessage(hDlg, WM_SETICON, ICON_SMALL, (LPARAM)hClassIconSm);
SetClassLongPtr(hDlg, GCLP_HICON, (LONG_PTR)hClassIcon);
}
SetDlgItemText(hDlg, stConEmuAbout, pAboutTitle);
SetDlgItemText(hDlg, stConEmuUrl, gsHomePage);
DonateBtns_Add(hDlg, pIconCtrl, IDOK);
HWND hTab = GetDlgItem(hDlg, tbAboutTabs);
size_t nPage = 0;
for (size_t i = 0; i < countof(Pages); i++)
{
TCITEM tie = {};
tie.mask = TCIF_TEXT;
tie.pszText = (LPWSTR)Pages[i].Title;
TabCtrl_InsertItem(hTab, i, &tie);
if (pszActivePage && (lstrcmpi(pszActivePage, Pages[i].Title) == 0))
nPage = i;
}
SetDlgItemText(hDlg, tAboutText, Pages[nPage].Text);
if (nPage != 0)
{
TabCtrl_SetCurSel(hTab, (int)nPage);
}
else
{
_ASSERTE(pszActivePage==NULL && "Unknown page name?");
}
SetFocus(hTab);
return FALSE;
}
case WM_CTLCOLORSTATIC:
if (GetWindowLongPtr((HWND)lParam, GWLP_ID) == stConEmuUrl)
{
SetTextColor((HDC)wParam, GetSysColor(COLOR_HOTLIGHT));
HBRUSH hBrush = GetSysColorBrush(COLOR_3DFACE);
SetBkMode((HDC)wParam, TRANSPARENT);
return (INT_PTR)hBrush;
}
else
{
SetTextColor((HDC)wParam, GetSysColor(COLOR_WINDOWTEXT));
HBRUSH hBrush = GetSysColorBrush(COLOR_3DFACE);
SetBkMode((HDC)wParam, TRANSPARENT);
return (INT_PTR)hBrush;
}
break;
case WM_SETCURSOR:
{
if (GetWindowLongPtr((HWND)wParam, GWLP_ID) == stConEmuUrl)
{
SetCursor(LoadCursor(NULL, IDC_HAND));
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, TRUE);
return TRUE;
}
return FALSE;
}
break;
case WM_COMMAND:
if (HIWORD(wParam) == BN_CLICKED)
{
switch (LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
case IDCLOSE:
aboutProc(hDlg, WM_CLOSE, 0, 0);
return 1;
case stConEmuUrl:
ConEmuAbout::OnInfo_HomePage();
return 1;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR nmhdr = (LPNMHDR)lParam;
if ((nmhdr->code == TCN_SELCHANGE) && (nmhdr->idFrom == tbAboutTabs))
{
int iPage = TabCtrl_GetCurSel(nmhdr->hwndFrom);
if ((iPage >= 0) && (iPage < (int)countof(Pages)))
SetDlgItemText(hDlg, tAboutText, Pages[iPage].Text);
}
break;
}
case WM_CLOSE:
//if (ghWnd == NULL)
gpConEmu->OnOurDialogClosed();
EndDialog(hDlg, IDOK);
//else
// DestroyWindow(hDlg);
break;
case WM_DESTROY:
mh_AboutDlg = NULL;
break;
default:
return FALSE;
}
return FALSE;
}
LRESULT CALLBACK PhpPropSheetWndProc(
_In_ HWND hwnd,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
PPH_PROCESS_PROPSHEETCONTEXT propSheetContext;
WNDPROC oldWndProc;
propSheetContext = PhGetWindowContext(hwnd, 0xF);
if (!propSheetContext)
return 0;
oldWndProc = propSheetContext->PropSheetWindowHookProc;
switch (uMsg)
{
case WM_DESTROY:
{
HWND tabControl;
TCITEM tabItem;
WCHAR text[128];
// Save the window position and size.
PhSaveWindowPlacementToSetting(L"ProcPropPosition", L"ProcPropSize", hwnd);
// Save the selected tab.
tabControl = PropSheet_GetTabControl(hwnd);
tabItem.mask = TCIF_TEXT;
tabItem.pszText = text;
tabItem.cchTextMax = RTL_NUMBER_OF(text) - 1;
if (TabCtrl_GetItem(tabControl, TabCtrl_GetCurSel(tabControl), &tabItem))
{
PhSetStringSetting(L"ProcPropPage", text);
}
}
break;
case WM_NCDESTROY:
{
PhUnregisterWindowCallback(hwnd);
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)oldWndProc);
PhRemoveWindowContext(hwnd, 0xF);
PhDeleteLayoutManager(&propSheetContext->LayoutManager);
PhFree(propSheetContext);
}
break;
case WM_SYSCOMMAND:
{
// Note: Clicking the X on the taskbar window thumbnail preview doens't close modeless property sheets
// when there are more than 1 window and the window doesn't have focus... The MFC, ATL and WTL libraries
// check if the propsheet is modeless and SendMessage WM_CLOSE and so we'll implement the same solution. (dmex)
switch (wParam & 0xFFF0)
{
case SC_CLOSE:
{
PostMessage(hwnd, WM_CLOSE, 0, 0);
//SetWindowLongPtr(hwnd, DWLP_MSGRESULT, TRUE);
//return TRUE;
}
break;
}
}
break;
case WM_COMMAND:
{
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
case IDOK:
// Prevent the OK button from working (even though
// it's already hidden). This prevents the Enter
// key from closing the dialog box.
return 0;
}
}
break;
case WM_SIZE:
{
if (!IsMinimized(hwnd))
{
PhLayoutManagerLayout(&propSheetContext->LayoutManager);
}
}
break;
case WM_SIZING:
{
PhResizingMinimumSize((PRECT)lParam, wParam, MinimumSize.right, MinimumSize.bottom);
}
break;
}
return CallWindowProc(oldWndProc, hwnd, uMsg, wParam, lParam);
}
BOOL CALLBACK ContainerDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
ChatContainer *container;
container = (ChatContainer *) GetWindowLong(hwndDlg, GWL_USERDATA);
if (container==NULL && msg!=WM_INITDIALOG) return FALSE;
switch (msg) {
case WM_INITDIALOG:
SendMessage(hwndDlg, WM_SETICON, ICON_BIG, (LPARAM) muccIcon[MUCC_IDI_CHAT]);
container = (ChatContainer *) lParam;
container->setHWND(hwndDlg);
TabCtrl_SetImageList(GetDlgItem(hwndDlg, IDC_TABS), hImageList);
SetWindowLong(hwndDlg, GWL_USERDATA, (LONG) container);
ShowWindow(hwndDlg, SW_SHOW);
SetEvent(container->getEvent());
return TRUE;
case WM_GETMINMAXINFO:
MINMAXINFO *mmi;
RECT rcChild, rcWindow;
mmi = (MINMAXINFO *) lParam;
GetWindowRect(hwndDlg, &rcWindow);
container->getChildWindowRect(&rcChild);
mmi->ptMinTrackSize.x = 380;
mmi->ptMinTrackSize.y = 130 + (rcWindow.bottom - rcWindow.top) - (rcChild.bottom - rcChild.top);
return FALSE;
case WM_SIZE:
if (IsIconic(hwndDlg) || wParam == SIZE_MINIMIZED) break;
{
RECT rc, rcChild, rcWindow;
GetClientRect(hwndDlg, &rc);
HWND hwndTabs = GetDlgItem(hwndDlg, IDC_TABS);
MoveWindow(hwndTabs, 0, 0, (rc.right - rc.left), (rc.bottom - rc.top) - 0, FALSE);
RedrawWindow(hwndTabs, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE);
container->getChildWindowRect(&rcChild);
if ((rcChild.bottom-rcChild.top) < 130 || (rcChild.right-rcChild.left) < 380) {
GetWindowRect(hwndDlg, &rcWindow);
if ((rcChild.bottom-rcChild.top) < 130) {
rcWindow.bottom = rcWindow.top + 130 + (rcWindow.bottom - rcWindow.top) - (rcChild.bottom - rcChild.top);
}
if ((rcChild.right-rcChild.left) < 380) {
rcWindow.right = rcWindow.left + 380;
}
MoveWindow(hwndDlg, rcWindow.left, rcWindow.top, rcWindow.right - rcWindow.left, rcWindow.bottom - rcWindow.top, TRUE);
container->getChildWindowRect(&rcChild);
}
if (container->getActive()!=NULL) {
MoveWindow(container->getActive()->getHWND(), rcChild.left, rcChild.top, rcChild.right-rcChild.left, rcChild.bottom - rcChild.top, TRUE);
}
}
return TRUE;
case DM_CREATECHILD:
SetWindowLong(hwndDlg, DWL_MSGRESULT, (LONG)CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_GROUPCHAT_LOG), hwndDlg, (DLGPROC) wParam, (LPARAM) lParam));
return TRUE;
case DM_ADDCHILD:
container->addChild((ChatWindow *) lParam);
return TRUE;
case DM_REMOVECHILD:
container->removeChild((ChatWindow *) lParam);
return TRUE;
case DM_CHANGECHILDDATA:
container->removeChild((ChatWindow *) lParam);
return TRUE;
case DM_SETUNREAD:
container->setUnread((ChatWindow *) lParam, (int)wParam);
return TRUE;
case DM_FLASHWINDOW:
if (GetActiveWindow() != hwndDlg && GetForegroundWindow() != hwndDlg) {
container->setFlash(0);
SetTimer(hwndDlg, TIMERID_FLASHWND, container->getFlashTimeout(), NULL);
}
return TRUE;
case WM_NOTIFY:
{
NMHDR* pNMHDR = (NMHDR*) lParam;
switch (pNMHDR->code) {
case TCN_SELCHANGE:
{
TCITEM tci = {0};
HWND hwndTabs = GetDlgItem(hwndDlg, IDC_TABS);
int iSel = TabCtrl_GetCurSel(hwndTabs);
tci.mask = TCIF_PARAM;
if (TabCtrl_GetItem(hwndTabs, iSel, &tci)) {
ChatWindow * chatWindow = (ChatWindow *) tci.lParam;
container->activateChild(chatWindow);
}
}
break;
case NM_CLICK:
{
FILETIME ft;
TCHITTESTINFO thinfo;
int tabId;
HWND hwndTabs = GetDlgItem(hwndDlg, IDC_TABS);
GetSystemTimeAsFileTime(&ft);
GetCursorPos(&thinfo.pt);
ScreenToClient(hwndTabs, &thinfo.pt);
tabId = TabCtrl_HitTest(hwndTabs, &thinfo);
if (tabId != -1 && tabId == container->lastClickTab &&
(ft.dwLowDateTime - container->lastClickTime) < (GetDoubleClickTime() * 10000)) {
SendMessage(container->getChildFromTab(tabId)->getHWND(), WM_CLOSE, 0, 0);
container->lastClickTab = -1;
} else {
container->lastClickTab = tabId;
}
container->lastClickTime = ft.dwLowDateTime;
}
break;
}
}
break;
case WM_ACTIVATE:
if (LOWORD(wParam) != WA_ACTIVE)
break;
case WM_MOUSEACTIVATE:
if (KillTimer(hwndDlg, TIMERID_FLASHWND)) {
FlashWindow(hwndDlg, FALSE);
}
/*
if (container->getActive()!=NULL) {
container->setUnread(container->getActive(), 0);
SendMessage(container->getActive()->getHWND(), WM_ACTIVATE, WA_ACTIVE, 0);
}*/
break;
case WM_CLOSE:
EndDialog(hwndDlg, 0);
return FALSE;
case WM_TIMER:
if (wParam == TIMERID_FLASHWND) {
if ((container->getFlash() > container->getFlashMax()) || (GetActiveWindow() == hwndDlg) || (GetForegroundWindow() == hwndDlg)) {
KillTimer(hwndDlg, TIMERID_FLASHWND);
FlashWindow(hwndDlg, FALSE);
} else if (container->getFlash() < container->getFlashMax()) {
FlashWindow(hwndDlg, TRUE);
container->setFlash(container->getFlash()+1);
}
}
break;
case WM_DESTROY:
SetWindowLong(hwndDlg, GWL_USERDATA, 0);
delete container;
return TRUE;
}
return FALSE;
}
BOOL CALLBACK playlists_dropdown::preferences::DisplayDlgProc(HWND wnd, UINT msg, WPARAM wp, LPARAM lp) {
switch (msg)
{
case MSG_UPDATEPREVIEW:
{
static_api_ptr_t<playlist_manager> pm;
t_size playlist = pm->get_active_playlist();
if (playlist != pfc_infinite) {
static_api_ptr_t<titleformat_compiler> cmp;
titleformat_object::ptr title_format;
if (cmp->compile(title_format, cfg::title_string)) {
titleformat_hook_impl_splitter hook(titleformat_hook_impl_splitter(
&title_format_hook(playlist, false),
&titleformat_hook_impl_list(playlist, pm->get_playlist_count())));
pfc::string8 title;
title_format->run(&hook, title, NULL);
pfc::string8 preview;
cmp->remove_color_marks(title, preview);
preview.replace_char('\t', ' ');
uSetDlgItemText(wnd, IDC_PREVIEW, preview);
} else {
uSetDlgItemText(wnd, IDC_PREVIEW, "COMPILATION ERROR");
}
} else {
uSetDlgItemText(wnd, IDC_PREVIEW, "N/A");
}
}
break;
case WM_COMMAND:
switch (wp)
{
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// GENERAL
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
case IDC_SHOW_ICONS:
cfg::show_icons = uButton_GetCheck(wnd, IDC_SHOW_ICONS);
playlists_dropdown::g_reload_icons();
playlists_dropdown::g_update_all_sizes();
playlists_dropdown::g_redraw_all();
break;
case IDC_ICON_UTILS:
{
HMENU menu = CreatePopupMenu();
uAppendMenu(menu, MF_STRING, 1, "Clear custom icons history");
uAppendMenu(menu, MF_STRING, 2, "Reset all icons to default");
RECT rc;
GetWindowRect(GetDlgItem(wnd, IDC_ICON_UTILS), &rc);
int cmd = TrackPopupMenu(menu, TPM_NONOTIFY | TPM_RETURNCMD, rc.left, rc.bottom, 0, GetDlgItem(wnd, IDC_ICON_UTILS), 0);
DestroyMenu(menu);
if (cmd == 1 && uMessageBox(wnd, "Are you sure you want to clear all custom icons history?", "Continue?", MB_YESNO) == IDYES) {
cfg::custom_icons_history.reset();
} else if (cmd == 2 && uMessageBox(wnd, "Are you sure you want to reset all icons to default?", "Continue?", MB_YESNO) == IDYES) {
try {
static_api_ptr_t<playlist_manager_v2> pm2;
for (int i = 0, total = pm2->get_playlist_count(); i < total; i++) {
pm2->playlist_remove_property(i, guid_icon_path);
}
} catch(...) { }
}
playlists_dropdown::g_reload_icons();
playlists_dropdown::g_update_all_sizes();
playlists_dropdown::g_redraw_all();
}
break;
case IDC_MIN_VISIBLE | EN_CHANGE << 16:
cfg::min_visible = uGetDlgItemInt(wnd, IDC_MIN_VISIBLE, NULL, true);
playlists_dropdown::g_update_all_min_visible();
break;
case IDC_FORMATTING_STRING | EN_CHANGE << 16:
if (TabCtrl_GetDlgCurSel(wnd, IDC_FS_TAB) == 0) {
uGetDlgItemText(wnd, IDC_FORMATTING_STRING, cfg::title_string);
uSendMessage(wnd, MSG_UPDATEPREVIEW, 0, 0);
} else {
uGetDlgItemText(wnd, IDC_FORMATTING_STRING, cfg::style_string);
}
uEnableWindow(uGetDlgItem(wnd, IDC_APPLY), true);
break;
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// PADDING
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
case IDC_PADDING_TOP | EN_CHANGE << 16:
cfg::padding.get_value().top = uGetDlgItemInt(wnd, IDC_PADDING_TOP, NULL, true);
playlists_dropdown::g_update_all_sizes();
playlists_dropdown::g_redraw_all();
break;
case IDC_PADDING_RIGHT | EN_CHANGE << 16:
cfg::padding.get_value().right = uGetDlgItemInt(wnd, IDC_PADDING_RIGHT, NULL, true);
playlists_dropdown::g_update_all_sizes();
playlists_dropdown::g_redraw_all();
break;
case IDC_PADDING_BOTTOM | EN_CHANGE << 16:
cfg::padding.get_value().bottom = uGetDlgItemInt(wnd, IDC_PADDING_BOTTOM, NULL, true);
playlists_dropdown::g_update_all_sizes();
playlists_dropdown::g_redraw_all();
break;
case IDC_PADDING_LEFT | EN_CHANGE << 16:
cfg::padding.get_value().left = uGetDlgItemInt(wnd, IDC_PADDING_LEFT, NULL, true);
playlists_dropdown::g_update_all_sizes();
playlists_dropdown::g_redraw_all();
break;
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// FIELDS BUTTON
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
case IDC_FIELDS:
{
HMENU menu = CreatePopupMenu();
for (int i = 1; i < tabsize(g_fields_list); i++) {
uAppendMenu(menu, !!g_fields_list[i].label ? MF_STRING : MF_SEPARATOR, i, g_fields_list[i].label);
}
RECT rc;
GetWindowRect(GetDlgItem(wnd, IDC_FIELDS), &rc);
int cmd = TrackPopupMenu(menu, TPM_NONOTIFY | TPM_RETURNCMD, rc.left, rc.bottom, 0, GetDlgItem(wnd, IDC_FIELDS), 0);
DestroyMenu(menu);
if (cmd >= 0 && cmd < tabsize(g_fields_list) && !!g_fields_list[cmd].label) {
uSendDlgItemMessageText(wnd, IDC_FORMATTING_STRING, EM_REPLACESEL, TRUE, g_fields_list[cmd].label);
SetFocus(GetDlgItem(wnd, IDC_FORMATTING_STRING));
}
}
break;
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
// APPLY
// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
case IDC_APPLY:
apply_config();
uEnableWindow(uGetDlgItem(wnd, IDC_APPLY), FALSE);
break;
}
break;
case WM_INITDIALOG:
{
EnableTheming(wnd);
// Setup "Display/Style" TabControl
HWND hTabWnd = uGetDlgItem(wnd, IDC_FS_TAB);
uTabCtrl_InsertItemText(hTabWnd, 0, "Display");
uTabCtrl_InsertItemText(hTabWnd, 1, "Style");
TabCtrl_SetCurSel(hTabWnd, cfg::last_fs_tab);
uSetDlgItemText(wnd, IDC_FORMATTING_STRING, get_formatting_string(TabCtrl_GetCurSel(hTabWnd)));
uButton_SetCheck(wnd, IDC_SHOW_ICONS, cfg::show_icons);
SetDlgSpinner(wnd, IDC_MIN_VISIBLE_SPIN, IDC_MIN_VISIBLE, 1, 1000, cfg::min_visible);
SetDlgSpinner(wnd, IDC_PADDING_TOP_SPIN, IDC_PADDING_TOP, 0, 1024, cfg::padding.get_value().top);
SetDlgSpinner(wnd, IDC_PADDING_RIGHT_SPIN, IDC_PADDING_RIGHT, 0, 1024, cfg::padding.get_value().right);
SetDlgSpinner(wnd, IDC_PADDING_BOTTOM_SPIN, IDC_PADDING_BOTTOM, 0, 1024, cfg::padding.get_value().bottom);
SetDlgSpinner(wnd, IDC_PADDING_LEFT_SPIN, IDC_PADDING_LEFT, 0, 1024, cfg::padding.get_value().left);
uEnableWindow(uGetDlgItem(wnd, IDC_APPLY), FALSE);
SendMessage(wnd, MSG_UPDATEPREVIEW, 0, 0);
}
break;
case WM_DESTROY:
cfg::last_fs_tab = TabCtrl_GetDlgCurSel(wnd, IDC_FS_TAB);
break;
case WM_NOTIFY:
if (((LPNMHDR) lp)->idFrom == IDC_FS_TAB && ((LPNMHDR) lp)->code == TCN_SELCHANGE) {
uSetDlgItemText(wnd, IDC_FORMATTING_STRING, get_formatting_string(TabCtrl_GetDlgCurSel(wnd, IDC_FS_TAB)));
}
break;
default:
return false;
}
return true;
}
void Notebook::tabEvent() {
int i = TabCtrl_GetCurSel((HWND)component);
selectPage(i);
}
BOOL CALLBACK ShortcutMapper::run_dlgProc(UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG :
{
initBabyGrid();
initTabs();
fillOutBabyGrid();
_babygrid->display();
goToCenter();
return TRUE;
}
case WM_NOTIFY: {
NMHDR nmh = *((NMHDR*)lParam);
if (nmh.hwndFrom == _hTabCtrl) {
if (nmh.code == TCN_SELCHANGE) {
int index = TabCtrl_GetCurSel(_hTabCtrl);
switch (index) {
// JOCE Plain numerical values?? makes sense?
case 0:
_currentState = STATE_MENU;
break;
case 1:
_currentState = STATE_MACRO;
break;
case 2:
_currentState = STATE_USER;
break;
case 3:
_currentState = STATE_PLUGIN;
break;
case 4:
_currentState = STATE_SCINTILLA;
break;
NO_DEFAULT_CASE;
}
fillOutBabyGrid();
}
}
break;
}
case WM_COMMAND :
{
switch (LOWORD(wParam))
{
case IDCANCEL :
{
::EndDialog(_hSelf, -1);
return TRUE;
}
case IDOK :
{
::EndDialog(_hSelf, 0);
return TRUE;
}
case IDM_BABYGRID_MODIFY :
{
assert(_babygrid);
NppParameters *nppParam = NppParameters::getInstance();
int row = _babygrid->getSelectedRow();
switch(_currentState) {
case STATE_MENU: {
//Get CommandShortcut corresponding to row
std::vector<CommandShortcut> & shortcuts = nppParam->getUserShortcuts();
CommandShortcut csc = shortcuts[row - 1], prevcsc = shortcuts[row - 1];
csc.init(_hInst, _hSelf);
if (csc.doDialog() != -1 && prevcsc != csc) { //shortcut was altered
nppParam->addUserModifiedIndex(row-1);
shortcuts[row - 1] = csc;
_babygrid->setText(row, 2, csc.toString().c_str());
//Notify current Accelerator class to update everything
nppParam->getAccelerator()->updateShortcuts();
}
break;
}
case STATE_MACRO: {
//Get MacroShortcut corresponding to row
std::vector<MacroShortcut> & shortcuts = nppParam->getMacroList();
MacroShortcut msc = shortcuts[row - 1], prevmsc = shortcuts[row - 1];
msc.init(_hInst, _hSelf);
if (msc.doDialog() != -1 && prevmsc != msc) { //shortcut was altered
shortcuts[row - 1] = msc;
_babygrid->setText(row, 1, msc.getName());
_babygrid->setText(row, 2, msc.toString().c_str());
//Notify current Accelerator class to update everything
nppParam->getAccelerator()->updateShortcuts();
}
break;
}
case STATE_USER: {
//Get UserCommand corresponding to row
std::vector<UserCommand> & shortcuts = nppParam->getUserCommandList();
UserCommand ucmd = shortcuts[row - 1];
ucmd.init(_hInst, _hSelf);
UserCommand prevucmd = ucmd;
if (ucmd.doDialog() != -1 && prevucmd != ucmd) { //shortcut was altered
shortcuts[row - 1] = ucmd;
_babygrid->setText(row, 1, ucmd.getName());
_babygrid->setText(row, 2, ucmd.toString().c_str());
//Notify current Accelerator class to update everything
nppParam->getAccelerator()->updateShortcuts();
}
break;
}
case STATE_PLUGIN: {
//Get PluginCmdShortcut corresponding to row
std::vector<PluginCmdShortcut> & shortcuts = nppParam->getPluginCommandList();
PluginCmdShortcut pcsc = shortcuts[row - 1];
pcsc.init(_hInst, _hSelf);
PluginCmdShortcut prevpcsc = pcsc;
if (pcsc.doDialog() != -1 && prevpcsc != pcsc) { //shortcut was altered
nppParam->addPluginModifiedIndex(row-1);
shortcuts[row - 1] = pcsc;
_babygrid->setText(row, 2, pcsc.toString().c_str());
//Notify current Accelerator class to update everything
nppParam->getAccelerator()->updateShortcuts();
unsigned long cmdID = pcsc.getID();
ShortcutKey shortcut;
shortcut._isAlt = pcsc.getKeyCombo()._isAlt;
shortcut._isCtrl = pcsc.getKeyCombo()._isCtrl;
shortcut._isShift = pcsc.getKeyCombo()._isShift;
shortcut._key = pcsc.getKeyCombo()._key;
::SendMessage(_hParent, NPPM_INTERNAL_PLUGINSHORTCUTMOTIFIED, cmdID, (LPARAM)&shortcut);
}
break;
}
case STATE_SCINTILLA: {
//Get ScintillaKeyMap corresponding to row
std::vector<ScintillaKeyMap> & shortcuts = nppParam->getScintillaKeyList();
ScintillaKeyMap skm = shortcuts[row - 1], prevskm = shortcuts[row-1];
skm.init(_hInst, _hSelf);
if (skm.doDialog() != -1 && prevskm != skm)
{
//shortcut was altered
nppParam->addScintillaModifiedIndex(row-1);
shortcuts[row-1] = skm;
_babygrid->setText(row, 2, skm.toString().c_str());
//Notify current Accelerator class to update key
nppParam->getScintillaAccelerator()->updateKeys();
}
break;
}
}
return TRUE;
}
case IDM_BABYGRID_DELETE :
{
NppParameters *nppParam = NppParameters::getInstance();
if (::MessageBox(_hSelf, TEXT("Are you sure you want to delete this shortcut?"), TEXT("Are you sure?"), MB_OKCANCEL) == IDOK)
{
assert(_babygrid);
const int row = _babygrid->getSelectedRow();
int shortcutIndex = row-1;
// Menu data
size_t posBase = 0;
size_t nbElem = 0;
HMENU hMenu = NULL;
int modifCmd = IDM_SETTING_SHORTCUT_MAPPER_RUN;
switch(_currentState)
{
case STATE_MENU:
case STATE_PLUGIN:
case STATE_SCINTILLA:
{
return FALSE; //this is bad
}
case STATE_MACRO:
{
std::vector<MacroShortcut> & theMacros = nppParam->getMacroList();
std::vector<MacroShortcut>::iterator it = theMacros.begin();
theMacros.erase(it + shortcutIndex);
fillOutBabyGrid();
// preparing to remove from menu
posBase = 6;
nbElem = theMacros.size();
hMenu = ::GetSubMenu((HMENU)::SendMessage(_hParent, NPPM_INTERNAL_GETMENU, 0, 0), MENUINDEX_MACRO);
modifCmd = IDM_SETTING_SHORTCUT_MAPPER_MACRO;
for (size_t i = shortcutIndex ; i < nbElem ; i++) //lower the IDs of the remaining items so there are no gaps
{
MacroShortcut ms = theMacros[i];
ms.setID(ms.getID() - 1); //shift all IDs
theMacros[i] = ms;
}
break;
}
case STATE_USER:
{
std::vector<UserCommand> & theUserCmds = nppParam->getUserCommandList();
std::vector<UserCommand>::iterator it = theUserCmds.begin();
theUserCmds.erase(it + shortcutIndex);
fillOutBabyGrid();
// preparing to remove from menu
posBase = 2;
nbElem = theUserCmds.size();
hMenu = ::GetSubMenu((HMENU)::SendMessage(_hParent, NPPM_INTERNAL_GETMENU, 0, 0), MENUINDEX_RUN);
modifCmd = IDM_SETTING_SHORTCUT_MAPPER_RUN;
for (size_t i = shortcutIndex ; i < nbElem ; i++) //lower the IDs of the remaining items so there are no gaps
{
UserCommand uc = theUserCmds[i];
uc.setID(uc.getID() - 1); //shift all IDs
theUserCmds[i] = uc;
}
break;
}
NO_DEFAULT_CASE;
}
// updateShortcuts() will update all menu item - the menu items will be shifted
nppParam->getAccelerator()->updateShortcuts();
// All menu items are shifted up. So we delete the last item
::RemoveMenu(hMenu, posBase + nbElem - 1, MF_BYPOSITION);
if (nbElem == 0)
{
::RemoveMenu(hMenu, modifCmd, MF_BYCOMMAND);
//remove separator
::RemoveMenu(hMenu, posBase-1, MF_BYPOSITION);
::RemoveMenu(hMenu, posBase-1, MF_BYPOSITION);
}
}
return TRUE;
}
case IDD_BABYGRID_ID1: {
if(HIWORD(wParam) == BGN_CELLDBCLICKED) //a cell was clicked in the properties grid
{
return ::SendMessage(_hSelf, WM_COMMAND, IDM_BABYGRID_MODIFY, LOWORD(lParam));
}
else if(HIWORD(wParam) == BGN_CELLRCLICKED) //a cell was clicked in the properties grid
{
POINT p;
::GetCursorPos(&p);
if (!_rightClickMenu)
{
_rightClickMenu = new ContextMenu();
}
if (!_rightClickMenu->isCreated())
{
std::vector<MenuItemUnit> itemUnitArray;
itemUnitArray.push_back(MenuItemUnit(IDM_BABYGRID_MODIFY, TEXT("Modify")));
itemUnitArray.push_back(MenuItemUnit(IDM_BABYGRID_DELETE, TEXT("Delete")));
_rightClickMenu->create(_hSelf, itemUnitArray);
}
switch(_currentState) {
case STATE_MACRO:
case STATE_USER: {
_rightClickMenu->enableItem(IDM_BABYGRID_DELETE, true);
break;
}
case STATE_MENU:
case STATE_PLUGIN:
case STATE_SCINTILLA: {
_rightClickMenu->enableItem(IDM_BABYGRID_DELETE, false);
break;
}
NO_DEFAULT_CASE;
}
_rightClickMenu->display(p);
return TRUE;
}
}
break;
NO_DEFAULT_CASE;
}
}
break;
default:
return FALSE;
}
return FALSE;
}
INT_PTR
CALLBACK
_main_dialog_proc(
HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam
)
{
WORD id = LOWORD(wparam);
WORD code = HIWORD(wparam);
_wnd_data *wnd;
_dnode *sel;
_dmnt *mnt;
int k = 0;
switch ( message )
{
case WM_INITDIALOG :
{
memset( __lists, HWND_NULL, sizeof(__lists) );
__lists[HMAIN_DRIVES] = GetDlgItem( hwnd, IDC_DISKDRIVES );
__dlg = hwnd;
_init_main_dlg( hwnd );
_load_diskdrives( hwnd, &__drives, _list_volumes(0) );
{
TCITEM tab_item = { TCIF_TEXT };
HWND h_tab = GetDlgItem(hwnd, IDT_INFO);
_tab_data *d_tab = malloc(sizeof(_tab_data));
zeroauto( d_tab, sizeof(_tab_data) );
d_tab->curr_tab = 1;
wnd_set_long( hwnd, GWL_USERDATA, d_tab );
wnd = _sub_class(
h_tab, SUB_NONE,
CreateDialog( __hinst, MAKEINTRESOURCE(DLG_MAIN_INFO), GetDlgItem(hwnd, IDC_MAIN_TAB), _tab_proc ),
CreateDialog( __hinst, MAKEINTRESOURCE(DLG_MAIN_ACTION), GetDlgItem(hwnd, IDC_MAIN_TAB), _tab_proc ),
HWND_NULL
);
{
__lists[HMAIN_INFO] = GetDlgItem( wnd->dlg[0], IDC_INF_TABLE );
__lists[HMAIN_ACT] = GetDlgItem( wnd->dlg[1], IDC_ACT_TABLE );
}
{
__dlg_act_info = wnd->dlg[1];
_list_insert_col( __lists[HMAIN_INFO], 380 );
_list_insert_col( __lists[HMAIN_INFO], 90 );
while (
_list_insert_item( __lists[HMAIN_INFO], k, 0, _info_table_items[k], 0 )
) k++;
_set_header_text(
__lists[HMAIN_INFO], 0, STR_HEAD_NO_ICONS, sizeof_w(STR_HEAD_NO_ICONS)
);
_list_insert_col( __lists[HMAIN_ACT], 90 );
_list_insert_col( __lists[HMAIN_ACT], 70 );
_list_insert_col( __lists[HMAIN_ACT], 85 );
_list_insert_col( __lists[HMAIN_ACT], 50 );
_list_insert_item( __lists[HMAIN_ACT], 0, 0, _act_table_items[0], 0 );
ListView_SetItemText( __lists[HMAIN_ACT], 0, 2, _act_table_items[3] );
_list_insert_item( __lists[HMAIN_ACT], 1, 0, _act_table_items[1], 0 );
ListView_SetItemText( __lists[HMAIN_ACT], 1, 2, _act_table_items[4] );
_init_combo(
GetDlgItem( __dlg_act_info, IDC_COMBO_PASSES), wipe_modes, WP_NONE, FALSE, -1
);
SendMessage(
GetDlgItem( __dlg_act_info, IDC_PROGRESS ),
PBM_SETBARCOLOR, 0, _cl( COLOR_BTNSHADOW, DARK_CLR - 20 )
);
SendMessage(
GetDlgItem( __dlg_act_info, IDC_PROGRESS ),
PBM_SETRANGE, 0, MAKELPARAM(0, PRG_STEP)
);
}
tab_item.pszText = L"Info";
TabCtrl_InsertItem( h_tab, 0, &tab_item );
{
NMHDR mhdr = { 0, 0, TCN_SELCHANGE };
TabCtrl_SetCurSel( h_tab, 0 );
SendMessage(hwnd, WM_NOTIFY, IDT_INFO, (LPARAM)&mhdr);
}
}
SendMessage( hwnd, WM_SYSCOLORCHANGE, 0, 0 );
_set_timer( MAIN_TIMER, TRUE, TRUE );
_set_timer( RAND_TIMER, TRUE, FALSE );
_set_timer( POST_TIMER, TRUE, FALSE );
return 0L;
}
break;
case WM_WINDOWPOSCHANGED :
{
WINDOWPOS *pos = (WINDOWPOS *)lparam;
int flags = pos->flags;
_dlg_right = pos->cx + pos->x;
_dlg_bottom = pos->cy + pos->y;
_dlg_left = pos->x;
if ( ( flags & SWP_SHOWWINDOW ) || ( flags & SWP_HIDEWINDOW ) )
{
_set_timer( MAIN_TIMER, flags & SWP_SHOWWINDOW, TRUE );
}
return 0L;
}
break;
case WM_ENTERSIZEMOVE :
{
//_middle_ctl(
// GetDlgItem(hwnd, IDC_DISKDRIVES),
// GetDlgItem(hwnd, IDC_RESIZING),
// TRUE
// );
//ShowWindow(GetDlgItem(hwnd, IDC_DISKDRIVES), SW_HIDE);
return 0L;
}
break;
case WM_EXITSIZEMOVE :
{
//ShowWindow(GetDlgItem(hwnd, IDC_DISKDRIVES), SW_SHOW);
return 0L;
}
break;
case WM_SIZING :
{
RECT *rect = ((RECT *)lparam);
rect->right = _dlg_right;
rect->left = _dlg_left;
if ( rect->bottom - rect->top < MAIN_DLG_MIN_HEIGHT )
{
rect->bottom = rect->top + MAIN_DLG_MIN_HEIGHT;
}
return 1L;
}
break;
case WM_SIZE :
{
int height = HIWORD(lparam);
int width = LOWORD(lparam);
int k;
_size_move_ctls _resize[ ] =
{
{ -1, IDC_DISKDRIVES, FALSE, 0, 0 },
{ -1, IDC_STATIC_LIST, TRUE, 0, 0 },
{ -1, IDC_STATIC_RIGHT, TRUE, 0, 0 }
};
_size_move_ctls _move[ ] =
{
{ IDC_STATIC_LIST, IDC_MAIN_TAB, TRUE, 0, 6 },
{ IDC_STATIC_LIST, IDT_INFO, FALSE, 0, 3 },
{ IDT_INFO, IDC_LINE_BOTTOM, TRUE, 0, 2 }
};
{
int c_size_hide = _main_headers[1].width;
int c_size_show = c_size_hide - GetSystemMetrics(SM_CXVSCROLL);
int c_size_curr = ListView_GetColumnWidth( __lists[HMAIN_DRIVES], 1 );
if ( GetWindowLong(__lists[HMAIN_DRIVES], GWL_STYLE) & WS_VSCROLL )
{
if ( c_size_curr != c_size_show ) ListView_SetColumnWidth( __lists[HMAIN_DRIVES], 1, c_size_show );
} else {
if ( c_size_curr != c_size_hide ) ListView_SetColumnWidth( __lists[HMAIN_DRIVES], 1, c_size_hide );
}
}
if ( height == 0 || width == 0 )
{
return 0L;
}
for ( k = 0; k < array_num(_resize); k++ )
{
_resize_ctl(
GetDlgItem(hwnd, _resize[k].id), height - _dlg_height, 0, _resize[k].val
);
}
_dlg_height = height;
for ( k = 0; k < array_num(_move); k++ )
{
_relative_move(
GetDlgItem( hwnd, _move[k].anchor ), GetDlgItem( hwnd, _move[k].id ), _move[k].dy, _move[k].dy, _move[k].val
);
InvalidateRect( GetDlgItem( hwnd, _move[k].id ), NULL, TRUE );
}
_middle_ctl(
GetDlgItem( hwnd, IDC_DISKDRIVES ),
GetDlgItem( hwnd, IDC_RESIZING ),
TRUE
);
return 0L;
}
break;
case WM_SYSCOMMAND :
{
if ( wparam == SC_MINIMIZE || wparam == SC_RESTORE )
{
_set_timer( MAIN_TIMER, wparam == SC_RESTORE, TRUE );
}
return 0L;
}
break;
case WM_APP + WM_APP_SHOW :
{
ShowWindow( hwnd, SW_HIDE );
}
break;
case WM_NOTIFY :
{
if ( wparam == IDT_INFO )
{
if ( ((NMHDR *)lparam)->code == TCN_SELCHANGE )
{
HWND h_tab = GetDlgItem( hwnd, IDT_INFO );
if ( !_is_curr_in_group(h_tab) )
{
_change_page( h_tab, TabCtrl_GetCurSel(h_tab) );
}
}
}
if ( wparam == IDC_DISKDRIVES )
{
sel = pv( _get_sel_item( __lists[HMAIN_DRIVES] ) );
mnt = &sel->mnt;
if ( ((NMHDR *)lparam)->code == LVN_ITEMCHANGED &&
(((NMLISTVIEW *)lparam)->uNewState & LVIS_FOCUSED ) )
{
_update_info_table( FALSE );
_activate_page( );
_refresh_menu( );
return 1L;
}
if ( ((NMHDR *)lparam)->code == LVN_ITEMACTIVATE )
{
BOOL mount =
( !(sel->mnt.info.status.flags & F_ENABLED) ) &&
( sel->mnt.fs[0] == '\0' );
if (! mount )
{
if (! sel->is_root ) __execute( mnt->info.status.mnt_point );
} else {
_menu_mount( sel );
}
}
switch( ((NM_LISTVIEW *)lparam)->hdr.code )
{
case LVN_KEYDOWN :
{
WORD key = ((NMLVKEYDOWN *)lparam)->wVKey;
int item = ListView_GetSelectionMark( __lists[HMAIN_DRIVES] );
switch ( key )
{
case VK_UP: item -= 1; break;
case VK_DOWN: item += 1; break;
}
if ( _is_root_item(_get_item_index( __lists[HMAIN_DRIVES], item )) )
{
ListView_SetItemState( __lists[HMAIN_DRIVES], item, LVIS_FOCUSED, TRUE );
}
if ( key != VK_APPS )
{
break;
}
}
case NM_RCLICK :
{
int item;
HMENU h_popup = CreatePopupMenu( );
_dact *act = _create_act_thread( sel, -1, -1 );
_update_info_table( FALSE );
_activate_page( );
_set_timer(MAIN_TIMER, FALSE, FALSE);
_refresh_menu( );
if ( ListView_GetSelectedCount( __lists[HMAIN_DRIVES] ) &&
!_is_root_item((LPARAM)sel) && _is_active_item((LPARAM)sel)
)
{
if ( mnt->info.status.flags & F_ENABLED )
{
if ( mnt->info.status.flags & F_CDROM )
{
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_UNMOUNT, IDS_UNMOUNT );
} else
{
if ( mnt->info.status.flags & F_FORMATTING )
{
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_FORMAT, IDS_FORMAT );
} else
{
if ( IS_UNMOUNTABLE(&mnt->info.status) )
{
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_UNMOUNT, IDS_UNMOUNT );
}
if ( !(mnt->info.status.flags & F_SYNC) )
{
AppendMenu( h_popup, MF_SEPARATOR, 0, NULL );
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_CHANGEPASS, IDS_CHPASS );
}
if ( !(act && act->status == ACT_RUNNING) )
{
if ( mnt->info.status.flags & F_SYNC )
{
if ( GetMenuItemCount(h_popup) > 0 )
{
AppendMenu( h_popup, MF_SEPARATOR, 0, NULL );
}
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_ENCRYPT, IDS_ENCRYPT );
} else
{
if ( GetMenuItemCount(h_popup) > 0 )
{
AppendMenu( h_popup, MF_SEPARATOR, 0, NULL );
}
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_REENCRYPT, IDS_REENCRYPT );
}
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_DECRYPT, IDS_DECRYPT );
}
}
}
} else
{
if ( mnt->info.status.flags & F_CDROM )
{
if ( *mnt->fs == '\0' )
{
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_MOUNT, IDS_MOUNT );
}
} else {
if ( *mnt->fs == '\0' )
{
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_MOUNT, IDS_MOUNT );
} else {
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_ENCRYPT, IDS_ENCRYPT );
}
if ( IS_UNMOUNTABLE(&mnt->info.status) )
{
AppendMenu( h_popup, MF_SEPARATOR, 0, NULL );
AppendMenu( h_popup, MF_STRING, ID_VOLUMES_FORMAT, IDS_FORMAT );
}
}
}
}
/*
_state_menu(
popup, sel && sel->status.flags & F_LOCKED ? MF_GRAYED : MF_ENABLED
);
*/
item = TrackPopupMenu(
h_popup,
TPM_RETURNCMD | TPM_LEFTBUTTON,
LOWORD(GetMessagePos( )),
HIWORD(GetMessagePos( )),
0,
hwnd,
NULL
);
DestroyMenu( h_popup );
switch ( item )
{
case ID_VOLUMES_DECRYPT : _menu_decrypt(sel); break;
case ID_VOLUMES_ENCRYPT : _menu_encrypt(sel); break;
case ID_VOLUMES_FORMAT : _menu_format(sel); break;
case ID_VOLUMES_REENCRYPT : _menu_reencrypt(sel); break;
case ID_VOLUMES_UNMOUNT : _menu_unmount(sel); break;
case ID_VOLUMES_MOUNT : _menu_mount(sel); break;
case ID_VOLUMES_CHANGEPASS : _menu_change_pass(sel); break;
}
if ( item )
{
_refresh( TRUE );
}
_set_timer( MAIN_TIMER, TRUE, TRUE );
}
break;
case NM_CLICK :
{
sel = pv(
_get_item_index( __lists[HMAIN_DRIVES], ((NM_LISTVIEW *)lparam)->iItem )
);
_update_info_table( FALSE );
_activate_page( );
_refresh_menu( );
}
break;
}
}
if ( ((NMHDR *)lparam)->code == HDN_ITEMCHANGED )
{
InvalidateRect( __lists[HMAIN_DRIVES], NULL, TRUE );
}
if ( ((NMHDR *)lparam)->code == HDN_ITEMCHANGING )
{
return 0L;
}
if ( ((NMHDR *)lparam)->code == HDN_BEGINTRACK )
{
return 1L;
}
}
break;
case WM_COMMAND:
{
_dnode *node = pv( _get_sel_item( __lists[HMAIN_DRIVES] ) );
switch (id)
{
case ID_SHIFT_TAB :
case ID_TAB :
{
HWND h_current = GetFocus( );
HWND h_next = GetNextDlgTabItem( hwnd, h_current, id == ID_SHIFT_TAB );
SetFocus( h_next );
}
break;
case ID_TOOLS_DRIVER :
{
if ( __msg_q( __dlg, L"Remove DiskCryptor driver?") )
{
int rlt;
if ( (rlt = _drv_action(DA_REMOVE, 0)) != ST_OK )
{
__error_s( __dlg, L"Error remove DiskCryptor driver", rlt );
} else {
return 0L;
}
}
}
break;
case ID_TOOLS_BENCHMARK : _dlg_benchmark( __dlg ); break;
case ID_HELP_ABOUT : _dlg_about( __dlg ); break;
case ID_HOMEPAGE : __execute( DC_HOMEPAGE ); break;
case ID_EXIT :
{
SendMessage( hwnd, WM_CLOSE, 0, 1 );
}
break;
case IDC_BTN_WIZARD : _menu_wizard(node); break;
case ID_VOLUMES_DELETE_MNTPOINT :
{
wchar_t *mnt_point = node->mnt.info.status.mnt_point;
if ( __msg_q( __dlg, L"Are you sure you want to delete mount point [%s]?", mnt_point ) )
{
_set_trailing_slash(mnt_point);
DeleteVolumeMountPoint(mnt_point);
}
}
break;
case IDC_BTN_DECRYPT_ :
case ID_VOLUMES_DECRYPT : _menu_decrypt( node ); break;
case IDC_BTN_ENCRYPT_ :
case ID_VOLUMES_ENCRYPT : _menu_encrypt( node ); break;
case ID_VOLUMES_MOUNTALL :
case IDC_BTN_MOUNTALL_ : _menu_mountall( ); break;
case ID_VOLUMES_DISMOUNTALL :
case IDC_BTN_UNMOUNTALL_ : _menu_unmountall( ); break;
case ID_VOLUMES_DISMOUNT : _menu_unmount( node ); break;
case ID_VOLUMES_MOUNT : _menu_mount( node ); break;
case ID_VOLUMES_FORMAT : _menu_format(node); break;
case ID_VOLUMES_REENCRYPT : _menu_reencrypt( node ); break;
case ID_TOOLS_SETTINGS : _dlg_options( __dlg ); break;
case ID_BOOT_OPTIONS : _dlg_config_loader( __dlg, FALSE ); break;
case ID_VOLUMES_CHANGEPASS : _menu_change_pass( node ); break;
case ID_TOOLS_CLEARCACHE : _menu_clear_cache( ); break;
case ID_VOLUMES_BACKUPHEADER : _menu_backup_header( node ); break;
case ID_VOLUMES_RESTOREHEADER : _menu_restore_header( node ); break;
case ID_TOOLS_ENCRYPT_CD: _menu_encrypt_cd( ); break;
}
switch ( id ) {
case IDC_BTN_MOUNT_:
{
node->mnt.info.status.flags & F_ENABLED ?
_menu_unmount(node) :
_menu_mount(node);
}
break;
case ID_TOOLS_BSOD :
{
if ( __msg_q( __dlg, L"Crash?" ) )
{
dc_get_bsod( );
}
}
break;
}
if ( id == IDCANCEL )
{
ShowWindow(hwnd, SW_HIDE);
}
_refresh(TRUE);
}
break;
case WM_CLOSE :
{
if ( lparam )
{
_tray_icon(FALSE);
EndDialog(hwnd, 0);
ExitProcess(0);
} else {
ShowWindow(hwnd, SW_HIDE);
}
return 0L;
}
break;
case WM_DESTROY :
{
PostQuitMessage(0);
return 0L;
}
break;
case WM_HOTKEY :
{
switch (wparam)
{
case 0 :
{
int mount_cnt;
dc_mount_all(NULL, &mount_cnt, 0);
}
break;
case 1 : dc_unmount_all( ); break;
case 2 : dc_clean_pass_cache( ); break;
case 3 : dc_get_bsod( ); break;
}
return 1L;
}
break;
case WM_ENDSESSION :
{
if ( lparam & ENDSESSION_LOGOFF )
{
if ( __config.conf_flags & CONF_DISMOUNT_LOGOFF )
{
dc_unmount_all( );
}
if ( __config.conf_flags & CONF_WIPEPAS_LOGOFF )
{
dc_clean_pass_cache( );
}
}
}
break;
case WM_SYSCOLORCHANGE :
{
COLORREF cl_light = _cl( COLOR_BTNFACE, LGHT_CLR );
COLORREF cl_button = GetSysColor( COLOR_BTNFACE );
int k;
for ( k = 0; k < array_num(__lists); k++ )
{
if ( ( __lists[k] != HWND_NULL ) && ( __lists[k] != NULL ) )
{
ListView_SetBkColor( __lists[k], cl_button );
ListView_SetTextBkColor( __lists[k], cl_button );
ListView_SetExtendedListViewStyle( __lists[k], LVS_EX_FULLROWSELECT );
if ( !IsWindowEnabled( __lists[k] ) )
{
// EnableWindow( __lists[k], TRUE );
// EnableWindow( __lists[k], FALSE );
}
}
}
TreeView_SetBkColor( GetDlgItem(hwnd, IDC_TREE), cl_light );
ListView_SetBkColor( __lists[HMAIN_DRIVES], cl_light );
ListView_SetTextBkColor( __lists[HMAIN_DRIVES], cl_light );
ListView_SetExtendedListViewStyle( __lists[HMAIN_DRIVES], LVS_EX_FULLROWSELECT );
ListView_SetImageList( __lists[HMAIN_DRIVES], __dsk_img, LVSIL_SMALL );
}
break;
case WM_APP + WM_APP_TRAY :
{
switch ( lparam )
{
case WM_LBUTTONDOWN :
{
BOOL show = !IsWindowVisible(hwnd);
ShowWindow(hwnd, show ? SW_SHOW : SW_HIDE);
if ( show )
{
SetForegroundWindow(hwnd);
}
}
break;
case WM_RBUTTONDOWN :
{
POINT pt; int item;
HMENU menu = CreatePopupMenu( );
AppendMenu( menu, MF_STRING, ID_VOLUMES_UNMOUNTALL, IDS_UNMOUNTALL );
AppendMenu( menu, MF_STRING, ID_VOLUMES_MOUNTALL, IDS_MOUNTALL );
AppendMenu( menu, MF_SEPARATOR, 0, NULL );
AppendMenu( menu, MF_STRING, ID_TOOLS_SETTINGS, IDS_SETTINGS );
AppendMenu( menu, MF_STRING, ID_HELP_ABOUT, IDS_ABOUT );
AppendMenu( menu, MF_SEPARATOR, 0, NULL );
AppendMenu( menu, MF_STRING, ID_EXIT, IDS_EXIT );
GetCursorPos(&pt);
SetForegroundWindow( hwnd );
item = TrackPopupMenu ( menu,
TPM_RETURNCMD | TPM_LEFTALIGN | TPM_BOTTOMALIGN | TPM_RIGHTBUTTON,
pt.x, pt.y, 0, hwnd,
NULL
);
DestroyMenu( menu );
switch (item) {
case ID_VOLUMES_UNMOUNTALL : _menu_unmountall( ); break;
case ID_VOLUMES_MOUNTALL : _menu_mountall( ); break;
case ID_HELP_ABOUT : _dlg_about( HWND_DESKTOP ); break;
case ID_TOOLS_SETTINGS : _dlg_options( __dlg ); break;
case ID_EXIT :
{
SendMessage(hwnd, WM_CLOSE, 0, 1);
}
break;
}
}
break;
}
}
break;
default:
{
int rlt = _draw_proc( message, lparam );
if (rlt != -1)
{
return rlt;
}
}
}
return 0L;
}
int TabBar::currentIndex() const
{
return TabCtrl_GetCurSel(handle());
}
BOOL CALLBACK ShortcutMapper::run_dlgProc(UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG :
{
initTabs();
initList();
populateShortCuts();
goToCenter();
GetWindowRect(_hSelf,&default_sm_size);
AnchorInit(_hSelf,ShortcutAnchors,sizeof(ShortcutAnchors)/sizeof(CONTROL_ANCHOR));
RestoreWinRelPosition(_hParent,_hSelf,&WinRelPos);
return TRUE;
}
case WM_DESTROY:
SaveWinRelPosition(_hParent,_hSelf,&WinRelPos);
break;
case WM_SIZE:
AnchorResize(_hSelf,ShortcutAnchors,sizeof(ShortcutAnchors)/sizeof(CONTROL_ANCHOR));
break;
case WM_SIZING:
return ClampMinWindowSize(&default_sm_size,wParam,(RECT*)lParam);
break;
case WM_NOTIFY: {
NMHDR nmh = *((NMHDR*)lParam);
if (nmh.hwndFrom == _hTabCtrl) {
if (nmh.code == TCN_SELCHANGE) {
int index = TabCtrl_GetCurSel(_hTabCtrl);
switch (index) {
case 0:
_currentState = STATE_MENU;
break;
case 1:
_currentState = STATE_MACRO;
break;
case 2:
_currentState = STATE_USER;
break;
case 3:
_currentState = STATE_PLUGIN;
break;
case 4:
_currentState = STATE_SCINTILLA;
break;
}
populateShortCuts();
}
}
else if(nmh.hwndFrom==hlistview){
switch(nmh.code){
case NM_DBLCLK:
return ::SendMessage(_hSelf, WM_COMMAND, IDC_SHORTCUT_MODIFY, LOWORD(lParam));
case NM_RCLICK:
{
POINT p;
::GetCursorPos(&p);
if (!_rightClickMenu.isCreated())
{
vector<MenuItemUnit> itemUnitArray;
itemUnitArray.push_back(MenuItemUnit(IDC_SHORTCUT_MODIFY, TEXT("Modify")));
itemUnitArray.push_back(MenuItemUnit(IDC_SHORTCUT_DISABLE, TEXT("Disable")));
itemUnitArray.push_back(MenuItemUnit(0, 0));
itemUnitArray.push_back(MenuItemUnit(IDC_SHORTCUT_DELETE, TEXT("Delete")));
_rightClickMenu.create(_hSelf, itemUnitArray);
}
switch(_currentState) {
case STATE_MACRO:
case STATE_USER: {
_rightClickMenu.enableItem(IDC_SHORTCUT_DELETE, true);
break; }
case STATE_MENU:
case STATE_PLUGIN:
case STATE_SCINTILLA: {
_rightClickMenu.enableItem(IDC_SHORTCUT_DELETE, false);
break; }
}
_rightClickMenu.display(p);
return TRUE;
}
}
}
break; }
case WM_COMMAND :
{
switch (LOWORD(wParam))
{
case IDCANCEL :
{
::EndDialog(_hSelf, -1);
return TRUE;
}
case IDOK :
{
if(GetFocus()==hlistview)
return ::SendMessage(_hSelf, WM_COMMAND, IDC_SHORTCUT_MODIFY, LOWORD(lParam));
else
::EndDialog(_hSelf, 0);
return TRUE;
}
case IDC_SHORTCUT_FILTER2:
case IDC_SHORTCUT_FILTER1:
if(HIWORD(wParam)==EN_CHANGE)
populateShortCuts();
break;
case IDC_SHORTCUT_DISABLE:
{
int sel=0;
sel=disable_selected(FALSE);
if(sel!=0){
if(IDOK==MessageBox(_hSelf,TEXT("Ok to disable selected shortcuts?"),TEXT("Warning!"),MB_OKCANCEL|MB_SYSTEMMODAL)){
disable_selected(TRUE);
populateShortCuts();
}
}
}
break;
case IDC_SHORTCUT_MODIFY :
{
NppParameters *nppParam = NppParameters::getInstance();
int index;
int selected_row=getselectedrow();
if(selected_row<0)
break;
index=getitemindex(selected_row);
switch(_currentState) {
case STATE_MENU: {
//Get CommandShortcut corresponding to index
vector<CommandShortcut> & shortcuts = nppParam->getUserShortcuts();
CommandShortcut csc = shortcuts[index], prevcsc = shortcuts[index];
csc.init(_hInst, _hSelf);
csc.set_shortcut_info(_currentState,index);
if (csc.doDialog() != -1 && prevcsc != csc) { //shortcut was altered
generic_string keys=csc.toString();
nppParam->addUserModifiedIndex(index);
shortcuts[index] = csc;
ListView_SetItemText(hlistview,selected_row,2,(LPWSTR)keys.c_str());
update_col_width(keys.c_str(),2);
//Notify current Accelerator class to update everything
nppParam->getAccelerator()->updateShortcuts();
TCHAR str[255];
if(0<check_in_use(_currentState,index,&csc.getKeyCombo(),nppParam,str,sizeof(str)/sizeof(TCHAR)))
MessageBox(_hSelf,str,L"Duplicates found",MB_OK);
}
break;
}
case STATE_MACRO: {
//Get MacroShortcut corresponding to index
vector<MacroShortcut> & shortcuts = nppParam->getMacroList();
MacroShortcut msc = shortcuts[index], prevmsc = shortcuts[index];
msc.init(_hInst, _hSelf);
msc.set_shortcut_info(_currentState,index);
if (msc.doDialog() != -1 && prevmsc != msc) { //shortcut was altered
generic_string name=msc.getName();
generic_string keys=msc.toString();
shortcuts[index] = msc;
ListView_SetItemText(hlistview,selected_row,1,(LPWSTR)name.c_str());
ListView_SetItemText(hlistview,selected_row,2,(LPWSTR)keys.c_str());
update_col_width(keys.c_str(),2);
//Notify current Accelerator class to update everything
nppParam->getAccelerator()->updateShortcuts();
TCHAR str[255];
if(0<check_in_use(_currentState,index,&msc.getKeyCombo(),nppParam,str,sizeof(str)/sizeof(TCHAR)))
MessageBox(_hSelf,str,L"Duplicates found",MB_OK);
}
break;
}
case STATE_USER: {
//Get UserCommand corresponding to index
vector<UserCommand> & shortcuts = nppParam->getUserCommandList();
UserCommand ucmd = shortcuts[index], prevucmd = shortcuts[index];
ucmd.init(_hInst, _hSelf);
ucmd.set_shortcut_info(_currentState,index);
prevucmd = ucmd;
if (ucmd.doDialog() != -1 && prevucmd != ucmd) { //shortcut was altered
generic_string name=ucmd.getName();
generic_string keys=ucmd.toString();
shortcuts[index] = ucmd;
ListView_SetItemText(hlistview,selected_row,1,(LPWSTR)name.c_str());
ListView_SetItemText(hlistview,selected_row,2,(LPWSTR)keys.c_str());
update_col_width(name.c_str(),1);
update_col_width(keys.c_str(),2);
//Notify current Accelerator class to update everything
nppParam->getAccelerator()->updateShortcuts();
TCHAR str[255];
if(0<check_in_use(_currentState,index,&ucmd.getKeyCombo(),nppParam,str,sizeof(str)/sizeof(TCHAR)))
MessageBox(_hSelf,str,L"Duplicates found",MB_OK);
}
break;
}
case STATE_PLUGIN: {
//Get PluginCmdShortcut corresponding to index
vector<PluginCmdShortcut> & shortcuts = nppParam->getPluginCommandList();
if(shortcuts.empty())
break;
PluginCmdShortcut pcsc = shortcuts[index], prevpcsc = shortcuts[index];
pcsc.init(_hInst, _hSelf);
pcsc.set_shortcut_info(_currentState,index);
prevpcsc = pcsc;
if (pcsc.doDialog() != -1 && prevpcsc != pcsc) { //shortcut was altered
nppParam->addPluginModifiedIndex(index);
generic_string keys=pcsc.toString();
shortcuts[index] = pcsc;
ListView_SetItemText(hlistview,selected_row,2,(LPWSTR)keys.c_str());
update_col_width(keys.c_str(),2);
//Notify current Accelerator class to update everything
nppParam->getAccelerator()->updateShortcuts();
TCHAR str[255];
if(0<check_in_use(_currentState,index,&pcsc.getKeyCombo(),nppParam,str,sizeof(str)/sizeof(TCHAR)))
MessageBox(_hSelf,str,L"Duplicates found",MB_OK);
unsigned long cmdID = pcsc.getID();
ShortcutKey shortcut;
shortcut._isAlt = pcsc.getKeyCombo()._isAlt;
shortcut._isCtrl = pcsc.getKeyCombo()._isCtrl;
shortcut._isShift = pcsc.getKeyCombo()._isShift;
shortcut._key = pcsc.getKeyCombo()._key;
::SendMessage(_hParent, NPPM_INTERNAL_PLUGINSHORTCUTMOTIFIED, cmdID, (LPARAM)&shortcut);
}
break;
}
case STATE_SCINTILLA: {
//Get ScintillaKeyMap corresponding to index
vector<ScintillaKeyMap> & shortcuts = nppParam->getScintillaKeyList();
ScintillaKeyMap skm = shortcuts[index], prevskm = shortcuts[index];
skm.init(_hInst, _hSelf);
skm.set_shortcut_info(_currentState,index);
if (skm.doDialog() != -1 && prevskm != skm)
{
//shortcut was altered
nppParam->addScintillaModifiedIndex(index);
shortcuts[index] = skm;
int i,max;
TCHAR str[40]={0};
max=skm.getSize();
for(i=0;i<max;i++){
generic_string keys=skm.toString(i);
_sntprintf_s(str,sizeof(str)/sizeof(TCHAR),_TRUNCATE,L"%s%s%c",str,keys.c_str(),i<(max-1)?L';':L'');
}
ListView_SetItemText(hlistview,selected_row,2,(LPWSTR)str);
update_col_width(str,2);
if(max>0){
TCHAR str[255];
KeyCombo skmkc=skm.getKeyComboByIndex(0);
if(0<check_in_use(_currentState,index,&skmkc,nppParam,str,sizeof(str)/sizeof(TCHAR)))
MessageBox(_hSelf,str,L"Duplicates found",MB_OK);
}
//Notify current Accelerator class to update key
nppParam->getScintillaAccelerator()->updateKeys();
}
break;
}
}
return TRUE;
}
case IDC_SHORTCUT_DELETE :
{
NppParameters *nppParam = NppParameters::getInstance();
int index,selected_row=getselectedrow();
TCHAR str[255]={0},msg[255]={0};
if(selected_row<0)
break;
index=getitemindex(selected_row);
ListView_GetItemText(hlistview,selected_row,1,str,sizeof(str)/sizeof(TCHAR));
_sntprintf_s(msg,sizeof(msg)/sizeof(TCHAR),_TRUNCATE,
TEXT("%s\r\n%s"),
TEXT("Are you sure you want to delete this shortcut?"),
str);
if (::MessageBox(_hSelf, msg, TEXT("Are you sure?"), MB_OKCANCEL) == IDOK)
{
int shortcutIndex = index;
DWORD cmdID = 0;
// Menu data
size_t posBase = 0;
size_t nbElem = 0;
HMENU hMenu = NULL;
int modifCmd = IDM_SETTING_SHORTCUT_MAPPER_RUN;
switch(_currentState)
{
case STATE_MENU:
case STATE_PLUGIN:
case STATE_SCINTILLA:
{
return FALSE; //this is bad
}
case STATE_MACRO:
{
vector<MacroShortcut> & theMacros = nppParam->getMacroList();
vector<MacroShortcut>::iterator it = theMacros.begin();
cmdID = theMacros[shortcutIndex].getID();
theMacros.erase(it + shortcutIndex);
populateShortCuts();
// preparing to remove from menu
posBase = 6;
nbElem = theMacros.size();
hMenu = ::GetSubMenu((HMENU)::SendMessage(_hParent, NPPM_INTERNAL_GETMENU, 0, 0), MENUINDEX_MACRO);
modifCmd = IDM_SETTING_SHORTCUT_MAPPER_MACRO;
for (size_t i = shortcutIndex ; i < nbElem ; i++) //lower the IDs of the remaining items so there are no gaps
{
MacroShortcut ms = theMacros[i];
ms.setID(ms.getID() - 1); //shift all IDs
theMacros[i] = ms;
}
break;
}
case STATE_USER:
{
vector<UserCommand> & theUserCmds = nppParam->getUserCommandList();
vector<UserCommand>::iterator it = theUserCmds.begin();
cmdID = theUserCmds[shortcutIndex].getID();
theUserCmds.erase(it + shortcutIndex);
populateShortCuts();
// preparing to remove from menu
posBase = 2;
nbElem = theUserCmds.size();
hMenu = ::GetSubMenu((HMENU)::SendMessage(_hParent, NPPM_INTERNAL_GETMENU, 0, 0), MENUINDEX_RUN);
modifCmd = IDM_SETTING_SHORTCUT_MAPPER_RUN;
for (size_t i = shortcutIndex ; i < nbElem ; i++) //lower the IDs of the remaining items so there are no gaps
{
UserCommand uc = theUserCmds[i];
uc.setID(uc.getID() - 1); //shift all IDs
theUserCmds[i] = uc;
}
break;
}
}
// updateShortcuts() will update all menu item - the menu items will be shifted
nppParam->getAccelerator()->updateShortcuts();
// All menu items are shifted up. So we delete the last item
::RemoveMenu(hMenu, posBase + nbElem, MF_BYPOSITION);
if (nbElem == 0)
{
::RemoveMenu(hMenu, modifCmd, MF_BYCOMMAND);
//remove separator
::RemoveMenu(hMenu, posBase-1, MF_BYPOSITION);
::RemoveMenu(hMenu, posBase-1, MF_BYPOSITION);
}
}
return TRUE;
}
}
}
default:
return FALSE;
}
return FALSE;
}
static INT_PTR CALLBACK helpDlgProc(HWND hwndDlg,UINT msg,WPARAM wParam,LPARAM lParam)
{
HELPDLGDATA *dat = (HELPDLGDATA *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
switch(msg) {
case WM_INITDIALOG:
TranslateDialogDefault(hwndDlg);
{
hwndHelpDialog = hwndDlg;
dat = (HELPDLGDATA*)mir_calloc(sizeof(HELPDLGDATA));
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)dat);
dat->vhs = (VARHELPINFO *)lParam;
// set tabs
int tabCount = 0;
RECT rcTabs, rcParent;
HWND hTab = GetDlgItem(hwndDlg, IDC_TABS);
GetWindowRect(hTab, &rcTabs);
GetWindowRect(hwndDlg, &rcParent);
TCITEM tci = { 0 };
HWND hPage, hShow = 0;
if (dat->vhs->flags&VHF_TOKENS) {
// token tab
tci.mask = TCIF_TEXT | TCIF_PARAM;
tci.pszText = TranslateT("Tokens");
hPage = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_TOKENS_DIALOG), hwndDlg, tokenHelpDlgProc, (LPARAM)GetParent(hwndDlg));
EnableThemeDialogTexture(hPage, ETDT_ENABLETAB);
tci.lParam = (LPARAM)hPage;
MoveWindow(hPage, (rcTabs.left - rcParent.left), (rcTabs.top - rcParent.top), (rcTabs.right - rcTabs.left) - 2 * iFrameX, (rcTabs.bottom - rcTabs.top) - 2 * iFrameY, TRUE);
ShowWindow(hPage, SW_HIDE);
TabCtrl_InsertItem(hTab, tabCount++, &tci);
hShow = hShow == 0 ? hPage : hShow;
}
if (dat->vhs->flags&VHF_INPUT) {
// input tab
tci.mask = TCIF_TEXT | TCIF_PARAM;
tci.pszText = TranslateT("Input");
dat->hwndInputDlg = hPage = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_INPUT_DIALOG), hwndDlg, inputDlgProc, (LPARAM)GetParent(hwndDlg));
EnableThemeDialogTexture(hPage, ETDT_ENABLETAB);
tci.lParam = (LPARAM)hPage;
MoveWindow(hPage, (rcTabs.left - rcParent.left), (rcTabs.top - rcParent.top), (rcTabs.right - rcTabs.left) - 2 * iFrameX, (rcTabs.bottom - rcTabs.top) - 2 * iFrameY, TRUE);
ShowWindow(hPage, SW_HIDE);
TabCtrl_InsertItem(hTab, tabCount++, &tci);
hShow = hShow == 0 ? hPage : hShow;
if ((dat->vhs->fi != NULL) && (dat->vhs->fi->szFormat != NULL)) {
if (dat->vhs->fi->flags & FIF_UNICODE)
SendMessage(hwndDlg, VARM_SETINPUTTEXT, 0, (LPARAM)dat->vhs->fi->tszFormat);
else {
WCHAR *wszFormatString = mir_a2t(dat->vhs->fi->szFormat);
SendMessage(hwndDlg, VARM_SETINPUTTEXT, 0, (LPARAM)wszFormatString);
mir_free(wszFormatString);
}
}
else if (dat->vhs->hwndCtrl != NULL) {
TCHAR *tszText = Hlp_GetWindowText(dat->vhs->hwndCtrl);
if (tszText != NULL) {
SendMessage(hwndDlg, VARM_SETINPUTTEXT, 0, (LPARAM)tszText);
mir_free(tszText);
}
}
if (dat->vhs->fi != NULL || dat->vhs->hwndCtrl != NULL) {
SetDlgItemText(hwndDlg, IDC_CANCEL, TranslateT("Cancel"));
ShowWindow(GetDlgItem(hwndDlg, IDC_OK), SW_SHOW);
}
}
if ((dat->vhs->flags&VHF_SUBJECT) ||
((dat->vhs->flags&VHF_INPUT) && (((dat->vhs->fi != NULL) && (dat->vhs->fi->hContact != NULL)) || (dat->vhs->flags&VHF_SETLASTSUBJECT)))) {
// subject window is created, but not necessarily shown
dat->hwndSubjectDlg = hPage = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_CLIST_DIALOG), hwndDlg, clistDlgProc, (LPARAM)GetParent(hwndDlg));
EnableThemeDialogTexture(hPage, ETDT_ENABLETAB);
MoveWindow(hPage, (rcTabs.left - rcParent.left), (rcTabs.top - rcParent.top), (rcTabs.right - rcTabs.left) - 2 * iFrameX, (rcTabs.bottom - rcTabs.top) - 2 * iFrameY, TRUE);
ShowWindow(hPage, SW_HIDE);
if ((dat->vhs->fi != NULL) && (dat->vhs->fi->hContact != NULL))
SendMessage(hwndDlg, VARM_SETSUBJECT, (WPARAM)dat->vhs->fi->hContact, 0);
else if (dat->vhs->flags&VHF_SETLASTSUBJECT)
SendMessage(hwndDlg, VARM_SETSUBJECT, (WPARAM)INVALID_HANDLE_VALUE, 0);
if (dat->vhs->flags&VHF_SUBJECT) {
// create subject tab
tci.lParam = (LPARAM)hPage;
tci.mask = TCIF_TEXT | TCIF_PARAM;
tci.pszText = TranslateT("%subject%");
TabCtrl_InsertItem(hTab, tabCount++, &tci);
hShow = hShow == 0 ? hPage : hShow;
}
}
if ((dat->vhs->flags&VHF_EXTRATEXT) ||
((dat->vhs->flags&VHF_INPUT) && (dat->vhs->fi != NULL) && (dat->vhs->fi->tszExtraText != NULL))) {
// extratext window is created, but not necessarily shown
dat->hwndExtraTextDlg = hPage = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_EXTRATEXT_DIALOG), hwndDlg, extratextDlgProc, (LPARAM)GetParent(hwndDlg));
EnableThemeDialogTexture(hPage, ETDT_ENABLETAB);
MoveWindow(hPage, (rcTabs.left - rcParent.left), (rcTabs.top - rcParent.top), (rcTabs.right - rcTabs.left) - 2 * iFrameX, (rcTabs.bottom - rcTabs.top) - 2 * iFrameY, TRUE);
ShowWindow(hPage, SW_HIDE);
if ((dat->vhs->fi != NULL) && (dat->vhs->fi->tszExtraText != NULL)) {
if (dat->vhs->fi->flags & FIF_UNICODE)
SendMessage(hwndDlg, VARM_SETEXTRATEXT, 0, (LPARAM)dat->vhs->fi->tszExtraText);
else {
WCHAR *wszSource = mir_a2t(dat->vhs->fi->szExtraText);
SendMessage(hwndDlg, VARM_SETEXTRATEXT, 0, (LPARAM)wszSource);
mir_free(wszSource);
}
}
if (dat->vhs->flags&VHF_EXTRATEXT) {
// create extratext tab
tci.mask = TCIF_TEXT | TCIF_PARAM;
tci.pszText = TranslateT("%extratext%");
tci.lParam = (LPARAM)hPage;
TabCtrl_InsertItem(hTab, tabCount++, &tci);
hShow = hShow == 0 ? hPage : hShow;
}
}
if (dat->vhs->flags&VHF_HELP) {
// helpinfo tab
tci.mask = TCIF_TEXT | TCIF_PARAM;
tci.pszText = TranslateT("Help");
hPage = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_HELPINFO_DIALOG), hwndDlg, helpInfoDlgProc, (LPARAM)GetParent(hwndDlg));
EnableThemeDialogTexture(hPage, ETDT_ENABLETAB);
tci.lParam = (LPARAM)hPage;
MoveWindow(hPage, (rcTabs.left - rcParent.left), (rcTabs.top - rcParent.top), (rcTabs.right - rcTabs.left) - 2 * iFrameX, (rcTabs.bottom - rcTabs.top) - 2 * iFrameY, TRUE);
ShowWindow(hPage, SW_HIDE);
TabCtrl_InsertItem(hTab, tabCount++, &tci);
hShow = hShow == 0 ? hPage : hShow;
}
Utils_RestoreWindowPositionNoMove(hwndDlg, NULL, MODULENAME, "help");
SetWindowText(hwndDlg, TranslateT("Variables Help"));
ShowWindow(hShow, SW_SHOW);
break;
}
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_OK:
if ((dat->vhs->fi != NULL) && (!(dat->vhs->flags&VHF_DONTFILLSTRUCT))) {
int len = SendMessage(hwndDlg, VARM_GETINPUTTEXTLENGTH, 0, 0);
if (len > 0) {
if ((dat->vhs->fi != NULL) && (!(dat->vhs->flags&VHF_DONTFILLSTRUCT))) {
if (dat->vhs->fi->flags&FIF_UNICODE) {
dat->vhs->fi->tszFormat = (TCHAR*)mir_calloc((len + 1)*sizeof(WCHAR));
SendMessage(hwndDlg, VARM_GETINPUTTEXT, (WPARAM)len + 1, (LPARAM)dat->vhs->fi->tszFormat);
}
else {
dat->vhs->fi->szFormat = (char*)mir_calloc(len + 1);
SendMessageA(hwndDlg, VARM_GETINPUTTEXT, (WPARAM)len + 1, (LPARAM)dat->vhs->fi->szFormat);
}
}
}
}
if (dat->vhs->hwndCtrl != NULL) {
int len = SendMessage(hwndDlg, VARM_GETINPUTTEXTLENGTH, 0, 0);
if (len > 0) {
TCHAR *tszText;
tszText = (TCHAR*)mir_calloc((len + 1)*sizeof(TCHAR));
if (tszText != NULL) {
SendMessage(hwndDlg, VARM_GETINPUTTEXT, (WPARAM)len + 1, (LPARAM)tszText);
SetWindowText(dat->vhs->hwndCtrl, tszText);
mir_free(tszText);
}
}
SendMessage(GetParent(dat->vhs->hwndCtrl),
WM_COMMAND,
MAKEWPARAM(GetDlgCtrlID(dat->vhs->hwndCtrl),
EN_CHANGE),
(LPARAM)dat->vhs->hwndCtrl);
}
if ((dat->vhs->flags&VHF_FULLFILLSTRUCT) && (dat->vhs->fi != NULL)) {
int len = SendMessage(hwndDlg, VARM_GETEXTRATEXTLENGTH, 0, 0);
if (len > 0) {
if (dat->vhs->fi->flags&FIF_UNICODE) {
dat->vhs->fi->tszExtraText = (TCHAR*)mir_calloc((len + 1)*sizeof(WCHAR));
SendMessage(hwndDlg, VARM_GETEXTRATEXT, (WPARAM)len + 1, (LPARAM)dat->vhs->fi->tszExtraText);
}
else {
dat->vhs->fi->szExtraText = (char*)mir_calloc(len + 1);
SendMessageA(hwndDlg, VARM_GETEXTRATEXT, (WPARAM)len + 1, (LPARAM)dat->vhs->fi->szExtraText);
}
}
dat->vhs->fi->hContact = (MCONTACT)SendMessage(hwndDlg, VARM_GETSUBJECT, 0, 0);
}
// fall through
case IDC_CANCEL:
if (GetParent(hwndDlg) == NULL)
DestroyWindow(hwndDlg);
else
EndDialog(hwndDlg, 0);
break;
}
break;
case VARM_SETSUBJECT:
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT,
SendMessage(dat->hwndSubjectDlg, VARM_SETSUBJECT, wParam, lParam));
return TRUE;
case VARM_GETSUBJECT:
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT,
SendMessage(dat->hwndSubjectDlg, VARM_GETSUBJECT, wParam, lParam));
return TRUE;
case VARM_SETEXTRATEXT:
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT,
SendMessage(dat->hwndExtraTextDlg, VARM_SETEXTRATEXT, wParam, lParam));
return TRUE;
case VARM_GETEXTRATEXTLENGTH:
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT,
SendMessage(dat->hwndExtraTextDlg, VARM_GETEXTRATEXTLENGTH, wParam, lParam));
return TRUE;
case VARM_GETEXTRATEXT:
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT,
SendMessage(dat->hwndExtraTextDlg, VARM_GETEXTRATEXT, wParam, lParam));
return TRUE;
case VARM_SETINPUTTEXT:
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT,
SendMessage(dat->hwndInputDlg, VARM_SETINPUTTEXT, wParam, lParam));
return TRUE;
case VARM_GETINPUTTEXTLENGTH:
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT,
SendMessage(dat->hwndInputDlg, VARM_GETINPUTTEXTLENGTH, wParam, lParam));
return TRUE;
case VARM_GETINPUTTEXT:
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT,
SendMessage(dat->hwndInputDlg, VARM_GETINPUTTEXT, wParam, lParam));
return TRUE;
case VARM_GETDIALOG:
switch (wParam) {
case VHF_INPUT:
SetWindowLongPtr(hwndDlg, DWLP_MSGRESULT, (LONG_PTR)dat->hwndInputDlg);
return TRUE;
}
break;
case WM_GETMINMAXINFO:
{
int i, count;
TCITEM tci;
RECT rcParent;
HWND hTab;
MINMAXINFO pageMinMax;
GetWindowRect(hwndDlg, &rcParent);
// defaults
((MINMAXINFO*)lParam)->ptMinTrackSize.x = 400;
((MINMAXINFO*)lParam)->ptMinTrackSize.y = 400;
hTab = GetDlgItem(hwndDlg, IDC_TABS);
tci.mask = TCIF_PARAM;
count = TabCtrl_GetItemCount(hTab);
// return the largest of all pages
for (i = 0; i < count; i++) {
TabCtrl_GetItem(hTab, i, &tci);
memset(&pageMinMax, 0, sizeof(pageMinMax));
SendMessage((HWND)tci.lParam, WM_GETMINMAXINFO, wParam, (LPARAM)&pageMinMax);
((MINMAXINFO*)lParam)->ptMinTrackSize.x = max(((MINMAXINFO*)lParam)->ptMinTrackSize.x, pageMinMax.ptMinTrackSize.x);
((MINMAXINFO*)lParam)->ptMinTrackSize.y = max(((MINMAXINFO*)lParam)->ptMinTrackSize.y, pageMinMax.ptMinTrackSize.y);
}
}
break;
case WM_SIZE:
if (!IsIconic(hwndDlg)) {
UTILRESIZEDIALOG urd = { 0 };
urd.cbSize = sizeof(urd);
urd.hInstance = hInst;
urd.hwndDlg = hwndDlg;
urd.lParam = 0;
// ! uses ANSI version !
urd.lpTemplate = MAKEINTRESOURCEA(IDD_HELP_DIALOG);
urd.pfnResizer = helpDialogResize;
CallService(MS_UTILS_RESIZEDIALOG, 0, (LPARAM)&urd);
SendMessage(hwndDlg, WM_MOVE, 0, 0);
RECT rcTabs, rcParent;
HWND hTab = GetDlgItem(hwndDlg, IDC_TABS);
GetWindowRect(hTab, &rcTabs);
GetWindowRect(hwndDlg, &rcParent);
TCITEM tci;
tci.mask = TCIF_PARAM;
int count = TabCtrl_GetItemCount(hTab);
for (int i = 0; i < count; i++) {
TabCtrl_GetItem(GetDlgItem(hwndDlg, IDC_TABS), i, &tci);
MoveWindow((HWND)tci.lParam, (rcTabs.left - rcParent.left), (rcTabs.top - rcParent.top), (rcTabs.right - rcTabs.left) - 2 * iFrameX, (rcTabs.bottom - rcTabs.top) - 2 * iFrameY, TRUE);
}
}
break;
case WM_NOTIFY:
if ((((NMHDR*)lParam)->idFrom == IDC_TABS)) {
if (((NMHDR*)lParam)->code == TCN_SELCHANGING) {
TCITEM tci;
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(GetDlgItem(hwndDlg, IDC_TABS), TabCtrl_GetCurSel(GetDlgItem(hwndDlg, IDC_TABS)), &tci);
ShowWindow((HWND)tci.lParam, SW_HIDE);
}
else if (((NMHDR*)lParam)->code == TCN_SELCHANGE) {
TCITEM tci;
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(GetDlgItem(hwndDlg, IDC_TABS), TabCtrl_GetCurSel(GetDlgItem(hwndDlg, IDC_TABS)), &tci);
ShowWindow((HWND)tci.lParam, SW_SHOW);
}
}
break;
case WM_CLOSE:
if (GetParent(hwndDlg) == NULL)
DestroyWindow(hwndDlg);
else
EndDialog(hwndDlg, 0);
break;
case WM_DESTROY:
Utils_SaveWindowPosition(hwndDlg, NULL, MODULENAME, "help");
HWND hTab = GetDlgItem(hwndDlg, IDC_TABS);
TCITEM tci;
tci.mask = TCIF_PARAM;
int count = TabCtrl_GetItemCount(hTab);
for (int i = 0; i < count; i++) {
TabCtrl_GetItem(hTab, i, &tci);
if (((HWND)tci.lParam != dat->hwndSubjectDlg) && ((HWND)tci.lParam != dat->hwndExtraTextDlg))
DestroyWindow((HWND)tci.lParam);
}
// these windows might have been created, but not inserted as tabs
if (IsWindow(dat->hwndSubjectDlg))
DestroyWindow(dat->hwndSubjectDlg);
if (IsWindow(dat->hwndExtraTextDlg))
DestroyWindow(dat->hwndExtraTextDlg);
mir_free(dat);
dat = NULL;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, 0);
break;
}
return FALSE;
}
void ApplicationPageUpdate(void)
{
/* Enable or disable the "End Task" & "Switch To" buttons */
if (ListView_GetSelectedCount(hApplicationPageListCtrl))
{
EnableWindow(hApplicationPageEndTaskButton, TRUE);
}
else
{
EnableWindow(hApplicationPageEndTaskButton, FALSE);
}
/* Enable "Switch To" button only if one app is selected */
if (ListView_GetSelectedCount(hApplicationPageListCtrl) == 1 )
{
EnableWindow(hApplicationPageSwitchToButton, TRUE);
}
else
{
EnableWindow(hApplicationPageSwitchToButton, FALSE);
}
/* If we are on the applications tab the windows menu will be */
/* present on the menu bar so enable & disable the menu items */
if (TabCtrl_GetCurSel(hTabWnd) == 0)
{
HMENU hMenu;
HMENU hWindowsMenu;
hMenu = GetMenu(hMainWnd);
hWindowsMenu = GetSubMenu(hMenu, 3);
/* Only one item selected */
if (ListView_GetSelectedCount(hApplicationPageListCtrl) == 1)
{
EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEHORIZONTALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEVERTICALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_MINIMIZE, MF_BYCOMMAND|MF_ENABLED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_MAXIMIZE, MF_BYCOMMAND|MF_ENABLED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_CASCADE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_BRINGTOFRONT, MF_BYCOMMAND|MF_ENABLED);
}
/* More than one item selected */
else if (ListView_GetSelectedCount(hApplicationPageListCtrl) > 1)
{
EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEHORIZONTALLY, MF_BYCOMMAND|MF_ENABLED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEVERTICALLY, MF_BYCOMMAND|MF_ENABLED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_MINIMIZE, MF_BYCOMMAND|MF_ENABLED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_MAXIMIZE, MF_BYCOMMAND|MF_ENABLED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_CASCADE, MF_BYCOMMAND|MF_ENABLED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_BRINGTOFRONT, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
}
/* No items selected */
else
{
EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEHORIZONTALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_TILEVERTICALLY, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_MINIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_MAXIMIZE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_CASCADE, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
EnableMenuItem(hWindowsMenu, ID_WINDOWS_BRINGTOFRONT, MF_BYCOMMAND|MF_DISABLED|MF_GRAYED);
}
}
}
BOOL CALLBACK CPublisherProperties::PropDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CPublisherProperties *_this = (CPublisherProperties *) GetWindowLong(hwnd, GWL_USERDATA);
switch (uMsg)
{
case WM_INITDIALOG:
{
SetWindowLong(hwnd, GWL_USERDATA, lParam);
CPublisherProperties* _this = (CPublisherProperties*) lParam;
_this->m_bIsPropDlgVisible = true;
_this->m_hPropWnd = hwnd;
InitCommonControls();
_this->m_hTab = GetDlgItem(hwnd, IDC_TAB_DIMDIM);
TCITEM item;
item.mask = TCIF_TEXT;
item.pszText=_T("Simple");
TabCtrl_InsertItem(_this->m_hTab, 0, &item);
item.pszText = _T("Advanced");
TabCtrl_InsertItem(_this->m_hTab, 1, &item);
TabCtrl_SetCurSel(_this->m_hTab, 0);
int tab_id = 0;
_this->m_hSimplePropWnd = CreateDialogParam(hAppInstance, MAKEINTRESOURCE(IDD_SIMPLEPROPS_DLG),
hwnd, (DLGPROC)_this->SimplePropDlgProc, (LONG)_this);
_this->m_hAdvancedPropWnd = CreateDialogParam(hAppInstance, MAKEINTRESOURCE(IDD_ADVPROPS_DLG),
hwnd, (DLGPROC)_this->AdvancedPropDlgProc, (LONG)_this);
RECT rc;
GetWindowRect(_this->m_hTab, &rc);
MapWindowPoints(NULL, hwnd, (POINT *)&rc, 2);
TabCtrl_AdjustRect(_this->m_hTab, FALSE, &rc);
SetWindowPos(_this->m_hSimplePropWnd, HWND_TOP, rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top,
(tab_id == 0) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW);
SetWindowPos(_this->m_hAdvancedPropWnd, HWND_TOP, rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top,
(tab_id == 1) ? SWP_SHOWWINDOW : SWP_HIDEWINDOW);
::SetForegroundWindow(hwnd);
return TRUE;
}
case WM_NOTIFY:
{
LPNMHDR pn = (LPNMHDR)lParam;
switch (pn->idFrom)
{
case IDC_TAB_DIMDIM:
{
int id = TabCtrl_GetCurSel(_this->m_hTab);
DWORD style;
if (pn->code == TCN_SELCHANGE) {
style = SW_SHOW;
} else if (pn->code == TCN_SELCHANGING) {
style = SW_HIDE;
} else {
return 0;
}
// FIXME: Map between tab IDs and subdialogs in one place.
const HWND subDialogList[2] = {_this->m_hSimplePropWnd, _this->m_hAdvancedPropWnd};
if (id >= 2) {
// Invalid tab ID.
return 0;
}
HWND subDialog = subDialogList[id];
ShowWindow(subDialog, style);
SetFocus(subDialog);
return 0;
}
}
return 0;
}
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDCANCEL:
EndDialog(hwnd, IDCANCEL);
_this->m_bIsPropDlgVisible = false;
return TRUE;
case IDOK:
{
// Get current profile from the dialog
int iVal = _this->m_simpleProps->GetCurrentProfile();
if (0 == iVal)
CProfileManager::getInstance()->enforceHighBWProfile();
else if (1 == iVal)
CProfileManager::getInstance()->enforceMediumBWProfile();
else
CProfileManager::getInstance()->enforceLowBWProfile();
// Local dump policy
if (false == _this->m_advancedProps->LocalDumpEnabled())
iVal = 2;
else
iVal = 3;
CProfileManager::getInstance()->UpdateConfig("OperationType", iVal);
// Logging policy
if (false == _this->m_advancedProps->LogEnabled())
iVal = 0;
else
iVal = 2;
CProfileManager::getInstance()->UpdateConfig("Logging", iVal);
// Commit modifications to configuration
CProfileManager::getInstance()->CommitConfig();
EndDialog(hwnd, IDOK);
_this->m_bIsPropDlgVisible = false;
}
return TRUE;
}
return 0;
}
return 0;
}
INT_PTR WINAPI ConEmuAbout::aboutProc(HWND hDlg, UINT messg, WPARAM wParam, LPARAM lParam)
{
INT_PTR lRc = 0;
if ((mp_ImgBtn && mp_ImgBtn->Process(hDlg, messg, wParam, lParam, lRc))
|| EditIconHint_Process(hDlg, messg, wParam, lParam, lRc))
{
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, lRc);
return TRUE;
}
PatchMsgBoxIcon(hDlg, messg, wParam, lParam);
switch (messg)
{
case WM_INITDIALOG:
{
gpConEmu->OnOurDialogOpened();
mh_AboutDlg = hDlg;
CDynDialog::LocalizeDialog(hDlg);
_ASSERTE(mp_ImgBtn==NULL);
SafeDelete(mp_ImgBtn);
mp_ImgBtn = new CImgButtons(hDlg, pIconCtrl, IDOK);
mp_ImgBtn->AddDonateButtons();
if (mp_DpiAware)
{
mp_DpiAware->Attach(hDlg, ghWnd, CDynDialog::GetDlgClass(hDlg));
}
CDpiAware::CenterDialog(hDlg);
if ((ghOpWnd && IsWindow(ghOpWnd)) || (WS_EX_TOPMOST & GetWindowLongPtr(ghWnd, GWL_EXSTYLE)))
{
SetWindowPos(hDlg, HWND_TOPMOST, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE);
}
LPCWSTR pszActivePage = (LPCWSTR)lParam;
wchar_t* pszTitle = lstrmerge(gpConEmu->GetDefaultTitle(), L" ", CLngRc::getRsrc(lng_DlgAbout/*"About"*/));
if (pszTitle)
{
SetWindowText(hDlg, pszTitle);
SafeFree(pszTitle);
}
if (hClassIcon)
{
SendMessage(hDlg, WM_SETICON, ICON_BIG, (LPARAM)hClassIcon);
SendMessage(hDlg, WM_SETICON, ICON_SMALL, (LPARAM)CreateNullIcon());
SetClassLongPtr(hDlg, GCLP_HICON, (LONG_PTR)hClassIcon);
}
// "Console Emulation program (local terminal)"
SetDlgItemText(hDlg, stConEmuAbout, CLngRc::getRsrc(lng_AboutAppName));
SetDlgItemText(hDlg, stConEmuUrl, gsHomePage);
EditIconHint_Set(hDlg, GetDlgItem(hDlg, tAboutSearch), true,
CLngRc::getRsrc(lng_Search/*"Search"*/),
false, UM_SEARCH, IDOK);
EditIconHint_Subclass(hDlg);
wchar_t* pszLabel = GetDlgItemTextPtr(hDlg, stConEmuVersion);
if (pszLabel)
{
wchar_t* pszSet = NULL;
if (gpUpd)
{
wchar_t* pszVerInfo = gpUpd->GetCurVerInfo();
if (pszVerInfo)
{
pszSet = lstrmerge(pszLabel, L" ", pszVerInfo);
free(pszVerInfo);
}
}
if (!pszSet)
{
pszSet = lstrmerge(pszLabel, L" ", L"Please check for updates manually");
}
if (pszSet)
{
SetDlgItemText(hDlg, stConEmuVersion, pszSet);
free(pszSet);
}
free(pszLabel);
}
HWND hTab = GetDlgItem(hDlg, tbAboutTabs);
INT_PTR nPage = -1;
for (size_t i = 0; i < countof(Pages); i++)
{
TCITEM tie = {};
tie.mask = TCIF_TEXT;
tie.pszText = (LPWSTR)Pages[i].Title;
TabCtrl_InsertItem(hTab, i, &tie);
if (pszActivePage && (lstrcmpi(pszActivePage, Pages[i].Title) == 0))
nPage = i;
}
if (nPage >= 0)
{
TabSelected(hDlg, nPage);
TabCtrl_SetCurSel(hTab, (int)nPage);
}
else if (!pszActivePage)
{
TabSelected(hDlg, 0);
}
else
{
_ASSERTE(pszActivePage==NULL && "Unknown page name?");
}
SetFocus(hTab);
return FALSE;
}
case WM_CTLCOLORSTATIC:
if (GetWindowLongPtr((HWND)lParam, GWLP_ID) == stConEmuUrl)
{
SetTextColor((HDC)wParam, GetSysColor(COLOR_HOTLIGHT));
HBRUSH hBrush = GetSysColorBrush(COLOR_3DFACE);
SetBkMode((HDC)wParam, TRANSPARENT);
return (INT_PTR)hBrush;
}
else
{
SetTextColor((HDC)wParam, GetSysColor(COLOR_WINDOWTEXT));
HBRUSH hBrush = GetSysColorBrush(COLOR_3DFACE);
SetBkMode((HDC)wParam, TRANSPARENT);
return (INT_PTR)hBrush;
}
break;
case WM_SETCURSOR:
{
if (GetWindowLongPtr((HWND)wParam, GWLP_ID) == stConEmuUrl)
{
SetCursor(LoadCursor(NULL, IDC_HAND));
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, TRUE);
return TRUE;
}
return FALSE;
}
break;
case WM_COMMAND:
switch (HIWORD(wParam))
{
case BN_CLICKED:
switch (LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
case IDCLOSE:
aboutProc(hDlg, WM_CLOSE, 0, 0);
return 1;
case stConEmuUrl:
ConEmuAbout::OnInfo_HomePage();
return 1;
} // BN_CLICKED
break;
case EN_SETFOCUS:
switch (LOWORD(wParam))
{
case tAboutText:
{
// Do not autosel all text
HWND hEdit = (HWND)lParam;
DWORD nStart = 0, nEnd = 0;
SendMessage(hEdit, EM_GETSEL, (WPARAM)&nStart, (LPARAM)&nEnd);
if (nStart != nEnd)
{
SendMessage(hEdit, EM_SETSEL, nTextSelStart, nTextSelEnd);
}
}
break;
}
} // switch (HIWORD(wParam))
break;
case WM_NOTIFY:
{
LPNMHDR nmhdr = (LPNMHDR)lParam;
if ((nmhdr->code == TCN_SELCHANGE) && (nmhdr->idFrom == tbAboutTabs))
{
int iPage = TabCtrl_GetCurSel(nmhdr->hwndFrom);
if ((iPage >= 0) && (iPage < (int)countof(Pages)))
TabSelected(hDlg, iPage);
}
break;
}
case UM_SEARCH:
searchProc(hDlg, (HWND)lParam, false);
break;
case UM_EDIT_KILL_FOCUS:
SendMessage((HWND)lParam, EM_GETSEL, (WPARAM)&nTextSelStart, (LPARAM)&nTextSelEnd);
break;
case WM_CLOSE:
//if (ghWnd == NULL)
gpConEmu->OnOurDialogClosed();
if (mp_DpiAware)
mp_DpiAware->Detach();
EndDialog(hDlg, IDOK);
SafeDelete(mp_ImgBtn);
break;
case WM_DESTROY:
mh_AboutDlg = NULL;
break;
default:
if (mp_DpiAware && mp_DpiAware->ProcessDpiMessages(hDlg, messg, wParam, lParam))
{
return TRUE;
}
}
return FALSE;
}
static BOOL CALLBACK IEViewOptDlgProc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam) {
switch (msg) {
case WM_INITDIALOG:
{
HWND tc;
TCITEM tci;
tc = GetDlgItem(hwndDlg, IDC_TABS);
tci.mask = TCIF_TEXT;
tci.pszText = TranslateT("General");
TabCtrl_InsertItem(tc, 0, &tci);
tci.pszText = TranslateT("Message Log");
TabCtrl_InsertItem(tc, 1, &tci);
// tci.pszText = Translate("Emoticons");
// TabCtrl_InsertItem(tc, 2, &tci);
tci.pszText = TranslateT("Group Chats");
TabCtrl_InsertItem(tc, 2, &tci);
tci.pszText = TranslateT("History");
TabCtrl_InsertItem(tc, 3, &tci);
// hwndEmoticons = CreateDialogParam(hInstance, MAKEINTRESOURCE(IDD_EMOTICONS_OPTIONS), hwndDlg, IEViewEmoticonsOptDlgProc, (LPARAM) NULL);
// SetWindowPos(hwndEmoticons, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW);
hwndPages[0] = CreateDialogParam(hInstance, MAKEINTRESOURCE(IDD_GENERAL_OPTIONS), hwndDlg, IEViewGeneralOptDlgProc, (LPARAM) NULL);
SetWindowPos(hwndPages[0], HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW);
hwndPages[1] = CreateDialogParam(hInstance, MAKEINTRESOURCE(IDD_SRMM_OPTIONS), hwndDlg, IEViewTemplatesOptDlgProc, (LPARAM) NULL);
SetWindowPos(hwndPages[1], HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW);
hwndPages[2] = CreateDialogParam(hInstance, MAKEINTRESOURCE(IDD_GROUPCHATS_OPTIONS), hwndDlg, IEViewGroupChatsOptDlgProc, (LPARAM) NULL);
SetWindowPos(hwndPages[2], HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW);
hwndPages[3] = CreateDialogParam(hInstance, MAKEINTRESOURCE(IDD_HISTORY_OPTIONS), hwndDlg, IEViewGroupChatsOptDlgProc, (LPARAM) NULL);
SetWindowPos(hwndPages[3], HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_HIDEWINDOW);
hwndCurrentTab = hwndPages[0];
ShowWindow(hwndPages[0], SW_SHOW);
return TRUE;
}
case WM_COMMAND:
break;
case WM_NOTIFY:
{
switch (((LPNMHDR) lParam)->code) {
case TCN_SELCHANGE:
switch (wParam) {
case IDC_TABS:
{
HWND hwnd = hwndPages[TabCtrl_GetCurSel(GetDlgItem(hwndDlg, IDC_TABS))];
if (hwnd!=hwndCurrentTab) {
ShowWindow(hwnd, SW_SHOW);
ShowWindow(hwndCurrentTab, SW_HIDE);
hwndCurrentTab = hwnd;
}
}
break;
}
break;
case PSN_APPLY:
for (int i = 0; i < 4; i++) {
SendMessage(hwndPages[i], WM_NOTIFY, wParam, lParam);
}
NotifyEventHooks(hHookOptionsChanged, 0, 0);
return TRUE;
}
}
break;
case WM_DESTROY:
break;
}
return FALSE;
}
static LRESULT CALLBACK SubclassProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
int ctrl;
switch (msg) {
case WM_KEYDOWN:
ctrl = GetKeyState(VK_CONTROL) & 0x8000;
if ( wParam == VK_DELETE && !ctrl) {
SendMessage(GetParent(hwnd), WM_COMMAND, IDC_DELETE, 0);
break;
}
if (wParam == VK_LEFT && ctrl)
{
NMHDR nmhdr = {0};
int tab = TabCtrl_GetCurSel(hTabs);
if (tab == 0)
tab = TabCtrl_GetItemCount(hTabs)-1;
else
tab--;
TabCtrl_SetCurSel(hTabs, tab);
nmhdr.code = TCN_SELCHANGE;
SendMessage(hwndConsole, WM_NOTIFY, IDC_TABS, (LPARAM)&nmhdr);
break;
}
if (wParam == VK_RIGHT && ctrl)
{
NMHDR nmhdr = {0};
int tab = TabCtrl_GetCurSel(hTabs);
int count = TabCtrl_GetItemCount(hTabs);
tab = (tab + 1) % count;
TabCtrl_SetCurSel(hTabs, tab);
nmhdr.code = TCN_SELCHANGE;
SendMessage(hwndConsole, WM_NOTIFY, IDC_TABS, (LPARAM)&nmhdr);
break;
}
break;
case WM_CHAR:
// CTRL
if ( !(GetKeyState(VK_CONTROL)&0x8000))
break;
switch(wParam) {
case 1: // Ctrl+A
if ( ListView_GetSelectedCount(hwnd) != (UINT)ListView_GetItemCount(hwnd))
ListView_SetItemState(hwnd, -1, LVIS_SELECTED, LVIS_SELECTED);
return 0;
case 3: // Ctrl+D
SendMessage(GetParent(hwnd), WM_COMMAND, IDC_COPY, 0);
return 0;
case 15: // Ctrl+O
SendMessage(GetParent(hwnd), WM_COMMAND, IDC_OPTIONS, 0);
return 0;
case 16: // Ctrl+P
SendMessage(GetParent(hwnd), WM_COMMAND, IDC_PAUSE, 0);
return 0;
case 17: // Ctrl+Q
SendMessage(GetParent(hwnd), WM_COMMAND, IDC_SCROLL, 0);
return 0;
case 19: // Ctrl+S
SendMessage(GetParent(hwnd), WM_COMMAND, IDC_SAVE, 0);
return 0;
case 23: // Ctrl+W
SendMessage(GetParent(hwnd), WM_COMMAND, IDC_CLOSE, 0);
return 0;
}
break;
}
return mir_callNextSubclass(hwnd, SubclassProc, msg, wParam, lParam);
}
BOOL CALLBACK DlgProcParentWindow(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
DWORD ws;
struct ParentWindowData *dat;
dat = (struct ParentWindowData *) GetWindowLong(hwndDlg, GWL_USERDATA);
if (!dat && msg!=WM_INITDIALOG) return FALSE;
switch (msg) {
case WM_INITDIALOG:
{
struct NewMessageWindowLParam *newData = (struct NewMessageWindowLParam *) lParam;
dat = (struct ParentWindowData *) malloc(sizeof(struct ParentWindowData));
dat->hContact = newData->hContact;
dat->nFlash = 0;
dat->nFlashMax = DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_FLASHCOUNT, SRMSGDEFSET_FLASHCOUNT);
dat->childrenCount = 0;
dat->children = NULL;
dat->hwnd = hwndDlg;
dat->flags = g_dat->flags;// | SMF_SHOWTITLEBAR;
dat->mouseLBDown = 0;
dat->windowWasCascaded = 0;
dat->hwndStatus = CreateWindowEx(0, STATUSCLASSNAME, NULL, WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP, 0, 0, 0, 0, hwndDlg, NULL, g_hInst, NULL);
{
int statwidths[4];
RECT rc;
SendMessage(dat->hwndStatus, SB_SETMINHEIGHT, GetSystemMetrics(SM_CYSMICON), 0);
GetWindowRect(dat->hwndStatus, &rc);
/*
statwidths[0] = rc.right - rc.left - SB_CHAR_WIDTH - SB_TYPING_WIDTH - SB_SENDING_WIDTH;
statwidths[1] = rc.right - rc.left - SB_TYPING_WIDTH - SB_SENDING_WIDTH; //rc.right - rc.left - SB_CHAR_WIDTH;
statwidths[2] = rc.right - rc.left - SB_TYPING_WIDTH; //rc.right - rc.left - SB_CHAR_WIDTH;
statwidths[3] = -1;
SendMessage(dat->hwndStatus, SB_SETPARTS, 4, (LPARAM) statwidths);
*/
statwidths[0] = rc.right - rc.left - SB_CHAR_WIDTH - SB_TYPING_WIDTH;
statwidths[1] = rc.right - rc.left - SB_TYPING_WIDTH;
statwidths[2] = -1;
SendMessage(dat->hwndStatus, SB_SETPARTS, 3, (LPARAM) statwidths);
}
dat->hwndTabs = GetDlgItem(hwndDlg, IDC_TABS);
dat->hwndActive = NULL;
SetWindowLong(hwndDlg, GWL_USERDATA, (LONG) dat);
if (g_dat->hIconList != NULL) {
TabCtrl_SetImageList(dat->hwndTabs, g_dat->hIconList);
}
WindowList_Add(g_dat->hParentWindowList, hwndDlg, 0);
dat->tabCtrlDat = (struct TabCtrlData *) malloc(sizeof(struct TabCtrlData));
dat->tabCtrlDat->bDragging = FALSE;
SetWindowLong(dat->hwndTabs, GWL_USERDATA, (LONG) dat->tabCtrlDat);
OldTabCtrlProc = (WNDPROC) SetWindowLong(dat->hwndTabs, GWL_WNDPROC, (LONG) TabCtrlProc);
ws = GetWindowLong(dat->hwndTabs, GWL_STYLE) & ~(TCS_BOTTOM);
if (dat->flags & SMF_TABSATBOTTOM) {
ws |= TCS_BOTTOM;
}
SetWindowLong(dat->hwndTabs, GWL_STYLE, ws);
ws = GetWindowLong(hwndDlg, GWL_STYLE) & ~(WS_CAPTION);
if (dat->flags & SMF_SHOWTITLEBAR) {
ws |= WS_CAPTION;
SetWindowLong(hwndDlg, GWL_STYLE, ws);
} else {
RECT rc;
SetWindowLong(hwndDlg, GWL_STYLE, ws);
GetWindowRect(hwndDlg, &rc);
SetWindowPos(hwndDlg, 0, 0, 0, rc.right - rc.left, rc.bottom - rc.top,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSENDCHANGING);
}
ws = GetWindowLong(hwndDlg, GWL_EXSTYLE) & ~WS_EX_LAYERED;
ws |= dat->flags & SMF_USETRANSPARENCY ? WS_EX_LAYERED : 0;
SetWindowLong(hwndDlg , GWL_EXSTYLE , ws);
if (dat->flags & SMF_USETRANSPARENCY) {
pSetLayeredWindowAttributes(hwndDlg, RGB(255,255,255), (BYTE)(255-g_dat->inactiveAlpha), LWA_ALPHA);
// RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
}
//SetWindowPos(dat->hwndTabs, 0, 0, -10, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
if (!(dat->flags & SMF_SHOWSTATUSBAR)) {
ShowWindow(dat->hwndStatus, SW_HIDE);
}
if (dat->flags & SMF_USETABS) {
if (ScriverRestoreWindowPosition(hwndDlg, NULL, SRMMMOD, "", 0, SW_HIDE)) {
SetWindowPos(hwndDlg, 0, 0, 0, 450, 300, SWP_NOZORDER | SWP_NOMOVE | SWP_HIDEWINDOW);
}
} else {
int savePerContact = DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_SAVEPERCONTACT, SRMSGDEFSET_SAVEPERCONTACT);
if (ScriverRestoreWindowPosition(hwndDlg, savePerContact ? dat->hContact : NULL, SRMMMOD, "", 0, SW_HIDE)) {
//if (Utils_RestoreWindowPosition(GetParent(hwndDlg), savePerContact ? dat->hContact : NULL, SRMMMOD, "")) {
if (savePerContact) {
if (ScriverRestoreWindowPosition(hwndDlg, NULL, SRMMMOD, "", RWPF_NOSIZE, SW_HIDE))
// if (Utils_RestoreWindowPositionNoMove(GetParent(hwndDlg), NULL, SRMMMOD, ""))
SetWindowPos(GetParent(hwndDlg), 0, 0, 0, 450, 300, SWP_NOZORDER | SWP_NOMOVE);
}
else
SetWindowPos(hwndDlg, 0, 0, 0, 450, 300, SWP_NOZORDER | SWP_NOMOVE);
}
if (!savePerContact && DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_CASCADE, SRMSGDEFSET_CASCADE))
WindowList_Broadcast(g_dat->hParentWindowList, DM_CASCADENEWWINDOW, (WPARAM) hwndDlg, (LPARAM) & dat->windowWasCascaded);
}
}
return TRUE;
case WM_GETMINMAXINFO:
{
MINMAXINFO *mmi = (MINMAXINFO *) lParam;
SIZE size;
GetMinimunWindowSize(dat, &size);
mmi->ptMinTrackSize.x = size.cx;
mmi->ptMinTrackSize.y = size.cy;
return FALSE;
}
case WM_SIZE:
if (wParam == SIZE_MINIMIZED) {
dat->bMinimized = 1;
}
if (IsIconic(hwndDlg)) {
MoveWindow(dat->hwndActive, dat->childRect.left, dat->childRect.top, dat->childRect.right-dat->childRect.left, dat->childRect.bottom - dat->childRect.top, TRUE);
} else {
// }
// if (!IsIconic(hwndDlg)) {
int i;
RECT rc, rcStatus, rcChild, rcWindow;
SIZE size;
dat->bMinimized = 0;
GetClientRect(hwndDlg, &rc);
GetWindowRect(hwndDlg, &rcWindow);
rcStatus.top = rcStatus.bottom = 0;
if (dat->flags & SMF_SHOWSTATUSBAR) {
int statwidths[4];
GetWindowRect(dat->hwndStatus, &rcStatus);
statwidths[0] = rc.right - rc.left - SB_CHAR_WIDTH - SB_TYPING_WIDTH;
statwidths[1] = rc.right - rc.left - SB_TYPING_WIDTH;
statwidths[2] = -1;
SendMessage(dat->hwndStatus, SB_SETPARTS, 3, (LPARAM) statwidths);
SendMessage(dat->hwndStatus, WM_SIZE, 0, 0);
}
MoveWindow(dat->hwndTabs, 0, 2, (rc.right - rc.left), (rc.bottom - rc.top) - (rcStatus.bottom - rcStatus.top) - 2, FALSE);
RedrawWindow(dat->hwndTabs, NULL, NULL, RDW_INVALIDATE | RDW_FRAME | RDW_ERASE);
GetMinimunWindowSize(dat, &size);
if ((rcWindow.bottom-rcWindow.top) < size.cy || (rcWindow.right-rcWindow.left) < size.cx) {
if ((rcWindow.bottom-rcWindow.top) < size.cy) {
rcWindow.bottom = rcWindow.top + size.cy;
}
if ((rcWindow.right-rcWindow.left) < size.cx) {
rcWindow.right = rcWindow.left + size.cx;
}
MoveWindow(hwndDlg, rcWindow.left, rcWindow.top, rcWindow.right - rcWindow.left, rcWindow.bottom - rcWindow.top, TRUE);
}
GetChildWindowRect(dat, &rcChild);
memcpy(&dat->childRect, &rcChild, sizeof(RECT));
for (i=0;i<dat->childrenCount;i++) {
if (dat->children[i] == dat->hwndActive) {
MoveWindow(dat->children[i], rcChild.left, rcChild.top, rcChild.right-rcChild.left, rcChild.bottom - rcChild.top, TRUE);
RedrawWindow(GetDlgItem(dat->children[i], IDC_LOG), NULL, NULL, RDW_INVALIDATE);
}
}
if (dat->flags & SMF_SHOWSTATUSBAR) {
RedrawWindow(dat->hwndStatus, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE);
}
}
return FALSE;
case WM_SETFOCUS:
SetFocus(dat->hwndActive);
return TRUE;
case WM_CLOSE:
DestroyWindow(hwndDlg);
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDCANCEL:
//DestroyWindow(hwndDlg);
return TRUE;
}
case WM_NOTIFY:
{
NMHDR* pNMHDR = (NMHDR*) lParam;
if (pNMHDR->hwndFrom == dat->hwndTabs) {
switch (pNMHDR->code) {
case TCN_SELCHANGE:
{
TCITEM tci = {0};
int iSel = TabCtrl_GetCurSel(dat->hwndTabs);
tci.mask = TCIF_PARAM;
if (TabCtrl_GetItem(dat->hwndTabs, iSel, &tci)) {
struct MessageWindowData * mdat = (struct MessageWindowData *) tci.lParam;
ActivateChild(dat, mdat->hwnd);
}
}
break;
case NM_RCLICK:
{
TCHITTESTINFO thinfo;
int tabId, x, y;
GetCursorPos(&thinfo.pt);
x = thinfo.pt.x;
y = thinfo.pt.y;
ScreenToClient(dat->hwndTabs, &thinfo.pt);
tabId = TabCtrl_HitTest(dat->hwndTabs, &thinfo);
if (tabId != -1) {
struct MessageWindowData * mwd = GetChildFromTab(dat->hwndTabs, tabId);
//CallService(MS_USERINFO_SHOWDIALOG, (WPARAM) mwd->hContact, 0);
HMENU hMenu = (HMENU) CallService(MS_CLIST_MENUBUILDCONTACT, (WPARAM) mwd->hContact, 0);
TrackPopupMenu(hMenu, 0, x, y, 0, mwd->hwnd, NULL);
DestroyMenu(hMenu);
}
}
break;
}
} else if (pNMHDR->hwndFrom == dat->hwndStatus) {
switch (pNMHDR->code) {
case NM_CLICK:
{
NMMOUSE *nm=(NMMOUSE*)lParam;
RECT rc;
SendMessage(dat->hwndStatus, SB_GETRECT, SendMessage(dat->hwndStatus, SB_GETPARTS, 0, 0) - 1, (LPARAM)&rc);
if (nm->pt.x >= rc.left)
SendMessage(dat->hwndActive, DM_SWITCHUNICODE, 0, 0);
}
}
break;
}
}
break;
case WM_DROPFILES:
SendMessage(dat->hwndActive, WM_DROPFILES, wParam, lParam);
break;
case WM_TIMER:
if (wParam == TIMERID_FLASHWND) {
if ((dat->nFlash > dat->nFlashMax)) {// || ((GetActiveWindow() == hwndDlg) && (GetForegroundWindow() == hwndDlg))) {
KillTimer(hwndDlg, TIMERID_FLASHWND);
FlashWindow(hwndDlg, FALSE);
} else if (dat->nFlash < dat->nFlashMax) {
FlashWindow(hwndDlg, TRUE);
dat->nFlash++;
}
}
break;
case WM_CONTEXTMENU:
{
if (dat->hwndStatus && dat->hwndStatus == (HWND) wParam) {
RECT rc;
POINT pt, pt2;
GetCursorPos(&pt);
pt2.x = pt.x;
pt2.y = pt.y;
ScreenToClient(dat->hwndStatus, &pt);
SendMessage(dat->hwndStatus, SB_GETRECT, SendMessage(dat->hwndStatus, SB_GETPARTS, 0, 0) - 1, (LPARAM)&rc);
if (pt.x >= rc.left && dat->hwndActive != NULL) {
int codePage = (int) SendMessage(dat->hwndActive, DM_GETCODEPAGE, 0, 0);
int i, iSel;
for(i = 0; i < GetMenuItemCount(g_dat->hMenuANSIEncoding); i++) {
CheckMenuItem (g_dat->hMenuANSIEncoding, i, MF_BYPOSITION | MF_UNCHECKED);
}
if(codePage == CP_ACP) {
CheckMenuItem(g_dat->hMenuANSIEncoding, 0, MF_BYPOSITION | MF_CHECKED);
} else {
CheckMenuItem(g_dat->hMenuANSIEncoding, codePage, MF_BYCOMMAND | MF_CHECKED);
}
iSel = TrackPopupMenu(g_dat->hMenuANSIEncoding, TPM_RETURNCMD, pt2.x, pt2.y, 0, hwndDlg, NULL);
if (iSel >= 500) {
if (iSel == 500) iSel = CP_ACP;
SendMessage(dat->hwndActive, DM_SETCODEPAGE, 0, iSel);
}
}
else
SendMessage(dat->hwndActive, WM_CONTEXTMENU, (WPARAM)hwndDlg, 0);
}
break;
}
case WM_ACTIVATE:
if (LOWORD(wParam) == WA_INACTIVE) {
ws = GetWindowLong(hwndDlg, GWL_EXSTYLE) & ~WS_EX_LAYERED;
ws |= dat->flags & SMF_USETRANSPARENCY ? WS_EX_LAYERED : 0;
SetWindowLong(hwndDlg , GWL_EXSTYLE , ws);
if (dat->flags & SMF_USETRANSPARENCY) {
pSetLayeredWindowAttributes(hwndDlg, RGB(255,255,255), (BYTE)(255-g_dat->inactiveAlpha), LWA_ALPHA);
// RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
}
}
if (LOWORD(wParam) != WA_ACTIVE)
break;
case WM_MOUSEACTIVATE:
if (KillTimer(hwndDlg, TIMERID_FLASHWND)) {
FlashWindow(hwndDlg, FALSE);
dat->nFlash = 0;
}
ws = GetWindowLong(hwndDlg, GWL_EXSTYLE) & ~WS_EX_LAYERED;
ws |= dat->flags & SMF_USETRANSPARENCY ? WS_EX_LAYERED : 0;
SetWindowLong(hwndDlg , GWL_EXSTYLE , ws);
if (dat->flags & SMF_USETRANSPARENCY) {
pSetLayeredWindowAttributes(hwndDlg, RGB(255,255,255), (BYTE)(255-g_dat->activeAlpha), LWA_ALPHA);
// RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
}
SendMessage(dat->hwndActive, WM_ACTIVATE, WA_ACTIVE, 0);
break;
case WM_LBUTTONDOWN:
dat->mouseLBDown = 1;
GetCursorPos(&dat->mouseLBDownPos);
SetCapture(hwndDlg);
break;
case WM_LBUTTONUP:
dat->mouseLBDown = 0;
ReleaseCapture();
break;
case WM_MOUSEMOVE:
if (dat->mouseLBDown) {
POINT pt;
RECT rc;
GetCursorPos(&pt);
GetWindowRect(hwndDlg, &rc);
SetWindowPos(hwndDlg, 0, rc.left - (dat->mouseLBDownPos.x - pt.x), rc.top - (dat->mouseLBDownPos.y - pt.y), 0, 0, SWP_NOZORDER | SWP_NOSIZE);
dat->mouseLBDownPos = pt;
}
break;
case WM_DESTROY:
{
g_dat->hParent = NULL;
SetWindowLong(hwndDlg, GWL_USERDATA, 0);
WindowList_Remove(g_dat->hParentWindowList, hwndDlg);
if (dat->children!=NULL) free (dat->children);
free(dat->tabCtrlDat);
free(dat);
if (dat->flags & SMF_USETABS) {
WINDOWPLACEMENT wp = { 0 };
wp.length = sizeof(wp);
GetWindowPlacement(hwndDlg, &wp);
DBWriteContactSettingDword(NULL, SRMMMOD, "x", wp.rcNormalPosition.left);
DBWriteContactSettingDword(NULL, SRMMMOD, "y", wp.rcNormalPosition.top);
DBWriteContactSettingDword(NULL, SRMMMOD, "width", wp.rcNormalPosition.right - wp.rcNormalPosition.left);
DBWriteContactSettingDword(NULL, SRMMMOD, "height", wp.rcNormalPosition.bottom - wp.rcNormalPosition.top);
} else {
WINDOWPLACEMENT wp = { 0 };
HANDLE hContact;
if (DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_SAVEPERCONTACT, SRMSGDEFSET_SAVEPERCONTACT))
hContact = dat->hContact;
else
hContact = NULL;
wp.length = sizeof(wp);
GetWindowPlacement(hwndDlg, &wp);
if (!dat->windowWasCascaded) {
DBWriteContactSettingDword(hContact, SRMMMOD, "x", wp.rcNormalPosition.left);
DBWriteContactSettingDword(hContact, SRMMMOD, "y", wp.rcNormalPosition.top);
}
DBWriteContactSettingDword(hContact, SRMMMOD, "width", wp.rcNormalPosition.right - wp.rcNormalPosition.left);
DBWriteContactSettingDword(hContact, SRMMMOD, "height", wp.rcNormalPosition.bottom - wp.rcNormalPosition.top);
}
}
break;
case DM_ERRORDECIDED:
break;
case DM_STARTFLASHING:
if (GetActiveWindow() != hwndDlg || GetForegroundWindow() != hwndDlg) {
dat->nFlash = 0;
SetTimer(hwndDlg, TIMERID_FLASHWND, TIMEOUT_FLASHWND, NULL);
}
break;
case DM_REMOVECHILD:
{
RemoveChild(dat, (HWND) lParam);
if (dat->childrenCount == 0) {
DestroyWindow(hwndDlg);
} else {
}
}
return TRUE;
case DM_ADDCHILD:
{
struct MessageWindowData * mdat = (struct MessageWindowData *) lParam;
AddChild(dat, mdat);
}
return TRUE;
case DM_ACTIVATECHILD:
if((HWND) lParam != dat->hwndActive) {
ActivateChild(dat, (HWND) lParam);
}
return TRUE;
case DM_ACTIVATEPREV:
ActivatePrevChild(dat, (HWND) lParam);
return TRUE;
case DM_ACTIVATENEXT:
ActivateNextChild(dat, (HWND) lParam);
return TRUE;
case DM_SENDMESSAGE:
{
int i;
for (i=0;i<dat->childrenCount;i++) {
SendMessage(dat->children[i], DM_SENDMESSAGE, wParam, lParam);
}
}
break;
case DM_OPTIONSAPPLIED:
{
RECT rc;
dat->flags = g_dat->flags;
if (!(dat->flags & SMF_SHOWSTATUSBAR)) {
ShowWindow(dat->hwndStatus, SW_HIDE);
} else {
ShowWindow(dat->hwndStatus, SW_SHOW);
}
ws = GetWindowLong(hwndDlg, GWL_STYLE) & ~(WS_CAPTION);
if (dat->flags & SMF_SHOWTITLEBAR) {
ws |= WS_CAPTION;
}
SetWindowLong(hwndDlg, GWL_STYLE, ws);
ws = GetWindowLong(hwndDlg, GWL_EXSTYLE)& ~WS_EX_LAYERED;
ws |= dat->flags & SMF_USETRANSPARENCY ? WS_EX_LAYERED : 0;
SetWindowLong(hwndDlg , GWL_EXSTYLE , ws);
if (dat->flags & SMF_USETRANSPARENCY) {
pSetLayeredWindowAttributes(hwndDlg, RGB(255,255,255), (BYTE)(255-g_dat->inactiveAlpha), LWA_ALPHA);
// RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
}
ws = GetWindowLong(dat->hwndTabs, GWL_STYLE) & ~(TCS_BOTTOM);
if (dat->flags & SMF_TABSATBOTTOM) {
ws |= TCS_BOTTOM;
}
SetWindowLong(dat->hwndTabs, GWL_STYLE, ws);
RedrawWindow(dat->hwndTabs, NULL, NULL, RDW_INVALIDATE);
GetWindowRect(hwndDlg, &rc);
SetWindowPos(hwndDlg, 0, 0, 0, rc.right - rc.left, rc.bottom - rc.top,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSENDCHANGING);
SendMessage(hwndDlg, WM_SIZE, 0, 0);
//RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_INVALIDATE | RDW_FRAME | RDW_ALLCHILDREN);
break;
}
case DM_UPDATETITLE:
{
struct MessageWindowData * mdat = (struct MessageWindowData *) lParam;
TCITEM tci;
int tabId;
char newtitle[256], oldtitle[256];
char *szStatus, *contactName, *pszNewTitleEnd;
TCHAR *tContactName;
if (mdat && mdat->hwnd == dat->hwndActive) {
pszNewTitleEnd = "Message Session";
if (mdat->hContact) {
if (mdat->szProto) {
CONTACTINFO ci;
char buf[128];
int statusIcon = DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_STATUSICON, SRMSGDEFSET_STATUSICON);
buf[0] = 0;
mdat->wStatus = DBGetContactSettingWord(mdat->hContact, mdat->szProto, "Status", ID_STATUS_OFFLINE);
contactName = (char *) CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM) mdat->hContact, 0);
ZeroMemory(&ci, sizeof(ci));
ci.cbSize = sizeof(ci);
ci.hContact = mdat->hContact;
ci.szProto = mdat->szProto;
ci.dwFlag = CNF_UNIQUEID;
if (!CallService(MS_CONTACT_GETCONTACTINFO, 0, (LPARAM) & ci)) {
switch (ci.type) {
case CNFT_ASCIIZ:
mir_snprintf(buf, sizeof(buf), "%s", ci.pszVal);
miranda_sys_free(ci.pszVal);
break;
case CNFT_DWORD:
mir_snprintf(buf, sizeof(buf), "%u", ci.dVal);
break;
}
}
szStatus = (char *) CallService(MS_CLIST_GETSTATUSMODEDESCRIPTION, mdat->szProto == NULL ? ID_STATUS_OFFLINE : DBGetContactSettingWord(mdat->hContact, mdat->szProto, "Status", ID_STATUS_OFFLINE), 0);
if (statusIcon)
mir_snprintf(newtitle, sizeof(newtitle), "%s - %s", contactName, Translate(pszNewTitleEnd));
else
mir_snprintf(newtitle, sizeof(newtitle), "%s (%s): %s", contactName, szStatus, Translate(pszNewTitleEnd));
}
}
else
lstrcpynA(newtitle, pszNewTitleEnd, sizeof(newtitle));
GetWindowTextA(hwndDlg, oldtitle, sizeof(oldtitle));
if (lstrcmpA(newtitle, oldtitle)) { //swt() flickers even if the title hasn't actually changed
SetWindowTextA(hwndDlg, newtitle);
//SendMessage(hwndDlg, WM_SIZE, 0, 0);
}
}
tabId = GetTabFromHWND(dat, mdat->hwnd);
tContactName = GetTabName(mdat->hContact);
tci.mask = TCIF_TEXT;
tci.pszText = tContactName;
TabCtrl_SetItem(dat->hwndTabs, tabId, &tci);
free(tContactName);
break;
}
case DM_UPDATEWINICON:
{
struct MessageWindowData * mdat = (struct MessageWindowData *) lParam;
if (mdat) {
if (mdat->szProto) {
int i, icoIdx = 0;
WORD wStatus;
wStatus = DBGetContactSettingWord(mdat->hContact, mdat->szProto, "Status", ID_STATUS_OFFLINE);
if (mdat->hwnd == dat->hwndActive) {
if (DBGetContactSettingByte(NULL, SRMMMOD, SRMSGSET_STATUSICON, SRMSGDEFSET_STATUSICON)) {
if (mdat->showTyping && (dat->flags&SMF_SHOWTYPINGWIN)) {
SendMessage(hwndDlg, WM_SETICON, (WPARAM) ICON_BIG, (LPARAM) g_dat->hIcons[SMF_ICON_TYPING]);
} else if (mdat->showUnread && (GetActiveWindow() != hwndDlg || GetForegroundWindow() != hwndDlg)) {
SendMessage(hwndDlg, WM_SETICON, (WPARAM) ICON_BIG, (LPARAM) LoadSkinnedIcon(SKINICON_EVENT_MESSAGE));
} else {
SendMessage(hwndDlg, WM_SETICON, (WPARAM) ICON_BIG, (LPARAM) LoadSkinnedProtoIcon(mdat->szProto, wStatus));
}
} else {
SendMessage(hwndDlg, WM_SETICON, (WPARAM) ICON_BIG, (LPARAM) LoadSkinnedIcon(SKINICON_EVENT_MESSAGE));
}
}
icoIdx = 0;
for (i = 0; i < g_dat->protoNum; i++) {
if (!strcmp(g_dat->protoNames[i], mdat->szProto)) {
icoIdx = wStatus - ID_STATUS_OFFLINE + (ID_STATUS_OUTTOLUNCH - ID_STATUS_OFFLINE + 1) * (i +1) + 2;
break;
}
}
if (mdat->hwnd != dat->hwndActive) {
if (mdat->showTyping) {
icoIdx = 1;
} else if (mdat->showUnread & 1) {
icoIdx = 0;
}
}
i = GetTabFromHWND(dat, mdat->hwnd);
if (i>=0) {
TCITEM tci;
tci.mask = TCIF_IMAGE;
tci.iImage = icoIdx;
TabCtrl_SetItem(dat->hwndTabs, i, &tci);
}
}
}
break;
}
case DM_UPDATESTATUSBAR:
break;
case DM_SWITCHSTATUSBAR:
dat->flags ^= SMF_SHOWSTATUSBAR;
if (!(dat->flags & SMF_SHOWSTATUSBAR)) {
ShowWindow(dat->hwndStatus, SW_HIDE);
} else {
ShowWindow(dat->hwndStatus, SW_SHOW);
}
SendMessage(hwndDlg, WM_SIZE, 0, 0);
break;
case DM_SWITCHTOOLBAR:
{
int i;
dat->flags ^= SMF_SHOWBTNS;
for (i=0;i<dat->childrenCount;i++) {
SendMessage(dat->children[i], DM_SWITCHTOOLBAR, 0, 0);
}
SendMessage(hwndDlg, WM_SIZE, 0, 0);
}
break;
case DM_SWITCHTITLEBAR:
{
RECT rc;
dat->flags ^= SMF_SHOWTITLEBAR;
ws = GetWindowLong(hwndDlg, GWL_STYLE) & ~(WS_CAPTION);
if (dat->flags & SMF_SHOWTITLEBAR) {
ws |= WS_CAPTION;
}
SetWindowLong(hwndDlg, GWL_STYLE, ws);
GetWindowRect(hwndDlg, &rc);
SetWindowPos(hwndDlg, 0, 0, 0, rc.right - rc.left, rc.bottom - rc.top,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOSENDCHANGING);
// SendMessage(hwndDlg, WM_SIZE, 0, 0);
RedrawWindow(hwndDlg, NULL, NULL, RDW_ERASE | RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
}
break;
case DM_CASCADENEWWINDOW:
if ((HWND) wParam == hwndDlg)
break;
{
RECT rcThis, rcNew;
GetWindowRect(hwndDlg, &rcThis);
GetWindowRect((HWND) wParam, &rcNew);
if (abs(rcThis.left - rcNew.left) < 3 && abs(rcThis.top - rcNew.top) < 3) {
int offset = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFRAME);
SetWindowPos((HWND) wParam, 0, rcNew.left + offset, rcNew.top + offset, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
*(int *) lParam = 1;
}
}
break;
//case DM_MESSAGESENDING:
// dat->messagesInProgress += wParam ? -1 : 1;
// if (dat->messagesInProgress < 0) dat->messagesInProgress = 0;
// break;
}
return FALSE;
}
static INT_PTR CALLBACK FtMgrDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
struct TFtMgrData *dat = (struct TFtMgrData *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
switch (msg) {
case WM_INITDIALOG:
{
TCITEM tci = {0};
HWND hwndTab = GetDlgItem(hwnd, IDC_TABS);
TranslateDialogDefault(hwnd);
Window_SetIcon_IcoLib(hwnd, SKINICON_EVENT_FILE);
dat = (struct TFtMgrData *)mir_calloc(sizeof(struct TFtMgrData));
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)dat);
dat->hhkPreshutdown = HookEventMessage(ME_SYSTEM_PRESHUTDOWN, hwnd, M_PRESHUTDOWN);
dat->hwndIncoming = CreateDialog(hInst, MAKEINTRESOURCE(IDD_FTPAGE), hwnd, FtMgrPageDlgProc);
dat->hwndOutgoing = CreateDialog(hInst, MAKEINTRESOURCE(IDD_FTPAGE), hwnd, FtMgrPageDlgProc);
ShowWindow(dat->hwndIncoming, SW_SHOW);
tci.mask = TCIF_PARAM|TCIF_TEXT;
tci.pszText = TranslateT("Incoming");
tci.lParam = (LPARAM)dat->hwndIncoming;
TabCtrl_InsertItem(hwndTab, 0, &tci);
tci.pszText = TranslateT("Outgoing");
tci.lParam = (LPARAM)dat->hwndOutgoing;
TabCtrl_InsertItem(hwndTab, 1, &tci);
// Utils_RestoreWindowPosition(hwnd, NULL, "SRFile", "FtMgrDlg_");
SAVEWINDOWPOS swp;
swp.hwnd = hwnd; swp.hContact = NULL; swp.szModule = "SRFile"; swp.szNamePrefix = "FtMgrDlg_";
CallService(MS_UTILS_RESTOREWINDOWPOSITION, RWPF_NOACTIVATE, (LPARAM)&swp);
// Fall through to setup initial placement
}
case WM_SIZE:
{
RECT rc, rcButton;
HDWP hdwp;
HWND hwndTab = GetDlgItem(hwnd, IDC_TABS);
GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rcButton);
OffsetRect(&rcButton, -rcButton.left, -rcButton.top);
GetClientRect(hwnd, &rc);
InflateRect(&rc, -6, -6);
hdwp = BeginDeferWindowPos(3);
hdwp = DeferWindowPos(hdwp, GetDlgItem(hwnd, IDC_CLEAR), NULL, rc.left, rc.bottom-rcButton.bottom, 0, 0, SWP_NOZORDER|SWP_NOSIZE);
hdwp = DeferWindowPos(hdwp, GetDlgItem(hwnd, IDCANCEL), NULL, rc.right-rcButton.right, rc.bottom-rcButton.bottom, 0, 0, SWP_NOZORDER|SWP_NOSIZE);
rc.bottom -= rcButton.bottom + 5;
hdwp = DeferWindowPos(hdwp, hwndTab, NULL, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, SWP_NOZORDER);
EndDeferWindowPos(hdwp);
GetWindowRect(hwndTab, &rc);
MapWindowPoints(NULL, hwnd, (LPPOINT)&rc, 2);
TabCtrl_AdjustRect(hwndTab, FALSE, &rc);
InflateRect(&rc, -5, -5);
hdwp = BeginDeferWindowPos(2);
hdwp = DeferWindowPos(hdwp, dat->hwndIncoming, HWND_TOP, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, 0);
hdwp = DeferWindowPos(hdwp, dat->hwndOutgoing, HWND_TOP, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, 0);
EndDeferWindowPos(hdwp);
break;
}
case WM_MOUSEWHEEL:
if (IsWindowVisible(dat->hwndIncoming)) SendMessage(dat->hwndIncoming, msg, wParam, lParam);
if (IsWindowVisible(dat->hwndOutgoing)) SendMessage(dat->hwndOutgoing, msg, wParam, lParam);
break;
case WM_FT_SELECTPAGE:
{
TCITEM tci = {0};
HWND hwndTab = GetDlgItem(hwnd, IDC_TABS);
if (TabCtrl_GetCurSel(hwndTab) == (int)wParam) break;
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(hwndTab, TabCtrl_GetCurSel(hwndTab), &tci);
ShowWindow((HWND)tci.lParam, SW_HIDE);
TabCtrl_SetCurSel(hwndTab, wParam);
TabCtrl_GetItem(hwndTab, TabCtrl_GetCurSel(hwndTab), &tci);
ShowWindow((HWND)tci.lParam, SW_SHOW);
}
break;
case WM_GETMINMAXINFO:
{
LPMINMAXINFO lpmmi = (LPMINMAXINFO)lParam;
lpmmi->ptMinTrackSize.x = 300;
lpmmi->ptMinTrackSize.y = 400;
return 0;
}
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDCANCEL:
PostMessage(hwnd, WM_CLOSE , 0, 0);
break;
case IDC_CLEAR:
PostMessage(dat->hwndIncoming, WM_FT_CLEANUP, 0, 0);
PostMessage(dat->hwndOutgoing, WM_FT_CLEANUP, 0, 0);
break;
}
break;
case WM_NOTIFY:
switch (((LPNMHDR)lParam)->idFrom) {
case IDC_TABS:
{
HWND hwndTab = GetDlgItem(hwnd, IDC_TABS);
switch (((LPNMHDR)lParam)->code) {
case TCN_SELCHANGING:
{
TCITEM tci = {0};
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(hwndTab, TabCtrl_GetCurSel(hwndTab), &tci);
ShowWindow((HWND)tci.lParam, SW_HIDE);
break;
}
case TCN_SELCHANGE:
{
TCITEM tci = {0};
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(hwndTab, TabCtrl_GetCurSel(hwndTab), &tci);
ShowWindow((HWND)tci.lParam, SW_SHOW);
break;
}
}
break;
}
}
break;
case M_PRESHUTDOWN:
SendMessage(dat->hwndIncoming, M_PRESHUTDOWN, 0, 0);
SendMessage(dat->hwndOutgoing, M_PRESHUTDOWN, 0, 0);
DestroyWindow(hwnd);
break;
case WM_CLOSE:
ShowWindow(hwnd, SW_HIDE);
if (db_get_b(NULL, "SRFile", "AutoClear", 1)) {
PostMessage(dat->hwndIncoming, WM_FT_CLEANUP, 0, 0);
PostMessage(dat->hwndOutgoing, WM_FT_CLEANUP, 0, 0);
}
return TRUE; /* Disable default IDCANCEL notification */
case WM_DESTROY:
UnhookEvent(dat->hhkPreshutdown);
Window_FreeIcon_IcoLib(hwnd);
DestroyWindow(dat->hwndIncoming);
DestroyWindow(dat->hwndOutgoing);
mir_free(dat);
SetWindowLongPtr(hwnd, GWLP_USERDATA, 0);
Utils_SaveWindowPosition(hwnd, NULL, "SRFile", "FtMgrDlg_");
break;
case WM_ACTIVATE:
dat->errorState = TBPF_NOPROGRESS;
wParam = 1;
break;
case WM_SHOWWINDOW:
if ( !wParam) { // hiding
KillTimer(hwnd, 1);
break;
}
lParam = 0;
case WM_TIMER:
if (pTaskbarInterface) {
SetTimer(hwnd, 1, 400, NULL);
if ((lParam == ACKRESULT_FAILED) || (lParam == ACKRESULT_DENIED))
dat->errorState = TBPF_ERROR;
TFtProgressData prg = {0};
SendMessage(dat->hwndIncoming, M_CALCPROGRESS, (WPARAM)&prg, 0);
SendMessage(dat->hwndOutgoing, M_CALCPROGRESS, (WPARAM)&prg, 0);
if (dat->errorState) {
pTaskbarInterface->SetProgressState(hwnd, dat->errorState);
if ( !prg.run)
pTaskbarInterface->SetProgressValue(hwnd, 1, 1);
}
else if (prg.run)
pTaskbarInterface->SetProgressState(hwnd, TBPF_NORMAL);
else if (prg.init || prg.scan)
pTaskbarInterface->SetProgressState(hwnd, TBPF_INDETERMINATE);
else {
pTaskbarInterface->SetProgressState(hwnd, TBPF_NOPROGRESS);
KillTimer(hwnd, 1);
}
if (prg.run)
pTaskbarInterface->SetProgressValue(hwnd, prg.totalProgress, prg.totalBytes);
}
break;
}
return FALSE;
}
BOOL CALLBACK TabCtrlProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
struct TabCtrlData *dat;
dat = (struct TabCtrlData *) GetWindowLong(hwnd, GWL_USERDATA);
switch(msg) {
case WM_MBUTTONDOWN:
{
TCITEM tci;
int tabId;
struct MessageWindowData *mwd;
TCHITTESTINFO thinfo;
thinfo.pt.x = (lParam<<16)>>16;
thinfo.pt.y = lParam>>16;
tabId = TabCtrl_HitTest(hwnd, &thinfo);
if (tabId >= 0) {
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(hwnd, tabId, &tci);
mwd = (struct MessageWindowData *) tci.lParam;
if (mwd != NULL) {
SendMessage(mwd->hwnd, WM_CLOSE, 0, 0);
}
}
return TRUE;
}
case WM_LBUTTONDBLCLK:
{
TCHITTESTINFO thinfo;
int tabId;
thinfo.pt.x = (lParam<<16)>>16;
thinfo.pt.y = lParam>>16;
tabId = TabCtrl_HitTest(hwnd, &thinfo);
if (tabId >=0 ) {
void * clickChild = GetChildFromTab(hwnd, tabId)->hwnd;
if (clickChild == dat->lastClickChild) {
SendMessage(clickChild, WM_CLOSE, 0, 0);
}
}
dat->lastClickChild = NULL;
}
break;
case WM_LBUTTONDOWN:
{
if (!dat->bDragging) {
TCHITTESTINFO thinfo;
thinfo.pt.x = (lParam<<16)>>16;
thinfo.pt.y = lParam>>16;
dat->srcTab = dat->destTab = TabCtrl_HitTest(hwnd, &thinfo);
if (dat->srcTab >=0 ) {
dat->lastClickChild = GetChildFromTab(hwnd, dat->srcTab)->hwnd;
} else {
dat->lastClickChild = NULL;
}
dat->bDragging = TRUE;
dat->bDragged = FALSE;
dat->mouseLBDownPos.x = thinfo.pt.x;
dat->mouseLBDownPos.y = thinfo.pt.y;
SetCapture(hwnd);
return 0;
}
}
break;
case WM_CAPTURECHANGED:
case WM_LBUTTONUP:
if (dat->bDragging) {
TCHITTESTINFO thinfo;
thinfo.pt.x = (lParam<<16)>>16;
thinfo.pt.y = lParam>>16;
if (dat->bDragged) {
ImageList_DragLeave(GetDesktopWindow());
ImageList_EndDrag();
ImageList_Destroy(dat->hDragImageList);
SetCursor(LoadCursor(NULL, IDC_ARROW));
dat->destTab = TabCtrl_HitTest(hwnd, &thinfo);
if (thinfo.flags != TCHT_NOWHERE && dat->destTab != dat->srcTab) {
NMHDR nmh;
TCHAR sBuffer[501];
TCITEM item;
int curSel;
curSel = TabCtrl_GetCurSel(hwnd);
item.mask = TCIF_IMAGE | TCIF_PARAM | TCIF_TEXT;
item.pszText = sBuffer;
item.cchTextMax = sizeof(sBuffer)/sizeof(TCHAR);
TabCtrl_GetItem(hwnd, dat->srcTab, &item);
sBuffer[sizeof(sBuffer)/sizeof(TCHAR)-1] = '\0';
if (curSel == dat->srcTab) {
curSel = dat->destTab;
} else {
if (curSel > dat->srcTab && curSel <= dat->destTab) {
curSel--;
} else if (curSel < dat->srcTab && curSel >= dat->destTab) {
curSel++;
}
}
TabCtrl_DeleteItem(hwnd, dat->srcTab);
TabCtrl_InsertItem(hwnd, dat->destTab, &item );
TabCtrl_SetCurSel(hwnd, curSel);
nmh.hwndFrom = hwnd;
nmh.idFrom = GetDlgCtrlID(hwnd);
nmh.code = TCN_SELCHANGE;
SendMessage(GetParent(hwnd), WM_NOTIFY, nmh.idFrom, (LPARAM)&nmh);
UpdateWindow(hwnd);
}
} else {
SendMessage(hwnd, WM_LBUTTONDOWN, wParam, lParam);
}
dat->bDragged = FALSE;
dat->bDragging = FALSE;
ReleaseCapture();
}
// Get the selection
int wxTabCtrl::GetSelection() const
{
return (int) TabCtrl_GetCurSel( (HWND) GetHWND() );
}
void TaskManager_OnTabWndSelChange(void)
{
int i;
HMENU hMenu;
HMENU hOptionsMenu;
HMENU hViewMenu;
HMENU hSubMenu;
WCHAR szTemp[256];
SYSTEM_INFO sysInfo;
hMenu = GetMenu(hMainWnd);
hViewMenu = GetSubMenu(hMenu, 2);
hOptionsMenu = GetSubMenu(hMenu, 1);
TaskManagerSettings.ActiveTabPage = TabCtrl_GetCurSel(hTabWnd);
for (i = GetMenuItemCount(hViewMenu) - 1; i > 2; i--) {
hSubMenu = GetSubMenu(hViewMenu, i);
if (hSubMenu)
DestroyMenu(hSubMenu);
RemoveMenu(hViewMenu, i, MF_BYPOSITION);
}
RemoveMenu(hOptionsMenu, 3, MF_BYPOSITION);
if (hWindowMenu)
DestroyMenu(hWindowMenu);
switch (TaskManagerSettings.ActiveTabPage) {
case 0:
ShowWindow(hApplicationPage, SW_SHOW);
ShowWindow(hProcessPage, SW_HIDE);
ShowWindow(hPerformancePage, SW_HIDE);
BringWindowToTop(hApplicationPage);
LoadStringW(hInst, IDS_MENU_LARGEICONS, szTemp, 256);
AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_LARGE, szTemp);
LoadStringW(hInst, IDS_MENU_SMALLICONS, szTemp, 256);
AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_SMALL, szTemp);
LoadStringW(hInst, IDS_MENU_DETAILS, szTemp, 256);
AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_DETAILS, szTemp);
if (GetMenuItemCount(hMenu) <= 5) {
hWindowMenu = LoadMenuW(hInst, MAKEINTRESOURCEW(IDR_WINDOWSMENU));
LoadStringW(hInst, IDS_MENU_WINDOWS, szTemp, 256);
InsertMenuW(hMenu, 3, MF_BYPOSITION|MF_POPUP, (UINT_PTR) hWindowMenu, szTemp);
DrawMenuBar(hMainWnd);
}
CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, TaskManagerSettings.ViewMode, MF_BYCOMMAND);
/*
* Give the application list control focus
*/
if (!bWasKeyboardInput)
SetFocus(hApplicationPageListCtrl);
break;
case 1:
ShowWindow(hApplicationPage, SW_HIDE);
ShowWindow(hProcessPage, SW_SHOW);
ShowWindow(hPerformancePage, SW_HIDE);
BringWindowToTop(hProcessPage);
LoadStringW(hInst, IDS_MENU_SELECTCOLUMNS, szTemp, 256);
AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_SELECTCOLUMNS, szTemp);
LoadStringW(hInst, IDS_MENU_16BITTASK, szTemp, 256);
AppendMenuW(hOptionsMenu, MF_STRING, ID_OPTIONS_SHOW16BITTASKS, szTemp);
if (TaskManagerSettings.Show16BitTasks)
CheckMenuItem(hOptionsMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_CHECKED);
if (GetMenuItemCount(hMenu) > 5)
{
DeleteMenu(hMenu, 3, MF_BYPOSITION);
DrawMenuBar(hMainWnd);
}
/*
* Give the process list control focus
*/
if (!bWasKeyboardInput)
SetFocus(hProcessPageListCtrl);
break;
case 2:
ShowWindow(hApplicationPage, SW_HIDE);
ShowWindow(hProcessPage, SW_HIDE);
ShowWindow(hPerformancePage, SW_SHOW);
BringWindowToTop(hPerformancePage);
if (GetMenuItemCount(hMenu) > 5) {
DeleteMenu(hMenu, 3, MF_BYPOSITION);
DrawMenuBar(hMainWnd);
}
GetSystemInfo(&sysInfo);
/* Hide CPU graph options on single CPU systems */
if (sysInfo.dwNumberOfProcessors > 1)
{
hSubMenu = CreatePopupMenu();
LoadStringW(hInst, IDS_MENU_ONEGRAPHALLCPUS, szTemp, 256);
AppendMenuW(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHALL, szTemp);
LoadStringW(hInst, IDS_MENU_ONEGRAPHPERCPU, szTemp, 256);
AppendMenuW(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, szTemp);
LoadStringW(hInst, IDS_MENU_CPUHISTORY, szTemp, 256);
AppendMenuW(hViewMenu, MF_STRING|MF_POPUP, (UINT_PTR) hSubMenu, szTemp);
if (TaskManagerSettings.CPUHistory_OneGraphPerCPU)
CheckMenuRadioItem(hSubMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, MF_BYCOMMAND);
else
CheckMenuRadioItem(hSubMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHALL, MF_BYCOMMAND);
}
LoadStringW(hInst, IDS_MENU_SHOWKERNELTIMES, szTemp, 256);
AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_SHOWKERNELTIMES, szTemp);
if (TaskManagerSettings.ShowKernelTimes)
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
else
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
/*
* Give the tab control focus
*/
if (!bWasKeyboardInput)
SetFocus(hTabWnd);
break;
}
}
INT_PTR CALLBACK SearchDlg(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
NMHDR *nmhdr;
static BOOL fMouseDown = FALSE;
static POINT ptLastPos;
static BOOL fFirstTime = TRUE;
HWND hwndCombo;
HWND hwndHV = g_hwndHexView;
switch(msg)
{
case WM_INITDIALOG:
AddSearchTabs(hwnd);
// text (UTF8/UTF16/UTF32)
hwndCombo = GetDlgItem(g_hwndFindPane[1], IDC_COMBO_DATATYPE);
AddSearchTypes(hwndCombo, SEARCHTYPE_ASCII, SEARCHTYPE_UTF32, 0);
//AddComboStrings(g_hwndFindPane[1], IDC_COMBO_DATATYPE, szTextNames);
// numbers (byte/word/dword/float/double)
hwndCombo = GetDlgItem(g_hwndFindPane[2], IDC_COMBO_DATATYPE);
AddSearchTypes(hwndCombo, SEARCHTYPE_BYTE, SEARCHTYPE_DOUBLE, 0);
//AddComboStrings(g_hwndFindPane[2], IDC_COMBO_DATATYPE, szNumberNames);
// replace (everything)
hwndCombo = GetDlgItem(g_hwndFindPane[3], IDC_COMBO_DATATYPE);
AddSearchTypes(hwndCombo, SEARCHTYPE_HEX, SEARCHTYPE_HEX, 0);
AddSearchTypes(hwndCombo, SEARCHTYPE_ASCII, SEARCHTYPE_UTF32, 0);
AddSearchTypes(hwndCombo, SEARCHTYPE_BYTE, SEARCHTYPE_DOUBLE, 0);
//AddComboStrings(g_hwndFindPane[3], IDC_COMBO3, szHexNames);
//AddComboStrings(g_hwndFindPane[3], IDC_COMBO3, szTextNames);
//AddComboStrings(g_hwndFindPane[3], IDC_COMBO3, szNumberNames);
if(fFirstTime)
{
CenterWindow(hwnd);
fFirstTime = FALSE;
}
else
{
SetWindowXY(hwnd, ptLastPos.x, ptLastPos.y, NULL);
}
return FALSE;
//case WM_SETFOC
case WM_NOTIFY:
nmhdr = (NMHDR *)lParam;
if(nmhdr->code == TCN_SELCHANGE)
{
nCurrentFindTab = TabCtrl_GetCurSel(nmhdr->hwndFrom);
SetFindTab(hwnd, nCurrentFindTab, fMouseDown);
return TRUE;
}
else if(nmhdr->code == TCN_SELCHANGING)
{
fMouseDown = (GetKeyState(VK_LBUTTON) & 0x80000000) ? TRUE : FALSE;
}
else if(nmhdr->code == NM_RELEASEDCAPTURE)
{
fMouseDown = FALSE;
}
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDCANCEL:
DestroyWindow(hwnd);
return TRUE;
case IDC_REPLACE:
Replace(GetCurFindTab(hwnd), hwndHV);
return TRUE;
case IDC_REPLACEALL:
return TRUE;
case IDOK:
Find(GetCurFindTab(hwnd), hwndHV);
return TRUE;
}
return TRUE;
case WM_MOVE:
{
RECT rect;
GetWindowRect(hwnd, &rect);
ptLastPos.x = rect.left;//(short)LOWORD(lParam);
ptLastPos.y = rect.top;//(short)HIWORD(lParam);
}
return TRUE;
case WM_CLOSE:
DestroyWindow(hwnd);
return TRUE;
case WM_DESTROY:
g_hwndSearch = 0;
return TRUE;
}
return FALSE;
}
static void TaskManager_OnTabWndSelChange(void)
{
int i;
HMENU hMenu;
HMENU hOptionsMenu;
HMENU hViewMenu;
HMENU hSubMenu;
WCHAR wszLargeIcons[255];
WCHAR wszSmallIcons[255];
WCHAR wszDetails[255];
WCHAR wszWindows[255];
WCHAR wszSelectColumns[255];
WCHAR wszShow16bTasks[255];
WCHAR wszOneGraphAllCPU[255];
WCHAR wszOneGraphPerCPU[255];
WCHAR wszCPUHistory[255];
WCHAR wszShowKernelTimes[255];
LoadStringW(hInst, IDS_VIEW_LARGE, wszLargeIcons, sizeof(wszLargeIcons)/sizeof(WCHAR));
LoadStringW(hInst, IDS_VIEW_SMALL, wszSmallIcons, sizeof(wszSmallIcons)/sizeof(WCHAR));
LoadStringW(hInst, IDS_VIEW_DETAILS, wszDetails, sizeof(wszDetails)/sizeof(WCHAR));
LoadStringW(hInst, IDS_WINDOWS, wszWindows, sizeof(wszWindows)/sizeof(WCHAR));
LoadStringW(hInst, IDS_VIEW_SELECTCOLUMNS, wszSelectColumns, sizeof(wszSelectColumns)/sizeof(WCHAR));
LoadStringW(hInst, IDS_OPTIONS_SHOW16BITTASKS, wszShow16bTasks, sizeof(wszShow16bTasks)/sizeof(WCHAR));
LoadStringW(hInst, IDS_VIEW_CPUHISTORY_ONEGRAPHALL, wszOneGraphAllCPU, sizeof(wszOneGraphAllCPU)/sizeof(WCHAR));
LoadStringW(hInst, IDS_VIEW_CPUHISTORY_ONEGRAPHPERCPU, wszOneGraphPerCPU, sizeof(wszOneGraphPerCPU)/sizeof(WCHAR));
LoadStringW(hInst, IDS_VIEW_CPUHISTORY, wszCPUHistory, sizeof(wszCPUHistory)/sizeof(WCHAR));
LoadStringW(hInst, IDS_VIEW_SHOWKERNELTIMES, wszShowKernelTimes, sizeof(wszShowKernelTimes)/sizeof(WCHAR));
hMenu = GetMenu(hMainWnd);
hViewMenu = GetSubMenu(hMenu, 2);
hOptionsMenu = GetSubMenu(hMenu, 1);
TaskManagerSettings.ActiveTabPage = TabCtrl_GetCurSel(hTabWnd);
for (i = GetMenuItemCount(hViewMenu) - 1; i > 2; i--) {
hSubMenu = GetSubMenu(hViewMenu, i);
if (hSubMenu)
DestroyMenu(hSubMenu);
RemoveMenu(hViewMenu, i, MF_BYPOSITION);
}
RemoveMenu(hOptionsMenu, 3, MF_BYPOSITION);
switch (TaskManagerSettings.ActiveTabPage) {
case 0:
ShowWindow(hApplicationPage, SW_SHOW);
ShowWindow(hProcessPage, SW_HIDE);
ShowWindow(hPerformancePage, SW_HIDE);
BringWindowToTop(hApplicationPage);
AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_LARGE, wszLargeIcons);
AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_SMALL, wszSmallIcons);
AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_DETAILS, wszDetails);
if (GetMenuItemCount(hMenu) <= 4) {
hSubMenu = LoadMenuW(hInst, MAKEINTRESOURCEW(IDR_WINDOWSMENU));
InsertMenuW(hMenu, 3, MF_BYPOSITION|MF_POPUP, (UINT_PTR)hSubMenu, wszWindows);
DrawMenuBar(hMainWnd);
}
if (TaskManagerSettings.View_LargeIcons)
CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_LARGE, MF_BYCOMMAND);
else if (TaskManagerSettings.View_SmallIcons)
CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_SMALL, MF_BYCOMMAND);
else
CheckMenuRadioItem(hViewMenu, ID_VIEW_LARGE, ID_VIEW_DETAILS, ID_VIEW_DETAILS, MF_BYCOMMAND);
/*
* Give the application list control focus
*/
SetFocus(hApplicationPageListCtrl);
break;
case 1:
ShowWindow(hApplicationPage, SW_HIDE);
ShowWindow(hProcessPage, SW_SHOW);
ShowWindow(hPerformancePage, SW_HIDE);
BringWindowToTop(hProcessPage);
AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_SELECTCOLUMNS, wszSelectColumns);
AppendMenuW(hOptionsMenu, MF_STRING, ID_OPTIONS_SHOW16BITTASKS, wszShow16bTasks);
if (TaskManagerSettings.Show16BitTasks)
CheckMenuItem(hOptionsMenu, ID_OPTIONS_SHOW16BITTASKS, MF_BYCOMMAND|MF_CHECKED);
if (GetMenuItemCount(hMenu) > 4)
{
RemoveMenu(hMenu, 3, MF_BYPOSITION);
DrawMenuBar(hMainWnd);
}
/*
* Give the process list control focus
*/
SetFocus(hProcessPageListCtrl);
break;
case 2:
ShowWindow(hApplicationPage, SW_HIDE);
ShowWindow(hProcessPage, SW_HIDE);
ShowWindow(hPerformancePage, SW_SHOW);
BringWindowToTop(hPerformancePage);
if (GetMenuItemCount(hMenu) > 4) {
RemoveMenu(hMenu, 3, MF_BYPOSITION);
DrawMenuBar(hMainWnd);
}
hSubMenu = CreatePopupMenu();
AppendMenuW(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHALL, wszOneGraphAllCPU);
AppendMenuW(hSubMenu, MF_STRING, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, wszOneGraphPerCPU);
AppendMenuW(hViewMenu, MF_STRING|MF_POPUP, (UINT_PTR)hSubMenu, wszCPUHistory);
AppendMenuW(hViewMenu, MF_STRING, ID_VIEW_SHOWKERNELTIMES, wszShowKernelTimes);
if (TaskManagerSettings.ShowKernelTimes)
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_CHECKED);
else
CheckMenuItem(hViewMenu, ID_VIEW_SHOWKERNELTIMES, MF_BYCOMMAND|MF_UNCHECKED);
if (TaskManagerSettings.CPUHistory_OneGraphPerCPU)
CheckMenuRadioItem(hSubMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, MF_BYCOMMAND);
else
CheckMenuRadioItem(hSubMenu, ID_VIEW_CPUHISTORY_ONEGRAPHALL, ID_VIEW_CPUHISTORY_ONEGRAPHPERCPU, ID_VIEW_CPUHISTORY_ONEGRAPHALL, MF_BYCOMMAND);
/*
* Give the tab control focus
*/
SetFocus(hTabWnd);
break;
}
}
