/*
* DlgProcYahooOpts - Connection Options Dialog
*/
static INT_PTR CALLBACK DlgProcYahooOptsIgnore(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
YList *l;
CYahooProto* ppro = (CYahooProto*)GetWindowLongPtr( hwndDlg, GWLP_USERDATA );
switch ( msg ) {
case WM_INITDIALOG:
TranslateDialogDefault( hwndDlg );
ppro = ( CYahooProto* )lParam;
SetWindowLongPtr( hwndDlg, GWLP_USERDATA, lParam );
if ( ppro->GetByte( "IgnoreUnknown", 0 )) {
CheckDlgButton(hwndDlg, IDC_OPT_IGN_UNKNOWN, 1);
EnableWindow( GetDlgItem(hwndDlg, IDC_IGN_ADD), 0);
EnableWindow( GetDlgItem(hwndDlg, IDC_IGN_REMOVE), 0);
EnableWindow( GetDlgItem(hwndDlg, IDC_YIGN_EDIT), 0);
EnableWindow( GetDlgItem(hwndDlg, IDC_YIGN_LIST), 0);
}
else CheckDlgButton(hwndDlg, IDC_OPT_IGN_LIST, 1);
/* show our current ignore list */
LOG(("[DlgProcYahooOptsIgnore] Grabbing current ignore list..."))
l = (YList *)ppro->GetIgnoreList();
while (l != NULL) {
struct yahoo_buddy *b = (struct yahoo_buddy *) l->data;
LOG(("[DlgProcYahooOptsIgnore] Buddy: %s", b->id ))
SendMessageA(GetDlgItem(hwndDlg,IDC_YIGN_LIST), LB_ADDSTRING, 0, (LPARAM)b->id);
l = l->next;
}
LOG(("[DlgProcYahooOptsIgnore] End of Ignore List..."))
return TRUE;
case WM_COMMAND:
switch ( LOWORD( wParam )) {
case IDC_OPT_IGN_UNKNOWN:
case IDC_OPT_IGN_LIST:
if (( HWND )lParam != GetFocus()) return 0;
EnableWindow( GetDlgItem(hwndDlg, IDC_IGN_ADD), LOWORD( wParam ) == IDC_OPT_IGN_LIST);
EnableWindow( GetDlgItem(hwndDlg, IDC_IGN_REMOVE), LOWORD( wParam ) == IDC_OPT_IGN_LIST);
EnableWindow( GetDlgItem(hwndDlg, IDC_YIGN_EDIT), LOWORD( wParam ) == IDC_OPT_IGN_LIST);
EnableWindow( GetDlgItem(hwndDlg, IDC_YIGN_LIST), LOWORD( wParam ) == IDC_OPT_IGN_LIST);
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
case IDC_IGN_ADD:
if (!ppro->m_bLoggedIn)
MessageBoxA(hwndDlg, Translate("You need to be connected to Yahoo to add to Ignore List."), Translate("Yahoo Ignore"), MB_OK| MB_ICONINFORMATION);
else {
char id[128];
int i = GetDlgItemTextA( hwndDlg, IDC_YIGN_EDIT, id, sizeof( id ));
if (i < 3) {
MessageBoxA(hwndDlg, Translate("Please enter a valid buddy name to ignore."), Translate("Yahoo Ignore"), MB_OK| MB_ICONINFORMATION);
break;
}
i = SendMessageA(GetDlgItem(hwndDlg,IDC_YIGN_LIST), LB_FINDSTRINGEXACT,(WPARAM) -1, (LPARAM)id);
if (i != LB_ERR ) {
MessageBoxA(hwndDlg, Translate("The buddy is already on your ignore list. "), Translate("Yahoo Ignore"), MB_OK | MB_ICONINFORMATION);
break;
}
ppro->IgnoreBuddy(id, 0);
SendMessageA(GetDlgItem(hwndDlg,IDC_YIGN_LIST), LB_ADDSTRING, 0, (LPARAM)id);
SetDlgItemTextA( hwndDlg, IDC_YIGN_EDIT, "" );
}
break;
case IDC_IGN_REMOVE:
{
int i;
char id[128];
if (!ppro->m_bLoggedIn) {
MessageBoxA(hwndDlg, Translate("You need to be connected to Yahoo to remove from the Ignore List."), Translate("Yahoo Ignore"), MB_OK| MB_ICONINFORMATION);
break;
}
i = SendMessage(GetDlgItem(hwndDlg,IDC_YIGN_LIST), LB_GETCURSEL, 0, 0);
if (i == LB_ERR) {
MessageBoxA(hwndDlg, Translate("Please select a buddy on the ignore list to remove."), Translate("Yahoo Ignore"), MB_OK| MB_ICONINFORMATION);
break;
}
SendMessageA(GetDlgItem(hwndDlg,IDC_YIGN_LIST), LB_GETTEXT, i, (LPARAM)id);
ppro->IgnoreBuddy(id, 1);
SendMessage(GetDlgItem(hwndDlg,IDC_YIGN_LIST), LB_DELETESTRING, i, 0);
}
}
break;
case WM_NOTIFY:
if (((LPNMHDR)lParam)->code == PSN_APPLY ) {
ppro->SetByte("IgnoreUnknown", ( BYTE )IsDlgButtonChecked( hwndDlg, IDC_OPT_IGN_UNKNOWN ));
return TRUE;
}
break;
}
return FALSE;
}
LRESULT COverlappedWindow::windowProc(HWND handle, UINT message, WPARAM wParam, LPARAM lParam)
{
switch( message ) {
case WM_NCCREATE:
{
CREATESTRUCT* pCreate = reinterpret_cast<CREATESTRUCT*>(lParam);
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(pCreate->lpCreateParams);
SetWindowLongPtr(handle, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(windowPtr));
windowPtr->OnNCCreate(handle);
return true;
}
case WM_CREATE:
{
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(GetWindowLongPtr(handle, GWLP_USERDATA));
windowPtr->OnCreate();
break;
}
case WM_SIZE:
{
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(GetWindowLongPtr(handle, GWLP_USERDATA));
windowPtr->OnSize();
break;
}
case WM_CTLCOLOREDIT:
{
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(GetWindowLongPtr(handle, GWLP_USERDATA));
HDC hdc = reinterpret_cast<HDC>(wParam);
return windowPtr->OnControlColorEdit(hdc);
}
case WM_COMMAND:
{
if( HIWORD(wParam) == EN_CHANGE ) {
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(GetWindowLongPtr(handle, GWLP_USERDATA));
windowPtr->OnTextChange();
break;
}
switch( LOWORD(wParam) ) {
case ID_FILE_SAVE:
{
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(GetWindowLongPtr(handle, GWLP_USERDATA));
windowPtr->saveFile();
break;
}
case ID_FILE_EXIT:
{
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(GetWindowLongPtr(handle, GWLP_USERDATA));
windowPtr->OnClose();
break;
}
case ID_VIEW_SETTINGS:
{
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(GetWindowLongPtr(handle, GWLP_USERDATA));
windowPtr->showSettings();
break;
}
case ID_KILL:
{
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(GetWindowLongPtr(handle, GWLP_USERDATA));
windowPtr->OnDestroy();
break;
}
}
break;
}
case WM_CLOSE:
{
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(GetWindowLongPtr(handle, GWLP_USERDATA));
windowPtr->OnClose();
break;
}
case WM_DESTROY:
{
COverlappedWindow* windowPtr = reinterpret_cast<COverlappedWindow*>(GetWindowLongPtr(handle, GWLP_USERDATA));
windowPtr->OnDestroy();
break;
}
default:
return DefWindowProc(handle, message, wParam, lParam);
}
return false;
}
IVDVideoWindow *VDGetIVideoWindow(HWND hwnd) {
return (IVDVideoWindow *)(VDVideoWindow *)GetWindowLongPtr(hwnd, 0);
}
LRESULT
WINAPI
LocalEditProc(
HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam
)
{
PPANE p = (PPANE)lParam;
PCXF pCxf = (PCXF)wParam;
PPANEINFO pInfo = (PPANEINFO)wParam;
LONG Len = 0;
LONG lLen = 0;
PTRVIB pVib = NULL;
PVTEXT pvtext;
ULONG i;
RECT Rect, tRect;
HWND hFoc;
HCURSOR hOldCursor, hWaitCursor;
hFoc = GetFocus();
__try {
switch (msg) {
case WU_INITDEBUGWIN:
Dbg(InitLocalsVits());
hWndLocal = hwnd;
PostMessage(hwnd, WU_UPDATE, 0, 0L);
break;
case WM_DESTROY:
hWndLocal = NULL; // Lose the Local Window Handle
//
// fall thru...
//
case WU_DBG_UNLOADEE:
case WU_DBG_UNLOADEM:
if ( pvitLocal) {
FreeLocalsVits(); // Lose the Local Trees
SendMessage(p->hWndLeft, LB_SETCOUNT, 1, 0);
SendMessage(p->hWndButton, LB_SETCOUNT, 1, 0);
SendMessage(p->hWndRight, LB_SETCOUNT, 1, 0);
p->MaxIdx = (WORD)1;
PostMessage(hwnd, WU_UPDATE, 0, 0L);
}
break;
case WU_DBG_LOADEM:
case WU_DBG_LOADEE:
if (!pvitLocal) {
Dbg(InitLocalsVits());
hWndLocal = hwnd;
PostMessage(hwnd, WU_UPDATE, 0, 0L);
}
break;
case WU_OPTIONS:
pVib = FTvibGetAtLine( pvitLocal, pInfo->ItemId);
if ( pVib == NULL) {
return FALSE;
}
pvtext = &pVib->pvtext[pVib->vibIndex];
if ( pInfo->pFormat && (*(pvtext->pszValueC) != '{')) {
FTEnsureTextExists(pVib);
if ( pvtext->pszFormat) {
free(pvtext->pszFormat);
}
pvtext->pszFormat = _strdup(pInfo->pFormat);
if ( pvtext->pszValueC) {
free(pvtext->pszValueC);
}
pvtext->pszValueC = NULL;
PaneInvalidateRow(p);
} else {
FTEnsureTextExists(pVib);
if ( pvtext->pszFormat) {
free(pvtext->pszFormat);
}
pvtext->pszFormat = '\0';
if ( pvtext->pszValueC) {
free(pvtext->pszValueC);
}
pvtext->pszValueC = NULL;
PaneInvalidateRow(p);
}
return TRUE;
case WU_INFO:
//
// Default to a reasonable baseline
//
pInfo->pBuffer = pInfo->pFormat = NULL;
pInfo->NewText = FALSE;
pInfo->ReadOnly = TRUE;
pVib = FTvibGetAtLine( pvitLocal, pInfo->ItemId);
if ( pVib == NULL) {
return(FALSE);
}
FTEnsureTextExists(pVib);
pvtext = &pVib->pvtext[pVib->vibIndex];
pInfo->pFormat = pvtext->pszFormat;
pInfo->pBuffer = FTGetPanelString( pvitLocal, pVib, pInfo->CtrlId);
if ( pInfo->CtrlId == ID_PANE_RIGHT) {
pInfo->ReadOnly = FALSE;
pInfo->NewText = FTGetPanelStatus( pVib, pInfo->CtrlId);
} else {
pInfo->ReadOnly = TRUE;
pInfo->NewText = FALSE;
}
return TRUE;
case WU_SETWATCH:
if ( pvitLocal == NULL) {
return(FALSE);
}
if ( p->nCtrlId == ID_PANE_RIGHT) {
BOOL retval;
fUseFrameContext = TRUE;
retval = (AcceptValueUpdate( pvitLocal, p));
if (retval == TRUE) {
UpdateDebuggerState(UPDATE_DATAWINS);
}
fUseFrameContext = FALSE;
return retval;
}
break;
case WU_INVALIDATE:
if (p == (PPANE)NULL) {
p = (PPANE)GetWindowLongPtr(GetLocalHWND(), GWW_EDIT);
}
SendMessage(p->hWndLeft, LB_SETCOUNT, 0, 0);
SendMessage(p->hWndButton, LB_SETCOUNT, 0, 0);
SendMessage(p->hWndRight, LB_SETCOUNT, 0, 0);
p->MaxIdx = 0;
PostMessage(hwnd, WU_UPDATE, 0, 0L);
InvalidateRect(p->hWndButton, NULL, TRUE);
InvalidateRect(p->hWndLeft, NULL, TRUE);
InvalidateRect(p->hWndRight, NULL, TRUE);
UpdateWindow (p->hWndButton);
UpdateWindow (p->hWndLeft);
UpdateWindow (p->hWndRight);
break;
case WU_EXPANDWATCH:
if ( pvitLocal == NULL) {
return(FALSE);
}
if ( FTExpand(pvitLocal, (ULONG)(wParam)) != OK) {
return(FALSE);
}
p->LeftOk = p->RightOk = FALSE;
pCxf = &pvitLocal->cxf; // Update in vit context
//
// fall thru...
//
case WU_UPDATE:
if ( pvitLocal == NULL) {
return(FALSE);
}
if (!pCxf) {
pCxf = &CxfIp;
}
//
// Has the Context Changed?
//
if ( UpdateLocalsVit(pCxf, p->bFlags.Expand1st) || p->LeftOk == FALSE ) {
hWaitCursor = LoadCursor ( (HINSTANCE) NULL, IDC_WAIT);
hOldCursor = SetCursor (hWaitCursor);
//
// Do we need to expand first level?
//
if ( p->bFlags.Expand1st) {
FTExpandOne(pvitLocal->pvibChild);
}
Len = (LONG)pvitLocal->cln;
p->MaxIdx = (WORD)Len;
lLen = (long) SendMessage(p->hWndLeft, LB_GETCOUNT, 0, 0L);
lLen = (lLen < Len || lLen == 0) ? Len : lLen;
SendMessage( p->hWndLeft, LB_SETCOUNT, lLen, 0L );
SendMessage( p->hWndButton, LB_SETCOUNT, lLen, 0L );
SendMessage( p->hWndRight, LB_SETCOUNT, lLen, 0L );
//
// Resetting the count, lost where we were so put us back
//
if (p->MaxIdx > 0) {
PaneResetIdx(p, p->CurIdx);
}
p->LeftOk = TRUE;
} else {
// Set hourglass cursor
hWaitCursor = LoadCursor ( (HINSTANCE) NULL, IDC_WAIT);
hOldCursor = SetCursor (hWaitCursor);
}
// Reset the right pane
FTAgeVibValues(pvitLocal->pvibChild);
for ( i= (ULONG)p->TopIdx;
i < (ULONG)(p->TopIdx + p->PaneLines) ; i++) {
if (FTVerifyNew(pvitLocal,i) ) {
PaneInvalidateItem( p->hWndRight, (PPANE)p, (SHORT)i);
}
}
p->RightOk = TRUE;
PaneCaretNum(p);
if ((hFoc == p->hWndButton) ||
(hFoc == p->hWndLeft) || (hFoc == p->hWndRight)) {
SendMessage(p->hWndButton ,
LB_GETITEMRECT,
(WPARAM)p->CurIdx,
(LPARAM)&Rect);
GetClientRect (p->hWndButton, &tRect);
tRect.top = Rect.top;
InvalidateRect(p->hWndButton, &tRect, TRUE);
SendMessage(p->hWndLeft ,
LB_GETITEMRECT,
(WPARAM)p->CurIdx,
(LPARAM)&Rect);
GetClientRect (p->hWndLeft, &tRect);
tRect.top = Rect.top;
InvalidateRect(p->hWndLeft, &tRect, TRUE);
SendMessage(p->hWndRight ,
LB_GETITEMRECT,
(WPARAM)p->CurIdx,
(LPARAM)&Rect);
GetClientRect (p->hWndRight, &tRect);
tRect.top = Rect.top;
InvalidateRect(p->hWndRight, &tRect, TRUE);
}
CheckPaneScrollBar( p, (WORD)Len);
// Set original cursor
hOldCursor = SetCursor (hOldCursor);
break;
}
} __except(EXCEPTION_EXECUTE_HANDLER) {
return FALSE;
}
return FALSE;
} /* LocalEditProc() */
LONG WINAPI WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
poWindow *win = (poWindow*)GetWindowLongPtr(hwnd, GWL_USERDATA);
switch(uMsg) {
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_SIZE:
window_width = LOWORD(lParam);
window_height = HIWORD(lParam);
if(win) win->resized(0,0,window_width,window_height);
break;
case WM_RBUTTONDOWN:
::SetCapture(hwnd);
isDragging = true;
if(win) win->mouseDown(LOSHORT(lParam), HISHORT(lParam), 0);
break;
case WM_RBUTTONUP:
::ReleaseCapture();
isDragging = false;
if(win) win->mouseUp(LOSHORT(lParam), HISHORT(lParam), 0);
break;
case WM_LBUTTONDOWN:
::SetCapture(hwnd);
isDragging = true;
if(win) win->mouseDown(LOSHORT(lParam), HISHORT(lParam), 0);
break;
case WM_LBUTTONUP:
::ReleaseCapture();
isDragging = false;
if(win) win->mouseUp(LOSHORT(lParam), HISHORT(lParam), 0);
break;
case WM_MBUTTONDOWN:
::SetCapture(hwnd);
isDragging = true;
if(win) win->mouseDown(LOSHORT(lParam), HISHORT(lParam), 0);
break;
case WM_MBUTTONUP:
::ReleaseCapture();
isDragging = false;
if(win) win->mouseUp(LOSHORT(lParam), HISHORT(lParam), 0);
break;
case WM_MOUSEMOVE:
if( isDragging )
if(win) win->mouseDrag(LOSHORT(lParam), HISHORT(lParam), 0);
else
if(win) win->mouseMove(LOSHORT(lParam), HISHORT(lParam), 0);
break;
case WM_MOUSEWHEEL:
break;
case WM_SYSKEYDOWN:
{
// alt-f4 ... pass to close the window
bool alt_down = (GetKeyState(VK_LMENU) & 0x80) || (GetKeyState(VK_RMENU) & 0x80) || (GetKeyState(VK_MENU) & 0x80);
if(VK_F4 == wParam && alt_down) {
PostMessage(hwnd, WM_CLOSE, 0, 0);
break;
}
}
case WM_KEYDOWN:
if(VK_F1 == wParam)
doFullscreen(hwnd, !is_fullscreen);
else
if(win) win->keyDown(mapVirtualKey(wParam), wParam, getKeyModifiers());
break;
case WM_SYSKEYUP:
case WM_KEYUP:
if(win) win->keyUp(mapVirtualKey(wParam), wParam, getKeyModifiers());
break;
case WM_KILLFOCUS:
// if we lose capture during a drag, post a mouse up event as a notifier
if( isDragging ) {
if(win) win->mouseDrag(LOSHORT(lParam), HISHORT(lParam), 0);
}
isDragging = false;
break;
case WM_ACTIVATE:
// make sure our fullscreen window plays nice with the task switcher
if(is_fullscreen) {
// if we're loosing focus, minimize to system tray
bool is_deactivated = WA_INACTIVE == LOWORD(wParam);
if(is_deactivated)
ShowWindow(hwnd,SW_SHOWMINIMIZED);
else
// sw_showmaximized flashes the title bar
// sw_show flashes the system tray, go figure
ShowWindow(hwnd,SW_SHOWMAXIMIZED);
}
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
/* Property page dialog callback */
INT_PTR CALLBACK
DatePageProc(HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
PGLOBALDATA pGlobalData;
pGlobalData = (PGLOBALDATA)GetWindowLongPtr(hwndDlg, DWLP_USER);
switch (uMsg)
{
case WM_INITDIALOG:
pGlobalData = (PGLOBALDATA)((LPPROPSHEETPAGE)lParam)->lParam;
SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pGlobalData);
InitMinMaxDateSpin(hwndDlg, pGlobalData->lcid);
UpdateDateLocaleSamples(hwndDlg, pGlobalData->lcid);
InitShortDateCB(hwndDlg, pGlobalData->lcid);
InitLongDateCB(hwndDlg, pGlobalData->lcid);
InitShortDateSepSamples(hwndDlg, pGlobalData->lcid);
/* TODO: Add other calendar types */
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_SECONDYEAR_EDIT:
{
if(HIWORD(wParam)==EN_CHANGE)
{
SetMinData(hwndDlg);
}
}
case IDC_SCR_MAX_YEAR:
{
/* Set "Apply" button enabled */
/* FIXME */
//PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
}
break;
case IDC_CALTYPE_COMBO:
case IDC_HIJCHRON_COMBO:
case IDC_SHRTDATEFMT_COMBO:
case IDC_SHRTDATESEP_COMBO:
case IDC_LONGDATEFMT_COMBO:
{
if (HIWORD(wParam) == CBN_SELCHANGE || HIWORD(wParam) == CBN_EDITCHANGE)
{
/* Set "Apply" button enabled */
PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
}
}
break;
}
}
break;
case WM_NOTIFY:
{
LPNMHDR lpnm = (LPNMHDR)lParam;
/* If push apply button */
if (lpnm->code == (UINT)PSN_APPLY)
{
SetMaxDate(hwndDlg, pGlobalData->lcid);
if(!SetShortDateSep(hwndDlg, pGlobalData->lcid)) break;
if(!SetShortDateFormat(hwndDlg, pGlobalData->lcid)) break;
if(!SetLongDateFormat(hwndDlg, pGlobalData->lcid)) break;
InitShortDateCB(hwndDlg, pGlobalData->lcid);
/* FIXME: */
//Sleep(15);
UpdateDateLocaleSamples(hwndDlg, pGlobalData->lcid);
}
}
break;
}
return FALSE;
}
INT_PTR CALLBACK DlgProcColorToolWindow(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static COLORCHOOSER* pCC = NULL;
static int iCurrentHotTrack;
static BOOL bChoosing;
static int iRows;
static int iColumns;
static HWND hPreviousActiveWindow;
switch(msg) {
case WM_INITDIALOG:
{
RECT rc;
int iSquareRoot;
int width ;
int height;
TranslateDialogDefault(hwndDlg);
pCC = (COLORCHOOSER*) lParam;
iCurrentHotTrack = -2;
bChoosing = FALSE;
iSquareRoot = (int)sqrt(pCC->pModule->nColorCount);
iColumns = iSquareRoot * iSquareRoot == pCC->pModule->nColorCount?iSquareRoot:iSquareRoot+1;
iRows = iSquareRoot;
rc.top = rc.left = 100;
rc.right = 100 + iColumns * 25 + 1;
rc.bottom = iRows * 20 + 100 + 20;
AdjustWindowRectEx(&rc, GetWindowLongPtr(hwndDlg, GWL_STYLE), FALSE, GetWindowLongPtr(hwndDlg, GWL_EXSTYLE));
width = rc.right - rc.left;
height = rc.bottom - rc.top;
pCC->yPosition -= height;
SetDlgItemText(hwndDlg, IDC_COLORTEXT, pCC->bForeground?TranslateT("Text colour"):TranslateT("Background colour"));
SetWindowPos(GetDlgItem(hwndDlg, IDC_COLORTEXT), NULL, 0, 0, width, 20, 0);
SetWindowPos(hwndDlg, NULL, pCC->xPosition, pCC->yPosition, width, height, SWP_SHOWWINDOW);
}
break;
case WM_CTLCOLOREDIT:
case WM_CTLCOLORSTATIC:
if (( HWND )lParam == GetDlgItem( hwndDlg, IDC_COLORTEXT )) {
SetTextColor((HDC)wParam,RGB(60,60,150));
SetBkColor((HDC)wParam,GetSysColor(COLOR_WINDOW));
return (INT_PTR)GetSysColorBrush(COLOR_WINDOW);
}
break;
case WM_COMMAND:
switch ( LOWORD( wParam )) {
case IDOK:
if (iCurrentHotTrack >= 0)
PostMessage(hwndDlg, WM_LBUTTONUP, 0, 0);
break;
case IDCANCEL:
DestroyWindow(hwndDlg);
break;
}
break;
case WM_LBUTTONUP:
if (iCurrentHotTrack >= 0 && iCurrentHotTrack < pCC->pModule->nColorCount && pCC->hWndTarget != NULL) {
HWND hWindow;
CHARFORMAT2 cf;
cf.cbSize = sizeof(CHARFORMAT2);
cf.dwMask = 0;
cf.dwEffects = 0;
hWindow = GetParent( pCC->hWndTarget );
if ( pCC->bForeground ) {
pCC->si->bFGSet = TRUE;
pCC->si->iFG = iCurrentHotTrack;
if ( IsDlgButtonChecked( hWindow, IDC_COLOR )) {
cf.dwMask = CFM_COLOR;
cf.crTextColor = pCC->pModule->crColors[iCurrentHotTrack];
SendMessage(pCC->hWndTarget, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf);
}
}
else {
pCC->si->bBGSet = TRUE;
pCC->si->iBG = iCurrentHotTrack;
if ( IsDlgButtonChecked( hWindow, IDC_BKGCOLOR )) {
cf.dwMask = CFM_BACKCOLOR;
cf.crBackColor = pCC->pModule->crColors[iCurrentHotTrack];
SendMessage(pCC->hWndTarget, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf);
}
}
}
PostMessage(hwndDlg, WM_CLOSE, 0, 0);
break;
case WM_ACTIVATE:
if (wParam == WA_INACTIVE)
PostMessage(hwndDlg, WM_CLOSE, 0, 0);
else if ((wParam == WA_ACTIVE) || (wParam == WA_CLICKACTIVE))
hPreviousActiveWindow = (HWND)lParam;
break;
case WM_MOUSEMOVE:
{
HDC hdc = GetDC(hwndDlg);
POINT pt;
RECT rect;
int but;
pt.x = LOWORD(lParam);
pt.y = HIWORD(lParam);
if (iCurrentHotTrack == -2)
return 0; // prevent focussing when not drawn yet!
but = CalculateCoordinatesToButton(pCC, pt);
// weird stuff
if (but != iCurrentHotTrack) {
if (iCurrentHotTrack >= 0) {
rect = CalculateButtonToCoordinates(pCC, iCurrentHotTrack);
DrawFocusRect(hdc, &rect);
iCurrentHotTrack = -1;
}
iCurrentHotTrack = but;
if (iCurrentHotTrack >= 0) {
rect = CalculateButtonToCoordinates(pCC, iCurrentHotTrack);
DrawFocusRect(hdc, &rect);
}
}
ReleaseDC(hwndDlg, hdc);
}
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc;
RECT rc;
int i = 0;
int iThisRow = 1;
int iThisColumn = 0;
GetClientRect(hwndDlg, &rc);
rc.top += 20;
hdc = BeginPaint(hwndDlg, &ps);
// fill background
FillRect(hdc, &rc, GetSysColorBrush(COLOR_WINDOW));
for (i; i < pCC->pModule->nColorCount; i++) {
HBRUSH hbr;
// decide place to draw the color block in the window
iThisColumn ++;
if (iThisColumn > iColumns) {
iThisColumn = 1;
iThisRow++;
}
if ( pCC->bForeground && pCC->si->bFGSet && pCC->si->iFG == i ||
!pCC->bForeground && pCC->si->bBGSet && pCC->si->iBG == i ) {
rc.top = (iThisRow-1) * 20+ 1 +20 ;
rc.left = (iThisColumn-1) * 25 + 1 + 1 ;
rc.bottom = iThisRow * 20- 1 + 20 ;
rc.right = iThisColumn * 25-1 ;
DrawEdge(hdc, &rc, EDGE_RAISED, BF_TOP|BF_LEFT|BF_RIGHT|BF_BOTTOM);
}
rc.top = (iThisRow-1) * 20+ 3 +20 ;
rc.left = (iThisColumn-1) * 25 + 3 + 1 ;
rc.bottom = iThisRow * 20- 3 + 20 ;
rc.right = iThisColumn * 25-3 ;
FillRect(hdc, &rc, GetStockObject(BLACK_BRUSH));
hbr = CreateSolidBrush(pCC->pModule->crColors[i]);
rc.top = (iThisRow-1) * 20+4 +20;
rc.left = (iThisColumn-1) * 25+ 4 + 1;
rc.bottom = iThisRow * 20-4 + 20;
rc.right = iThisColumn * 25-4;
FillRect(hdc, &rc, hbr);
DeleteObject(hbr);
}
EndPaint(hwndDlg, &ps);
iCurrentHotTrack = -1;
}
break;
case WM_CLOSE:
SetFocus(pCC->hWndTarget);
DestroyWindow(hwndDlg);
break;
case WM_DESTROY:
mir_free( pCC );
return TRUE;
}
return FALSE;
}
INT_PTR CALLBACK FBOptionsMessagingProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
FacebookProto *proto = reinterpret_cast<FacebookProto*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
switch (message)
{
case WM_INITDIALOG:
{
TranslateDialogDefault(hwnd);
proto = reinterpret_cast<FacebookProto*>(lparam);
SetWindowLongPtr(hwnd, GWLP_USERDATA, lparam);
LoadDBCheckState(proto, hwnd, IDC_CUSTOM_SMILEYS, FACEBOOK_KEY_CUSTOM_SMILEYS, DEFAULT_CUSTOM_SMILEYS);
LoadDBCheckState(proto, hwnd, IDC_KEEP_UNREAD, FACEBOOK_KEY_KEEP_UNREAD, DEFAULT_KEEP_UNREAD);
LoadDBCheckState(proto, hwnd, IDC_MESSAGES_ON_OPEN, FACEBOOK_KEY_MESSAGES_ON_OPEN, DEFAULT_MESSAGES_ON_OPEN);
LoadDBCheckState(proto, hwnd, IDC_LOGIN_SYNC, FACEBOOK_KEY_LOGIN_SYNC, DEFAULT_LOGIN_SYNC);
LoadDBCheckState(proto, hwnd, IDC_ENABLE_CHATS, FACEBOOK_KEY_ENABLE_CHATS, DEFAULT_ENABLE_CHATS);
LoadDBCheckState(proto, hwnd, IDC_HIDE_CHATS, FACEBOOK_KEY_HIDE_CHATS, DEFAULT_HIDE_CHATS);
int count = proto->getByte(FACEBOOK_KEY_MESSAGES_ON_OPEN_COUNT, 10);
count = min(count, FACEBOOK_MESSAGES_ON_OPEN_LIMIT);
SetDlgItemInt(hwnd, IDC_MESSAGES_COUNT, count, TRUE);
SendDlgItemMessage(hwnd, IDC_MESSAGES_COUNT, EM_LIMITTEXT, 2, 0);
SendDlgItemMessage(hwnd, IDC_MESSAGES_COUNT_SPIN, UDM_SETRANGE32, 1, 99);
} return TRUE;
case WM_COMMAND:
switch (LOWORD(wparam))
{
case IDC_MESSAGES_COUNT:
if (HIWORD(wparam) == EN_CHANGE && (HWND)lparam == GetFocus())
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
default:
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
}
return TRUE;
case WM_NOTIFY:
{
if (reinterpret_cast<NMHDR*>(lparam)->code == PSN_APPLY)
{
StoreDBCheckState(proto, hwnd, IDC_CUSTOM_SMILEYS, FACEBOOK_KEY_CUSTOM_SMILEYS);
StoreDBCheckState(proto, hwnd, IDC_KEEP_UNREAD, FACEBOOK_KEY_KEEP_UNREAD);
StoreDBCheckState(proto, hwnd, IDC_LOGIN_SYNC, FACEBOOK_KEY_LOGIN_SYNC);
StoreDBCheckState(proto, hwnd, IDC_MESSAGES_ON_OPEN, FACEBOOK_KEY_MESSAGES_ON_OPEN);
StoreDBCheckState(proto, hwnd, IDC_ENABLE_CHATS, FACEBOOK_KEY_ENABLE_CHATS);
StoreDBCheckState(proto, hwnd, IDC_HIDE_CHATS, FACEBOOK_KEY_HIDE_CHATS);
int count = GetDlgItemInt(hwnd, IDC_MESSAGES_COUNT, NULL, TRUE);
count = min(count, FACEBOOK_MESSAGES_ON_OPEN_LIMIT);
proto->setByte(FACEBOOK_KEY_MESSAGES_ON_OPEN_COUNT, count);
}
} return TRUE;
}
return FALSE;
}
//===========================================================================
int HookWindow (HWND hwnd, int early)
{
LONG_PTR lStyle = GetWindowLongPtr(hwnd, GWL_STYLE);
// if it does not have a caption, there is nothing to skin.
if (WS_CAPTION != (lStyle & WS_CAPTION))
{
//send_log(hwnd, "no caption");
return 0;
}
LONG_PTR lExStyle = GetWindowLongPtr(hwnd, GWL_EXSTYLE);
// child windows are excluded unless they have a sysmenu or are MDI clients
if ((lStyle & WS_CHILD)
&& false == (lStyle & WS_SYSMENU)
&& false == (WS_EX_MDICHILD & lExStyle)
)
{
//send_log(hwnd, "child, no sysmenu, not a MDI");
return 0;
}
// if it is already hooked, dont fall into loop
if (get_WinInfo(hwnd))
{
//send_log(hwnd, "already hooked");
return 0;
}
// being skeptical about windows without sysmenu
if (false == (lStyle & WS_SYSMENU) && false == (lStyle & WS_VISIBLE))
{
//if (0 == early) send_log(hwnd, "invisible without sysmenu");
return early;
}
// check for something like a vertical titlebar, erm...
if (lExStyle & WS_EX_TOOLWINDOW)
{
RECT rc; GetWindowRect(hwnd, &rc);
ScreenToClient(hwnd, (LPPOINT)&rc.left);
if (rc.top > -10)
{
//if (0 == early) send_log(hwnd, "abnormal caption");
return early;
}
}
// ------------------------------------------------------
// now check the exclusion list
int found = 0;
struct shmem sh;
SkinStruct *pSkin = (SkinStruct *)GetSharedMem(&sh);
if (NULL == pSkin)
return 0;
copy_skin(pSkin);
char sClassName[200]; sClassName[0] = 0;
GetClassName(hwnd, sClassName, sizeof sClassName);
char sFileName[200]; sFileName[0] = 0;
get_module(hwnd, sFileName, sizeof sFileName);
struct exclusion_item *ei = pSkin->exInfo.ei;
for (int i = pSkin->exInfo.count; i; --i)
{
char *f, *c = (f = ei->buff) + ei->flen;
// if filename matches and if class matches or is empty...
bool r = match(sFileName, f) && (0 == *c || match(sClassName, c));
//dbg_printf("check [%d,%d] %s:%s", r, ei->option, f, c);
if (r)
{
found = 1 == ei->option ? -1 : 1; // check 'hook-early' option
break;
}
ei = (struct exclusion_item *)(c + ei->clen);
}
ReleaseSharedMem(&sh);
// ------------------------------------------------------
if (early && 0 == found)
{
//send_log(hwnd, "Checking later:");
return 1;
}
// send message to log_window
if (mSkin.enableLog)
{
char msg[100];
sprintf_s(msg, 100, "%s%s",
found > 0 ? "Excluded" : early ? "Hooked early" : "Hooked",
IsWindowVisible(hwnd) ? "" : " invisible");
send_log(hwnd, msg);
}
// return when excluded;
if (found > 0)
return 0;
// skin it.
subclass_window(hwnd);
return 2;
}
INT_PTR CALLBACK FBAccountProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
FacebookProto *proto = reinterpret_cast<FacebookProto*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
switch (message)
{
case WM_INITDIALOG:
{
TranslateDialogDefault(hwnd);
proto = reinterpret_cast<FacebookProto*>(lparam);
SetWindowLongPtr(hwnd, GWLP_USERDATA, lparam);
ptrA login(db_get_sa(NULL, proto->ModuleName(), FACEBOOK_KEY_LOGIN));
if (login != NULL)
SetDlgItemTextA(hwnd, IDC_UN, login);
ptrA password(db_get_sa(NULL, proto->ModuleName(), FACEBOOK_KEY_PASS));
if (password != NULL)
SetDlgItemTextA(hwnd, IDC_PW, password);
if (!proto->isOffline())
{
SendDlgItemMessage(hwnd, IDC_UN, EM_SETREADONLY, 1, 0);
SendDlgItemMessage(hwnd, IDC_PW, EM_SETREADONLY, 1, 0);
}
return TRUE;
}
case WM_COMMAND:
if (LOWORD(wparam) == IDC_NEWACCOUNTLINK)
{
proto->OpenUrl(std::string(FACEBOOK_URL_HOMEPAGE));
return TRUE;
}
if (HIWORD(wparam) == EN_CHANGE && reinterpret_cast<HWND>(lparam) == GetFocus())
{
switch (LOWORD(wparam))
{
case IDC_UN:
case IDC_PW:
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
}
}
break;
case WM_NOTIFY:
if (reinterpret_cast<NMHDR*>(lparam)->code == PSN_APPLY)
{
char str[128];
GetDlgItemTextA(hwnd, IDC_UN, str, _countof(str));
db_set_s(NULL, proto->ModuleName(), FACEBOOK_KEY_LOGIN, str);
GetDlgItemTextA(hwnd, IDC_PW, str, _countof(str));
db_set_s(NULL, proto->ModuleName(), FACEBOOK_KEY_PASS, str);
return TRUE;
}
break;
}
return FALSE;
}
INT_PTR CALLBACK FBOptionsEventsProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
FacebookProto *proto = reinterpret_cast<FacebookProto*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
switch (message)
{
case WM_INITDIALOG:
{
TranslateDialogDefault(hwnd);
proto = reinterpret_cast<FacebookProto*>(lparam);
SetWindowLongPtr(hwnd, GWLP_USERDATA, lparam);
for (size_t i = 0; i < _countof(feed_types); i++)
SendDlgItemMessageA(hwnd, IDC_FEED_TYPE, CB_INSERTSTRING, i, reinterpret_cast<LPARAM>(Translate(feed_types[i].name)));
SendDlgItemMessage(hwnd, IDC_FEED_TYPE, CB_SETCURSEL, proto->getByte(FACEBOOK_KEY_FEED_TYPE, 0), 0);
for (size_t i = 0; i < _countof(server_types); i++)
SendDlgItemMessageA(hwnd, IDC_URL_SERVER, CB_INSERTSTRING, i, reinterpret_cast<LPARAM>(Translate(server_types[i].name)));
SendDlgItemMessage(hwnd, IDC_URL_SERVER, CB_SETCURSEL, proto->getByte(FACEBOOK_KEY_SERVER_TYPE, 0), 0);
LoadDBCheckState(proto, hwnd, IDC_SYSTRAY_NOTIFY, FACEBOOK_KEY_SYSTRAY_NOTIFY, DEFAULT_SYSTRAY_NOTIFY);
LoadDBCheckState(proto, hwnd, IDC_NOTIFICATIONS_CHATROOM, FACEBOOK_KEY_NOTIFICATIONS_CHATROOM, DEFAULT_NOTIFICATIONS_CHATROOM);
LoadDBCheckState(proto, hwnd, IDC_NOTIFICATIONS_ENABLE, FACEBOOK_KEY_EVENT_NOTIFICATIONS_ENABLE, DEFAULT_EVENT_NOTIFICATIONS_ENABLE);
LoadDBCheckState(proto, hwnd, IDC_FEEDS_ENABLE, FACEBOOK_KEY_EVENT_FEEDS_ENABLE, DEFAULT_EVENT_FEEDS_ENABLE);
LoadDBCheckState(proto, hwnd, IDC_FRIENDSHIP_ENABLE, FACEBOOK_KEY_EVENT_FRIENDSHIP_ENABLE, DEFAULT_EVENT_FRIENDSHIP_ENABLE);
LoadDBCheckState(proto, hwnd, IDC_TICKER_ENABLE, FACEBOOK_KEY_EVENT_TICKER_ENABLE, DEFAULT_EVENT_TICKER_ENABLE);
LoadDBCheckState(proto, hwnd, IDC_ON_THIS_DAY_ENABLE, FACEBOOK_KEY_EVENT_ON_THIS_DAY_ENABLE, DEFAULT_EVENT_ON_THIS_DAY_ENABLE);
LoadDBCheckState(proto, hwnd, IDC_FILTER_ADS, FACEBOOK_KEY_FILTER_ADS, DEFAULT_FILTER_ADS);
} return TRUE;
case WM_COMMAND:
switch (LOWORD(wparam))
{
case IDC_FEED_TYPE:
case IDC_URL_SERVER:
if (HIWORD(wparam) == CBN_SELCHANGE)
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
default:
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
}
return TRUE;
case WM_NOTIFY:
{
if (reinterpret_cast<NMHDR*>(lparam)->code == PSN_APPLY)
{
proto->setByte(FACEBOOK_KEY_FEED_TYPE, SendDlgItemMessage(hwnd, IDC_FEED_TYPE, CB_GETCURSEL, 0, 0));
proto->setByte(FACEBOOK_KEY_SERVER_TYPE, SendDlgItemMessage(hwnd, IDC_URL_SERVER, CB_GETCURSEL, 0, 0));
StoreDBCheckState(proto, hwnd, IDC_SYSTRAY_NOTIFY, FACEBOOK_KEY_SYSTRAY_NOTIFY);
StoreDBCheckState(proto, hwnd, IDC_NOTIFICATIONS_CHATROOM, FACEBOOK_KEY_NOTIFICATIONS_CHATROOM);
StoreDBCheckState(proto, hwnd, IDC_NOTIFICATIONS_ENABLE, FACEBOOK_KEY_EVENT_NOTIFICATIONS_ENABLE);
StoreDBCheckState(proto, hwnd, IDC_FEEDS_ENABLE, FACEBOOK_KEY_EVENT_FEEDS_ENABLE);
StoreDBCheckState(proto, hwnd, IDC_FRIENDSHIP_ENABLE, FACEBOOK_KEY_EVENT_FRIENDSHIP_ENABLE);
StoreDBCheckState(proto, hwnd, IDC_TICKER_ENABLE, FACEBOOK_KEY_EVENT_TICKER_ENABLE);
StoreDBCheckState(proto, hwnd, IDC_ON_THIS_DAY_ENABLE, FACEBOOK_KEY_EVENT_ON_THIS_DAY_ENABLE);
StoreDBCheckState(proto, hwnd, IDC_FILTER_ADS, FACEBOOK_KEY_FILTER_ADS);
}
} return TRUE;
}
return FALSE;
}
INT_PTR CALLBACK FBOptionsProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
FacebookProto *proto = reinterpret_cast<FacebookProto*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
switch (message)
{
case WM_INITDIALOG:
{
TranslateDialogDefault(hwnd);
proto = reinterpret_cast<FacebookProto*>(lparam);
SetWindowLongPtr(hwnd, GWLP_USERDATA, lparam);
ptrA login(db_get_sa(NULL, proto->ModuleName(), FACEBOOK_KEY_LOGIN));
if (login != NULL)
SetDlgItemTextA(hwnd, IDC_UN, login);
ptrA password(db_get_sa(NULL, proto->ModuleName(), FACEBOOK_KEY_PASS));
if (password != NULL)
SetDlgItemTextA(hwnd, IDC_PW, password);
if (!proto->isOffline()) {
SendDlgItemMessage(hwnd, IDC_UN, EM_SETREADONLY, TRUE, 0);
SendDlgItemMessage(hwnd, IDC_PW, EM_SETREADONLY, TRUE, 0);
}
SendDlgItemMessage(hwnd, IDC_GROUP, EM_LIMITTEXT, FACEBOOK_GROUP_NAME_LIMIT, 0);
if (proto->m_tszDefaultGroup != NULL)
SetDlgItemText(hwnd, IDC_GROUP, proto->m_tszDefaultGroup);
LoadDBCheckState(proto, hwnd, IDC_SET_IGNORE_STATUS, FACEBOOK_KEY_DISABLE_STATUS_NOTIFY, DEFAULT_DISABLE_STATUS_NOTIFY);
LoadDBCheckState(proto, hwnd, IDC_BIGGER_AVATARS, FACEBOOK_KEY_BIG_AVATARS, DEFAULT_BIG_AVATARS);
LoadDBCheckState(proto, hwnd, IDC_NAME_AS_NICK, FACEBOOK_KEY_NAME_AS_NICK, DEFAULT_NAME_AS_NICK);
} return TRUE;
case WM_COMMAND:
{
switch (LOWORD(wparam)) {
case IDC_NEWACCOUNTLINK:
proto->OpenUrl(std::string(FACEBOOK_URL_HOMEPAGE));
return TRUE;
case IDC_UN:
case IDC_PW:
case IDC_GROUP:
if (HIWORD(wparam) == EN_CHANGE && (HWND)lparam == GetFocus())
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
break;
default:
SendMessage(GetParent(hwnd), PSM_CHANGED, 0, 0);
}
} break;
case WM_NOTIFY:
if (reinterpret_cast<NMHDR*>(lparam)->code == PSN_APPLY)
{
char str[128]; TCHAR tstr[128];
GetDlgItemTextA(hwnd, IDC_UN, str, _countof(str));
db_set_s(0, proto->ModuleName(), FACEBOOK_KEY_LOGIN, str);
GetDlgItemTextA(hwnd, IDC_PW, str, _countof(str));
proto->setString(FACEBOOK_KEY_PASS, str);
GetDlgItemText(hwnd, IDC_GROUP, tstr, _countof(tstr));
if (tstr[0] != '\0')
{
proto->m_tszDefaultGroup = mir_tstrdup(tstr);
proto->setTString(FACEBOOK_KEY_DEF_GROUP, tstr);
Clist_GroupCreate(0, tstr);
}
else {
proto->delSetting(FACEBOOK_KEY_DEF_GROUP);
proto->m_tszDefaultGroup = NULL;
}
StoreDBCheckState(proto, hwnd, IDC_SET_IGNORE_STATUS, FACEBOOK_KEY_DISABLE_STATUS_NOTIFY);
StoreDBCheckState(proto, hwnd, IDC_BIGGER_AVATARS, FACEBOOK_KEY_BIG_AVATARS);
StoreDBCheckState(proto, hwnd, IDC_NAME_AS_NICK, FACEBOOK_KEY_NAME_AS_NICK);
return TRUE;
}
break;
}
return FALSE;
}
INT_PTR CALLBACK FBMindProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
post_status_data *data;
switch (message)
{
case WM_INITDIALOG:
{
TranslateDialogDefault(hwnd);
Window_SetIcon_IcoLib(hwnd, GetIconHandle("mind"));
data = reinterpret_cast<post_status_data*>(lparam);
SetWindowLongPtr(hwnd, GWLP_USERDATA, lparam);
SendDlgItemMessage(hwnd, IDC_MINDMSG, EM_LIMITTEXT, FACEBOOK_MIND_LIMIT, 0);
SendDlgItemMessage(hwnd, IDC_URL, EM_LIMITTEXT, 1024, 0);
ptrT place(data->proto->getTStringA(FACEBOOK_KEY_PLACE));
SetDlgItemText(hwnd, IDC_PLACE, place != NULL ? place : _T("Miranda NG"));
bShowContacts = data->proto->getByte("PostStatusExpand", 0) > 0;
ResizeHorizontal(hwnd, bShowContacts);
HWND hwndClist = GetDlgItem(hwnd, IDC_CCLIST);
SetWindowLongPtr(hwndClist, GWL_STYLE, GetWindowLongPtr(hwndClist, GWL_STYLE) & ~CLS_HIDEOFFLINE);
for (std::vector<wall_data*>::size_type i = 0; i < data->walls.size(); i++)
SendDlgItemMessage(hwnd, IDC_WALL, CB_INSERTSTRING, i, reinterpret_cast<LPARAM>(data->walls[i]->title));
SendDlgItemMessage(hwnd, IDC_WALL, CB_SETCURSEL, 0, 0);
SendDlgItemMessage(hwnd, IDC_WALL, CB_SETCURSEL, data->proto->getByte(FACEBOOK_KEY_LAST_WALL, 0), 0);
RefreshPrivacy(hwnd, data);
ptrA firstname(data->proto->getStringA(FACEBOOK_KEY_FIRST_NAME));
if (firstname != NULL) {
char title[100];
mir_snprintf(title, Translate("What's on your mind, %s?"), firstname);
SetWindowTextA(hwnd, title);
}
}
EnableWindow(GetDlgItem(hwnd, IDOK), FALSE);
return TRUE;
case WM_NOTIFY:
{
NMCLISTCONTROL *nmc = (NMCLISTCONTROL *)lparam;
if (nmc->hdr.idFrom == IDC_CCLIST) {
switch (nmc->hdr.code) {
case CLN_LISTREBUILT:
data = reinterpret_cast<post_status_data*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
ClistPrepare(data->proto, NULL, nmc->hdr.hwndFrom);
break;
}
}
}
break;
case WM_COMMAND:
switch (LOWORD(wparam))
{
case IDC_WALL:
if (HIWORD(wparam) == CBN_SELCHANGE) {
data = reinterpret_cast<post_status_data*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
RefreshPrivacy(hwnd, data);
}
break;
case IDC_MINDMSG:
case IDC_URL:
if (HIWORD(wparam) == EN_CHANGE) {
bool ok = SendDlgItemMessage(hwnd, IDC_MINDMSG, WM_GETTEXTLENGTH, 0, 0) > 0;
if (!ok && SendDlgItemMessage(hwnd, IDC_URL, WM_GETTEXTLENGTH, 0, 0) > 0)
ok = true;
EnableWindow(GetDlgItem(hwnd, IDOK), ok);
return TRUE;
}
break;
case IDC_EXPAND:
bShowContacts = !bShowContacts;
ResizeHorizontal(hwnd, bShowContacts);
break;
case IDOK:
{
data = reinterpret_cast<post_status_data*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
TCHAR mindMessageT[FACEBOOK_MIND_LIMIT + 1];
TCHAR urlT[1024];
TCHAR placeT[100];
GetDlgItemText(hwnd, IDC_MINDMSG, mindMessageT, _countof(mindMessageT));
GetDlgItemText(hwnd, IDC_PLACE, placeT, _countof(placeT));
GetDlgItemText(hwnd, IDC_URL, urlT, _countof(urlT));
ShowWindow(hwnd, SW_HIDE);
int wall_id = SendDlgItemMessage(hwnd, IDC_WALL, CB_GETCURSEL, 0, 0);
int privacy_id = SendDlgItemMessage(hwnd, IDC_PRIVACY, CB_GETCURSEL, 0, 0);
data->proto->setTString(FACEBOOK_KEY_PLACE, placeT);
data->proto->setByte("PostStatusExpand", bShowContacts);
// remember last wall, only when there are more options
if (SendDlgItemMessage(hwnd, IDC_WALL, CB_GETCOUNT, 0, 0) > 1)
data->proto->setByte(FACEBOOK_KEY_LAST_WALL, wall_id);
// remember last privacy, only when there are more options
if (SendDlgItemMessage(hwnd, IDC_PRIVACY, CB_GETCOUNT, 0, 0) > 1)
data->proto->setByte(FACEBOOK_KEY_PRIVACY_TYPE, privacy_id);
status_data *status = new status_data();
status->user_id = data->walls[wall_id]->user_id;
status->isPage = data->walls[wall_id]->isPage;
status->privacy = privacy_types[privacy_id].id;
status->place = T2Utf(placeT);
status->url = _T2A(urlT);
HWND hwndList = GetDlgItem(hwnd, IDC_CCLIST);
GetSelectedContacts(data->proto, NULL, hwndList, &status->users);
T2Utf narrow(mindMessageT);
status->text = narrow;
if (status->user_id == data->proto->facy.self_.user_id && data->proto->last_status_msg_ != (char*)narrow)
data->proto->last_status_msg_ = narrow;
data->proto->ForkThread(&FacebookProto::SetAwayMsgWorker, status);
EndDialog(hwnd, wparam);
return TRUE;
}
case IDCANCEL:
EndDialog(hwnd, wparam);
return TRUE;
} break;
case WM_DESTROY:
data = reinterpret_cast<post_status_data*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
for (std::vector<wall_data*>::size_type i = 0; i < data->walls.size(); i++) {
mir_free(data->walls[i]->title);
delete data->walls[i];
}
delete data;
}
return FALSE;
}
/*
* DlgProcYahooOpts - Account Options Dialog
*/
static INT_PTR CALLBACK DlgProcYahooOpts(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
DBVARIANT dbv;
CYahooProto* ppro = (CYahooProto*)GetWindowLongPtr( hwndDlg, GWLP_USERDATA );
switch ( msg ) {
case WM_INITDIALOG:
TranslateDialogDefault( hwndDlg );
ppro = (CYahooProto*)lParam;
SetWindowLongPtr( hwndDlg, GWLP_USERDATA, lParam );
if ( !ppro->GetString( YAHOO_LOGINID, &dbv )) {
SetDlgItemTextA(hwndDlg,IDC_HANDLE,dbv.pszVal);
DBFreeVariant(&dbv);
}
if ( !ppro->GetString( "Nick", &dbv )) {
SetDlgItemTextA(hwndDlg,IDC_NICK,dbv.pszVal);
DBFreeVariant(&dbv);
}
if ( !ppro->GetString( YAHOO_PASSWORD, &dbv )) {
//bit of a security hole here, since it's easy to extract a password from an edit box
YAHOO_CallService( MS_DB_CRYPT_DECODESTRING, strlen( dbv.pszVal )+1, ( LPARAM )dbv.pszVal );
SetDlgItemTextA( hwndDlg, IDC_PASSWORD, dbv.pszVal );
DBFreeVariant( &dbv );
}
//SetButtonCheck( hwndDlg, IDC_DISABLE_UTF8, ppro->GetByte( "DisableUTF8", 0 ));
SetButtonCheck( hwndDlg, IDC_USE_YAB, ppro->GetByte( "UseYAB", 1 ));
SetButtonCheck( hwndDlg, IDC_SHOW_AVATARS, ppro->GetByte( "ShowAvatars", 1 ));
SetButtonCheck( hwndDlg, IDC_MAIL_AUTOLOGIN, ppro->GetByte( "MailAutoLogin", 1 ));
SetButtonCheck( hwndDlg, IDC_DISABLEYAHOOMAIL, !ppro->GetByte( "DisableYahoomail", 0 ));
SetButtonCheck( hwndDlg, IDC_SHOW_ERRORS, ppro->GetByte( "ShowErrors", 1 ));
return TRUE;
case WM_COMMAND:
switch ( LOWORD( wParam )) {
case IDC_NEWYAHOOACCOUNTLINK:
YAHOO_CallService( MS_UTILS_OPENURL, 1,
ppro->GetByte( "YahooJapan", 0 ) ?
(LPARAM)"http://edit.yahoo.co.jp/config/eval_register" :
(LPARAM)"http://edit.yahoo.com/config/eval_register" );
return TRUE;
//case IDC_DISABLE_UTF8:
case IDC_USE_YAB:
case IDC_SHOW_AVATARS:
case IDC_MAIL_AUTOLOGIN:
case IDC_SHOW_ERRORS:
case IDC_DISABLEYAHOOMAIL:
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
if ( HIWORD( wParam ) == EN_CHANGE && ( HWND )lParam == GetFocus())
switch( LOWORD( wParam )) {
case IDC_HANDLE:
case IDC_PASSWORD:
case IDC_NICK:
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
}
break;
case WM_NOTIFY:
if (((LPNMHDR)lParam)->code == (UINT) PSN_APPLY ) {
BOOL reconnectRequired = FALSE;
char str[128];
GetDlgItemTextA( hwndDlg, IDC_HANDLE, str, sizeof( str ));
dbv.pszVal = NULL;
if ( ppro->GetString( YAHOO_LOGINID, &dbv ) || lstrcmpA( str, dbv.pszVal ))
reconnectRequired = TRUE;
if ( dbv.pszVal != NULL )
DBFreeVariant( &dbv );
ppro->SetString( YAHOO_LOGINID, str );
GetDlgItemTextA( hwndDlg, IDC_PASSWORD, str, sizeof( str ));
YAHOO_CallService( MS_DB_CRYPT_ENCODESTRING, sizeof( str ),( LPARAM )str );
dbv.pszVal = NULL;
if ( ppro->GetString( YAHOO_PASSWORD, &dbv ) || lstrcmpA( str, dbv.pszVal ))
reconnectRequired = TRUE;
if ( dbv.pszVal != NULL )
DBFreeVariant( &dbv );
ppro->SetString( YAHOO_PASSWORD, str );
GetDlgItemTextA( hwndDlg, IDC_NICK, str, sizeof( str ));
if (str[0] == '\0') {
/* Check for empty Nick, if so delete the key in the DB */
DBDeleteContactSetting( NULL, ppro->m_szModuleName, "Nick" );
} else {
/* otherwise save the new Nick */
ppro->SetString( "Nick", str );
}
//ppro->SetByte("DisableUTF8", ( BYTE )IsDlgButtonChecked( hwndDlg, IDC_DISABLE_UTF8 ));
ppro->SetByte("UseYAB", ( BYTE )IsDlgButtonChecked( hwndDlg, IDC_USE_YAB ));
ppro->SetByte("ShowAvatars", ( BYTE )IsDlgButtonChecked( hwndDlg, IDC_SHOW_AVATARS ));
ppro->SetByte("MailAutoLogin", ( BYTE )IsDlgButtonChecked( hwndDlg, IDC_MAIL_AUTOLOGIN ));
ppro->SetByte("DisableYahoomail", ( BYTE )!IsDlgButtonChecked( hwndDlg, IDC_DISABLEYAHOOMAIL ));
ppro->SetByte("ShowErrors", ( BYTE )IsDlgButtonChecked( hwndDlg, IDC_SHOW_ERRORS ));
if (reconnectRequired ) {
DBDeleteContactSetting(NULL, ppro->m_szModuleName, YAHOO_PWTOKEN);
}
/*if ( restartRequired )
MessageBoxA( hwndDlg, Translate( "The changes you have made require you to restart Miranda IM before they take effect"), Translate("YAHOO Options"), MB_OK );
else */
if ( reconnectRequired && ppro->m_bLoggedIn )
MessageBoxA( hwndDlg, Translate( "The changes you have made require you to reconnect to the Yahoo network before they take effect"), Translate("YAHOO Options"), MB_OK );
return TRUE;
}
break;
}
return FALSE;
}
LRESULT CALLBACK win_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
struct ag_window* window = (struct ag_window*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
switch(msg)
{
case WM_CREATE:
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)((LPCREATESTRUCT)lparam)->lpCreateParams);
break;
case WM_DESTROY:
ag_event__push(ag_event__close_new(window));
break;
case WM_PAINT:
{
struct ag_surface32* surface = window->filtered_surface->output;
BITMAPINFO info;
PAINTSTRUCT ps;
info.bmiHeader.biSize = sizeof(BITMAPINFO);
info.bmiHeader.biWidth = surface->size.w;
info.bmiHeader.biHeight = -surface->size.h;
info.bmiHeader.biPlanes = 1;
info.bmiHeader.biBitCount = 32;
info.bmiHeader.biCompression = BI_RGB;
info.bmiHeader.biSizeImage = 0;
info.bmiHeader.biXPelsPerMeter = 1;
info.bmiHeader.biYPelsPerMeter = 1;
info.bmiHeader.biClrUsed = 0;
info.bmiHeader.biClrImportant = 0;
HDC hdc = BeginPaint(hwnd, &ps);
SetDIBitsToDevice(hdc, 0, 0, surface->size.w, surface->size.h, 0, 0, 0, surface->size.h, surface->data, &info, DIB_RGB_COLORS);
EndPaint(hwnd, &ps);
break;
}
case WM_SIZE:
window->size = ag_vec2i(LOWORD(lparam)/window->filtered_surface->scale, HIWORD(lparam)/window->filtered_surface->scale);
ag_window__reinit_surfaces(window);
if(ag_state_current)
ag_state__run_inner(ag_state_current);
break;
case WM_INPUT:
{
unsigned size;
GetRawInputData((HRAWINPUT)lparam, RID_INPUT, 0, &size, sizeof(RAWINPUTHEADER));
RAWINPUT* input = (RAWINPUT*)malloc(size);
GetRawInputData((HRAWINPUT)lparam, RID_INPUT, input, &size, sizeof(RAWINPUTHEADER));
RAWHID* hid = &input->data.hid;
for(int i = 0; i < hid->dwCount; ++i)
{
printf("[ ");
for(int j = 0; j < hid->dwSizeHid; ++j)
printf("%#04x ", hid->bRawData[j+i*hid->dwSizeHid]);
printf("] ");
}
printf("\n");
}
break;
case WM_MOUSEMOVE:
window->mouse_pos.x = GET_X_LPARAM(lparam) / window->filtered_surface->scale;
window->mouse_pos.y = GET_Y_LPARAM(lparam) / window->filtered_surface->scale;
ag_event__push(ag_event__mouse_move_new(window, window->mouse_pos));
break;
case WM_LBUTTONDOWN:
ag_event__push(ag_event__mouse_down_new(window, window->mouse_pos));
break;
case WM_LBUTTONUP:
ag_event__push(ag_event__mouse_up_new(window, window->mouse_pos));
break;
default:
return DefWindowProc(hwnd, msg, wparam, lparam);
}
return 0;
}
bool Win32Factory::init()
{
const char* vlc_name = "VLC Media Player";
const char* vlc_icon = "VLC_ICON";
const char* vlc_class = "SkinWindowClass";
// Get instance handle
m_hInst = GetModuleHandle( NULL );
if( m_hInst == NULL )
{
msg_Err( getIntf(), "Cannot get module handle" );
}
// Create window class
WNDCLASS skinWindowClass;
skinWindowClass.style = CS_DBLCLKS;
skinWindowClass.lpfnWndProc = (WNDPROC)Win32Factory::Win32Proc;
skinWindowClass.lpszClassName = _T(vlc_class);
skinWindowClass.lpszMenuName = NULL;
skinWindowClass.cbClsExtra = 0;
skinWindowClass.cbWndExtra = 0;
skinWindowClass.hbrBackground = NULL;
skinWindowClass.hCursor = LoadCursor( NULL, IDC_ARROW );
skinWindowClass.hIcon = LoadIcon( m_hInst, _T(vlc_icon) );
skinWindowClass.hInstance = m_hInst;
// Register class and check it
if( !RegisterClass( &skinWindowClass ) )
{
WNDCLASS wndclass;
// Check why it failed. If it's because the class already exists
// then fine, otherwise return with an error.
if( !GetClassInfo( m_hInst, _T(vlc_class), &wndclass ) )
{
msg_Err( getIntf(), "cannot register window class" );
return false;
}
}
// Create Window
m_hParentWindow = CreateWindowEx( WS_EX_TOOLWINDOW, _T(vlc_class),
_T(vlc_name), WS_POPUP | WS_SYSMENU | WS_MINIMIZEBOX,
-200, -200, 0, 0, 0, 0, m_hInst, 0 );
if( m_hParentWindow == NULL )
{
msg_Err( getIntf(), "cannot create parent window" );
return false;
}
// Store with it a pointer to the interface thread
SetWindowLongPtr( m_hParentWindow, GWLP_USERDATA, (LONG_PTR)getIntf() );
// We do it this way otherwise CreateWindowEx will fail
// if WS_EX_LAYERED is not supported
SetWindowLongPtr( m_hParentWindow, GWL_EXSTYLE,
GetWindowLongPtr( m_hParentWindow, GWL_EXSTYLE ) |
WS_EX_LAYERED );
ShowWindow( m_hParentWindow, SW_SHOW );
// Initialize the systray icon
m_trayIcon.cbSize = sizeof( NOTIFYICONDATA );
m_trayIcon.hWnd = m_hParentWindow;
m_trayIcon.uID = 42;
m_trayIcon.uFlags = NIF_ICON|NIF_TIP|NIF_MESSAGE;
m_trayIcon.uCallbackMessage = MY_WM_TRAYACTION;
m_trayIcon.hIcon = LoadIcon( m_hInst, _T(vlc_icon) );
strcpy( m_trayIcon.szTip, vlc_name );
// Show the systray icon if needed
if( var_InheritBool( getIntf(), "skins2-systray" ) )
{
addInTray();
}
// Show the task in the task bar if needed
if( var_InheritBool( getIntf(), "skins2-taskbar" ) )
{
addInTaskBar();
}
// Initialize the OLE library (for drag & drop)
OleInitialize( NULL );
// Initialize the resource path
char *datadir = config_GetUserDir( VLC_DATA_DIR );
m_resourcePath.push_back( (string)datadir + "\\skins" );
free( datadir );
datadir = config_GetDataDir();
m_resourcePath.push_back( (string)datadir + "\\skins" );
m_resourcePath.push_back( (string)datadir + "\\skins2" );
m_resourcePath.push_back( (string)datadir + "\\share\\skins" );
m_resourcePath.push_back( (string)datadir + "\\share\\skins2" );
free( datadir );
// Enumerate all monitors available
EnumDisplayMonitors( NULL, NULL, MonitorEnumProc, (LPARAM)&m_monitorList );
int num = 0;
for( list<HMONITOR>::iterator it = m_monitorList.begin();
it != m_monitorList.end(); ++it, num++ )
{
MONITORINFO mi;
mi.cbSize = sizeof( MONITORINFO );
if( GetMonitorInfo( *it, &mi ) )
{
msg_Dbg( getIntf(), "monitor #%i, %ldx%ld at +%ld+%ld", num,
mi.rcMonitor.right - mi.rcMonitor.left,
mi.rcMonitor.bottom - mi.rcMonitor.top,
mi.rcMonitor.left,
mi.rcMonitor.top );
}
}
// All went well
return true;
}
void Creds_OnUpdate (HWND hDlg)
{
LPTSTR pszCell = (LPTSTR)GetWindowLongPtr (hDlg, DWLP_USER);
if (!pszCell || !*pszCell)
{
BOOL fRunning = IsServiceRunning();
ShowWindow (GetDlgItem (hDlg, IDC_RUNNING), fRunning);
ShowWindow (GetDlgItem (hDlg, IDC_STOPPED), !fRunning);
ShowWindow (GetDlgItem (hDlg, IDC_CREDS_OBTAIN), fRunning);
return;
}
lock_ObtainMutex(&g.credsLock);
size_t iCreds;
for (iCreds = 0; iCreds < g.cCreds; ++iCreds)
{
if (!lstrcmpi (g.aCreds[ iCreds ].szCell, pszCell))
break;
}
TCHAR szGateway[cchRESOURCE] = TEXT("");
if (!g.fIsWinNT)
GetGatewayName (szGateway);
if (!szGateway[0])
{
SetDlgItemText (hDlg, IDC_CREDS_CELL, pszCell);
}
else
{
TCHAR szCell[ cchRESOURCE ];
TCHAR szFormat[ cchRESOURCE ];
GetString (szFormat, IDS_CELL_GATEWAY);
wsprintf (szCell, szFormat, pszCell, szGateway);
SetDlgItemText (hDlg, IDC_CREDS_CELL, szCell);
}
if (iCreds == g.cCreds)
{
TCHAR szText[cchRESOURCE];
GetString (szText, IDS_NO_CREDS);
SetDlgItemText (hDlg, IDC_CREDS_INFO, szText);
}
else
{
// FormatString(%t) expects a date in GMT, not the local time zone...
//
FILETIME ftLocal;
SystemTimeToFileTime (&g.aCreds[ iCreds ].stExpires, &ftLocal);
FILETIME ftGMT;
LocalFileTimeToFileTime (&ftLocal, &ftGMT);
SYSTEMTIME stGMT;
FileTimeToSystemTime (&ftGMT, &stGMT);
SYSTEMTIME stNow;
GetLocalTime (&stNow);
FILETIME ftNow;
SystemTimeToFileTime (&stNow, &ftNow);
LONGLONG llNow = (((LONGLONG)ftNow.dwHighDateTime) << 32) + (LONGLONG)(ftNow.dwLowDateTime);
LONGLONG llExpires = (((LONGLONG)ftLocal.dwHighDateTime) << 32) + (LONGLONG)(ftLocal.dwLowDateTime);
llNow /= c100ns1SECOND;
llExpires /= c100ns1SECOND;
LPTSTR pszCreds = NULL;
if (llExpires <= (llNow + (LONGLONG)cminREMIND_WARN * csec1MINUTE))
pszCreds = FormatString (IDS_CREDS_EXPIRED, TEXT("%s"), g.aCreds[ iCreds ].szUser);
if (!pszCreds || !pszCreds[0])
pszCreds = FormatString (IDS_CREDS, TEXT("%s%t"), g.aCreds[ iCreds ].szUser, &stGMT);
SetDlgItemText (hDlg, IDC_CREDS_INFO, pszCreds);
FreeString (pszCreds);
}
lock_ReleaseMutex(&g.credsLock);
CheckDlgButton (hDlg, IDC_CREDS_REMIND, (iCreds == g.cCreds) ? FALSE : g.aCreds[iCreds].fRemind);
EnableWindow (GetDlgItem (hDlg, IDC_CREDS_OBTAIN), IsServiceRunning());
EnableWindow (GetDlgItem (hDlg, IDC_CREDS_REMIND), (iCreds != g.cCreds));
EnableWindow (GetDlgItem (hDlg, IDC_CREDS_DESTROY), (iCreds != g.cCreds));
}
LRESULT CALLBACK Win32Factory::Win32Proc( HWND hwnd, UINT uMsg,
WPARAM wParam, LPARAM lParam )
{
// Get pointer to thread info: should only work with the parent window
intf_thread_t *p_intf = (intf_thread_t *)GetWindowLongPtr( hwnd,
GWLP_USERDATA );
// If doesn't exist, treat windows message normally
if( p_intf == NULL || p_intf->p_sys->p_osFactory == NULL )
{
return DefWindowProc( hwnd, uMsg, wParam, lParam );
}
Win32Factory *pFactory = (Win32Factory*)Win32Factory::instance( p_intf );
GenericWindow *pWin = pFactory->m_windowMap[hwnd];
if( hwnd == pFactory->getParentWindow() )
{
if( uMsg == WM_SYSCOMMAND )
{
// If closing parent window
if( (wParam & 0xFFF0) == SC_CLOSE )
{
libvlc_Quit( p_intf->p_libvlc );
return 0;
}
else if( (wParam & 0xFFF0) == SC_MINIMIZE )
{
pFactory->minimize();
return 0;
}
else if( (wParam & 0xFFF0) == SC_RESTORE )
{
pFactory->restore();
return 0;
}
else
{
msg_Dbg( p_intf, "WM_SYSCOMMAND %i", (wParam & 0xFFF0) );
}
}
// Handle systray notifications
else if( uMsg == MY_WM_TRAYACTION )
{
if( (UINT)lParam == WM_LBUTTONDOWN )
{
p_intf->p_sys->p_theme->getWindowManager().raiseAll();
CmdDlgHidePopupMenu aCmdPopup( p_intf );
aCmdPopup.execute();
return 0;
}
else if( (UINT)lParam == WM_RBUTTONDOWN )
{
CmdDlgShowPopupMenu aCmdPopup( p_intf );
aCmdPopup.execute();
return 0;
}
else if( (UINT)lParam == WM_LBUTTONDBLCLK )
{
CmdRestore aCmdRestore( p_intf );
aCmdRestore.execute();
return 0;
}
}
}
else if( pWin )
{
Win32Loop* pLoop =
(Win32Loop*) OSFactory::instance( p_intf )->getOSLoop();
if( pLoop )
return pLoop->processEvent( hwnd, uMsg, wParam, lParam );
}
// If hwnd does not match any window or message not processed
return DefWindowProc( hwnd, uMsg, wParam, lParam );
}
//--------------------------------------------------------------------------
bool WindowsVideoDevice::SetupWindowData(VeWindow::Data* pkWindow,
HWND hWnd, VE_BOOL bCreated) noexcept
{
VE_ASSERT(pkWindow);
VeWindowData* pkData = VE_NEW VeWindowData;
VE_ASSERT(pkData);
pkData->m_pkWindow = pkWindow;
pkData->m_hWnd = hWnd;
pkData->m_hDc = GetDC(hWnd);
pkData->m_bCreated = bCreated;
pkData->m_u32MouseButtonFlags = 0;
pkWindow->m_spDriverdata = pkData;
if (!SetProp(hWnd, TEXT("VeWindowData"), pkData))
{
ReleaseDC(hWnd, pkData->m_hDc);
pkWindow->m_spDriverdata = nullptr;
pkData = nullptr;
return false;
}
pkData->m_pfuncWndProc = (WNDPROC)GetWindowLongPtr(hWnd, GWLP_WNDPROC);
if (pkData->m_pfuncWndProc == WindowProc)
{
pkData->m_pfuncWndProc = nullptr;
}
else
{
SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)WindowProc);
}
{
RECT rect;
if (GetClientRect(hWnd, &rect))
{
VeInt32 w = rect.right;
VeInt32 h = rect.bottom;
if ((pkWindow->w && pkWindow->w != w) || (pkWindow->h && pkWindow->h != h))
{
SetWindowPositionInternal(pkWindow,
SWP_NOCOPYBITS | SWP_NOZORDER | SWP_NOACTIVATE);
}
else
{
pkWindow->w = w;
pkWindow->h = h;
}
}
}
{
POINT point;
point.x = 0;
point.y = 0;
if (ClientToScreen(hWnd, &point))
{
pkWindow->x = point.x;
pkWindow->y = point.y;
}
}
{
DWORD style = GetWindowLong(hWnd, GWL_STYLE);
if (style & WS_VISIBLE)
{
pkWindow->m_u32Flags |= VE_WINDOW_SHOWN;
}
else
{
pkWindow->m_u32Flags &= ~VE_WINDOW_SHOWN;
}
if (style & (WS_BORDER | WS_THICKFRAME))
{
pkWindow->m_u32Flags &= ~VE_WINDOW_BORDERLESS;
}
else
{
pkWindow->m_u32Flags |= VE_WINDOW_BORDERLESS;
}
if (style & WS_THICKFRAME)
{
pkWindow->m_u32Flags |= VE_WINDOW_RESIZABLE;
}
else
{
pkWindow->m_u32Flags &= ~VE_WINDOW_RESIZABLE;
}
# ifdef WS_MAXIMIZE
if (style & WS_MAXIMIZE)
{
pkWindow->m_u32Flags |= VE_WINDOW_MAXIMIZED;
}
else
# endif
{
pkWindow->m_u32Flags &= ~VE_WINDOW_MAXIMIZED;
}
# ifdef WS_MINIMIZE
if (style & WS_MINIMIZE)
{
pkWindow->m_u32Flags |= VE_WINDOW_MINIMIZED;
}
else
# endif
{
pkWindow->m_u32Flags &= ~VE_WINDOW_MINIMIZED;
}
}
if (GetFocus() == hWnd)
{
pkWindow->m_u32Flags |= VE_WINDOW_INPUT_FOCUS;
//SDL_SetKeyboardFocus(data->window);
if (pkWindow->m_u32Flags & VE_WINDOW_INPUT_GRABBED)
{
RECT rect;
GetClientRect(hWnd, &rect);
ClientToScreen(hWnd, (LPPOINT)& rect);
ClientToScreen(hWnd, (LPPOINT)& rect + 1);
ClipCursor(&rect);
}
}
/*if (videodata->RegisterTouchWindow)
{
videodata->RegisterTouchWindow(hwnd, (TWF_FINETOUCH | TWF_WANTPALM));
}*/
DragAcceptFiles(hWnd, TRUE);
return true;
}
void guiSubclassWindow(HWND hwnd, WNDPROC newproc) {
SetWindowLongPtr(hwnd, GWLP_USERDATA, GetWindowLongPtr(hwnd, GWLP_WNDPROC));
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LPARAM)newproc);
}
LRESULT WINAPI ColorControlProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
CCStruct *pCCData;
switch(message)
{
case WM_NCCREATE:
{
CREATESTRUCT *pCreateData = (CREATESTRUCT*)lParam;
//add custom data to window
pCCData = (CCStruct*)malloc(sizeof(CCStruct));
zero(pCCData, sizeof(CCStruct));
SetWindowLongPtr(hwnd, 0, (LONG_PTR)pCCData);
pCCData->structSize = sizeof(CCStruct);
pCCData->curColor = 0xFFFFFF;
pCCData->bDisabled = ((pCreateData->style & WS_DISABLED) != 0);
pCCData->cx = pCreateData->cx;
pCCData->cy = pCreateData->cy;
for(int i=0; i<16; i++) pCCData->custColors[i] = 0xC0C0C0;
return TRUE;
}
case WM_DESTROY:
{
pCCData = (CCStruct*)GetWindowLongPtr(hwnd, 0);
if(pCCData)
free(pCCData);
break;
}
case WM_PAINT:
{
pCCData = (CCStruct*)GetWindowLongPtr(hwnd, 0);
PAINTSTRUCT ps;
HDC hDC = BeginPaint(hwnd, &ps);
DrawColorControl(hDC, pCCData);
EndPaint(hwnd, &ps);
break;
}
case WM_ENABLE:
{
pCCData = (CCStruct*)GetWindowLongPtr(hwnd, 0);
pCCData->bDisabled = !wParam;
//redraw control
HDC hDC = GetDC(hwnd);
DrawColorControl(hDC, pCCData);
ReleaseDC(hwnd, hDC);
break;
}
case WM_LBUTTONDBLCLK:
{
pCCData = (CCStruct*)GetWindowLongPtr(hwnd, 0);
if(pCCData->bDisabled)
break;
CHOOSECOLOR chooserData;
zero(&chooserData, sizeof(chooserData));
chooserData.lStructSize = sizeof(chooserData);
chooserData.hwndOwner = GetParent(hwnd);
chooserData.Flags = CC_RGBINIT | CC_FULLOPEN;
chooserData.rgbResult = pCCData->curColor;
chooserData.lpCustColors = pCCData->custColors;
if(ChooseColor(&chooserData))
{
pCCData->curColor = chooserData.rgbResult;
HDC hDC = GetDC(hwnd);
DrawColorControl(hDC, pCCData);
ReleaseDC(hwnd, hDC);
HWND hwndParent = GetParent(hwnd);
DWORD controlID = (DWORD)GetWindowLongPtr(hwnd, GWLP_ID);
SendMessage(hwndParent, WM_COMMAND, MAKEWPARAM(controlID, CCN_CHANGED), (LPARAM)hwnd);
}
break;
}
default:
return DefWindowProc(hwnd, message, wParam, lParam);
}
return 0;
}
INT_PTR CALLBACK CConfig::NotificationsDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
char buf[128];
switch (uMsg) {
case WM_INITDIALOG:
{
m_bInitializingDialog = true;
// Translate the dialog
TranslateDialogDefault(hwndDlg);
// Initialize the protocol filter list
SetWindowLongPtr(GetDlgItem(hwndDlg, IDC_PROTOCOLS), GWL_STYLE, GetWindowLongPtr(GetDlgItem(hwndDlg, IDC_PROTOCOLS), GWL_STYLE) | TVS_NOHSCROLL);
int iRes = 0;
HIMAGELIST himlCheckBoxes;
himlCheckBoxes = ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), ILC_COLOR32 | ILC_MASK, 2, 2);
iRes = ImageList_AddIcon(himlCheckBoxes, LoadIcon(hInstance, MAKEINTRESOURCE(IDI_NOTICK)));
iRes = ImageList_AddIcon(himlCheckBoxes, LoadIcon(hInstance, MAKEINTRESOURCE(IDI_TICK)));
TreeView_SetImageList(GetDlgItem(hwndDlg, IDC_PROTOCOLS), himlCheckBoxes, TVSIL_NORMAL);
FillTree(GetDlgItem(hwndDlg, IDC_PROTOCOLS));
CheckDlgButton(hwndDlg, IDC_NOTIFY_TIMESTAMPS, m_abBoolSettings[NOTIFY_TIMESTAMPS] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_SHOWPROTO, m_abBoolSettings[NOTIFY_SHOWPROTO] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_CHANNELCUTOFF, m_abBoolSettings[NOTIFY_CHANNELCUTOFF] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_NICKCUTOFF, m_abBoolSettings[NOTIFY_NICKCUTOFF] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_IRC_MESSAGES, m_abBoolSettings[NOTIFY_IRC_MESSAGES] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_IRC_USERS, m_abBoolSettings[NOTIFY_IRC_USERS] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_IRC_EMOTES, m_abBoolSettings[NOTIFY_IRC_EMOTES] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_IRC_NOTICES, m_abBoolSettings[NOTIFY_IRC_NOTICES] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_IRC_CHANNEL, m_abBoolSettings[NOTIFY_IRC_CHANNEL] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_IRC_STATUS, m_abBoolSettings[NOTIFY_IRC_STATUS] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_PROTO_STATUS, m_abBoolSettings[NOTIFY_PROTO_STATUS] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_PROTO_SIGNON, m_abBoolSettings[NOTIFY_PROTO_SIGNON] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_PROTO_SIGNOFF, m_abBoolSettings[NOTIFY_PROTO_SIGNOFF] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_SIGNON, m_abBoolSettings[NOTIFY_SIGNON] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_SIGNOFF, m_abBoolSettings[NOTIFY_SIGNOFF] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_STATUS, m_abBoolSettings[NOTIFY_STATUS] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_MESSAGES, m_abBoolSettings[NOTIFY_MESSAGES] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_FILE, m_abBoolSettings[NOTIFY_FILE] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_CONTACTS, m_abBoolSettings[NOTIFY_CONTACTS] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_URL, m_abBoolSettings[NOTIFY_URL] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_NO_SKIP_REPLY, m_abBoolSettings[NOTIFY_NO_SKIP_REPLY] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_SKIP_SIGNON, m_abBoolSettings[NOTIFY_SKIP_SIGNON] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_SKIP_SIGNOFF, m_abBoolSettings[NOTIFY_SKIP_SIGNOFF] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_SKIP_STATUS, m_abBoolSettings[NOTIFY_SKIP_STATUS] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_SKIP_MESSAGES, m_abBoolSettings[NOTIFY_SKIP_MESSAGES] ? BST_CHECKED : BST_UNCHECKED);
_itoa_s(m_aiIntSettings[NOTIFY_CHANNELCUTOFF_OFFSET], buf, _countof(buf), 10);
SetDlgItemTextA(hwndDlg, IDC_NOTIFY_CHANNELCUTOFF_OFFSET, buf);
_itoa_s(m_aiIntSettings[NOTIFY_NICKCUTOFF_OFFSET], buf, _countof(buf), 10);
SetDlgItemTextA(hwndDlg, IDC_NOTIFY_NICKCUTOFF_OFFSET, buf);
_itoa_s(m_aiIntSettings[NOTIFY_LOGSIZE], buf, _countof(buf), 10);
SetDlgItemTextA(hwndDlg, IDC_NOTIFY_LOGSIZE, buf);
_itoa_s(m_aiIntSettings[NOTIFY_DURATION], buf, _countof(buf), 10);
SetDlgItemTextA(hwndDlg, IDC_NOTIFY_DURATION, buf);
CheckDlgButton(hwndDlg, IDC_NOTIFY_TITLEHIDE, m_aiIntSettings[NOTIFY_TITLE] == NOTIFY_TITLE_HIDE ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_TITLENAME, m_aiIntSettings[NOTIFY_TITLE] == NOTIFY_TITLE_NAME ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_NOTIFY_TITLEINFO, m_aiIntSettings[NOTIFY_TITLE] == NOTIFY_TITLE_INFO ? BST_CHECKED : BST_UNCHECKED);
m_bInitializingDialog = false;
break;
}
case WM_NOTIFY:
{
if (((LPNMHDR)lParam)->idFrom == IDC_PROTOCOLS) {
if (((LPNMHDR)lParam)->code != NM_CLICK)
return 0;
TVHITTESTINFO hti;
hti.pt.x = (short)LOWORD(GetMessagePos());
hti.pt.y = (short)HIWORD(GetMessagePos());
ScreenToClient(((LPNMHDR)lParam)->hwndFrom, &hti.pt);
if (TreeView_HitTest(((LPNMHDR)lParam)->hwndFrom, &hti))
if (hti.flags&TVHT_ONITEMICON) {
TVITEM tvi;
tvi.mask = TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
tvi.hItem = hti.hItem;
TreeView_GetItem(((LPNMHDR)lParam)->hwndFrom, &tvi);
tvi.iImage = tvi.iSelectedImage = !tvi.iImage;
((CProtoFilter *)tvi.lParam)->bTempNotificationFilter = tvi.iImage != 0;
TreeView_SetItem(((LPNMHDR)lParam)->hwndFrom, &tvi);
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
}
break;
}
switch (((LPNMHDR)lParam)->code) {
case PSN_APPLY:
{
m_abBoolSettings[NOTIFY_TIMESTAMPS] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_TIMESTAMPS) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_CHANNELCUTOFF] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_CHANNELCUTOFF) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_NICKCUTOFF] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_NICKCUTOFF) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_SHOWPROTO] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_SHOWPROTO) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_IRC_MESSAGES] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_IRC_MESSAGES) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_IRC_USERS] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_IRC_USERS) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_IRC_EMOTES] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_IRC_EMOTES) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_IRC_NOTICES] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_IRC_NOTICES) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_IRC_CHANNEL] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_IRC_CHANNEL) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_IRC_STATUS] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_IRC_STATUS) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_PROTO_STATUS] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_PROTO_STATUS) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_PROTO_SIGNON] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_PROTO_SIGNON) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_PROTO_SIGNOFF] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_PROTO_SIGNOFF) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_MESSAGES] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_MESSAGES) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_SIGNON] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_SIGNON) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_SIGNOFF] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_SIGNOFF) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_STATUS] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_STATUS) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_URL] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_URL) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_FILE] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_FILE) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_CONTACTS] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_CONTACTS) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_NO_SKIP_REPLY] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_NO_SKIP_REPLY) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_SKIP_MESSAGES] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_SKIP_MESSAGES) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_SKIP_SIGNON] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_SKIP_SIGNON) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_SKIP_SIGNOFF] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_SKIP_SIGNOFF) == BST_CHECKED ? true : false;
m_abBoolSettings[NOTIFY_SKIP_STATUS] = IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_SKIP_STATUS) == BST_CHECKED ? true : false;
GetDlgItemTextA(hwndDlg, IDC_NOTIFY_CHANNELCUTOFF_OFFSET, buf, _countof(buf));
m_aiIntSettings[NOTIFY_CHANNELCUTOFF_OFFSET] = atoi(buf) > 0 ? atoi(buf) : 1;
GetDlgItemTextA(hwndDlg, IDC_NOTIFY_NICKCUTOFF_OFFSET, buf, _countof(buf));
m_aiIntSettings[NOTIFY_NICKCUTOFF_OFFSET] = atoi(buf) > 0 ? atoi(buf) : 1;
GetDlgItemTextA(hwndDlg, IDC_NOTIFY_DURATION, buf, _countof(buf));
m_aiIntSettings[NOTIFY_DURATION] = atoi(buf) > 0 ? atoi(buf) : 1;
GetDlgItemTextA(hwndDlg, IDC_NOTIFY_LOGSIZE, buf, _countof(buf));
m_aiIntSettings[NOTIFY_LOGSIZE] = atoi(buf) > 0 ? atoi(buf) : 1;
if (IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_TITLEHIDE) == BST_CHECKED)
m_aiIntSettings[NOTIFY_TITLE] = NOTIFY_TITLE_HIDE;
else if (IsDlgButtonChecked(hwndDlg, IDC_NOTIFY_TITLENAME) == BST_CHECKED)
m_aiIntSettings[NOTIFY_TITLE] = NOTIFY_TITLE_NAME;
else
m_aiIntSettings[NOTIFY_TITLE] = NOTIFY_TITLE_INFO;
// apply all contactlist protocol filters
vector<CProtoFilter*>::iterator iter = m_ProtoList.begin();
while (iter != m_ProtoList.end()) {
(*iter)->bNotificationFilter = (*iter)->bTempNotificationFilter;
iter++;
}
CConfig::SaveSettings();
SendMessage(hwndDlg, WM_INITDIALOG, 0, 0);
break;
}
}
break;
}
case WM_COMMAND:
{
// Activate the apply button
if (!m_bInitializingDialog && ((HIWORD(wParam) == EN_CHANGE) || (HIWORD(wParam) == BN_CLICKED)))
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
}
return 0;
}
void Aggregates_SubclassList (HWND hDlg)
{
HWND hList = GetDlgItem (hDlg, IDC_AGG_LIST);
procAggregatesList = GetWindowLongPtr (hList, GWLP_WNDPROC);
SetWindowLongPtr (hList, GWLP_WNDPROC, (LONG_PTR)Aggregates_SubclassListProc);
}
INT_PTR CALLBACK CConfig::ContactlistDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg) {
case WM_INITDIALOG:
{
m_bInitializingDialog = true;
// Translate the dialog
TranslateDialogDefault(hwndDlg);
// Initialize the protocol filter list
SetWindowLongPtr(GetDlgItem(hwndDlg, IDC_CLIST_PROTOFILTER), GWL_STYLE, GetWindowLongPtr(GetDlgItem(hwndDlg, IDC_CLIST_PROTOFILTER), GWL_STYLE) | TVS_NOHSCROLL);
int iRes = 0;
HIMAGELIST himlCheckBoxes;
himlCheckBoxes = ImageList_Create(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), ILC_COLOR32 | ILC_MASK, 2, 2);
iRes = ImageList_AddIcon(himlCheckBoxes, LoadIcon(hInstance, MAKEINTRESOURCE(IDI_NOTICK)));
iRes = ImageList_AddIcon(himlCheckBoxes, LoadIcon(hInstance, MAKEINTRESOURCE(IDI_TICK)));
TreeView_SetImageList(GetDlgItem(hwndDlg, IDC_CLIST_PROTOFILTER), himlCheckBoxes, TVSIL_NORMAL);
FillTree(GetDlgItem(hwndDlg, IDC_CLIST_PROTOFILTER), true);
CheckDlgButton(hwndDlg, IDC_CLIST_SELECTION, m_abBoolSettings[CLIST_SELECTION] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_CLIST_COLUMNS, m_abBoolSettings[CLIST_COLUMNS] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_CLIST_HIDEOFFLINE, m_abBoolSettings[CLIST_HIDEOFFLINE] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_CLIST_USEIGNORE, m_abBoolSettings[CLIST_USEIGNORE] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_CLIST_USEGROUPS, m_abBoolSettings[CLIST_USEGROUPS] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_CLIST_SHOWPROTO, m_abBoolSettings[CLIST_SHOWPROTO] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_CLIST_DRAWLINES, m_abBoolSettings[CLIST_DRAWLINES] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_CLIST_POSITION, m_abBoolSettings[CLIST_POSITION] ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hwndDlg, IDC_CLIST_COUNTERS, m_abBoolSettings[CLIST_COUNTERS] ? BST_CHECKED : BST_UNCHECKED);
if (m_aiIntSettings[CLIST_GA] == CLIST_GA_NONE)
CheckDlgButton(hwndDlg, IDC_CLIST_GA_NONE, BST_CHECKED);
else if (m_aiIntSettings[CLIST_GA] == CLIST_GA_COLLAPSE)
CheckDlgButton(hwndDlg, IDC_CLIST_GA_COLLAPSE, BST_CHECKED);
else
CheckDlgButton(hwndDlg, IDC_CLIST_GA_EXPAND, BST_CHECKED);
m_bInitializingDialog = false;
break;
}
case WM_NOTIFY:
{
if (((LPNMHDR)lParam)->idFrom == IDC_CLIST_PROTOFILTER) {
if (((LPNMHDR)lParam)->code != NM_CLICK)
return 0;
TVHITTESTINFO hti;
hti.pt.x = (short)LOWORD(GetMessagePos());
hti.pt.y = (short)HIWORD(GetMessagePos());
ScreenToClient(((LPNMHDR)lParam)->hwndFrom, &hti.pt);
if (TreeView_HitTest(((LPNMHDR)lParam)->hwndFrom, &hti))
if (hti.flags&TVHT_ONITEMICON) {
TVITEM tvi;
tvi.mask = TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
tvi.hItem = hti.hItem;
TreeView_GetItem(((LPNMHDR)lParam)->hwndFrom, &tvi);
tvi.iImage = tvi.iSelectedImage = !tvi.iImage;
((CProtoFilter *)tvi.lParam)->bTempContactlistFilter = tvi.iImage != 0;
TreeView_SetItem(((LPNMHDR)lParam)->hwndFrom, &tvi);
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
}
break;
}
switch (((LPNMHDR)lParam)->code) {
case PSN_APPLY:
{
m_abBoolSettings[CLIST_SELECTION] = IsDlgButtonChecked(hwndDlg, IDC_CLIST_SELECTION) == BST_CHECKED ? true : false;
m_abBoolSettings[CLIST_COLUMNS] = IsDlgButtonChecked(hwndDlg, IDC_CLIST_COLUMNS) == BST_CHECKED ? true : false;
m_abBoolSettings[CLIST_HIDEOFFLINE] = IsDlgButtonChecked(hwndDlg, IDC_CLIST_HIDEOFFLINE) == BST_CHECKED ? true : false;
m_abBoolSettings[CLIST_USEGROUPS] = IsDlgButtonChecked(hwndDlg, IDC_CLIST_USEGROUPS) == BST_CHECKED ? true : false;
m_abBoolSettings[CLIST_USEIGNORE] = IsDlgButtonChecked(hwndDlg, IDC_CLIST_USEIGNORE) == BST_CHECKED ? true : false;
m_abBoolSettings[CLIST_SHOWPROTO] = IsDlgButtonChecked(hwndDlg, IDC_CLIST_SHOWPROTO) == BST_CHECKED ? true : false;
m_abBoolSettings[CLIST_DRAWLINES] = IsDlgButtonChecked(hwndDlg, IDC_CLIST_DRAWLINES) == BST_CHECKED ? true : false;
m_abBoolSettings[CLIST_POSITION] = IsDlgButtonChecked(hwndDlg, IDC_CLIST_POSITION) == BST_CHECKED ? true : false;
m_abBoolSettings[CLIST_COUNTERS] = IsDlgButtonChecked(hwndDlg, IDC_CLIST_COUNTERS) == BST_CHECKED ? true : false;
if (IsDlgButtonChecked(hwndDlg, IDC_CLIST_GA_NONE) == BST_CHECKED)
m_aiIntSettings[CLIST_GA] = CLIST_GA_NONE;
else if (IsDlgButtonChecked(hwndDlg, IDC_CLIST_GA_COLLAPSE) == BST_CHECKED)
m_aiIntSettings[CLIST_GA] = CLIST_GA_COLLAPSE;
else
m_aiIntSettings[CLIST_GA] = CLIST_GA_EXPAND;
// apply all contactlist protocol filters
vector<CProtoFilter*>::iterator iter = m_ProtoList.begin();
while (iter != m_ProtoList.end()) {
(*iter)->bContactlistFilter = (*iter)->bTempContactlistFilter;
iter++;
}
CConfig::SaveSettings();
SendMessage(hwndDlg, WM_INITDIALOG, 0, 0);
break;
}
}
break;
}
case WM_COMMAND:
{
// Activate the apply button
if (!m_bInitializingDialog && ((HIWORD(wParam) == EN_CHANGE) || (HIWORD(wParam) == BN_CLICKED)))
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
}
return 0;
}
int APIENTRY WinMain(HINSTANCE hCurrentInst, HINSTANCE hPreviousInst, LPSTR lpszCmdLine, int nCmdShow) {
openConsoleWindow();
HINSTANCE hinst = hCurrentInst;
registerWindowsClass(hinst);
setupApplication();
double avg_frame_time = 0.0;
double next_frame_time=-1.0, last_frame_time=0.0;
int frame_num = 0;
::ShowWindow( hwnd, SW_SHOW );
::SetForegroundWindow( hwnd );
::SetFocus( hwnd );
// do the draw/update/event loop
MSG msg;
bool quit = false;
while(!quit) {
if( ::PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) {
if(msg.message == WM_QUIT) {
cleanupApplication();
poWindow *win = (poWindow*)GetWindowLongPtr(hwnd,GWL_USERDATA);
delete win;
cleanupWindow();
break;
}
::TranslateMessage( &msg );
::DispatchMessage( &msg );
}
double now = getTiming();
if(now >= next_frame_time) {
next_frame_time = now + 1.0 / 60.0;
double dt = now - last_frame_time;
poWindow *win = (poWindow*)GetWindowLongPtr(hwnd,GWL_USERDATA);
if(win) {
win->makeCurrent();
win->update();
win->draw();
}
SwapBuffers(dc);
frame_num++;
last_frame_time = now;
}
else {
Sleep(1);
}
}
cleanupWindow();
#if defined WIN32 && defined _DEBUG
//_CrtDumpMemoryLeaks();
#endif
return msg.wParam;
}
//WM_COMMAND
void PBSettings_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
(void) hwndCtl; //To avoid the warning
//Get the PBSDP
PenBrushSettingsDlgParam * pbsdp=(PenBrushSettingsDlgParam *)(LONG_PTR)GetWindowLongPtr(hwnd,GWLP_USERDATA);
if(pbsdp==NULL)
return;
switch(id)
{
case IDOK: //OK button
if(codeNotify==BN_CLICKED)
{
fgColor=pbsdp->workingFG;
bgColor=pbsdp->workingBG;
}
//Note: no break
case IDCANCEL: //Cancel button
if(codeNotify==BN_CLICKED)
EndDialog(hwnd,id);
break; //case IDCANCEL: (and IDOK:)
case IDC_PB_B_COLOR: //Click on the color pane: ask the user a new color and update the preview and the color pane
if(codeNotify==BN_CLICKED)
{
pbsdp->GetCurrentCU().SetColor(GetColor(hwnd,pbsdp->GetCurrentCU().GetColor(),dsUpdater->GetDibSection()));
InvalidateRect(GetDlgItem(hwnd,IDC_PB_B_COLOR),NULL,FALSE);
UpdatePreviewPane(hwnd);
}
break; //case IDC_PB_B_COLOR:
case IDC_PB_H_COLORP: //Click on the hatch color pane: ask the user a new color and update the preview and the hatch color pane
if(codeNotify==BN_CLICKED)
{
pbsdp->workingBG.GetRefACUPs().bgColor=pbsdp->workingFG.GetRefACUPs().bgColor=GetColor(hwnd,pbsdp->workingBG.GetRefACUPs().bgColor,dsUpdater->GetDibSection());
InvalidateRect(GetDlgItem(hwnd,IDC_PB_H_COLORP),NULL,FALSE);
UpdatePreviewPane(hwnd);
}
break; //case IDC_PB_H_COLORP:
case IDC_PB_H_COLOR: //Click on the transparent/opaque secondary hatch color radio buttons
case IDC_PB_H_TRANSPARENT:
if(codeNotify==BN_CLICKED)
{
//Update the ColorUtils
CommonControls2ColorUtils(hwnd);
//Update the preview pane
UpdatePreviewPane(hwnd);
}
break; //case IDC_PB_H_COLOR: / IDC_PB_H_TRANSPARENT:
case IDC_PB_PREVIEW: //Click on the preview pane
if(codeNotify==BN_CLICKED)
{
pbsdp->swappedColors=!pbsdp->swappedColors;
//Update the preview pane
UpdatePreviewPane(hwnd);
}
break; //case IDC_PB_PREVIEW:
case IDC_PB_TX_WIDTH:
if(codeNotify==EN_CHANGE)
{
static UINT lastVal=pbsdp->workingFG.GetPenWidth();
if(ValidateUIntFieldChange(hwnd,(WORD)id,lastVal,MINPENWIDTH,MAXPENWIDTH))
{
//Update the ColorUtils
CommonControls2ColorUtils(hwnd);
//Update the preview pane
UpdatePreviewPane(hwnd);
}
}
default: //Others
//Brush radiobuttons: update the ColorUtils and the preview pane
if(
BETWEEN(id,IDC_PB_B_SOLID,IDC_PB_B_HDI) &&
codeNotify == BN_CLICKED
)
{
pbsdp->GetCurrentCU().SetBrushSettings(BrushFromCtrls(hwnd,pbsdp->GetCurrentCU().GetColor()));
UpdatePreviewPane(hwnd);
break;
}
//Pen radiobuttons: update the ColorUtils and the preview pane
else if(
BETWEEN(id,IDC_PB_P_SOLID,IDC_PB_P_CUSTOM) ||
BETWEEN(id,IDC_PB_P_END_ROUND,IDC_PB_P_END_FLAT) ||
BETWEEN(id,IDC_PB_P_LJ_ROUND,IDC_PB_P_LJ_MITER) ||
id==IDC_PB_P_TX_CUSTOM && codeNotify == EN_CHANGE
)
{
nEXTLOGPEN lp=PenFromCtrls(hwnd,pbsdp->GetCurrentCU().GetPenWidth());
if(id == IDC_PB_P_CUSTOM)
{
EnableWindow(GetDlgItem(hwnd,IDC_PB_P_TX_CUSTOM),TRUE);
ShowWindow(GetDlgItem(hwnd,IDC_PB_P_IS_CUSTOM),SW_SHOWNA);
}
else if(BETWEEN(id,IDC_PB_P_SOLID,IDC_PB_P_DASHDOTDOT))
{
EnableWindow(GetDlgItem(hwnd,IDC_PB_P_TX_CUSTOM),FALSE);
ShowWindow(GetDlgItem(hwnd,IDC_PB_P_IS_CUSTOM),SW_HIDE);
}
pbsdp->GetCurrentCU().SetPenSettings(lp);
if(((lp.dwPenStyle&PS_STYLE_MASK)==PS_USERSTYLE)&&lp.lpStyle!=NULL)
delete[] lp.lpStyle;
UpdatePreviewPane(hwnd);
break;
}
}
}
/* Property page dialog callback */
INT_PTR CALLBACK
StartRecDlgProc(HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
PSTARTINFO pStartInfo;
PBOOTRECORD pRecord;
int iTimeout;
LRESULT lResult;
WCHAR szTimeout[10];
UNREFERENCED_PARAMETER(lParam);
pStartInfo = (PSTARTINFO)GetWindowLongPtr(hwndDlg, DWLP_USER);
switch(uMsg)
{
case WM_INITDIALOG:
pStartInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(STARTINFO));
SetWindowLongPtr(hwndDlg, DWLP_USER, (LONG_PTR)pStartInfo);
LoadRecoveryOptions(hwndDlg, pStartInfo);
SetRecoveryTimeout(hwndDlg, 0);
return LoadOSList(hwndDlg, pStartInfo);
case WM_DESTROY:
DeleteBootRecords(hwndDlg);
HeapFree(GetProcessHeap(), 0, pStartInfo);
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDC_STRRECEDIT:
ShellExecuteW(0, L"open", L"notepad", pStartInfo->szFreeldrIni, NULL, SW_SHOWNORMAL);
// FIXME: Use CreateProcess and wait untill finished
// DeleteBootRecords(hwndDlg);
// LoadOSList(hwndDlg);
break;
case IDOK:
/* Save timeout */
if (SendDlgItemMessage(hwndDlg, IDC_STRECLIST, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
iTimeout = SendDlgItemMessage(hwndDlg, IDC_STRRECLISTUPDWN, UDM_GETPOS, (WPARAM)0, (LPARAM)0);
else
iTimeout = 0;
swprintf(szTimeout, L"%i", iTimeout);
lResult = SendDlgItemMessageW(hwndDlg, IDC_STRECOSCOMBO, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
if (lResult == CB_ERR)
{
/* ? */
DeleteBootRecords(hwndDlg);
return TRUE;
}
pRecord = (PBOOTRECORD) SendDlgItemMessage(hwndDlg, IDC_STRECOSCOMBO, CB_GETITEMDATA, (WPARAM)lResult, (LPARAM)0);
if ((INT_PTR)pRecord != CB_ERR)
{
if (pStartInfo->iFreeLdrIni == 1) // FreeLdrIni style
{
/* Set default timeout */
WritePrivateProfileStringW(L"FREELOADER",
L"TimeOut",
szTimeout,
pStartInfo->szFreeldrIni);
/* Set default OS */
WritePrivateProfileStringW(L"FREELOADER",
L"DefaultOS",
pRecord->szSectionName,
pStartInfo->szFreeldrIni);
}
else if (pStartInfo->iFreeLdrIni == 2) // BootIni style
{
/* Set default timeout */
WritePrivateProfileStringW(L"boot loader",
L"timeout",
szTimeout,
pStartInfo->szFreeldrIni);
/* Set default OS */
WritePrivateProfileStringW(L"boot loader",
L"default",
pRecord->szBootPath,
pStartInfo->szFreeldrIni);
}
}
if (SaveRecoveryOptions)
{
WriteStartupRecoveryOptions(hwndDlg, pStartInfo);
}
EndDialog(hwndDlg,
LOWORD(wParam));
return TRUE;
case IDCANCEL:
EndDialog(hwndDlg,
LOWORD(wParam));
return TRUE;
case IDC_STRECLIST:
if (SendDlgItemMessage(hwndDlg, IDC_STRECLIST, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
SetTimeout(hwndDlg, 30);
else
SetTimeout(hwndDlg, 0);
break;
case IDC_STRRECREC:
if (SendDlgItemMessage(hwndDlg, IDC_STRRECREC, BM_GETCHECK, (WPARAM)0, (LPARAM)0) == BST_CHECKED)
SetRecoveryTimeout(hwndDlg, 30);
else
SetRecoveryTimeout(hwndDlg, 0);
break;
case IDC_STRRECDEBUGCOMBO:
if (HIWORD(wParam) == CBN_SELCHANGE)
{
LRESULT lResult;
lResult = SendDlgItemMessage(hwndDlg, IDC_STRRECDEBUGCOMBO, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
if (lResult != CB_ERR && lResult != (LRESULT)pStartInfo->dwCrashDumpEnabled)
{
if (pStartInfo->dwCrashDumpEnabled == 1 || pStartInfo->dwCrashDumpEnabled == 2)
{
SendDlgItemMessageW(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szDumpFile) / sizeof(WCHAR), (LPARAM)pStartInfo->szDumpFile);
}
else if (pStartInfo->dwCrashDumpEnabled == 3)
{
SendDlgItemMessageW(hwndDlg, IDC_STRRECDUMPFILE, WM_GETTEXT, (WPARAM)sizeof(pStartInfo->szMinidumpDir) / sizeof(WCHAR), (LPARAM)pStartInfo->szMinidumpDir);
}
pStartInfo->dwCrashDumpEnabled = (DWORD)lResult;
SetCrashDlgItems(hwndDlg, pStartInfo);
}
}
break;
}
break;
}
return FALSE;
}
HRESULT CALLBACK DlgProc_Browse (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
{
BROWSEDIALOGPARAMS *pbdp;
if (AfsAppLib_HandleHelp (IDD_APPLIB_BROWSE, hDlg, msg, wp, lp))
{
return FALSE;
}
if (msg == WM_INITDIALOG)
{
SetWindowLongPtr (hDlg, DWLP_USER, lp);
}
if ((pbdp = (BROWSEDIALOGPARAMS *)GetWindowLongPtr (hDlg, DWLP_USER)) != NULL)
{
switch (msg)
{
case WM_INITDIALOG:
DlgProc_Browse_OnInitDialog (hDlg, pbdp);
break;
case WM_NOTIFY:
switch (((LPNMHDR)lp)->code)
{
case LVN_ITEMCHANGED:
if ( ((LPNM_LISTVIEW)lp)->uNewState & LVIS_SELECTED )
{
DlgProc_Browse_SelectedEntry (hDlg, pbdp);
}
break;
case NM_DBLCLK:
PostMessage (hDlg, WM_COMMAND, MAKELONG(IDC_BROWSE_SELECT,BN_CLICKED), (LPARAM)GetDlgItem(hDlg,IDC_BROWSE_SELECT));
break;
}
break;
case WM_DESTROY:
DlgProc_Browse_StopSearch (pbdp);
if (pbdp->hImages != NULL)
{
ListView_SetImageList (GetDlgItem (hDlg, IDC_BROWSE_LIST), 0, 0);
ImageList_Destroy (pbdp->hImages);
}
break;
case WM_FOUNDNAME:
{
LPTSTR pszName = (LPTSTR)lp;
if (pszName != NULL)
{
HWND hList = GetDlgItem (hDlg, IDC_BROWSE_LIST);
LV_AddItem (hList, 1, INDEX_SORT, 0, 0, pszName);
FreeString (pszName);
}
break;
}
case WM_THREADSTART:
{
TCHAR szText[ cchRESOURCE ];
GetString (szText, IDS_BROWSE_WAITING);
SetDlgItemText (pbdp->hDlg, IDC_BROWSE_STATUS, szText);
break;
}
case WM_THREADDONE:
{
SetDlgItemText (pbdp->hDlg, IDC_BROWSE_STATUS, TEXT(""));
break;
}
case WM_COMMAND:
switch (LOWORD(wp))
{
case IDCANCEL:
EndDialog (hDlg, LOWORD(wp));
break;
case IDC_BROWSE_SELECT:
if ( (GetDlgItem (pbdp->hDlg, IDC_BROWSE_NONE) != NULL) &&
(IsDlgButtonChecked (pbdp->hDlg, IDC_BROWSE_NONE)) )
{
pbdp->szCell[0] = TEXT('\0');
pbdp->szNamed[0] = TEXT('\0');
}
else
{
GetDlgItemText (hDlg, IDC_BROWSE_CELL, pbdp->szCell, cchNAME);
GetDlgItemText (hDlg, IDC_BROWSE_NAMED, pbdp->szNamed, cchRESOURCE);
}
EndDialog (hDlg, IDOK);
break;
case IDC_BROWSE_CELL:
if (HIWORD(wp) == CBN_SELCHANGE)
{
GetDlgItemText (hDlg, IDC_BROWSE_CELL, pbdp->szCell, cchNAME);
DlgProc_Browse_StartSearch (pbdp, FALSE);
}
break;
case IDC_BROWSE_RESTART:
GetDlgItemText (hDlg, IDC_BROWSE_CELL, pbdp->szCell, cchNAME);
DlgProc_Browse_StartSearch (pbdp, FALSE);
PostMessage (hDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem (hDlg, IDC_BROWSE_NAMED), (LPARAM)TRUE);
break;
case IDC_BROWSE_NAMED:
if (HIWORD(wp) == EN_UPDATE) // has the user hit Enter here?
{
TCHAR szTest[ cchRESOURCE ];
GetDlgItemText (hDlg, IDC_BROWSE_NAMED, szTest, cchRESOURCE);
if ( (lstrlen (szTest) > 0) &&
(szTest[ lstrlen(szTest)-1 ] == TEXT('\n')) )
{
szTest[ lstrlen(szTest)-1 ] = TEXT('\0');
if ( (lstrlen (szTest) > 0) &&
(szTest[ lstrlen(szTest)-1 ] == TEXT('\r')) )
{
szTest[ lstrlen(szTest)-1 ] = TEXT('\0');
}
SetDlgItemText (hDlg, IDC_BROWSE_NAMED, szTest);
PostMessage (hDlg, WM_COMMAND, MAKELONG(IDC_BROWSE_SELECT,BN_CLICKED), (LPARAM)GetDlgItem(hDlg,IDC_BROWSE_SELECT));
}
}
break;
case IDC_BROWSE_NONE:
DlgProc_Browse_OnNone (hDlg, pbdp);
break;
}
break;
}
}
return FALSE;
}
static INT_PTR CALLBACK DefInpProc(HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
{
switch (Msg) {
case WM_INITDIALOG: {
hIpsDlg = hDlg;
hWhiteBGBrush = CreateSolidBrush(RGB(0xFF,0xFF,0xFF));
hPreview = PNGLoadBitmap(hIpsDlg, NULL, 304, 228, 2);
SendDlgItemMessage(hIpsDlg, IDC_SCREENSHOT_H, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hPreview);
LONG_PTR Style;
Style = GetWindowLongPtr (GetDlgItem(hIpsDlg, IDC_TREE1), GWL_STYLE);
Style |= TVS_CHECKBOXES;
SetWindowLongPtr (GetDlgItem(hIpsDlg, IDC_TREE1), GWL_STYLE, Style);
IpsManagerInit();
WndInMid(hDlg, hScrnWnd);
SetFocus(hDlg); // Enable Esc=close
break;
}
case WM_COMMAND: {
int wID = LOWORD(wParam);
int Notify = HIWORD(wParam);
if (Notify == BN_CLICKED) {
switch (wID) {
case IDOK: {
IpsOkay();
break;
}
case IDCANCEL: {
SendMessage(hDlg, WM_CLOSE, 0, 0);
return 0;
}
case IDC_IPSMAN_DESELECTALL: {
for (int i = 0; i < nNumPatches; i++) {
for (int j = 0; j < nNumPatches; j++) {
_TreeView_SetCheckState(hIpsList, hPatchHandlesIndex[j], FALSE);
}
}
break;
}
}
}
if (wID == IDC_CHOOSE_LIST && Notify == CBN_SELCHANGE) {
nIpsSelectedLanguage = SendMessage(GetDlgItem(hIpsDlg, IDC_CHOOSE_LIST), CB_GETCURSEL, 0, 0);
TreeView_DeleteAllItems(hIpsList);
FillListBox();
RefreshPatch();
return 0;
}
break;
}
case WM_NOTIFY: {
NMHDR* pNmHdr = (NMHDR*)lParam;
if (LOWORD(wParam) == IDC_TREE1 && pNmHdr->code == TVN_SELCHANGED) {
RefreshPatch();
return 1;
}
if (LOWORD(wParam) == IDC_TREE1 && pNmHdr->code == NM_DBLCLK) {
// disable double-click node-expand
SetWindowLongPtr(hIpsDlg, DWLP_MSGRESULT, 1);
return 1;
}
if (LOWORD(wParam) == IDC_TREE1 && pNmHdr->code == NM_CLICK) {
POINT cursorPos;
GetCursorPos(&cursorPos);
ScreenToClient(hIpsList, &cursorPos);
TVHITTESTINFO thi;
thi.pt = cursorPos;
TreeView_HitTest(hIpsList, &thi);
if (thi.flags == TVHT_ONITEMSTATEICON) {
TreeView_SelectItem(hIpsList, thi.hItem);
}
return 1;
}
SetWindowLongPtr(hIpsDlg, DWLP_MSGRESULT, CDRF_DODEFAULT);
return 1;
}
case WM_CTLCOLORSTATIC: {
if ((HWND)lParam == GetDlgItem(hIpsDlg, IDC_TEXTCOMMENT)) {
return (INT_PTR)hWhiteBGBrush;
}
break;
}
case WM_CLOSE: {
IpsManagerExit();
break;
}
}
return 0;
}
/*
* DlgProcYahooOpts - Connection Options Dialog
*/
static INT_PTR CALLBACK DlgProcYahooOptsConn(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
DBVARIANT dbv;
CYahooProto* ppro = (CYahooProto*)GetWindowLongPtr( hwndDlg, GWLP_USERDATA );
switch ( msg ) {
case WM_INITDIALOG:
TranslateDialogDefault( hwndDlg );
ppro = ( CYahooProto* )lParam;
SetWindowLongPtr( hwndDlg, GWLP_USERDATA, lParam );
if ( !ppro->GetString( YAHOO_LOGINSERVER, &dbv )){
SetDlgItemTextA( hwndDlg, IDC_LOGINSERVER, dbv.pszVal );
DBFreeVariant( &dbv );
}
else SetDlgItemTextA( hwndDlg, IDC_LOGINSERVER,
ppro->GetByte( "YahooJapan", 0 )
? YAHOO_DEFAULT_JAPAN_LOGIN_SERVER
: YAHOO_DEFAULT_LOGIN_SERVER );
SetDlgItemInt( hwndDlg, IDC_YAHOOPORT, ppro->GetWord( NULL, YAHOO_LOGINPORT, YAHOO_DEFAULT_PORT ), FALSE );
SetButtonCheck( hwndDlg, IDC_YAHOO_JAPAN, ppro->GetByte( "YahooJapan", 0 ) );
return TRUE;
case WM_COMMAND:
switch ( LOWORD( wParam )) {
case IDC_RESETSERVER:
SetDlgItemTextA( hwndDlg, IDC_LOGINSERVER, YAHOO_DEFAULT_LOGIN_SERVER );
SetDlgItemInt( hwndDlg, IDC_YAHOOPORT, YAHOO_DEFAULT_PORT, FALSE );
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
case IDC_YAHOO_JAPAN:
SetDlgItemTextA( hwndDlg, IDC_LOGINSERVER,
(IsDlgButtonChecked(hwndDlg,IDC_YAHOO_JAPAN)==BST_CHECKED) ?
YAHOO_DEFAULT_JAPAN_LOGIN_SERVER :
YAHOO_DEFAULT_LOGIN_SERVER );
// fall through and enable apply button
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
if ( HIWORD( wParam ) == EN_CHANGE && ( HWND )lParam == GetFocus())
switch( LOWORD( wParam )) {
case IDC_LOGINSERVER:
case IDC_YAHOOPORT:
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
}
break;
case WM_NOTIFY:
if (((LPNMHDR)lParam)->code == PSN_APPLY )
{
BOOL reconnectRequired = FALSE/*, restartRequired = FALSE*/;
char str[128];
DBVARIANT dbv;
int port;
GetDlgItemTextA( hwndDlg, IDC_LOGINSERVER, str, sizeof( str ));
if ( ppro->GetString( YAHOO_LOGINSERVER, &dbv ) || lstrcmpA( str, dbv.pszVal ))
reconnectRequired = TRUE;
if ( dbv.pszVal != NULL )
DBFreeVariant( &dbv );
ppro->SetString( YAHOO_LOGINSERVER, str );
port = GetDlgItemInt( hwndDlg, IDC_YAHOOPORT, NULL, FALSE );
if ( ppro->GetWord(NULL, YAHOO_LOGINPORT, -1) != port)
reconnectRequired = TRUE;
ppro->SetWord( NULL, YAHOO_LOGINPORT, port);
ppro->SetByte("YahooJapan", ( BYTE )IsDlgButtonChecked( hwndDlg, IDC_YAHOO_JAPAN ));
/*if ( restartRequired )
MessageBoxA( hwndDlg, Translate( "The changes you have made require you to restart Miranda IM before they take effect"), Translate("YAHOO Options"), MB_OK );
else */
if ( reconnectRequired && ppro->m_bLoggedIn )
MessageBoxA( hwndDlg, Translate( "The changes you have made require you to reconnect to the Yahoo network before they take effect"), Translate("YAHOO Options"), MB_OK );
return TRUE;
}
break;
}
return FALSE;
}
