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;
}
long WMSize (HWND hwnd, WPARAM wParam, LPARAM lParam){
MoveWindow (hwndEdit, 0, 0, LOWORD (lParam), HIWORD (lParam), TRUE);
return 0;
}
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
int
ACE_OS::uname (ACE_utsname *name)
{
ACE_OS_TRACE ("ACE_OS::uname");
#if !defined (ACE_LACKS_UNAME)
ACE_OSCALL_RETURN (::uname (name), int, -1);
#elif defined (ACE_WIN32)
size_t maxnamelen = sizeof name->nodename;
ACE_OS::strcpy (name->sysname, "Win32");
ACE_TEXT_OSVERSIONINFO vinfo;
vinfo.dwOSVersionInfoSize = sizeof(ACE_TEXT_OSVERSIONINFO);
ACE_TEXT_GetVersionEx (&vinfo);
SYSTEM_INFO sinfo;
# if defined (ACE_HAS_PHARLAP)
// PharLap doesn't do GetSystemInfo. What's really wanted is the
// CPU architecture, so we can get that with EtsGetSystemInfo. Fill
// in what's wanted in the SYSTEM_INFO structure, and carry on. Note
// that the CPU type values in EK_KERNELINFO have the same values
// are the ones defined for SYSTEM_INFO.
EK_KERNELINFO ets_kern;
EK_SYSTEMINFO ets_sys;
EtsGetSystemInfo (&ets_kern, &ets_sys);
sinfo.wProcessorLevel = static_cast<WORD> (ets_kern.CpuType);
sinfo.wProcessorArchitecture = PROCESSOR_ARCHITECTURE_INTEL;
sinfo.dwProcessorType = ets_kern.CpuType * 100 + 86;
# else
::GetSystemInfo(&sinfo);
# endif /* ACE_HAS_PHARLAP */
const char* unknown = "???";
if (
vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT
# if defined (VER_PLATFORM_WIN32_CE)
|| vinfo.dwPlatformId == VER_PLATFORM_WIN32_CE
# endif
)
{
// Get information from the two structures
const char *os;
if (vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
os = "Windows NT %d.%d";
else
os = "Windows CE %d.%d";
ACE_OS::sprintf (name->release,
os,
(int) vinfo.dwMajorVersion,
(int) vinfo.dwMinorVersion);
ACE_OS::sprintf (name->version,
"Build %d %s",
(int) vinfo.dwBuildNumber,
ACE_TEXT_ALWAYS_CHAR (vinfo.szCSDVersion));
// We have to make sure that the size of (processor + subtype)
// is not greater than the size of name->machine. So we give
// half the space to the processor and half the space to
// subtype. The -1 is necessary for because of the space
// between processor and subtype in the machine name.
const int bufsize = (sizeof (name->machine) / 2) - 1;
char processor[bufsize] = "Unknown";
char subtype[bufsize] = "Unknown";
# if defined (ghs)
WORD arch = sinfo.u.s.wProcessorArchitecture;
# else
WORD arch = sinfo.wProcessorArchitecture;
# endif
switch (arch)
{
case PROCESSOR_ARCHITECTURE_INTEL:
ACE_OS::strcpy (processor, "Intel");
if (sinfo.wProcessorLevel == 3)
ACE_OS::strcpy (subtype, "80386");
else if (sinfo.wProcessorLevel == 4)
ACE_OS::strcpy (subtype, "80486");
else if (sinfo.wProcessorLevel == 5)
ACE_OS::strcpy (subtype, "Pentium");
else if (sinfo.wProcessorLevel == 6)
ACE_OS::strcpy (subtype, "Pentium Pro");
else if (sinfo.wProcessorLevel == 7) // I'm guessing here
ACE_OS::strcpy (subtype, "Pentium II");
break;
case PROCESSOR_ARCHITECTURE_MIPS:
ACE_OS::strcpy (processor, "MIPS");
ACE_OS::strcpy (subtype, "R4000");
break;
case PROCESSOR_ARCHITECTURE_ALPHA:
ACE_OS::strcpy (processor, "Alpha");
ACE_OS::sprintf (subtype, "%d", sinfo.wProcessorLevel);
break;
case PROCESSOR_ARCHITECTURE_PPC:
ACE_OS::strcpy (processor, "PPC");
if (sinfo.wProcessorLevel == 1)
ACE_OS::strcpy (subtype, "601");
else if (sinfo.wProcessorLevel == 3)
ACE_OS::strcpy (subtype, "603");
else if (sinfo.wProcessorLevel == 4)
ACE_OS::strcpy (subtype, "604");
else if (sinfo.wProcessorLevel == 6)
ACE_OS::strcpy (subtype, "603+");
else if (sinfo.wProcessorLevel == 9)
ACE_OS::strcpy (subtype, "804+");
else if (sinfo.wProcessorLevel == 20)
ACE_OS::strcpy (subtype, "620");
break;
# if defined PROCESSOR_ARCHITECTURE_IA64
case PROCESSOR_ARCHITECTURE_IA64:
ACE_OS::strcpy (processor, "Itanium");
ACE_OS::sprintf (subtype, "%d",
sinfo.wProcessorLevel);
break;
# endif
# if defined PROCESSOR_ARCHITECTURE_AMD64
case PROCESSOR_ARCHITECTURE_AMD64:
ACE_OS::strcpy (processor, "x64");
ACE_OS::sprintf (subtype, "%d",
sinfo.wProcessorLevel);
break;
# endif
# if defined PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
ACE_OS::strcpy (processor, "WOW64");
ACE_OS::sprintf (subtype, "%d",
sinfo.wProcessorLevel);
break;
# endif
# if defined PROCESSOR_ARCHITECTURE_ARM
case PROCESSOR_ARCHITECTURE_ARM:
ACE_OS::strcpy (processor, "ARM");
ACE_OS::sprintf (subtype, "%d",
sinfo.wProcessorLevel);
break;
# endif
case PROCESSOR_ARCHITECTURE_UNKNOWN:
default:
// @@ We could provide WinCE specific info here. But let's
// defer that to some later point.
ACE_OS::strcpy (processor, "Unknown");
break;
}
ACE_OS::sprintf (name->machine,
"%s %s",
processor, subtype);
}
else if (vinfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
{
if (vinfo.dwMajorVersion == 4 && vinfo.dwMinorVersion == 0)
{
ACE_OS::strcpy (name->release, "Windows 95");
if (vinfo.szCSDVersion[1] == ACE_TEXT('C'))
ACE_OS::strcat (name->release, " OSR2");
}
else if (vinfo.dwMajorVersion == 4 && vinfo.dwMinorVersion == 10)
{
ACE_OS::strcpy (name->release, "Windows 98");
if (vinfo.szCSDVersion[1] == ACE_TEXT('A'))
ACE_OS::strcat (name->release, " SE");
}
else if (vinfo.dwMajorVersion == 4 && vinfo.dwMinorVersion == 90)
{
ACE_OS::strcpy (name->release, "Windows Me");
}
else
{
ACE_OS::strcpy (name->release, unknown);
}
ACE_OS::sprintf (name->version, "%d", LOWORD (vinfo.dwBuildNumber));
if (sinfo.dwProcessorType == PROCESSOR_INTEL_386)
ACE_OS::strcpy (name->machine, "Intel 80386");
else if (sinfo.dwProcessorType == PROCESSOR_INTEL_486)
ACE_OS::strcpy (name->machine, "Intel 80486");
else if (sinfo.dwProcessorType == PROCESSOR_INTEL_PENTIUM)
ACE_OS::strcpy (name->machine, "Intel Pentium");
else
ACE_OS::strcpy (name->machine, unknown);
}
else
{
// We don't know what this is!
ACE_OS::strcpy (name->release, unknown);
ACE_OS::strcpy (name->version, unknown);
ACE_OS::strcpy (name->machine, unknown);
}
# if defined (ACE_LACKS_HOSTNAME)
return 0;
# else /* ACE_LACKS_HOSTNAME */
return ACE_OS::hostname (name->nodename, maxnamelen);
# endif /* ACE_LACKS_HOSTNAME */
#elif defined (ACE_VXWORKS)
size_t maxnamelen = sizeof name->nodename;
ACE_OS::strcpy (name->sysname, "VxWorks");
ACE_OS::strcpy (name->release, kernelVersion());
ACE_OS::strcpy (name->version, sysBspRev ());
ACE_OS::strcpy (name->machine, sysModel ());
return ACE_OS::hostname (name->nodename, maxnamelen);
#elif defined (INTEGRITY)
if (!name) {
errno = EFAULT;
return -1;
}
strcpy(name->sysname,"INTEGRITY");
int status = gethostname(name->nodename,_SYS_NMLN);
strcpy(name->release,"4.0");
strcpy(name->version,"4.0.9");
strcpy(name->machine,"a standard name");
return status;
#endif /* ACE_WIN32 */
}
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;
}
BOOL CALLBACK VNCOptions::OptDlgProc( HWND hwnd, UINT uMsg,
WPARAM wParam, LPARAM lParam ) {
// This is a static method, so we don't know which instantiation we're
// dealing with. But we can get a pseudo-this from the parameter to
// WM_INITDIALOG, which we therafter store with the window and retrieve
// as follows:
VNCOptions *_this = (VNCOptions *) GetWindowLong(hwnd, GWL_USERDATA);
switch (uMsg) {
case WM_INITDIALOG:
{
SetWindowLong(hwnd, GWL_USERDATA, lParam);
_this = (VNCOptions *) lParam;
// Initialise the controls
HWND had = GetDlgItem(hwnd, IDC_AUTODETECT);
SendMessage(had, BM_SETCHECK, _this->autoDetect, 0);
for (int i = rfbEncodingRaw; i <= LASTENCODING; i++) {
HWND hPref = GetDlgItem(hwnd, IDC_RAWRADIO + (i-rfbEncodingRaw));
SendMessage(hPref, BM_SETCHECK,
(i== _this->m_PreferredEncoding), 0);
EnableWindow(hPref, _this->m_UseEnc[i] && !_this->autoDetect);
}
HWND hCopyRect = GetDlgItem(hwnd, ID_SESSION_SET_CRECT);
SendMessage(hCopyRect, BM_SETCHECK, _this->m_UseEnc[rfbEncodingCopyRect], 0);
EnableWindow(hCopyRect, !_this->autoDetect);
HWND hSwap = GetDlgItem(hwnd, ID_SESSION_SWAPMOUSE);
SendMessage(hSwap, BM_SETCHECK, _this->m_SwapMouse, 0);
HWND hDeiconify = GetDlgItem(hwnd, IDC_BELLDEICONIFY);
SendMessage(hDeiconify, BM_SETCHECK, _this->m_DeiconifyOnBell, 0);
#ifndef UNDER_CE
HWND hDisableClip = GetDlgItem(hwnd, IDC_DISABLECLIPBOARD);
SendMessage(hDisableClip, BM_SETCHECK, _this->m_DisableClipboard, 0);
#endif
HWND h8bit = GetDlgItem(hwnd, IDC_8BITCHECK);
SendMessage(h8bit, BM_SETCHECK, _this->m_Use8Bit, 0);
EnableWindow(h8bit, !_this->autoDetect);
HWND hShared = GetDlgItem(hwnd, IDC_SHARED);
SendMessage(hShared, BM_SETCHECK, _this->m_Shared, 0);
EnableWindow(hShared, !_this->m_running);
HWND hViewOnly = GetDlgItem(hwnd, IDC_VIEWONLY);
SendMessage(hViewOnly, BM_SETCHECK, _this->m_ViewOnly, 0);
HWND hScaling = GetDlgItem(hwnd, IDC_SCALING);
SendMessage(hScaling, BM_SETCHECK, _this->m_scaling, 0);
SetDlgItemInt( hwnd, IDC_SCALE_NUM, _this->m_scale_num, FALSE);
SetDlgItemInt( hwnd, IDC_SCALE_DEN, _this->m_scale_den, FALSE);
#ifndef UNDER_CE
HWND hFullScreen = GetDlgItem(hwnd, IDC_FULLSCREEN);
SendMessage(hFullScreen, BM_SETCHECK, _this->m_FullScreen, 0);
HWND hEmulate = GetDlgItem(hwnd, IDC_EMULATECHECK);
SendMessage(hEmulate, BM_SETCHECK, _this->m_Emul3Buttons, 0);
#endif
CentreWindow(hwnd);
return TRUE;
}
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
{
HWND had = GetDlgItem(hwnd, IDC_AUTODETECT);
_this->autoDetect =
(SendMessage(had, BM_GETCHECK, 0, 0) == BST_CHECKED);
for (int i = rfbEncodingRaw; i <= LASTENCODING; i++) {
HWND hPref = GetDlgItem(hwnd, IDC_RAWRADIO+i-rfbEncodingRaw);
if (SendMessage(hPref, BM_GETCHECK, 0, 0) == BST_CHECKED)
_this->m_PreferredEncoding = i;
}
HWND hCopyRect = GetDlgItem(hwnd, ID_SESSION_SET_CRECT);
_this->m_UseEnc[rfbEncodingCopyRect] =
(SendMessage(hCopyRect, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hSwap = GetDlgItem(hwnd, ID_SESSION_SWAPMOUSE);
_this->m_SwapMouse =
(SendMessage(hSwap, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hDeiconify = GetDlgItem(hwnd, IDC_BELLDEICONIFY);
_this->m_DeiconifyOnBell =
(SendMessage(hDeiconify, BM_GETCHECK, 0, 0) == BST_CHECKED);
#ifndef UNDER_CE
HWND hDisableClip = GetDlgItem(hwnd, IDC_DISABLECLIPBOARD);
_this->m_DisableClipboard =
(SendMessage(hDisableClip, BM_GETCHECK, 0, 0) == BST_CHECKED);
#endif
HWND h8bit = GetDlgItem(hwnd, IDC_8BITCHECK);
_this->m_Use8Bit =
(SendMessage(h8bit, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hShared = GetDlgItem(hwnd, IDC_SHARED);
_this->m_Shared =
(SendMessage(hShared, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hViewOnly = GetDlgItem(hwnd, IDC_VIEWONLY);
_this->m_ViewOnly =
(SendMessage(hViewOnly, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hScaling = GetDlgItem(hwnd, IDC_SCALING);
_this->m_scaling =
(SendMessage(hScaling, BM_GETCHECK, 0, 0) == BST_CHECKED);
if (_this->m_scaling) {
_this->m_scale_num = GetDlgItemInt( hwnd, IDC_SCALE_NUM, NULL, TRUE);
_this->m_scale_den = GetDlgItemInt( hwnd, IDC_SCALE_DEN, NULL, TRUE);
_this->FixScaling();
if (_this->m_scale_num == 1 && _this->m_scale_den == 1)
_this->m_scaling = false;
} else {
_this->m_scale_num = 1;
_this->m_scale_den = 1;
}
#ifndef UNDER_CE
HWND hFullScreen = GetDlgItem(hwnd, IDC_FULLSCREEN);
_this->m_FullScreen =
(SendMessage(hFullScreen, BM_GETCHECK, 0, 0) == BST_CHECKED);
HWND hEmulate = GetDlgItem(hwnd, IDC_EMULATECHECK);
_this->m_Emul3Buttons =
(SendMessage(hEmulate, BM_GETCHECK, 0, 0) == BST_CHECKED);
#endif
EndDialog(hwnd, TRUE);
return TRUE;
}
case IDCANCEL:
EndDialog(hwnd, FALSE);
return TRUE;
case IDC_AUTODETECT:
bool ad = IsDlgButtonChecked(hwnd, IDC_AUTODETECT);
for (int i = rfbEncodingRaw; i <= LASTENCODING; i++) {
HWND hPref = GetDlgItem(hwnd, IDC_RAWRADIO + (i-rfbEncodingRaw));
EnableWindow(hPref, _this->m_UseEnc[i] && !ad);
}
HWND hCopyRect = GetDlgItem(hwnd, ID_SESSION_SET_CRECT);
EnableWindow(hCopyRect, !ad);
HWND h8bit = GetDlgItem(hwnd, IDC_8BITCHECK);
EnableWindow(h8bit, !ad);
return TRUE;
}
break;
case WM_DESTROY:
EndDialog(hwnd, FALSE);
return TRUE;
}
return 0;
}
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;
}
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;
}
//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;
}
static DWORD modData(MIDIMAPDATA* mom, DWORD_PTR dwParam)
{
BYTE lb = LOBYTE(LOWORD(dwParam));
WORD chn = lb & 0x0F;
DWORD ret = MMSYSERR_NOERROR;
if (MIDIMAP_IsBadData(mom))
return MMSYSERR_ERROR;
if (!mom->ChannelMap[chn]) return MMSYSERR_NOERROR;
switch (lb & 0xF0)
{
case 0x80:
case 0x90:
case 0xA0:
case 0xB0:
case 0xC0:
case 0xD0:
case 0xE0:
if (mom->ChannelMap[chn]->loaded == 0)
{
if (midiOutOpen(&mom->ChannelMap[chn]->hMidi, mom->ChannelMap[chn]->uDevID,
0L, 0L, CALLBACK_NULL) == MMSYSERR_NOERROR)
mom->ChannelMap[chn]->loaded = 1;
else
mom->ChannelMap[chn]->loaded = -1;
/* FIXME: should load here the IDF midi data... and allow channel and
* patch mappings
*/
}
if (mom->ChannelMap[chn]->loaded > 0)
{
/* change channel */
dwParam &= ~0x0F;
dwParam |= mom->ChannelMap[chn]->aChn[chn];
if ((LOBYTE(LOWORD(dwParam)) & 0xF0) == 0xC0 /* program change */ &&
mom->ChannelMap[chn]->lpbPatch)
{
BYTE patch = HIBYTE(LOWORD(dwParam));
/* change patch */
dwParam &= ~0x0000FF00;
dwParam |= mom->ChannelMap[chn]->lpbPatch[patch];
}
ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
}
break;
case 0xF0:
for (chn = 0; chn < 16; chn++)
{
if (mom->ChannelMap[chn]->loaded > 0)
ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
}
break;
default:
FIXME("ooch %lx\n", dwParam);
}
return ret;
}
////////////////////////////////////////////////////////////////////////////////
// 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: Account manager options dialog
INT_PTR CALLBACK gg_acc_mgr_guidlgproc(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));
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);
}
break;
}
case WM_COMMAND:
{
switch (LOWORD(wParam)) {
case IDC_CREATEACCOUNT:
{
// 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;
dat.mode = GG_USERUTIL_CREATE;
ret = DialogBoxParam(hInstance, MAKEINTRESOURCE(IDD_CREATEACCOUNT), 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, "");
}
}
}
break;
}
case WM_NOTIFY:
{
switch(((LPNMHDR)lParam)->idFrom)
{
case 0:
switch (((LPNMHDR) lParam)->code) {
case PSN_APPLY:
{
GGPROTO *gg = (GGPROTO *)GetWindowLongPtr(hwndDlg, GWLP_USERDATA);
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);
}
}
}
break;
}
}
return FALSE;
}
////////////////////////////////////////////////////////////////////////////////////////////
// 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;
}
////////////////////////////////////////////////////////////////////////////////////////////
// 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 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
}
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;
}
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;
}
LRESULT CALLBACK CMainWindow::WinMsgHandler(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_CREATE:
{
m_hwnd = hwnd;
Initialize();
}
break;
case WM_COMMAND:
{
return DoCommand(LOWORD(wParam));
}
break;
case WM_MOUSEWHEEL:
{
if (GET_KEYSTATE_WPARAM(wParam) == MK_SHIFT)
{
// scroll sideways
SendEditor(SCI_LINESCROLL, -GET_WHEEL_DELTA_WPARAM(wParam)/40, 0);
}
else
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
break;
case WM_SIZE:
{
RECT rect;
GetClientRect(*this, &rect);
if (m_bShowFindBar)
{
::SetWindowPos(m_hWndEdit, HWND_TOP,
rect.left, rect.top,
rect.right-rect.left, rect.bottom-rect.top-30,
SWP_SHOWWINDOW);
::SetWindowPos(m_FindBar, HWND_TOP,
rect.left, rect.bottom-30,
rect.right-rect.left, 30,
SWP_SHOWWINDOW);
}
else
{
::SetWindowPos(m_hWndEdit, HWND_TOP,
rect.left, rect.top,
rect.right-rect.left, rect.bottom-rect.top,
SWP_SHOWWINDOW);
::ShowWindow(m_FindBar, SW_HIDE);
}
}
break;
case WM_GETMINMAXINFO:
{
MINMAXINFO * mmi = (MINMAXINFO*)lParam;
mmi->ptMinTrackSize.x = 100;
mmi->ptMinTrackSize.y = 100;
return 0;
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_CLOSE:
{
CRegStdWORD w = CRegStdWORD(_T("Software\\TortoiseGit\\UDiffViewerWidth"), (DWORD)CW_USEDEFAULT);
CRegStdWORD h = CRegStdWORD(_T("Software\\TortoiseGit\\UDiffViewerHeight"), (DWORD)CW_USEDEFAULT);
CRegStdWORD p = CRegStdWORD(_T("Software\\TortoiseGit\\UDiffViewerPos"), 0);
RECT rect;
::GetWindowRect(*this, &rect);
w = rect.right-rect.left;
h = rect.bottom-rect.top;
p = MAKELONG(rect.left, rect.top);
}
::DestroyWindow(m_hwnd);
break;
case WM_SETFOCUS:
SetFocus(m_hWndEdit);
break;
case COMMITMONITOR_FINDMSGNEXT:
{
SendEditor(SCI_CHARRIGHT);
SendEditor(SCI_SEARCHANCHOR);
m_bMatchCase = !!wParam;
m_findtext = (LPCTSTR)lParam;
SendEditor(SCI_SEARCHNEXT, m_bMatchCase ? SCFIND_MATCHCASE : 0, (LPARAM)CUnicodeUtils::StdGetUTF8(m_findtext).c_str());
SendEditor(SCI_SCROLLCARET);
}
break;
case COMMITMONITOR_FINDMSGPREV:
{
SendEditor(SCI_SEARCHANCHOR);
m_bMatchCase = !!wParam;
m_findtext = (LPCTSTR)lParam;
SendEditor(SCI_SEARCHPREV, m_bMatchCase ? SCFIND_MATCHCASE : 0, (LPARAM)CUnicodeUtils::StdGetUTF8(m_findtext).c_str());
SendEditor(SCI_SCROLLCARET);
}
break;
case COMMITMONITOR_FINDEXIT:
{
RECT rect;
GetClientRect(*this, &rect);
m_bShowFindBar = false;
::ShowWindow(m_FindBar, SW_HIDE);
::SetWindowPos(m_hWndEdit, HWND_TOP,
rect.left, rect.top,
rect.right-rect.left, rect.bottom-rect.top,
SWP_SHOWWINDOW);
}
break;
case COMMITMONITOR_FINDRESET:
SendEditor(SCI_SETSELECTIONSTART, 0);
SendEditor(SCI_SETSELECTIONEND, 0);
SendEditor(SCI_SEARCHANCHOR);
break;
default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
};
int
tray_notify_cb(UINT message, WPARAM uID, LPARAM lEvent)
{
switch(LOWORD(lEvent)) {
case WM_RBUTTONUP: {
HINSTANCE hInstance = applet->hInstance;
HMENU hMenu = LoadMenu(hInstance, MAKEINTRESOURCE(IDC_STARTINTRAY));
if (applet->web_status == WEB_READY)
EnableMenuItem (hMenu, IDM_OPEN, MF_ENABLED);
else
EnableMenuItem (hMenu, IDM_OPEN, MF_GRAYED);
if (applet->auto_sync_disabled) {
EnableMenuItem (hMenu, IDM_ENABLE_AUTO_SYNC, MF_ENABLED);
EnableMenuItem (hMenu, IDM_DISABLE_AUTO_SYNC, MF_GRAYED);
} else {
EnableMenuItem (hMenu, IDM_DISABLE_AUTO_SYNC, MF_ENABLED);
EnableMenuItem (hMenu, IDM_ENABLE_AUTO_SYNC, MF_GRAYED);
}
/* Always allow restarting. */
EnableMenuItem (hMenu, IDM_RESTART, MF_ENABLED);
hMenu = GetSubMenu(hMenu, 0);
HWND hWnd = applet->hWnd;
SetForegroundWindow(hWnd);
POINT pos;
GetCursorPos(&pos);
TrackPopupMenu(hMenu, 0, pos.x, pos.y, 0, hWnd, NULL);
DestroyMenu(hMenu);
break;
}
case WM_MOUSEMOVE:
break;
case WM_LBUTTONUP:
if (applet->web_status == WEB_READY) {
open_web_browser (SEAF_HTTP_ADDR);
}
break;
case NIN_BALLOONUSERCLICK: {
if (applet->last_synced_repo[0] != '\0') {
char *repo = applet->last_synced_repo;
if (repo[0]) {
char buf[128];
snprintf (buf, sizeof(buf), SEAF_HTTP_ADDR "/repo/?repo=%s", repo);
open_web_browser (buf);
memset(repo, 0, sizeof(applet->last_synced_repo));
}
}
break;
}
case NIN_BALLOONHIDE:
case NIN_BALLOONTIMEOUT:
memset(applet->last_synced_repo, 0, sizeof(applet->last_synced_repo));
break;
default:
break;
}
return TRUE;
}
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;
}
static void BuildDynamicKeyMapTable()
{
HKL hkl = GetKeyboardLayout(0);
// Will need this to reset layout after dead keys.
UINT spaceScanCode = MapVirtualKeyEx(VK_SPACE, 0, hkl);
DynamicKeyMapEntry *dynamic;
LANGID idLang = LOWORD(GetKeyboardLayout(0));
UINT codePage;
TCHAR strCodePage[MAX_ACP_STR_LEN];
// use the LANGID to create a LCID
LCID idLocale = MAKELCID(idLang, SORT_DEFAULT);
// get the ANSI code page associated with this locale
if (GetLocaleInfo(idLocale, LOCALE_IDEFAULTANSICODEPAGE,
strCodePage, sizeof(strCodePage)/sizeof(TCHAR)) > 0 )
{
codePage = _ttoi(strCodePage);
} else {
codePage = GetACP();
}
// Entries in dynamic table that maps between Java VK and Windows
// VK are built in three steps:
// 1. Map windows VK to ANSI character (cannot map to unicode
// directly, since ::ToUnicode is not implemented on win9x)
// 2. Convert ANSI char to Unicode char
// 3. Map Unicode char to Java VK via two auxilary tables.
for (dynamic = dynamicKeyMapTable; dynamic->windowsKey != 0; ++dynamic)
{
char cbuf[2] = { '\0', '\0'};
WCHAR ucbuf[2] = { L'\0', L'\0' };
int nchars;
UINT scancode;
const CharToVKEntry *charMap;
int nconverted;
WCHAR uc;
BYTE kbdState[256];
// Defaults to J_VK_UNDEFINED
dynamic->javaKey = J_VK_UNDEFINED;
GetKeyboardState(kbdState);
kbdState[dynamic->windowsKey] |= 0x80; // Press the key.
// Unpress modifiers, since they are most likely pressed as
// part of the keyboard switching shortcut.
kbdState[VK_CONTROL] &= ~0x80;
kbdState[VK_SHIFT] &= ~0x80;
kbdState[VK_MENU] &= ~0x80;
scancode = MapVirtualKeyEx(dynamic->windowsKey, 0, hkl);
nchars = ToAsciiEx(dynamic->windowsKey, scancode, kbdState,
(WORD*)cbuf, 0, hkl);
// Auxiliary table used to map Unicode character to Java VK.
// Will assign a different table for dead keys (below).
charMap = charToVKTable;
if (nchars < 0) { // Dead key
char junkbuf[2] = { '\0', '\0'};
// Use a different table for dead chars since different layouts
// return different characters for the same dead key.
charMap = charToDeadVKTable;
// We also need to reset layout so that next translation
// is unaffected by the dead status. We do this by
// translating <SPACE> key.
kbdState[dynamic->windowsKey] &= ~0x80;
kbdState[VK_SPACE] |= 0x80;
ToAsciiEx(VK_SPACE, spaceScanCode, kbdState,
(WORD*)junkbuf, 0, hkl);
}
nconverted = MultiByteToWideChar(codePage, 0,
cbuf, 1, ucbuf, 2);
uc = ucbuf[0];
{
const CharToVKEntry *map;
for (map = charMap; map->c != 0; ++map) {
if (uc == map->c) {
dynamic->javaKey = map->javaKey;
break;
}
}
}
} // for each VK_OEM_*
}
JNIEXPORT jint JNICALL Java_org_eclipse_cdt_utils_spawner_Spawner_exec0
(JNIEnv * env, jobject process, jobjectArray cmdarray, jobjectArray envp, jstring dir, jintArray channels)
{
HANDLE stdHandles[3];
PROCESS_INFORMATION pi = {0}, *piCopy;
STARTUPINFOW si;
DWORD flags = 0;
const wchar_t * cwd = NULL;
LPVOID envBlk = NULL;
int ret = 0;
int nCmdLineLength= 0;
wchar_t * szCmdLine= 0;
int nBlkSize = MAX_ENV_SIZE;
wchar_t * szEnvBlock = NULL;
jsize nCmdTokens = 0;
jsize nEnvVars = 0;
int i;
DWORD pid = GetCurrentProcessId();
int nPos;
pProcInfo_t pCurProcInfo;
// This needs to be big enough to contain the name of the event used when calling CreateEventW bellow.
// It is made of a prefix (7 characters max) plus the value of a pointer that gets output in characters.
// This will be bigger in the case of 64 bit.
static const int MAX_EVENT_NAME_LENGTH = 50;
wchar_t eventBreakName[MAX_EVENT_NAME_LENGTH];
wchar_t eventWaitName[MAX_EVENT_NAME_LENGTH];
wchar_t eventTerminateName[MAX_EVENT_NAME_LENGTH];
wchar_t eventKillName[MAX_EVENT_NAME_LENGTH];
wchar_t eventCtrlcName[MAX_EVENT_NAME_LENGTH];
#ifdef DEBUG_MONITOR
wchar_t buffer[4000];
#endif
int nLocalCounter;
wchar_t inPipeName[PIPE_NAME_LENGTH];
wchar_t outPipeName[PIPE_NAME_LENGTH];
wchar_t errPipeName[PIPE_NAME_LENGTH];
nCmdLineLength= MAX_CMD_SIZE;
szCmdLine= (wchar_t *)malloc(nCmdLineLength * sizeof(wchar_t));
szCmdLine[0]= _T('\0');
if((HIBYTE(LOWORD(GetVersion()))) & 0x80)
{
ThrowByName(env, "java/io/IOException", "Does not support Windows 3.1/95/98/Me");
return 0;
}
if (cmdarray == 0)
{
ThrowByName(env, "java/lang/NullPointerException", "No command line specified");
return 0;
}
ZeroMemory(stdHandles, sizeof(stdHandles));
// Create pipe names
EnterCriticalSection(&cs);
swprintf(inPipeName, L"\\\\.\\pipe\\stdin%08i%010i", pid, nCounter);
swprintf(outPipeName, L"\\\\.\\pipe\\stdout%08i%010i", pid, nCounter);
swprintf(errPipeName, L"\\\\.\\pipe\\stderr%08i%010i", pid, nCounter);
nLocalCounter = nCounter;
++nCounter;
LeaveCriticalSection(&cs);
if ((INVALID_HANDLE_VALUE == (stdHandles[0] = CreateNamedPipeW(inPipeName, PIPE_ACCESS_OUTBOUND,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES, PIPE_SIZE, PIPE_SIZE, PIPE_TIMEOUT, NULL))) ||
(INVALID_HANDLE_VALUE == (stdHandles[1] = CreateNamedPipeW(outPipeName, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES, PIPE_SIZE, PIPE_SIZE, PIPE_TIMEOUT, NULL))) ||
(INVALID_HANDLE_VALUE == (stdHandles[2] = CreateNamedPipeW(errPipeName, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
PIPE_UNLIMITED_INSTANCES, PIPE_SIZE, PIPE_SIZE, PIPE_TIMEOUT, NULL)))) {
CloseHandle(stdHandles[0]);
CloseHandle(stdHandles[1]);
CloseHandle(stdHandles[2]);
ThrowByName(env, "java/io/IOException", "CreatePipe");
return 0;
}
#ifdef DEBUG_MONITOR
swprintf(buffer, _T("Opened pipes: %s, %s, %s\n"), inPipeName, outPipeName, errPipeName);
OutputDebugStringW(buffer);
#endif
nCmdTokens = env->GetArrayLength(cmdarray);
nEnvVars = env->GetArrayLength(envp);
pCurProcInfo = createProcInfo();
if(NULL == pCurProcInfo)
{
ThrowByName(env, "java/io/IOException", "Too many processes");
return 0;
}
// Construct starter's command line
swprintf(eventBreakName, L"SABreak%04x%08x", pid, nLocalCounter);
swprintf(eventWaitName, L"SAWait%004x%08x", pid, nLocalCounter);
swprintf(eventTerminateName, L"SATerm%004x%08x", pid, nLocalCounter);
swprintf(eventKillName, L"SAKill%04x%08x", pid, nLocalCounter);
swprintf(eventCtrlcName, L"SACtrlc%04x%08x", pid, nLocalCounter);
pCurProcInfo->eventBreak = CreateEventW(NULL, FALSE, FALSE, eventBreakName);
if(NULL == pCurProcInfo->eventBreak || GetLastError() == ERROR_ALREADY_EXISTS)
{
ThrowByName(env, "java/io/IOException", "Cannot create event");
return 0;
}
pCurProcInfo->eventWait = CreateEventW(NULL, TRUE, FALSE, eventWaitName);
pCurProcInfo->eventTerminate = CreateEventW(NULL, FALSE, FALSE, eventTerminateName);
pCurProcInfo->eventKill = CreateEventW(NULL, FALSE, FALSE, eventKillName);
pCurProcInfo->eventCtrlc = CreateEventW(NULL, FALSE, FALSE, eventCtrlcName);
swprintf(szCmdLine, L"\"%sstarter.exe\" %i %i %s %s %s %s %s ", path, pid, nLocalCounter, eventBreakName, eventWaitName, eventTerminateName, eventKillName, eventCtrlcName);
nPos = wcslen(szCmdLine);
// Prepare command line
for(i = 0; i < nCmdTokens; ++i)
{
jstring item = (jstring)env->GetObjectArrayElement(cmdarray, i);
jsize len = env->GetStringLength(item);
int nCpyLen;
const wchar_t * str = (const wchar_t *)env->GetStringChars(item, 0);
if(NULL != str)
{
int requiredSize= nPos+len+2;
if (requiredSize > 32*1024) {
ThrowByName(env, "java/io/IOException", "Command line too long");
return 0;
}
ensureSize(&szCmdLine, &nCmdLineLength, requiredSize);
if (NULL == szCmdLine) {
ThrowByName(env, "java/io/IOException", "Not enough memory");
return 0;
}
if(0 > (nCpyLen = copyTo(szCmdLine + nPos, str, len, nCmdLineLength - nPos)))
{
ThrowByName(env, "java/io/IOException", "Command line too long");
return 0;
}
nPos += nCpyLen;
szCmdLine[nPos] = _T(' ');
++nPos;
env->ReleaseStringChars(item, (const jchar *)str);
}
}
szCmdLine[nPos] = _T('\0');
#ifdef DEBUG_MONITOR
swprintf(buffer, _T("There are %i environment variables \n"), nEnvVars);
OutputDebugStringW(buffer);
#endif
// Prepare environment block
if (nEnvVars > 0)
{
nPos = 0;
szEnvBlock = (wchar_t *)malloc(nBlkSize * sizeof(wchar_t));
for(i = 0; i < nEnvVars; ++i)
{
jstring item = (jstring)env->GetObjectArrayElement(envp, i);
jsize len = env->GetStringLength(item);
const wchar_t * str = (const wchar_t *)env->GetStringChars(item, 0);
if(NULL != str)
{
while((nBlkSize - nPos) <= (len + 2)) // +2 for two '\0'
{
nBlkSize += MAX_ENV_SIZE;
szEnvBlock = (wchar_t *)realloc(szEnvBlock, nBlkSize * sizeof(wchar_t));
if(NULL == szEnvBlock)
{
ThrowByName(env, "java/io/IOException", "Not enough memory");
return 0;
}
#ifdef DEBUG_MONITOR
swprintf(buffer, _T("Realloc environment block; new length is %i \n"), nBlkSize);
OutputDebugStringW(buffer);
#endif
}
#ifdef DEBUG_MONITOR
swprintf(buffer, _T("%s\n"), str);
OutputDebugStringW(buffer);
#endif
wcsncpy(szEnvBlock + nPos, str, len);
nPos += len;
szEnvBlock[nPos] = _T('\0');
++nPos;
env->ReleaseStringChars(item, (const jchar *)str);
}
}
szEnvBlock[nPos] = _T('\0');
}
if (dir != 0)
{
const wchar_t * str = (const wchar_t *)env->GetStringChars(dir, 0);
if(NULL != str)
{
cwd = wcsdup(str);
env->ReleaseStringChars(dir, (const jchar *)str);
}
}
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
si.dwFlags |= STARTF_USESHOWWINDOW;
si.wShowWindow = SW_HIDE; // Processes in the Process Group are hidden
SetHandleInformation(stdHandles[0], HANDLE_FLAG_INHERIT, FALSE);
SetHandleInformation(stdHandles[1], HANDLE_FLAG_INHERIT, FALSE);
SetHandleInformation(stdHandles[2], HANDLE_FLAG_INHERIT, FALSE);
flags = CREATE_NEW_CONSOLE;
flags |= CREATE_NO_WINDOW;
flags |= CREATE_UNICODE_ENVIRONMENT;
#ifdef DEBUG_MONITOR
OutputDebugStringW(szCmdLine);
#endif
// launches starter; we need it to create another console group to correctly process
// emulation of SYSint signal (Ctrl-C)
ret = CreateProcessW(0, /* executable name */
szCmdLine, /* command line */
0, /* process security attribute */
0, /* thread security attribute */
FALSE, /* inherits system handles */
flags, /* normal attached process */
szEnvBlock, /* environment block */
cwd, /* change to the new current directory */
&si, /* (in) startup information */
&pi); /* (out) process information */
if(NULL != cwd)
free((void *)cwd);
if(NULL != szEnvBlock)
free(szEnvBlock);
if(NULL != szCmdLine)
free(szCmdLine);
if (!ret) // Launching error
{
char * lpMsgBuf;
CloseHandle(stdHandles[0]);
CloseHandle(stdHandles[1]);
CloseHandle(stdHandles[2]);
FormatMessageA(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
GetLastError(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
(char *)&lpMsgBuf,
0,
NULL
);
ThrowByName(env, "java/io/IOException", lpMsgBuf);
// Free the buffer.
LocalFree( lpMsgBuf );
cleanUpProcBlock(pCurProcInfo);
ret = -1;
}
else
{
int file_handles[3];
HANDLE h[2];
int what;
EnterCriticalSection(&cs);
pCurProcInfo -> pid = pi.dwProcessId;
h[0] = pCurProcInfo -> eventWait;
h[1] = pi.hProcess;
what = WaitForMultipleObjects(2, h, FALSE, INFINITE);
if(what != WAIT_OBJECT_0) // CreateProcess failed
{
#ifdef DEBUG_MONITOR
swprintf(buffer, _T("Process %i failed\n"), pi.dwProcessId);
OutputDebugStringW(buffer);
#endif
cleanUpProcBlock(pCurProcInfo);
ThrowByName(env, "java/io/IOException", "Launching failed");
#ifdef DEBUG_MONITOR
OutputDebugStringW(_T("Process failed\n"));
#endif
}
else
{
ret = (long)(pCurProcInfo -> uid);
// Prepare stream handlers to return to java program
file_handles[0] = (int)stdHandles[0];
file_handles[1] = (int)stdHandles[1];
file_handles[2] = (int)stdHandles[2];
env->SetIntArrayRegion(channels, 0, 3, (jint *)file_handles);
// do the cleanup so launch the according thread
// create a copy of the PROCESS_INFORMATION as this might get destroyed
piCopy = (PROCESS_INFORMATION *)malloc(sizeof(PROCESS_INFORMATION));
memcpy(piCopy, &pi, sizeof(PROCESS_INFORMATION));
_beginthread(waitProcTermination, 0, (void *)piCopy);
#ifdef DEBUG_MONITOR
OutputDebugStringW(_T("Process started\n"));
#endif
}
LeaveCriticalSection(&cs);
}
CloseHandle(pi.hThread);
return ret;
}
/*
* 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);
}
BOOL CALLBACK DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
int i, size;
char *selected_language = NULL;
static HFONT font;
switch (uMsg) {
case WM_INITDIALOG:
// add languages
for (i = visible_langs_num - 1; i >= 0; i--) {
int cbi;
cbi = SendDlgItemMessage(hwndDlg, IDC_LANGUAGE, CB_ADDSTRING, 0, (LPARAM) langs[i].name);
SendDlgItemMessage(hwndDlg, IDC_LANGUAGE, CB_SETITEMDATA, cbi, (LPARAM) langs[i].id);
// remember selected language
if (!lstrcmp(langs[i].id, getuservariable(INST_LANG))) {
selected_language = langs[i].name;
}
}
// select the current language
if (selected_language)
SendDlgItemMessage(hwndDlg, IDC_LANGUAGE, CB_SELECTSTRING, (WPARAM) -1, (LPARAM) selected_language);
else
SendDlgItemMessage(hwndDlg, IDC_LANGUAGE, CB_SETCURSEL, 0, 0);
// set texts
SetDlgItemText(hwndDlg, IDC_TEXT, g_wndtext);
SetWindowText(hwndDlg, g_wndtitle);
SendDlgItemMessage(hwndDlg, IDC_APPICON, STM_SETICON, (LPARAM)LoadIcon(GetModuleHandle(0),MAKEINTRESOURCE(103)), 0);
// set font
if (dofont && !popstring(temp)) {
size = myatou(temp);
if (!popstring(temp)) {
LOGFONT f = {0,};
if (lstrcmp(temp, "MS Shell Dlg")) {
f.lfHeight = -MulDiv(size, GetDeviceCaps(GetDC(hwndDlg), LOGPIXELSY), 72);
lstrcpy(f.lfFaceName, temp);
font = CreateFontIndirect(&f);
SendMessage(hwndDlg, WM_SETFONT, (WPARAM)font, 1);
SendDlgItemMessage(hwndDlg, IDOK, WM_SETFONT, (WPARAM)font, 1);
SendDlgItemMessage(hwndDlg, IDCANCEL, WM_SETFONT, (WPARAM)font, 1);
SendDlgItemMessage(hwndDlg, IDC_LANGUAGE, WM_SETFONT, (WPARAM)font, 1);
SendDlgItemMessage(hwndDlg, IDC_TEXT, WM_SETFONT, (WPARAM)font, 1);
}
}
}
// show window
ShowWindow(hwndDlg, SW_SHOW);
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
// push result on the stack
i = SendDlgItemMessage(hwndDlg, IDC_LANGUAGE, CB_GETCURSEL, 0, 0);
i = SendDlgItemMessage(hwndDlg, IDC_LANGUAGE, CB_GETITEMDATA, i, 0);
if (i != CB_ERR && i) {
pushstring((char *) i);
} else {
// ?!
pushstring("cancel");
}
// end dialog
EndDialog(hwndDlg, 0);
break;
case IDCANCEL:
// push "cancel" on the stack
pushstring("cancel");
// end dialog
EndDialog(hwndDlg, 0);
break;
}
break;
case WM_DESTROY:
// clean up
if (font) DeleteObject(font);
break;
default:
return FALSE; // message not processed
}
return TRUE; // message processed
}
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;
}
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;
}
}
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;
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_COMMAND:
{
int wmId = LOWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
}
break;
#pragma region Code
case WM_CREATE:
if (nullptr == Inst) {
Inst = new ComputeVK();
}
if (nullptr != Inst) {
try {
Inst->OnCreate(hWnd, hInst, szTitle);
}
catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
}
break;
case WM_TIMER:
if (nullptr != Inst) {
Inst->OnTimer(hWnd, hInst);
}
break;
case WM_SIZE:
if (nullptr != Inst) {
Inst->OnSize(hWnd, hInst);
}
break;
case WM_KEYDOWN:
if (VK_ESCAPE == wParam) {
SendMessage(hWnd, WM_DESTROY, 0, 0);
}
break;
#pragma endregion
case WM_PAINT:
{
PAINTSTRUCT ps;
HDC hdc = BeginPaint(hWnd, &ps);
// TODO: Add any drawing code that uses hdc here...
#pragma region Code
if (nullptr != Inst) {
Inst->OnPaint(hWnd, hInst);
}
#pragma endregion
EndPaint(hWnd, &ps);
}
break;
case WM_DESTROY:
#pragma region Code
if (nullptr != Inst) {
Inst->OnDestroy(hWnd, hInst);
}
SAFE_DELETE(Inst);
#pragma endregion
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
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;
}
/***********************************************************************
* 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;
}
