void Server_DisplayTab (HWND hDlg, CHILDTAB iTab)
{
HWND hTab = GetDlgItem (hDlg, IDC_TABS);
int idd = -1;
DLGPROC dlgproc = NULL;
switch (iTab)
{
case tabSERVICES:
idd = IDD_SERVICES;
dlgproc = (DLGPROC)Services_DlgProc;
break;
case tabAGGREGATES:
idd = IDD_AGGREGATES;
dlgproc = (DLGPROC)Aggregates_DlgProc;
break;
case tabFILESETS:
idd = IDD_FILESETS;
dlgproc = (DLGPROC)Filesets_DlgProc;
break;
}
if (idd != -1)
{
HWND hDialogOld = GetTabChild (hTab);
HWND hDialogNew = ModelessDialog (idd, hTab, dlgproc);
if (hDialogNew != NULL)
{
TabCtrl_SetCurSel (hTab, iTab);
ShowWindow (hDialogNew, SW_SHOW);
if (hDialogOld != NULL)
{
DestroyWindow (hDialogOld);
}
Server_ForceRedraw (hDlg);
}
}
}
LRESULT CColorPicker::OnKeyDownList(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
bHandled = FALSE;
if (wParam == VK_ESCAPE)
{
Close();
}
else if (wParam == VK_RETURN)
{
int nSel = m_winList.SendMessage(LB_GETCURSEL);
if(nSel >= 0) m_clr = m_SystemColors[nSel].clr;
Close();
}
else if (wParam == VK_TAB)
{
BOOL b;
TabCtrl_SetCurSel(m_winTab, 0);
OnTabSelChange(0, 0, b);
}
return 0;
}
int wxNotebook::SetSelection(size_t nPage)
{
wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("notebook page out of range") );
if ( m_selection == wxNOT_FOUND || nPage != (size_t)m_selection )
{
if ( SendPageChangingEvent(nPage) )
{
// program allows the page change
const int selectionOld = m_selection;
UpdateSelection(nPage);
TabCtrl_SetCurSel(GetHwnd(), nPage);
SendPageChangedEvent(selectionOld, nPage);
}
}
return m_selection;
}
// On load of a new document we insert a new tab item in the tab bar.
// Its text is the name of the opened file.
void TabsOnLoadedDoc(WindowInfo *win)
{
if (!win)
return;
TabData *td = new TabData();
SaveTabData(win, td);
TCITEM tcs;
tcs.mask = TCIF_TEXT | TCIF_PARAM;
tcs.pszText = (WCHAR *)path::GetBaseName(win->loadedFilePath);
tcs.lParam = (LPARAM)td;
int count = TabsGetCount(win);
if (-1 != TabCtrl_InsertItem(win->hwndTabBar, count, &tcs)) {
TabCtrl_SetCurSel(win->hwndTabBar, count);
UpdateTabWidth(win);
}
else
DeleteTabData(td, false);
UpdateCurrentTabBgColForWindow(win);
}
//
// Ensure the TabView reflects the dockwnds
//
void UpdateDockTabView(DOCKPANEL *dpp)
{
DOCKWND *dwp = 0;
int idx = 0;
int selidx = 0;
DOCKWND *seldwp = 0;
TabCtrl_DeleteAllItems(dpp->hwndTabView);
//TRACEA("Updating tab: %x %x\n", dpp->hwndPanel, dpp);
for(dwp = dpp->WndListHead->flink; dwp != dpp->WndListTail; dwp = dwp->flink)
{
if(dwp->fVisible)
{
TCITEM tci = { TCIF_PARAM|TCIF_TEXT };
tci.lParam = dwp->uWndId;
tci.pszText = dwp->szTitle;
if(dwp->uWndId == dpp->uCurrentTabId)
{
selidx = idx;
seldwp = dwp;
}
TabCtrl_InsertItem(dpp->hwndTabView, idx++, &tci);
}
}
TabCtrl_SetCurSel(dpp->hwndTabView, selidx);
if(seldwp)
{
SetWindowText(dpp->hwndPanel, seldwp->szTitle);
}
InvalidateRect(dpp->hwndPanel, 0, TRUE);
}
static void ActivateChild(struct ParentWindowData *dat, HWND child) {
int i;
RECT rcChild;
GetChildWindowRect(dat, &rcChild);
SetWindowPos(child, HWND_TOP, rcChild.left, rcChild.top, rcChild.right-rcChild.left, rcChild.bottom - rcChild.top, SWP_NOSIZE);
if(child != dat->hwndActive) {
HWND prev = dat->hwndActive;
dat->hwndActive = child;
SendMessage(dat->hwndActive, DM_UPDATESTATUSBAR, 0, 0);
SendMessage(dat->hwndActive, DM_UPDATETITLE, 0, 0);
SendMessage(dat->hwnd, WM_SIZE, 0, 0);
ShowWindow(dat->hwndActive, SW_SHOWNOACTIVATE);
SendMessage(dat->hwndActive, DM_SCROLLLOGTOBOTTOM, 0, 0);
if (prev!=NULL) ShowWindow(prev, SW_HIDE);
} else {
SendMessage(dat->hwnd, WM_SIZE, 0, 0);
}
i = GetTabFromHWND(dat, child);
TabCtrl_SetCurSel(dat->hwndTabs, i);
SendMessage(dat->hwndActive, DM_ACTIVATE, WA_ACTIVE, 0);
}
// On load of a new document we insert a new tab item in the tab bar.
void TabsOnLoadedDoc(WindowInfo *win)
{
if (!win)
return;
TabInfo *tab = win->tabs.Last();
VerifyTabInfo(win, tab);
TCITEM tcs;
tcs.mask = TCIF_TEXT;
tcs.pszText = (WCHAR *)tab->GetTabTitle();
int index = (int)win->tabs.Count() - 1;
if (-1 != TabCtrl_InsertItem(win->hwndTabBar, index, &tcs)) {
TabCtrl_SetCurSel(win->hwndTabBar, index);
UpdateTabWidth(win);
}
else {
// TODO: what now?
CrashIf(true);
}
}
/*
** Opens the About dialog.
**
*/
void DialogAbout::Open(int tab)
{
if (!c_Dialog)
{
c_Dialog = new DialogAbout();
}
c_Dialog->ShowDialogWindow(
GetString(ID_STR_ABOUTRAINMETER),
0, 0, 400, 210,
DS_CENTER | WS_POPUP | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME,
WS_EX_APPWINDOW | WS_EX_CONTROLPARENT | ((*GetString(ID_STR_ISRTL) == L'1') ? WS_EX_LAYOUTRTL : 0),
GetRainmeter().GetWindow());
// Fake WM_NOTIFY to change tab
NMHDR nm;
nm.code = TCN_SELCHANGE;
nm.idFrom = Id_Tab;
nm.hwndFrom = c_Dialog->GetControl(Id_Tab);
TabCtrl_SetCurSel(nm.hwndFrom, tab);
c_Dialog->OnNotify(0, (LPARAM)&nm);
}
//WM_INITDIALOG
BOOL PBSettings_OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam)
{
(void) hwndFocus; //To avoid the warning
//Associate the parameters to the window
SetWindowLongPtr(hwnd,GWLP_USERDATA,(__int3264)(LONG_PTR)lParam);
//Get the PBSDP
PenBrushSettingsDlgParam * pbsdp=(PenBrushSettingsDlgParam *)(LONG_PTR)GetWindowLongPtr(hwnd,GWLP_USERDATA);
//Create the tabs
TCITEM ti;
//Foreground tab
ti.pszText=const_cast<LPTSTR>(langFile->GetString(IDS_PB_TABS_FG).c_str());
ti.mask=TCIF_TEXT;
if((pbsdp->fgTabIndex=TabCtrl_InsertItem(GetDlgItem(hwnd,IDC_PB_TABS),0,&ti))==-1)
throw std::runtime_error(ERROR_STD_PROLOG "TabCtrl_InsertItem returned -1 creating the \"Foreground\" tab.");
//Background tab
ti.pszText=const_cast<LPTSTR>(langFile->GetString(IDS_PB_TABS_BG).c_str());
if((pbsdp->bgTabIndex=TabCtrl_InsertItem(GetDlgItem(hwnd,IDC_PB_TABS),1,&ti))==-1)
throw std::runtime_error(ERROR_STD_PROLOG "TabCtrl_InsertItem returned -1 creating the \"Background\" tab.");
//Select the right tab
TabCtrl_SetCurSel(GetDlgItem(hwnd,IDC_PB_TABS),pbsdp->GetActiveTabIndex());
//Send a fake notification
NMHDR nmh;
nmh.code=TCN_SELCHANGE;
nmh.hwndFrom=GetDlgItem(hwnd,IDC_PB_TABS);
nmh.idFrom=IDC_PB_TABS;
FORWARD_WM_NOTIFY(hwnd,IDC_PB_TABS,&nmh,SendMessage);
//Setup the updown control
//Set the range of the width updown control
SendDlgItemMessage(hwnd,IDC_PB_UD_WIDTH,UDM_SETRANGE,0,(LPARAM) MAKELONG((short) MAXPENWIDTH, (short) MINPENWIDTH));
//Init some other controls
ColorUtils2CommonControls(hwnd);
//Subclass the textbox
SetWindowLongPtr(GetDlgItem(hwnd,IDC_PB_P_TX_CUSTOM),GWLP_USERDATA,(__int3264)(LONG_PTR)SetWindowLongPtr(GetDlgItem(hwnd,IDC_PB_P_TX_CUSTOM),GWLP_WNDPROC,(__int3264)(LONG_PTR)SubclTxtProc));
//Load the captions of the child windows (and of itself)
langFile->InitializeDialogCaptions(hwnd, IDD_PENBRUSHSETTINGS);
return TRUE;
}
//
// Show the find/replace/goto dialog
//
HWND ShowFindDlg(HWND hwndParent, UINT nPage)
{
HWND hwndTab;
NMHDR nmhdr;
//
// Create the dialog if it hasn't been already
//
if(g_hwndSearchDlg == 0)
{
g_hwndSearchDlg = CreateDialog(g_hResourceModule, MAKEINTRESOURCE(IDD_FIND), hwndParent, SearchDlgProc);
CenterWindow(g_hwndSearchDlg);
ShowWindow(g_hwndSearchDlg, SW_SHOW);
}
SetForegroundWindow(g_hwndSearchDlg);
//
// Simulate the user clicking one of the TABs in order to
// set the desired page
//
hwndTab = GetDlgItem(g_hwndSearchDlg, IDC_TAB1);
nmhdr.hwndFrom = hwndTab;
nmhdr.code = TCN_SELCHANGE;
nmhdr.idFrom = IDC_TAB1;
TabCtrl_SetCurSel(hwndTab, nPage);
SendMessage(g_hwndSearchDlg, WM_NOTIFY, IDC_TAB1, (LPARAM)&nmhdr);
// Set focus to 1st control in dialog
SetFocus(GetDlgItem(g_hwndFindPane[nPage], IDC_COMBO1));
PostMessage(g_hwndFindPane[nPage], WM_NEXTDLGCTL, IDC_COMBO1, TRUE);
return g_hwndSearchDlg;
}
INT_PTR CALLBACK config_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
LPNMHDR lpn = (LPNMHDR) lParam;
switch (uMsg) {
case WM_INITDIALOG:
logger.Info("config_dlgproc()", "WM_INITDIALOG");
TCITEM tie;
m_hwndDlg = hwndDlg;
m_hwndTab = GetDlgItem(hwndDlg, IDC_CONFIG_TABS);
tie.mask = TCIF_TEXT;
for (int i = 0; i < sizeof(tabs) / sizeof(pref_tab); i++) {
tie.pszText = tabs[i].title;
TabCtrl_InsertItem(m_hwndTab, i, &tie);
}
TabCtrl_SetCurSel(m_hwndTab, 0);
OnSelChanged(hwndDlg);
break;
case WM_NOTIFY:
if(lpn) if(lpn->code==TCN_SELCHANGE) OnSelChanged(hwndDlg);
break;
case WM_COMMAND:
logger.Message("config_dlgproc()", "WM_COMMAND");
switch (LOWORD(wParam)) {
case IDOK:
mlOrgConfig.SaveConfiguration(iniFile);
case IDCANCEL:
mlOrgConfig.LoadConfiguration(iniFile);
EndDialog(hwndDlg, 0);
break;
}
break;
}
return 0;
}
/// Function name : displayDocumentByIndex
// Description : Changes the active tab and displays the appropriate document
//
// HWND hTabCtrl : [in] Document control handle
// CONST UINT iIndex : [in] Zero based index of the document to display
//
VOID displayDocumentByIndex(HWND hTabCtrl, CONST UINT iIndex)
{
DOCUMENTS_DATA* pWindowData; // Window data
DOCUMENT* pDocument; // Target Document
// Prepare
pWindowData = getDocumentsControlData(hTabCtrl);
// Lookup document and ensure its not already active
if (findDocumentByIndex(hTabCtrl, iIndex, pDocument) AND pDocument != getActiveDocument())
{
// [SUCCESS] Hide current active document (if any)
if (getActiveDocument())
ShowWindow(getActiveDocument()->hWnd, SW_HIDE);
/// Ensure correct tab is selected
TabCtrl_SetCurSel(pWindowData->hTabCtrl, iIndex); // Already active if user has changed tab manually
/// Display new document
setActiveDocument(pWindowData, pDocument);
}
}
void CTerrainTool::ContentInit()
{
_SetEdtValue(IDC_EDIT_BRUSH_SIZE, 10);
_SetEdtValue(IDC_EDIT_CAMERA_MOVE, 1);
_SetRangeTrackBar(IDC_SLIDE_BRUSH_SIZE, 1, 100);
_SetRangeTrackBar(IDC_SLIDE_CAMERA_MOVE, 1, 20);
_SetPosTrackBar(IDC_SLIDE_BRUSH_SIZE, 10);
_SetPosTrackBar(IDC_SLIDE_CAMERA_MOVE, 1);
_SetCheckBox(IDC_CHECK_FOG, false);
_SetCheckBox(IDC_CHECK_LIGHT, false);
_SetCheckBox(IDC_CHECK_WIRE, false);
_SetCheckBox(IDC_CHECK_PICK, true);
m_pEditDlg->ContentInit();
int id = dynamic_cast<Scn_MapTool*>(AVDirector::GetDiector()->GetScene())->baseTexID();
int num = dynamic_cast<Scn_MapTool*>(AVDirector::GetDiector()->GetScene())->SizeSplatTextures();
m_pSplattingDlg->ContentInit(id, num);//임시
for(int i=0; i<num; i++)
m_pSplattingDlg->m_vID.push_back(i);
HWND hWnd = GetDlgItem(m_hWnd, IDC_TAB);
TabCtrl_SetCurSel(hWnd, 0);
}
// Called when we're closing a document
void TabsOnCloseDoc(WindowInfo *win)
{
int count = TabsGetCount(win);
if (count <= 0)
return;
if (win->AsFixed() && win->AsFixed()->userAnnots && win->AsFixed()->userAnnotsModified) {
// TODO: warn about unsaved changes
}
int current = TabCtrl_GetCurSel(win->hwndTabBar);
TabData *tdata = GetTabData(win, current);
win->tabSelectionHistory->Remove(tdata);
UpdateTabFileDisplayStateForWin(win, tdata);
DeleteTabData(tdata, false);
TabCtrl_DeleteItem(win->hwndTabBar, current);
UpdateTabWidth(win);
if (count > 1) {
tdata = win->tabSelectionHistory->Pop();
TabCtrl_SetCurSel(win->hwndTabBar, FindTabIndex(win, tdata));
LoadModelIntoTab(win, tdata);
UpdateCurrentTabBgColForWindow(win);
}
}
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);
}
}
INT_PTR WINAPI ConEmuAbout::aboutProc(HWND hDlg, UINT messg, WPARAM wParam, LPARAM lParam)
{
INT_PTR lRc = 0;
if (DonateBtns_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;
DonateBtns_Add(hDlg, pIconCtrl, IDOK);
if (mp_DpiAware)
{
mp_DpiAware->Attach(hDlg, ghWnd, CDynDialog::GetDlgClass(hDlg));
}
RECT rect = {};
if (GetWindowRect(hDlg, &rect))
{
CDpiAware::GetCenteredRect(ghWnd, rect);
MoveWindowRect(hDlg, rect);
}
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" 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);
}
SetDlgItemText(hDlg, stConEmuAbout, pAboutTitle);
SetDlgItemText(hDlg, stConEmuUrl, gsHomePage);
EditIconHint_Set(hDlg, GetDlgItem(hDlg, tAboutSearch), true, L"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);
//else
// DestroyWindow(hDlg);
break;
case WM_DESTROY:
mh_AboutDlg = NULL;
break;
default:
if (mp_DpiAware && mp_DpiAware->ProcessDpiMessages(hDlg, messg, wParam, lParam))
{
return TRUE;
}
}
return FALSE;
}
INT_PTR CALLBACK DlgAddGameProc(HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
switch (uMsg) {
case WM_INITDIALOG:
{
//übersetzen lassen
TranslateDialogDefault(hwndDlg);
//per thread liste füllen
mir_forkthread(FillGameList, hwndDlg);
}
break;
case WM_COMMAND:
if (LOWORD(wParam) == IDC_SEARCH && HIWORD(wParam) == EN_CHANGE)
{
char temp[256];
//eingabe bei der suche auslesen
GetDlgItemTextA(hwndDlg, IDC_SEARCH, temp, SIZEOF(temp));
//eingabe in der liste suchen
int idx = SendDlgItemMessageA(hwndDlg, IDC_GAMELIST, LB_FINDSTRING, 0, (LPARAM)temp);
//gefunden?
if (idx != LB_ERR)
{
//als aktiv setzen
SendDlgItemMessage(hwndDlg, IDC_GAMELIST, LB_SETCURSEL, idx, 0);
}
}
else if (LOWORD(wParam) == IDCANCEL)
{
//nicht schließen, wenn noch der thread läuft
if (dontClose) {
MessageBox(hwndDlg, TranslateT("Please wait, game.ini will be currently parsed..."), TranslateT("XFire Options"), MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
return SendMessage(GetParent(hwndDlg), WM_CLOSE, 0, 0);
}
else if (LOWORD(wParam) == IDC_CUSTOM)
{
int idx = SendDlgItemMessage(hwndDlg, IDC_GAMELIST, LB_GETCURSEL, 0, 0);
//es wurde was ausgewählt?
if (idx == LB_ERR) {
MessageBox(hwndDlg, TranslateT("Please choose one game in the list!"), TranslateT("XFire Options"), MB_OK | MB_ICONEXCLAMATION);
}
else
{
char ret[512] = "";
char gameidtemp[10] = "";
int gameids = SendDlgItemMessage((HWND)hwndDlg, IDC_GAMELIST, LB_GETITEMDATA, idx, 0);
//gameid splitten
int gameid1 = LOWORD(gameids);
int gameid2 = HIWORD(gameids);
if (gameid2 != 0)
mir_snprintf(gameidtemp, SIZEOF(gameidtemp), "%d_%d", gameid1, gameid2);
else
mir_snprintf(gameidtemp, SIZEOF(gameidtemp), "%d", gameid1);
//spielnamen holen
if (xfire_GetPrivateProfileString(gameidtemp, "LongName", "", ret, 512, inipath)) {
mir_snprintf(gameidtemp, SIZEOF(gameidtemp), "%d", gameid1);
//einige felder vorbelegen
SetDlgItemTextA(hPage, IDC_ADD_NAME, ret);
SetDlgItemText(hPage, IDC_ADD_DETECTEXE, _T(""));
SetDlgItemText(hPage, IDC_ADD_LAUNCHEREXE, _T(""));
SetDlgItemTextA(hPage, IDC_ADD_ID, gameidtemp);
SetDlgItemText(hPage, IDC_ADD_STATUSMSG, _T(""));
SetDlgItemText(hPage, IDC_ADD_CUSTOMPARAMS, _T(""));
SetDlgItemTextA(hPage, IDC_ADD_SENDID, gameidtemp);
//auf customeintrag edit tab wechseln
TabCtrl_SetCurSel(hwndTab, 1);
ShowWindow(hwndDlg, SW_HIDE);
ShowWindow(hPage, SW_SHOW);
}
}
}
else if (LOWORD(wParam) == IDOK)
{
int idx = SendDlgItemMessage(hwndDlg, IDC_GAMELIST, LB_GETCURSEL, 0, 0);
//es wurde was ausgewählt?
if (idx == LB_ERR) {
MessageBox(hwndDlg, TranslateT("Please choose one game in the list!"), TranslateT("XFire Options"), MB_OK | MB_ICONEXCLAMATION);
}
else
{
//datei öffnen dialog
OPENFILENAMEA ofn;
//listdata auslesen, wo die gameid gespeihcert ist
int gameids = SendDlgItemMessage((HWND)hwndDlg, IDC_GAMELIST, LB_GETITEMDATA, idx, 0);
//gameid splitten
int gameid1 = LOWORD(gameids);
int gameid2 = HIWORD(gameids);
char gameidtemp[10] = "";
char ret[512];
if (gameid2 != 0)
mir_snprintf(gameidtemp, SIZEOF(gameidtemp), "%d_%d", gameid1, gameid2);
else
mir_snprintf(gameidtemp, SIZEOF(gameidtemp), "%d", gameid1);
//neuen gameeintrag anlegen
Xfire_game* newgame = new Xfire_game();
//gameid und sendid setzen
newgame->id = gameid1;
newgame->send_gameid = gameid1;
//es handelt sich um einen customeintrag, man staune xD
newgame->custom = 1;
//launcherexe abfragen
if (xfire_GetPrivateProfileString(gameidtemp, "LauncherExe", "", ret, 512, inipath)) {
//datei vom user öffnen lassen
if (OpenFileDialog(hwndDlg, &ofn, ret))
{
//lowercase pfad
newgame->strtolower(ofn.lpstrFile);
//pfad dem spiel zuordnen
newgame->setString(ofn.lpstrFile, &newgame->launchparams);
}
else
{
//speicher freigeben
delete newgame;
return FALSE;
}
}
//detectexe abfragen
if (xfire_GetPrivateProfileString(gameidtemp, "DetectExe", "", ret, 512, inipath)) {
//datei vom user öffnen lassen
if (OpenFileDialog(hwndDlg, &ofn, ret))
{
//lowercase pfad
newgame->strtolower(ofn.lpstrFile);
//pfad dem spiel zuordnen
newgame->setString(ofn.lpstrFile, &newgame->path);
}
else
{
//speicher freigeben
delete newgame;
return FALSE;
}
} //MatchExe abfragen
else if (xfire_GetPrivateProfileString(gameidtemp, "MatchExe", "", ret, 512, inipath)) {
//datei vom user öffnen lassen
if (OpenFileDialog(hwndDlg, &ofn, ret))
{
//lowercase pfad
newgame->strtolower(ofn.lpstrFile);
//pfad dem spiel zuordnen
newgame->setString(ofn.lpstrFile, &newgame->path);
}
else
{
//speicher freigeben
delete newgame;
return FALSE;
}
}
//prüfe ob schon ein launchstring festgelegt wurde, wenn nicht die detectexe nehmen
if (!newgame->launchparams&&newgame->path) {
newgame->setString(newgame->path, &newgame->launchparams);
}
//prüfe ob schon ein detectexe festgelegt wurde, wenn nicht die launchstring nehmen
if (newgame->launchparams&&!newgame->path) {
newgame->setString(newgame->launchparams, &newgame->path);
}
//LauncherUrl wird der launcherstring überschrieben
if (xfire_GetPrivateProfileString(gameidtemp, "LauncherUrl", "", ret, 512, inipath)) {
newgame->setString(ret, &newgame->launchparams);
}
else if (xfire_GetPrivateProfileString(gameidtemp, "Launch", "", ret, 512, inipath)) {
str_replace(ret, "%UA_LAUNCHER_EXE_PATH%", ""); //erstmal unwichtige sachen entfernen
//str_replace(ret,"%UA_LAUNCHER_EXTRA_ARGS%",""); // - auch entfernen
str_replace(ret, "%UA_LAUNCHER_LOGIN_ARGS%", ""); // - auch entfernen
//ein leerzeichen anfügen
newgame->appendString(" ", &newgame->launchparams);
//nun commandline des launchstringes dranhängen
newgame->appendString(ret, &newgame->launchparams);
}
//restliche wichtige felder einfügen
if (xfire_GetPrivateProfileString(gameidtemp, "LauncherPasswordArgs", "", ret, 512, inipath))
newgame->setString(ret, &newgame->pwparams);
if (xfire_GetPrivateProfileString(gameidtemp, "LauncherNetworkArgs", "", ret, 512, inipath))
newgame->setString(ret, &newgame->networkparams);
if (xfire_GetPrivateProfileString(gameidtemp, "CommandLineMustContain[0]", "", ret, 512, inipath))
newgame->setString(ret, &newgame->mustcontain);
if (xfire_GetPrivateProfileString(gameidtemp, "XUSERSendId", "", ret, 512, inipath))
newgame->send_gameid = atoi(ret);
if (xfire_GetPrivateProfileString(gameidtemp, "XUSERSetStatusMsg", "", ret, 512, inipath))
newgame->setstatusmsg = atoi(ret);
//namen setzen und icon laden
newgame->setNameandIcon();
//spiel in die gameliste einfügen
xgamelist.Addgame(newgame);
//derzeitige gameliste in die datenbank eintragen
xgamelist.writeDatabase();
//startmenu leeren
xgamelist.clearStartmenu();
//startmenu neuerzeugen
xgamelist.createStartmenu();
return SendMessage(GetParent(hwndDlg), WM_CLOSE, 0, 0);
}
}
break;
case WM_CLOSE:
//nicht schließen, wenn noch der thread läuft
if (dontClose) {
MessageBox(hwndDlg, TranslateT("Please wait, game.ini will be currently parsed..."), TranslateT("XFire Options"), MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
//hauptfenster schließen
SendMessage(GetParent(hwndDlg), WM_CLOSE, 0, 0);
break;
}
return FALSE;
}
INT_PTR CALLBACK stats_dlgproc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
HWND dlg;
LPNMHDR lpn = (LPNMHDR) lParam;
switch (uMsg) {
case WM_INITDIALOG:
dlg = CreateDialog(plugin.hDllInstance,
MAKEINTRESOURCE(IDD_PROCESSING),
hwndDlg, process_dlgproc);
memset(tmp, 0, sizeof(tmp));
GetPrivateProfileString("ml_stats", "query", "type = \"0\"",
tmp, sizeof(tmp), iniFile);
SetDlgItemText(hwndDlg, IDC_QUERY, tmp);
m_pRecords = getRecords(tmp);
TCITEM tie;
m_hwndDlg = hwndDlg;
m_hwndTab = GetDlgItem(hwndDlg, IDC_STATS_TABS);
tie.mask = TCIF_TEXT;
for (int i = 0; i < sizeof(tabs) / sizeof(pref_tab); i++) {
tie.pszText = tabs[i].title;
TabCtrl_InsertItem(m_hwndTab, i, &tie);
}
DestroyWindow(dlg);
TabCtrl_SetCurSel(m_hwndTab, 0);
OnSelChanged(hwndDlg);
break;
case WM_NOTIFY:
if(lpn) if(lpn->code==TCN_SELCHANGE) OnSelChanged(hwndDlg);
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_ABOUT:
LoadString(plugin.hDllInstance, IDS_ABOUTBOX, tmp, sizeof(tmp));
MessageBox(hwndDlg, tmp, "Media Library Stastics",
MB_OK | MB_ICONINFORMATION);
break;
case IDC_FILTER:
dlg = CreateDialog(plugin.hDllInstance,
MAKEINTRESOURCE(IDD_PROCESSING),
hwndDlg, process_dlgproc);
memset(tmp, 0, sizeof(tmp));
GetDlgItemText(hwndDlg, IDC_QUERY, tmp, sizeof(tmp));
m_pRecords = getRecords(tmp);
DestroyWindow(dlg);
OnSelChanged(hwndDlg);
break;
case IDOK:
memset(tmp, 0, sizeof(tmp));
GetDlgItemText(hwndDlg, IDC_QUERY, tmp, sizeof(tmp));
WritePrivateProfileString("ml_stats", "query", tmp, iniFile);
case IDCANCEL:
EndDialog(hwndDlg, 0);
break;
}
break;
}
return 0;
}
HWND TSAPI CreateNewTabForContact(TContainerData *pContainer, MCONTACT hContact, int isSend, const char *pszInitialText, BOOL bActivateTab, BOOL bPopupContainer, BOOL bWantPopup, HANDLE hdbEvent)
{
TCHAR newcontactname[128], tabtitle[128];
int newItem;
DBVARIANT dbv = {0};
if (M.FindWindow(hContact) != 0) {
_DebugPopup(hContact, _T("Warning: trying to create duplicate window"));
return 0;
}
// if we have a max # of tabs/container set and want to open something in the default container...
if (hContact != 0 && M.GetByte("limittabs", 0) && !_tcsncmp(pContainer->szName, _T("default"), 6)) {
if ((pContainer = FindMatchingContainer(_T("default"), hContact)) == NULL) {
TCHAR szName[CONTAINER_NAMELEN + 1];
mir_sntprintf(szName, CONTAINER_NAMELEN, _T("default"));
if ((pContainer = CreateContainer(szName, CNT_CREATEFLAG_CLONED, hContact)) == NULL)
return 0;
}
}
TNewWindowData newData = {0};
newData.hContact = hContact;
newData.isWchar = isSend;
newData.szInitialText = pszInitialText;
char *szProto = GetContactProto(newData.hContact);
ZeroMemory(&newData.item, sizeof(newData.item));
// obtain various status information about the contact
TCHAR *contactName = pcli->pfnGetContactDisplayName(newData.hContact, 0);
/*
* cut nickname if larger than x chars...
*/
if (contactName && lstrlen(contactName) > 0) {
if (M.GetByte("cuttitle", 0))
CutContactName(contactName, newcontactname, SIZEOF(newcontactname));
else {
lstrcpyn(newcontactname, contactName, SIZEOF(newcontactname));
newcontactname[127] = 0;
}
//Mad: to fix tab width for nicknames with ampersands
Utils::DoubleAmpersands(newcontactname);
} else
lstrcpyn(newcontactname, _T("_U_"), SIZEOF(newcontactname));
WORD wStatus = (szProto == NULL ? ID_STATUS_OFFLINE : db_get_w(newData.hContact, szProto, "Status", ID_STATUS_OFFLINE));
TCHAR *szStatus = pcli->pfnGetStatusModeDescription(szProto == NULL ? ID_STATUS_OFFLINE : db_get_w(newData.hContact, szProto, "Status", ID_STATUS_OFFLINE), 0);
if (M.GetByte("tabstatus", 1))
mir_sntprintf(tabtitle, SIZEOF(tabtitle), _T("%s (%s) "), newcontactname, szStatus);
else
mir_sntprintf(tabtitle, SIZEOF(tabtitle), _T("%s "), newcontactname);
newData.item.pszText = tabtitle;
newData.item.mask = TCIF_TEXT | TCIF_IMAGE | TCIF_PARAM;
newData.item.iImage = 0;
newData.item.cchTextMax = 255;
HWND hwndTab = GetDlgItem(pContainer->hwnd, IDC_MSGTABS);
// hide the active tab
if (pContainer->hwndActive && bActivateTab)
ShowWindow(pContainer->hwndActive, SW_HIDE);
{
int iTabIndex_wanted = M.GetDword(hContact, "tabindex", pContainer->iChilds * 100);
int iCount = TabCtrl_GetItemCount(hwndTab);
TCITEM item = {0};
int relPos;
int i;
pContainer->iTabIndex = iCount;
if (iCount > 0) {
for (i = iCount - 1; i >= 0; i--) {
item.mask = TCIF_PARAM;
TabCtrl_GetItem(hwndTab, i, &item);
HWND hwnd = (HWND)item.lParam;
TWindowData *dat = (TWindowData*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
if (dat) {
relPos = M.GetDword(dat->hContact, "tabindex", i * 100);
if (iTabIndex_wanted <= relPos)
pContainer->iTabIndex = i;
}
}
}
}
newItem = TabCtrl_InsertItem(hwndTab, pContainer->iTabIndex, &newData.item);
SendMessage(hwndTab, EM_REFRESHWITHOUTCLIP, 0, 0);
if (bActivateTab)
TabCtrl_SetCurSel(GetDlgItem(pContainer->hwnd, IDC_MSGTABS), newItem);
newData.iTabID = newItem;
newData.iTabImage = newData.item.iImage;
newData.pContainer = pContainer;
newData.iActivate = (int) bActivateTab;
pContainer->iChilds++;
newData.bWantPopup = bWantPopup;
newData.hdbEvent = hdbEvent;
HWND hwndNew = CreateDialogParam(g_hInst, MAKEINTRESOURCE(IDD_MSGSPLITNEW), GetDlgItem(pContainer->hwnd, IDC_MSGTABS), DlgProcMessage, (LPARAM)&newData);
/*
* switchbar support
*/
if (pContainer->dwFlags & CNT_SIDEBAR) {
TWindowData *dat = (TWindowData*)GetWindowLongPtr(hwndNew, GWLP_USERDATA);
if (dat)
pContainer->SideBar->addSession(dat, pContainer->iTabIndex);
}
SendMessage(pContainer->hwnd, WM_SIZE, 0, 0);
// if the container is minimized, then pop it up...
if (IsIconic(pContainer->hwnd)) {
if (bPopupContainer) {
SendMessage(pContainer->hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
SetFocus(pContainer->hwndActive);
}
else {
if (pContainer->dwFlags & CNT_NOFLASH)
SendMessage(pContainer->hwnd, DM_SETICON, 0, (LPARAM)LoadSkinnedIcon(SKINICON_EVENT_MESSAGE));
else
FlashContainer(pContainer, 1, 0);
}
}
if (bActivateTab) {
ActivateExistingTab(pContainer, hwndNew);
SetFocus(hwndNew);
RedrawWindow(pContainer->hwnd, NULL, NULL, RDW_ERASENOW);
UpdateWindow(pContainer->hwnd);
if (GetForegroundWindow() != pContainer->hwnd && bPopupContainer == TRUE)
SetForegroundWindow(pContainer->hwnd);
}
else if (!IsIconic(pContainer->hwnd) && IsWindowVisible(pContainer->hwnd)) {
SendMessage(pContainer->hwndActive, WM_SIZE, 0, 0);
RedrawWindow(pContainer->hwndActive, NULL, NULL, RDW_INVALIDATE | RDW_ALLCHILDREN | RDW_UPDATENOW);
RedrawWindow(pContainer->hwndActive, NULL, NULL, RDW_ERASENOW | RDW_UPDATENOW);
}
//MaD
if (PluginConfig.m_HideOnClose&&!IsWindowVisible(pContainer->hwnd)) {
WINDOWPLACEMENT wp={0};
wp.length = sizeof(wp);
GetWindowPlacement(pContainer->hwnd, &wp);
BroadCastContainer(pContainer, DM_CHECKSIZE, 0, 0); // make sure all tabs will re-check layout on activation
if (wp.showCmd == SW_SHOWMAXIMIZED)
ShowWindow(pContainer->hwnd, SW_SHOWMAXIMIZED);
else {
if (bPopupContainer)
ShowWindow(pContainer->hwnd, SW_SHOWNORMAL);
else
ShowWindow(pContainer->hwnd, SW_SHOWMINNOACTIVE);
}
SendMessage(pContainer->hwndActive, WM_SIZE, 0, 0);
}
if (PluginConfig.m_bIsWin7 && PluginConfig.m_useAeroPeek && CSkin::m_skinEnabled)
CWarning::show(CWarning::WARN_AEROPEEK_SKIN, MB_ICONWARNING|MB_OK);
if (ServiceExists(MS_HPP_EG_EVENT) && ServiceExists(MS_IEVIEW_EVENT) && db_get_b(0, "HistoryPlusPlus", "IEViewAPI", 0))
if (IDYES == CWarning::show(CWarning::WARN_HPP_APICHECK, MB_ICONWARNING|MB_YESNO))
db_set_b(0, "HistoryPlusPlus", "IEViewAPI", 0);
return hwndNew; // return handle of the new dialog
}
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) {
FILETIME ft;
TCHITTESTINFO thinfo;
GetSystemTimeAsFileTime(&ft);
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->clickLParam = lParam;
dat->clickWParam = wParam;
dat->lastClickTime = ft.dwLowDateTime;
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, dat->clickWParam, dat->clickLParam);
}
dat->bDragged = FALSE;
dat->bDragging = FALSE;
ReleaseCapture();
}
static INT_PTR CALLBACK OptionsDlgProc(HWND hdlg, UINT message, WPARAM wParam, LPARAM lParam)
{
OptionsPageData *opd;
OptionsDlgData *dat = (OptionsDlgData*)GetWindowLongPtr(hdlg, GWLP_USERDATA);
HWND hwndTree = GetDlgItem(hdlg, IDC_PAGETREE);
switch (message) {
case WM_CTLCOLORSTATIC:
switch (GetDlgCtrlID((HWND)lParam)) {
case IDC_WHITERECT:
case IDC_KEYWORD_FILTER:
SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
return (INT_PTR)GetSysColorBrush(COLOR_WINDOW);
}
break;
case WM_INITDIALOG:
TranslateDialogDefault(hdlg);
if (!ServiceExists(MS_MODERNOPT_SHOW))
ShowWindow(GetDlgItem(hdlg, IDC_MODERN), FALSE);
{
PROPSHEETHEADER *psh = (PROPSHEETHEADER*)lParam;
OPENOPTIONSDIALOG *ood = (OPENOPTIONSDIALOG*)psh->pStartPage;
COMBOBOXINFO cbi;
cbi.cbSize = sizeof(COMBOBOXINFO);
GetComboBoxInfo(GetDlgItem(hdlg, IDC_KEYWORD_FILTER), &cbi);
mir_subclassWindow(cbi.hwndItem, OptionsFilterSubclassProc);
if (IsAeroMode()) {
mir_subclassWindow(cbi.hwndCombo, AeroPaintSubclassProc);
mir_subclassWindow(cbi.hwndItem, AeroPaintSubclassProc);
}
Utils_RestoreWindowPositionNoSize(hdlg, NULL, "Options", "");
Window_SetIcon_IcoLib(hdlg, SKINICON_OTHER_OPTIONS);
EnableWindow(GetDlgItem(hdlg, IDC_APPLY), FALSE);
dat = new OptionsDlgData;
SetWindowLongPtr(hdlg, GWLP_USERDATA, (LONG_PTR)dat);
SetWindowText(hdlg, psh->pszCaption);
LOGFONT lf;
dat->hBoldFont = (HFONT)SendDlgItemMessage(hdlg, IDC_APPLY, WM_GETFONT, 0, 0);
GetObject(dat->hBoldFont, sizeof(lf), &lf);
lf.lfWeight = FW_BOLD;
dat->hBoldFont = CreateFontIndirect(&lf);
dat->hPluginLoad = HookEventMessage(ME_SYSTEM_MODULELOAD, hdlg, HM_MODULELOAD);
dat->hPluginUnload = HookEventMessage(ME_SYSTEM_MODULEUNLOAD, hdlg, HM_MODULEUNLOAD);
dat->currentPage = -1;
ptrT lastPage, lastGroup, lastTab;
if (ood->pszPage == NULL) {
lastPage = db_get_tsa(NULL, "Options", "LastPage");
if (ood->pszGroup == NULL)
lastGroup = db_get_tsa(NULL, "Options", "LastGroup");
else
lastGroup = mir_a2t(ood->pszGroup);
}
else {
lastPage = mir_a2t(ood->pszPage);
lastGroup = mir_a2t(ood->pszGroup);
}
if (ood->pszTab == NULL)
lastTab = db_get_tsa(NULL, "Options", "LastTab");
else
lastTab = mir_a2t(ood->pszTab);
OPTIONSDIALOGPAGE *odp = (OPTIONSDIALOGPAGE*)psh->ppsp;
for (UINT i = 0; i < psh->nPages; i++, odp++) {
opd = (OptionsPageData*)mir_calloc(sizeof(OptionsPageData));
if (!LoadOptionsPage(odp, opd)) {
mir_free(opd);
continue;
}
dat->arOpd.insert(opd);
if (!lstrcmp(lastPage, odp->ptszTitle) && !lstrcmpnull(lastGroup, odp->ptszGroup))
if ((ood->pszTab == NULL && dat->currentPage == -1) || !lstrcmpnull(lastTab, odp->ptszTab))
dat->currentPage = (int)i;
}
GetWindowRect(GetDlgItem(hdlg, IDC_STNOPAGE), &dat->rcDisplay);
MapWindowPoints(NULL, hdlg, (LPPOINT)&dat->rcDisplay, 2);
// Add an item to count in height
TCITEM tie;
tie.mask = TCIF_TEXT | TCIF_IMAGE;
tie.iImage = -1;
tie.pszText = _T("X");
TabCtrl_InsertItem(GetDlgItem(hdlg, IDC_TAB), 0, &tie);
GetWindowRect(GetDlgItem(hdlg, IDC_TAB), &dat->rcTab);
MapWindowPoints(NULL, hdlg, (LPPOINT)&dat->rcTab, 2);
TabCtrl_AdjustRect(GetDlgItem(hdlg, IDC_TAB), FALSE, &dat->rcTab);
FillFilterCombo(hdlg, dat);
PostMessage(hdlg, DM_REBUILDPAGETREE, 0, 0);
}
return TRUE;
case DM_REBUILDPAGETREE:
RebuildPageTree(hdlg, dat);
break;
case HM_MODULELOAD:
LoadOptionsModule(hdlg, dat, (HINSTANCE)lParam);
break;
case HM_MODULEUNLOAD:
UnloadOptionsModule(hdlg, dat, (HINSTANCE)lParam);
break;
case PSM_CHANGED:
EnableWindow(GetDlgItem(hdlg, IDC_APPLY), TRUE);
opd = dat->getCurrent();
if (opd)
opd->changed = 1;
return TRUE;
case PSM_GETBOLDFONT:
SetWindowLongPtr(hdlg, DWLP_MSGRESULT, (LONG_PTR)dat->hBoldFont);
return TRUE;
case WM_NOTIFY:
switch (wParam) {
case IDC_TAB:
case IDC_PAGETREE:
switch (((LPNMHDR)lParam)->code) {
case TVN_ITEMEXPANDING:
SetWindowLongPtr(hdlg, DWLP_MSGRESULT, FALSE);
return TRUE;
case TCN_SELCHANGING:
case TVN_SELCHANGING:
opd = dat->getCurrent();
if (opd && opd->hwnd != NULL) {
PSHNOTIFY pshn;
pshn.hdr.code = PSN_KILLACTIVE;
pshn.hdr.hwndFrom = dat->arOpd[dat->currentPage]->hwnd;
pshn.hdr.idFrom = 0;
pshn.lParam = 0;
if (SendMessage(dat->arOpd[dat->currentPage]->hwnd, WM_NOTIFY, 0, (LPARAM)&pshn)) {
SetWindowLongPtr(hdlg, DWLP_MSGRESULT, TRUE);
return TRUE;
}
}
break;
case TCN_SELCHANGE:
case TVN_SELCHANGED:
ShowWindow(GetDlgItem(hdlg, IDC_STNOPAGE), SW_HIDE);
opd = dat->getCurrent();
if (opd && opd->hwnd != NULL)
ShowWindow(opd->hwnd, SW_HIDE);
if (wParam != IDC_TAB) {
TVITEM tvi;
tvi.hItem = dat->hCurrentPage = TreeView_GetSelection(hwndTree);
if (tvi.hItem == NULL) {
ShowWindow(GetDlgItem(hdlg, IDC_TAB), SW_HIDE);
break;
}
tvi.mask = TVIF_HANDLE | TVIF_PARAM;
TreeView_GetItem(hwndTree, &tvi);
dat->currentPage = tvi.lParam;
ShowWindow(GetDlgItem(hdlg, IDC_TAB), SW_HIDE);
}
else {
TCITEM tie;
tie.mask = TCIF_PARAM;
TabCtrl_GetItem(GetDlgItem(hdlg, IDC_TAB), TabCtrl_GetCurSel(GetDlgItem(hdlg, IDC_TAB)), &tie);
dat->currentPage = tie.lParam;
TVITEM tvi;
tvi.hItem = dat->hCurrentPage;
tvi.mask = TVIF_PARAM;
tvi.lParam = dat->currentPage;
TreeView_SetItem(hwndTree, &tvi);
}
opd = dat->getCurrent();
if (opd == NULL) {
ShowWindow(GetDlgItem(hdlg, IDC_STNOPAGE), SW_SHOW);
break;
}
if (opd->hwnd == NULL) {
opd->hwnd = CreateDialogIndirectParamA(opd->hInst, opd->pTemplate, hdlg, opd->dlgProc, opd->dwInitParam);
if (opd->flags & ODPF_BOLDGROUPS)
EnumChildWindows(opd->hwnd, BoldGroupTitlesEnumChildren, (LPARAM)dat->hBoldFont);
RECT rcPage;
GetClientRect(opd->hwnd, &rcPage);
int w = opd->width = rcPage.right;
int h = opd->height = rcPage.bottom;
RECT rc;
GetWindowRect(opd->hwnd, &rc);
opd->offsetX = 0;
opd->offsetY = 0;
opd->insideTab = IsInsideTab(hdlg, dat, dat->currentPage);
if (opd->insideTab) {
SetWindowPos(opd->hwnd, HWND_TOP, (dat->rcTab.left + dat->rcTab.right - w) >> 1, dat->rcTab.top, w, h, 0);
ThemeDialogBackground(opd->hwnd, TRUE);
}
else {
SetWindowPos(opd->hwnd, HWND_TOP, (dat->rcDisplay.left + dat->rcDisplay.right - w) >> 1, (dat->rcDisplay.top + dat->rcDisplay.bottom - h) >> 1, w, h, 0);
ThemeDialogBackground(opd->hwnd, FALSE);
}
}
if (wParam != IDC_TAB) {
opd->insideTab = IsInsideTab(hdlg, dat, dat->currentPage);
if (opd->insideTab) {
// Make tabbed pane
int pages = 0, sel = 0;
HWND hwndTab = GetDlgItem(hdlg, IDC_TAB);
TabCtrl_DeleteAllItems(hwndTab);
TCITEM tie;
tie.mask = TCIF_TEXT | TCIF_IMAGE | TCIF_PARAM;
tie.iImage = -1;
for (int i = 0; i < dat->arOpd.getCount(); i++) {
if (!CheckPageShow(hdlg, dat, i))
continue;
OptionsPageData *p = dat->arOpd[i];
if (lstrcmp(opd->ptszTitle, p->ptszTitle) || lstrcmpnull(opd->ptszGroup, p->ptszGroup))
continue;
tie.pszText = TranslateTH(p->hLangpack, p->ptszTab);
tie.lParam = i;
TabCtrl_InsertItem(hwndTab, pages, &tie);
if (!lstrcmp(opd->ptszTab, p->ptszTab))
sel = pages;
pages++;
}
TabCtrl_SetCurSel(hwndTab, sel);
ShowWindow(hwndTab, opd->insideTab ? SW_SHOW : SW_HIDE);
}
if (opd->insideTab)
ThemeDialogBackground(opd->hwnd, TRUE);
else
ThemeDialogBackground(opd->hwnd, FALSE);
}
ShowWindow(opd->hwnd, SW_SHOW);
if (((LPNMTREEVIEW)lParam)->action == TVC_BYMOUSE)
PostMessage(hdlg, DM_FOCUSPAGE, 0, 0);
else
SetFocus(hwndTree);
}
void CConsoleOutputFilterDlg::OnInitDialog(HWND hDlg)
{
TC_ITEM tie;
// dialog items initialization
m_hWnd = hDlg;
m_hBrushBkCheckbox = ::CreateSolidBrush(RGB_BK_CHECKBOX);
s_hDlg = hDlg;
s_hMsgHook = ::SetWindowsHookEx(WH_GETMESSAGE, GetMsgProc, NULL, GetCurrentThreadId());
for ( int i = 0; i < DLG_COUNT; i++ )
{
m_hTabDlg[i] = NULL;
}
m_hTabs = CreateWindowEx( 0
, WC_TABCONTROL
, _T("coucou")
, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | WS_TABSTOP | WS_GROUP | TCS_HOTTRACK
, 10, 10, 575, 440
, hDlg
, NULL
, (HINSTANCE)Runtime::GetNppExec().m_hDllModule
, NULL
);
if ( m_hTabs )
{
HFONT hFont = (HFONT) SendMessage( hDlg, WM_GETFONT, 0, 0 );
SendMessage( m_hTabs, WM_SETFONT, (WPARAM) hFont, 0 );
}
// adding tabs...
tie.mask = TCIF_TEXT;
tie.pszText = (LPTSTR) _T("Filter");
TabCtrl_InsertItem(m_hTabs, 1, &tie);
tie.pszText = (LPTSTR) _T("Replace");
TabCtrl_InsertItem(m_hTabs, 2, &tie);
tie.pszText = (LPTSTR) _T("HighLight");
TabCtrl_InsertItem(m_hTabs, 3, &tie);
// set active tab
NMHDR nmh;
nmh.code = TCN_SELCHANGE;
nmh.hwndFrom = m_hTabs;
nmh.idFrom = 0;
TabCtrl_SetCurSel(m_hTabs, m_nLastTab); // initially: Highlight tab
// (see the constructor)
SendMsg( WM_NOTIFY, 0, (LPARAM) &nmh );
// resizing
HWND hClient = NULL;
for ( int i = 0; i < DLG_COUNT; i++ )
{
if ( m_hTabDlg[i] )
{
hClient = m_hTabDlg[i];
break;
}
}
if ( hClient )
{
RECT rcClientWnd;
if ( ::GetWindowRect(hClient, &rcClientWnd) )
{
RECT rcWnd;
RECT rcClnt;
int width;
int height;
::GetWindowRect(m_hTabs, &rcWnd);
//::GetClientRect(m_hTabs, &rcClnt);
// GetClientRect for m_hTabs returns the same width & height
// as GetWindowRect. VERY usefull, isn't it?
width = (rcClientWnd.right - rcClientWnd.left) + 6;
height = (rcClientWnd.bottom - rcClientWnd.top) + 29;
::MoveWindow(m_hTabs, 10, 10, width, height, FALSE);
if ( ::GetWindowRect(m_hTabs, &rcClientWnd) )
{
::GetWindowRect(hDlg, &rcWnd);
::GetClientRect(hDlg, &rcClnt);
width = (rcClientWnd.right - rcClientWnd.left) + 20 +
(rcWnd.right - rcWnd.left) - (rcClnt.right - rcClnt.left);
height = rcWnd.bottom - rcWnd.top;
::MoveWindow(
hDlg,
0,
0,
width,
height,
FALSE
);
}
}
}
// finally...
this->CenterWindow(Runtime::GetNppExec().m_nppData._nppHandle);
}
static BOOL CALLBACK ConfigProc(HWND wnd, UINT msg, WPARAM wp, LPARAM lp)
{
switch (msg)
{
case WM_INITDIALOG:
{
uTCITEM tabs;
memset(&tabs, 0, sizeof(tabs));
HWND wnd_tab = GetDlgItem(wnd, IDC_TAB1);
tabs.mask = TCIF_TEXT;
tabs.pszText = "Variables";
uTabCtrl_InsertItem(wnd_tab, 0, &tabs);
tabs.pszText = "Style";
uTabCtrl_InsertItem(wnd_tab, 1, &tabs);
TabCtrl_SetCurSel(wnd_tab, g_cur_tab2);
uSendDlgItemMessageText(wnd, IDC_CHAR7, WM_SETTEXT, 0, "\x07");
colour_code_gen(wnd, IDC_COLOUR, false, true);
uSendDlgItemMessage(wnd, IDC_STRING, EM_LIMITTEXT, 0, 0);
refresh_me(wnd);
editproc = (WNDPROC)SetWindowLongPtr(GetDlgItem(wnd, IDC_STRING), GWLP_WNDPROC, (LPARAM)EditHook);
g_editor_font_notify.set(GetDlgItem(wnd, IDC_STRING));
}
break;
case WM_NOTIFY:
switch (((LPNMHDR)lp)->idFrom)
{
case IDC_TAB1:
switch (((LPNMHDR)lp)->code)
{
case TCN_SELCHANGE:
{
save_string(wnd);
int id = TabCtrl_GetCurSel(GetDlgItem(wnd, IDC_TAB1));
g_cur_tab2 = id;
uSendDlgItemMessageText(wnd, IDC_STRING, WM_SETTEXT, 0, (g_cur_tab2 == 0 ? cfg_globalstring : cfg_colour));
}
break;
}
break;
}
break;
case WM_DESTROY:
{
g_editor_font_notify.release();
save_string(wnd);
refresh_all_playlist_views();
pvt::ng_playlist_view_t::g_update_all_items();
}
break;
case WM_COMMAND:
switch (wp)
{
case IDC_GLOBAL:
cfg_global = uSendMessage((HWND)lp, BM_GETCHECK, 0, 0);
break;
case IDC_DATE:
cfg_playlist_date = uSendMessage((HWND)lp, BM_GETCHECK, 0, 0);
set_day_timer();
pvt::ng_playlist_view_t::g_on_use_date_info_change();
break;
case IDC_TFHELP:
{
RECT rc;
GetWindowRect(GetDlgItem(wnd, IDC_TFHELP), &rc);
// MapWindowPoints(HWND_DESKTOP, wnd, (LPPOINT)(&rc), 2);
HMENU menu = CreatePopupMenu();
enum { IDM_TFHELP = 1, IDM_GHELP = 2, IDM_SPEEDTEST, IDM_PREVIEW, IDM_EDITORFONT, IDM_RESETSTYLE };
uAppendMenu(menu, (MF_STRING), IDM_TFHELP, "Titleformatting &help");
uAppendMenu(menu, (MF_STRING), IDM_GHELP, "&Global help");
uAppendMenu(menu, (MF_SEPARATOR), 0, "");
uAppendMenu(menu, (MF_STRING), IDM_SPEEDTEST, "&Speed test");
uAppendMenu(menu, (MF_STRING), IDM_PREVIEW, "&Preview to console");
uAppendMenu(menu, (MF_SEPARATOR), 0, "");
uAppendMenu(menu, (MF_STRING), IDM_EDITORFONT, "Change editor &font");
uAppendMenu(menu, (MF_SEPARATOR), 0, "");
uAppendMenu(menu, (MF_STRING), IDM_RESETSTYLE, "&Reset style string");
int cmd = TrackPopupMenu(menu, TPM_LEFTBUTTON | TPM_NONOTIFY | TPM_RETURNCMD, rc.left, rc.bottom, 0, wnd, 0);
DestroyMenu(menu);
if (cmd == IDM_TFHELP)
{
standard_commands::main_titleformat_help();
}
else if (cmd == IDM_GHELP)
{
uMessageBox(wnd, COLOUR_HELP "\n\nNew global format: $set_global(var, val), retreive values using $get_global(var)", "Global help", 0);
}
else if (cmd == IDM_SPEEDTEST)
{
speedtest(g_columns, cfg_global != 0, cfg_oldglobal != 0, cfg_playlist_date != 0);
}
else if (cmd == IDM_PREVIEW)
{
preview_to_console(string_utf8_from_window(wnd, IDC_STRING), g_cur_tab2 != 0 && cfg_global);
}
else if (cmd == IDM_EDITORFONT)
{
if (font_picker(wnd, cfg_editor_font))
g_editor_font_notify.on_change();
}
else if (cmd == IDM_RESETSTYLE)
{
extern const char * g_default_colour;
cfg_colour = g_default_colour;
if (g_cur_tab2 == 1)
uSendDlgItemMessageText(wnd, IDC_STRING, WM_SETTEXT, 0, cfg_colour);
refresh_all_playlist_views();
pvt::ng_playlist_view_t::g_update_all_items();
}
}
break;
case IDC_OLDGLOBAL:
cfg_oldglobal = uSendMessage((HWND)lp, BM_GETCHECK, 0, 0);
break;
case IDC_GLOBALSORT:
cfg_global_sort = uSendMessage((HWND)lp, BM_GETCHECK, 0, 0);
break;
case IDC_APPLY:
save_string(wnd);
refresh_all_playlist_views();
pvt::ng_playlist_view_t::g_update_all_items();
break;
case IDC_PICK_COLOUR:
colour_code_gen(wnd, IDC_COLOUR, false, false);
break;
}
}
return 0;
}
void
mxTab::select (int index)
{
TabCtrl_SetCurSel ((HWND) getHandle (), index);
}
INT_PTR CDialogPackage::OnCommand(WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam))
{
case IDC_PACKAGE_NEXT_BUTTON:
{
HWND item = GetDlgItem(m_Window, IDC_PACKAGE_TAB);
TCITEM tci = {0};
tci.mask = TCIF_TEXT;
tci.pszText = L"Options";
TabCtrl_InsertItem(item, 0, &tci);
tci.pszText = L"Advanced";
TabCtrl_InsertItem(item, 1, &tci);
item = GetDlgItem(m_Window, IDC_PACKAGE_NEXT_BUTTON);
ShowWindow(item, SW_HIDE);
item = GetDlgItem(m_Window, IDC_PACKAGE_CREATEPACKAGE_BUTTON);
ShowWindow(item, SW_SHOWNORMAL);
SendMessage(m_Window, DM_SETDEFID, IDC_PACKAGE_CREATEPACKAGE_BUTTON, 0);
ShowWindow(m_TabInfo.GetWindow(), SW_HIDE);
m_TabOptions.Activate();
}
break;
case IDC_PACKAGE_CREATEPACKAGE_BUTTON:
{
HWND item = GetDlgItem(m_Window, IDC_PACKAGE_CREATEPACKAGE_BUTTON);
EnableWindow(item, FALSE);
item = GetDlgItem(m_Window, IDCANCEL);
EnableWindow(item, FALSE);
m_TabOptions.Activate();
item = GetDlgItem(m_Window, IDC_PACKAGE_TAB);
TabCtrl_SetCurSel(item, 0);
EnableWindow(item, FALSE);
EnableWindow(m_TabOptions.GetWindow(), FALSE);
EnableWindow(m_TabAdvanced.GetWindow(), FALSE);
item = GetDlgItem(m_TabOptions.GetWindow(), IDC_INSTALLTAB_CREATING_TEXT);
ShowWindow(item, SW_SHOWNORMAL);
item = GetDlgItem(m_TabOptions.GetWindow(), IDC_INSTALLTAB_CREATING_BAR);
ShowWindow(item, SW_SHOWNORMAL);
SendMessage(item, PBM_SETMARQUEE, (WPARAM)TRUE, 0);
m_PackagerThread = (HANDLE)_beginthreadex(NULL, 0, PackagerThreadProc, this, 0, NULL);
if (!m_PackagerThread)
{
MessageBox(m_Window, L"Unknown error.", L"Rainmeter Skin Packager", MB_ERROR);
EndDialog(m_Window, 0);
}
}
break;
case IDCANCEL:
if (!m_PackagerThread)
{
EndDialog(m_Window, 0);
}
break;
default:
return FALSE;
}
return TRUE;
}
HRESULT _stdcall CContainer::DragOver(DWORD grfKeyState,POINTL pt,DWORD *pdwEffect)
{
TCHITTESTINFO HitTestInfo;
BOOL bOnSameDrive;
int iTab;
HitTestInfo.pt.x = pt.x;
HitTestInfo.pt.y = pt.y;
ScreenToClient(m_hTabCtrl,&HitTestInfo.pt);
iTab = TabCtrl_HitTest(m_hTabCtrl,&HitTestInfo);
if(iTab == -1)
{
*pdwEffect = DROPEFFECT_NONE;
}
else
{
TCITEM tcItem;
tcItem.mask = TCIF_PARAM;
TabCtrl_GetItem(m_hTabCtrl,iTab,&tcItem);
if(iTab != m_iTabSelectedItem)
{
/* Set a timer. If the mouse does not move
outside this tab before the timer expires,
and the item is still been dragged, switch
focus to this tab.
The timer will be set if the tab the item
is currently above does not match the
tab it was above initially (when the timer
was previously set). */
if(iTab != m_iTabDragTab)
{
SetTimer(m_hTabCtrl,TABDRAG_TIMER_ID,TABDRAG_TIMER_ELAPSED,TabDragTimerProc);
m_iTabDragTab = iTab;
}
else if(g_bTabDragTimerElapsed)
{
m_iTabSelectedItem = iTab;
TabCtrl_SetCurSel(m_hTabCtrl,m_iTabSelectedItem);
OnTabChangeInternal(TRUE);
g_bTabDragTimerElapsed = FALSE;
}
}
else
{
KillTimer(m_hTabCtrl,TABDRAG_TIMER_ID);
m_iTabDragTab = iTab;
}
/* If the tab contains a virtual folder,
then files cannot be dropped. */
if(m_pShellBrowser[(int)tcItem.lParam]->InVirtualFolder())
{
*pdwEffect = DROPEFFECT_NONE;
}
else
{
bOnSameDrive = CheckItemLocations((int)tcItem.lParam);
*pdwEffect = DetermineCurrentDragEffect(grfKeyState,
*pdwEffect,m_bDataAccept,bOnSameDrive);
}
}
m_pDropTargetHelper->DragOver((LPPOINT)&pt,*pdwEffect);
return S_OK;
}
void Explorerplusplus::SetTabSelection(int Index)
{
m_iTabSelectedItem = Index;
TabCtrl_SetCurSel(m_hTabCtrl,m_iTabSelectedItem);
OnTabChangeInternal(TRUE);
}
BOOL CDisasm::DlgProc(UINT message, WPARAM wParam, LPARAM lParam)
{
//if (!m_hDlg) return FALSE;
switch(message)
{
case WM_INITDIALOG:
{
return TRUE;
}
break;
case WM_NOTIFY:
switch (wParam)
{
case IDC_LEFTTABS:
leftTabs->HandleNotify(lParam);
break;
case IDC_BREAKPOINTLIST:
breakpointList->HandleNotify(lParam);
break;
case IDC_THREADLIST:
threadList->HandleNotify(lParam);
break;
case IDC_STACKFRAMES:
stackTraceView->HandleNotify(lParam);
break;
case IDC_DEBUG_BOTTOMTABS:
bottomTabs->HandleNotify(lParam);
break;
}
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 ID_TOGGLE_PAUSE:
SendMessage(MainWindow::GetHWND(),WM_COMMAND,ID_TOGGLE_PAUSE,0);
break;
case ID_DEBUG_DISPLAYMEMVIEW:
bottomTabs->ShowTab(GetDlgItem(m_hDlg,IDC_DEBUGMEMVIEW));
break;
case ID_DEBUG_DISPLAYBREAKPOINTLIST:
bottomTabs->ShowTab(breakpointList->GetHandle());
break;
case ID_DEBUG_DISPLAYTHREADLIST:
bottomTabs->ShowTab(threadList->GetHandle());
break;
case ID_DEBUG_DISPLAYSTACKFRAMELIST:
bottomTabs->ShowTab(stackTraceView->GetHandle());
break;
case ID_DEBUG_DSIPLAYREGISTERLIST:
TabCtrl_SetCurSel(GetDlgItem(m_hDlg, IDC_LEFTTABS),0);
ShowWindow(GetDlgItem(m_hDlg, IDC_REGLIST), SW_NORMAL);
ShowWindow(GetDlgItem(m_hDlg, IDC_FUNCTIONLIST), SW_HIDE);
break;
case ID_DEBUG_DSIPLAYFUNCTIONLIST:
TabCtrl_SetCurSel(GetDlgItem(m_hDlg, IDC_LEFTTABS),1);
ShowWindow(GetDlgItem(m_hDlg, IDC_REGLIST), SW_HIDE);
ShowWindow(GetDlgItem(m_hDlg, IDC_FUNCTIONLIST), SW_NORMAL);
break;
case ID_DEBUG_ADDBREAKPOINT:
{
keepStatusBarText = true;
bool isRunning = Core_IsActive();
if (isRunning)
{
SetDebugMode(true, false);
Core_EnableStepping(true);
Core_WaitInactive(200);
}
BreakpointWindow bpw(m_hDlg,cpu);
if (bpw.exec()) bpw.addBreakpoint();
if (isRunning)
{
SetDebugMode(false, false);
Core_EnableStepping(false);
}
keepStatusBarText = false;
}
break;
case ID_DEBUG_STEPOVER:
if (GetFocus() == GetDlgItem(m_hDlg,IDC_DISASMVIEW)) stepOver();
break;
case ID_DEBUG_STEPINTO:
if (GetFocus() == GetDlgItem(m_hDlg,IDC_DISASMVIEW)) stepInto();
break;
case ID_DEBUG_RUNTOLINE:
if (GetFocus() == GetDlgItem(m_hDlg,IDC_DISASMVIEW)) runToLine();
break;
case ID_DEBUG_STEPOUT:
if (GetFocus() == GetDlgItem(m_hDlg,IDC_DISASMVIEW)) stepOut();
break;
case ID_DEBUG_HIDEBOTTOMTABS:
{
RECT rect;
hideBottomTabs = !hideBottomTabs;
GetClientRect(m_hDlg,&rect);
UpdateSize(rect.right-rect.left,rect.bottom-rect.top);
}
break;
case ID_DEBUG_TOGGLEBOTTOMTABTITLES:
bottomTabs->SetShowTabTitles(!bottomTabs->GetShowTabTitles());
break;
case IDC_SHOWVFPU:
vfpudlg->Show(true);
break;
case IDC_FUNCTIONLIST:
switch (HIWORD(wParam))
{
case CBN_DBLCLK:
{
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);
SetFocus(GetDlgItem(m_hDlg, IDC_DISASMVIEW));
}
}
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);
SetFocus(GetDlgItem(m_hDlg, IDC_DISASMVIEW));
}
}
break;
};
break;
case IDC_STOPGO:
{
if (!Core_IsStepping()) // stop
{
ptr->setDontRedraw(false);
SetDebugMode(true, true);
Core_EnableStepping(true);
_dbg_update_();
Sleep(1); //let cpu catch up
ptr->gotoPC();
UpdateDialog();
vfpudlg->Update();
} else { // go
lastTicks = CoreTiming::GetTicks();
// If the current PC is on a breakpoint, the user doesn't want to do nothing.
CBreakPoints::SetSkipFirst(currentMIPS->pc);
SetDebugMode(false, true);
Core_EnableStepping(false);
}
}
break;
case IDC_STEP:
stepInto();
break;
case IDC_STEPOVER:
stepOver();
break;
case IDC_STEPOUT:
stepOut();
break;
case IDC_STEPHLE:
{
if (Core_IsActive())
break;
lastTicks = CoreTiming::GetTicks();
// If the current PC is on a breakpoint, the user doesn't want to do nothing.
CBreakPoints::SetSkipFirst(currentMIPS->pc);
hleDebugBreak();
SetDebugMode(false, true);
_dbg_update_();
Core_EnableStepping(false);
}
break;
case IDC_MEMCHECK:
SendMessage(m_hDlg,WM_COMMAND,ID_DEBUG_ADDBREAKPOINT,0);
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, ConvertUTF8ToWString(symbolMap.GetDescription(pc)).c_str()), pc);
if (symbolMap.GetDescription(pc) != symbolMap.GetDescription(ra))
{
ComboBox_SetItemData(list, ComboBox_AddString(list, ConvertUTF8ToWString(symbolMap.GetDescription(ra)).c_str()), ra);
count++;
}
//walk the stack chain
while (addr != 0xFFFFFFFF && addr!=0 && count++<20)
{
DWORD fun = Memory::ReadUnchecked_U32(addr+4);
const wchar_t *str = ConvertUTF8ToWString(symbolMap.GetDescription(fun)).c_str();
if (wcslen(str) == 0)
str = L"(unknown)";
ComboBox_SetItemData(list, ComboBox_AddString(list,str), fun);
addr = Memory::ReadUnchecked_U32(addr);
}
ComboBox_SetCurSel(list,0);
}
break;
case IDC_GOTOPC:
{
ptr->gotoPC();
SetFocus(GetDlgItem(m_hDlg, IDC_DISASMVIEW));
UpdateDialog();
}
break;
case IDC_GOTOLR:
{
ptr->gotoAddr(cpu->GetLR());
SetFocus(GetDlgItem(m_hDlg, IDC_DISASMVIEW));
}
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_DEB_MAPLOADED:
NotifyMapLoaded();
break;
case WM_DEB_GOTOWPARAM:
{
CtrlDisAsmView *ptr = CtrlDisAsmView::getFrom(GetDlgItem(m_hDlg,IDC_DISASMVIEW));
ptr->gotoAddr(wParam);
SetFocus(GetDlgItem(m_hDlg,IDC_DISASMVIEW));
break;
}
case WM_DEB_GOTOADDRESSEDIT:
{
wchar_t szBuffer[256];
CtrlDisAsmView *ptr = CtrlDisAsmView::getFrom(GetDlgItem(m_hDlg,IDC_DISASMVIEW));
GetWindowText(GetDlgItem(m_hDlg,IDC_ADDRESS),szBuffer,256);
u32 addr;
if (parseExpression(ConvertWStringToUTF8(szBuffer).c_str(),cpu,addr) == false)
{
displayExpressionError(GetDlgItem(m_hDlg,IDC_ADDRESS));
} else {
ptr->gotoAddr(addr);
SetFocus(GetDlgItem(m_hDlg, IDC_DISASMVIEW));
}
UpdateDialog();
}
break;
case WM_DEB_SETDEBUGLPARAM:
SetDebugMode(lParam != 0, true);
return TRUE;
case WM_DEB_UPDATE:
Update();
return TRUE;
case WM_DEB_TABPRESSED:
bottomTabs->NextTab(true);
SetFocus(bottomTabs->CurrentTabHandle());
break;
case WM_DEB_SETSTATUSBARTEXT:
if (!keepStatusBarText)
SendMessage(statusBarWnd,WM_SETTEXT,0,(LPARAM)ConvertUTF8ToWString((const char *)lParam).c_str());
break;
case WM_DEB_GOTOHEXEDIT:
{
CtrlMemView *memory = CtrlMemView::getFrom(GetDlgItem(m_hDlg,IDC_DEBUGMEMVIEW));
memory->gotoAddr(wParam);
// display the memory viewer too
HWND bp = GetDlgItem(m_hDlg, IDC_BREAKPOINTLIST);
HWND mem = GetDlgItem(m_hDlg, IDC_DEBUGMEMVIEW);
HWND threads = GetDlgItem(m_hDlg, IDC_THREADLIST);
ShowWindow(bp,SW_HIDE);
ShowWindow(mem,SW_NORMAL);
ShowWindow(threads,SW_HIDE);
}
break;
case WM_SIZE:
{
UpdateSize(LOWORD(lParam), HIWORD(lParam));
SendMessage(statusBarWnd,WM_SIZE,0,10);
SavePosition();
return TRUE;
}
case WM_MOVE:
SavePosition();
break;
case WM_GETMINMAXINFO:
{
MINMAXINFO *m = (MINMAXINFO *)lParam;
// Reduce the minimum size slightly, so they can size it however they like.
m->ptMinTrackSize.x = minWidth;
//m->ptMaxTrackSize.x = m->ptMinTrackSize.x;
m->ptMinTrackSize.y = minHeight;
}
return TRUE;
case WM_CLOSE:
Show(false);
return TRUE;
case WM_ACTIVATE:
if (wParam == WA_ACTIVE || wParam == WA_CLICKACTIVE)
{
g_activeWindow = WINDOW_CPUDEBUGGER;
}
break;
}
return FALSE;
}
INT_PTR CALLBACK DlgAddGameProcMain(HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
TCITEMA tci = { 0 };
int iTotal;
RECT rcClient;
//icon des dialogs setzen
SendMessage(hwndDlg, WM_SETICON, (WPARAM)false, (LPARAM)LoadIcon(hinstance, MAKEINTRESOURCE(IDI_TM)));
hwndTab = GetDlgItem(hwndDlg, IDC_OPTIONSTAB);
TabCtrl_DeleteAllItems(hwndTab);
GetClientRect(GetParent(hwndTab), &rcClient);
hPage = CreateDialog(hinstance, MAKEINTRESOURCE(IDD_ADDGAME), hwndDlg, DlgAddGameProc);
//bei editgame keine spiellisteauswahl
if (!editgame)
{
iTotal = TabCtrl_GetItemCount(hwndTab);
tci.mask = TCIF_PARAM | TCIF_TEXT;
tci.lParam = (LPARAM)hPage;
tci.pszText = Translate("Supported Games");
SendMessageA(hwndTab, TCM_INSERTITEMA, iTotal, (WPARAM)&tci);
MoveWindow(hPage, 3, 24, rcClient.right - 10, rcClient.bottom - 28, 1);
iTotal++;
}
else
ShowWindow(hPage, FALSE);
hPage = CreateDialog(hinstance, MAKEINTRESOURCE(IDD_ADDGAME2), hwndDlg, DlgAddGameProc2);
iTotal = TabCtrl_GetItemCount(hwndTab);
tci.mask = TCIF_PARAM | TCIF_TEXT;
tci.lParam = (LPARAM)hPage;
tci.pszText = Translate("Custom game");
SendMessageA(hwndTab, TCM_INSERTITEMA, iTotal, (WPARAM)&tci);
MoveWindow(hPage, 3, 24, rcClient.right - 10, rcClient.bottom - 28, 1);
iTotal++;
//bei editgame 2. registerkarte aktiv schalten
if (!editgame) {
ShowWindow(hPage, FALSE);
TabCtrl_SetCurSel(hwndTab, 0);
}
return TRUE;
}
case WM_CLOSE:
//nicht schließen, wenn noch der thread läuft
if (dontClose) return FALSE;
//buffer leeren
if (buffer)
{
delete[] buffer;
buffer = NULL;
}
EndDialog(hwndDlg, 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(hwndDlg, IDC_OPTIONSTAB));
for (i = 0; i < count; i++)
{
TabCtrl_GetItem(GetDlgItem(hwndDlg, IDC_OPTIONSTAB), i, &tci);
SendMessage((HWND)tci.lParam, WM_NOTIFY, 0, lParam);
}
break;
}
}
break;
case IDC_OPTIONSTAB:
{
HWND hTabCtrl = GetDlgItem(hwndDlg, IDC_OPTIONSTAB);
switch (((LPNMHDR)lParam)->code)
{
case TCN_SELCHANGING:
{
TCITEM tci;
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(hTabCtrl, TabCtrl_GetCurSel(hTabCtrl), &tci);
ShowWindow((HWND)tci.lParam, SW_HIDE);
}
break;
case TCN_SELCHANGE:
{
TCITEM tci;
tci.mask = TCIF_PARAM;
TabCtrl_GetItem(hTabCtrl, TabCtrl_GetCurSel(hTabCtrl), &tci);
ShowWindow((HWND)tci.lParam, SW_SHOW);
}
break;
}
break;
}
}
break;
}
return FALSE;
}
LRESULT CALLBACK Config(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
#define TABS 8
static char TabTitles[TABS][10]={"Audio","CPU","Display","Keyboard","Joysticks","Misc","Tape","BitBanger"};
static unsigned char TabCount=0,SelectedTab=0;
static HWND hWndTabDialog;
static HWND g_hWndConfig[TABS];
TCITEM Tabs;
switch (message)
{
case WM_INITDIALOG:
InitCommonControls();
TempConfig=CurrentConfig;
CpuIcons[0]=LoadIcon(EmuState.WindowInstance,(LPCTSTR)IDI_MOTO);
CpuIcons[1]=LoadIcon(EmuState.WindowInstance,(LPCTSTR)IDI_HITACHI2);
MonIcons[0]=LoadIcon(EmuState.WindowInstance,(LPCTSTR)IDI_COMPOSITE);
MonIcons[1]=LoadIcon(EmuState.WindowInstance,(LPCTSTR)IDI_RGB);
hWndTabDialog= GetDlgItem(hDlg,IDC_CONFIGTAB); //get handle of Tabbed Dialog
//get handles to all the sub panels in the control
g_hWndConfig[0]=CreateDialog(EmuState.WindowInstance,MAKEINTRESOURCE(IDD_AUDIO),hWndTabDialog,(DLGPROC) AudioConfig);
g_hWndConfig[1]=CreateDialog(EmuState.WindowInstance,MAKEINTRESOURCE(IDD_CPU),hWndTabDialog,(DLGPROC) CpuConfig);
g_hWndConfig[2]=CreateDialog(EmuState.WindowInstance,MAKEINTRESOURCE(IDD_DISPLAY),hWndTabDialog,(DLGPROC) DisplayConfig);
g_hWndConfig[3]=CreateDialog(EmuState.WindowInstance,MAKEINTRESOURCE(IDD_INPUT),hWndTabDialog,(DLGPROC) InputConfig);
g_hWndConfig[4]=CreateDialog(EmuState.WindowInstance,MAKEINTRESOURCE(IDD_JOYSTICK),hWndTabDialog,(DLGPROC) JoyStickConfig);
g_hWndConfig[5]=CreateDialog(EmuState.WindowInstance,MAKEINTRESOURCE(IDD_MISC),hWndTabDialog,(DLGPROC) MiscConfig);
g_hWndConfig[6]=CreateDialog(EmuState.WindowInstance,MAKEINTRESOURCE(IDD_CASSETTE),hWndTabDialog,(DLGPROC) TapeConfig);
g_hWndConfig[7]=CreateDialog(EmuState.WindowInstance,MAKEINTRESOURCE(IDD_BITBANGER),hWndTabDialog,(DLGPROC) BitBanger);
//Set the title text for all tabs
for (TabCount=0;TabCount<TABS;TabCount++)
{
Tabs.mask= TCIF_TEXT | TCIF_IMAGE;
Tabs.iImage=-1;
Tabs.pszText=TabTitles[TabCount];
TabCtrl_InsertItem(hWndTabDialog,TabCount,&Tabs);
}
TabCtrl_SetCurSel(hWndTabDialog,0); //Set Initial Tab to 0
for (TabCount = 0; TabCount < TABS; TabCount++) //Hide All the Sub Panels
{
ShowWindow(g_hWndConfig[TabCount], SW_HIDE);
}
SetWindowPos(g_hWndConfig[0], HWND_TOP, 10, 30, 0, 0, SWP_NOSIZE | SWP_SHOWWINDOW);
RefreshJoystickStatus();
break;
case WM_NOTIFY:
if ((LOWORD(wParam))==IDC_CONFIGTAB)
{
SelectedTab=TabCtrl_GetCurSel(hWndTabDialog);
for (TabCount=0;TabCount<TABS;TabCount++)
ShowWindow(g_hWndConfig[TabCount],SW_HIDE);
SetWindowPos(g_hWndConfig[SelectedTab],HWND_TOP,10,30,0,0,SWP_NOSIZE|SWP_SHOWWINDOW);
}
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
hDlgBar=NULL;
hDlgTape=NULL;
EmuState.ResetPending = VCC_RESET_PENDING_UPDATECONFIG;
if ((CurrentConfig.RamSize != TempConfig.RamSize) | (CurrentConfig.CpuType != TempConfig.CpuType))
{
EmuState.ResetPending = VCC_RESET_PENDING_HARD;
}
if ((CurrentConfig.SndOutDev != TempConfig.SndOutDev) | (CurrentConfig.AudioRate != TempConfig.AudioRate))
{
SoundInit(EmuState.WindowHandle, SoundCards[TempConfig.SndOutDev].Guid, TempConfig.AudioRate);
}
CurrentConfig=TempConfig;
vccKeyboardBuildRuntimeTable((keyboardlayout_e)CurrentConfig.KeyMap);
Right=TempRight;
Left=TempLeft;
SetStickNumbers(Left.DiDevice,Right.DiDevice);
for (temp = 0; temp < TABS; temp++)
{
DestroyWindow(g_hWndConfig[temp]);
}
#ifdef CONFIG_DIALOG_MODAL
EndDialog(hDlg, LOWORD(wParam));
#else
DestroyWindow(hDlg);
#endif
EmuState.ConfigDialog=NULL;
break;
case IDAPPLY:
EmuState.ResetPending = VCC_RESET_PENDING_UPDATECONFIG;
if ((CurrentConfig.RamSize != TempConfig.RamSize) | (CurrentConfig.CpuType != TempConfig.CpuType))
{
EmuState.ResetPending = VCC_RESET_PENDING_HARD;
}
if ((CurrentConfig.SndOutDev != TempConfig.SndOutDev) | (CurrentConfig.AudioRate != TempConfig.AudioRate))
{
SoundInit(EmuState.WindowHandle, SoundCards[TempConfig.SndOutDev].Guid, TempConfig.AudioRate);
}
CurrentConfig=TempConfig;
vccKeyboardBuildRuntimeTable((keyboardlayout_e)CurrentConfig.KeyMap);
Right=TempRight;
Left=TempLeft;
SetStickNumbers(Left.DiDevice,Right.DiDevice);
break;
case IDCANCEL:
for (temp = 0; temp < TABS; temp++)
{
DestroyWindow(g_hWndConfig[temp]);
}
#ifdef CONFIG_DIALOG_MODAL
EndDialog(hDlg, LOWORD(wParam));
#else
DestroyWindow(hDlg);
#endif
EmuState.ConfigDialog=NULL;
break;
}
break; //break WM_COMMAND
} //End Switch
return FALSE;
}
