/***********************************************************************
* ButtonWndProc_common
*/
LRESULT ButtonWndProc_common(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL unicode )
{
RECT rect;
POINT pt;
LONG style = GetWindowLongW( hWnd, GWL_STYLE );
UINT btn_type = get_button_type( style );
LONG state;
HANDLE oldHbitmap;
if (!IsWindow( hWnd )) return 0;
pt.x = (short)LOWORD(lParam);
pt.y = (short)HIWORD(lParam);
switch (uMsg)
{
case WM_GETDLGCODE:
switch(btn_type)
{
case BS_USERBUTTON:
case BS_PUSHBUTTON: return DLGC_BUTTON | DLGC_UNDEFPUSHBUTTON;
case BS_DEFPUSHBUTTON: return DLGC_BUTTON | DLGC_DEFPUSHBUTTON;
case BS_RADIOBUTTON:
case BS_AUTORADIOBUTTON: return DLGC_BUTTON | DLGC_RADIOBUTTON;
case BS_GROUPBOX: return DLGC_STATIC;
default: return DLGC_BUTTON;
}
case WM_ENABLE:
paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
break;
case WM_CREATE:
if (!hbitmapCheckBoxes)
{
BITMAP bmp;
hbitmapCheckBoxes = LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CHECKBOXES));
GetObjectW( hbitmapCheckBoxes, sizeof(bmp), &bmp );
checkBoxWidth = bmp.bmWidth / 4;
checkBoxHeight = bmp.bmHeight / 3;
}
if (btn_type >= MAX_BTN_TYPE)
return -1; /* abort */
/* XP turns a BS_USERBUTTON into BS_PUSHBUTTON */
if (btn_type == BS_USERBUTTON )
{
style = (style & ~0x0f) | BS_PUSHBUTTON;
WIN_SetStyle( hWnd, style, 0x0f & ~style );
}
set_button_state( hWnd, BUTTON_UNCHECKED );
return 0;
case WM_ERASEBKGND:
if (btn_type == BS_OWNERDRAW)
{
HDC hdc = (HDC)wParam;
RECT rc;
HBRUSH hBrush;
HWND parent = GetParent(hWnd);
if (!parent) parent = hWnd;
hBrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORBTN, (WPARAM)hdc, (LPARAM)hWnd);
if (!hBrush) /* did the app forget to call defwindowproc ? */
hBrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORBTN,
(WPARAM)hdc, (LPARAM)hWnd);
GetClientRect(hWnd, &rc);
FillRect(hdc, &rc, hBrush);
}
return 1;
case WM_PRINTCLIENT:
case WM_PAINT:
if (btnPaintFunc[btn_type])
{
PAINTSTRUCT ps;
HDC hdc = wParam ? (HDC)wParam : BeginPaint( hWnd, &ps );
int nOldMode = SetBkMode( hdc, OPAQUE );
(btnPaintFunc[btn_type])( hWnd, hdc, ODA_DRAWENTIRE );
SetBkMode(hdc, nOldMode); /* reset painting mode */
if( !wParam ) EndPaint( hWnd, &ps );
}
break;
case WM_KEYDOWN:
if (wParam == VK_SPACE)
{
SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 );
set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED );
SetCapture( hWnd );
}
break;
case WM_LBUTTONDBLCLK:
if(style & BS_NOTIFY ||
btn_type == BS_RADIOBUTTON ||
btn_type == BS_USERBUTTON ||
btn_type == BS_OWNERDRAW)
{
BUTTON_NOTIFY_PARENT(hWnd, BN_DOUBLECLICKED);
break;
}
/* fall through */
case WM_LBUTTONDOWN:
SetCapture( hWnd );
SetFocus( hWnd );
set_button_state( hWnd, get_button_state( hWnd ) | BUTTON_BTNPRESSED );
SendMessageW( hWnd, BM_SETSTATE, TRUE, 0 );
break;
case WM_KEYUP:
if (wParam != VK_SPACE)
break;
/* fall through */
case WM_LBUTTONUP:
state = get_button_state( hWnd );
if (!(state & BUTTON_BTNPRESSED)) break;
state &= BUTTON_NSTATES;
set_button_state( hWnd, state );
if (!(state & BUTTON_HIGHLIGHTED))
{
ReleaseCapture();
break;
}
SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
ReleaseCapture();
GetClientRect( hWnd, &rect );
if (uMsg == WM_KEYUP || PtInRect( &rect, pt ))
{
state = get_button_state( hWnd );
switch(btn_type)
{
case BS_AUTOCHECKBOX:
SendMessageW( hWnd, BM_SETCHECK, !(state & BUTTON_CHECKED), 0 );
break;
case BS_AUTORADIOBUTTON:
SendMessageW( hWnd, BM_SETCHECK, TRUE, 0 );
break;
case BS_AUTO3STATE:
SendMessageW( hWnd, BM_SETCHECK,
(state & BUTTON_3STATE) ? 0 : ((state & 3) + 1), 0 );
break;
}
BUTTON_NOTIFY_PARENT(hWnd, BN_CLICKED);
}
break;
case WM_CAPTURECHANGED:
TRACE("WM_CAPTURECHANGED %p\n", hWnd);
state = get_button_state( hWnd );
if (state & BUTTON_BTNPRESSED)
{
state &= BUTTON_NSTATES;
set_button_state( hWnd, state );
if (state & BUTTON_HIGHLIGHTED) SendMessageW( hWnd, BM_SETSTATE, FALSE, 0 );
}
break;
case WM_MOUSEMOVE:
if ((wParam & MK_LBUTTON) && GetCapture() == hWnd)
{
GetClientRect( hWnd, &rect );
SendMessageW( hWnd, BM_SETSTATE, PtInRect(&rect, pt), 0 );
}
break;
case WM_SETTEXT:
{
/* Clear an old text here as Windows does */
HDC hdc = GetDC(hWnd);
HBRUSH hbrush;
RECT client, rc;
HWND parent = GetParent(hWnd);
if (!parent) parent = hWnd;
hbrush = (HBRUSH)SendMessageW(parent, WM_CTLCOLORSTATIC,
(WPARAM)hdc, (LPARAM)hWnd);
if (!hbrush) /* did the app forget to call DefWindowProc ? */
hbrush = (HBRUSH)DefWindowProcW(parent, WM_CTLCOLORSTATIC,
(WPARAM)hdc, (LPARAM)hWnd);
GetClientRect(hWnd, &client);
rc = client;
BUTTON_CalcLabelRect(hWnd, hdc, &rc);
/* Clip by client rect bounds */
if (rc.right > client.right) rc.right = client.right;
if (rc.bottom > client.bottom) rc.bottom = client.bottom;
FillRect(hdc, &rc, hbrush);
ReleaseDC(hWnd, hdc);
if (unicode) DefWindowProcW( hWnd, WM_SETTEXT, wParam, lParam );
else DefWindowProcA( hWnd, WM_SETTEXT, wParam, lParam );
if (btn_type == BS_GROUPBOX) /* Yes, only for BS_GROUPBOX */
InvalidateRect( hWnd, NULL, TRUE );
else
paint_button( hWnd, btn_type, ODA_DRAWENTIRE );
return 1; /* success. FIXME: check text length */
}
case WM_SETFONT:
set_button_font( hWnd, (HFONT)wParam );
if (lParam) InvalidateRect(hWnd, NULL, TRUE);
break;
case WM_GETFONT:
return (LRESULT)get_button_font( hWnd );
case WM_SETFOCUS:
TRACE("WM_SETFOCUS %p\n",hWnd);
set_button_state( hWnd, get_button_state(hWnd) | BUTTON_HASFOCUS );
paint_button( hWnd, btn_type, ODA_FOCUS );
if (style & BS_NOTIFY)
BUTTON_NOTIFY_PARENT(hWnd, BN_SETFOCUS);
break;
case WM_KILLFOCUS:
TRACE("WM_KILLFOCUS %p\n",hWnd);
state = get_button_state( hWnd );
set_button_state( hWnd, state & ~BUTTON_HASFOCUS );
paint_button( hWnd, btn_type, ODA_FOCUS );
if ((state & BUTTON_BTNPRESSED) && GetCapture() == hWnd)
ReleaseCapture();
if (style & BS_NOTIFY)
BUTTON_NOTIFY_PARENT(hWnd, BN_KILLFOCUS);
InvalidateRect( hWnd, NULL, FALSE );
break;
case WM_SYSCOLORCHANGE:
InvalidateRect( hWnd, NULL, FALSE );
break;
case BM_SETSTYLE:
if ((wParam & 0x0f) >= MAX_BTN_TYPE) break;
btn_type = wParam & 0x0f;
style = (style & ~0x0f) | btn_type;
WIN_SetStyle( hWnd, style, 0x0f & ~style );
/* Only redraw if lParam flag is set.*/
if (lParam)
InvalidateRect( hWnd, NULL, TRUE );
break;
case BM_CLICK:
SendMessageW( hWnd, WM_LBUTTONDOWN, 0, 0 );
SendMessageW( hWnd, WM_LBUTTONUP, 0, 0 );
break;
case BM_SETIMAGE:
/* Check that image format matches button style */
switch (style & (BS_BITMAP|BS_ICON))
{
case BS_BITMAP:
if (wParam != IMAGE_BITMAP) return 0;
break;
case BS_ICON:
if (wParam != IMAGE_ICON) return 0;
break;
default:
return 0;
}
oldHbitmap = (HBITMAP)SetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET, lParam );
InvalidateRect( hWnd, NULL, FALSE );
return (LRESULT)oldHbitmap;
case BM_GETIMAGE:
return GetWindowLongPtrW( hWnd, HIMAGE_GWL_OFFSET );
case BM_GETCHECK:
return get_button_state( hWnd ) & 3;
case BM_SETCHECK:
if (wParam > maxCheckState[btn_type]) wParam = maxCheckState[btn_type];
state = get_button_state( hWnd );
if ((btn_type == BS_RADIOBUTTON) || (btn_type == BS_AUTORADIOBUTTON))
{
if (wParam) style |= WS_TABSTOP;
else style &= ~WS_TABSTOP;
SetWindowLongW( hWnd, GWL_STYLE, style );
}
if ((state & 3) != wParam)
{
set_button_state( hWnd, (state & ~3) | wParam );
paint_button( hWnd, btn_type, ODA_SELECT );
}
if ((btn_type == BS_AUTORADIOBUTTON) && (wParam == BUTTON_CHECKED) && (style & WS_CHILD))
BUTTON_CheckAutoRadioButton( hWnd );
break;
case BM_GETSTATE:
return get_button_state( hWnd );
case BM_SETSTATE:
state = get_button_state( hWnd );
if (wParam)
{
if (state & BUTTON_HIGHLIGHTED) break;
set_button_state( hWnd, state | BUTTON_HIGHLIGHTED );
}
else
{
if (!(state & BUTTON_HIGHLIGHTED)) break;
set_button_state( hWnd, state & ~BUTTON_HIGHLIGHTED );
}
paint_button( hWnd, btn_type, ODA_SELECT );
break;
case WM_NCHITTEST:
if(btn_type == BS_GROUPBOX) return HTTRANSPARENT;
/* fall through */
default:
return unicode ? DefWindowProcW(hWnd, uMsg, wParam, lParam) :
DefWindowProcA(hWnd, uMsg, wParam, lParam);
}
return 0;
}
static LRESULT CALLBACK Desk_WndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static const UINT msgs [] = { BB_DRAGTODESKTOP, BB_REDRAWGUI, 0 };
static bool button_down, dblclk;
int n;
switch (uMsg)
{
//====================
case WM_CREATE:
hDesktopWnd = hwnd;
MakeSticky(hwnd);
MessageManager_Register(hwnd, msgs, true);
init_DeskDropTarget(hwnd);
Desk_SetPosition();
break;
//====================
case WM_DESTROY:
exit_DeskDropTarget(hwnd);
MessageManager_Register(hwnd, msgs, false);
RemoveSticky(hwnd);
break;
case WM_NCPAINT:
// dbg_printf("ncpaint: %x %x %x %x", hwnd, uMsg, wParam, lParam);
// keep the window on bottom
Desk_SetPosition();
break;
case WM_SETTINGCHANGE:
if (SPI_SETDESKWALLPAPER == wParam)
InvalidateRect(hwnd, NULL, FALSE);
break;
//====================
case WM_CLOSE:
break;
//====================
case WM_MOUSEACTIVATE:
return MA_NOACTIVATE;
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
case WM_MBUTTONDOWN:
case WM_XBUTTONDOWN:
dblclk = false;
button_down = true;
if (uMsg == WM_LBUTTONDOWN) {
n = 0;
goto post_click_2;
}
break;
case WM_MOUSEMOVE:
break;
case WM_LBUTTONDBLCLK:
case WM_RBUTTONDBLCLK:
case WM_MBUTTONDBLCLK:
dblclk = true;
button_down = true;
break;
case WM_LBUTTONUP: n = dblclk ? 7 : 1; goto post_click;
case WM_RBUTTONUP: n = 2; goto post_click;
case WM_MBUTTONUP: n = 3; goto post_click;
case WM_XBUTTONUP:
switch (HIWORD(wParam)) {
case XBUTTON1: n = 4; goto post_click;
case XBUTTON2: n = 5; goto post_click;
case XBUTTON3: n = 6; goto post_click;
} break;
post_click:
if (false == button_down)
break;
button_down = dblclk = false;
post_click_2:
wParam &= (MK_CONTROL|MK_SHIFT);
if (0x8000 & GetAsyncKeyState(VK_MENU))
wParam |= MK_ALT;
PostMessage(BBhwnd, BB_DESKCLICK, wParam, n);
break;
//====================
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc_scrn;
HDC hdc_bmp;
HGDIOBJ other;
hdc_scrn = BeginPaint(hwnd, &ps);
if (Root.bmp) {
hdc_bmp = CreateCompatibleDC(hdc_scrn);
other = SelectObject(hdc_bmp, Root.bmp);
BitBltRect(hdc_scrn, hdc_bmp, &ps.rcPaint);
SelectObject(hdc_bmp, other);
DeleteDC(hdc_bmp);
} else {
PaintDesktop(hdc_scrn);
}
EndPaint(hwnd, &ps);
break;
}
//====================
case WM_ERASEBKGND:
return TRUE;
//====================
case BB_DRAGTODESKTOP:
return get_drop_command((const char *)lParam, wParam);
case BB_REDRAWGUI:
if (wParam & BBRG_DESK)
Desk_new_background("style");
break;
//====================
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
LRESULT Window::WndProc(HWND hwnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
{
switch (nMsg)
{
case WM_CREATE:
return 0;
case WM_CLOSE:
m_isexit = true;
return 0;
case WM_ACTIVATE:
if (LOWORD(wParam) != WA_INACTIVE)
m_active = true;
else
m_active = false;
return 0;
case WM_MOVE:
m_desc.posx = LOWORD(lParam);
m_desc.posy = HIWORD(lParam);
m_UpdateWindowState();
return 0;
case WM_SIZE:
if (!m_desc.resizing)
return 0;
m_desc.width = LOWORD(lParam);
m_desc.height = HIWORD(lParam);
m_isresize = true;
if (wParam == SIZE_MINIMIZED)
{
m_active = false;
m_minimized = true;
m_maximized = false;
}
else if (wParam == SIZE_MAXIMIZED)
{
m_active = true;
m_minimized = false;
m_maximized = true;
}
else if (wParam == SIZE_RESTORED)
{
if (m_minimized)
{
m_active = true;
m_minimized = false;
}
else if (m_maximized)
{
m_active = true;
m_maximized = false;
}
}
m_UpdateWindowState();
return 0;
case WM_MOUSEMOVE: case WM_LBUTTONUP: case WM_LBUTTONDOWN: case WM_MBUTTONUP: case WM_MBUTTONDOWN: case WM_RBUTTONUP: case WM_RBUTTONDOWN: case WM_MOUSEWHEEL: case WM_KEYDOWN: case WM_KEYUP:
if (m_inputmgr)
m_inputmgr->Run(nMsg, wParam, lParam);
return 0;
}
return DefWindowProcW(hwnd, nMsg, wParam, lParam);
}
bool _ConfigProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
int wmId,wmEvent;
int tSel = 0;
switch(uMsg)
{
case WM_INITDIALOG:
{
wchar_t temp[128];
char temp2[192];
sprintf_s( temp2, "%S", m_Device.c_str() );
haveGuid = ! FAILED(GUIDFromString(temp2,&DevGuid));
SendMessage(GetDlgItem(hWnd,IDC_DS_DEVICE),CB_RESETCONTENT,0,0);
ndevs=0;
DirectSoundEnumerate( DSEnumCallback, NULL );
tSel=-1;
for(int i=0;i<ndevs;i++)
{
SendMessage(GetDlgItem(hWnd,IDC_DS_DEVICE),CB_ADDSTRING,0,(LPARAM)m_devices[i].name.wc_str());
if(haveGuid && IsEqualGUID(m_devices[i].guid,DevGuid) || tSel < 0 && !m_devices[i].hasGuid)
tSel = i;
}
if(tSel>=0)
SendMessage(GetDlgItem(hWnd,IDC_DS_DEVICE),CB_SETCURSEL,tSel,0);
INIT_SLIDER( IDC_BUFFERS_SLIDER, 2, MAX_BUFFER_COUNT, 2, 1, 1 );
SendMessage(GetDlgItem(hWnd,IDC_BUFFERS_SLIDER),TBM_SETPOS,TRUE,m_NumBuffers);
swprintf_s(temp, L"%d (%d ms latency)",m_NumBuffers, 1000 / (96000 / (m_NumBuffers * BufferSize)));
SetWindowText(GetDlgItem(hWnd,IDC_LATENCY_LABEL),temp);
SET_CHECK( IDC_GLOBALFOCUS_DISABLE, m_DisableGlobalFocus );
SET_CHECK( IDC_USE_HARDWARE, m_UseHardware );
}
break;
case WM_COMMAND:
{
wchar_t temp[128];
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDOK:
{
int i = (int)SendMessage(GetDlgItem(hWnd,IDC_DS_DEVICE),CB_GETCURSEL,0,0);
if(!m_devices[i].hasGuid)
{
m_Device[0] = 0; // clear device name to ""
}
else
{
swprintf_s(temp, L"{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
m_devices[i].guid.Data1,
m_devices[i].guid.Data2,
m_devices[i].guid.Data3,
m_devices[i].guid.Data4[0],
m_devices[i].guid.Data4[1],
m_devices[i].guid.Data4[2],
m_devices[i].guid.Data4[3],
m_devices[i].guid.Data4[4],
m_devices[i].guid.Data4[5],
m_devices[i].guid.Data4[6],
m_devices[i].guid.Data4[7]
);
m_Device = temp;
}
m_NumBuffers = (int)SendMessage( GetDlgItem( hWnd, IDC_BUFFERS_SLIDER ), TBM_GETPOS, 0, 0 );
if( m_NumBuffers < 2 ) m_NumBuffers = 2;
if( m_NumBuffers > MAX_BUFFER_COUNT ) m_NumBuffers = MAX_BUFFER_COUNT;
EndDialog(hWnd,0);
}
break;
case IDCANCEL:
EndDialog(hWnd,0);
break;
HANDLE_CHECK( IDC_GLOBALFOCUS_DISABLE, m_DisableGlobalFocus );
HANDLE_CHECK( IDC_USE_HARDWARE, m_UseHardware );
default:
return FALSE;
}
}
break;
case WM_HSCROLL:
{
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
switch(wmId)
{
//case TB_ENDTRACK:
//case TB_THUMBPOSITION:
case TB_LINEUP:
case TB_LINEDOWN:
case TB_PAGEUP:
case TB_PAGEDOWN:
wmEvent = (int)SendMessage((HWND)lParam,TBM_GETPOS,0,0);
case TB_THUMBTRACK:
{
wchar_t temp[128];
if( wmEvent < 2 ) wmEvent = 2;
if( wmEvent > MAX_BUFFER_COUNT ) wmEvent = MAX_BUFFER_COUNT;
SendMessage((HWND)lParam,TBM_SETPOS,TRUE,wmEvent);
swprintf_s(temp,L"%d (%d ms latency)",wmEvent, 1000 / (96000 / (wmEvent * BufferSize)));
SetWindowText(GetDlgItem(hWnd,IDC_LATENCY_LABEL),temp);
break;
}
default:
return FALSE;
}
}
break;
default:
return FALSE;
}
return TRUE;
}
/**
* Callbackfunktion der WinAPI.
*
* @param[in] window Fensterhandle
* @param[in] msg Fensternachricht
* @param[in] wParam Erster Nachrichtenparameter
* @param[in] wParam Zweiter Nachrichtenparameter
*
* @author FloSoft
*/
LRESULT CALLBACK VideoWinAPI::WindowProc(HWND window, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg)
{
case WM_PASTE:
{
pVideoWinAPI->OnWMPaste();
} break;
case WM_CLOSE:
{
PostQuitMessage(0);
return 0;
} break;
case WM_ACTIVATE:
{
switch(wParam)
{
default:
case WA_ACTIVE:
{
ShowCursor(0);
} break;
case WA_INACTIVE:
{
ShowCursor(1);
} break;
}
} break;
case WM_SYSCOMMAND:
{
switch (wParam)
{
case SC_SCREENSAVE:
case SC_MONITORPOWER:
case SC_KEYMENU: // F10-Fehler beheben -> will sonst Fenster verschieben, was das
// das Zeichnen unterbindet
return 0;
}
} break;
case WM_MOUSEMOVE:
{
pVideoWinAPI->mouse_xy.x = LOWORD(lParam);
pVideoWinAPI->mouse_xy.y = HIWORD(lParam);
pVideoWinAPI->CallBack->Msg_MouseMove(pVideoWinAPI->mouse_xy);
} break;
case WM_LBUTTONDOWN:
{
pVideoWinAPI->mouse_l = true;
pVideoWinAPI->mouse_xy.ldown = true;
pVideoWinAPI->CallBack->Msg_LeftDown(pVideoWinAPI->mouse_xy);
} break;
case WM_LBUTTONUP:
{
pVideoWinAPI->mouse_l = false;
pVideoWinAPI->mouse_xy.ldown = false;
pVideoWinAPI->CallBack->Msg_LeftUp(pVideoWinAPI->mouse_xy);
} break;
case WM_RBUTTONDOWN:
{
pVideoWinAPI->mouse_r = true;
pVideoWinAPI->mouse_xy.rdown = true;
pVideoWinAPI->CallBack->Msg_RightDown(pVideoWinAPI->mouse_xy);
} break;
case WM_RBUTTONUP:
{
pVideoWinAPI->mouse_r = false;
pVideoWinAPI->mouse_xy.rdown = false;
pVideoWinAPI->CallBack->Msg_RightUp(pVideoWinAPI->mouse_xy);
} break;
case WM_MOUSEWHEEL:
{
// Obtain scrolling distance. For every multiple of WHEEL_DELTA, we have to fire an event, because we treat the wheel like two buttons.
// One wheel "step" usually produces a mouse_z of +/- WHEEL_DELTA. But there may exist wheels without "steps" that result in lower values we have to cumulate.
pVideoWinAPI->mouse_z += GET_WHEEL_DELTA_WPARAM(wParam);
// We don't want to crash if there were even wheels that produce higher values...
while (std::abs(pVideoWinAPI->mouse_z) >= WHEEL_DELTA)
{
if (pVideoWinAPI->mouse_z > 0) // Scrolled to top
{
pVideoWinAPI->mouse_z -= WHEEL_DELTA;
pVideoWinAPI->CallBack->Msg_WheelUp(pVideoWinAPI->mouse_xy);
}
else // Scrolled to bottom
{
pVideoWinAPI->mouse_z += WHEEL_DELTA;
pVideoWinAPI->CallBack->Msg_WheelDown(pVideoWinAPI->mouse_xy);
}
}
} break;
case WM_KEYDOWN:
// case WM_SYSKEYDOWN: // auch abfangen, wenn linkes ALT mit gedrückt wurde
{
pVideoWinAPI->OnWMKeyDown((unsigned int)wParam, lParam);
} return 0;
case WM_CHAR:
case WM_SYSCHAR: // auch abfangen, wenn linkes ALT mit gedrückt wurde
{
pVideoWinAPI->OnWMChar((unsigned int)wParam, false, lParam);
} return 0;
}
return DefWindowProcW(window, msg, wParam, lParam);
}
int ToolBar::getHeight() const {
DWORD size = (DWORD)SendMessage(_hSelf, TB_GETBUTTONSIZE, 0, 0);
DWORD padding = (DWORD)SendMessage(_hSelf, TB_GETPADDING, 0, 0);
int totalHeight = HIWORD(size) + HIWORD(padding) - 3;
return totalHeight;
}
long WMSize (HWND hwnd, WPARAM wParam, LPARAM lParam){
MoveWindow (hwndEdit, 0, 0, LOWORD (lParam), HIWORD (lParam), TRUE);
return 0;
}
//Handle Select Mode dialog box
INT_PTR CALLBACK WINDOW::SelectModeProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg)
{
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDOK: //If OK was pressed
{
//Make changes to resolution
if(IsDlgButtonChecked(hWnd, IDC_640))
{
Instance()->width=640;
Instance()->height=480;
}
if(IsDlgButtonChecked(hWnd, IDC_800))
{
Instance()->width=800;
Instance()->height=600;
}
if(IsDlgButtonChecked(hWnd, IDC_1024))
{
Instance()->width=1024;
Instance()->height=768;
}
EndDialog(hWnd, wParam);
return true;
}
}
switch (HIWORD(wParam))
{
case BN_CLICKED: //If a button was pressed
{
CheckDlgButton(hWnd, lParam, BST_CHECKED);
//If it is the fullscreen button, change the variable
if((int)LOWORD(wParam) == IDC_FULLSCREEN)
Instance()->fullscreen=!Instance()->fullscreen;
//If it is an AA settings button, save the nuber of samples
if((int) LOWORD(wParam) == IDC_NOAA)
Instance()->numSamples=0;
for(int i=2; i<16; ++i)
{
if((int) LOWORD(wParam)==IDC_2AA+i-2)
Instance()->numSamples=i;
}
return true;
}
}
break;
}
case WM_INITDIALOG: //Initiate dialog box
{
//Set default resolution
if(Instance()->width==640)
CheckRadioButton(hWnd, IDC_640, IDC_1024, IDC_640);
if(Instance()->width==800)
CheckRadioButton(hWnd, IDC_640, IDC_1024, IDC_800);
if(Instance()->width==1024)
CheckRadioButton(hWnd, IDC_640, IDC_1024, IDC_1024);
//Set default full screen
if(Instance()->fullscreen)
CheckDlgButton(hWnd, IDC_FULLSCREEN, true);
//Grey out the unsupported AA modes
HWND buttonHWnd;
for(int i=2; i<=16; ++i)
{
//requires that 2AA - 16AA have sequential ID numbers
buttonHWnd=GetDlgItem(hWnd, IDC_2AA+(i-2));
EnableWindow(buttonHWnd, Instance()->samplesSupported[i]);
}
//Set default to no AA
CheckRadioButton(hWnd, IDC_NOAA, IDC_16AA, IDC_NOAA);
return true;
}
}
return false;
}
bool CMainWindow::Initialize()
{
CRegStdWORD pos(_T("Software\\TortoiseGit\\UDiffViewerPos"), 0);
CRegStdWORD width(_T("Software\\TortoiseGit\\UDiffViewerWidth"), (DWORD)640);
CRegStdWORD height(_T("Software\\TortoiseGit\\UDiffViewerHeight"), (DWORD)480);
if (DWORD(pos) && DWORD(width) && DWORD(height))
{
RECT rc;
rc.left = LOWORD(DWORD(pos));
rc.top = HIWORD(DWORD(pos));
rc.right = rc.left + DWORD(width);
rc.bottom = rc.top + DWORD(height);
HMONITOR hMon = MonitorFromRect(&rc, MONITOR_DEFAULTTONULL);
if (hMon)
{
// only restore the window position if the monitor is valid
MoveWindow(*this, LOWORD(DWORD(pos)), HIWORD(DWORD(pos)),
DWORD(width), DWORD(height), FALSE);
}
}
m_hWndEdit = ::CreateWindow(
_T("Scintilla"),
_T("Source"),
WS_CHILD | WS_VSCROLL | WS_HSCROLL | WS_CLIPCHILDREN,
CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, CW_USEDEFAULT,
*this,
0,
hResource,
0);
if (m_hWndEdit == NULL)
return false;
RECT rect;
GetClientRect(*this, &rect);
::SetWindowPos(m_hWndEdit, HWND_TOP,
rect.left, rect.top,
rect.right-rect.left, rect.bottom-rect.top,
SWP_SHOWWINDOW);
m_directFunction = SendMessage(m_hWndEdit, SCI_GETDIRECTFUNCTION, 0, 0);
m_directPointer = SendMessage(m_hWndEdit, SCI_GETDIRECTPOINTER, 0, 0);
// Set up the global default style. These attributes are used wherever no explicit choices are made.
SetAStyle(STYLE_DEFAULT, ::GetSysColor(COLOR_WINDOWTEXT), ::GetSysColor(COLOR_WINDOW),
// Reusing TortoiseBlame's setting which already have an user friendly
// pane in TortoiseSVN's Settings dialog, while there is no such
// pane for TortoiseUDiff.
CRegStdWORD(_T("Software\\TortoiseGit\\BlameFontSize"), 10),
WideToMultibyte(CRegStdString(_T("Software\\TortoiseGit\\BlameFontName"), _T("Courier New"))).c_str());
SendEditor(SCI_SETTABWIDTH, 4);
SendEditor(SCI_SETREADONLY, TRUE);
LRESULT pix = SendEditor(SCI_TEXTWIDTH, STYLE_LINENUMBER, (LPARAM)"_99999");
SendEditor(SCI_SETMARGINWIDTHN, 0, pix);
SendEditor(SCI_SETMARGINWIDTHN, 1);
SendEditor(SCI_SETMARGINWIDTHN, 2);
//Set the default windows colors for edit controls
SendEditor(SCI_STYLESETFORE, STYLE_DEFAULT, ::GetSysColor(COLOR_WINDOWTEXT));
SendEditor(SCI_STYLESETBACK, STYLE_DEFAULT, ::GetSysColor(COLOR_WINDOW));
SendEditor(SCI_SETSELFORE, TRUE, ::GetSysColor(COLOR_HIGHLIGHTTEXT));
SendEditor(SCI_SETSELBACK, TRUE, ::GetSysColor(COLOR_HIGHLIGHT));
SendEditor(SCI_SETCARETFORE, ::GetSysColor(COLOR_WINDOWTEXT));
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Proc: Advanced options dialog
static INT_PTR CALLBACK gg_advoptsdlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_INITDIALOG:
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_SERVERHOSTS, &dbv)) {
SetDlgItemText(hwndDlg, IDC_HOST, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
SetDlgItemText(hwndDlg, IDC_HOST, GG_KEYDEF_SERVERHOSTS);
CheckDlgButton(hwndDlg, IDC_KEEPALIVE, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_KEEPALIVE, GG_KEYDEF_KEEPALIVE));
CheckDlgButton(hwndDlg, IDC_SHOWCERRORS, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWCERRORS, GG_KEYDEF_SHOWCERRORS));
CheckDlgButton(hwndDlg, IDC_ARECONNECT, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_ARECONNECT, GG_KEYDEF_ARECONNECT));
CheckDlgButton(hwndDlg, IDC_MSGACK, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_MSGACK, GG_KEYDEF_MSGACK));
CheckDlgButton(hwndDlg, IDC_MANUALHOST, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_MANUALHOST, GG_KEYDEF_MANUALHOST));
CheckDlgButton(hwndDlg, IDC_SSLCONN, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_SSLCONN, GG_KEYDEF_SSLCONN));
EnableWindow(GetDlgItem(hwndDlg, IDC_HOST), IsDlgButtonChecked(hwndDlg, IDC_MANUALHOST));
EnableWindow(GetDlgItem(hwndDlg, IDC_PORT), IsDlgButtonChecked(hwndDlg, IDC_MANUALHOST));
CheckDlgButton(hwndDlg, IDC_DIRECTCONNS, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_DIRECTCONNS, GG_KEYDEF_DIRECTCONNS));
if (num = DBGetContactSettingWord(NULL, GG_PROTO, GG_KEY_DIRECTPORT, GG_KEYDEF_DIRECTPORT))
SetDlgItemText(hwndDlg, IDC_DIRECTPORT, ditoa(num));
CheckDlgButton(hwndDlg, IDC_FORWARDING, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_FORWARDING, GG_KEYDEF_FORWARDING));
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_FORWARDHOST, &dbv)) {
SetDlgItemText(hwndDlg, IDC_FORWARDHOST, dbv.pszVal);
DBFreeVariant(&dbv);
}
if (num = DBGetContactSettingWord(NULL, GG_PROTO, GG_KEY_FORWARDPORT, GG_KEYDEF_FORWARDPORT))
SetDlgItemText(hwndDlg, IDC_FORWARDPORT, ditoa(num));
EnableWindow(GetDlgItem(hwndDlg, IDC_DIRECTPORT), IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDING), IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDPORT), IsDlgButtonChecked(hwndDlg, IDC_FORWARDING) && IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDHOST), IsDlgButtonChecked(hwndDlg, IDC_FORWARDING) && IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
break;
}
case WM_COMMAND:
{
if ((LOWORD(wParam) == IDC_DIRECTPORT || LOWORD(wParam) == IDC_FORWARDHOST || LOWORD(wParam) == IDC_FORWARDPORT)
&& (HIWORD(wParam) != EN_CHANGE || (HWND) lParam != GetFocus()))
return 0;
switch (LOWORD(wParam)) {
case IDC_MANUALHOST:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_HOST), IsDlgButtonChecked(hwndDlg, IDC_MANUALHOST));
EnableWindow(GetDlgItem(hwndDlg, IDC_PORT), IsDlgButtonChecked(hwndDlg, IDC_MANUALHOST));
ShowWindow(GetDlgItem(hwndDlg, IDC_RELOADREQD), SW_SHOW);
break;
}
case IDC_DIRECTCONNS:
case IDC_FORWARDING:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_DIRECTPORT), IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDING), IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDPORT), IsDlgButtonChecked(hwndDlg, IDC_FORWARDING) && IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
EnableWindow(GetDlgItem(hwndDlg, IDC_FORWARDHOST), IsDlgButtonChecked(hwndDlg, IDC_FORWARDING) && IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
ShowWindow(GetDlgItem(hwndDlg, IDC_RELOADREQD), SW_SHOW);
break;
}
}
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
case WM_NOTIFY:
{
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
{
char str[512];
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_KEEPALIVE, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_KEEPALIVE));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWCERRORS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SHOWCERRORS));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_ARECONNECT, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_ARECONNECT));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_MSGACK, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_MSGACK));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_MANUALHOST, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_MANUALHOST));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_SSLCONN, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SSLCONN));
// Transfer settings
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_DIRECTCONNS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_DIRECTCONNS));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_FORWARDING, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_FORWARDING));
// Write custom servers
GetDlgItemText(hwndDlg, IDC_HOST, str, sizeof(str));
DBWriteContactSettingString(NULL, GG_PROTO, GG_KEY_SERVERHOSTS, str);
// Write direct port
GetDlgItemText(hwndDlg, IDC_DIRECTPORT, str, sizeof(str));
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_DIRECTPORT, (WORD)atoi(str));
// Write forwarding host
GetDlgItemText(hwndDlg, IDC_FORWARDHOST, str, sizeof(str));
DBWriteContactSettingString(NULL, GG_PROTO, GG_KEY_FORWARDHOST, str);
GetDlgItemText(hwndDlg, IDC_FORWARDPORT, str, sizeof(str));
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_FORWARDPORT, (WORD)atoi(str));
break;
}
}
break;
}
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////////
// Info Page : Proc
static INT_PTR CALLBACK gg_detailsdlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
struct GGDETAILSDLGDATA *dat = (struct GGDETAILSDLGDATA *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
switch(msg)
{
case WM_INITDIALOG:
{
TranslateDialogDefault(hwndDlg);
dat = (struct GGDETAILSDLGDATA *)mir_alloc(sizeof(struct GGDETAILSDLGDATA));
dat->hContact=(HANDLE)lParam;
dat->disableUpdate = FALSE;
dat->updating = FALSE;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)dat);
// Add genders
if(!dat->hContact)
{
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_ADDSTRING, 0, (LPARAM)_T("")); // 0
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_ADDSTRING, 0, (LPARAM)Translate("Female")); // 1
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_ADDSTRING, 0, (LPARAM)Translate("Male")); // 2
}
break;
}
case WM_NOTIFY:
switch (((LPNMHDR)lParam)->idFrom)
{
case 0:
switch (((LPNMHDR)lParam)->code)
{
case PSN_PARAMCHANGED:
{
dat->gg = (GGPROTO *)((LPPSHNOTIFY)lParam)->lParam;
break;
}
case PSN_INFOCHANGED:
{
char *szProto;
HANDLE hContact = (HANDLE)((LPPSHNOTIFY)lParam)->lParam;
GGPROTO *gg = dat->gg;
// Show updated message
if(dat && dat->updating)
{
MessageBox(
NULL,
Translate("Your details has been uploaded to the public directory."),
GG_PROTONAME,
MB_OK | MB_ICONINFORMATION
);
dat->updating = FALSE;
break;
}
if (hContact == NULL)
szProto = GG_PROTO;
else
szProto = (char*)CallService(MS_PROTO_GETCONTACTBASEPROTO, (WPARAM)hContact, 0);
if (szProto == NULL)
break;
// Disable when updating
if(dat) dat->disableUpdate = TRUE;
SetValue(hwndDlg, IDC_UIN, hContact, szProto, GG_KEY_UIN, 0, hContact != NULL);
SetValue(hwndDlg, IDC_REALIP, hContact, szProto, GG_KEY_CLIENTIP, SVS_IP, hContact != NULL);
SetValue(hwndDlg, IDC_PORT, hContact, szProto, GG_KEY_CLIENTPORT, SVS_ZEROISUNSPEC, hContact != NULL);
SetValue(hwndDlg, IDC_VERSION, hContact, szProto, GG_KEY_CLIENTVERSION, SVS_GGVERSION, hContact != NULL);
SetValue(hwndDlg, IDC_FIRSTNAME, hContact, szProto, "FirstName", SVS_NORMAL, hContact != NULL);
SetValue(hwndDlg, IDC_LASTNAME, hContact, szProto, "LastName", SVS_NORMAL, hContact != NULL);
SetValue(hwndDlg, IDC_NICKNAME, hContact, szProto, "NickName", SVS_NORMAL, hContact != NULL);
SetValue(hwndDlg, IDC_BIRTHYEAR, hContact, szProto, "BirthYear", SVS_ZEROISUNSPEC, hContact != NULL);
SetValue(hwndDlg, IDC_CITY, hContact, szProto, "City", SVS_NORMAL, hContact != NULL);
SetValue(hwndDlg, IDC_FAMILYNAME, hContact, szProto, "FamilyName", SVS_NORMAL, hContact != NULL);
SetValue(hwndDlg, IDC_CITYORIGIN, hContact, szProto, "CityOrigin", SVS_NORMAL, hContact != NULL);
if (hContact)
{
SetValue(hwndDlg, IDC_GENDER, hContact, szProto, "Gender", SVS_GENDER, hContact != NULL);
SetValue(hwndDlg, IDC_STATUSDESCR, hContact, "CList", GG_KEY_STATUSDESCR, SVS_NORMAL, hContact != NULL);
}
else switch((char)DBGetContactSettingByte(hContact, GG_PROTO, "Gender", (BYTE)'?'))
{
case 'F':
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_SETCURSEL, 1, 0);
break;
case 'M':
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_SETCURSEL, 2, 0);
break;
default:
SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_SETCURSEL, 0, 0);
}
// Disable when updating
if(dat) dat->disableUpdate = FALSE;
break;
}
}
break;
}
break;
case WM_COMMAND:
if (dat && !dat->hContact && LOWORD(wParam) == IDC_SAVE && HIWORD(wParam) == BN_CLICKED)
{
// Save user data
char text[256];
gg_pubdir50_t req;
GGPROTO *gg = dat->gg;
if (!gg_isonline(gg))
{
MessageBox(NULL,
Translate("You have to be logged in before you can change your details."),
GG_PROTONAME, MB_OK | MB_ICONSTOP
);
break;
}
EnableWindow(GetDlgItem(hwndDlg, IDC_SAVE), FALSE);
req = gg_pubdir50_new(GG_PUBDIR50_WRITE);
GetDlgItemText(hwndDlg, IDC_FIRSTNAME, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_FIRSTNAME, text);
GetDlgItemText(hwndDlg, IDC_LASTNAME, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_LASTNAME, text);
GetDlgItemText(hwndDlg, IDC_NICKNAME, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_NICKNAME, text);
GetDlgItemText(hwndDlg, IDC_CITY, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_CITY, text);
// Gadu-Gadu Female <-> Male
switch(SendDlgItemMessage(hwndDlg, IDC_GENDER, CB_GETCURSEL, 0, 0))
{
case 1:
gg_pubdir50_add(req, GG_PUBDIR50_GENDER, GG_PUBDIR50_GENDER_SET_FEMALE);
break;
case 2:
gg_pubdir50_add(req, GG_PUBDIR50_GENDER, GG_PUBDIR50_GENDER_SET_MALE);
break;
default:
gg_pubdir50_add(req, GG_PUBDIR50_GENDER, "");
}
GetDlgItemText(hwndDlg, IDC_BIRTHYEAR, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_BIRTHYEAR, text);
GetDlgItemText(hwndDlg, IDC_FAMILYNAME, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_FAMILYNAME, text);
GetDlgItemText(hwndDlg, IDC_CITYORIGIN, text, sizeof(text));
if (strlen(text)) gg_pubdir50_add(req, GG_PUBDIR50_FAMILYCITY, text);
// Run update
gg_pubdir50_seq_set(req, GG_SEQ_CHINFO);
EnterCriticalSection(&gg->sess_mutex);
gg_pubdir50(gg->sess, req);
LeaveCriticalSection(&gg->sess_mutex);
dat->updating = TRUE;
gg_pubdir50_free(req);
}
if(dat && !dat->hContact && !dat->disableUpdate && (HIWORD(wParam) == EN_CHANGE && (
LOWORD(wParam) == IDC_NICKNAME || LOWORD(wParam) == IDC_FIRSTNAME || LOWORD(wParam) == IDC_LASTNAME || LOWORD(wParam) == IDC_FAMILYNAME ||
LOWORD(wParam) == IDC_CITY || LOWORD(wParam) == IDC_CITYORIGIN || LOWORD(wParam) == IDC_BIRTHYEAR) ||
HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_GENDER))
EnableWindow(GetDlgItem(hwndDlg, IDC_SAVE), TRUE);
switch(LOWORD(wParam))
{
case IDCANCEL:
SendMessage(GetParent(hwndDlg),msg,wParam,lParam);
break;
}
break;
case WM_DESTROY:
if(dat) mir_free(dat);
break;
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Proc: Conference options dialog
static INT_PTR CALLBACK gg_confoptsdlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_INITDIALOG:
{
DWORD num;
GGPROTO *gg = (GGPROTO *)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_TOTAL, CB_ADDSTRING, 0, (LPARAM)Translate("Allow"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_TOTAL, CB_ADDSTRING, 0, (LPARAM)Translate("Ask"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_TOTAL, CB_ADDSTRING, 0, (LPARAM)Translate("Ignore"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_TOTAL, CB_SETCURSEL,
DBGetContactSettingWord(NULL, GG_PROTO, GG_KEY_GC_POLICY_TOTAL, GG_KEYDEF_GC_POLICY_TOTAL), 0);
if (num = DBGetContactSettingWord(NULL, GG_PROTO, GG_KEY_GC_COUNT_TOTAL, GG_KEYDEF_GC_COUNT_TOTAL))
SetDlgItemText(hwndDlg, IDC_GC_COUNT_TOTAL, ditoa(num));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_UNKNOWN, CB_ADDSTRING, 0, (LPARAM)Translate("Allow"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_UNKNOWN, CB_ADDSTRING, 0, (LPARAM)Translate("Ask"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_UNKNOWN, CB_ADDSTRING, 0, (LPARAM)Translate("Ignore"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_UNKNOWN, CB_SETCURSEL,
DBGetContactSettingWord(NULL, GG_PROTO, GG_KEY_GC_POLICY_UNKNOWN, GG_KEYDEF_GC_POLICY_UNKNOWN), 0);
if (num = DBGetContactSettingWord(NULL, GG_PROTO, GG_KEY_GC_COUNT_UNKNOWN, GG_KEYDEF_GC_COUNT_UNKNOWN))
SetDlgItemText(hwndDlg, IDC_GC_COUNT_UNKNOWN, ditoa(num));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_DEFAULT, CB_ADDSTRING, 0, (LPARAM)Translate("Allow"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_DEFAULT, CB_ADDSTRING, 0, (LPARAM)Translate("Ask"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_DEFAULT, CB_ADDSTRING, 0, (LPARAM)Translate("Ignore"));
SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_DEFAULT, CB_SETCURSEL,
DBGetContactSettingWord(NULL, GG_PROTO, GG_KEY_GC_POLICY_DEFAULT, GG_KEYDEF_GC_POLICY_DEFAULT), 0);
break;
}
case WM_COMMAND:
{
if ((LOWORD(wParam) == IDC_GC_COUNT_TOTAL || LOWORD(wParam) == IDC_GC_COUNT_UNKNOWN)
&& (HIWORD(wParam) != EN_CHANGE || (HWND) lParam != GetFocus()))
return 0;
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
case WM_NOTIFY:
{
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
{
char str[128];
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
// Write groupchat policy
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_GC_POLICY_TOTAL,
(WORD)SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_TOTAL, CB_GETCURSEL, 0, 0));
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_GC_POLICY_UNKNOWN,
(WORD)SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_UNKNOWN, CB_GETCURSEL, 0, 0));
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_GC_POLICY_DEFAULT,
(WORD)SendDlgItemMessage(hwndDlg, IDC_GC_POLICY_DEFAULT, CB_GETCURSEL, 0, 0));
GetDlgItemText(hwndDlg, IDC_GC_COUNT_TOTAL, str, sizeof(str));
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_GC_COUNT_TOTAL, (WORD)atoi(str));
GetDlgItemText(hwndDlg, IDC_GC_COUNT_UNKNOWN, str, sizeof(str));
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_GC_COUNT_UNKNOWN, (WORD)atoi(str));
break;
}
}
break;
}
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////////////////////
// Proc: General options dialog
static INT_PTR CALLBACK gg_genoptsdlgproc(HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_INITDIALOG:
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)lParam;
SetWindowLongPtr(hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam);
TranslateDialogDefault(hwndDlg);
if (num = DBGetContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, 0))
{
SetDlgItemText(hwndDlg, IDC_UIN, ditoa(num));
ShowWindow(GetDlgItem(hwndDlg, IDC_CREATEACCOUNT), SW_HIDE);
}
else
{
ShowWindow(GetDlgItem(hwndDlg, IDC_CHPASS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_REMOVEACCOUNT), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_LOSTPASS), SW_HIDE);
}
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, &dbv)) {
CallService(MS_DB_CRYPT_DECODESTRING, strlen(dbv.pszVal) + 1, (LPARAM) dbv.pszVal);
SetDlgItemText(hwndDlg, IDC_PASSWORD, dbv.pszVal);
DBFreeVariant(&dbv);
}
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, &dbv)) {
SetDlgItemText(hwndDlg, IDC_EMAIL, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
{
ShowWindow(GetDlgItem(hwndDlg, IDC_LOSTPASS), SW_HIDE);
ShowWindow(GetDlgItem(hwndDlg, IDC_CHPASS), SW_HIDE);
}
CheckDlgButton(hwndDlg, IDC_FRIENDSONLY, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_FRIENDSONLY, GG_KEYDEF_FRIENDSONLY));
CheckDlgButton(hwndDlg, IDC_SHOWINVISIBLE, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWINVISIBLE, GG_KEYDEF_SHOWINVISIBLE));
CheckDlgButton(hwndDlg, IDC_LEAVESTATUSMSG, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_LEAVESTATUSMSG, GG_KEYDEF_LEAVESTATUSMSG));
if(gg->gc_enabled)
CheckDlgButton(hwndDlg, IDC_IGNORECONF, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_IGNORECONF, GG_KEYDEF_IGNORECONF));
else
{
EnableWindow(GetDlgItem(hwndDlg, IDC_IGNORECONF), FALSE);
CheckDlgButton(hwndDlg, IDC_IGNORECONF, TRUE);
}
CheckDlgButton(hwndDlg, IDC_IMGRECEIVE, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGRECEIVE, GG_KEYDEF_IMGRECEIVE));
CheckDlgButton(hwndDlg, IDC_SHOWLINKS, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWLINKS, GG_KEYDEF_SHOWLINKS));
CheckDlgButton(hwndDlg, IDC_ENABLEAVATARS, DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_ENABLEAVATARS, GG_KEYDEF_ENABLEAVATARS));
EnableWindow(GetDlgItem(hwndDlg, IDC_LEAVESTATUS), IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
EnableWindow(GetDlgItem(hwndDlg, IDC_IMGMETHOD), IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("<Last Status>")); // 0
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Online")); // ID_STATUS_ONLINE
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Away")); // ID_STATUS_AWAY
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("DND")); // ID_STATUS_DND
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Free for chat")); // ID_STATUS_FREECHAT
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_ADDSTRING, 0, (LPARAM)Translate("Invisible")); // ID_STATUS_INVISIBLE
switch(DBGetContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, GG_KEYDEF_LEAVESTATUS))
{
case ID_STATUS_ONLINE:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 1, 0);
break;
case ID_STATUS_AWAY:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 2, 0);
break;
case ID_STATUS_DND:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 3, 0);
break;
case ID_STATUS_FREECHAT:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 4, 0);
break;
case ID_STATUS_INVISIBLE:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 5, 0);
break;
default:
SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_SETCURSEL, 0, 0);
}
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)Translate("System tray icon"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)Translate("Popup window"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_ADDSTRING, 0, (LPARAM)Translate("Message with [img] BBCode"));
SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_SETCURSEL,
DBGetContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGMETHOD, GG_KEYDEF_IMGMETHOD), 0);
break;
}
case WM_COMMAND:
{
if ((LOWORD(wParam) == IDC_UIN || LOWORD(wParam) == IDC_PASSWORD || LOWORD(wParam) == IDC_EMAIL)
&& (HIWORD(wParam) != EN_CHANGE || (HWND) lParam != GetFocus()))
return 0;
switch (LOWORD(wParam)) {
case IDC_EMAIL:
case IDC_UIN:
{
gg_optsdlgcheck(hwndDlg);
break;
}
case IDC_LEAVESTATUSMSG:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_LEAVESTATUS), IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
break;
}
case IDC_IMGRECEIVE:
{
EnableWindow(GetDlgItem(hwndDlg, IDC_IMGMETHOD), IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
break;
}
case IDC_LOSTPASS:
{
char email[128];
uin_t uin;
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
GetDlgItemText(hwndDlg, IDC_UIN, email, sizeof(email));
uin = atoi(email);
GetDlgItemText(hwndDlg, IDC_EMAIL, email, sizeof(email));
if(!strlen(email))
MessageBox(
NULL,
Translate("You need to specify your registration e-mail first."),
GG_PROTONAME,
MB_OK | MB_ICONEXCLAMATION);
else if(MessageBox(
NULL,
Translate("Your password will be sent to your registration e-mail.\nDo you want to continue ?"),
GG_PROTONAME,
MB_OKCANCEL | MB_ICONQUESTION) == IDOK)
gg_remindpassword(gg, uin, email);
return FALSE;
}
case IDC_CREATEACCOUNT:
case IDC_REMOVEACCOUNT:
if(gg_isonline((GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA)))
{
if(MessageBox(
NULL,
Translate("You should disconnect before making any permanent changes with your account.\nDo you want to disconnect now ?"),
((GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA))->proto.m_szModuleName,
MB_OKCANCEL | MB_ICONEXCLAMATION) == IDCANCEL)
break;
else
gg_disconnect((GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA));
}
case IDC_CHPASS:
case IDC_CHEMAIL:
{
// Readup data
GGUSERUTILDLGDATA dat;
int ret;
char pass[128], email[128];
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
GetDlgItemText(hwndDlg, IDC_UIN, pass, sizeof(pass));
dat.uin = atoi(pass);
GetDlgItemText(hwndDlg, IDC_PASSWORD, pass, sizeof(pass));
GetDlgItemText(hwndDlg, IDC_EMAIL, email, sizeof(email));
dat.pass = pass;
dat.email = email;
dat.gg = gg;
if(LOWORD(wParam) == IDC_CREATEACCOUNT)
{
dat.mode = GG_USERUTIL_CREATE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CREATEACCOUNT), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else if(LOWORD(wParam) == IDC_CHPASS)
{
dat.mode = GG_USERUTIL_PASS;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CHPASS), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else if(LOWORD(wParam) == IDC_CHEMAIL)
{
dat.mode = GG_USERUTIL_EMAIL;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CHEMAIL), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
else
{
dat.mode = GG_USERUTIL_REMOVE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_REMOVEACCOUNT), hwndDlg, gg_userutildlgproc, (LPARAM)&dat);
}
if(ret == IDOK)
{
DBVARIANT dbv;
DWORD num;
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
// Show reload required window
ShowWindow(GetDlgItem(hwndDlg, IDC_RELOADREQD), SW_SHOW);
// Update uin
if (num = DBGetContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, 0))
SetDlgItemText(hwndDlg, IDC_UIN, ditoa(num));
else
SetDlgItemText(hwndDlg, IDC_UIN, "");
// Update password
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, &dbv)) {
CallService(MS_DB_CRYPT_DECODESTRING, strlen(dbv.pszVal) + 1, (LPARAM) dbv.pszVal);
SetDlgItemText(hwndDlg, IDC_PASSWORD, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
SetDlgItemText(hwndDlg, IDC_PASSWORD, "");
// Update e-mail
if (!DBGetContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, &dbv)) {
SetDlgItemText(hwndDlg, IDC_EMAIL, dbv.pszVal);
DBFreeVariant(&dbv);
}
else
SetDlgItemText(hwndDlg, IDC_EMAIL, "");
// Update links
gg_optsdlgcheck(hwndDlg);
// Remove details
if(LOWORD(wParam) != IDC_CHPASS && LOWORD(wParam) != IDC_CHEMAIL)
{
DBDeleteContactSetting(NULL, GG_PROTO, GG_KEY_NICK);
DBDeleteContactSetting(NULL, GG_PROTO, "NickName");
DBDeleteContactSetting(NULL, GG_PROTO, "City");
DBDeleteContactSetting(NULL, GG_PROTO, "FirstName");
DBDeleteContactSetting(NULL, GG_PROTO, "LastName");
DBDeleteContactSetting(NULL, GG_PROTO, "FamilyName");
DBDeleteContactSetting(NULL, GG_PROTO, "CityOrigin");
DBDeleteContactSetting(NULL, GG_PROTO, "Age");
DBDeleteContactSetting(NULL, GG_PROTO, "BirthYear");
DBDeleteContactSetting(NULL, GG_PROTO, "Gender");
}
}
}
break;
}
SendMessage(GetParent(hwndDlg), PSM_CHANGED, 0, 0);
break;
}
case WM_NOTIFY:
{
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
{
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
int status_flags = GG_STATUS_FLAG_UNKNOWN;
char str[128];
uin_t uin;
// Write Gadu-Gadu number & password
GetDlgItemText(hwndDlg, IDC_UIN, str, sizeof(str));
uin = atoi(str);
GetDlgItemText(hwndDlg, IDC_PASSWORD, str, sizeof(str));
CallService(MS_DB_CRYPT_ENCODESTRING, sizeof(str), (LPARAM) str);
gg_checknewuser(gg, uin, str);
DBWriteContactSettingDword(NULL, GG_PROTO, GG_KEY_UIN, uin);
DBWriteContactSettingString(NULL, GG_PROTO, GG_KEY_PASSWORD, str);
// Write Gadu-Gadu email
GetDlgItemText(hwndDlg, IDC_EMAIL, str, sizeof(str));
DBWriteContactSettingString(NULL, GG_PROTO, GG_KEY_EMAIL, str);
// Write checkboxes
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_FRIENDSONLY, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_FRIENDSONLY));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWINVISIBLE, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SHOWINVISIBLE));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_LEAVESTATUSMSG, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_LEAVESTATUSMSG));
if (gg->gc_enabled)
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_IGNORECONF, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_IGNORECONF));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGRECEIVE, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_IMGRECEIVE));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_SHOWLINKS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_SHOWLINKS));
if (IsDlgButtonChecked(hwndDlg, IDC_SHOWLINKS))
status_flags |= GG_STATUS_FLAG_SPAM;
EnterCriticalSection(&gg->sess_mutex);
gg_change_status_flags(gg->sess, status_flags);
LeaveCriticalSection(&gg->sess_mutex);
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_ENABLEAVATARS, (BYTE) IsDlgButtonChecked(hwndDlg, IDC_ENABLEAVATARS));
DBWriteContactSettingByte(NULL, GG_PROTO, GG_KEY_IMGMETHOD,
(BYTE)SendDlgItemMessage(hwndDlg, IDC_IMGMETHOD, CB_GETCURSEL, 0, 0));
// Write leave status
switch(SendDlgItemMessage(hwndDlg, IDC_LEAVESTATUS, CB_GETCURSEL, 0, 0))
{
case 1:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_ONLINE);
break;
case 2:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_AWAY);
break;
case 3:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_DND);
break;
case 4:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_FREECHAT);
break;
case 5:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, ID_STATUS_INVISIBLE);
break;
default:
DBWriteContactSettingWord(NULL, GG_PROTO, GG_KEY_LEAVESTATUS, GG_KEYDEF_LEAVESTATUS);
}
break;
}
}
break;
}
}
return FALSE;
}
LRESULT CALLBACK BaseApp::wndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
LRESULT result = 0;
if (message == WM_CREATE)
{
LPCREATESTRUCT pcs = (LPCREATESTRUCT)lParam;
BaseApp *pBaseApp = (BaseApp *)pcs->lpCreateParams;
::SetWindowLongPtrW(
hwnd,
GWLP_USERDATA,
PtrToUlong(pBaseApp)
);
result = 1;
}
else
{
BaseApp *pBaseApp = reinterpret_cast<BaseApp *>(static_cast<LONG_PTR>(
::GetWindowLongPtrW(
hwnd,
GWLP_USERDATA
)));
bool wasHandled = false;
UINT width = LOWORD(lParam);
UINT height = HIWORD(lParam);
if (pBaseApp)
{
switch (message)
{
case WM_KEYDOWN:
pBaseApp->onKeyDown(wParam);
InvalidateRect(hwnd, NULL, FALSE);
break;
case WM_SIZE:
pBaseApp->onResize(width, height);
result = 0;
wasHandled = true;
break;
case WM_DISPLAYCHANGE:
InvalidateRect(hwnd, NULL, FALSE);
result = 0;
wasHandled = true;
break;
case WM_PAINT:
pBaseApp->onRender();
ValidateRect(hwnd, NULL);
result = 0;
wasHandled = true;
break;
case WM_DESTROY:
PostQuitMessage(0);
result = 1;
wasHandled = true;
break;
case WM_LBUTTONDOWN:
pBaseApp->onLButtonDown(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), (DWORD)wParam);
break;
case WM_LBUTTONUP:
pBaseApp->onLButtonUp();
break;
case WM_MOUSEMOVE:
pBaseApp->onMouseMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), (DWORD)wParam);
break;
}
}
if (!wasHandled)
{
result = DefWindowProc(hwnd, message, wParam, lParam);
}
}
return result;
}
static LRESULT CALLBACK wndProc(HWND wnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
int useDefWindowProc = 0;
JNIEnv *env = NULL;
jobject window = NULL;
BOOL isKeyDown = FALSE;
WindowUserData * wud;
#ifdef DEBUG_KEYS
if ( WM_KEYDOWN == message ) {
STD_PRINT("*** WindowsWindow: wndProc window %p, 0x%X %d/%d\n", wnd, message, (int)LOWORD(lParam), (int)HIWORD(lParam));
}
#endif
#if defined(UNDER_CE) || _MSC_VER <= 1200
wud = (WindowUserData *) GetWindowLong(wnd, GWL_USERDATA);
#else
wud = (WindowUserData *) GetWindowLongPtr(wnd, GWLP_USERDATA);
#endif
if(NULL==wud) {
return DefWindowProc(wnd, message, wParam, lParam);
}
env = wud->jenv;
window = wud->jinstance;
if (NULL==window || NULL==env) {
return DefWindowProc(wnd, message, wParam, lParam);
}
// DBG_PRINT("*** WindowsWindow: window %p -> %p, 0x%X %d/%d\n", wnd, window, message, (int)LOWORD(lParam), (int)HIWORD(lParam));
switch (message) {
//
// The signal pipeline for destruction is:
// Java::DestroyWindow(wnd) _or_ window-close-button ->
// WM_CLOSE -> Java::windowDestroyNotify -> W_DESTROY -> Java::windowDestroyed ->
// Java::CleanupWindowResources()
case WM_CLOSE:
(*env)->CallVoidMethod(env, window, windowDestroyNotifyID);
break;
case WM_DESTROY:
{
#if defined(UNDER_CE) || _MSC_VER <= 1200
SetWindowLong(wnd, GWL_USERDATA, (intptr_t) NULL);
#else
SetWindowLongPtr(wnd, GWLP_USERDATA, (intptr_t) NULL);
#endif
free(wud); wud=NULL;
(*env)->CallVoidMethod(env, window, windowDestroyedID);
(*env)->DeleteGlobalRef(env, window);
}
break;
case WM_SYSCHAR:
useDefWindowProc = WmChar(env, window, wParam,
LOWORD(lParam), HIWORD(lParam), FALSE);
break;
case WM_CHAR:
useDefWindowProc = WmChar(env, window, wParam,
LOWORD(lParam), HIWORD(lParam), TRUE);
break;
case WM_KEYDOWN:
#ifdef DEBUG_KEYS
STD_PRINT("*** WindowsWindow: windProc sending window %p -> %p, 0x%X %d/%d\n", wnd, window, message, (int)LOWORD(lParam), (int)HIWORD(lParam));
#endif
useDefWindowProc = WmKeyDown(env, window, wParam,
LOWORD(lParam), HIWORD(lParam), FALSE);
break;
case WM_KEYUP:
useDefWindowProc = WmKeyUp(env, window, wParam,
LOWORD(lParam), HIWORD(lParam), FALSE);
break;
case WM_SIZE:
WmSize(env, wnd, window, (UINT)wParam);
break;
case WM_SETTINGCHANGE:
if (wParam == SPI_SETNONCLIENTMETRICS) {
// make sure insets are updated, we don't need to resize the window
// because the size of the client area doesn't change
(void)UpdateInsets(env, wnd, window);
} else {
useDefWindowProc = 1;
}
break;
case WM_LBUTTONDOWN:
NewtWindows_requestFocus ( wnd ); // request focus on this window, if not already ..
(*env)->CallVoidMethod(env, window, sendMouseEventID,
(jint) EVENT_MOUSE_PRESSED,
GetModifiers(),
(jint) LOWORD(lParam), (jint) HIWORD(lParam),
(jint) 1, (jint) 0);
useDefWindowProc = 1;
break;
case WM_LBUTTONUP:
(*env)->CallVoidMethod(env, window, sendMouseEventID,
(jint) EVENT_MOUSE_RELEASED,
GetModifiers(),
(jint) LOWORD(lParam), (jint) HIWORD(lParam),
(jint) 1, (jint) 0);
useDefWindowProc = 1;
break;
case WM_MBUTTONDOWN:
NewtWindows_requestFocus ( wnd ); // request focus on this window, if not already ..
(*env)->CallVoidMethod(env, window, sendMouseEventID,
(jint) EVENT_MOUSE_PRESSED,
GetModifiers(),
(jint) LOWORD(lParam), (jint) HIWORD(lParam),
(jint) 2, (jint) 0);
useDefWindowProc = 1;
break;
case WM_MBUTTONUP:
(*env)->CallVoidMethod(env, window, sendMouseEventID,
(jint) EVENT_MOUSE_RELEASED,
GetModifiers(),
(jint) LOWORD(lParam), (jint) HIWORD(lParam),
(jint) 2, (jint) 0);
useDefWindowProc = 1;
break;
case WM_RBUTTONDOWN:
NewtWindows_requestFocus ( wnd ); // request focus on this window, if not already ..
(*env)->CallVoidMethod(env, window, sendMouseEventID,
(jint) EVENT_MOUSE_PRESSED,
GetModifiers(),
(jint) LOWORD(lParam), (jint) HIWORD(lParam),
(jint) 3, (jint) 0);
useDefWindowProc = 1;
break;
case WM_RBUTTONUP:
(*env)->CallVoidMethod(env, window, sendMouseEventID,
(jint) EVENT_MOUSE_RELEASED,
GetModifiers(),
(jint) LOWORD(lParam), (jint) HIWORD(lParam),
(jint) 3, (jint) 0);
useDefWindowProc = 1;
break;
case WM_MOUSEMOVE:
(*env)->CallVoidMethod(env, window, sendMouseEventID,
(jint) EVENT_MOUSE_MOVED,
GetModifiers(),
(jint) LOWORD(lParam), (jint) HIWORD(lParam),
(jint) 0, (jint) 0);
useDefWindowProc = 1;
break;
case WM_MOUSEWHEEL: {
// need to convert the coordinates to component-relative
int x = GET_X_LPARAM(lParam);
int y = GET_Y_LPARAM(lParam);
POINT eventPt;
eventPt.x = x;
eventPt.y = y;
ScreenToClient(wnd, &eventPt);
(*env)->CallVoidMethod(env, window, sendMouseEventID,
(jint) EVENT_MOUSE_WHEEL_MOVED,
GetModifiers(),
(jint) eventPt.x, (jint) eventPt.y,
(jint) 0, (jint) (GET_WHEEL_DELTA_WPARAM(wParam)/120.0f));
useDefWindowProc = 1;
break;
}
case WM_SETFOCUS:
(*env)->CallVoidMethod(env, window, focusChangedID,
(jlong)wParam, JNI_TRUE);
useDefWindowProc = 1;
break;
case WM_KILLFOCUS:
(*env)->CallVoidMethod(env, window, focusChangedID,
(jlong)wParam, JNI_FALSE);
useDefWindowProc = 1;
break;
case WM_MOVE:
DBG_PRINT("*** WindowsWindow: WM_MOVE window %p, %d/%d\n", wnd, (int)LOWORD(lParam), (int)HIWORD(lParam));
(*env)->CallVoidMethod(env, window, positionChangedID,
(jint)LOWORD(lParam), (jint)HIWORD(lParam));
useDefWindowProc = 1;
break;
case WM_PAINT: {
RECT r;
if (GetUpdateRect(wnd, &r, FALSE)) {
if ((r.right-r.left) > 0 && (r.bottom-r.top) > 0) {
(*env)->CallVoidMethod(env, window, sendPaintEventID,
0, r.left, r.top, r.right-r.left, r.bottom-r.top);
}
ValidateRect(wnd, &r);
useDefWindowProc = 0;
} else {
useDefWindowProc = 1;
}
break;
}
case WM_ERASEBKGND:
// ignore erase background
useDefWindowProc = 0;
break;
// FIXME: generate EVENT_MOUSE_ENTERED, EVENT_MOUSE_EXITED
default:
useDefWindowProc = 1;
}
if (useDefWindowProc)
return DefWindowProc(wnd, message, wParam, lParam);
return 0;
}
LRESULT VLCControlsWnd::WindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg){
case WM_CREATE:{
const int ControlsHeight = 21+3;
const int ButtonsWidth = ControlsHeight;
int HorizontalOffset = xControlsSpace;
int ControlWidth = ButtonsWidth;
hPlayPauseButton =
CreateWindow(TEXT("BUTTON"), TEXT("Play/Pause"),
WS_CHILD|WS_VISIBLE|BS_BITMAP|BS_FLAT,
HorizontalOffset, xControlsSpace,
ControlWidth, ControlsHeight, hWnd(),
(HMENU)ID_FS_PLAY_PAUSE, 0, 0);
SendMessage(hPlayPauseButton, BM_SETIMAGE,
(WPARAM)IMAGE_BITMAP, (LPARAM)RC().hPauseBitmap);
HorizontalOffset+=ControlWidth+xControlsSpace;
ControlWidth = 200;
int VideoPosControlHeight = 10;
hVideoPosScroll =
CreateWindow(PROGRESS_CLASS, TEXT("Video Position"),
WS_CHILD|WS_DISABLED|WS_VISIBLE|SBS_HORZ|SBS_TOPALIGN|PBS_SMOOTH,
HorizontalOffset, xControlsSpace+(ControlsHeight-VideoPosControlHeight)/2,
ControlWidth, VideoPosControlHeight, hWnd(),
(HMENU)ID_FS_VIDEO_POS_SCROLL, 0, 0);
HMODULE hThModule = LoadLibrary(TEXT("UxTheme.dll"));
if(hThModule){
FARPROC proc = GetProcAddress(hThModule, "SetWindowTheme");
typedef HRESULT (WINAPI* SetWindowThemeProc)(HWND, LPCWSTR, LPCWSTR);
if(proc){
((SetWindowThemeProc)proc)(hVideoPosScroll, L"", L"");
}
FreeLibrary(hThModule);
}
HorizontalOffset+=ControlWidth+xControlsSpace;
ControlWidth = ButtonsWidth;
hMuteButton =
CreateWindow(TEXT("BUTTON"), TEXT("Mute"),
WS_CHILD|WS_VISIBLE|BS_AUTOCHECKBOX|BS_PUSHLIKE|BS_BITMAP, //BS_FLAT
HorizontalOffset, xControlsSpace,
ControlWidth, ControlsHeight,
hWnd(), (HMENU)ID_FS_MUTE, 0, 0);
SendMessage(hMuteButton, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP,
(LPARAM)RC().hVolumeBitmap);
HorizontalOffset+=ControlWidth+xControlsSpace;
ControlWidth = 100;
hVolumeSlider =
CreateWindow(TRACKBAR_CLASS, TEXT("Volume"),
WS_CHILD|WS_VISIBLE|TBS_HORZ|TBS_BOTTOM|TBS_AUTOTICKS,
HorizontalOffset, xControlsSpace,
ControlWidth, ControlsHeight - 4, hWnd(),
(HMENU)ID_FS_VOLUME, 0, 0);
HorizontalOffset+=ControlWidth+xControlsSpace;
SendMessage(hVolumeSlider, TBM_SETRANGE, FALSE, (LPARAM) MAKELONG (0, 100));
SendMessage(hVolumeSlider, TBM_SETTICFREQ, (WPARAM) 10, 0);
ControlWidth = ButtonsWidth;
DWORD dwFSBtnStyle = WS_CHILD|BS_BITMAP|BS_FLAT;
if( !PO() || PO()->get_enable_fs() ){
dwFSBtnStyle |= WS_VISIBLE;
}
hFSButton =
CreateWindow(TEXT("BUTTON"), TEXT("Toggle fullscreen"),
dwFSBtnStyle,
HorizontalOffset, xControlsSpace,
ControlWidth, ControlsHeight, hWnd(),
(HMENU)ID_FS_SWITCH_FS, 0, 0);
SendMessage(hFSButton, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP,
(LPARAM)RC().hDeFullscreenBitmap);
HorizontalOffset+=ControlWidth+xControlsSpace;
RECT rect;
GetClientRect(GetParent(hWnd()), &rect);
int ControlWndWidth = HorizontalOffset;
int ControlWndHeight = xControlsSpace+ControlsHeight+xControlsSpace;
SetWindowPos(hWnd(), 0,
0, (rect.bottom - rect.top) - ControlWndWidth,
rect.right-rect.left, ControlWndHeight,
SWP_NOZORDER|SWP_NOOWNERZORDER|SWP_NOACTIVATE);
//new message blinking timer
SetTimer(hWnd(), 2, 500, NULL);
CreateToolTip();
break;
}
case WM_SHOWWINDOW:{
if(FALSE!=wParam){ //showing
UpdateButtons();
}
break;
}
case WM_LBUTTONUP:{
POINT BtnUpPoint = {LOWORD(lParam), HIWORD(lParam)};
RECT VideoPosRect;
GetWindowRect(hVideoPosScroll, &VideoPosRect);
ClientToScreen(hWnd(), &BtnUpPoint);
if(PtInRect(&VideoPosRect, BtnUpPoint)){
SetVideoPos(float(BtnUpPoint.x-VideoPosRect.left)/(VideoPosRect.right-VideoPosRect.left));
}
break;
}
case WM_TIMER:{
switch(wParam){
case 1:{
POINT MousePoint;
GetCursorPos(&MousePoint);
RECT ControlWndRect;
GetWindowRect(hWnd(), &ControlWndRect);
if(PtInRect(&ControlWndRect, MousePoint)||GetCapture()==hVolumeSlider){
//do not allow control window to close while mouse is within
NeedShowControls();
}
else{
NeedHideControls();
}
break;
}
case 2:{
UpdateButtons();
break;
}
}
break;
}
case WM_SETCURSOR:{
RECT VideoPosRect;
GetWindowRect(hVideoPosScroll, &VideoPosRect);
DWORD dwMsgPos = GetMessagePos();
POINT MsgPosPoint = {LOWORD(dwMsgPos), HIWORD(dwMsgPos)};
if(PtInRect(&VideoPosRect, MsgPosPoint)){
SetCursor(LoadCursor(NULL, IDC_HAND));
return TRUE;
}
else{
return VLCWnd::WindowProc(uMsg, wParam, lParam);
}
break;
}
case WM_NCDESTROY:
break;
case WM_COMMAND:{
WORD NCode = HIWORD(wParam);
WORD Control = LOWORD(wParam);
switch(NCode){
case BN_CLICKED:{
switch(Control){
case ID_FS_SWITCH_FS:
WM().ToggleFullScreen();
break;
case ID_FS_PLAY_PAUSE:{
if( VP() ){
if( IsPlaying() )
VP()->pause();
else
VP()->play();
}
break;
}
case ID_FS_MUTE:{
if( VP() ){
VP()->set_mute( IsDlgButtonChecked(hWnd(), ID_FS_MUTE) != FALSE );
SyncVolumeSliderWithVLCVolume();
}
break;
}
}
break;
}
}
break;
}
case WM_SIZE:{
if( GetWindowLong(hWnd(), GWL_STYLE) & WS_VISIBLE &&
!WM().IsFullScreen() &&
( !PO() || !PO()->get_show_toolbar() ) )
{
//hide controls when they are not allowed
NeedHideControls();
}
const int new_client_width = LOWORD(lParam);
bool isFSBtnVisible =
(GetWindowLong(hFSButton, GWL_STYLE) & WS_VISIBLE) != 0;
HDWP hDwp = BeginDeferWindowPos(4);
int VideoScrollWidth = new_client_width;
POINT pt = {0, 0};
RECT rect;
GetWindowRect(hPlayPauseButton, &rect);
pt.x = rect.right;
ScreenToClient(hWnd(), &pt);
VideoScrollWidth -= pt.x;
VideoScrollWidth -= xControlsSpace;
RECT VideoSrcollRect;
GetWindowRect(hVideoPosScroll, &VideoSrcollRect);
RECT MuteRect;
GetWindowRect(hMuteButton, &MuteRect);
VideoScrollWidth -= xControlsSpace;
VideoScrollWidth -= (MuteRect.right - MuteRect.left);
RECT VolumeRect;
GetWindowRect(hVolumeSlider, &VolumeRect);
VideoScrollWidth -= xControlsSpace;
VideoScrollWidth -= (VolumeRect.right - VolumeRect.left);
RECT FSRect = {0, 0, 0, 0};
if( isFSBtnVisible ) {
GetWindowRect(hFSButton, &FSRect);
VideoScrollWidth -= xControlsSpace;
VideoScrollWidth -= (FSRect.right - FSRect.left);
VideoScrollWidth -= xControlsSpace;
}
pt.x = VideoSrcollRect.left;
pt.y = VideoSrcollRect.top;
ScreenToClient(hWnd(), &pt);
hDwp = DeferWindowPos(hDwp, hVideoPosScroll, 0, pt.x, pt.y,
VideoScrollWidth,
VideoSrcollRect.bottom - VideoSrcollRect.top,
SWP_NOACTIVATE|SWP_NOOWNERZORDER);
int HorizontalOffset =
pt.x + VideoScrollWidth + xControlsSpace;
pt.x = 0;
pt.y = MuteRect.top;
ScreenToClient(hWnd(), &pt);
hDwp = DeferWindowPos(hDwp, hMuteButton, 0,
HorizontalOffset, pt.y, 0, 0,
SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOOWNERZORDER);
HorizontalOffset +=
MuteRect.right - MuteRect.left + xControlsSpace;
pt.x = 0;
pt.y = VolumeRect.top;
ScreenToClient(hWnd(), &pt);
hDwp = DeferWindowPos(hDwp, hVolumeSlider, 0,
HorizontalOffset, pt.y, 0, 0,
SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOOWNERZORDER);
HorizontalOffset +=
VolumeRect.right - VolumeRect.left + xControlsSpace;
if( isFSBtnVisible ) {
pt.x = 0;
pt.y = FSRect.top;
ScreenToClient(hWnd(), &pt);
hDwp = DeferWindowPos(hDwp, hFSButton, 0,
HorizontalOffset, pt.y, 0, 0,
SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOOWNERZORDER);
}
EndDeferWindowPos(hDwp);
break;
}
case WM_HSCROLL:
case WM_VSCROLL: {
if( VP() ){
if(hVolumeSlider==(HWND)lParam){
LRESULT SliderPos = SendMessage(hVolumeSlider, (UINT) TBM_GETPOS, 0, 0);
SetVLCVolumeBySliderPos(SliderPos);
}
}
break;
}
default:
return VLCWnd::WindowProc(uMsg, wParam, lParam);
}
return 0L;
}
/*
* Class: com_jogamp_newt_impl_windows_WindowsDisplay
* Method: DispatchMessages
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_com_jogamp_newt_impl_windows_WindowsDisplay_DispatchMessages
(JNIEnv *env, jclass clazz)
{
int i = 0;
MSG msg;
BOOL gotOne;
// Periodically take a break
do {
gotOne = PeekMessage(&msg, (HWND) NULL, 0, 0, PM_REMOVE);
if (gotOne) {
++i;
#ifdef DEBUG_KEYS
if(WM_KEYDOWN == msg.message) {
STD_PRINT("*** WindowsWindow: DispatchMessages window %p, 0x%X %d/%d\n", msg.hwnd, msg.message, (int)LOWORD(msg.lParam), (int)HIWORD(msg.lParam));
}
#endif
TranslateMessage(&msg);
DispatchMessage(&msg);
}
} while (gotOne && i < 100);
}
void cMainGame::WndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
if(m_pCamera)
m_pCamera->WndProc(hWnd, message, wParam, lParam);
switch (message)
{
case WM_RBUTTONDOWN:
{
m_pStartNode = GetPickedNode(LOWORD(lParam), HIWORD(lParam));
}
break;
case WM_RBUTTONUP:
{
if(m_pStartNode)
{
m_pDestNode = GetPickedNode(LOWORD(lParam), HIWORD(lParam));
if(m_pDestNode)
{
FindPath();
}
}
m_pDestNode = NULL;
m_pStartNode = NULL;
}
break;
case WM_KEYDOWN:
{
static int n = 0;
++n;
m_pSkinnedMesh->SetAnimationIndex(n);
}
break;
case WM_LBUTTONDOWN:
{
// static int n = 0;
// ++n;
// m_pSkinnedMesh->SetAnimationIndex(n);
//
// ResetAllNode();
//
// m_pPickedNode = GetPickedNode(LOWORD(lParam), HIWORD(lParam));
// if(m_pPickedNode)
// {
// m_pPickedNode->SetState(cDijkstraNode::E_SELECTED);
// }
}
break;
case WM_LBUTTONUP:
{
cDijkstraNode* pNode = GetPickedNode(LOWORD(lParam), HIWORD(lParam));
if(m_pPickedNode && pNode)
{
ST_PC_VERTEX v;
v.c = D3DCOLOR_XRGB(255, 0 ,0);
v.p = m_pPickedNode->GetPosition();
m_vecEdge.push_back(v);
v.p = pNode->GetPosition();
m_vecEdge.push_back(v);
D3DXVECTOR3 vDelta = m_pPickedNode->GetPosition() - pNode->GetPosition();
float l = D3DXVec3Length(&vDelta);
m_vecEdgeCost[m_pPickedNode->GetNodeId()][pNode->GetNodeId()] = l;
m_vecEdgeCost[pNode->GetNodeId()][m_pPickedNode->GetNodeId()] = l;
}
m_pPickedNode = NULL;
ResetAllNode();
}
break;
case WM_MOUSEMOVE:
{
int x = LOWORD(lParam);
int y = HIWORD(lParam);
cRay r = cRay::RayAtWorldSpace(x, y);
for (size_t i = 0; i < m_vecDijkstraNode.size(); ++i)
{
if(m_vecDijkstraNode[i]->GetState() == cDijkstraNode::E_SELECTED)
continue;
if(m_vecDijkstraNode[i]->GetState() == cDijkstraNode::E_PATH)
continue;
if(r.IsPicked(m_vecDijkstraNode[i]->GetPosition(), m_vecDijkstraNode[i]->GetRadius()))
{
m_vecDijkstraNode[i]->SetState(cDijkstraNode::E_MOUSE_OVER);
}
else
{
m_vecDijkstraNode[i]->SetState(cDijkstraNode::E_NORMAL);
}
}
}
break;
}
}
void CBacnetOutput::OnNMClickListOutput(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
// TODO: Add your control notification handler code here
long lRow,lCol;
m_output_list.Set_Edit(true);
DWORD dwPos=GetMessagePos();//Get which line is click by user.Set the check box, when user enter Insert it will jump to program dialog
CPoint point( LOWORD(dwPos), HIWORD(dwPos));
m_output_list.ScreenToClient(&point);
LVHITTESTINFO lvinfo;
lvinfo.pt=point;
lvinfo.flags=LVHT_ABOVE;
int nItem=m_output_list.SubItemHitTest(&lvinfo);
if((nItem!=-1) && (nItem < BAC_OUTPUT_ITEM_COUNT))
{
output_list_line = nItem;
if((m_Output_data.at(output_list_line).sub_id !=0) &&
//(m_Output_data.at(output_list_line).sub_number !=0) &&
(m_Output_data.at(output_list_line).sub_product !=0))
{
unsigned char temp_pid = m_Output_data.at(output_list_line).sub_product;
if((temp_pid == PM_T3PT10) ||
(temp_pid == PM_T3IOA) ||
(temp_pid == PM_T332AI) ||
(temp_pid == PM_T38AI16O) ||
(temp_pid == PM_T38I13O) ||
(temp_pid == PM_T34AO) ||
(temp_pid == PM_T36CT) ||
(temp_pid == PM_T322AI) ||
(temp_pid == PM_T38AI8AO6DO))
{
m_output_item_info.ShowWindow(true);
CString temp_name;
temp_name = GetProductName(m_Output_data.at(output_list_line).sub_product);
CString show_info;
CString temp_id;
CString temp_number;
temp_id.Format(_T(" Sub ID: %u "),(unsigned char)m_Output_data.at(output_list_line).sub_id);
temp_number.Format(_T("Output%d"),(unsigned char)m_Output_data.at(output_list_line).sub_number+1);
show_info = _T("Module:") + temp_name +_T(" ") + temp_id + temp_number;
m_output_item_info.SetWindowTextW(show_info);
}
else
{
m_output_item_info.ShowWindow(false);
}
}
else
{
m_output_item_info.ShowWindow(false);
}
}
lRow = lvinfo.iItem;
lCol = lvinfo.iSubItem;
if(lRow>= OUTPUT_LIMITE_ITEM_COUNT)
return;
if(lRow>m_output_list.GetItemCount()) //如果点击区超过最大行号，则点击是无效的
return;
if(lRow<0)
return;
CString New_CString;
CString temp_task_info;
CString temp1;
CStringArray temparray;
if(lCol == OUTPUT_VALUE)
{
if(m_Output_data.at(lRow).auto_manual == BAC_AUTO) //If it is auto mode, disable to change the value.
{
m_output_list.Set_Edit(false);
return;
}
if(m_Output_data.at(lRow).digital_analog != BAC_UNITS_DIGITAL)
return;
memcpy_s(&m_temp_output_data[lRow],sizeof(Str_out_point),&m_Output_data.at(lRow),sizeof(Str_out_point));
if((m_Output_data.at(lRow).range < 23) &&(m_Output_data.at(lRow).range !=0))
temp1 = Digital_Units_Array[m_Output_data.at(lRow).range];
else if((m_Output_data.at(lRow).range >=23) && (m_Output_data.at(lRow).range <= 30))
{
if(receive_customer_unit)
temp1 = temp_unit_no_index[m_Output_data.at(lRow).range - 23];
else
{
m_output_list.Set_Edit(false);
return;
}
}
else
return;
//if(m_Output_data.at(lRow).range > 11)
// temp1 = Digital_Units_Array[m_Output_data.at(lRow).range - 11];//11 is the sizeof the array
//else
// temp1 = Digital_Units_Array[m_Output_data.at(lRow).range];
SplitCStringA(temparray,temp1,_T("/"));
if(m_Output_data.at(lRow).control == 0)
{
m_Output_data.at(lRow).control = 1;
m_output_list.SetItemText(lRow,OUTPUT_VALUE,temparray.GetAt(1));
New_CString = temparray.GetAt(1);
}
else
{
m_Output_data.at(lRow).control = 0;
m_output_list.SetItemText(lRow,OUTPUT_VALUE,temparray.GetAt(0));
New_CString = temparray.GetAt(0);
}
}
else if(lCol == OUTPUT_AUTO_MANUAL)
{
memcpy_s(&m_temp_output_data[lRow],sizeof(Str_out_point),&m_Output_data.at(lRow),sizeof(Str_out_point));
if(m_Output_data.at(lRow).auto_manual == 0)
{
m_Output_data.at(lRow).auto_manual = 1;
m_output_list.SetItemText(lRow,OUTPUT_AUTO_MANUAL,_T("Manual"));
//m_output_list.SetCellEnabled(lRow,OUTPUT_VALUE,TRUE);
New_CString = _T("Manual");
}
else
{
m_Output_data.at(lRow).auto_manual = 0;
m_output_list.SetItemText(lRow,OUTPUT_AUTO_MANUAL,_T("Auto"));
//m_output_list.SetCellEnabled(lRow,OUTPUT_VALUE,FALSE);
New_CString = _T("Auto");
}
}
else if(lCol == OUTPUT_RANGE)
{
//CString temp_cs = m_output_list.GetItemText(Changed_Item,Changed_SubItem);
BacnetRange dlg;
//点击产品的时候 需要读customer units，老的产品firmware 说不定没有 这些，所以不强迫要读到;
if(!read_customer_unit)
{
int temp_invoke_id = -1;
int send_status = true;
int resend_count = 0;
for (int z=0;z<3;z++)
{
do
{
resend_count ++;
if(resend_count>5)
{
send_status = false;
break;
}
temp_invoke_id = GetPrivateData(
g_bac_instance,
READUNIT_T3000,
0,
BAC_CUSTOMER_UNITS_COUNT - 1,
sizeof(Str_Units_element));
Sleep(SEND_COMMAND_DELAY_TIME);
} while (g_invoke_id<0);
if(send_status)
{
for (int z=0;z<1000;z++)
{
Sleep(1);
if(tsm_invoke_id_free(temp_invoke_id))
{
read_customer_unit = true;
break;
}
else
continue;
}
}
if(read_customer_unit)
break;
}
}
if(m_Output_data.at(lRow).digital_analog == BAC_UNITS_ANALOG)
{
bac_ranges_type = OUTPUT_RANGE_ANALOG_TYPE;
if(m_Output_data.at(lRow).range > (sizeof(Output_Analog_Units_Array) / sizeof(Output_Analog_Units_Array[0])))
{
m_Output_data.at(lRow).range = 0;
bac_range_number_choose = 0;
}
}
else
{
bac_ranges_type = OUTPUT_RANGE_DIGITAL_TYPE;
if(m_Output_data.at(lRow).range > 30)
{
m_Output_data.at(lRow).range = 0;
bac_range_number_choose = 0;
}
}
//if(temp_cs.CompareNoCase(Units_Type[UNITS_TYPE_ANALOG])==0)
//{
initial_dialog = 3;
bac_range_number_choose = m_Output_data.at(lRow).range;
//bac_ranges_type = OUTPUT_RANGE_ANALOG_TYPE;
dlg.DoModal();
if(range_cancel)
{
PostMessage(WM_REFRESH_BAC_OUTPUT_LIST,lRow,REFRESH_ON_ITEM);//这里调用 刷新线程重新刷新会方便一点;
return ;
}
if(bac_range_number_choose == 0) //如果选择的是 unused 就认为是analog 的unused;这样 能显示对应的value;
{
m_Output_data.at(lRow).digital_analog = BAC_UNITS_ANALOG;
bac_ranges_type = OUTPUT_RANGE_ANALOG_TYPE;
}
if(bac_ranges_type == OUTPUT_RANGE_ANALOG_TYPE)
{
m_Output_data.at(lRow).digital_analog = BAC_UNITS_ANALOG;
m_Output_data.at(lRow).range = bac_range_number_choose;
m_output_list.SetItemText(lRow,OUTPUT_UNITE,Output_Analog_Units_Show[bac_range_number_choose]);
m_output_list.SetItemText(lRow,OUTPUT_RANGE,OutPut_List_Analog_Range[bac_range_number_choose]);
//m_output_list.SetItemText(lRow,OUTPUT_0_PERSENT,_T("0"));
//m_output_list.SetCellEnabled(lRow,OUTPUT_0_PERSENT,1);
//m_output_list.SetItemText(lRow,OUTPUT_100_PERSENT,_T("10"));
//m_output_list.SetCellEnabled(lRow,OUTPUT_100_PERSENT,1);
#if 0
CString cstemp_value;
float temp_float_value;
temp_float_value = m_Output_data.at(Changed_Item).value / 1000;
cstemp_value.Format(_T("%.2f"),temp_float_value);
m_output_list.SetItemText(Changed_Item,OUTPUT_VALUE,cstemp_value);
#endif
CString cstemp_value;
cstemp_value.Format(_T("%d"),m_Output_data.at(lRow).value);
m_output_list.SetItemText(lRow,OUTPUT_VALUE,cstemp_value);
}
else if((bac_ranges_type == VARIABLE_RANGE_DIGITAL_TYPE) || (bac_ranges_type == INPUT_RANGE_DIGITAL_TYPE) || (bac_ranges_type == OUTPUT_RANGE_DIGITAL_TYPE))
{
m_Output_data.at(lRow).digital_analog = BAC_UNITS_DIGITAL;
m_Output_data.at(lRow).range = bac_range_number_choose;
//m_output_list.SetItemText(lRow,OUTPUT_0_PERSENT,_T(""));
//m_output_list.SetCellEnabled(lRow,OUTPUT_0_PERSENT,0);
//m_output_list.SetItemText(lRow,OUTPUT_100_PERSENT,_T(""));
//m_output_list.SetCellEnabled(lRow,OUTPUT_100_PERSENT,0);
CStringArray temparray;
if((bac_range_number_choose >= 23) && (bac_range_number_choose <= 30))
{
//temp1.Format(_T("%s"), temp_unit_no_index[bac_range_number_choose - 23]);
temp1 = temp_unit_no_index[bac_range_number_choose - 23];
}
else
temp1 = Digital_Units_Array[bac_range_number_choose];//22 is the sizeof the array
SplitCStringA(temparray,temp1,_T("/"));
if(m_Output_data.at(lRow).control == 1)
{
if((temparray.GetSize()==2)&&(!temparray.GetAt(1).IsEmpty()))
{
m_output_list.SetItemText(lRow,OUTPUT_VALUE,temparray.GetAt(1));
}
}
else
{
if((temparray.GetSize()==2)&&(!temparray.GetAt(0).IsEmpty()))
{
m_output_list.SetItemText(lRow,OUTPUT_VALUE,temparray.GetAt(0));
}
}
m_output_list.SetItemText(lRow,OUTPUT_RANGE,temp1);
m_output_list.SetItemText(lRow,OUTPUT_UNITE,_T(""));//如果是数字单位 Unit 要清空;
}
}
else
{
return;
}
//return;
m_output_list.Set_Edit(false);
int cmp_ret = memcmp(&m_temp_output_data[lRow],&m_Output_data.at(lRow),sizeof(Str_out_point));
if(cmp_ret!=0)
{
m_output_list.SetItemBkColor(lRow,lCol,LIST_ITEM_CHANGED_BKCOLOR);
temp_task_info.Format(_T("Write Output List Item%d .Changed to \"%s\" "),lRow + 1,New_CString);
Post_Write_Message(g_bac_instance,WRITEOUTPUT_T3000,lRow,lRow,sizeof(Str_out_point),m_output_dlg_hwnd,temp_task_info,lRow,lCol);
}
*pResult = 0;
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// Below we check what the user types in. If they use the arrow keys
// then we want to move the triangle around (LEFT RIGHT UP and DOWN keys)
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE: // Check if we hit the ESCAPE key.
PostQuitMessage(0); // Tell windows we want to quit
break;
case VK_UP: // Check if we hit the UP ARROW key.
vTriangle[0].x += 0.01f; // Move the left point of the triangle to the left
vTriangle[1].x += 0.01f; // Move the right point of the triangle to the left
vTriangle[2].x += 0.01f; // Move the top point of the triangle to the left
break;
case VK_DOWN: // Check if we hit the DOWN ARROW key.
vTriangle[0].x -= 0.01f; // Move the left point of the triangle to the left
vTriangle[1].x -= 0.01f; // Move the right point of the triangle to the left
vTriangle[2].x -= 0.01f; // Move the top point of the triangle to the left
break;
case VK_LEFT: // Check if we hit the LEFT ARROW key.
vTriangle[0].z -= 0.01f; // Move the left point of the triangle back
vTriangle[1].z -= 0.01f; // Move the right point of the triangle back
vTriangle[2].z -= 0.01f; // Move the top point of the triangle back
break;
case VK_RIGHT: // Check if we hit the RIGHT ARROW key.
vTriangle[0].z += 0.01f; // Move the left point of the triangle forward
vTriangle[1].z += 0.01f; // Move the right point of the triangle forward
vTriangle[2].z += 0.01f; // Move the top point of the triangle forward
break;
}
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case WM_CLOSE: // If the window is closed
PostQuitMessage(0); // Tell windows we want to quit
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
long WMCommand (HWND hwnd, WPARAM wParam, LPARAM lParam){
if (LOWORD(wParam) == 1 && HIWORD (wParam) == EN_ERRSPACE)
MessageBox (hwnd, "Edit control out of space.", "Popup Editor", MB_OK | MB_ICONSTOP);
return 0;
}
LRESULT CALLBACK MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg) {
case WM_NOTIFY:
return MainNotify(hWnd, (LPNMHDR) lParam);
break;
case WM_CREATE:
MainCreate(hWnd);
break;
case WM_DROPFILES:
MainDropFiles(hWnd, (HDROP) wParam);
break;
case WM_COMMAND:
MainCommand(hWnd, LOWORD(wParam));
break;
case WM_SIZE:
MainSize(hWnd, LOWORD(lParam), HIWORD(lParam));
break;
case WM_MENUSELECT:
MainMenuSelect(hWnd, LOWORD(wParam), HIWORD(wParam));
break;
case WM_SETFOCUS:
SetFocus(hWndRtf);
break;
case WM_CONTEXTMENU: {
HWND hParam = (HWND) wParam;
HWND hRtfChild = GetDlgItem(hWnd, IDC_Rtf);
if (hParam == hWnd || hParam == hRtfChild)
ShowContextMenu(LOWORD(lParam), HIWORD(lParam));
}
break;
case WM_HELP:
MainCommand(hWnd, ID_HELPCONTENTS);
break;
case WM_CLOSE:
FinalizeWinGHCi();
if (Running)
AbortExecution();
FireAsyncCommand(TEXT(":quit"));
// should not be necessary
SetEvent(hKillGHCi);
PostQuitMessage(0);
break;
default: return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
return 0;
}
// ----------------------------------------------------------------------------
// Name : MouseMessage()
// Desc :
// ----------------------------------------------------------------------------
WMSG_RESULT CUIPetItemMix::MouseMessage( MSG *pMsg )
{
WMSG_RESULT wmsgResult;
// Title bar
static BOOL bTitleBarClick = FALSE;
// Mouse point
static int nOldX, nOldY;
int nX = LOWORD( pMsg->lParam );
int nY = HIWORD( pMsg->lParam );
// Mouse message
switch( pMsg->message )
{
case WM_MOUSEMOVE:
{
if( IsInside( nX, nY ) )
{
CUIManager::getSingleton()->SetMouseCursorInsideUIs();
int iRowS = m_sbProcessItem.GetScrollPos();
int iRowE = iRowS + PROCESS_SLOT_ROW;
if ( m_vecIcons.size() < iRowE )
{
iRowE = m_vecIcons.size();
}
if ( IsInsideRect ( nX, nY, m_rcItem ) )
{
bool bShowItem = false;
for( int iRow = iRowS; iRow < iRowE; iRow++ )
{
m_vecIcons[iRow]->MouseMessage( pMsg );
}
}
}
// Move refine
if( bTitleBarClick && ( pMsg->wParam & MK_LBUTTON ) )
{
int ndX = nX - nOldX;
int ndY = nY - nOldY;
nOldX = nX; nOldY = nY;
Move( ndX, ndY );
return WMSG_SUCCESS;
}
// Close button
else if( m_btnClose.MouseMessage( pMsg ) != WMSG_FAIL )
return WMSG_SUCCESS;
// OK button
else if( m_btnOK[1].MouseMessage( pMsg ) != WMSG_FAIL ) // 제작 타입 A
return WMSG_SUCCESS;
else if( m_btnOK[2].MouseMessage( pMsg ) != WMSG_FAIL ) // 제작 타입 B
return WMSG_SUCCESS;
else if( m_btnOK[0].MouseMessage( pMsg ) != WMSG_FAIL && m_nPetType == DRAGON_WEAPON ) // DRAGON
return WMSG_SUCCESS;
// Cancel button
else if( m_btnCancel.MouseMessage( pMsg ) != WMSG_FAIL )
return WMSG_SUCCESS;
// List box of skill desc
else if( m_sbProcessItem.MouseMessage( pMsg ) != WMSG_FAIL )
return WMSG_SUCCESS;
else if( m_lbPreconditionDesc.MouseMessage( pMsg ) != WMSG_FAIL )
return WMSG_SUCCESS;
}
break;
case WM_LBUTTONDOWN:
{
if( IsInside( nX, nY ) )
{
nOldX = nX; nOldY = nY;
// Close button
if( m_btnClose.MouseMessage( pMsg ) != WMSG_FAIL )
{
// Nothing
}
// Title bar
else if( IsInsideRect( nX, nY, m_rcTitle ) )
{
bTitleBarClick = TRUE;
}
// OK button
else if( m_btnOK[0].MouseMessage( pMsg ) != WMSG_FAIL && m_nPetType == DRAGON_WEAPON )
{
// Nothing
}
else if( m_btnOK[1].MouseMessage( pMsg ) != WMSG_FAIL )
{
// Nothing
}
else if( m_btnOK[2].MouseMessage( pMsg ) != WMSG_FAIL )
{
// Nothing
}
// Cancel button
else if( m_btnCancel.MouseMessage( pMsg ) != WMSG_FAIL )
{
// Nothing
}
else if( m_sbProcessItem.MouseMessage( pMsg ) != WMSG_FAIL )
{
return WMSG_SUCCESS;
}
CUIManager::getSingleton()->RearrangeOrder( UI_PETITEMMIX, TRUE );
return WMSG_SUCCESS;
}
}
break;
case WM_LBUTTONUP:
{
// If holding button doesn't exist
if (UIMGR()->GetDragIcon() == NULL)
{
// Title bar
bTitleBarClick = FALSE;
// If refine isn't focused
if( !IsFocused() )
return WMSG_FAIL;
// Close button
if( ( wmsgResult = m_btnClose.MouseMessage( pMsg ) ) != WMSG_FAIL )
{
if( wmsgResult == WMSG_COMMAND )
ClosePetItemMix();
return WMSG_SUCCESS;
}
// OK button
else if( ( wmsgResult = m_btnOK[0].MouseMessage( pMsg ) ) != WMSG_FAIL &&
m_nPetType == DRAGON_WEAPON )
{
if( wmsgResult == WMSG_COMMAND )
SendPetItemMixReq( 0, DRAGON_WEAPON );
return WMSG_SUCCESS;
}
else if( ( wmsgResult = m_btnOK[1].MouseMessage( pMsg ) ) != WMSG_FAIL )
{
if( wmsgResult == WMSG_COMMAND )
SendPetItemMixReq( 0, KNIGHT_AMOR );
return WMSG_SUCCESS;
}
else if( ( wmsgResult = m_btnOK[2].MouseMessage( pMsg ) ) != WMSG_FAIL )
{
if( wmsgResult == WMSG_COMMAND )
SendPetItemMixReq( 1, KNIGHT_AMOR );
return WMSG_SUCCESS;
}
// Cancel button
else if( ( wmsgResult = m_btnCancel.MouseMessage( pMsg ) ) != WMSG_FAIL )
{
if( wmsgResult == WMSG_COMMAND )
ClosePetItemMix();
return WMSG_SUCCESS;
}
else if( m_sbProcessItem.MouseMessage( pMsg ) != WMSG_FAIL )
{
return WMSG_SUCCESS;
}
else if( IsInsideRect( nX, nY, m_rcIcons ) )
{
int iRowS = m_sbProcessItem.GetScrollPos();
int iRowE = iRowS + PROCESS_SLOT_ROW;
if ( m_vecIcons.size() < iRowE )
{
iRowE = m_vecIcons.size();
}
for( int iRow = iRowS; iRow < iRowE; iRow++ )
{
if( m_vecIcons[iRow]->MouseMessage( pMsg ) != WMSG_FAIL )
{
m_nSelectProcessItem = iRow;
SelectItem ( m_nSelectProcessItem );
return WMSG_SUCCESS;
}
}
}
}
}
break;
case WM_LBUTTONDBLCLK:
{
if( IsInside( nX, nY ) )
return WMSG_SUCCESS;
}
break;
case WM_MOUSEWHEEL:
{
if( IsInside( nX, nY ) )
{
if ( IsInsideRect ( nX, nY, m_rcItem ) )
{
return m_sbProcessItem.MouseMessage( pMsg );
}
else if ( IsInsideRect ( nX, nY, m_rcDesc ) )
{
return m_lbPreconditionDesc.MouseMessage ( pMsg );
}
return WMSG_SUCCESS;
}
}
break;
}
return WMSG_FAIL;
}
static int winDialogBaseProc(Ihandle* ih, UINT msg, WPARAM wp, LPARAM lp, LRESULT *result)
{
if (iupwinBaseContainerProc(ih, msg, wp, lp, result))
return 1;
iupwinMenuDialogProc(ih, msg, wp, lp);
switch (msg)
{
case WM_GETDLGCODE:
*result = DLGC_WANTALLKEYS;
return 1;
case WM_GETMINMAXINFO:
{
if (winDialogCheckMinMaxInfo(ih, (MINMAXINFO*)lp))
{
*result = 0;
return 1;
}
break;
}
case WM_SIZE:
{
if (ih->data->ignore_resize)
break;
switch(wp)
{
case SIZE_MINIMIZED:
{
if (ih->data->show_state != IUP_MINIMIZE)
{
IFni show_cb = (IFni)IupGetCallback(ih, "SHOW_CB");
if (show_cb && show_cb(ih, IUP_MINIMIZE) == IUP_CLOSE)
IupExitLoop();
ih->data->show_state = IUP_MINIMIZE;
}
break;
}
case SIZE_MAXIMIZED:
{
if (ih->data->show_state != IUP_MAXIMIZE)
{
IFni show_cb = (IFni)IupGetCallback(ih, "SHOW_CB");
if (show_cb && show_cb(ih, IUP_MAXIMIZE) == IUP_CLOSE)
IupExitLoop();
ih->data->show_state = IUP_MAXIMIZE;
}
winDialogResize(ih, LOWORD(lp), HIWORD(lp));
break;
}
case SIZE_RESTORED:
{
if (ih->data->show_state == IUP_MAXIMIZE || ih->data->show_state == IUP_MINIMIZE)
{
IFni show_cb = (IFni)IupGetCallback(ih, "SHOW_CB");
if (show_cb && show_cb(ih, IUP_RESTORE) == IUP_CLOSE)
IupExitLoop();
ih->data->show_state = IUP_RESTORE;
}
winDialogResize(ih, LOWORD(lp), HIWORD(lp));
break;
}
}
break;
}
case WM_USER+IWIN_TRAY_NOTIFICATION:
{
int dclick = 0;
int button = 0;
int pressed = 0;
switch (lp)
{
case WM_LBUTTONDOWN:
pressed = 1;
button = 1;
break;
case WM_MBUTTONDOWN:
pressed = 1;
button = 2;
break;
case WM_RBUTTONDOWN:
pressed = 1;
button = 3;
break;
case WM_LBUTTONDBLCLK:
dclick = 1;
button = 1;
break;
case WM_MBUTTONDBLCLK:
dclick = 1;
button = 2;
break;
case WM_RBUTTONDBLCLK:
dclick = 1;
button = 3;
break;
case WM_LBUTTONUP:
button = 1;
break;
case WM_MBUTTONUP:
button = 2;
break;
case WM_RBUTTONUP:
button = 3;
break;
}
if (button != 0)
{
IFniii cb = (IFniii)IupGetCallback(ih, "TRAYCLICK_CB");
if (cb && cb(ih, button, pressed, dclick) == IUP_CLOSE)
IupExitLoop();
}
break;
}
case WM_CLOSE:
{
Icallback cb = IupGetCallback(ih, "CLOSE_CB");
if (cb)
{
int ret = cb(ih);
if (ret == IUP_IGNORE)
{
*result = 0;
return 1;
}
if (ret == IUP_CLOSE)
IupExitLoop();
}
/* child mdi is automatically destroyed */
if (iupAttribGetInt(ih, "MDICHILD"))
IupDestroy(ih);
else
{
if (!winDialogMDICloseChildren(ih))
{
*result = 0;
return 1;
}
IupHide(ih); /* IUP default processing */
}
*result = 0;
return 1;
}
case WM_SETCURSOR:
{
if (ih->handle == (HWND)wp && LOWORD(lp)==HTCLIENT)
{
HCURSOR hCur = (HCURSOR)iupAttribGet(ih, "_IUPWIN_HCURSOR");
if (hCur)
{
SetCursor(hCur);
*result = 1;
return 1;
}
else if (iupAttribGet(ih, "CURSOR"))
{
SetCursor(NULL);
*result = 1;
return 1;
}
}
break;
}
case WM_ERASEBKGND:
{
HBITMAP hBitmap = (HBITMAP)iupAttribGet(ih, "_IUPWIN_BACKGROUND_BITMAP");
if (hBitmap)
{
RECT rect;
HDC hdc = (HDC)wp;
HBRUSH hBrush = CreatePatternBrush(hBitmap);
GetClientRect(ih->handle, &rect);
FillRect(hdc, &rect, hBrush);
DeleteObject(hBrush);
/* return non zero value */
*result = 1;
return 1;
}
else
{
unsigned char r, g, b;
char* color = iupAttribGet(ih, "_IUPWIN_BACKGROUND_COLOR");
if (iupStrToRGB(color, &r, &g, &b))
{
RECT rect;
HDC hdc = (HDC)wp;
SetDCBrushColor(hdc, RGB(r,g,b));
GetClientRect(ih->handle, &rect);
FillRect(hdc, &rect, (HBRUSH)GetStockObject(DC_BRUSH));
/* return non zero value */
*result = 1;
return 1;
}
}
break;
}
case WM_DESTROY:
{
/* Since WM_CLOSE changed the Windows default processing */
/* WM_DESTROY is NOT received by IupDialogs */
/* Except when they are children of other IupDialogs and the parent is destroyed. */
/* So we have to destroy the child dialog. */
/* The application is responsable for destroying the children before this happen. */
IupDestroy(ih);
break;
}
}
if (msg == (UINT)WM_HELPMSG)
{
Ihandle* child = NULL;
DWORD* struct_ptr = (DWORD*)lp;
if (*struct_ptr == sizeof(CHOOSECOLOR))
{
CHOOSECOLOR* choosecolor = (CHOOSECOLOR*)lp;
child = (Ihandle*)choosecolor->lCustData;
}
if (*struct_ptr == sizeof(CHOOSEFONT))
{
CHOOSEFONT* choosefont = (CHOOSEFONT*)lp;
child = (Ihandle*)choosefont->lCustData;
}
if (child)
{
Icallback cb = IupGetCallback(child, "HELP_CB");
if (cb && cb(child) == IUP_CLOSE)
EndDialog((HWND)iupAttribGet(child, "HWND"), IDCANCEL);
}
}
return 0;
}
/******************************************************************
* WDML_ClientProc
*
* Window Proc created on client side for each conversation
*/
static LRESULT CALLBACK WDML_ClientProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
{
UINT uiLo, uiHi;
WDML_CONV* pConv = NULL;
HSZ hszSrv, hszTpc;
TRACE("%p %04x %08lx %08lx\n", hwnd, iMsg, wParam , lParam);
if (iMsg == WM_DDE_ACK &&
/* in the initial WM_INITIATE sendmessage */
((pConv = WDML_GetConvFromWnd(hwnd)) == NULL || pConv->wStatus == XST_INIT1))
{
/* In response to WM_DDE_INITIATE, save server window */
char buf[256];
WDML_INSTANCE* pInstance;
/* note: sent messages do not need packing */
uiLo = LOWORD(lParam);
uiHi = HIWORD(lParam);
/* FIXME: convlist should be handled here */
if (pConv)
{
/* we already have started the conv with a server, drop other replies */
GlobalDeleteAtom(uiLo);
GlobalDeleteAtom(uiHi);
PostMessageW((HWND)wParam, WM_DDE_TERMINATE, (WPARAM)hwnd, 0);
return 0;
}
pInstance = WDML_GetInstanceFromWnd(hwnd);
hszSrv = WDML_MakeHszFromAtom(pInstance, uiLo);
hszTpc = WDML_MakeHszFromAtom(pInstance, uiHi);
pConv = WDML_AddConv(pInstance, WDML_CLIENT_SIDE, hszSrv, hszTpc, hwnd, (HWND)wParam);
SetWindowLongPtrW(hwnd, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
pConv->wStatus |= ST_CONNECTED;
pConv->wConvst = XST_INIT1;
/* check if server is handled by DDEML */
if ((GetClassNameA((HWND)wParam, buf, sizeof(buf)) &&
lstrcmpiA(buf, WDML_szServerConvClassA) == 0) ||
(GetClassNameW((HWND)wParam, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
lstrcmpiW((LPWSTR)buf, WDML_szServerConvClassW) == 0))
{
pConv->wStatus |= ST_ISLOCAL;
}
WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_CONNECT_CONFIRM, (WPARAM)hwnd, wParam);
GlobalDeleteAtom(uiLo);
GlobalDeleteAtom(uiHi);
/* accept conversation */
return 1;
}
if (iMsg >= WM_DDE_FIRST && iMsg <= WM_DDE_LAST)
{
pConv = WDML_GetConvFromWnd(hwnd);
if (pConv)
{
MSG msg;
HDDEDATA hdd;
msg.hwnd = hwnd;
msg.message = iMsg;
msg.wParam = wParam;
msg.lParam = lParam;
WDML_HandleReply(pConv, &msg, &hdd, NULL);
}
return 0;
}
return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, iMsg, wParam, lParam) :
DefWindowProcA(hwnd, iMsg, wParam, lParam);
}
LRESULT WINAPI vmdWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
PAINTSTRUCT ps; /* Paint structure. */
// XXX this enum has to be replicated here since its otherwise
// private to the DisplayDevice class and children.
enum EventCodes { WIN_REDRAW, WIN_LEFT, WIN_MIDDLE, WIN_RIGHT,
WIN_WHEELUP, WIN_WHEELDOWN, WIN_MOUSEX, WIN_MOUSEY,
WIN_KBD,
WIN_KBD_ESCAPE,
WIN_KBD_UP,
WIN_KBD_DOWN,
WIN_KBD_LEFT,
WIN_KBD_RIGHT,
WIN_KBD_PAGE_UP,
WIN_KBD_PAGE_DOWN,
WIN_KBD_HOME,
WIN_KBD_END,
WIN_KBD_INSERT,
WIN_KBD_DELETE,
WIN_KBD_F1, WIN_KBD_F2, WIN_KBD_F3, WIN_KBD_F4,
WIN_KBD_F5, WIN_KBD_F6, WIN_KBD_F7, WIN_KBD_F8,
WIN_KBD_F9, WIN_KBD_F10, WIN_KBD_F11, WIN_KBD_F12,
WIN_NOEVENT };
wgldata *glwsrv;
OpenGLDisplayDevice * ogldispdev;
// Upon first window creation, immediately set our user-data field
// to store caller-provided handles for this window instance
if (msg == WM_NCCREATE) {
#if defined(_M_X64) || defined(_WIN64) || defined(_Wp64)
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR) (((CREATESTRUCT *) lParam)->lpCreateParams));
#else
SetWindowLong(hwnd, GWL_USERDATA, (LONG) (((CREATESTRUCT *) lParam)->lpCreateParams));
#endif
}
// check to make sure we have a valid window data structure in case
// it is destroyed while there are still pending messages...
#if defined(_M_X64) || defined(_WIN64) || defined(_Wp64)
ogldispdev = (OpenGLDisplayDevice *) GetWindowLongPtr(hwnd, GWLP_USERDATA);
#else
ogldispdev = (OpenGLDisplayDevice *) GetWindowLong(hwnd, GWL_USERDATA);
#endif
// when VMD destroys its window data structures it is possible that
// the window could still get messages briefly thereafter, this prevents
// us from attempting to handle any messages when the VMD state that goes
// with the window has already been destructed. (most notably when using
// the spaceball..) If we have a NULL pointer, let windows handle the
// event for us using the default window proc.
if (ogldispdev == NULL)
return DefWindowProc(hwnd, msg, wParam, lParam);
glwsrv = &ogldispdev->glwsrv;
#ifdef VMDSPACEWARE
// see if it is a spaceball event, if so do something about it.
if (vmd_processwin32spaceballevent(glwsrv, msg, wParam, lParam))
return 0; //
#endif
switch(msg) {
case WM_CREATE:
glwsrv->hWnd = hwnd;
glwsrv->hRC = SetupOpenGL(glwsrv);
glwsrv->WEvents = WIN_REDRAW;
return 0;
case WM_SIZE:
wglMakeCurrent(glwsrv->hDC, glwsrv->hRC);
ogldispdev->xSize = LOWORD(lParam);
ogldispdev->ySize = HIWORD(lParam);
ogldispdev->reshape();
glViewport(0, 0, (GLsizei) ogldispdev->xSize, (GLsizei) ogldispdev->ySize);
glwsrv->WEvents = WIN_REDRAW;
return 0;
case WM_SIZING:
wglMakeCurrent(glwsrv->hDC, glwsrv->hRC);
glClear(GL_COLOR_BUFFER_BIT);
SwapBuffers(glwsrv->hDC);
glDrawBuffer(GL_BACK);
return 0;
case WM_CLOSE:
PostQuitMessage(0);
return 0;
case WM_PAINT:
BeginPaint(hwnd, &ps);
EndPaint(hwnd, &ps);
glwsrv->WEvents = WIN_REDRAW;
return 0;
case WM_KEYDOWN:
glwsrv->KeyFlag = MapVirtualKey((UINT) wParam, 2); // map to ASCII
glwsrv->WEvents = WIN_KBD;
if (glwsrv->KeyFlag == 0) {
unsigned int keysym = wParam;
switch (keysym) {
case VK_ESCAPE: glwsrv->WEvents = WIN_KBD_ESCAPE; break;
case VK_UP: glwsrv->WEvents = WIN_KBD_UP; break;
case VK_DOWN: glwsrv->WEvents = WIN_KBD_DOWN; break;
case VK_LEFT: glwsrv->WEvents = WIN_KBD_LEFT; break;
case VK_RIGHT: glwsrv->WEvents = WIN_KBD_RIGHT; break;
case VK_PRIOR: glwsrv->WEvents = WIN_KBD_PAGE_UP; break;
case VK_NEXT: glwsrv->WEvents = WIN_KBD_PAGE_DOWN; break;
case VK_HOME: glwsrv->WEvents = WIN_KBD_HOME; break;
case VK_END: glwsrv->WEvents = WIN_KBD_END; break;
case VK_INSERT: glwsrv->WEvents = WIN_KBD_INSERT; break;
case VK_DELETE: glwsrv->WEvents = WIN_KBD_DELETE; break;
case VK_F1: glwsrv->WEvents = WIN_KBD_F1; break;
case VK_F2: glwsrv->WEvents = WIN_KBD_F2; break;
case VK_F3: glwsrv->WEvents = WIN_KBD_F3; break;
case VK_F4: glwsrv->WEvents = WIN_KBD_F4; break;
case VK_F5: glwsrv->WEvents = WIN_KBD_F5; break;
case VK_F6: glwsrv->WEvents = WIN_KBD_F6; break;
case VK_F7: glwsrv->WEvents = WIN_KBD_F7; break;
case VK_F8: glwsrv->WEvents = WIN_KBD_F8; break;
case VK_F9: glwsrv->WEvents = WIN_KBD_F9; break;
case VK_F10: glwsrv->WEvents = WIN_KBD_F10; break;
case VK_F11: glwsrv->WEvents = WIN_KBD_F11; break;
case VK_F12: glwsrv->WEvents = WIN_KBD_F12; break;
default:
glwsrv->WEvents = WIN_NOEVENT;
break;
}
}
return 0;
case WM_MOUSEMOVE:
vmd_transwin32mouse(ogldispdev, lParam);
glwsrv->MouseFlags = (long) wParam;
return 0;
case WM_MOUSEWHEEL:
{
int zDelta = ((short) HIWORD(wParam));
// XXX
// zDelta is in positive or negative multiples of WHEEL_DELTA for
// clicky type scroll wheels on existing mice, may need to
// recode this for continuous wheels at some future point in time.
// WHEEL_DELTA is 120 in current versions of Windows.
// We only activate an event if the user moves the mouse wheel at
// least half of WHEEL_DELTA, so that they don't do it by accident
// all the time.
if (zDelta > (WHEEL_DELTA / 2)) {
glwsrv->WEvents = WIN_WHEELUP;
} else if (zDelta < -(WHEEL_DELTA / 2)) {
glwsrv->WEvents = WIN_WHEELDOWN;
}
}
return 0;
case WM_LBUTTONDOWN:
SetCapture(hwnd);
vmd_transwin32mouse(ogldispdev, lParam);
glwsrv->MouseFlags = (long) wParam;
glwsrv->WEvents = WIN_LEFT;
return 0;
case WM_LBUTTONUP:
vmd_transwin32mouse(ogldispdev, lParam);
glwsrv->MouseFlags = (long) wParam;
glwsrv->WEvents = WIN_LEFT;
if (!(glwsrv->MouseFlags & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)))
ReleaseCapture();
return 0;
case WM_MBUTTONDOWN:
SetCapture(hwnd);
vmd_transwin32mouse(ogldispdev, lParam);
glwsrv->MouseFlags = (long) wParam;
glwsrv->WEvents = WIN_MIDDLE;
return 0;
case WM_MBUTTONUP:
vmd_transwin32mouse(ogldispdev, lParam);
glwsrv->MouseFlags = (long) wParam;
glwsrv->WEvents = WIN_MIDDLE;
if (!(glwsrv->MouseFlags & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)))
ReleaseCapture();
return 0;
case WM_RBUTTONDOWN:
SetCapture(hwnd);
vmd_transwin32mouse(ogldispdev, lParam);
glwsrv->MouseFlags = (long) wParam;
glwsrv->WEvents = WIN_RIGHT;
return 0;
case WM_RBUTTONUP:
vmd_transwin32mouse(ogldispdev, lParam);
glwsrv->MouseFlags = (long) wParam;
glwsrv->WEvents = WIN_RIGHT;
if (!(glwsrv->MouseFlags & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)))
ReleaseCapture();
return 0;
case WM_SETCURSOR:
// We process the mouse cursor hit test codes here, they tell us
// what part of the window we're over, which helps us set the cursor
// to the correct style for sizing borders, moves, etc.
switch (LOWORD(lParam)) {
case HTBOTTOM:
case HTTOP:
SetCursor(LoadCursor(NULL, IDC_SIZENS));
break;
case HTLEFT:
case HTRIGHT:
SetCursor(LoadCursor(NULL, IDC_SIZEWE));
break;
case HTTOPRIGHT:
case HTBOTTOMLEFT:
SetCursor(LoadCursor(NULL, IDC_SIZENESW));
break;
case HTTOPLEFT:
case HTBOTTOMRIGHT:
SetCursor(LoadCursor(NULL, IDC_SIZENWSE));
break;
case HTCAPTION:
SetCursor(LoadCursor(NULL, IDC_ARROW));
break;
case HTCLIENT:
default:
ogldispdev->set_cursor(glwsrv->cursornum);
}
return 0;
//
// Handle Windows File Drag and Drop Operations
// This code needs to be linked against SHELL32.DLL
//
case WM_DROPFILES:
{
char lpszFile[4096];
UINT numfiles, fileindex, numc;
HDROP hDropInfo = (HDROP)wParam;
// Get the number of simultaneous dragged/dropped files.
numfiles = DragQueryFile(hDropInfo, (DWORD)(-1), (LPSTR)NULL, 0);
msgInfo << "Ignoring Drag and Drop operation, received "
<< ((int) numfiles) << " files:" << sendmsg;
FileSpec spec;
for (fileindex=0; fileindex<numfiles; fileindex++) {
// lpszFile: complete pathname with device, colon and backslashes
numc = DragQueryFile(hDropInfo, fileindex, (char *) &lpszFile, 4096);
// VMD loads the file(s) here, or queues them up in its own
// list to decide how to cope with them. Deciding how to deal
// with these files is definitely the tricky part.
msgInfo << " File(" << ((int) fileindex) << "): " << lpszFile
<< " (numc=" << ((int) numc) << ")" << sendmsg;
// attempt to load the file into a new molecule
ogldispdev->vmdapp->molecule_load(-1, lpszFile, NULL, &spec);
}
DragFinish(hDropInfo); // finish drop operation and release memory
}
return 0;
default:
return DefWindowProc(hwnd, msg, wParam, lParam);
}
return 0;
}
static LRESULT CALLBACK
MainWndProc(HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam)
{
PMAIN_WND_INFO Info;
LRESULT Ret = 0;
/* Get the window context */
Info = (PMAIN_WND_INFO)GetWindowLongPtr(hwnd,
GWLP_USERDATA);
if (Info == NULL && msg != WM_CREATE)
{
goto HandleDefaultMessage;
}
switch(msg)
{
case WM_CREATE:
{
Info = (PMAIN_WND_INFO)(((LPCREATESTRUCT)lParam)->lpCreateParams);
/* Initialize the main window context */
Info->hMainWnd = hwnd;
Info->SelectedItem = NO_ITEM_SELECTED;
SetWindowLongPtr(hwnd,
GWLP_USERDATA,
(LONG_PTR)Info);
if (!InitMainWnd(Info))
return -1;
/* Fill the list-view before showing the main window */
RefreshServiceList(Info);
/* Show the window */
ShowWindow(hwnd,
Info->nCmdShow);
SetFocus(Info->hListView);
}
break;
case WM_SIZE:
{
MainWndResize(Info,
LOWORD(lParam),
HIWORD(lParam));
}
break;
case WM_NOTIFY:
{
LPNMHDR pnmhdr = (LPNMHDR)lParam;
switch (pnmhdr->code)
{
case NM_DBLCLK:
{
POINT pt;
RECT rect;
GetCursorPos(&pt);
GetWindowRect(Info->hListView, &rect);
if (PtInRect(&rect, pt))
{
SendMessage(hwnd,
WM_COMMAND,
//ID_PROP,
MAKEWPARAM((WORD)ID_PROP, (WORD)0),
0);
}
//OpenPropSheet(Info);
}
break;
case NM_RETURN:
{
SendMessage(hwnd,
WM_COMMAND,
//ID_PROP,
MAKEWPARAM((WORD)ID_PROP, (WORD)0),
0);
}
break;
case LVN_COLUMNCLICK:
{
static int iLastSortColumn = 0;
LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
/* get new sort parameters */
if (pnmv->iSubItem == iLastSortColumn)
bSortAscending = !bSortAscending;
else
{
iLastSortColumn = pnmv->iSubItem;
bSortAscending = TRUE;
}
/* store a copy to have access from callback */
hListView = Info->hListView;
(void)ListView_SortItems(Info->hListView,
CompareFunc,
pnmv->iSubItem);
}
break;
case LVN_ITEMCHANGED:
{
LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
if (pnmv->uNewState != 0)
{
ListViewSelectionChanged(Info, pnmv);
SetMenuAndButtonStates(Info);
}
}
break;
case TTN_GETDISPINFO:
{
LPTOOLTIPTEXT lpttt;
UINT idButton;
lpttt = (LPTOOLTIPTEXT)lParam;
/* Specify the resource identifier of the descriptive
* text for the given button. */
idButton = (UINT)lpttt->hdr.idFrom;
switch (idButton)
{
case ID_PROP:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PROP);
break;
case ID_REFRESH:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_REFRESH);
break;
case ID_EXPORT:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_EXPORT);
break;
case ID_CREATE:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_CREATE);
break;
case ID_DELETE:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_DELETE);
break;
case ID_START:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_START);
break;
case ID_STOP:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_STOP);
break;
case ID_PAUSE:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PAUSE);
break;
case ID_RESTART:
lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_RESTART);
break;
}
}
break;
}
}
break;
case WM_CONTEXTMENU:
{
POINT pt;
RECT lvRect;
INT xPos = GET_X_LPARAM(lParam);
INT yPos = GET_Y_LPARAM(lParam);
GetCursorPos(&pt);
/* display popup when cursor is in the list view */
GetWindowRect(Info->hListView, &lvRect);
if (PtInRect(&lvRect, pt))
{
TrackPopupMenuEx(GetSubMenu(Info->hShortcutMenu, 0),
TPM_RIGHTBUTTON,
xPos,
yPos,
Info->hMainWnd,
NULL);
}
}
break;
case WM_COMMAND:
{
MainWndCommand(Info,
LOWORD(wParam),
(HWND)lParam);
goto HandleDefaultMessage;
}
case WM_MENUSELECT:
{
if (Info->hStatus != NULL)
{
if (!MainWndMenuHint(Info,
LOWORD(wParam),
MainMenuHintTable,
sizeof(MainMenuHintTable) / sizeof(MainMenuHintTable[0]),
IDS_HINT_BLANK))
{
MainWndMenuHint(Info,
LOWORD(wParam),
SystemMenuHintTable,
sizeof(SystemMenuHintTable) / sizeof(SystemMenuHintTable[0]),
IDS_HINT_BLANK);
}
}
}
break;
case WM_ENTERMENULOOP:
{
Info->bInMenuLoop = TRUE;
UpdateMainStatusBar(Info);
break;
}
case WM_EXITMENULOOP:
{
Info->bInMenuLoop = FALSE;
UpdateMainStatusBar(Info);
break;
}
case WM_CLOSE:
{
HeapFree(ProcessHeap,
0,
Info->pAllServices);
DestroyMenu(Info->hShortcutMenu);
DestroyWindow(hwnd);
}
break;
case WM_DESTROY:
{
HeapFree(ProcessHeap,
0,
Info);
SetWindowLongPtr(hwnd,
GWLP_USERDATA,
0);
PostQuitMessage(0);
}
break;
default:
{
HandleDefaultMessage:
Ret = DefWindowProc(hwnd,
msg,
wParam,
lParam);
}
break;
}
return Ret;
}
BOOL PSPrint(
LPIMAGE lpImage,
LPFRAME lpFrame,
BYTE cSep,
int xSrc,
int ySrc,
int dxSrc,
int dySrc,
int xDest,
int yDest,
int dxDest,
int dyDest,
int iPrResX,
int iPrResY )
{
int y, yline, ystart, ylast, x, depth;
LFIXED yrate, yoffset;
LPTR lpBuffer[5], p1Buf, p2Buf, p3Buf, p4Buf;
LPSTR lpAngle, lpRuling;
LPTR lpImageData;
BOOL Negative, Asciize;
STRING szAngle, szRuling;
long lSize;
LPFRAME lpBaseFrame;
#define C_ANGLE Halftone.ScreenAngle[0]
#define M_ANGLE Halftone.ScreenAngle[1]
#define Y_ANGLE Halftone.ScreenAngle[2]
#define K_ANGLE Halftone.ScreenAngle[3]
#define C_RULING Halftone.ScreenRuling[0]
#define M_RULING Halftone.ScreenRuling[1]
#define Y_RULING Halftone.ScreenRuling[2]
#define K_RULING Halftone.ScreenRuling[3]
ProgressBegin(1,0);
lpAngle = szAngle;
lpRuling = szRuling;
Negative = Page.Negative;
Asciize = !Page.BinaryPS;
PS_ID( IDS_PS_DICTDEF );
/* Send the definition of the read data function */
if ( Asciize )
{
PS_ID( IDS_PS_HEXDATA );
}
else
{
PS_ID( IDS_PS_BINDATA );
}
if ( !Halftone.DoHalftoning )
goto HalftoningDone;
/* Send the definition of the spot function */
if ( Halftone.DotShape == IDC_ELLIPSEDOT )
{
PS_ID( IDS_PS_ELLDOT1 );
PS_ID( IDS_PS_ELLDOT2 );
}
else
if ( Halftone.DotShape == IDC_SQUAREDOT )
{
PS_ID( IDS_PS_SQUDOT );
}
else
if ( Halftone.DotShape == IDC_CIRCLEDOT )
{
PS_ID( IDS_PS_CIRDOT );
}
else
if ( Halftone.DotShape == IDC_TRIANGLEDOT )
{
PS_ID( IDS_PS_TRIDOT );
}
else
if ( Halftone.DotShape == IDC_PROPELLERDOT )
{
PS_ID( IDS_PS_PROPDOT );
}
if ( Page.OutputType == IDC_PRINT_BLACKSEPS ||
Page.OutputType == IDC_PRINT_GRAY )
{ // Setup the "image" screen angles and freqs based on the sep
if ( cSep == 'C' )
{
FixedAscii( C_ANGLE, lpAngle, -2 );
FixedAscii( C_RULING, lpRuling, -2 );
}
else
if ( cSep == 'M' )
{
FixedAscii( M_ANGLE, lpAngle, -2 );
FixedAscii( M_RULING, lpRuling, -2 );
}
else
if ( cSep == 'Y' )
{
FixedAscii( Y_ANGLE, lpAngle, -2 );
FixedAscii( Y_RULING, lpRuling, -2 );
}
else
//if ( cSep == 'K' || cSep == 'X' || !cSep )
{
FixedAscii( K_ANGLE, lpAngle, -2 );
FixedAscii( K_RULING, lpRuling, -2 );
}
PS_ID2( IDS_PS_SETSCREEN, lpRuling, lpAngle );
}
else
{ // Setup the "colorimage" screen angles and frequencies
PS_ID( IDS_PS_COLOREXT );
PS_ID( IDS_PS_STARTBLOCK );
FixedAscii( C_RULING, lpRuling, -2 );
FixedAscii( C_ANGLE, lpAngle, -2 );
PS_ID2( IDS_PS_SETSPOT, lpRuling, lpAngle );
FixedAscii( M_RULING, lpRuling, -2 );
FixedAscii( M_ANGLE, lpAngle, -2 );
PS_ID2( IDS_PS_SETSPOT, lpRuling, lpAngle );
FixedAscii( Y_RULING, lpRuling, -2 );
FixedAscii( Y_ANGLE, lpAngle, -2 );
PS_ID2( IDS_PS_SETSPOT, lpRuling, lpAngle );
FixedAscii( K_RULING, lpRuling, -2 );
FixedAscii( K_ANGLE, lpAngle, -2 );
PS_ID2( IDS_PS_SETSPOT, lpRuling, lpAngle );
PS_ID( IDS_PS_SETCOLORSCREEN );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
FixedAscii( K_RULING, lpRuling, -2 );
FixedAscii( K_ANGLE, lpAngle, -2 );
PS_ID2( IDS_PS_SETSCREEN, lpRuling, lpAngle );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IFELSE );
}
HalftoningDone:
// Setup a null transfer curve unless doing seps w/black ink (image operator)
if ( Page.OutputType == IDC_PRINT_BLACKSEPS )
{
PS_ID( IDS_PS_BLACKSEPS );
}
else
if ( Page.OutputType == IDC_PRINT_COLORSEPS )
{
PS_ID( IDS_PS_COLORSEPS );
}
else
{
PS_ID( IDS_PS_NOINVERT );
}
PS_ID( IDS_PS_CHECKINVERT );
/* Send the destination point (x,y) in spots */
PS_ID2( IDS_PS_TRANSLATE, xDest, yDest );
/* Send the destination size (w,h) in spots */
PS_ID2( IDS_PS_SCALE, dxDest, dyDest );
if (lpImage)
lpBaseFrame = ImgGetBaseEditFrame(lpImage);
else
lpBaseFrame = lpFrame;
/* Compute how many pixels we're going to send */
/* Never send more than 16 pixels per halftone grid (or 4/grid in x and y) */
if (depth = FrameDepth( lpBaseFrame ))
{
if ( iPrResX < 600 )
dxDest /= 4;
else dxDest /= 8;
if ( iPrResY < 600 )
dyDest /= 4;
else dyDest /= 8;
}
if (depth == 0) depth = 1;
/* Let the printer do any upsizing */
if ( dySrc < dyDest )
{
yrate = UNITY;
dxDest = dxSrc;
dyDest = dySrc;
}
else yrate = FGET( dySrc, dyDest );
/* Send the definition for the line buffers */
PS_ID1( IDS_PS_LINE1, dxDest );
PS_ID1( IDS_PS_LINE2, dxDest );
PS_ID1( IDS_PS_LINE3, dxDest );
PS_ID1( IDS_PS_LINE4, dxDest );
PS_ID1( IDS_PS_LINE5, dxDest );
if ( cSep ) // Plane at a time
{ // cSep is either 'C', 'M', 'Y', 'K', 'X'(gray) or NULL
if ( Page.OutputType == IDC_PRINT_COLORSEPS )
{
PS_ID( IDS_PS_DOCOLORSEPDEF );
}
else
{
PS_ID( IDS_PS_NOCOLORSEPDEF );
}
PS_ID( IDS_PS_DOIMAGEDEF );
PS_ID( IDS_PS_COLORSEPVAL );
// Start color image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
if ( cSep == 'C' )
{
PS_ID( IDS_PS_SEPCYAN );
}
else
if ( cSep == 'M' )
{
PS_ID( IDS_PS_SEPMAGENTA );
}
else
if ( cSep == 'Y' )
{
PS_ID( IDS_PS_SEPYELLOW );
}
else
if ( cSep == 'K' || cSep == 'X' )
{
PS_ID( IDS_PS_SEPBLACK );
}
PS_ID( IDS_PS_COLORIMAGE4 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
// Start gray image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE1 );
PS_ID( IDS_PS_IMAGE );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IFELSE );
PS_ID( IDS_PS_DEF );
}
else
if ( Page.Type == IDC_PRINTER_IS_CMYK )
{
if (Page.OutputType == IDC_PRINT_COLORGRAY)
{
PS_ID( IDS_PS_DOIMAGEDEF );
PS_ID( IDS_PS_COLOREXT );
// Start color image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE1 );
PS_ID( IDS_PS_GETLINE2 );
PS_ID( IDS_PS_GETLINE3 );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE4 );
PS_ID( IDS_PS_GETLINE5 );
PS_ID( IDS_PS_POP );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_COLORIMAGE4 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
// Start gray image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_DUMPLINE1 );
PS_ID( IDS_PS_DUMPLINE2 );
PS_ID( IDS_PS_DUMPLINE3 );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE4 );
PS_ID( IDS_PS_GETLINE5 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IMAGE );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IFELSE );
PS_ID( IDS_PS_DEF );
}
else
{
PS_ID( IDS_PS_DOIMAGEDEF );
PS_ID( IDS_PS_COLOREXT );
// Start color image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE1 );
PS_ID( IDS_PS_GETLINE2 );
PS_ID( IDS_PS_GETLINE3 );
PS_ID( IDS_PS_GETLINE4 );
PS_ID( IDS_PS_COLORIMAGE4 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
// Start gray image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_DUMPLINE1 );
PS_ID( IDS_PS_DUMPLINE2 );
PS_ID( IDS_PS_DUMPLINE3 );
PS_ID( IDS_PS_GETLINE4 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_NOIMAGE );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IFELSE );
PS_ID( IDS_PS_DEF );
}
}
else
if ( Page.Type == IDC_PRINTER_IS_RGB )
{
PS_ID( IDS_PS_DOIMAGEDEF );
PS_ID( IDS_PS_COLOREXT );
// Start color image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_GETLINE1 );
PS_ID( IDS_PS_GETLINE2 );
PS_ID( IDS_PS_GETLINE3 );
if ( Page.OutputType == IDC_PRINT_COLORGRAY )
{
PS_ID( IDS_PS_DUMPLINE4 );
}
PS_ID( IDS_PS_COLORIMAGE3 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
// Start gray image proc
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_STARTBLOCK );
PS_ID( IDS_PS_DUMPLINE1 );
PS_ID( IDS_PS_DUMPLINE2 );
if ( Page.OutputType == IDC_PRINT_COLORGRAY )
{
PS_ID( IDS_PS_DUMPLINE3 );
PS_ID( IDS_PS_GETLINE4 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IMAGE );
}
else
{
PS_ID( IDS_PS_GETLINE3 );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_NOIMAGE );
}
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_ENDBLOCK );
PS_ID( IDS_PS_IFELSE );
PS_ID( IDS_PS_DEF );
}
/* Send the inline image's size, packing, and transform */
PS_ID5( IDS_PS_TRANSFORM, dxDest, dyDest, 8, dxDest, dyDest );
if ( !Asciize )
{
// The size must include the doimage command that follows
lSize = (long)dxDest * dyDest * depth;
PS_ID1( IDS_PS_BEGINBINARY, lSize + 9 + 2 );
}
PS_ID( IDS_PS_DOIMAGE ); // Should be 9 characters
for ( x=0; x<5; x++ )
lpBuffer[x] = NULL;
if (!AllocLines((LPPTR)&lpImageData, 1, dxSrc, depth))
{
ProgressEnd();
return(FALSE);
}
if (!AllocLines((LPPTR)&lpBuffer[0], 1, dxDest, depth))
{
FreeUp( lpImageData );
ProgressEnd();
return( FALSE );
}
if (!AllocLines((LPPTR)&lpBuffer[1], 4, dxDest, 1))
{
FreeUp(lpBuffer[0]);
FreeUp( lpImageData );
ProgressEnd();
return( FALSE );
}
p1Buf = lpBuffer[1];
p2Buf = lpBuffer[2];
p3Buf = lpBuffer[3];
p4Buf = lpBuffer[4];
ystart = ySrc;
yline = -1;
yoffset = (long)yrate>>1;
for (y=0; y<dyDest; y++)
{
if (AstralClockCursor( y, dyDest, YES ))
{
fAbortPrint = YES;
break;
}
/* Check for user input to abort dialog box */
(*lpAbortTest)(hPrinterDC, 0);
if ( fAbortPrint )
break;
ylast = yline;
#ifdef WIN32
yline = ystart + WHOLE( yoffset );
#else
yline = ystart + HIWORD( yoffset );
#endif
yoffset += yrate;
if ( yline != ylast )
{
LFIXED rate;
if (lpImage)
ImgGetLine( lpImage, NULL, xSrc, yline, dxSrc, lpImageData );
else
copy(FramePointer(lpBaseFrame, xSrc, yline, NO), lpImageData, dxSrc*depth);
rate = FGET( dxSrc, dxDest );
FrameSample(
lpBaseFrame,
lpImageData,
0,
lpBuffer[0],
0,
dxDest,
rate);
}
if ( cSep )
{ // cSep is either 'C', 'M', 'Y', 'K', 'X'(gray) or NULL
if (cSep != 'X')
{
LPTR lpOutBuf;
int iPlaneOffset;
switch(cSep)
{
case 'C' : lpOutBuf = p1Buf; iPlaneOffset = 0; break;
case 'M' : lpOutBuf = p2Buf; iPlaneOffset = 1; break;
case 'Y' : lpOutBuf = p3Buf; iPlaneOffset = 2; break;
case 'K' : lpOutBuf = p4Buf; iPlaneOffset = 3; break;
}
switch(depth)
{
case 0 :
case 1 :
lpOutBuf = (LPTR)lpBuffer[0];
break;
case 3 :
ClrRGBtoCMYK( (LPRGB)lpBuffer[0],
p1Buf, p2Buf, p3Buf,p4Buf,dxDest,YES);
break;
case 4 :
{
LPTR lpSrc = (LPTR)lpBuffer[0];
LPTR lpDst = lpOutBuf;
int iCount = dxDest;
lpSrc += iPlaneOffset;
while(iCount-- > 0)
{
*lpDst++ = *lpSrc;
lpSrc += 4;
}
}
break;
}
if (Negative)
negate(lpOutBuf, (long)dxDest);
if ( !SendPSData( Asciize, lpOutBuf, dxDest ) )
goto ErrorExit;
}
else
{
ConvertData( lpBuffer[0], depth, dxDest, p1Buf, 1 );
if (Negative)
negate(p1Buf, (long)dxDest);
CorrectGray( p1Buf, dxDest, YES, YES );
if ( !SendPSData( Asciize, p1Buf, dxDest ) )
goto ErrorExit;
}
}
else if ( Page.Type == IDC_PRINTER_IS_CMYK )
{
switch(depth)
{
case 0 :
case 1 :
copy( lpBuffer[0], p1Buf, dxDest );
copy( lpBuffer[0], p2Buf, dxDest );
copy( lpBuffer[0], p3Buf, dxDest );
copy( lpBuffer[0], p4Buf, dxDest );
break;
case 3 :
ClrRGBtoCMYK( (LPRGB)lpBuffer[0],
p1Buf, p2Buf, p3Buf,p4Buf,dxDest,YES);
break;
case 4 :
{
LPTR lpSrc = (LPTR)lpBuffer[0];
LPTR lpDst1 = p1Buf;
LPTR lpDst2 = p2Buf;
LPTR lpDst3 = p3Buf;
LPTR lpDst4 = p4Buf;
int iCount = dxDest;
while(iCount-- > 0)
{
*lpDst1++ = *lpSrc++;
*lpDst2++ = *lpSrc++;
*lpDst3++ = *lpSrc++;
*lpDst4++ = *lpSrc++;
}
}
break;
}
if (Negative)
{
negate(p1Buf, (long)dxDest);
negate(p2Buf, (long)dxDest);
negate(p3Buf, (long)dxDest);
negate(p4Buf, (long)dxDest);
}
if ( !SendPSData( Asciize, p1Buf, dxDest ) )
goto ErrorExit;
if ( !SendPSData( Asciize, p2Buf, dxDest ) )
goto ErrorExit;
if ( !SendPSData( Asciize, p3Buf, dxDest ) )
goto ErrorExit;
if ( !SendPSData( Asciize, p4Buf, dxDest ) )
goto ErrorExit;
if ( Page.OutputType == IDC_PRINT_COLORGRAY )
{
ConvertData( lpBuffer[0], depth, dxDest, p1Buf, 1 );
if (Negative)
negate(p1Buf, (long)dxDest);
CorrectGray( p1Buf, dxDest, YES, YES);
if ( !SendPSData( Asciize, p1Buf, dxDest ) )
goto ErrorExit;
}
}
else if ( Page.Type == IDC_PRINTER_IS_RGB )
{
switch(depth)
{
case 0 :
case 1 :
copy( lpBuffer[0], p1Buf, dxDest );
copy( lpBuffer[0], p2Buf, dxDest );
copy( lpBuffer[0], p3Buf, dxDest );
break;
case 3 :
UnshuffleRGB( (LPRGB)lpBuffer[0],
p1Buf, p2Buf, p3Buf, dxDest );
break;
case 4 :
{
LPCMYK lpCMYK = (LPCMYK)lpBuffer[0];
LPTR lpDst1 = p1Buf;
LPTR lpDst2 = p2Buf;
LPTR lpDst3 = p3Buf;
RGBS rgb;
int iCount = dxDest;
while(iCount-- > 0)
{
CMYKtoRGB(lpCMYK->c, lpCMYK->m, lpCMYK->y, lpCMYK->k, &rgb);
lpCMYK++;
*lpDst1++ = rgb.red;
*lpDst2++ = rgb.green;
*lpDst3++ = rgb.blue;
}
}
break;
}
if (Negative)
{
negate( p1Buf, dxDest );
negate( p2Buf, dxDest );
negate( p3Buf, dxDest );
}
if ( !SendPSData( Asciize, p1Buf, dxDest ) )
goto ErrorExit;
if ( !SendPSData( Asciize, p2Buf, dxDest ) )
goto ErrorExit;
if ( !SendPSData( Asciize, p3Buf, dxDest ) )
goto ErrorExit;
if ( Page.OutputType == IDC_PRINT_COLORGRAY )
{
ConvertData( (LPTR)lpBuffer[0], depth, dxDest, p1Buf, 1 );
if (Negative)
negate(p1Buf, (long)dxDest);
CorrectGray( p1Buf, dxDest, YES, YES);
if ( !SendPSData( Asciize, p1Buf, dxDest ) )
goto ErrorExit;
}
}
}
if ( !Asciize )
{
PS_ID( IDS_PS_ENDBINARY );
}
/* Send the save restore command */
PS_ID( IDS_PS_MYSAVERESTORE );
PS_ID( IDS_PS_END );
ErrorExit:
if ( lpBuffer[0] )
FreeUp(lpBuffer[0]);
if ( lpBuffer[1] )
FreeUp(lpBuffer[1]);
if ( lpImageData )
FreeUp( lpImageData );
ProgressEnd();
return( TRUE );
}
void InputWin32::ProcessWindowsEvent(UINT message, WPARAM w_param, LPARAM l_param)
{
if (context == NULL)
return;
// Process all mouse and keyboard events
switch (message)
{
case WM_LBUTTONDOWN:
context->ProcessMouseButtonDown(0, GetKeyModifierState());
break;
case WM_LBUTTONUP:
context->ProcessMouseButtonUp(0, GetKeyModifierState());
break;
case WM_RBUTTONDOWN:
context->ProcessMouseButtonDown(1, GetKeyModifierState());
break;
case WM_RBUTTONUP:
context->ProcessMouseButtonUp(1, GetKeyModifierState());
break;
case WM_MBUTTONDOWN:
context->ProcessMouseButtonDown(2, GetKeyModifierState());
break;
case WM_MBUTTONUP:
context->ProcessMouseButtonUp(2, GetKeyModifierState());
break;
case WM_MOUSEMOVE:
context->ProcessMouseMove(LOWORD(l_param), HIWORD(l_param), GetKeyModifierState());
break;
case WM_MOUSEWHEEL:
context->ProcessMouseWheel(((short) HIWORD(w_param)) / -WHEEL_DELTA, GetKeyModifierState());
break;
case WM_KEYDOWN:
{
Rocket::Core::Input::KeyIdentifier key_identifier = key_identifier_map[w_param];
int key_modifier_state = GetKeyModifierState();
// Check for a shift-~ to toggle the debugger.
if (key_identifier == Rocket::Core::Input::KI_OEM_3 &&
key_modifier_state & Rocket::Core::Input::KM_SHIFT)
{
Rocket::Debugger::SetVisible(!Rocket::Debugger::IsVisible());
break;
}
context->ProcessKeyDown(key_identifier, key_modifier_state);
}
break;
case WM_CHAR:
{
// Only send through printable characters.
if (w_param >= 32)
context->ProcessTextInput((Rocket::Core::word) w_param);
// Or endlines - Windows sends them through as carriage returns.
else if (w_param == '\r')
context->ProcessTextInput((Rocket::Core::word) '\n');
}
break;
case WM_KEYUP:
context->ProcessKeyUp(key_identifier_map[w_param], GetKeyModifierState());
break;
}
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_ACTIVATE:
if (globalGame != nullptr)
{
if (LOWORD(wParam) == WA_INACTIVE)
{
if (globalIsActive == true)
{
globalPreviousFullscreenState = Prism::Engine::GetInstance()->IsFullscreen();
globalIsActive = false;
globalGame->Pause();
}
}
else
{
if (globalIsActive == false)
{
bool currFullscreen = Prism::Engine::GetInstance()->IsFullscreen();
if (currFullscreen != globalPreviousFullscreenState)
{
Prism::Engine::GetInstance()->SetFullscreen(globalPreviousFullscreenState);
}
#ifdef RELEASE_BUILD
Prism::Engine::GetInstance()->SetFullscreen(true);
#endif
globalIsActive = true;
globalGame->UnPause();
}
}
}
break;
case WM_SIZE:
{
globalClientWidth = LOWORD(lParam);
globalClientHeight = HIWORD(lParam);
if (globalClientWidth >= globalSetup.myScreenWidth) globalClientWidth = globalSetup.myScreenWidth;
if (globalClientHeight >= globalSetup.myScreenHeight) globalClientHeight = globalSetup.myScreenHeight;
if (LOWORD(wParam) == SIZE_MINIMIZED)
{
if (globalGame != nullptr)
{
globalGame->Pause();
}
}
else if (LOWORD(wParam) == SIZE_MAXIMIZED)
{
OnResize();
}
else if (LOWORD(wParam) == SIZE_RESTORED)
{
if (globalIsResizing == false)
{
OnResize();
}
}
break;
}
case WM_ENTERSIZEMOVE:
if (globalGame != nullptr)
{
globalGame->Pause();
globalIsResizing = true;
}
break;
case WM_EXITSIZEMOVE:
if (globalGame != nullptr)
{
globalIsResizing = false;
OnResize();
}
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
