//==============================================================================
BOOL CALLBACK GbaSlotBox_Proc(HWND dialog, UINT msg,WPARAM wparam,LPARAM lparam)
{
switch(msg)
{
case WM_INITDIALOG:
{
OKbutton = GetDlgItem(dialog, IDOK);
for(int i = 0; i < NDS_ADDON_COUNT; i++)
ComboBox_AddString(GetDlgItem(dialog, IDC_ADDONS_LIST), addonList[i].name);
ComboBox_SetCurSel(GetDlgItem(dialog, IDC_ADDONS_LIST), temp_type);
u8 tmp_info[512];
addonList[temp_type].info((char *)tmp_info);
SetWindowText(GetDlgItem(dialog, IDC_ADDONS_INFO), (char *)tmp_info);
wndConfig=CreateDialog(hAppInst, MAKEINTRESOURCE(GBAslot_IDDs[temp_type]),
dialog, (DLGPROC)GBAslot_Procs[temp_type]);
if (temp_type == 0)
EnableWindow(OKbutton, TRUE);
return TRUE;
}
case WM_COMMAND:
{
switch (LOWORD(wparam))
{
case IDOK:
{
int Msg = IDYES;
if (romloaded)
{
int Msg = MessageBox(dialog,
"After change GBA slot pak game will reset!\nAre you sure to continue?", "DeSmuME",
MB_YESNO|MB_ICONQUESTION|MB_DEFBUTTON2);
}
if (Msg == IDYES)
{
if (wndConfig) DestroyWindow(wndConfig);
EndDialog(dialog, TRUE);
}
}
return TRUE;
case IDCANCEL:
if (wndConfig) DestroyWindow(wndConfig);
EndDialog(dialog, FALSE);
return TRUE;
case IDC_ADDONS_LIST:
if (HIWORD(wparam) == CBN_SELENDOK)
{
temp_type = ComboBox_GetCurSel(GetDlgItem(dialog, IDC_ADDONS_LIST));
if (temp_type != last_type)
{
if (wndConfig) DestroyWindow(wndConfig);
wndConfig=CreateDialog(hAppInst,
MAKEINTRESOURCE(GBAslot_IDDs[temp_type]), dialog,
(DLGPROC)GBAslot_Procs[temp_type]);
u8 tmp_info[512];
addonList[temp_type].info((char *)tmp_info);
SetWindowText(GetDlgItem(dialog, IDC_ADDONS_INFO), (char *)tmp_info);
last_type = temp_type;
}
}
return TRUE;
}
break;
}
}
return FALSE;
}
INT_PTR
CALLBACK
_options_dlg_proc(
HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam
)
{
_ctl_init ctl_chk_general[ ] =
{
{ STR_NULL, IDC_AUTO_MOUNT_ON_BOOT, CONF_AUTOMOUNT_BOOT },
{ STR_NULL, IDC_EXPLORER_ON_MOUNT, CONF_EXPLORER_MOUNT },
{ STR_NULL, IDC_CACHE_PASSWORDS, CONF_CACHE_PASSWORD },
{ STR_NULL, IDC_UNMOUNT_LOGOFF, CONF_DISMOUNT_LOGOFF },
{ STR_NULL, IDC_FORCE_UNMOUNT, CONF_FORCE_DISMOUNT },
{ STR_NULL, IDC_WIPE_LOGOFF, CONF_WIPEPAS_LOGOFF },
{ STR_NULL, IDC_AUTO_START, CONF_AUTO_START }
};
_ctl_init ctl_chk_extended[ ] =
{
{ STR_NULL, IDC_HARD_CRYPTO_SUPPORT, CONF_HW_CRYPTO },
{ STR_NULL, IDC_HIDE_FILES, CONF_HIDE_DCSYS },
{ STR_NULL, IDC_DISABLE_TRIM, CONF_DISABLE_TRIM },
{ STR_NULL, IDC_SSD_OPTIMIZATION, CONF_ENABLE_SSD_OPT }
};
_ctl_init static_head_general[ ] =
{
{ L"# Mount Settings", IDC_HEAD1, 0 },
{ L"# Password Caching", IDC_HEAD2, 0 },
{ L"# Boot Options", IDC_HEAD3, 0 }
};
_ctl_init static_head_extended[ ] =
{
{ L"# Extended Settings", IDC_HEAD1, 0 }
};
WORD code = LOWORD(wparam);
WORD id = LOWORD(wparam);
DWORD _flags = 0;
DWORD _hotkeys[HOTKEYS] = { 0 };
_wnd_data *wnd;
int check = 0;
int k = 0;
switch ( message )
{
case WM_INITDIALOG :
{
TCITEM tab_item = { TCIF_TEXT };
HWND h_tab = GetDlgItem( hwnd, IDT_TAB );
_tab_data *d_tab = malloc(sizeof(_tab_data));
wnd = _sub_class(
h_tab, SUB_NONE,
CreateDialog( __hinst, MAKEINTRESOURCE(DLG_CONF_GENERAL), GetDlgItem(hwnd, IDC_TAB), _tab_proc ),
CreateDialog( __hinst, MAKEINTRESOURCE(DLG_CONF_EXTNDED), GetDlgItem(hwnd, IDC_TAB), _tab_proc ),
CreateDialog( __hinst, MAKEINTRESOURCE(DLG_CONF_HOTKEYS), GetDlgItem(hwnd, IDC_TAB), _tab_proc ),
HWND_NULL
);
memset(d_tab, 0, sizeof(_tab_data));
d_tab->active = wnd->dlg[0];
wnd_set_long(hwnd, GWL_USERDATA, d_tab);
{
for ( k = 0; k < array_num(ctl_chk_general); k++ )
{
_sub_class( GetDlgItem( wnd->dlg[0], ctl_chk_general[k].id ), SUB_STATIC_PROC, HWND_NULL );
_set_check( wnd->dlg[0], ctl_chk_general[k].id, __config.conf_flags & ctl_chk_general[k].val );
}
for ( k = 0; k < array_num(ctl_chk_extended); k++ )
{
_sub_class( GetDlgItem( wnd->dlg[1], ctl_chk_extended[k].id ), SUB_STATIC_PROC, HWND_NULL );
_set_check( wnd->dlg[1], ctl_chk_extended[k].id, __config.conf_flags & ctl_chk_extended[k].val );
}
if ( ! (__config.load_flags & DST_HW_CRYPTO) )
{
wchar_t s_ch_label[MAX_PATH] = { 0 };
HWND h_check = GetDlgItem( wnd->dlg[1], IDC_HARD_CRYPTO_SUPPORT );
EnableWindow( h_check, FALSE );
GetWindowText( h_check, s_ch_label, sizeof_w(s_ch_label) );
wcscat( s_ch_label, L" (not supported)" );
SetWindowText( h_check, s_ch_label );
}
for ( k = 0; k < array_num(static_head_general); k++ )
{
SetWindowText(GetDlgItem(wnd->dlg[0], static_head_general[k].id), static_head_general[k].display);
SendMessage(GetDlgItem(wnd->dlg[0], static_head_general[k].id), (UINT)WM_SETFONT, (WPARAM)__font_bold, 0);
}
for ( k = 0; k < array_num(static_head_extended); k++ )
{
SetWindowText(GetDlgItem(wnd->dlg[1], static_head_extended[k].id), static_head_extended[k].display);
SendMessage(GetDlgItem(wnd->dlg[1], static_head_extended[k].id), (UINT)WM_SETFONT, (WPARAM)__font_bold, 0);
}
SendMessage(
wnd->dlg[0], WM_USER_CLICK, (WPARAM)GetDlgItem(wnd->dlg[0], IDC_AUTO_START), 0
);
_sub_class(
GetDlgItem(wnd->dlg[2], IDC_KEY_USEEXT), SUB_STATIC_PROC, HWND_NULL
);
k = 0;
while ( hotks_edit[k].id != -1 )
{
wchar_t key[200] = { 0 };
_sub_class(
GetDlgItem(wnd->dlg[2], hotks_edit[k].id), SUB_KEY_PROC, HWND_NULL
);
_sub_class(
GetDlgItem(wnd->dlg[2], hotks_chk[k].id), SUB_STATIC_PROC, HWND_NULL
);
_set_check( wnd->dlg[2], hotks_chk[k].id, __config.hotkeys[k] );
SendMessage(
wnd->dlg[2], WM_USER_CLICK, (WPARAM)GetDlgItem(wnd->dlg[2], hotks_chk[k].id), 0
);
_key_name(HIWORD( __config.hotkeys[k]), LOWORD(__config.hotkeys[k]), key );
SetWindowText(GetDlgItem(wnd->dlg[2], hotks_edit[k].id), key);
((_wnd_data *)wnd_get_long(
GetDlgItem(wnd->dlg[2], hotks_edit[k].id), GWL_USERDATA)
)->vk = __config.hotkeys[k];
k++;
}
}
tab_item.pszText = L"General";
TabCtrl_InsertItem(h_tab, 0, &tab_item);
tab_item.pszText = L"Extended";
TabCtrl_InsertItem(h_tab, 1, &tab_item);
tab_item.pszText = L"Hot Keys";
TabCtrl_InsertItem(h_tab, 2, &tab_item);
{
k = 1;
while ( wnd->dlg[k] != 0 )
{
ShowWindow( wnd->dlg[k], SW_HIDE );
k++;
}
}
SetForegroundWindow( hwnd );
return 1L;
}
break;
case WM_NOTIFY :
{
if ( wparam == IDT_TAB )
{
if ( ((NMHDR *)lparam)->code == TCN_SELCHANGE )
{
HWND h_tab = GetDlgItem(hwnd, IDT_TAB);
if ( !_is_curr_in_group(h_tab) )
{
_change_page( h_tab, TabCtrl_GetCurSel(h_tab) );
}
}
}
}
break;
case WM_COMMAND :
{
/*
switch (id)
{
case ID_SHIFT_TAB :
case ID_TAB :
{
HWND h_current = GetFocus( );
HWND h_next = GetNextDlgTabItem( sheets[index].hwnd, h_current, id == ID_SHIFT_TAB );
SetFocus( h_next );
}
break;
*/
if ( (id == IDOK) || (id == IDCANCEL) )
{
wnd = wnd_get_long( GetDlgItem(hwnd, IDT_TAB), GWL_USERDATA );
if ( wnd )
{
for ( k = 0; k < array_num(ctl_chk_general); k++ )
{
_flags |= _get_check(wnd->dlg[0], ctl_chk_general[k].id) ? ctl_chk_general[k].val : FALSE;
}
for ( k = 0; k < array_num(ctl_chk_extended); k++ )
{
_flags |= _get_check(wnd->dlg[1], ctl_chk_extended[k].id) ? ctl_chk_extended[k].val : FALSE;
}
k = 0;
while ( hotks_edit[k].id != -1 )
{
if ( _get_check(wnd->dlg[2], hotks_chk[k].id) )
{
_hotkeys[k] = (
(_wnd_data *)wnd_get_long(GetDlgItem(wnd->dlg[2], hotks_edit[k].id), GWL_USERDATA)
)->vk;
}
k++;
}
}
if ( id == IDCANCEL ) check = TRUE;
if ( id == IDOK )
{
_unset_hotkeys(__config.hotkeys);
check = _check_hotkeys(wnd->dlg[0], _hotkeys);
if ( check )
{
if ( _hotkeys[3] && !__config.hotkeys[3] ) {
if (! __msg_w( hwnd, L"Set Hotkey for call BSOD?" ) )
{
_hotkeys[3] = 0;
}
}
if ( (_flags & CONF_AUTO_START) != (__config.conf_flags & CONF_AUTO_START) )
{
autorun_set(_flags & CONF_AUTO_START);
}
__config.conf_flags = _flags;
memcpy(&__config.hotkeys, &_hotkeys, sizeof(DWORD)*HOTKEYS);
dc_save_conf(&__config);
}
_set_hotkeys(hwnd, __config.hotkeys, FALSE);
}
if ( check )
{
EndDialog (hwnd, id);
}
return 1L;
}
}
break;
case WM_DESTROY :
{
wnd = wnd_get_long( GetDlgItem(hwnd, IDT_TAB), GWL_USERDATA );
if ( wnd )
{
for ( k = 0; k < array_num(ctl_chk_general); k++ )
{
__unsub_class(GetDlgItem(wnd->dlg[0], ctl_chk_general[k].id));
}
for ( k = 0; k < array_num(ctl_chk_extended); k++ )
{
__unsub_class(GetDlgItem(wnd->dlg[1], ctl_chk_extended[k].id));
}
__unsub_class(GetDlgItem(wnd->dlg[1], IDC_KEY_USEEXT));
k = 0;
while ( hotks_edit[k].id != -1 )
{
__unsub_class(GetDlgItem(wnd->dlg[2], hotks_edit[k].id));
__unsub_class(GetDlgItem(wnd->dlg[2], hotks_chk[k].id));
k++;
}
}
__unsub_class(GetDlgItem(hwnd, IDT_TAB));
}
break;
default :
{
int rlt = _draw_proc(message, lparam);
if ( rlt != -1 )
{
return rlt;
}
}
}
return 0L;
}
LRESULT CALLBACK MixerPlus_MainWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static HMIXER hMixer = NULL;
static DWORD dwLines = 0; // Must always count plinfo correctly
static PMIXERPLUS_INFO pinfo = NULL;
static PMIXERPLUS_LINE_INFO plinfo = NULL; // Array
static HWND hCFader = NULL;
static DWORD dwControlFlags = 0;
static MIXERLINE mxlineDest;
static MIXERPLUS_CONTROL_FEED feed;
UINT i, j;
RECT rcCtrl, rcCFader, rcWnd;
SCROLLINFO si;
MIXERCAPS mxcaps;
MIXERLINE mxlineSrc;
MIXERLINECONTROLS mxlctls;
MIXERCONTROL mxctl;
MIXERCONTROLDETAILS mxcdtls;
TCHAR szTitle[MIXERPLUS_MAX_TITLE];
switch(uMsg)
{
case MM_MIXM_LINE_CHANGE:
for(i = 0; i < dwLines; i++)
if(((DWORD) lParam) == plinfo[i].dwLineID)
{
SendMessage(plinfo[i].hCtrl, uMsg, wParam, lParam);
return 0;
}
break;
case MM_MIXM_CONTROL_CHANGE:
for(i = 0; i < dwLines; i++)
{
/* Check if child contains control for which this message is intended */
if(((plinfo[i].dwControlFlags & MIXERPLUS_LINE_CONTROL_VOLUME)
&& ((DWORD) lParam) == plinfo[i].volume.dwID)
|| ((plinfo[i].dwControlFlags & MIXERPLUS_LINE_CONTROL_MUTE)
&& ((DWORD) lParam) == plinfo[i].mute.dwID))
{
SendMessage(plinfo[i].hCtrl, uMsg, wParam, lParam);
return 0;
}
}
if((dwControlFlags & MIXERPLUS_LINE_CONTROL_FEED)
&& (((DWORD) lParam) == feed.dwID))
{
mxlctls.cbStruct = sizeof(mxlctls);
mxlctls.cbmxctrl = sizeof(mxctl);
mxlctls.dwControlID = feed.dwID;
mxlctls.pamxctrl = &mxctl;
if(MMERROR(mixerGetLineControls((HMIXEROBJ) hMixer,
&mxlctls,
MIXER_GETLINECONTROLSF_ONEBYID)))
{
return 0;
}
if(feed.dwSources != mxctl.cMultipleItems)
{
/* Reallocate */
HeapFree(pinfo->hHeap, 0, feed.pmxcdtls_lt);
HeapFree(pinfo->hHeap, 0, feed.pmxcdtls_b);
feed.pmxcdtls_lt =
(LPMIXERCONTROLDETAILS_LISTTEXT) HeapAlloc(pinfo->hHeap, 0,
mxctl.cMultipleItems * sizeof(MIXERCONTROLDETAILS_LISTTEXT));
feed.pmxcdtls_b =
(LPMIXERCONTROLDETAILS_BOOLEAN) HeapAlloc(pinfo->hHeap, 0,
mxctl.cMultipleItems * sizeof(MIXERCONTROLDETAILS_BOOLEAN));
if(!feed.pmxcdtls_lt || !feed.pmxcdtls_b)
{
dwControlFlags &= ~MIXERPLUS_LINE_CONTROL_FEED;
MixerPlus_ErrorBox(hWnd, TEXT("Cannot allocate memory. Check available memory."));
DestroyWindow(hWnd);
return 0;
}
feed.dwSources = mxctl.cMultipleItems;
}
mxcdtls.cbStruct = sizeof(mxcdtls);
mxcdtls.cbDetails = sizeof(MIXERCONTROLDETAILS_LISTTEXT);
mxcdtls.dwControlID = feed.dwID;
mxcdtls.cMultipleItems = feed.dwSources;
mxcdtls.cChannels = 1;
mxcdtls.paDetails = feed.pmxcdtls_lt;
if(MMERROR(mixerGetControlDetails((HMIXEROBJ) hMixer,
&mxcdtls,
MIXER_GETCONTROLDETAILSF_LISTTEXT)))
{
return 0;
}
mxcdtls.cbStruct = sizeof(mxcdtls);
mxcdtls.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
mxcdtls.dwControlID = feed.dwID;
mxcdtls.cMultipleItems = feed.dwSources;
mxcdtls.cChannels = 1;
mxcdtls.paDetails = feed.pmxcdtls_b;
if(MMERROR(mixerGetControlDetails((HMIXEROBJ) hMixer,
&mxcdtls,
MIXER_GETCONTROLDETAILSF_VALUE)))
{
return 0;
}
for(i = 0; i < dwLines; i++)
for(j = 0; j < feed.dwSources; j++)
if(plinfo[i].dwLineID == feed.pmxcdtls_lt[j].dwParam1)
CheckDlgButton(plinfo[i].hCtrl,
IDB_POWER,
feed.pmxcdtls_b[j].fValue ? BST_CHECKED : BST_UNCHECKED);
}
break;
case WM_HSCROLL:
/* Get scroll position */
si.cbSize = sizeof(si);
si.fMask = SIF_ALL;
GetScrollInfo(hWnd, SB_HORZ, &si);
/* Adjust */
switch(LOWORD(wParam))
{
case SB_THUMBTRACK: si.nPos = si.nTrackPos; break;
case SB_LINELEFT:
case SB_PAGELEFT:
si.nPos--; break;
case SB_LINERIGHT:
case SB_PAGERIGHT:
si.nPos++; break;
case SB_LEFT: si.nPos = si.nMin; break;
case SB_RIGHT: si.nPos = si.nMax; break;
}
SetScrollInfo(hWnd, SB_HORZ, &si, TRUE);
/* Allow for adjustments by Windows */
si.cbSize = sizeof(si);
si.fMask = SIF_POS;
GetScrollInfo(hWnd, SB_HORZ, &si);
/* Move child windows */
for(i = 0; i < dwLines; i++)
{
GetWindowRect(plinfo[i].hCtrl, &rcCtrl);
MoveWindow(plinfo[i].hCtrl,
(i - si.nPos) * (rcCtrl.right - rcCtrl.left), 0,
(rcCtrl.right - rcCtrl.left), (rcCtrl.bottom - rcCtrl.top),
TRUE);
}
return TRUE;
case WM_COMMAND:
/* Passed from crossfader */
if(LOWORD(wParam) == IDB_FADE && HIWORD(wParam) == BN_CLICKED)
{
/* Get indices */
i = (DWORD) SendDlgItemMessage(hCFader,
IDC_SOURCE,
CB_GETCURSEL,
0, 0);
j = (DWORD) SendDlgItemMessage(hCFader,
IDC_TARGET,
CB_GETCURSEL,
0, 0);
/* Do nothing if source is target */
if(i == j)
return TRUE;
/* Start faders */
SendMessage(plinfo[i].hCtrl,
WM_COMMAND,
MAKEWPARAM(IDB_FADEOUT, BN_CLICKED),
(LPARAM) GetDlgItem(plinfo[i].hCtrl, IDB_FADEOUT));
SendMessage(plinfo[j].hCtrl,
WM_COMMAND,
MAKEWPARAM(IDB_FADEIN, BN_CLICKED),
(LPARAM) GetDlgItem(plinfo[j].hCtrl, IDB_FADEIN));
return TRUE;
}
/* Passed from feed button */
else if((dwControlFlags & MIXERPLUS_LINE_CONTROL_FEED)
&& LOWORD(wParam) == IDB_POWER && HIWORD(wParam) == BN_CLICKED)
{
mxcdtls.cbStruct = sizeof(mxcdtls);
mxcdtls.cbDetails = sizeof(MIXERCONTROLDETAILS_BOOLEAN);
mxcdtls.dwControlID = feed.dwID;
mxcdtls.cMultipleItems = feed.dwSources;
mxcdtls.cChannels = 1;
mxcdtls.paDetails = feed.pmxcdtls_b;
for(i = 0; i < dwLines; i++)
if(((HWND) lParam) == GetDlgItem(plinfo[i].hCtrl, IDB_POWER))
{
for(j = 0; j < feed.dwSources; j++)
if(plinfo[i].dwLineID == feed.pmxcdtls_lt[j].dwParam1)
{
ZeroMemory(feed.pmxcdtls_b, feed.dwSources * sizeof(MIXERCONTROLDETAILS_BOOLEAN));
feed.pmxcdtls_b[j].fValue = !(IsDlgButtonChecked(plinfo[i].hCtrl, IDB_POWER) == BST_CHECKED);
mixerSetControlDetails((HMIXEROBJ) hMixer,
&mxcdtls,
MIXER_SETCONTROLDETAILSF_VALUE);
return TRUE;
}
break;
}
return TRUE;
}
switch(LOWORD(wParam))
{
case ID_FILE_EXIT:
SendMessage(hWnd, WM_CLOSE, 0, 0);
return 0;
case ID_TOOLS_OPTIONS:
/* Show options dialog box */
if(DialogBoxParam(pinfo->hInstance,
MAKEINTRESOURCE(IDD_OPTIONS),
hWnd,
(DLGPROC) MixerPlus_OptionsDlgProc,
(LPARAM) pinfo) != IDOK)
{
return TRUE;
}
/* Destroy everything */
for(i = 0; i < dwLines; i++)
DestroyWindow(plinfo[i].hCtrl);
if(hCFader)
{
DestroyWindow(hCFader);
hCFader = NULL;
}
if(dwControlFlags & MIXERPLUS_LINE_CONTROL_FEED)
{
dwControlFlags &= ~MIXERPLUS_LINE_CONTROL_FEED;
HeapFree(pinfo->hHeap, 0, feed.pmxcdtls_lt);
HeapFree(pinfo->hHeap, 0, feed.pmxcdtls_b);
}
if(plinfo)
{
HeapFree(pinfo->hHeap, 0, plinfo);
plinfo = NULL;
dwLines = 0;
}
if(hMixer)
{
mixerClose(hMixer);
hMixer = NULL;
}
/* Recreate */
SendMessage(hWnd,
WM_CREATE,
0,
0); // Do not need to set this since pinfo not NULL
return 0;
case ID_HELP_ABOUT:
MessageBox(hWnd,
TEXT("Mixer Plus v0.2\n\nWritten by John Peloquin"),
TEXT("Mixer Plus"),
MB_ICONINFORMATION);
return 0;
}
break;
case WM_CREATE:
/* NOTE: This message is also simulated when the user changes options */
/* Get init info if we do not aleady have it */
if(!pinfo)
pinfo = (PMIXERPLUS_INFO)(((LPCREATESTRUCT) lParam)->lpCreateParams);
/* Open mixer device */
if(MMERROR(mixerOpen(&hMixer,
pinfo->dwMixerID,
(DWORD_PTR) hWnd, 0,
MIXER_OBJECTF_MIXER | CALLBACK_WINDOW)))
{
MixerPlus_ErrorBox(hWnd, TEXT("Cannot open mixer device."));
return 0;
}
if(!MMERROR(mixerGetDevCaps((UINT) hMixer, &mxcaps, sizeof(mxcaps))))
{
if(SUCCEEDED(StringCchPrintf(szTitle,
LENGTHOF(szTitle),
TEXT("Mixer Plus [%s - %s]"),
mxcaps.szPname,
(pinfo->mode == MIXERPLUS_MODE_PLAYBACK) ? TEXT("Playback") : TEXT("Recording"))))
{
SetWindowText(hWnd, szTitle);
}
}
/* Get mixer destination line info */
mxlineDest.cbStruct = sizeof(mxlineDest);
mxlineDest.dwComponentType = (pinfo->mode == MIXERPLUS_MODE_PLAYBACK) ?
MIXERLINE_COMPONENTTYPE_DST_SPEAKERS :
MIXERLINE_COMPONENTTYPE_DST_WAVEIN;
if(MMERROR(mixerGetLineInfo((HMIXEROBJ) hMixer,
&mxlineDest,
MIXER_GETLINEINFOF_COMPONENTTYPE)))
{
mixerClose(hMixer);
MixerPlus_ErrorBox(hWnd, TEXT("Cannot open mixer destination line."));
return 0;
}
/* The output destination line also has volume and other controls, so
we wish to treat it like a source line. We do not do this for the
recording destination line */
dwLines = mxlineDest.cConnections
+ ((pinfo->mode == MIXERPLUS_MODE_PLAYBACK) ? 1 : 0);
/* Allocate info block memory for destination line and its associated source lines */
if(!(plinfo = HeapAlloc(pinfo->hHeap,
HEAP_ZERO_MEMORY, // This is necessary!
dwLines * sizeof(MIXERPLUS_LINE_INFO))))
{
mixerClose(hMixer);
MixerPlus_ErrorBox(hWnd, TEXT("Cannot allocate memory. Check available memory."));
return -1;
}
/* Create crossfader */
if(dwLines > 0)
{
hCFader = CreateDialog(pinfo->hInstance,
MAKEINTRESOURCE(IDD_CROSSFADER),
hWnd,
(DLGPROC) MixerPlus_CFaderDlgProc);
}
if(pinfo->mode == MIXERPLUS_MODE_PLAYBACK)
{
/* Put output destination line info at beginning of array */
i = 0;
plinfo[i].mode = pinfo->mode;
plinfo[i].hHeap = pinfo->hHeap;
plinfo[i].hMixer = hMixer;
plinfo[i].dwLineID = mxlineDest.dwLineID;
plinfo[i].dwChannels = mxlineDest.cChannels;
StringCchCopy(plinfo[i].szName,
LENGTHOF(plinfo[i].szName),
mxlineDest.szName);
/* Add to crossfader lists */
SendDlgItemMessage(hCFader,
IDC_SOURCE,
CB_ADDSTRING,
0,
(LPARAM) plinfo[i].szName);
SendDlgItemMessage(hCFader,
IDC_TARGET,
CB_ADDSTRING,
0,
(LPARAM) plinfo[i].szName);
/* Create its child window */
if(plinfo[i].hCtrl = CreateDialogParam(pinfo->hInstance,
MAKEINTRESOURCE(IDD_MIXERCTRL),
hWnd,
(DLGPROC) MixerPlus_CtrlDlgProc,
(LPARAM) &plinfo[i]))
{
ShowWindow(plinfo[i].hCtrl, SW_SHOW);
}
}
/* Get ahold of selection control for recording destination line */
else
{
mxlctls.cbStruct = sizeof(mxlctls);
mxlctls.cbmxctrl = sizeof(mxctl);
mxlctls.dwLineID = mxlineDest.dwLineID;
mxlctls.dwControlType = MIXERCONTROL_CONTROLTYPE_MUX;
mxlctls.pamxctrl = &mxctl;
if(!MMERROR(mixerGetLineControls((HMIXEROBJ) hMixer,
&mxlctls,
MIXER_GETLINECONTROLSF_ONEBYTYPE)))
{
feed.pmxcdtls_lt =
(LPMIXERCONTROLDETAILS_LISTTEXT) HeapAlloc(pinfo->hHeap, 0,
mxctl.cMultipleItems * sizeof(MIXERCONTROLDETAILS_LISTTEXT));
feed.pmxcdtls_b =
(LPMIXERCONTROLDETAILS_BOOLEAN) HeapAlloc(pinfo->hHeap, 0,
mxctl.cMultipleItems * sizeof(MIXERCONTROLDETAILS_BOOLEAN));
if(!feed.pmxcdtls_lt || !feed.pmxcdtls_b)
{
mixerClose(hMixer);
MixerPlus_ErrorBox(hWnd, TEXT("Cannot allocate memory. Check available memory."));
return -1;
}
dwControlFlags |= MIXERPLUS_LINE_CONTROL_FEED;
feed.dwID = mxctl.dwControlID;
feed.dwSources = mxctl.cMultipleItems;
}
}
/* Get source line info and create child windows */
for(i = 0; i < mxlineDest.cConnections; i++)
{
j = (pinfo->mode == MIXERPLUS_MODE_PLAYBACK) ? i + 1 : i;
mxlineSrc.cbStruct = sizeof(mxlineSrc);
mxlineSrc.dwDestination = mxlineDest.dwDestination;
mxlineSrc.dwSource = i;
mixerGetLineInfo((HMIXEROBJ) hMixer, &mxlineSrc, MIXER_GETLINEINFOF_SOURCE);
plinfo[j].mode = pinfo->mode;
plinfo[j].hHeap = pinfo->hHeap;
plinfo[j].hMixer = hMixer;
plinfo[j].dwLineID = mxlineSrc.dwLineID;
plinfo[j].dwChannels = mxlineSrc.cChannels;
StringCchCopy(plinfo[j].szName,
LENGTHOF(plinfo[j].szName),
mxlineSrc.szName);
/* Add to crossfader lists */
SendDlgItemMessage(hCFader,
IDC_SOURCE,
CB_ADDSTRING,
0,
(LPARAM) plinfo[j].szName);
SendDlgItemMessage(hCFader,
IDC_TARGET,
CB_ADDSTRING,
0,
(LPARAM) plinfo[j].szName);
if(plinfo[j].hCtrl = CreateDialogParam(pinfo->hInstance,
MAKEINTRESOURCE(IDD_MIXERCTRL),
hWnd,
(DLGPROC) MixerPlus_CtrlDlgProc,
(LPARAM) &plinfo[j]))
{
if(dwControlFlags & MIXERPLUS_LINE_CONTROL_FEED)
{
SetDlgItemText(plinfo[j].hCtrl, IDB_POWER, TEXT("Feed"));
EnableWindow(GetDlgItem(plinfo[j].hCtrl, IDB_POWER), TRUE);
}
GetWindowRect(plinfo[j].hCtrl, &rcCtrl);
MoveWindow(plinfo[j].hCtrl,
j * (rcCtrl.right - rcCtrl.left), 0,
rcCtrl.right - rcCtrl.left, rcCtrl.bottom - rcCtrl.top,
FALSE);
ShowWindow(plinfo[j].hCtrl, SW_SHOW);
}
}
/* Adjust window */
if(dwLines > 0 && hCFader)
{
/* Simulate feed control update if necessary */
if(dwControlFlags & MIXERPLUS_LINE_CONTROL_FEED)
SendMessage(hWnd,
MM_MIXM_CONTROL_CHANGE,
(WPARAM) hMixer,
(LPARAM) feed.dwID);
/* Initialize crossfader */
SendDlgItemMessage(hCFader,
IDC_SOURCE,
CB_SETCURSEL,
0, 0);
SendDlgItemMessage(hCFader,
IDC_TARGET,
CB_SETCURSEL,
0, 0);
GetWindowRect(hCFader, &rcCFader);
MoveWindow(hCFader,
0, rcCtrl.bottom - rcCtrl.top,
rcCFader.right - rcCFader.left, rcCFader.bottom - rcCFader.top,
FALSE);
ShowWindow(hCFader, SW_SHOW);
/* Resize main window */
rcWnd.left = 0;
rcWnd.top = 0;
rcWnd.right = MIXERPLUS_LINES_PER_VIEW * (rcCtrl.right - rcCtrl.left);
rcWnd.bottom = (rcCtrl.bottom - rcCtrl.top) + (rcCFader.bottom - rcCFader.top);
AdjustWindowRect(&rcWnd, WS_CAPTION, TRUE);
rcWnd.bottom += GetSystemMetrics(SM_CYHSCROLL);
SetWindowPos(hWnd,
HWND_TOP,
0, 0,
rcWnd.right - rcWnd.left,
rcWnd.bottom - rcWnd.top,
SWP_NOMOVE);
/* Set scroll range and position */
si.cbSize = sizeof(si);
si.fMask = SIF_RANGE | SIF_POS;
si.nMin = 0;
si.nMax = max(0, dwLines - MIXERPLUS_LINES_PER_VIEW);
si.nPos = 0;
SetScrollInfo(hWnd, SB_HORZ, &si, TRUE);
}
return 0;
case WM_DESTROY:
if(dwControlFlags & MIXERPLUS_LINE_CONTROL_FEED)
{
HeapFree(pinfo->hHeap, 0, feed.pmxcdtls_lt);
HeapFree(pinfo->hHeap, 0, feed.pmxcdtls_b);
}
/* BUG FIX: intermittent access violation on exit.
Do not free plinfo here, as the child windows
reference it during their WM_DESTROY processing,
occurs after this (see MSDN).
This is not a huge leak, as the heap is destroyed
immediately after the message loop.
*/
/*
if(plinfo)
HeapFree(pinfo->hHeap, 0, plinfo);
*/
if(hMixer)
mixerClose(hMixer);
/* Kill message loop */
PostQuitMessage(0);
return 0;
}
/* Pass message to default handler */
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
int WINAPI createCfgDlg()
{
g_is_back=0;
g_is_cancel=0;
HWND mainwnd = hMainWindow;
if (!mainwnd)
{
popstring(NULL);
pushstring("error finding mainwnd");
return 1; // cannot be used in silent mode unfortunately.
}
if (!g_stacktop || !*g_stacktop || !(pszFilename = (*g_stacktop)->text) || !pszFilename[0] || !ReadSettings())
{
popstring(NULL);
pushstring("error finding config");
return 1;
}
HWND childwnd=GetDlgItem(mainwnd,nRectId);
if (!childwnd)
{
popstring(NULL);
pushstring("error finding childwnd");
return 1;
}
hCancelButton = GetDlgItem(mainwnd,IDCANCEL);
hNextButton = GetDlgItem(mainwnd,IDOK);
hBackButton = GetDlgItem(mainwnd,3);
mySetWindowText(hCancelButton,pszCancelButtonText);
mySetWindowText(hNextButton,pszNextButtonText);
mySetWindowText(hBackButton,pszBackButtonText);
if (bBackEnabled!=-1) EnableWindow(hBackButton,bBackEnabled);
if (bCancelEnabled!=-1) EnableWindow(hCancelButton,bCancelEnabled);
if (bCancelShow!=-1) old_cancel_visible=ShowWindow(hCancelButton,bCancelShow?SW_SHOWNA:SW_HIDE);
HFONT hFont = (HFONT)mySendMessage(mainwnd, WM_GETFONT, 0, 0);
// Prevent WM_COMMANDs from being processed while we are building
g_done = 1;
RECT dialog_r;
int mainWndWidth, mainWndHeight;
hConfigWindow=CreateDialog(m_hInstance,MAKEINTRESOURCE(IDD_DIALOG1),mainwnd,cfgDlgProc);
if (hConfigWindow)
{
GetWindowRect(childwnd,&dialog_r);
MapWindowPoints(0, mainwnd, (LPPOINT) &dialog_r, 2);
mainWndWidth = dialog_r.right - dialog_r.left;
mainWndHeight = dialog_r.bottom - dialog_r.top;
SetWindowPos(
hConfigWindow,
0,
dialog_r.left,
dialog_r.top,
mainWndWidth,
mainWndHeight,
SWP_NOZORDER|SWP_NOACTIVATE
);
// Sets the font of IO window to be the same as the main window
mySendMessage(hConfigWindow, WM_SETFONT, (WPARAM)hFont, TRUE);
}
else
{
popstring(NULL);
pushstring("error creating dialog");
return 1;
}
// Init dialog unit conversion
HDC memDC = CreateCompatibleDC(GetDC(hConfigWindow));
SelectObject(memDC, hFont);
TEXTMETRIC tm;
GetTextMetrics(memDC, &tm);
int baseUnitY = tm.tmHeight;
SIZE size;
GetTextExtentPoint32(memDC,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", 52, &size);
int baseUnitX = (size.cx / 26 + 1) / 2;
DeleteDC(memDC);
BOOL fFocused = FALSE;
#define DEFAULT_STYLES (WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS)
for (int nIdx = 0; nIdx < nNumFields; nIdx++) {
static struct {
char* pszClass;
DWORD dwStyle;
DWORD dwRTLStyle;
DWORD dwExStyle;
DWORD dwRTLExStyle;
} ClassTable[] = {
{ "STATIC", // FIELD_LABEL
DEFAULT_STYLES,
DEFAULT_STYLES | SS_RIGHT,
WS_EX_TRANSPARENT,
WS_EX_TRANSPARENT | WS_EX_RTLREADING },
{ "STATIC", // FIELD_ICON
DEFAULT_STYLES | SS_ICON,
DEFAULT_STYLES | SS_ICON,
0,
WS_EX_RTLREADING },
{ "STATIC", // FIELD_BITMAP
DEFAULT_STYLES | SS_BITMAP | SS_CENTERIMAGE,
DEFAULT_STYLES | SS_BITMAP | SS_CENTERIMAGE,
0,
WS_EX_RTLREADING },
{ "BUTTON", // FIELD_BROWSEBUTTON
DEFAULT_STYLES | WS_TABSTOP,
DEFAULT_STYLES | WS_TABSTOP,
0,
WS_EX_RTLREADING },
{ "BUTTON", // FIELD_LINK
DEFAULT_STYLES | WS_TABSTOP | BS_OWNERDRAW,
DEFAULT_STYLES | WS_TABSTOP | BS_OWNERDRAW | BS_RIGHT,
0,
WS_EX_RTLREADING },
{ "BUTTON", // FIELD_BUTTON
DEFAULT_STYLES | WS_TABSTOP,
DEFAULT_STYLES | WS_TABSTOP,
0,
WS_EX_RTLREADING },
{ "BUTTON", // FIELD_GROUPBOX
DEFAULT_STYLES | BS_GROUPBOX,
DEFAULT_STYLES | BS_GROUPBOX | BS_RIGHT,
WS_EX_TRANSPARENT,
WS_EX_TRANSPARENT | WS_EX_RTLREADING },
{ "BUTTON", // FIELD_CHECKBOX
DEFAULT_STYLES | WS_TABSTOP | BS_TEXT | BS_VCENTER | BS_AUTOCHECKBOX | BS_MULTILINE,
DEFAULT_STYLES | WS_TABSTOP | BS_TEXT | BS_VCENTER | BS_AUTOCHECKBOX | BS_MULTILINE | BS_RIGHT | BS_LEFTTEXT,
0,
WS_EX_RTLREADING },
{ "BUTTON", // FIELD_RADIOBUTTON
DEFAULT_STYLES | WS_TABSTOP | BS_TEXT | BS_VCENTER | BS_AUTORADIOBUTTON | BS_MULTILINE,
DEFAULT_STYLES | WS_TABSTOP | BS_TEXT | BS_VCENTER | BS_AUTORADIOBUTTON | BS_MULTILINE | BS_RIGHT | BS_LEFTTEXT,
0,
WS_EX_RTLREADING },
{ "EDIT", // FIELD_TEXT
DEFAULT_STYLES | WS_TABSTOP | ES_AUTOHSCROLL,
DEFAULT_STYLES | WS_TABSTOP | ES_AUTOHSCROLL | ES_RIGHT,
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE,
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_RTLREADING },
{ "EDIT", // FIELD_FILEREQUEST
DEFAULT_STYLES | WS_TABSTOP | ES_AUTOHSCROLL,
DEFAULT_STYLES | WS_TABSTOP | ES_AUTOHSCROLL | ES_RIGHT,
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE,
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_RTLREADING },
{ "EDIT", // FIELD_DIRREQUEST
DEFAULT_STYLES | WS_TABSTOP | ES_AUTOHSCROLL,
DEFAULT_STYLES | WS_TABSTOP | ES_AUTOHSCROLL | ES_RIGHT,
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE,
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_RTLREADING },
{ "COMBOBOX", // FIELD_COMBOBOX
DEFAULT_STYLES | WS_TABSTOP | WS_VSCROLL | WS_CLIPCHILDREN | CBS_AUTOHSCROLL | CBS_HASSTRINGS,
DEFAULT_STYLES | WS_TABSTOP | WS_VSCROLL | WS_CLIPCHILDREN | CBS_AUTOHSCROLL | CBS_HASSTRINGS,
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE,
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_RIGHT | WS_EX_RTLREADING },
{ "LISTBOX", // FIELD_LISTBOX
DEFAULT_STYLES | WS_TABSTOP | WS_VSCROLL | LBS_DISABLENOSCROLL | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT,
DEFAULT_STYLES | WS_TABSTOP | WS_VSCROLL | LBS_DISABLENOSCROLL | LBS_HASSTRINGS | LBS_NOINTEGRALHEIGHT,
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE,
WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_RIGHT | WS_EX_RTLREADING }
};
FieldType *pField = pFields + nIdx;
#undef DEFAULT_STYLES
if (pField->nType < 1 || pField->nType > (sizeof(ClassTable) / sizeof(ClassTable[0])))
continue;
DWORD dwStyle, dwExStyle;
if (bRTL) {
dwStyle = ClassTable[pField->nType - 1].dwRTLStyle;
dwExStyle = ClassTable[pField->nType - 1].dwRTLExStyle;
}
else {
dwStyle = ClassTable[pField->nType - 1].dwStyle;
dwExStyle = ClassTable[pField->nType - 1].dwExStyle;
}
// Convert from dialog units
RECT rect;
rect.left = MulDiv(pField->rect.left, baseUnitX, 4);
rect.right = MulDiv(pField->rect.right, baseUnitX, 4);
rect.top = MulDiv(pField->rect.top, baseUnitY, 8);
rect.bottom = MulDiv(pField->rect.bottom, baseUnitY, 8);
if (pField->rect.left < 0)
rect.left += mainWndWidth;
if (pField->rect.right < 0)
rect.right += mainWndWidth;
if (pField->rect.top < 0)
rect.top += mainWndHeight;
if (pField->rect.bottom < 0)
rect.bottom += mainWndHeight;
if (bRTL) {
int right = rect.right;
rect.right = mainWndWidth - rect.left;
rect.left = mainWndWidth - right;
}
char *title = pField->pszText;
switch (pField->nType) {
case FIELD_ICON:
case FIELD_BITMAP:
title = NULL; // otherwise it is treated as the name of a resource
break;
case FIELD_CHECKBOX:
case FIELD_RADIOBUTTON:
dwStyle ^= pField->nFlags & BS_LEFTTEXT;
break;
case FIELD_TEXT:
case FIELD_FILEREQUEST:
case FIELD_DIRREQUEST:
if (pField->nFlags & FLAG_PASSWORD)
dwStyle |= ES_PASSWORD;
if (pField->nFlags & FLAG_ONLYNUMBERS)
dwStyle |= ES_NUMBER;
if (pField->nFlags & FLAG_WANTRETURN)
dwStyle |= ES_WANTRETURN;
if (pField->nFlags & FLAG_READONLY)
dwStyle |= ES_READONLY;
title = pField->pszState;
if (pField->nFlags & FLAG_MULTILINE)
{
dwStyle |= ES_MULTILINE | ES_AUTOVSCROLL;
// Enable word-wrap unless we have a horizontal scroll bar
// or it has been explicitly disallowed
if (!(pField->nFlags & (WS_HSCROLL | FLAG_NOWORDWRAP)))
dwStyle &= ~ES_AUTOHSCROLL;
ConvertNewLines(pField->pszState);
// If multiline-readonly then hold the text back until after the
// initial focus has been set. This is so the text is not initially
// selected - useful for License Page look-a-likes.
if (pField->nFlags & FLAG_READONLY)
title = NULL;
}
break;
case FIELD_COMBOBOX:
dwStyle |= (pField->nFlags & FLAG_DROPLIST) ? CBS_DROPDOWNLIST : CBS_DROPDOWN;
title = pField->pszState;
break;
case FIELD_LISTBOX:
dwStyle |= pField->nFlags & (LBS_NOTIFY | LBS_MULTIPLESEL | LBS_EXTENDEDSEL);
break;
}
dwStyle |= pField->nFlags & (WS_GROUP | WS_HSCROLL | WS_VSCROLL | WS_DISABLED);
if (pField->nFlags & WS_TABSTOP) dwStyle &= ~WS_TABSTOP;
HWND hwCtrl = pField->hwnd = CreateWindowEx(
dwExStyle,
ClassTable[pField->nType - 1].pszClass,
title,
dwStyle,
rect.left,
rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
hConfigWindow,
(HMENU)pField->nControlID,
m_hInstance,
NULL
);
if (hwCtrl) {
// Sets the font of IO window to be the same as the main window
mySendMessage(hwCtrl, WM_SETFONT, (WPARAM)hFont, TRUE);
// make sure we created the window, then set additional attributes
switch (pField->nType) {
case FIELD_TEXT:
case FIELD_FILEREQUEST:
case FIELD_DIRREQUEST:
mySendMessage(hwCtrl, EM_LIMITTEXT, (WPARAM)pField->nMaxLength, (LPARAM)0);
break;
case FIELD_CHECKBOX:
case FIELD_RADIOBUTTON:
if (pField->pszState[0] == '1')
mySendMessage(hwCtrl, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
break;
case FIELD_COMBOBOX:
case FIELD_LISTBOX:
// if this is a listbox or combobox, we need to add the list items.
if (pField->pszListItems) {
UINT nAddMsg, nFindMsg, nSetSelMsg;
if (pField->nType == FIELD_COMBOBOX) {
nAddMsg = CB_ADDSTRING;
nFindMsg = CB_FINDSTRINGEXACT;
nSetSelMsg = CB_SETCURSEL;
}
else {
nAddMsg = LB_ADDSTRING;
nFindMsg = LB_FINDSTRINGEXACT;
nSetSelMsg = LB_SETCURSEL;
}
char *pszStart, *pszEnd, *pszList;
pszStart = pszEnd = pszList = STRDUP(pField->pszListItems);
while ((*pszEnd) && (*pszStart)) {
if (*pszEnd == '|') {
*pszEnd = '\0';
if (pszEnd > pszStart) {
mySendMessage(hwCtrl, nAddMsg, 0, (LPARAM)pszStart);
}
// jump to the next item, skip any redundant | characters
do { pszEnd++; } while (*pszEnd == '|');
pszStart = pszEnd;
}
pszEnd++;
}
FREE(pszList);
if (pField->pszState) {
if (pField->nFlags & (LBS_MULTIPLESEL|LBS_EXTENDEDSEL) && nFindMsg == LB_FINDSTRINGEXACT) {
mySendMessage(hwCtrl, LB_SETSEL, FALSE, -1);
pszStart = pszEnd = pField->pszState;
while (*pszStart) {
char cLast = *pszEnd;
if (*pszEnd == '|') *pszEnd = '\0';
if (!*pszEnd) {
if (pszEnd > pszStart) {
int nItem = mySendMessage(hwCtrl, nFindMsg, -1, (LPARAM)pszStart);
if (nItem != CB_ERR) { // CB_ERR == LB_ERR == -1
mySendMessage(hwCtrl, LB_SETSEL, TRUE, nItem);
}
}
if (cLast) {
do {
pszEnd++;
} while (*pszEnd == '|');
}
pszStart = pszEnd;
}
pszEnd++;
}
}
else {
int nItem = mySendMessage(hwCtrl, nFindMsg, -1, (LPARAM)pField->pszState);
if (nItem != CB_ERR) { // CB_ERR == LB_ERR == -1
mySendMessage(hwCtrl, nSetSelMsg, nItem, 0);
}
}
}
}
break;
case FIELD_ICON:
case FIELD_BITMAP:
{
WPARAM nImageType = pField->nType == FIELD_BITMAP ? IMAGE_BITMAP : IMAGE_ICON;
LPARAM nImage = 0;
if (pField->pszText) {
pField->hImage = LoadImage(
m_hInstance,
pField->pszText,
nImageType,
(pField->nFlags & FLAG_RESIZETOFIT)
? (rect.right - rect.left)
: 0,
(pField->nFlags & FLAG_RESIZETOFIT)
? (rect.bottom - rect.top)
: 0,
LR_LOADFROMFILE
);
nImage = (LPARAM)pField->hImage;
}
else
nImage = (LPARAM)LoadIcon(GetModuleHandle(0), MAKEINTRESOURCE(103));
mySendMessage(
hwCtrl,
STM_SETIMAGE,
nImageType,
nImage
);
break;
}
#ifdef IO_ENABLE_LINK
case FIELD_LINK:
pField->nParentIdx = SetWindowLong(hwCtrl, GWL_WNDPROC, (long)StaticLINKWindowProc);
break;
#endif
}
// Set initial focus to the first appropriate field
if (!fFocused && (dwStyle & (WS_TABSTOP | WS_DISABLED)) == WS_TABSTOP && pField->nType >= FIELD_SETFOCUS) {
fFocused = TRUE;
mySetFocus(hwCtrl);
}
// If multiline-readonly then hold the text back until after the
// initial focus has been set. This is so the text is not initially
// selected - useful for License Page look-a-likes.
if ((pField->nFlags & (FLAG_MULTILINE | FLAG_READONLY)) == (FLAG_MULTILINE | FLAG_READONLY))
mySetWindowText(hwCtrl, pField->pszState);
}
}
if (!fFocused)
mySetFocus(hNextButton);
mySetWindowText(mainwnd,pszTitle);
pFilenameStackEntry = *g_stacktop;
*g_stacktop = (*g_stacktop)->next;
static char tmp[32];
wsprintf(tmp,"%d",hConfigWindow);
pushstring(tmp);
return 0;
}
void __declspec(dllexport) Init(HWND hwndParent, int string_size, TCHAR *variables, stack_t **stacktop, extra_parameters *extra)
{
HWND hwStartMenuSelect;
hwParent = hwndParent;
validate_filename = extra->validate_filename;
EXDLL_INIT();
extra->RegisterPluginCallback(g_hInstance, PluginCallback);
g_done = 0;
noicon = 0;
rtl = 0;
autoadd = 0;
text[0] = 0;
progname[0] = 0;
lastused[0] = 0;
checkbox[0] = 0;
g_hwStartMenuSelect = NULL;
{
hwChild = GetDlgItem(hwndParent, 1018);
if (!hwChild)
{
pushstring(_T("error finding childwnd"));
return;
}
popstring(buf);
while (buf[0] == _T('/'))
{
if (!lstrcmpi(buf+1, _T("noicon")))
{
noicon = 1;
}
else if (!lstrcmpi(buf+1, _T("rtl")))
{
rtl = 1;
}
else if (!lstrcmpi(buf+1, _T("text")))
{
popstring(text);
}
else if (!lstrcmpi(buf+1, _T("autoadd")))
{
autoadd = 1;
}
else if (!lstrcmpi(buf+1, _T("lastused")))
{
popstring(lastused);
}
else if (!lstrcmpi(buf+1, _T("checknoshortcuts")))
{
popstring(checkbox);
}
if (popstring(buf))
{
*buf = 0;
}
}
if (*buf)
{
lstrcpy(progname, buf);
}
else
{
pushstring(_T("error reading parameters"));
return;
}
hwStartMenuSelect = CreateDialog(g_hInstance, MAKEINTRESOURCE(IDD_DIALOG), hwndParent, dlgProc);
g_hwStartMenuSelect = hwStartMenuSelect;
if (!hwStartMenuSelect)
{
pushstring(_T("error creating dialog"));
return;
}
else
{
lpWndProcOld = (WNDPROC) SetWindowLongPtr(hwndParent, DWLP_DLGPROC, (LONG_PTR) ParentWndProc);
wsprintf(buf, _T("%u"), hwStartMenuSelect);
pushstring(buf);
}
}
}
void TRANSLATEOBJ::make_dialog(void)
{
display_toolbox(hDlg=CreateDialog(hInst, (LPCTSTR)IDD_TRANSLATEBOX, ghWndStatusbox, (DLGPROC)TranslateDlgHandler));
}
INT_PTR CALLBACK OptionsProc(HWND hdlg,UINT msg,WPARAM wparam,LPARAM lparam)
{
switch(msg){
case WM_INITDIALOG:{
DWORD style;
g_opHdlg=hdlg;
bOptionsInit=TRUE;
TranslateDialogDefault(hdlg);
if(g_iButtonsCount!=db_get_b(NULL, PLGNAME,"ButtonsCount", 0))
{
LOGFONT logFont;
HFONT hFont;
bNeedRestart=TRUE;
EnableWindow(GetDlgItem(hdlg,IDC_BUTTONSLIST),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_BLISTADD),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_BLISTREMOVE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_MENUTREE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_MTREEADD),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_MTREEREMOVE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_BUTTONNAME),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_MENUNAME),FALSE);
ShowWindow(GetDlgItem(hdlg,IDC_WARNING),SW_SHOW);
hFont = (HFONT)SendDlgItemMessage(hdlg, IDC_WARNING, WM_GETFONT, 0, 0);
GetObject(hFont, sizeof(logFont), &logFont);
logFont.lfWeight = FW_BOLD;
hFont = CreateFontIndirect(&logFont);
SendDlgItemMessage(hdlg, IDC_WARNING, WM_SETFONT, (WPARAM)hFont, 0);
break;
}
g_iOPButtonsCount=g_iButtonsCount;
hButtonsList=GetDlgItem(hdlg,IDC_BUTTONSLIST);
hMenuTree=GetDlgItem(hdlg,IDC_MENUTREE);
style = GetWindowLongPtr(hButtonsList,GWL_STYLE);
style |=TVS_NOHSCROLL;
SetWindowLongPtr(hButtonsList,GWL_STYLE, style);
style = GetWindowLongPtr(hMenuTree,GWL_STYLE);
style |=TVS_NOHSCROLL;
SetWindowLongPtr(hMenuTree,GWL_STYLE, style);
BuildButtonsList(hButtonsList);
if (!TreeView_GetCount(hButtonsList))
EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),FALSE);
mir_subclassWindow( GetDlgItem(hdlg,IDC_BUTTONNAME), EditSubclassProc);
mir_subclassWindow( GetDlgItem(hdlg,IDC_MENUNAME), EditSubclassProc);
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
CheckDlgButton(hdlg,IDC_RAUTOSEND,(g_bRClickAuto=db_get_b(NULL,PLGNAME,"RClickAuto",0)) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg,IDC_LAUTOSEND,(g_bLClickAuto=db_get_b(NULL,PLGNAME,"LClickAuto",0)) ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg,IDC_ENABLEQUICKMENU,(g_bQuickMenu=db_get_b(NULL, PLGNAME,"QuickMenu", 1)) ? BST_CHECKED : BST_UNCHECKED);
bOptionsInit=FALSE;
}break;
case WM_LBUTTONUP:
if(drag) {
TVHITTESTINFO hti;
HTREEITEM htiAfter=NULL;
ButtonData* bd=NULL;
TVITEM tvi;
RECT rc;
BYTE height;
BOOLEAN bAsChild = FALSE;
TreeView_SetInsertMark(hMenuTree, NULL, 0 );
ReleaseCapture();
SetCursor( LoadCursor( NULL, IDC_ARROW ));
hti.pt.x = ( SHORT )LOWORD( lparam );
hti.pt.y = ( SHORT )HIWORD( lparam );
ClientToScreen(hdlg,&hti.pt);
ScreenToClient(hMenuTree,&hti.pt);
TreeView_HitTest( hMenuTree, &hti );
if(TreeView_GetParent(hMenuTree,hti.hItem)&&TreeView_GetChild(hMenuTree,hDragItem))
break;
if(TreeView_GetChild(hMenuTree,hti.hItem)&&TreeView_GetChild(hMenuTree,hDragItem))
break;
if ( hti.flags & TVHT_ABOVE ) {
htiAfter = TVI_FIRST;
}
else
if ( hti.flags & ( TVHT_NOWHERE|TVHT_BELOW )) {
htiAfter = TVI_LAST;
}
else
if ( hti.flags & ( TVHT_ONITEM|TVHT_ONITEMRIGHT )) {
// check where over the item, the pointer is
if ( !TreeView_GetItemRect( hMenuTree, hti.hItem, &rc, FALSE )) {
drag=0;
break;
}
height = ( BYTE )( rc.bottom - rc.top );
if ( hti.pt.y - ( height / 3 ) < rc.top ) {
HTREEITEM hItem = hti.hItem;
if ( !( hti.hItem = TreeView_GetPrevSibling( hMenuTree, hItem )) ) {
if ( !( hti.hItem = TreeView_GetParent(hMenuTree, hItem )))
htiAfter = TVI_FIRST;
else
bAsChild = TRUE;
}
}
else
if ( hti.pt.y + ( height / 3 ) <= rc.bottom ) {
bAsChild = TRUE;
}
}
if(TreeView_GetChild(hMenuTree,hDragItem)&&bAsChild)
break;
if(hti.hItem){
tvi.hItem=hti.hItem;
tvi.mask=TVIF_PARAM |TVIF_HANDLE;
TreeView_GetItem(hMenuTree,&tvi);
if ((bd=(ButtonData*)tvi.lParam)&&(bd->fEntryOpType&QMF_EX_SEPARATOR))
bAsChild = FALSE;
}
if(TreeView_GetParent(hMenuTree,hti.hItem))
bAsChild = FALSE;
MoveItem( hDragItem, htiAfter?htiAfter:hti.hItem, bAsChild );
SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
drag=0;
}
break;
///////////////////////////////////
//From UserInfoEx by DeathAxe
//
case WM_MOUSEMOVE:
{
if (!drag) break;
{
TVHITTESTINFO hti;
hti.pt.x=(short)LOWORD(lparam);
hti.pt.y=(short)HIWORD(lparam);
ClientToScreen(hdlg,&hti.pt);
ScreenToClient(hMenuTree,&hti.pt);
TreeView_HitTest(hMenuTree,&hti);
if ( hti.flags & ( TVHT_ONITEM|TVHT_ONITEMRIGHT )) {
RECT rc;
BYTE height;
if ( TreeView_GetItemRect(hMenuTree, hti.hItem, &rc, FALSE )) {
height = ( BYTE )( rc.bottom - rc.top );
if ( hti.pt.y - ( height / 3 ) < rc.top ) {
SetCursor( LoadCursor( NULL, IDC_ARROW ));
TreeView_SetInsertMark( hMenuTree, hti.hItem, 0 );
}
else
if ( hti.pt.y + ( height / 3 ) > rc.bottom ) {
SetCursor( LoadCursor( NULL, IDC_ARROW ));
TreeView_SetInsertMark( hMenuTree, hti.hItem, 1 );
}
else {
TreeView_SetInsertMark( hMenuTree, NULL, 0 );
SetCursor( LoadCursor( GetModuleHandle(NULL), MAKEINTRESOURCE( 183 )) );
}
}
}
else {
if ( hti.flags & TVHT_ABOVE ) SendMessage( hMenuTree, WM_VSCROLL, MAKEWPARAM( SB_LINEUP, 0 ), 0 );
if ( hti.flags & TVHT_BELOW ) SendMessage( hMenuTree, WM_VSCROLL, MAKEWPARAM( SB_LINEDOWN, 0 ), 0 );
TreeView_SetInsertMark( hMenuTree, NULL, 0 );
}
}
}break;
/////////////
case WM_DESTROY:
if (g_varhelpDlg)
DestroyWindow(g_varhelpDlg);
g_varhelpDlg=NULL;
break;
case WM_NOTIFY:
switch(((LPNMHDR)lparam)->idFrom) {
case 0:
if (((LPNMHDR)lparam)->code == PSN_APPLY ) {
if (!bNeedRestart){
SetMenuEntryProperties(hdlg);
SaveMenuTree(hdlg);
}
db_set_b(NULL,PLGNAME,"RClickAuto",(BYTE)(g_bRClickAuto=IsDlgButtonChecked(hdlg,IDC_RAUTOSEND)));
db_set_b(NULL,PLGNAME,"LClickAuto",(BYTE)(g_bLClickAuto=IsDlgButtonChecked(hdlg,IDC_LAUTOSEND)));
db_set_b(NULL,PLGNAME,"QuickMenu",(BYTE)(g_bQuickMenu=IsDlgButtonChecked(hdlg,IDC_ENABLEQUICKMENU)));
return 1;
}
else if (((LPNMHDR)lparam)->code == PSN_RESET ) {
if (!bNeedRestart)
RestoreModuleData(hdlg);
return 1;
}
break;
case IDC_MENUTREE:
switch (((LPNMHDR)lparam)->code){
case TVN_KEYDOWN:{
TV_KEYDOWN* pTVKeyDown = (TV_KEYDOWN*) ((LPNMHDR)lparam);
if ( pTVKeyDown->wVKey == VK_F2 )
TreeView_EditLabel(hMenuTree,TreeView_GetSelection(hMenuTree));
else if ( pTVKeyDown->wVKey == VK_DELETE )
SendMessage(hdlg,WM_COMMAND,IDC_MTREEREMOVE,0);
}break;
case TVN_BEGINLABELEDITA:
case TVN_BEGINLABELEDITW:
hwndEdit=TreeView_GetEditControl(hMenuTree);
mir_subclassWindow(hwndEdit, LabelEditSubclassProc);
break;
case TVN_ENDLABELEDITA:
case TVN_ENDLABELEDITW:
{
TVITEM tvi;
ButtonData* bd=NULL;
TCHAR strbuf[256];
TCHAR szLabel[256];
tvi.pszText = strbuf;
tvi.cchTextMax = SIZEOF(strbuf);
tvi.mask=TVIF_TEXT |TVIF_HANDLE|TVIF_PARAM;
tvi.hItem=TreeView_GetSelection(hMenuTree);
TreeView_GetItem(hMenuTree,&tvi);
GetWindowText(hwndEdit, szLabel, SIZEOF(szLabel));
hwndEdit=NULL;
if (!_tcslen(szLabel)) break;
if (bd = (ButtonData*)tvi.lParam){
if (!_tcscmp(szLabel,_T("---"))) {
if(TreeView_GetChild(hMenuTree,tvi.hItem))
break;
else{
bd->fEntryOpType=QMF_EX_SEPARATOR;
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
}
}
else {
bd->fEntryOpType&=~QMF_EX_SEPARATOR;
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),TRUE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),TRUE);
SetDlgItemText(hdlg, IDC_MENUVALUE, bd->pszOpValue/*?bd->pszOpValue:bd->pszValue*/);
}
bd->pszOpName=mir_tstrdup(szLabel);
tvi.pszText=szLabel;
TreeView_SetItem(hMenuTree, &tvi);
SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
}
}break;
case NM_KILLFOCUS:
TreeView_EndEditLabelNow(hButtonsList, 1);
break;
case TVN_BEGINDRAGA:
case TVN_BEGINDRAGW:
SetCapture(hdlg);
drag=1;
hDragItem=((LPNMTREEVIEW)lparam)->itemNew.hItem;
TreeView_SelectItem(hMenuTree,hDragItem);
break;
case TVN_SELCHANGINGA:
case TVN_SELCHANGINGW:
{
TVITEM tvi;
HTREEITEM hti;
ButtonData* bd;
hti=TreeView_GetSelection(hMenuTree);
if (hti==NULL)
break;
tvi.hItem=hti;
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
TreeView_GetItem(hMenuTree,&tvi);
if (tvi.lParam == 0)
break;
bd = ( ButtonData* )tvi.lParam;
if (bd) {
TCHAR szValue[256];
GetDlgItemText(hdlg, IDC_MENUVALUE, szValue, SIZEOF(szValue));
if(_tcslen(szValue))
{
if(bd->pszOpValue&&(bd->pszOpValue!=bd->pszValue))
mir_free(bd->pszOpValue);
bd->pszOpValue=mir_tstrdup(szValue);
}
bd->bOpInQMenu=IsDlgButtonChecked(hdlg,IDC_INQMENU);
bd->bIsOpServName=IsDlgButtonChecked(hdlg,IDC_ISSERVNAME);
}
}break;
case TVN_SELCHANGEDA:
case TVN_SELCHANGEDW:
{
TVITEM tvi;
HTREEITEM hti;
ButtonData* bd=NULL;
hti=TreeView_GetSelection(hMenuTree);
if (hti==NULL)
break;
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
tvi.hItem=hti;
TreeView_GetItem(hMenuTree,&tvi);
bd = ( ButtonData* )tvi.lParam;
if (bd) {
if (!TreeView_GetChild(hMenuTree, tvi.hItem)&&!(bd->fEntryOpType&QMF_EX_SEPARATOR))
{
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),TRUE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),TRUE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),TRUE);
SetDlgItemText(hdlg, IDC_MENUVALUE, bd->pszOpValue/*?bd->pszOpValue:bd->pszValue*/);
}
else
{
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
if (!(bd->fEntryOpType&QMF_EX_SEPARATOR))
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
}
CheckDlgButton(hdlg,IDC_INQMENU,bd->bOpInQMenu ? BST_CHECKED : BST_UNCHECKED);
CheckDlgButton(hdlg,IDC_ISSERVNAME,bd->bIsOpServName ? BST_CHECKED : BST_UNCHECKED);
}
}
}break;
case IDC_BUTTONSLIST:
switch (((LPNMHDR)lparam)->code) {
case TVN_KEYDOWN:{
TV_KEYDOWN* pTVKeyDown = (TV_KEYDOWN*) ((LPNMHDR)lparam);
if ( pTVKeyDown->wVKey == VK_F2 )
TreeView_EditLabel(hButtonsList,TreeView_GetSelection(hButtonsList));
else if ( pTVKeyDown->wVKey == VK_DELETE )
SendMessage(hdlg,WM_COMMAND,IDC_BLISTREMOVE,0);
}break;
case TVN_BEGINLABELEDITA:
case TVN_BEGINLABELEDITW:
hwndEdit = TreeView_GetEditControl(hButtonsList);
mir_subclassWindow(hwndEdit, LabelEditSubclassProc);
break;
case TVN_ENDLABELEDITA:
case TVN_ENDLABELEDITW:
{
TVITEM tvi;
TCHAR strbuf[128];
TCHAR szLabel[128];
tvi.pszText = strbuf;
tvi.cchTextMax = SIZEOF(strbuf);
tvi.mask=TVIF_TEXT |TVIF_HANDLE|TVIF_PARAM;
tvi.hItem=TreeView_GetSelection(hButtonsList);
TreeView_GetItem(hButtonsList,&tvi);
GetWindowText(hwndEdit, szLabel, SIZEOF(szLabel));
hwndEdit=NULL;
if (!_tcslen(szLabel)) break;
tvi.pszText=szLabel;
((ListData*)tvi.lParam)->dwOPFlags|=QMF_RENAMED;
TreeView_SetItem(hButtonsList, &tvi);
SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
}break;
case TVN_SELCHANGINGA:
case TVN_SELCHANGINGW:
SetMenuEntryProperties(hdlg);
break;
case TVN_SELCHANGEDA:
case TVN_SELCHANGEDW:
{
TVITEM tvi;
HTREEITEM hti;
hti=TreeView_GetSelection(hButtonsList);
if(hti==NULL||!TreeView_GetCount(hButtonsList)) {
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME2),FALSE);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
break;
}
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
tvi.hItem=hti;
TreeView_GetItem(hButtonsList,&tvi);
if(tvi.lParam==0) break;
BuildMenuTree(hMenuTree,(SortedList *)((ListData*)tvi.lParam)->sl);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),TRUE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME2),TRUE);
CheckDlgButton(hdlg,IDC_ISSERVNAME2,((ListData*)tvi.lParam)->bIsOpServName ? BST_CHECKED : BST_UNCHECKED);
if (((ListData*)tvi.lParam)->ptszOPQValue)
SetDlgItemText(hdlg, IDC_RCLICKVALUE, ((ListData*)tvi.lParam)->ptszOPQValue);
else
SetDlgItemText(hdlg, IDC_RCLICKVALUE, _T(""));
}break;
}break;
}
break;
case WM_COMMAND:
switch(LOWORD(wparam)) {
case IDC_VARHELP:
if (!g_varhelpDlg)
g_varhelpDlg=CreateDialog(hinstance,MAKEINTRESOURCE(IDD_HELPDIALOG), 0, HelpDlgProc);
else
//ShowWindow(g_varhelpDlg,SW_SHOWDEFAULT);
SetWindowPos(g_varhelpDlg,0,0,0,0,0,SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE);
break;
case IDC_BLISTADD:
{
TVINSERTSTRUCT tvis;
ListData* ld=NULL;
TCHAR namebuff[MAX_PATH]={'\0'};
int count=TreeView_GetCount(hButtonsList);
if (count>10) break;
if(g_iOPButtonsCount==99){
MessageBox(NULL, TranslateT("Congratulation!\r\nYou have clicked this button 100 times!\r\nThere was access violation at this point...\r\nAnd now function for freeing resources must be called...\r\nBut no! there's only break :D"), TranslateT("You win!"),MB_OK);
break;
}
ld = (ListData *)mir_alloc(sizeof(ListData));
ButtonsList[g_iOPButtonsCount++]=ld;
ld->sl=List_Create(0,1);
ld->dwOPFlags=QMF_NEW;
ld->bIsOpServName=0;
ld->ptszButtonName=NULL;
ld->ptszOPQValue=NULL;
ld->ptszQValue=NULL;
tvis.hParent = NULL;
tvis.hInsertAfter = TVI_LAST;
GetDlgItemText(hdlg, IDC_BUTTONNAME, namebuff, SIZEOF(namebuff));
tvis.item.mask=TVIF_PARAM|TVIF_TEXT;
tvis.item.pszText=(_tcslen(namebuff))?namebuff:TranslateT("New Button");
tvis.item.lParam=(LPARAM)ld;
TreeView_SelectItem(hButtonsList,TreeView_InsertItem(hButtonsList,&tvis));
}break;
case IDC_BLISTREMOVE:
{
TVITEM tvi;
ListData* ld;
if (!(tvi.hItem=TreeView_GetSelection(hButtonsList)))
break;
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
TreeView_GetItem(hButtonsList,&tvi);
ld= (ListData*)tvi.lParam;
ld->dwOPFlags|=QMF_DELETNEEDED;
TreeView_DeleteItem(hButtonsList,tvi.hItem);
if (!TreeView_GetCount(hButtonsList)) {
TreeView_DeleteAllItems(hMenuTree);
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_RCLICKVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME2),FALSE);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
SetDlgItemText(hdlg, IDC_RCLICKVALUE, _T(""));
}
}break;
case IDC_MTREEADD:
{
TVINSERTSTRUCT tvis;
TVITEM tvi;
ButtonData *bd=NULL;
SortedList *sl=NULL;
TCHAR namebuff[MAX_PATH]={'\0'};
if (!TreeView_GetCount(hButtonsList)) break;
if (!(tvi.hItem=TreeView_GetSelection(hButtonsList))) break;
bd = (ButtonData *)mir_alloc(sizeof(ButtonData));
memset(bd,0,sizeof(ButtonData));
GetDlgItemText(hdlg, IDC_MENUNAME, namebuff, SIZEOF(namebuff));
bd->dwOPPos=TreeView_GetCount(hMenuTree)-1;
bd->pszOpName=_tcslen(namebuff)?mir_tstrdup(namebuff):mir_tstrdup(TranslateT("New Menu Entry"));
bd->pszOpValue=mir_tstrdup(bd->pszOpName);
bd->fEntryOpType=!_tcscmp(namebuff,_T("---"))?QMF_EX_SEPARATOR:0;
bd->dwOPFlags=QMF_NEW;
bd->pszName=NULL;
bd->pszValue=NULL;
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
TreeView_GetItem(hButtonsList,&tvi);
sl=((ListData*)tvi.lParam)->sl;
List_InsertPtr(sl,bd);
tvis.hParent = NULL;
tvis.hInsertAfter = TVI_LAST;
tvis.item.mask=TVIF_PARAM|TVIF_TEXT;
tvis.item.pszText=bd->pszOpName;
tvis.item.lParam=(LPARAM)bd;
TreeView_SelectItem(hMenuTree,TreeView_InsertItem(hMenuTree,&tvis));
}break;
case IDC_MTREEREMOVE:
{
TVITEM tvi;
TVINSERTSTRUCT tvis;
HTREEITEM hti=NULL;
ButtonData *bd=NULL;
tvi.mask=TVIF_HANDLE|TVIF_PARAM;
if (!(tvi.hItem=TreeView_GetSelection(hMenuTree)))
break;
TreeView_GetItem(hMenuTree,&tvi);
hti=tvi.hItem;
bd= (ButtonData*)tvi.lParam;
bd->dwOPFlags|=QMF_DELETNEEDED;
if(tvi.hItem=TreeView_GetChild(hMenuTree,tvi.hItem)) {
TCHAR strbuf[128];
while(tvi.hItem){
tvis.hInsertAfter=hti;
tvi.pszText = strbuf;
tvi.cchTextMax = SIZEOF(strbuf);
tvi.mask=TVIF_HANDLE|TVIF_PARAM|TVIF_TEXT;
TreeView_GetItem(hMenuTree,&tvi);
tvis.hParent=NULL;
tvis.item=tvi;
TreeView_InsertItem(hMenuTree,&tvis);
tvi.hItem=TreeView_GetNextSibling(hMenuTree,tvi.hItem);
}
}
TreeView_DeleteItem(hMenuTree,hti);
if (!TreeView_GetCount(hMenuTree)) {
EnableWindow(GetDlgItem(hdlg,IDC_MENUVALUE),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_ISSERVNAME),FALSE);
EnableWindow(GetDlgItem(hdlg,IDC_INQMENU),FALSE);
SetDlgItemText(hdlg, IDC_MENUVALUE, _T(""));
}
}break;
}
break;
case WM_CLOSE:
EndDialog(hdlg,0);
return 0;
}
if (HIWORD(wparam)==BN_CLICKED && GetFocus()==(HWND)lparam)
SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
else if ((HIWORD(wparam) == EN_CHANGE)&&(GetFocus()==(HWND)lparam))
if (!bOptionsInit) SendMessage(GetParent(hdlg),PSM_CHANGED,0,0);
return 0;
}
INT_PTR AddFeed(WPARAM wParam, LPARAM lParam)
{
hAddFeedDlg = CreateDialog(hInst, MAKEINTRESOURCE(IDD_ADDFEED), NULL, DlgProcAddFeedOpts);
ShowWindow(hAddFeedDlg, SW_SHOW);
return 0;
}
//============================================================================================
// MAIN
//============================================================================================
extern "C" int WINAPI WinMain( HINSTANCE hInstance, // handle to current instance
HINSTANCE hPrevInstance, // handle to previous instance
LPSTR lpCmdLine, // command line
int nCmdShow ){ // show state
TCHAR szTokens[] = "-/";
int iRes;
HWND hDlgWnd;
UINT uiTimerID;
HRESULT hr;
// Parse the command line for options
LPCTSTR lpszToken = FindOneOf(lpCmdLine, szTokens);
while (lpszToken != NULL) {
if (lstrcmpi(lpszToken, "UnregServer")==0) {
iRes = g_UnregisterCOM();
if( iRes != 0 ) {
MessageBox( NULL, "Error: Can't unregister server. g_UnregisterCOM() failed.", x_szTitle, MB_OK);
}
else {
MessageBox( NULL, "Success: the server is unregistered.", x_szTitle, MB_OK);
}
return iRes;
}
if (lstrcmpi(lpszToken, "RegServer")==0) {
iRes = g_RegisterCOM();
if( iRes != 0 ) {
MessageBox( NULL, "Error: Can't register server. g_RegisterCOM() failed.", x_szTitle, MB_OK);
}
else {
MessageBox( NULL, "Success: the server is registered.", x_szTitle, MB_OK);
}
return iRes;
}
lpszToken = FindOneOf(lpszToken, szTokens);
} // while there are tokens
//------- Windows staff starts here
CP_printfCreate(x_szTitle); // create console window
hDlgWnd=CreateDialog(hInstance, MAKEINTRESOURCE(IDD_MAIN_DIALOG),
NULL, x_DialogProc);
SetWindowText(hDlgWnd, x_szTitle);
SendMessage(hDlgWnd, WM_SETICON, ICON_BIG,
(LPARAM)LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON_APPL)));
SendMessage(hDlgWnd, WM_SETICON, ICON_SMALL,
(LPARAM)LoadImage(hInstance, MAKEINTRESOURCE(IDI_ICON_APPL), IMAGE_ICON, 16, 16, 0));
ShowWindow(hDlgWnd, SW_SHOW);
CP_printf(g_szVersion);
CP_printf("\n\n");
uiTimerID = SetTimer( hDlgWnd, TIMER_ID, TIMER_PERIOD_MS, NULL );
if ( uiTimerID == 0){
CP_printf("Error: could not create timer!"); // don't exit we are still functional
}
// Init COM using apartment-threaded model
hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
if( hr != S_OK) {
MessageBox( NULL, "Error in CoInitializeEx()", x_szTitle, MB_OK);
return 1;
}
iRes = g_Init_EyeTrack( );
if( iRes != 0 ) {
MessageBox( NULL, "Error: g_Init_EyeTrack() failed.", x_szTitle, MB_OK);
return 1;
}
// Message loop
MSG msg;
while (GetMessage(&msg, 0, 0, 0)) {
// Process dialog messages in IsDialogMessage() pass others to translate/dispatch
if(!IsDialogMessage(hDlgWnd,&msg)){
TranslateMessage(&msg);
DispatchMessage(&msg);
}
} // end of message loop
KillTimer( hDlgWnd, TIMER_ID);
CoUninitialize();
return 0;
}
//---------------------------------------------------------------------------
//WM_INITDIALOG:
void TfrmMain::wmInitdialog(WPARAM wParam, LPARAM lParam) {
HWND hCtrl;
//Taskbar and Window icon
SendMessage(m_hWnd, WM_SETICON, ICON_BIG, (LPARAM)IcoLib_GetIcon(ICO_PLUG_SSWINDOW1, true));
SendMessage(m_hWnd, WM_SETICON, ICON_SMALL, (LPARAM)IcoLib_GetIcon(ICO_PLUG_SSWINDOW2));
LPTSTR pt = mir_a2t(__PLUGIN_NAME);
SetWindowText(m_hWnd, pt);
mir_freeAndNil(pt);
// Headerbar
pt = mir_tstrdup((LPTSTR)CallService(MS_CLIST_GETCONTACTDISPLAYNAME, (WPARAM)m_hContact, (LPARAM)GCDNF_TCHAR));
if (pt && (m_hContact != 0)) {
LPTSTR lptString = NULL;
mir_tcsadd(lptString , TranslateT("Send screenshot to\n"));
mir_tcsadd(lptString , pt);
SetDlgItemText(m_hWnd, IDC_HEADERBAR, lptString);
mir_free(lptString);
}
mir_freeAndNil(pt);
SendMessage(GetDlgItem(m_hWnd, IDC_HEADERBAR), WM_SETICON, 0, (WPARAM)IcoLib_GetIcon(ICO_PLUG_SSWINDOW1, true));
//Timed controls
CheckDlgButton(m_hWnd,ID_chkTimed, m_opt_chkTimed ? BST_CHECKED : BST_UNCHECKED);
SetDlgItemInt (m_hWnd,ID_edtTimed, (UINT)m_opt_edtTimed, FALSE);
SendDlgItemMessage(m_hWnd, ID_upTimed, UDM_SETRANGE, 0, (LPARAM)MAKELONG(250, 1));
chkTimedClick(); //enable disable Timed controls
//create Image list for tab control
if(m_himlTab == 0) {
//m_himlTab = ImageList_Create(16, 16, PluginConfig.m_bIsXP ? ILC_COLOR32 | ILC_MASK : ILC_COLOR8 | ILC_MASK, 2, 0);
m_himlTab = ImageList_Create(16, 16, ILC_COLOR32 | ILC_MASK, 2, 0);
ImageList_AddIcon(m_himlTab, IcoLib_GetIcon(ICO_PLUG_SSWINDOW2));
ImageList_AddIcon(m_himlTab, IcoLib_GetIcon(ICO_PLUG_SSWINDOW2));
}
//create the tab control.
{
TAB_INFO itab;
RECT rcClient, rcTab;
m_hwndTab = GetDlgItem(m_hWnd, IDC_CAPTURETAB);
TabCtrl_SetItemExtra(m_hwndTab, sizeof(TAB_INFO) - sizeof(TCITEMHEADER));
ZeroMemory(&itab, sizeof(itab));
itab.hwndMain = m_hWnd;
itab.hwndTab = m_hwndTab;
GetWindowRect(m_hwndTab, &rcTab);
GetWindowRect(m_hWnd, &rcClient);
TabCtrl_SetImageList(m_hwndTab, m_himlTab);
// Add a tab for each of the three child dialog boxes.
itab.tcih.mask = TCIF_PARAM|TCIF_TEXT|TCIF_IMAGE;
itab.tcih.pszText = TranslateT("Window");
itab.tcih.iImage = 0;
itab.hwndTabPage = CreateDialog(hInst,MAKEINTRESOURCE(IDD_UMain_CaptureWindow), m_hWnd,DlgProc_CaptureWindow);
TabCtrl_InsertItem(m_hwndTab, 0, &itab);
MoveWindow(itab.hwndTabPage, (rcTab.left - rcClient.left)+2, (rcTab.top - rcClient.top), (rcTab.right - rcTab.left) - 2*5, (rcTab.bottom - rcTab.top) - 2*20, TRUE);
ShowWindow(itab.hwndTabPage, SW_HIDE);
CheckDlgButton(itab.hwndTabPage, ID_chkClientArea, m_opt_chkClientArea ? BST_CHECKED : BST_UNCHECKED);
itab.tcih.pszText = TranslateT("Desktop");
itab.tcih.iImage = 1;
itab.hwndTabPage = CreateDialog(hInst,MAKEINTRESOURCE(IDD_UMain_CaptureDesktop), m_hWnd, DlgProc_CaptureDesktop);
TabCtrl_InsertItem(m_hwndTab, 1, &itab);
MoveWindow(itab.hwndTabPage, (rcTab.left - rcClient.left)+2, (rcTab.top - rcClient.top), (rcTab.right - rcTab.left) - 2*5, (rcTab.bottom - rcTab.top) - 2*20, TRUE);
ShowWindow(itab.hwndTabPage, SW_HIDE);
hCtrl = GetDlgItem(itab.hwndTabPage, ID_edtCaption);
ComboBox_ResetContent(hCtrl);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("<Entire Desktop>")) ,0);
ComboBox_SetCurSel (hCtrl,0);
if(m_MonitorCount >1) {
TCHAR tszTemp[120];
for (size_t i = 0; i < m_MonitorCount; ++i) {
mir_sntprintf(tszTemp, SIZEOF(tszTemp),_T("%i. %s%s"),
i+1,
TranslateT("Monitor"),
(m_Monitors[i].dwFlags & MONITORINFOF_PRIMARY) ? TranslateT(" (primary)") : _T("")
);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, tszTemp) , i+1);
}
ComboBox_SelectItemData (hCtrl, -1, m_opt_cboxDesktop); //use Workaround for MS bug ComboBox_SelectItemData
}
PostMessage(m_hWnd, WM_COMMAND, MAKEWPARAM(ID_edtCaption, CBN_SELCHANGE),(LPARAM)hCtrl);
//select tab and set m_hwndTabPage
TabCtrl_SetCurSel(m_hwndTab, m_opt_tabCapture);
ZeroMemory(&itab, sizeof(itab));
itab.tcih.mask = TCIF_PARAM;
TabCtrl_GetItem(m_hwndTab,TabCtrl_GetCurSel(m_hwndTab),&itab);
ShowWindow(itab.hwndTabPage,SW_SHOW);
m_hwndTabPage = itab.hwndTabPage;
}
//init Format combo box
{
hCtrl = GetDlgItem(m_hWnd, ID_cboxFormat);
ComboBox_ResetContent(hCtrl);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, _T("PNG")),0);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, _T("JPG")),1);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, _T("BMP")),2);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, _T("TIF")),3);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, _T("GIF")),4);
ComboBox_SelectItemData (hCtrl, -1, m_opt_cboxFormat); //use Workaround for MS bug ComboBox_SelectItemData
}
//init SendBy combo box
{
hCtrl = GetDlgItem(m_hWnd, ID_cboxSendBy);
ComboBox_ResetContent(hCtrl);
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("<Only save>")) ,SS_JUSTSAVE);
if (m_hContact) {
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("File Transfer")),SS_FILESEND);
}
else if(m_opt_cboxSendBy == SS_FILESEND) {
m_opt_cboxSendBy = SS_IMAGESHACK;
}
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("E-mail")) ,SS_EMAIL);
if (myGlobals.PluginHTTPExist) {
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, _T("HTTP Server")) ,SS_HTTPSERVER);
}
else if(m_opt_cboxSendBy == SS_HTTPSERVER) {
m_opt_cboxSendBy = SS_IMAGESHACK;
}
if (myGlobals.PluginFTPExist) {
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("FTP File")) ,SS_FTPFILE);
}
else if(m_opt_cboxSendBy == SS_FTPFILE) {
m_opt_cboxSendBy = SS_IMAGESHACK;
}
ComboBox_SetItemData(hCtrl, ComboBox_AddString(hCtrl, TranslateT("ImageShack")) ,(BYTE)SS_IMAGESHACK);
ComboBox_SelectItemData (hCtrl, -1, m_opt_cboxSendBy); //use Workaround for MS bug ComboBox_SelectItemData
cboxSendByChange(); //enable disable controls
}
//init footer options
CheckDlgButton(m_hWnd,ID_chkOpenAgain, m_opt_chkOpenAgain ? BST_CHECKED : BST_UNCHECKED);
if (hCtrl = GetDlgItem(m_hWnd, ID_btnAbout)) {
SendDlgItemMessage(m_hWnd, ID_btnAbout, BUTTONADDTOOLTIP, (WPARAM)TranslateT("Information"), MBBF_TCHAR);
HICON hIcon = IcoLib_GetIcon(ICO_PLUG_SSHELP);
SendMessage(hCtrl, BM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
SetWindowText(hCtrl, hIcon ? _T("") : _T("?"));
}
if (hCtrl = GetDlgItem(m_hWnd, ID_btnExplore)) {
SendDlgItemMessage(m_hWnd, ID_btnExplore, BUTTONADDTOOLTIP, (WPARAM)TranslateT("Open Folder"), MBBF_TCHAR);
HICON hIcon = IcoLib_GetIcon(ICO_PLUG_SSFOLDERO);
SendMessage(hCtrl, BM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
SetWindowText(hCtrl, hIcon ? _T("") : _T("..."));
}
if (hCtrl = GetDlgItem(m_hWnd, ID_btnDesc)) {
SendDlgItemMessage(m_hWnd, ID_btnDesc, BUTTONADDTOOLTIP, (WPARAM)TranslateT("Fill description textbox."), MBBF_TCHAR);
HICON hIcon = IcoLib_GetIcon(m_opt_btnDesc ? ICO_PLUG_SSDESKON : ICO_PLUG_SSDESKOFF);
SendMessage(hCtrl, BM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
SetWindowText(hCtrl, hIcon ? _T("") : _T("D"));
SendMessage(hCtrl, BM_SETCHECK, m_opt_btnDesc ? BST_CHECKED : BST_UNCHECKED, NULL);
}
if (hCtrl = GetDlgItem(m_hWnd, ID_btnDeleteAfterSend)) {
SendDlgItemMessage(m_hWnd, ID_btnDeleteAfterSend, BUTTONADDTOOLTIP, (WPARAM)TranslateT("Delete after send"), MBBF_TCHAR);
HICON hIcon = IcoLib_GetIcon(m_opt_btnDeleteAfterSend ? ICO_PLUG_SSDELON : ICO_PLUG_SSDELOFF);
SendMessage(hCtrl, BM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
SetWindowText(hCtrl, hIcon ? _T("") : _T("X"));
SendMessage(hCtrl, BM_SETCHECK, m_opt_btnDeleteAfterSend ? BST_CHECKED : BST_UNCHECKED, NULL);
}
if (hCtrl = GetDlgItem(m_hWnd, ID_btnCapture)) {
SendDlgItemMessage(m_hWnd, ID_btnCapture, BUTTONADDTOOLTIP, (WPARAM)TranslateT("Capture"), MBBF_TCHAR);
HICON hIcon = IcoLib_GetIcon(ICO_PLUG_OK);
SendMessage(hCtrl, BM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
SetWindowText(hCtrl, TranslateT("&Capture"));
SendMessage(hCtrl, BUTTONSETDEFAULT, (WPARAM)1, NULL);
}
// CheckDlgButton(m_hWnd,ID_chkEditor, m_opt_chkEditor ? BST_CHECKED : BST_UNCHECKED);
TranslateDialogDefault(m_hWnd);
}
void ProgressBarDialog::show()
{
m_hDialog = CreateDialog ((HINSTANCE)GetCurrentModuleHandle(), MAKEINTRESOURCE (IDD_DIALOG1), 0, ProgressBarDialog::DialogProc);
}
HWND C_THISCLASS::conf(HINSTANCE hInstance, HWND hwndParent) // return NULL if no config dialog possible
{
g_ConfigThis = this;
return CreateDialog(hInstance,MAKEINTRESOURCE(IDD_CFG_BPM),hwndParent,g_DlgProc);
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
switch (message)
{
case WM_CREATE:
{
robinsonp = (char *)robinson;
timegoesbyp = (char *)timegoesby;
}
break;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
switch (wmId)
{
case IDM_TORISETTINGS: case IDM_YOMISETTINGS:
{
if(wmId == IDM_TORISETTINGS){
ChangeToriYomi(TORI);
}else{
ChangeToriYomi(YOMI);
}
DialogBox(hInst,MAKEINTRESOURCE(IDD_SETTINGS),hWnd,(DLGPROC)SettingsProc);
HDC hdc = GetDC(hWndMain);
LoadImageToDC(hdc,currentdesign);
ReleaseDC(hWndMain,hdc);
}
break;
case IDM_SAVEASIMAGE: case IDM_YOMIASIMAGE:
{
if(wmId == IDM_SAVEASIMAGE){
ChangeToriYomi(TORI);
}else{
ChangeToriYomi(YOMI);
}
DialogBox(hInst,MAKEINTRESOURCE(IDD_SAVEIMAGE),hWnd,(DLGPROC)SaveAsImageProc);
}
break;
case IDM_FUDADESIGN: case IDM_YOMIDESIGN:
{
if(wmId == IDM_FUDADESIGN){
ChangeToriYomi(TORI);
HWND hDlg = CreateDialog(hInst,MAKEINTRESOURCE(IDD_FUDADESIGN),hWnd,(DLGPROC)ToriDesignProc);
ShowWindow(hDlg,SW_SHOW);
}else{
ChangeToriYomi(YOMI);
HWND hDlg = CreateDialog(hInst,MAKEINTRESOURCE(IDD_YOMIDESIGN),hWnd,(DLGPROC)YomiDesignProc);
ShowWindow(hDlg,SW_SHOW);
}
}
break;
case IDM_FUDAOTOSI:
{
ChangeToriYomi(TORI);
CreateFudaOtositorifuda();
if(torifuda_of_fudaotosi.size() == 0){
if(IDYES!=MessageBox(hWnd,"貴方はすでに全ての札を覚えています。\r\nまた最初からやり直しますか？\r\n","確認",MB_YESNO)){
return 0;
};
ClearNigateFuda();
CreateFudaOtositorifuda();
}
HWND hDlg = CreateDialog(hInst,MAKEINTRESOURCE(IDD_FUDAOTOSI),hWnd,(DLGPROC)FudaOtosiProc);
ShowWindow(hDlg,SW_SHOW);
}
break;
case IDM_VERSION:
DialogBox(hInst,MAKEINTRESOURCE(IDD_VERSION),hWnd,(DLGPROC)VersionProc);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_PAINT:{
hdc = BeginPaint(hWnd, &ps);
if(front_structure.hdc != NULL){
int width, height;
width = currentdesign.width;
height = currentdesign.height;
HBITMAP hold1 = (HBITMAP)SelectObject(front_structure.hdc,front_structure.hbmp);
HBITMAP hCurrentBMP = CreateCompatibleBitmap(hdc,width,height);
HBITMAP hold = (HBITMAP)SelectObject(hdc,hCurrentBMP);
BitBlt(hdc,0,0,width,height,front_structure.hdc,0,0,SRCCOPY);
SelectObject(hdc,hold);
SelectObject(front_structure.hdc,hold1);
DeleteObject(hCurrentBMP);
}
EndPaint(hWnd, &ps);
}
break;
case WM_DESTROY:
tori_or_yomi = TORI;
SaveToIniFile(0, ¤tdesign);
tori_or_yomi = YOMI;
SaveToIniFile(0, ¤tdesign);
DeleteFile("bg_image\\tori_current.img");
DeleteFile("bg_image\\yomi_current.img");
PostQuitMessage(0);
break;
case WM_KEYDOWN:
{
// robinson
if(robinsonp != NULL){
if(wParam == *robinsonp){
robinsonp ++;
}else{
robinsonp = (char *)robinson;
}
if(*robinsonp == '\0'){
robinsonp = (char *)robinson;
HMODULE hmd = GetModuleHandle("gdiplus.dll");
if(hmd == NULL){
MessageBox(hWnd,"GDI+ には対応していません","(@_@)",MB_OK);
}else{
if(!gdiplus_useable){
gdiplus_useable = 1;
SetWindowText(hWnd,"GDI+: ON");
}else{
gdiplus_useable = 0;
SetWindowText(hWnd,"GDI+: OFF");
}
HDC hdc = GetDC(hWndMain);
LoadImageToDC(hdc,currentdesign);
ReleaseDC(hWndMain,hdc);
UpdateMainWindow(FALSE);
}
}
}
// timegoesby
if(timegoesbyp != NULL){
if(wParam == *timegoesbyp){
timegoesbyp ++;
}else{
timegoesbyp = (char *)timegoesby;
}
if(*timegoesbyp == '\0'){
timegoesbyp = (char *)timegoesby;
std::string buf;
int maxbpp, minbpp;
buf += GetMaxMinDisplayColors(&maxbpp,&minbpp);
char b[16];
wsprintf(b,"%d",maxbpp);
buf += b;
buf += " ビットに変更 -> [はい]\r\n";
wsprintf(b,"%d",minbpp);
buf += b;
buf += " ビットに変更 -> [いいえ]\r\n";
int r = MessageBox(hWnd,buf.c_str(),"(^θ^)",MB_YESNOCANCEL);
if( r == IDYES || r == IDNO){
DEVMODE dv;
ZeroMemory(&dv,sizeof(DEVMODE));
dv.dmSize = sizeof(DEVMODE);
dv.dmFields = DM_BITSPERPEL;
if(r == IDYES){
dv.dmBitsPerPel = maxbpp;
}else{
dv.dmBitsPerPel = minbpp;
}
ChangeDisplaySettings(&dv,0);
}
}
}
}
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
void CONSTANTOBJ::make_dialog(void)
{
display_toolbox(hDlg=CreateDialog(hInst, (LPCTSTR)IDD_CONSTANTBOX, ghWndStatusbox, (DLGPROC)ConstantDlgHandler));
}
INT_PTR CALLBACK PhSipCpuDialogProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
PPH_LAYOUT_ITEM graphItem;
PPH_LAYOUT_ITEM panelItem;
WCHAR brandString[49];
PhSipInitializeCpuDialog();
CpuDialog = hwndDlg;
PhInitializeLayoutManager(&CpuLayoutManager, hwndDlg);
PhAddLayoutItem(&CpuLayoutManager, GetDlgItem(hwndDlg, IDC_CPUNAME), NULL, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT | PH_LAYOUT_FORCE_INVALIDATE);
graphItem = PhAddLayoutItem(&CpuLayoutManager, GetDlgItem(hwndDlg, IDC_GRAPH_LAYOUT), NULL, PH_ANCHOR_ALL);
CpuGraphMargin = graphItem->Margin;
panelItem = PhAddLayoutItem(&CpuLayoutManager, GetDlgItem(hwndDlg, IDC_LAYOUT), NULL, PH_ANCHOR_LEFT | PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
SendMessage(GetDlgItem(hwndDlg, IDC_TITLE), WM_SETFONT, (WPARAM)CpuSection->Parameters->LargeFont, FALSE);
SendMessage(GetDlgItem(hwndDlg, IDC_CPUNAME), WM_SETFONT, (WPARAM)CpuSection->Parameters->MediumFont, FALSE);
PhSipGetCpuBrandString(brandString);
SetDlgItemText(hwndDlg, IDC_CPUNAME, brandString);
CpuPanel = CreateDialog(PhInstanceHandle, MAKEINTRESOURCE(IDD_SYSINFO_CPUPANEL), hwndDlg, PhSipCpuPanelDialogProc);
ShowWindow(CpuPanel, SW_SHOW);
PhAddLayoutItemEx(&CpuLayoutManager, CpuPanel, NULL, PH_ANCHOR_LEFT | PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM, panelItem->Margin);
PhSipCreateCpuGraphs();
if (NumberOfProcessors != 1)
{
OneGraphPerCpu = (BOOLEAN)PhGetIntegerSetting(L"SysInfoWindowOneGraphPerCpu");
Button_SetCheck(GetDlgItem(CpuPanel, IDC_ONEGRAPHPERCPU), OneGraphPerCpu ? BST_CHECKED : BST_UNCHECKED);
PhSipSetOneGraphPerCpu();
}
else
{
OneGraphPerCpu = FALSE;
EnableWindow(GetDlgItem(CpuPanel, IDC_ONEGRAPHPERCPU), FALSE);
PhSipSetOneGraphPerCpu();
}
PhSipUpdateCpuGraphs();
PhSipUpdateCpuPanel();
}
break;
case WM_DESTROY:
{
PhDeleteLayoutManager(&CpuLayoutManager);
}
break;
case WM_SIZE:
{
PhLayoutManagerLayout(&CpuLayoutManager);
PhSipLayoutCpuGraphs();
}
break;
case WM_NOTIFY:
{
NMHDR *header = (NMHDR *)lParam;
ULONG i;
if (header->hwndFrom == CpuGraphHandle)
{
PhSipNotifyCpuGraph(-1, header);
}
else
{
for (i = 0; i < NumberOfProcessors; i++)
{
if (header->hwndFrom == CpusGraphHandle[i])
{
PhSipNotifyCpuGraph(i, header);
break;
}
}
}
}
break;
}
return FALSE;
}
void MakeLogWindow(void)
{
if(!logwin)
CreateDialog(fceu_hInstance,"MESSAGELOG",0,LogCon);
}
//.........................................................
BOOL OnInitAdvancedDialog(void)
{
DWORD dwResult,
dWord;
HWND hChild;
int index = -1;
TCHAR buffer[64];
RECT r;
POINT point;
// NOTE==> IF ANYTHING ON THIS PAGE IS MOVED TAKE INTO CONSIDERATION
// THAT THIS SETTING IS USED TO TELL WHAT HAS NOT CHANGED ON
// RETURN FROM THE PROPERTY PAGE CALL
//#ifdef WIN32
m_bAdvancedPageHit = TRUE;
//#endif
// Get the coordinates of area for the settings dialogs
hSettingsListbox = GetDlgItem(hAdvanced, IDC_SETTINGS_LIST);
GetWindowRect(hSettingsListbox, &r);
point.x = r.right + 10;
point.y = r.top - 6;
ScreenToClient(hAdvanced, &point);
// Error Log
dWord = sizeof(errorLog);
dwResult = PALGetObject(hPeripheral, OT_PERIPHERAL_ERROR_LOG, 0, &errorLog, &dWord);
if (dwResult IS RC_SUCCESS)
{
LoadString(hInstance, IDS_ERROR_LOG, buffer, SIZEOF_IN_CHAR(buffer));
index = ListBox_AddString(hSettingsListbox, buffer);
ListBox_SetItemData(hSettingsListbox, index, (LPARAM)IDI_ERROR_LOG);
hErrLogDlg = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_ADV_ERROR_LOG), hAdvanced, AdvErrorLogSheetProc);
TRACE0(TEXT("HPPRUI: hErrLogDlg Created\r\n"));
SetWindowPos(hErrLogDlg, NULL, point.x, point.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
hChild = GetWindow(hErrLogDlg, GW_CHILD);
while (hChild)
{
SetWindowFont(hChild, hFont, TRUE);
hChild = GetWindow(hChild, GW_HWNDNEXT);
}
}
if ( ( pjlFeatures.jamRecovery & SETTING_SUPPORTED ) OR
( pjlFeatures.autoCont & SETTING_SUPPORTED ) OR
( pjlFeatures.clearableWarnings & SETTING_SUPPORTED ) )
{
LoadString(hInstance, IDS_ERROR_HANDLING, buffer, SIZEOF_IN_CHAR(buffer));
index = ListBox_AddString(hSettingsListbox, buffer);
ListBox_SetItemData(hSettingsListbox, index, (LPARAM)IDI_ERROR_HANDLING);
hErrorsDlg = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_ADV_ERROR_HANDLING), hAdvanced, AdvErrorsSheetProc);
TRACE0(TEXT("HPPRUI: hErrorsDlg Created\r\n"));
SetWindowPos(hErrorsDlg, NULL, point.x, point.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
hChild = GetWindow(hErrorsDlg, GW_CHILD);
while (hChild)
{
SetWindowFont(hChild, hFont, TRUE);
hChild = GetWindow(hChild, GW_HWNDNEXT);
}
}
if ( ( pjlFeatures.resourceSave & SETTING_SUPPORTED ) OR
( pjlFeatures.IObuffer & SETTING_SUPPORTED ) OR
( pjlFeatures.pageProtect & SETTING_SUPPORTED ) OR
( pjlFeatures.powerSave & SETTING_SUPPORTED ) )
{
LoadString(hInstance, IDS_MEMORY, buffer, SIZEOF_IN_CHAR(buffer));
index = ListBox_AddString(hSettingsListbox, buffer);
ListBox_SetItemData(hSettingsListbox, index, (LPARAM)IDI_MEMORY);
hMemoryDlg = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_ADV_MEMORY), hAdvanced, AdvMemorySheetProc);
TRACE0(TEXT("HPPRUI: hMemoryDlg Created\r\n"));
SetWindowPos(hMemoryDlg, NULL, point.x, point.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
hChild = GetWindow(hMemoryDlg, GW_CHILD);
while (hChild)
{
SetWindowFont(hChild, hFont, TRUE);
hChild = GetWindow(hChild, GW_HWNDNEXT);
}
}
if ( ( pjlFeatures.cpLock & SETTING_SUPPORTED ) OR
( pjlFeatures.passWord & SETTING_SUPPORTED ) )
{
LoadString(hInstance, IDS_SECURITY, buffer, SIZEOF_IN_CHAR(buffer));
index = ListBox_AddString(hSettingsListbox, buffer);
ListBox_SetItemData(hSettingsListbox, index, (LPARAM)IDI_SECURITY);
hSecurityDlg = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_ADV_SECURITY), hAdvanced, AdvSecuritySheetProc);
TRACE0(TEXT("HPPRUI: hSecurityDlg Created\r\n"));
SetWindowPos(hSecurityDlg, NULL, point.x, point.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
hChild = GetWindow(hSecurityDlg, GW_CHILD);
while (hChild)
{
SetWindowFont(hChild, hFont, TRUE);
hChild = GetWindow(hChild, GW_HWNDNEXT);
}
}
if( ( pjlFeatures.personality & SETTING_SUPPORTED ) OR
( pjlFeatures.timeout & SETTING_SUPPORTED ) OR
( pjlFeatures.lang & SETTING_SUPPORTED ) )
{
LoadString(hInstance, IDS_SETUP, buffer, SIZEOF_IN_CHAR(buffer));
index = ListBox_AddString(hSettingsListbox, buffer);
ListBox_SetItemData(hSettingsListbox, index, (LPARAM)IDI_SETUP);
hSetupDlg = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_ADV_SETUP), hAdvanced, AdvSetupSheetProc);
TRACE0(TEXT("HPPRUI: hSetupDlg Created\r\n"));
SetWindowPos(hSetupDlg, NULL, point.x, point.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
hChild = GetWindow(hSetupDlg, GW_CHILD);
while (hChild)
{
SetWindowFont(hChild, hFont, TRUE);
hChild = GetWindow(hChild, GW_HWNDNEXT);
}
}
if( ( pjlFeatures.jobOffset & SETTING_SUPPORTED ) OR
( pjlFeatures.outbin & SETTING_SUPPORTED ) )
{
LoadString(hInstance, IDS_OUTPUT, buffer, SIZEOF_IN_CHAR(buffer));
index = ListBox_AddString(hSettingsListbox, buffer);
ListBox_SetItemData(hSettingsListbox, index, (LPARAM)IDI_OUTPUT);
hOutputDlg = CreateDialog(hInstance, MAKEINTRESOURCE(IDD_ADV_OUTPUT), hAdvanced, AdvOutputSheetProc);
TRACE0(TEXT("HPPRUI: hOutputDlg Created\r\n"));
SetWindowPos(hOutputDlg, NULL, point.x, point.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
hChild = GetWindow(hOutputDlg, GW_CHILD);
while (hChild)
{
SetWindowFont(hChild, hFont, TRUE);
hChild = GetWindow(hChild, GW_HWNDNEXT);
}
}
ListBox_SetCurSel(hSettingsListbox, 0);
return(TRUE);
}
INT_PTR ExportFeeds(WPARAM wParam, LPARAM lParam)
{
CreateDialog(hInst, MAKEINTRESOURCE(IDD_FEEDEXPORT), NULL, DlgProcExportOpts);
return 0;
}
//
// function: MainWndHandler(HWND, unsigned, WORD, LONG)
//
// purpose: make initialisations (globals, Def-TTY settings)
// create Toolbox Dialog
//
// process Menu Selections
// load/save Config
// play/capture Archive
// open midi-device
// change com settings
// connect/disconnect to EEG-amp
// load/save Config
//
// scale and paint the channel-oscilloscope
//
//
//
LRESULT CALLBACK MainWndHandler(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
char sztemp[256];
switch( message )
{
case WM_CREATE:
break;
case WM_ENABLE:
if ((wParam==TRUE) && (NB_OBJ != NULL))
{
NB_OBJ->update_channelinfo();
NB_OBJ=NULL;
}
break;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Menüauswahlen analysieren:
switch( wmId )
{
case IDM_NEWCONFIG:
stop_timer();
TTY.read_pause=1;
//BreakDownCommPort();
CAPTFILE.do_read=0;
close_captfile();
if (ghWndAnimation!=NULL) SendMessage(ghWndAnimation,WM_CLOSE,0,0);
ghWndAnimation=NULL;
close_toolbox();
write_logfile("new config: deleting all objects.");
while (GLOBAL.objects>0)
free_object(0);
deviceobject=NULL;
GLOBAL.showdesign=TRUE;
ShowWindow(ghWndDesign,TRUE);
SetWindowPos(ghWndDesign,HWND_TOP,0,0,0,0,SWP_DRAWFRAME|SWP_NOMOVE|SWP_NOSIZE);
SetDlgItemText(ghWndStatusbox,IDC_DESIGN,"Hide Design");
GLOBAL.hidestatus=FALSE;
ShowWindow(ghWndStatusbox,TRUE);
SetWindowText(ghWndMain,"BrainBay");
GLOBAL.configfile[0]=0;
init_system_time(); PACKET.readstate=0;
GLOBAL.session_length=0;
SetDlgItemText(ghWndStatusbox,IDC_STATUS,"ready.");
SetDlgItemInt(ghWndStatusbox,IDC_SAMPLINGRATE,PACKETSPERSECOND,0);
SetDlgItemText(ghWndStatusbox,IDC_STATUS,"Configuration loaded");
SetDlgItemText(ghWndStatusbox,IDC_TIME,"0.0");
SetDlgItemText(ghWndStatusbox,IDC_JUMPPOS,"0.0");
SetDlgItemText(ghWndStatusbox,IDC_SESSLEN,"0.0");
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETPOS,TRUE,(LONG)0);
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETSELEND,TRUE,(LONG)0);
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETSELSTART,TRUE,(LONG)0);
InvalidateRect(ghWndDesign,NULL,TRUE);
InvalidateRect(ghWndMain,NULL,TRUE);
break;
case IDM_SAVECONFIG:
{
char configfilename[MAX_PATH];
int save_toolbox=GLOBAL.showtoolbox;
close_toolbox();
GLOBAL.showtoolbox=save_toolbox;
strcpy(configfilename,GLOBAL.resourcepath);
if (GLOBAL.configfile[0]==0)
strcat(configfilename,"CONFIGURATIONS\\*.con");
else strcpy(configfilename,GLOBAL.configfile);
if (open_file_dlg(hWnd,configfilename, FT_CONFIGURATION, OPEN_SAVE))
{
if (!save_configfile(configfilename)) report_error("Could not save Config File");
else
{
char * d_name,new_name[80];
write_logfile("configruation saved.");
d_name=configfilename;
while (strstr(d_name,"\\")) d_name=strstr(d_name,"\\")+1;
strcpy(new_name,"BrainBay - ");strcat(new_name,d_name);
SetWindowText(ghWndMain,new_name);
}
}
if (GLOBAL.showtoolbox!=-1)
{
actobject=objects[GLOBAL.showtoolbox];
actobject->make_dialog();
}
}
break;
case IDM_LOADCONFIG:
{
char configfilename[MAX_PATH];
close_toolbox();
strcpy(configfilename,GLOBAL.resourcepath);
strcat(configfilename,"CONFIGURATIONS\\*.con");
if (open_file_dlg(hWnd,configfilename, FT_CONFIGURATION, OPEN_LOAD))
{
write_logfile("load config: free existing objects.");
if (!load_configfile(configfilename)) report_error("Could not load Config File");
else sort_objects();
}
}
break;
case IDM_ABOUT:
close_toolbox();
DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)AboutDlgHandler);
break;
case IDM_HELP:
{
char tmpfile [250];
close_toolbox();
strcpy(tmpfile,GLOBAL.resourcepath);
strcat(tmpfile,"brainbay_user_manual.pdf");
ShellExecute(0, "open", tmpfile, NULL, NULL, SW_SHOWNORMAL);
}
break;
case IDM_VIEWLASTLOGFILE:
{
char tmpfile [250];
close_toolbox();
strcpy(tmpfile,GLOBAL.resourcepath);
strcat(tmpfile,"bbay.log");
ShellExecute(0, "open", tmpfile, NULL, NULL, SW_SHOWNORMAL);
}
break;
case IDM_EXIT:
DestroyWindow( hWnd );
break;
case IDM_PLAY:
SendMessage(ghWndStatusbox,WM_COMMAND, IDC_RUNSESSION,0);
break;
case IDM_STOP:
SendMessage(ghWndStatusbox,WM_COMMAND, IDC_STOPSESSION,0);
break;
case IDM_NEUROSERVER:
strcpy(sztemp,GLOBAL.resourcepath);
strcat(sztemp,"NETWORK\\nsd.exe");
ShellExecute(hWnd, "open", sztemp, NULL, NULL, SW_SHOWNORMAL);
break;
case IDM_READEDF:
{
char edffilename[MAX_PATH];
close_toolbox();
strcpy(edffilename,GLOBAL.resourcepath);
strcat(edffilename,"ARCHIVES\\*.edf");
if (open_file_dlg(hWnd,edffilename, FT_EDF, OPEN_LOAD))
{
strcpy(sztemp,GLOBAL.resourcepath);
strcat(sztemp,"NETWORK\\readedf.exe");
ShellExecute(hWnd, NULL, sztemp, edffilename, NULL, SW_SHOWNORMAL);
}
}
break;
case IDM_EDITCOLORS:
close_toolbox();
display_toolbox(CreateDialog(hInst, (LPCTSTR)IDD_EDITCOLORBOX, ghWndStatusbox, (DLGPROC)COLORDlgHandler));
break;
case IDM_EDITSCALES:
close_toolbox();
display_toolbox(CreateDialog(hInst, (LPCTSTR)IDD_EDITSCALEBOX, ghWndStatusbox, (DLGPROC)SCALEDlgHandler));
break;
case IDM_SETTINGS:
if (ghWndSettings==NULL) ghWndSettings=CreateDialog(hInst, (LPCTSTR)IDD_SETTINGSBOX, ghWndStatusbox, (DLGPROC)SETTINGSDlgHandler);
else SetForegroundWindow(ghWndSettings);
break;
case IDM_DEVICESETTINGS:
if (deviceobject)
{
close_toolbox();
actobject=deviceobject;
// GLOBAL.showtoolbox=find_object(devicebox);
actobject->make_dialog();
if (actobject->displayWnd)
SetWindowPos(actobject->displayWnd,HWND_TOP,0,0,0,0,SWP_DRAWFRAME|SWP_NOMOVE|SWP_NOSIZE);
} else report ("No Amplifier Device present in the design");
break;
case IDM_INSERTMIDI: create_object(OB_MIDI);
break;
case IDM_INSERTSPECTRUM: create_object(OB_FFT);
break;
case IDM_INSERTTHRESHOLD: create_object(OB_THRESHOLD);
break;
case IDM_INSERTFILTER: create_object(OB_FILTER);
break;
case IDM_INSERTMAGNITUDE:create_object(OB_MAGNITUDE);
break;
case IDM_INSERTPARTICLE:create_object(OB_PARTICLE);
break;
case IDM_INSERTOSCI:create_object(OB_OSCI);
break;
case IDM_INSERTTRANSLATE:create_object(OB_TRANSLATE);
break;
case IDM_INSERTSIGNAL:create_object(OB_SIGNAL);
break;
case IDM_INSERTAND:create_object(OB_AND);
break;
case IDM_INSERTOR:create_object(OB_OR);
break;
case IDM_INSERTNOT:create_object(OB_NOT);
break;
case IDM_INSERTWAV:
if (!count_objects(OB_WAV)) create_object(OB_WAV);
else report_error("Currently only one Sound player is supported.");
break;
case IDM_INSERTTCPRECEIVER:create_object(OB_TCP_RECEIVER);
break;
case IDM_INSERTDOKU:create_object(OB_DOKU);
break;
case IDM_INSERTEVAL:create_object(OB_EVAL);
break;
case IDM_INSERTAVI:create_object(OB_AVI);
break;
case IDM_INSERTAVERAGE:create_object(OB_AVERAGE);
break;
case IDM_INSERTCORR:create_object(OB_CORR);
break;
case IDM_INSERTEDFWRITER:create_object(OB_EDF_WRITER);
break;
case IDM_INSERTTCPSENDER:create_object(OB_TCP_SENDER);
break;
case IDM_INSERTEDFREADER:create_object(OB_EDF_READER);
break;
case IDM_INSERTCOMPARE:create_object(OB_COMPARE);
break;
case IDM_INSERTBALLGAME:create_object(OB_BALLGAME);
break;
case IDM_INSERTMIXER4:create_object(OB_MIXER4);
break;
case IDM_INSERTMOUSE:create_object(OB_MOUSE);
break;
case IDM_INSERTERPDETECT:create_object(OB_ERPDETECT);
break;
case IDM_INSERTCOM_WRITER:create_object(OB_COM_WRITER);
break;
case IDM_INSERTCAM:
if (!count_objects(OB_CAM)) create_object(OB_CAM);
break;
case IDM_INSERTINTEGRATE:create_object(OB_INTEGRATE);
break;
case IDM_INSERTDEBOUNCE:create_object(OB_DEBOUNCE);
break;
case IDM_INSERTSAMPLE_HOLD:create_object(OB_SAMPLE_HOLD);
break;
case IDM_INSERTCONSTANT:create_object(OB_CONSTANT);
break;
case IDM_INSERTMATLAB:create_object(OB_MATLAB);
break;
case IDM_INSERTCOUNTER:create_object(OB_COUNTER);
break;
case IDM_INSERTSKINDIALOG:
if (!count_objects(OB_SKINDIALOG)) create_object(OB_SKINDIALOG);
break;
case IDM_INSERTFILE_WRITER:create_object(OB_FILE_WRITER);
break;
case IDM_INSERTDEVIATION:create_object(OB_DEVIATION);
break;
case IDM_INSERTMCIPLAYER:create_object(OB_MCIPLAYER);
break;
case IDM_INSERTKEYSTRIKE:create_object(OB_KEYSTRIKE);
break;
case IDM_INSERTPEAKDETECT:create_object(OB_PEAKDETECT);
break;
case IDM_INSERTSPELLER:create_object(OB_SPELLER);
break;
case IDM_INSERTMARTINI:create_object(OB_MARTINI);
break;
case IDM_INSERTFILE_READER:create_object(OB_FILE_READER);
break;
case IDM_INSERTPORT_IO:create_object(OB_PORT_IO);
break;
case IDM_INSERTARRAY3600:create_object(OB_ARRAY3600);
break;
case IDM_INSERTCOMREADER:create_object(OB_COMREADER);
break;
case IDM_INSERTMIN:create_object(OB_MIN);
break;
case IDM_INSERTMAX:create_object(OB_MAX);
break;
case IDM_INSERTROUND:create_object(OB_ROUND);
break;
case IDM_INSERTDIFFERENTIATE:create_object(OB_DIFFERENTIATE);
break;
case IDM_INSERTDELAY:create_object(OB_DELAY);
break;
case IDM_INSERTLIMITER:create_object(OB_LIMITER);
break;
case IDM_INSERTFLOATVECTOR:
create_object(OB_FLOATVECTOR);
break;
case IDM_INSERTVECTORFLOAT:
create_object(OB_VECTORFLOAT);
break;
case IDM_INSERTDISPLAYVECTOR:
create_object(OB_DISPLAYVECTOR);
break;
case IDM_INSERTVECTORBUFFER:
create_object(OB_BUFFER);
break;
// here are th supported EED devices
case IDM_INSERT_EEG_GENERIC8:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_RAW8BIT; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_GENERIC16:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_RAW; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_IBVA:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_IBVA; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_NIA:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_NIA; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_P21:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_MONOLITHEEG_P21; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_OPENBCI8:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_OPENBCI8; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_P2:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_MODEEG_P2; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_P3:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_MODEEG_P3; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_PENDANT:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_PENDANT3; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_QDS:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_QDS; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_SBT4:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_SBT4; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_SBT2:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_SBT2; create_object(OB_EEG);}
break;
// these devices need special care (seperate element)
case IDM_INSERTOPTIMA:
if ((!count_objects(OB_NEUROBIT)) && (!count_objects(OB_EEG))) create_object(OB_NEUROBIT);
break;
case IDM_INSERTEMOTIV:
if ((!count_objects(OB_EMOTIV)) && (!count_objects(OB_EEG))) create_object(OB_EMOTIV);
break;
case IDM_COPY:
if (actobject)
{
copy_object=actobject;
if ((copy_object->type!=OB_EEG)&&(copy_object->type!=OB_WAV)&&(copy_object->type!=OB_CAM)
&&(copy_object->type!=OB_SKINDIALOG)&&(copy_object->type!=OB_NEUROBIT))
{
HANDLE hFile;
char tmpfile[256];
create_object(copy_object->type);
strcpy(tmpfile,GLOBAL.resourcepath);
strcat(tmpfile,"tmp_copy.con");
hFile = CreateFile(tmpfile, GENERIC_WRITE, 0, NULL,CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile != INVALID_HANDLE_VALUE)
{
copy_object->save(hFile);
save_property(hFile,"end Object",P_END,NULL);
CloseHandle(hFile);
}
hFile = CreateFile(tmpfile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if(hFile != INVALID_HANDLE_VALUE)
{
load_next_config_buffer(hFile);
actobject->load(hFile);
CloseHandle(hFile);
DeleteFile(tmpfile);
}
actobject->xPos+=10; actobject->yPos+=10;
}
close_toolbox();
}
break;
default:
return DefWindowProc( hWnd, message, wParam, lParam );
}
break;
case WM_ACTIVATE:
{
/* char t[50];
static int cn=0;
cn++;
sprintf(t,"%d:%d,%d",cn,HIWORD(lParam),LOWORD(lParam)); //==WA_CLICKACTIVE))
SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_ADDSTRING, 0, (LPARAM) t);
SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_SETCURSEL, SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_GETCOUNT, 0, 0)-1, 0);
UpdateWindow(ghWndStatusbox);
*/
if ((LOWORD(lParam)==WA_CLICKACTIVE) || (HIWORD(lParam)==WA_CLICKACTIVE))
SetWindowPos(ghWndMain,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
SetFocus(ghWndMain);
}
break;
case WM_ACTIVATEAPP:
{
/* char t[50];
static int cn=0;
cn++;
sprintf(t,"%d:%d,%d",cn,HIWORD(lParam),LOWORD(lParam)); //==WA_CLICKACTIVE))
SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_ADDSTRING, 0, (LPARAM) t);
SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_SETCURSEL, SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_GETCOUNT, 0, 0)-1, 0);
UpdateWindow(ghWndStatusbox); */
// if ((LOWORD(lParam)==1828) || (LOWORD(lParam)==964))
//SetWindowPos(ghWndMain,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
SetWindowPos(ghWndMain,0,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
// return DefWindowProc( hWnd, message, wParam, lParam );
}
break;
case WM_KEYDOWN:
if (lParam==KEY_DELETE )
SendMessage(ghWndDesign, message,wParam,lParam);
break;
case WM_SIZE:
if (wParam== SIZE_MAXIMIZED)
{
GLOBAL.main_maximized=lParam;
ShowWindow(ghWndStatusbox,TRUE);
GLOBAL.hidestatus=FALSE;
if (GLOBAL.session_length==0)
SetWindowPos(ghWndStatusbox, ghWndMain, 4, HIWORD(lParam)+15,
LOWORD(lParam)-8,HIWORD(lParam), 0);
else SetWindowPos(ghWndStatusbox, ghWndMain, 4, HIWORD(lParam)-20,
LOWORD(lParam)-8,HIWORD(lParam), 0);
}
else if (wParam== SIZE_RESTORED)
{
WINDOWPLACEMENT wndpl;
GetWindowPlacement(ghWndMain, &wndpl);
GLOBAL.top=wndpl.rcNormalPosition.top;
GLOBAL.left=wndpl.rcNormalPosition.left;
GLOBAL.right=wndpl.rcNormalPosition.right;
GLOBAL.bottom=wndpl.rcNormalPosition.bottom;
GLOBAL.main_maximized=0;
update_status_window();
}
else if (wParam== SIZE_MINIMIZED)
{
ShowWindow(ghWndStatusbox,FALSE);
GLOBAL.hidestatus=TRUE;
}
break;
case WM_MOVE:
{
WINDOWPLACEMENT wndpl;
GetWindowPlacement(ghWndMain, &wndpl);
GLOBAL.top=wndpl.rcNormalPosition.top;
GLOBAL.left=wndpl.rcNormalPosition.left;
GLOBAL.right=wndpl.rcNormalPosition.right;
GLOBAL.bottom=wndpl.rcNormalPosition.bottom;
update_status_window();
}
break;
//case WM_PAINT:
// break;
case WM_DESTROY:
actobject=0;
GlobalCleanup();
PostQuitMessage( 0 );
break;
case WM_INPUT:
if ((TTY.CONNECTED) && (!GLOBAL.loading))
ReadNIA( wParam, lParam); // NIA Daten vorhanden: auslesen
return(TRUE);
default:
return DefWindowProc( hWnd, message, wParam, lParam );
}
return 0;
}
// createGUI()
//
void createGUI(HWND hWnd)
{
if (!guiWnd)
guiWnd = CreateDialog(hInst, (LPCTSTR)IDD_MAINWINDOW, hWnd, (DLGPROC)GUIProc);
ShowWindow(guiWnd,SW_SHOWNORMAL);
}
//-----------------------------------------------------------------------
// FUNCTION WinMain
// PURPOSE: application entry point, register MainWindow class
//-----------------------------------------------------------------------
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow )
{
MSG msg;
hInst=hInstance;
// conv_file();
init_path();
register_classes(hInstance);
if(!(ghWndMain=CreateWindow("brainBay_Class", "BrainBay",
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, 10, 20, 900, 520, NULL, NULL, hInstance, NULL)))
critical_error("can't create main Window");
else {GLOBAL.left=20;GLOBAL.top=20;GLOBAL.right=900;GLOBAL.bottom=520; }
ShowWindow( ghWndMain, SW_SHOWNORMAL );
UpdateWindow( ghWndMain );
create_logfile();
write_logfile("BrainBay start.");
GlobalInitialize();
ghWndStatusbox=CreateDialog(hInst, (LPCTSTR)IDD_STATUSBOX, ghWndMain, (DLGPROC)StatusDlgHandler);
if(!(ghWndDesign=CreateWindow("Design_Class", "Design", WS_CLIPSIBLINGS | WS_CAPTION | WS_THICKFRAME | WS_CHILD | WS_HSCROLL | WS_VSCROLL ,GLOBAL.design_left, GLOBAL.design_top, GLOBAL.design_right-GLOBAL.design_left, GLOBAL.design_bottom-GLOBAL.design_top, ghWndMain, NULL, hInst, NULL)))
report_error("can't create Design Window");
else
{
SCROLLINFO si;
ZeroMemory(&si, sizeof(si));
si.cbSize = sizeof(si);
si.fMask = SIF_TRACKPOS|SIF_RANGE|SIF_TRACKPOS;
GetScrollInfo(ghWndDesign, SB_HORZ, &si);
si.nMax=5000; si.nMin=0; si.nPos=0; si.nTrackPos=0;
SetScrollInfo(ghWndDesign, SB_HORZ, &si,TRUE);
GetScrollInfo(ghWndDesign, SB_VERT, &si);
si.nMax=5000; si.nMin=0; si.nPos=0; si.nTrackPos=0;
SetScrollInfo(ghWndDesign, SB_VERT, &si,TRUE);
ShowWindow( ghWndDesign, TRUE ); UpdateWindow( ghWndDesign );
}
if (GLOBAL.startup)
{
if (!load_configfile(GLOBAL.configfile)) report_error("Could not load Config File");
//else sort_objects();
}
update_status_window();
UINT timerid= timeSetEvent(30,5,AnimProc,1,TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
// main message loop
while (TRUE)
{
check_keys();
if(!GetMessage(&msg, NULL, 0, 0)) break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
timeKillEvent(timerid);
return msg.wParam;
}
static int InitializeDialog (HWND window)
{
TCITEM gui_tab_item;
struct reference_data* data;
HWND tab_window;
HWND ref_syntax_window;
HWND ref_plugins_window;
HWND ref_templates_window;
HICON icon;
data = malloc(sizeof(struct reference_data));
if(data == NULL)
goto allocate_reference_data_failed;
icon = LoadIcon(tside_application_instance, MAKEINTRESOURCE(TSIDE_I_GUI_REFERENCE));
if(icon == NULL)
goto load_reference_icon_failed;
SendMessage(window, WM_SETICON, ICON_BIG, (LPARAM)icon);
tab_window = GetDlgItem(window, TSIDE_C_REFERENCE_TABS);
ref_syntax_window = CreateDialog(
tside_application_instance,
MAKEINTRESOURCE(TSIDE_D_REF_SYNTAX),
window,
&TSIDE_RefSyntaxMessageProc
);
if(ref_syntax_window == NULL)
goto create_ref_syntax_window_failed;
ref_plugins_window = CreateDialog(
tside_application_instance,
MAKEINTRESOURCE(TSIDE_D_REF_PLUGINS),
window,
&TSIDE_RefPluginsMessageProc
);
if(ref_plugins_window == NULL)
goto create_ref_plugins_window_failed;
ref_templates_window = CreateDialog(
tside_application_instance,
MAKEINTRESOURCE(TSIDE_D_REF_TEMPLATES),
window,
&TSIDE_RefTemplatesMessageProc
);
if(ref_templates_window == NULL)
goto create_ref_templates_window_failed;
gui_tab_item.mask = TCIF_TEXT;
gui_tab_item.pszText = TSIDE_GetResourceText(TSIDE_S_REFERENCE_TAB_SYNTAX);
SendMessage(tab_window, TCM_INSERTITEM, TSIDE_REFERENCE_SYNTAX, (LPARAM)&gui_tab_item);
gui_tab_item.mask = TCIF_TEXT;
gui_tab_item.pszText = TSIDE_GetResourceText(TSIDE_S_REFERENCE_TAB_PLUGINS);
SendMessage(tab_window, TCM_INSERTITEM, TSIDE_REFERENCE_PLUGINS, (LPARAM)&gui_tab_item);
gui_tab_item.mask = TCIF_TEXT;
gui_tab_item.pszText = TSIDE_GetResourceText(TSIDE_S_REFERENCE_TAB_TEMPLATES);
SendMessage(tab_window, TCM_INSERTITEM, TSIDE_REFERENCE_TEMPLATES, (LPARAM)&gui_tab_item);
data->reference_window = window;
data->tab_window = tab_window;
data->ref_syntax_window = ref_syntax_window;
data->ref_plugins_window = ref_plugins_window;
data->ref_templates_window = ref_templates_window;
SetWindowLongPtr(window, GWLP_USERDATA, (LONG_PTR)data);
RepositionControls(data);
SetSelectedTab(TSIDE_REFERENCE_PLUGINS, data);
return TSIDE_ERROR_NONE;
create_ref_templates_window_failed:
DestroyWindow(ref_plugins_window);
create_ref_plugins_window_failed:
DestroyWindow(ref_syntax_window);
create_ref_syntax_window_failed:
DestroyIcon(icon);
load_reference_icon_failed:
free(data);
allocate_reference_data_failed:
return TSIDE_ERROR_REFERENCE_ERROR;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static uint32_t lanLastPing = 0;
static HFONT _hFont = 0;
switch (message)
{
case WM_CREATE:
{
HFONT hFont = 0;
NONCLIENTMETRICS ncm = { sizeof(ncm) };
if (SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0))
{
hFont = CreateFontIndirect(&ncm.lfMessageFont);
_hFont = hFont;
}
if (!hFont)
hFont = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
RECT rcClient;
GetClientRect(hWnd, &rcClient);
g_hWndListViewServers = CreateWindow(WC_LISTVIEW, nullptr, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | LVS_REPORT | LVS_SHOWSELALWAYS | LVS_AUTOARRANGE | LVS_OWNERDATA, 1, 21, rcClient.right - UI_PLAYERLIST_WIDTH - 4, rcClient.bottom - UI_SERVERINFO_HEIGHT - 21 - 2, hWnd, nullptr, g_hInst, nullptr);
if (g_hWndListViewServers)
{
SetWindowTheme(g_hWndListViewServers, L"Explorer", nullptr);
ListView_SetExtendedListViewStyle(g_hWndListViewServers, LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER);
LVCOLUMN lvc;
lvc.mask = LVCF_WIDTH;
lvc.cx = 30;
ListView_InsertColumn(g_hWndListViewServers, 0, &lvc);
lvc.mask = LVCF_WIDTH | LVCF_TEXT;
lvc.cx = 240;
lvc.pszText = LoadStr(L"Server Name", IDS_SERVERNAME);
ListView_InsertColumn(g_hWndListViewServers, 1, &lvc);
lvc.cx = 60;
lvc.pszText = LoadStr(L"Ping", IDS_PING);
ListView_InsertColumn(g_hWndListViewServers, 2, &lvc);
lvc.cx = 80;
lvc.pszText = LoadStr(L"Players", IDS_PLAYERS);
ListView_InsertColumn(g_hWndListViewServers, 3, &lvc);
lvc.cx = 70;
lvc.pszText = LoadStr(L"Version", IDS_VERSION);
ListView_InsertColumn(g_hWndListViewServers, 4, &lvc);
lvc.cx = 120;
lvc.pszText = LoadStr(L"Gamemode", IDS_GAMEMODE);
ListView_InsertColumn(g_hWndListViewServers, 5, &lvc);
lvc.cx = 100;
lvc.pszText = LoadStr(L"Map Name", IDS_MAPNAME);
ListView_InsertColumn(g_hWndListViewServers, 6, &lvc);
}
g_hWndListViewHistory = CreateWindow(WC_LISTVIEW, nullptr, WS_CHILD | WS_CLIPSIBLINGS | LVS_REPORT | LVS_SHOWSELALWAYS | LVS_AUTOARRANGE | LVS_OWNERDATA, 1, 21, rcClient.right - UI_PLAYERLIST_WIDTH - 4, rcClient.bottom - UI_SERVERINFO_HEIGHT - 21 - 2, hWnd, nullptr, g_hInst, nullptr);
if (g_hWndListViewHistory)
{
SetWindowTheme(g_hWndListViewHistory, L"Explorer", nullptr);
ListView_SetExtendedListViewStyle(g_hWndListViewHistory, LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER);
LVCOLUMN lvc;
lvc.mask = LVCF_WIDTH;
lvc.cx = 30;
ListView_InsertColumn(g_hWndListViewHistory, 0, &lvc);
lvc.mask = LVCF_WIDTH | LVCF_TEXT;
lvc.cx = 220;
lvc.pszText = LoadStr(L"Server Name", IDS_SERVERNAME);
ListView_InsertColumn(g_hWndListViewHistory, 1, &lvc);
lvc.cx = 60;
lvc.pszText = LoadStr(L"Ping", IDS_PING);
ListView_InsertColumn(g_hWndListViewHistory, 2, &lvc);
lvc.cx = 80;
lvc.pszText = LoadStr(L"Players", IDS_PLAYERS);
ListView_InsertColumn(g_hWndListViewHistory, 3, &lvc);
lvc.cx = 70;
lvc.pszText = LoadStr(L"Version", IDS_VERSION);
ListView_InsertColumn(g_hWndListViewHistory, 4, &lvc);
lvc.cx = 100;
lvc.pszText = LoadStr(L"Gamemode", IDS_GAMEMODE);
ListView_InsertColumn(g_hWndListViewHistory, 5, &lvc);
lvc.cx = 160;
lvc.pszText = LoadStr(L"Last Played", IDS_LASTPLAYED);
ListView_InsertColumn(g_hWndListViewHistory, 6, &lvc);
}
g_hWndTab = CreateWindow(WC_TABCONTROL, nullptr, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE, 0, 0, rcClient.right - UI_PLAYERLIST_WIDTH, rcClient.bottom - UI_SERVERINFO_HEIGHT, hWnd, nullptr, g_hInst, nullptr);
if (g_hWndTab)
{
SetWindowFont(g_hWndTab, hFont, FALSE);
HIMAGELIST hTabIml = ImageList_Create(16, 16, ILC_COLOR32, 0, 0);
if (hTabIml)
{
for (int i = IDI_FAVORITE; i <= IDI_HISTORY; ++i)
ImageList_AddIcon(hTabIml, LoadIcon(g_hInst, MAKEINTRESOURCE(i)));
TabCtrl_SetImageList(g_hWndTab, hTabIml);
}
TCITEM tie;
tie.mask = TCIF_TEXT | TCIF_IMAGE;
tie.iImage = 0;
tie.pszText = LoadStr(L"Favorites", IDS_FAVORITES);
TabCtrl_InsertItem(g_hWndTab, 0, &tie);
tie.iImage = 1;
tie.pszText = LoadStr(L"Internet", IDS_INTERNET);
TabCtrl_InsertItem(g_hWndTab, 1, &tie);
tie.iImage = 1;
tie.pszText = LoadStr(L"Official", IDS_OFFICIAL);
TabCtrl_InsertItem(g_hWndTab, 2, &tie);
tie.iImage = 2;
tie.pszText = LoadStr(L"Lan", IDS_LAN);
TabCtrl_InsertItem(g_hWndTab, 3, &tie);
tie.iImage = 3;
tie.pszText = LoadStr(L"History", IDS_HISTORY);
TabCtrl_InsertItem(g_hWndTab, 4, &tie);
}
g_hWndListViewPlayers = CreateWindowEx(0, WC_LISTVIEW, nullptr, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | LVS_REPORT | LVS_SHOWSELALWAYS | LVS_NOCOLUMNHEADER | LVS_SINGLESEL | LVS_OWNERDATA, rcClient.right - UI_PLAYERLIST_WIDTH + 1, 18, UI_PLAYERLIST_WIDTH - 2, rcClient.bottom - UI_SERVERINFO_HEIGHT - 18 - 2, hWnd, nullptr, g_hInst, nullptr);
if (g_hWndListViewPlayers)
{
SetWindowTheme(g_hWndListViewPlayers, L"Explorer", nullptr);
ListView_SetExtendedListViewStyle(g_hWndListViewPlayers, LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER);
LVCOLUMN lvc;
lvc.mask = LVCF_WIDTH;
lvc.cx = UI_PLAYERLIST_WIDTH - 2;
ListView_InsertColumn(g_hWndListViewPlayers, 0, &lvc);
}
g_hWndGroupBox1 = CreateWindow(WC_BUTTON, LoadStr(L"Players", IDS_PLAYERSLIST), WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | BS_GROUPBOX, rcClient.right - UI_PLAYERLIST_WIDTH, 0, UI_PLAYERLIST_WIDTH, rcClient.bottom - UI_SERVERINFO_HEIGHT, hWnd, nullptr, g_hInst, nullptr);
if (g_hWndGroupBox1)
{
SetWindowFont(g_hWndGroupBox1, hFont, FALSE);
}
g_hWndGroupBox2 = CreateWindow(WC_BUTTON, LoadStr(L"Server Info", IDS_SERVERINFO), WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | BS_GROUPBOX, 0, rcClient.bottom - UI_SERVERINFO_HEIGHT, rcClient.right, 118, hWnd, nullptr, g_hInst, nullptr);
if (g_hWndGroupBox2)
{
SetWindowFont(g_hWndGroupBox2, hFont, FALSE);
int y = 18;
#define LINE_GAP 20
HWND hStatic = CreateWindow(WC_STATIC, LoadStr(L"Server Name:", IDS_SERVERNAME_), WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT, 10, y, 100, 16, g_hWndGroupBox2, nullptr, g_hInst, nullptr);
if (hStatic) SetWindowFont(hStatic, hFont, FALSE);
HWND hEdit = CreateWindow(WC_EDIT, nullptr, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | ES_READONLY, 112, y, 300, 16, g_hWndGroupBox2, (HMENU)1001, g_hInst, nullptr);
if (hEdit) SetWindowFont(hEdit, hFont, FALSE);
y += LINE_GAP;
hStatic = CreateWindow(WC_STATIC, LoadStr(L"Server IP:", IDS_SERVERIP), WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT, 10, y, 100, 16, g_hWndGroupBox2, nullptr, g_hInst, nullptr);
if (hStatic) SetWindowFont(hStatic, hFont, FALSE);
hEdit = CreateWindow(WC_EDIT, nullptr, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | ES_READONLY, 112, y, 300, 16, g_hWndGroupBox2, (HMENU)1002, g_hInst, nullptr);
if (hEdit) SetWindowFont(hEdit, hFont, FALSE);
y += LINE_GAP;
hStatic = CreateWindow(WC_STATIC, LoadStr(L"Server Players:", IDS_SERVERPLAYERS), WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT, 10, y, 100, 16, g_hWndGroupBox2, nullptr, g_hInst, nullptr);
if (hStatic) SetWindowFont(hStatic, hFont, FALSE);
hEdit = CreateWindow(WC_EDIT, nullptr, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | ES_READONLY, 112, y, 300, 16, g_hWndGroupBox2, (HMENU)1003, g_hInst, nullptr);
if (hEdit) SetWindowFont(hEdit, hFont, FALSE);
y += LINE_GAP;
hStatic = CreateWindow(WC_STATIC, LoadStr(L"Server Ping:", IDS_SERVERPING), WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT, 10, y, 100, 16, g_hWndGroupBox2, nullptr, g_hInst, nullptr);
if (hStatic) SetWindowFont(hStatic, hFont, FALSE);
hEdit = CreateWindow(WC_EDIT, nullptr, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | ES_READONLY, 112, y, 300, 16, g_hWndGroupBox2, (HMENU)1004, g_hInst, nullptr);
if (hEdit) SetWindowFont(hEdit, hFont, FALSE);
y += LINE_GAP;
hStatic = CreateWindow(WC_STATIC, LoadStr(L"Server Gamemode:", IDS_SERVERGAMEMODE), WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SS_RIGHT, 10, y, 100, 16, g_hWndGroupBox2, nullptr, g_hInst, nullptr);
if (hStatic) SetWindowFont(hStatic, hFont, FALSE);
hEdit = CreateWindow(WC_EDIT, nullptr, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | ES_READONLY, 112, y, 300, 16, g_hWndGroupBox2, (HMENU)1005, g_hInst, nullptr);
if (hEdit) SetWindowFont(hEdit, hFont, FALSE);
}
g_hWndStatusBar = CreateWindow(STATUSCLASSNAME, nullptr, WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | SBARS_SIZEGRIP, 0, 0, 0, 0, hWnd, nullptr, g_hInst, nullptr);
do {
g_UDPSocket = socket(AF_INET, SOCK_DGRAM, 0);
if (g_UDPSocket == INVALID_SOCKET)
break;
uint32_t timeout = 2000;
setsockopt(g_UDPSocket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout));
struct sockaddr_in bindaddr = { AF_INET };
if (bind(g_UDPSocket, (sockaddr *)&bindaddr, 16) != NO_ERROR)
{
closesocket(g_UDPSocket);
break;
}
if (WSAAsyncSelect(g_UDPSocket, hWnd, WM_SOCKET, FD_READ) == SOCKET_ERROR)
{
closesocket(g_UDPSocket);
break;
}
return 0;
} while (0);
}
break;
case WM_COMMAND:
{
int wmId = LOWORD(wParam);
switch (wmId)
{
case IDM_TOOLS_SETTINGS:
ShowSettings();
break;
case IDM_ABOUT:
DialogBox(g_hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
}
break;
case WM_NOTIFY:
{
switch (((LPNMHDR)lParam)->code)
{
case TCN_SELCHANGE:
{
g_currentTab = TabCtrl_GetCurSel(((LPNMHDR)lParam)->hwndFrom);
switch (g_currentTab)
{
case 0: // Favorites
case 1: // Internet
case 2: // Official
case 3: // Lan
ListView_DeleteAllItems(g_hWndListViewServers);
ListView_DeleteAllItems(g_hWndListViewPlayers);
g_serversList.clear();
ShowWindow(g_hWndListViewServers, SW_SHOW);
ShowWindow(g_hWndListViewHistory, SW_HIDE);
UpdateWindow(g_hWndListViewServers);
if (g_currentTab == 1 || g_currentTab == 2)
{
HWND hDialog = CreateDialog(g_hInst, MAKEINTRESOURCEW(IDD_LOADING), hWnd, nullptr);
SetWindowPos(hDialog, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
UpdateWindow(hDialog);
if (g_serversMasterList)
{
delete g_serversMasterList;
g_serversMasterList = nullptr;
}
std::string data;
data.reserve(2048);
const char *url;
if (g_currentTab == 1)
url = (g_browserSettings.masterlistURL + "/servers").c_str();
else
url = (g_browserSettings.masterlistURL + "/official").c_str();
CURLcode curlRet = CurlRequset(url, data, "VCMP/0.4");
if (curlRet == CURLE_OK)
{
serverMasterList serversList;
if (ParseJson(data.data(), serversList))
{
for (auto it = serversList.begin(); it != serversList.end(); ++it)
{
SendQuery(it->address, 'i');
it->lastPing = GetTickCount();
}
g_serversMasterList = new serverMasterList(serversList);
}
else
{
MessageBox(hWnd, LoadStr(L"Can't parse master list data.", IDS_MASTERLISTDATA), LoadStr(L"Error", IDS_ERROR), MB_ICONWARNING);
}
}
else
{
wchar_t message[512];
swprintf_s(message, LoadStr(L"Can't get information from master list.\n%hs", IDS_MASTERLISTFAILED), curl_easy_strerror(curlRet));
MessageBox(hWnd, message, LoadStr(L"Error", IDS_ERROR), MB_ICONWARNING);
}
DestroyWindow(hDialog);
}
else if (g_currentTab == 3)
{
BOOL broadcast = TRUE;
setsockopt(g_UDPSocket, SOL_SOCKET, SO_BROADCAST, (char *)&broadcast, sizeof(broadcast));
for (uint16_t port = 8000; port <= 8200; ++port)
{
serverAddress address = { INADDR_BROADCAST, port };
SendQuery(address, 'i');
}
broadcast = FALSE;
setsockopt(g_UDPSocket, SOL_SOCKET, SO_BROADCAST, (char *)&broadcast, sizeof(broadcast));
lanLastPing = GetTickCount();
}
break;
case 4: // History
ShowWindow(g_hWndListViewHistory, SW_SHOW);
ShowWindow(g_hWndListViewServers, SW_HIDE);
break;
}
}
break;
case LVN_GETDISPINFO:
{
LPNMLVDISPINFOW di = (LPNMLVDISPINFOW)lParam;
if (di->hdr.hwndFrom == g_hWndListViewServers)
{
size_t i = di->item.iItem;
if (g_serversList.size() > i)
{
if (di->item.iSubItem == 0 && di->item.mask & LVIF_IMAGE)
di->item.iImage = 0;
if (di->item.mask & LVIF_TEXT)
{
switch (di->item.iSubItem)
{
case 0: // Icon
break;
case 1: // Server Name
if (di->item.cchTextMax > 0 && di->item.pszText)
{
MultiByteToWideChar(CP_ACP, 0, g_serversList[i].info.serverName.c_str(), -1, di->item.pszText, di->item.cchTextMax);
}
break;
case 2: // Ping
{
uint32_t ping = g_serversList[i].lastRecv - g_serversList[i].lastPing[1];
_itow_s(ping, di->item.pszText, di->item.cchTextMax, 10);
}
break;
case 3: // Players
swprintf_s(di->item.pszText, di->item.cchTextMax, L"%hu/%hu", g_serversList[i].info.players, g_serversList[i].info.maxPlayers);
break;
case 4: // Version
{
MultiByteToWideChar(CP_ACP, 0, g_serversList[i].info.versionName, -1, di->item.pszText, di->item.cchTextMax);
}
break;
case 5: // Gamemode
{
MultiByteToWideChar(CP_ACP, 0, g_serversList[i].info.gameMode.c_str(), -1, di->item.pszText, di->item.cchTextMax);
}
break;
case 6: // Map name
{
MultiByteToWideChar(CP_ACP, 0, g_serversList[i].info.mapName.c_str(), -1, di->item.pszText, di->item.cchTextMax);
}
break;
}
}
}
}
else if (di->hdr.hwndFrom == g_hWndListViewHistory) // FIXME
{
}
else if (di->hdr.hwndFrom == g_hWndListViewPlayers)
{
size_t i = ListView_GetSelectionMark(g_hWndListViewServers);
if (g_serversList.size() > i)
{
serverPlayers &players = g_serversList[i].players;
size_t j = di->item.iItem;
if (players.size() > j)
{
if (di->item.mask & LVIF_TEXT)
{
MultiByteToWideChar(CP_ACP, 0, players[j].name, -1, di->item.pszText, di->item.cchTextMax);
}
}
}
}
}
break;
case NM_CUSTOMDRAW:
{
LPNMLVCUSTOMDRAW nmcd = (LPNMLVCUSTOMDRAW)lParam;
if (nmcd->nmcd.hdr.hwndFrom == g_hWndListViewServers)
{
switch (nmcd->nmcd.dwDrawStage)
{
case CDDS_PREPAINT:
return CDRF_NOTIFYITEMDRAW;
case CDDS_ITEMPREPAINT:
{
COLORREF crText;
size_t i = nmcd->nmcd.dwItemSpec;
if (g_serversList.size() > i && g_serversList[i].isOfficial)
crText = g_browserSettings.officialColor;
else
crText = 0;
nmcd->clrText = crText;
return CDRF_DODEFAULT;
}
}
}
}
break;
case LVN_ITEMCHANGED:
{
LPNMITEMACTIVATE nmitem = (LPNMITEMACTIVATE)lParam;
if (nmitem->hdr.hwndFrom == g_hWndListViewServers)
{
size_t i = nmitem->iItem;
if (i != -1 && g_serversList.size() > i)
{
if (g_serversList[i].info.players == 0)
ListView_DeleteAllItems(g_hWndListViewPlayers);
std::wstring wstr;
ConvertCharset(g_serversList[i].info.serverName.c_str(), wstr);
SetDlgItemText(g_hWndGroupBox2, 1001, wstr.c_str()); // Server Name
wchar_t ipstr[22];
char *ip = (char *)&(g_serversList[i].address.ip);
swprintf_s(ipstr, L"%hhu.%hhu.%hhu.%hhu:%hu", ip[0], ip[1], ip[2], ip[3], g_serversList[i].address.port);
SetDlgItemText(g_hWndGroupBox2, 1002, ipstr); // Server IP
wchar_t playersstr[12];
swprintf_s(playersstr, L"%hu/%hu", g_serversList[i].info.players, g_serversList[i].info.maxPlayers);
SetDlgItemText(g_hWndGroupBox2, 1003, playersstr); // Server Players
wchar_t pingsstr[12];
uint32_t ping = g_serversList[i].lastRecv - g_serversList[i].lastPing[1];
_itow_s(ping, pingsstr, 10);
SetDlgItemText(g_hWndGroupBox2, 1004, pingsstr); // Server Ping
ConvertCharset(g_serversList[i].info.gameMode.c_str(), wstr);
SetDlgItemText(g_hWndGroupBox2, 1005, wstr.c_str()); // Server Gamemode
SendQuery(g_serversList[i].address, 'i');
SendQuery(g_serversList[i].address, 'c');
g_serversList[i].lastPing[0] = GetTickCount();
}
else
{
ListView_DeleteAllItems(g_hWndListViewPlayers);
for (int i = 1001; i <= 1005; ++i)
SetDlgItemText(g_hWndGroupBox2, i, nullptr);
}
}
}
break;
case LVN_ITEMACTIVATE:
{
LPNMITEMACTIVATE nmia = (LPNMITEMACTIVATE)lParam;
if (nmia->hdr.hwndFrom == g_hWndListViewServers)
{
size_t i = nmia->iItem;
if (i != -1 && g_serversList.size() > i)
{
char ipstr[16];
char *ip = (char *)&(g_serversList[i].address.ip);
snprintf(ipstr, sizeof(ipstr), "%hhu.%hhu.%hhu.%hhu", ip[0], ip[1], ip[2], ip[3]);
char vcmpDll[MAX_PATH];
snprintf(vcmpDll, sizeof(vcmpDll), "%ls%s\\vcmp-game.dll", g_exePath, g_serversList[i].info.versionName);
LaunchVCMP(ipstr, g_serversList[i].address.port, g_browserSettings.playerName, nullptr, g_browserSettings.gamePath, vcmpDll);
}
}
}
break;
}
}
break;
case WM_SIZE:
{
int clientWidth = GET_X_LPARAM(lParam), clientHeight = GET_Y_LPARAM(lParam);
SetWindowPos(g_hWndTab, 0, 0, 0, clientWidth - UI_PLAYERLIST_WIDTH, clientHeight - UI_SERVERINFO_HEIGHT, SWP_NOZORDER);
SetWindowPos(g_hWndListViewServers, 0, 1, 21, clientWidth - UI_PLAYERLIST_WIDTH - 4, clientHeight - UI_SERVERINFO_HEIGHT - 21 - 2, SWP_NOZORDER);
SetWindowPos(g_hWndListViewHistory, 0, 1, 21, clientWidth - UI_PLAYERLIST_WIDTH - 4, clientHeight - UI_SERVERINFO_HEIGHT - 21 - 2, SWP_NOZORDER);
SetWindowPos(g_hWndGroupBox1, 0, clientWidth - UI_PLAYERLIST_WIDTH, 0, UI_PLAYERLIST_WIDTH, clientHeight - UI_SERVERINFO_HEIGHT, SWP_NOZORDER);
SetWindowPos(g_hWndListViewPlayers, 0, clientWidth - UI_PLAYERLIST_WIDTH + 1, 18, UI_PLAYERLIST_WIDTH - 2, clientHeight - UI_SERVERINFO_HEIGHT - 18 - 2, SWP_NOZORDER);
SetWindowPos(g_hWndGroupBox2, 0, 0, clientHeight - UI_SERVERINFO_HEIGHT, clientWidth, 118, SWP_NOZORDER);
SendMessage(g_hWndStatusBar, WM_SIZE, 0, 0);
}
break;
case WM_GETMINMAXINFO:
((LPMINMAXINFO)lParam)->ptMinTrackSize = { 750, 500 };
break;
case WM_DESTROY:
if (_hFont)
DeleteObject(_hFont);
PostQuitMessage(0);
break;
case WM_SOCKET:
{
if (WSAGETSELECTEVENT(lParam) == FD_READ)
{
char *recvBuf = (char *)calloc(1024, sizeof(char));
if (recvBuf)
{
struct sockaddr_in recvAddr;
int addrLen = sizeof(recvAddr);
int recvLen = recvfrom(g_UDPSocket, recvBuf, 1024, 0, (sockaddr *)&recvAddr, &addrLen);
if (recvLen != -1 && recvLen >= 11)
{
if (recvLen > 1024)
recvLen = 1024;
if (*(int *)recvBuf == 0x3430504D) // MP04
{
char opcode = recvBuf[10];
if (opcode == 'i' || opcode == 'c')
{
uint32_t ip = recvAddr.sin_addr.s_addr;
uint16_t port = ntohs(recvAddr.sin_port);
bool found = false;
serverMasterListInfo masterInfo;
if (g_currentTab == 1 || g_currentTab == 2)
{
for (auto it = g_serversMasterList->begin(); it != g_serversMasterList->end(); ++it)
{
if (it->address.ip == ip && it->address.port == port)
{
found = true;
masterInfo = *it;
break;
}
}
}
else if (g_currentTab == 3) // Lan
{
found = true;
masterInfo.address = { ip, port };
masterInfo.isOfficial = false;
masterInfo.lastPing = lanLastPing;
}
if (found)
{
switch (opcode)
{
case 'i':
{
serverInfo info;
if (GetServerInfo(recvBuf, recvLen, info))
{
bool inList = false;
for (auto it = g_serversList.begin(); it != g_serversList.end(); ++it)
{
if (it->address.ip == ip && it->address.port == port)
{
inList = true;
it->lastRecv = GetTickCount();
it->lastPing[1] = it->lastPing[0];
it->info = info;
auto i = it - g_serversList.begin();
ListView_Update(g_hWndListViewServers, i);
break;
}
}
if (!inList)
{
serverAllInfo allInfo;
allInfo.address = masterInfo.address;
allInfo.info = info;
allInfo.isOfficial = masterInfo.isOfficial;
allInfo.lastPing[0] = masterInfo.lastPing;
allInfo.lastPing[1] = masterInfo.lastPing;
allInfo.lastRecv = GetTickCount();
g_serversList.push_back(allInfo);
LVITEM lvi = { 0 };
ListView_InsertItem(g_hWndListViewServers, &lvi);
}
}
}
break;
case 'c':
{
serverPlayers players;
if (GetServerPlayers(recvBuf, recvLen, players))
{
for (auto it = g_serversList.begin(); it != g_serversList.end(); ++it)
{
if (it->address.ip == ip && it->address.port == port)
{
it->lastRecv = GetTickCount();
it->lastPing[1] = it->lastPing[0];
it->players = players;
auto i = it - g_serversList.begin();
ListView_SetItemCount(g_hWndListViewPlayers, players.size());
break;
}
}
}
}
break;
}
}
}
}
}
free(recvBuf);
}
}
}
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
void AddSearchTabs(HWND hwnd)
{
TCITEM tcitem;
RECT rect;
int i;
HWND hwndTab = GetDlgItem(hwnd, IDC_TAB1);
tcitem.mask = TCIF_TEXT;
tcitem.pszText = _T("Find");
TabCtrl_InsertItem(hwndTab, 0, &tcitem);
tcitem.mask = TCIF_TEXT;
tcitem.pszText = _T("Replace");
TabCtrl_InsertItem(hwndTab, 1, &tcitem);
tcitem.mask = TCIF_TEXT;
tcitem.pszText = _T("Goto");
TabCtrl_InsertItem(hwndTab, 2, &tcitem);
///tcitem.mask = TCIF_TEXT;
///tcitem.pszText = _T("Replace");
//TabCtrl_InsertItem(hwndTab, 3, &tcitem);
// GetClient
// TabCtrl_GetItemRect(hwndTab, 0, &rect);
//for(i = MAX_FIND_PANES-1; i >= 0; i--)
//{
g_hwndFindPane[0] = CreateDialog(g_hResourceModule, MAKEINTRESOURCE(IDD_FINDPANE), hwnd, FindHexDlg);
g_hwndFindPane[1] = CreateDialog(g_hResourceModule, MAKEINTRESOURCE(IDD_REPLACEPANE), hwnd, FindHexDlg);
g_hwndFindPane[2] = CreateDialog(g_hResourceModule, MAKEINTRESOURCE(IDD_GOTOPANE), hwnd, FindHexDlg);
//ShowWindow(g_hwndFindPane[0], SW_SHOW);
//}
// work out how big tab control needs to be to hold the pane
//for(i = 0; i < MAX_FIND_PANES; i++)
i = 0;
{
GetClientRect(g_hwndFindPane[i], &rect);
MapWindowPoints(g_hwndFindPane[i], hwnd, (POINT *)&rect, 2);
TabCtrl_AdjustRect(hwndTab, TRUE, &rect);
// break;
}
// move tab control into position
MoveWindow(hwndTab, FINDBORDER, FINDBORDER, rect.right-rect.left, rect.bottom-rect.top, FALSE);
// adjust the find dialog size
AdjustWindowRectEx(&rect, GetWindowLong(hwnd, GWL_STYLE), FALSE, GetWindowLong(hwnd, GWL_EXSTYLE));
InflateRect(&rect, FINDBORDER, FINDBORDER);
SetWindowPos(hwnd, 0, 0, 0, rect.right-rect.left, rect.bottom-rect.top-2, SWP_SIZEONLY);
// now find out the tab control's client display area
GetWindowRect(hwndTab, &rect);
MapWindowPoints(0, hwnd, (POINT *)&rect, 2);
TabCtrl_AdjustRect(hwndTab, FALSE, &rect);
// move find pane into position
for(i = 0; i < MAX_FIND_PANES; i++)
{
MoveWindow(g_hwndFindPane[i], rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top, FALSE);
}
// ShowWindow(g_hwndFindPane[0], SW_SHOW);
}
void MyLib::Main()
{
m_mainHWND = CreateDialog( g_hinstDLL, MAKEINTRESOURCE(IDD_PASEK), 0, ToolDlgProc );
}
void
mswin_display_splash_window(BOOL show_ver)
{
MSG msg;
int left, top;
RECT splashrt;
RECT clientrt;
RECT controlrt;
HWND hWnd;
int buttop;
int strsize = 0;
int bufsize = BUFSZ;
char *buf = malloc(bufsize);
if (buf == NULL)
panic("out of memory");
buf[0] = '\0';
hWnd = CreateDialog(GetNHApp()->hApp, MAKEINTRESOURCE(IDD_SPLASH),
GetNHApp()->hMainWnd, NHSplashWndProc);
if (!hWnd)
panic("Cannot create Splash window");
mswin_init_splashfonts(hWnd);
GetNHApp()->hPopupWnd = hWnd;
/* Get control size */
GetWindowRect(GetDlgItem(hWnd, IDOK), &controlrt);
controlrt.right -= controlrt.left;
controlrt.bottom -= controlrt.top;
/* Get current client area */
GetClientRect(hWnd, &clientrt);
/* Get window size */
GetWindowRect(hWnd, &splashrt);
splashrt.right -= splashrt.left;
splashrt.bottom -= splashrt.top;
/* Get difference between requested client area and current value */
splashrt.right += SPLASH_WIDTH + SPLASH_OFFSET_X * 2 - clientrt.right;
splashrt.bottom += SPLASH_HEIGHT + controlrt.bottom + SPLASH_OFFSET_Y * 3
- clientrt.bottom;
/* Place the window centered */
/* On the screen, not on the parent window */
left = (GetSystemMetrics(SM_CXSCREEN) - splashrt.right) / 2;
top = (GetSystemMetrics(SM_CYSCREEN) - splashrt.bottom) / 2;
MoveWindow(hWnd, left, top, splashrt.right, splashrt.bottom, TRUE);
/* Place the OK control */
GetClientRect(hWnd, &clientrt);
MoveWindow(GetDlgItem(hWnd, IDOK),
(clientrt.right - clientrt.left - controlrt.right) / 2,
clientrt.bottom - controlrt.bottom - SPLASH_OFFSET_Y,
controlrt.right, controlrt.bottom, TRUE);
buttop = clientrt.bottom - controlrt.bottom - SPLASH_OFFSET_Y;
/* Place the text control */
GetWindowRect(GetDlgItem(hWnd, IDC_EXTRAINFO), &controlrt);
controlrt.right -= controlrt.left;
controlrt.bottom -= controlrt.top;
GetClientRect(hWnd, &clientrt);
MoveWindow(GetDlgItem(hWnd, IDC_EXTRAINFO),
clientrt.left + SPLASH_OFFSET_X,
buttop - controlrt.bottom - SPLASH_OFFSET_Y,
clientrt.right - 2 * SPLASH_OFFSET_X, controlrt.bottom, TRUE);
/* Fill the text control */
Sprintf(buf, "%s\r\n%s\r\n%s\r\n%s\r\n\r\n", COPYRIGHT_BANNER_A,
COPYRIGHT_BANNER_B, COPYRIGHT_BANNER_C, COPYRIGHT_BANNER_D);
strsize = strlen(buf);
if (show_ver) {
/* Show complete version information */
dlb *f;
getversionstring(buf + strsize);
strcat(buf, "\r\n\r\n");
strsize = strlen(buf);
/* Add compile options */
f = dlb_fopen(OPTIONS_USED, RDTMODE);
if (f) {
char line[LLEN + 1];
while (dlb_fgets(line, LLEN, f)) {
size_t len;
len = strlen(line);
if (len > 0 && line[len - 1] == '\n') {
line[len - 1] = '\r';
line[len] = '\n';
line[len + 1] = '\0';
len++;
}
if (strsize + (int) len + 1 > bufsize) {
bufsize += BUFSZ;
buf = realloc(buf, bufsize);
if (buf == NULL)
panic("out of memory");
}
strcat(buf, line);
strsize += len;
}
(void) dlb_fclose(f);
}
} else {
/* Show news, if any */
if (iflags.news) {
FILE *nf;
iflags.news = 0; /* prevent newgame() from re-displaying news */
nf = fopen(NEWS, "r");
if (nf != NULL) {
char line[LLEN + 1];
while (fgets(line, LLEN, nf)) {
size_t len;
len = strlen(line);
if (len > 0 && line[len - 1] == '\n') {
line[len - 1] = '\r';
line[len] = '\n';
line[len + 1] = '\0';
len++;
}
if (strsize + (int) len + 1 > bufsize) {
bufsize += BUFSZ;
buf = realloc(buf, bufsize);
if (buf == NULL)
panic("out of memory");
}
strcat(buf, line);
strsize += len;
}
(void) fclose(nf);
} else {
strcat(buf, "No news.");
}
}
}
SetWindowText(GetDlgItem(hWnd, IDC_EXTRAINFO), buf);
free(buf);
ShowWindow(hWnd, SW_SHOW);
while (IsWindow(hWnd) && GetMessage(&msg, NULL, 0, 0) != 0) {
if (!IsDialogMessage(hWnd, &msg)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
GetNHApp()->hPopupWnd = NULL;
mswin_destroy_splashfonts();
}
static DWORD WINAPI password_thread(void *data)
{
tcn_pass_cb_t *cb = (tcn_pass_cb_t *)data;
MSG msg;
HWINSTA hwss;
HWINSTA hwsu;
HDESK hwds;
HDESK hwdu;
HWND hwnd;
/* Ensure connection to service window station and desktop, and
* save their handles.
*/
GetDesktopWindow();
hwss = GetProcessWindowStation();
hwds = GetThreadDesktop(GetCurrentThreadId());
/* Impersonate the client and connect to the User's
* window station and desktop.
*/
hwsu = OpenWindowStation("WinSta0", FALSE, MAXIMUM_ALLOWED);
if (hwsu == NULL) {
ExitThread(1);
return 1;
}
SetProcessWindowStation(hwsu);
hwdu = OpenDesktop("Default", 0, FALSE, MAXIMUM_ALLOWED);
if (hwdu == NULL) {
SetProcessWindowStation(hwss);
CloseWindowStation(hwsu);
ExitThread(1);
return 1;
}
SetThreadDesktop(hwdu);
hwnd = CreateDialog(dll_instance, MAKEINTRESOURCE(1001), NULL, NULL);
if (hwnd != NULL)
ShowWindow(hwnd, SW_SHOW);
else {
ExitThread(1);
return 1;
}
while (1) {
if (PeekMessage(&msg, hwnd, 0, 0, PM_REMOVE)) {
if (msg.message == WM_KEYUP) {
int nVirtKey = (int)msg.wParam;
if (nVirtKey == VK_ESCAPE) {
DestroyWindow(hwnd);
break;
}
else if (nVirtKey == VK_RETURN) {
HWND he = GetDlgItem(hwnd, 1002);
if (he) {
int n = GetWindowText(he, cb->password, SSL_MAX_PASSWORD_LEN - 1);
cb->password[n] = '\0';
}
DestroyWindow(hwnd);
break;
}
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
Sleep(100);
}
/* Restore window station and desktop.
*/
SetThreadDesktop(hwds);
SetProcessWindowStation(hwss);
CloseDesktop(hwdu);
CloseWindowStation(hwsu);
ExitThread(0);
return 0;
}
static INT_PTR CALLBACK NetAdapterDialogProc(
_In_ HWND hwndDlg,
_In_ UINT uMsg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
PPH_NETADAPTER_SYSINFO_CONTEXT context = NULL;
if (uMsg == WM_INITDIALOG)
{
context = (PPH_NETADAPTER_SYSINFO_CONTEXT)lParam;
SetProp(hwndDlg, L"Context", (HANDLE)context);
}
else
{
context = (PPH_NETADAPTER_SYSINFO_CONTEXT)GetProp(hwndDlg, L"Context");
if (uMsg == WM_NCDESTROY)
{
PhDeleteLayoutManager(&context->LayoutManager);
PhDeleteGraphState(&context->GraphState);
if (context->GraphHandle)
DestroyWindow(context->GraphHandle);
if (context->PanelWindowHandle)
DestroyWindow(context->PanelWindowHandle);
PhUnregisterCallback(&PhProcessesUpdatedEvent, &context->ProcessesUpdatedRegistration);
RemoveProp(hwndDlg, L"Context");
}
}
if (context == NULL)
return FALSE;
switch (uMsg)
{
case WM_INITDIALOG:
{
PPH_LAYOUT_ITEM graphItem;
PPH_LAYOUT_ITEM panelItem;
context->WindowHandle = hwndDlg;
PhInitializeGraphState(&context->GraphState);
PhInitializeLayoutManager(&context->LayoutManager, hwndDlg);
PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_ADAPTERNAME), NULL, PH_ANCHOR_LEFT | PH_ANCHOR_TOP | PH_ANCHOR_RIGHT | PH_LAYOUT_FORCE_INVALIDATE);
graphItem = PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_GRAPH_LAYOUT), NULL, PH_ANCHOR_ALL);
panelItem = PhAddLayoutItem(&context->LayoutManager, GetDlgItem(hwndDlg, IDC_LAYOUT), NULL, PH_ANCHOR_LEFT | PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM);
SendMessage(GetDlgItem(hwndDlg, IDC_ADAPTERNAME), WM_SETFONT, (WPARAM)context->SysinfoSection->Parameters->LargeFont, FALSE);
SetDlgItemText(hwndDlg, IDC_ADAPTERNAME, context->SysinfoSection->Name.Buffer);
context->PanelWindowHandle = CreateDialog(PluginInstance->DllBase, MAKEINTRESOURCE(IDD_NETADAPTER_PANEL), hwndDlg, NetAdapterPanelDialogProc);
ShowWindow(context->PanelWindowHandle, SW_SHOW);
PhAddLayoutItemEx(&context->LayoutManager, context->PanelWindowHandle, NULL, PH_ANCHOR_LEFT | PH_ANCHOR_RIGHT | PH_ANCHOR_BOTTOM, panelItem->Margin);
// Create the graph control.
context->GraphHandle = CreateWindow(
PH_GRAPH_CLASSNAME,
NULL,
WS_VISIBLE | WS_CHILD | WS_BORDER,
0,
0,
3,
3,
hwndDlg,
NULL,
PluginInstance->DllBase,
NULL
);
Graph_SetTooltip(context->GraphHandle, TRUE);
PhAddLayoutItemEx(&context->LayoutManager, context->GraphHandle, NULL, PH_ANCHOR_ALL, graphItem->Margin);
PhRegisterCallback(
&PhProcessesUpdatedEvent,
ProcessesUpdatedHandler,
context,
&context->ProcessesUpdatedRegistration
);
NetAdapterUpdateGraphs(context);
NetAdapterUpdatePanel(context);
}
break;
case WM_SIZE:
PhLayoutManagerLayout(&context->LayoutManager);
break;
case WM_NOTIFY:
{
NMHDR* header = (NMHDR*)lParam;
if (header->hwndFrom == context->GraphHandle)
{
switch (header->code)
{
case GCN_GETDRAWINFO:
{
PPH_GRAPH_GETDRAWINFO getDrawInfo = (PPH_GRAPH_GETDRAWINFO)header;
PPH_GRAPH_DRAW_INFO drawInfo = getDrawInfo->DrawInfo;
drawInfo->Flags = PH_GRAPH_USE_GRID | PH_GRAPH_USE_LINE_2;
context->SysinfoSection->Parameters->ColorSetupFunction(drawInfo, PhGetIntegerSetting(L"ColorCpuKernel"), PhGetIntegerSetting(L"ColorCpuUser"));
PhGraphStateGetDrawInfo(
&context->GraphState,
getDrawInfo,
context->InboundBuffer.Count
);
if (!context->GraphState.Valid)
{
FLOAT maxGraphHeight1 = 0;
FLOAT maxGraphHeight2 = 0;
for (ULONG i = 0; i < drawInfo->LineDataCount; i++)
{
context->GraphState.Data1[i] = (FLOAT)PhGetItemCircularBuffer_ULONG64(&context->InboundBuffer, i);
context->GraphState.Data2[i] = (FLOAT)PhGetItemCircularBuffer_ULONG64(&context->OutboundBuffer, i);
if (context->GraphState.Data1[i] > maxGraphHeight1)
maxGraphHeight1 = context->GraphState.Data1[i];
if (context->GraphState.Data2[i] > maxGraphHeight2)
maxGraphHeight2 = context->GraphState.Data2[i];
}
// Scale the data.
PhxfDivideSingle2U(
context->GraphState.Data1,
maxGraphHeight1,
drawInfo->LineDataCount
);
// Scale the data.
PhxfDivideSingle2U(
context->GraphState.Data2,
maxGraphHeight2,
drawInfo->LineDataCount
);
context->GraphState.Valid = TRUE;
}
}
break;
case GCN_GETTOOLTIPTEXT:
{
PPH_GRAPH_GETTOOLTIPTEXT getTooltipText = (PPH_GRAPH_GETTOOLTIPTEXT)header;
if (getTooltipText->Index < getTooltipText->TotalCount)
{
if (context->GraphState.TooltipIndex != getTooltipText->Index)
{
ULONG64 adapterInboundValue = PhGetItemCircularBuffer_ULONG64(
&context->InboundBuffer,
getTooltipText->Index
);
ULONG64 adapterOutboundValue = PhGetItemCircularBuffer_ULONG64(
&context->OutboundBuffer,
getTooltipText->Index
);
PhSwapReference2(&context->GraphState.TooltipText, PhFormatString(
L"R: %s\nS: %s\n%s",
PhaFormatSize(adapterInboundValue, -1)->Buffer,
PhaFormatSize(adapterOutboundValue, -1)->Buffer,
((PPH_STRING)PHA_DEREFERENCE(PhGetStatisticsTimeString(NULL, getTooltipText->Index)))->Buffer
));
}
getTooltipText->Text = context->GraphState.TooltipText->sr;
}
}
break;
}
}
}
break;
case MSG_UPDATE:
{
NetAdapterUpdateGraphs(context);
NetAdapterUpdatePanel(context);
}
break;
}
return FALSE;
}
void EVALOBJ::make_dialog(void)
{
display_toolbox(hDlg=CreateDialog(hInst, (LPCTSTR)IDD_EVALBOX, ghWndStatusbox, (DLGPROC)EvalDlgHandler));
}
static INT_PTR CALLBACK DialogProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
static activePage = 0;
switch (msg)
{
/* init */
case WM_INITDIALOG:
{
LOCALDATA *data = LocalAlloc(LPTR, sizeof(LOCALDATA));
HINSTANCE inst = (HINSTANCE)lParam;
TCITEM item;
/* init */
SetWindowLong(hwnd, GWL_USERDATA, (LONG)data);
data->htab = GetDlgItem(hwnd, IDC_TABS);
data->hdlg = NULL;
/* add pages */
item.mask = TCIF_TEXT;
data->all[0] = CreateDialog(inst, MAKEINTRESOURCE(IDD_CONFIG_GENERAL), hwnd, GeneralProc);
item.pszText = "General";
TabCtrl_InsertItem(data->htab, 0, &item);
data->all[1] = CreateDialog(inst, MAKEINTRESOURCE(IDD_CONFIG_OUTPUT), hwnd, OutputProc);
item.pszText = "Output";
TabCtrl_InsertItem(data->htab, 1, &item);
/* get rect (after adding pages) */
GetWindowRect(data->htab, &data->r);
ScreenToClientRect(hwnd, &data->r);
TabCtrl_AdjustRect(data->htab, 0, &data->r);
/* simulate item change */
TabCtrl_SetCurSel(data->htab, activePage);
OnSelChange(hwnd);
}
return TRUE;
/* destory */
case WM_DESTROY:
{
LOCALDATA *data = (LOCALDATA*)GetWindowLong(hwnd, GWL_USERDATA);
int i;
activePage = TabCtrl_GetCurSel(data->htab);
for (i=0; i<NUM_PAGES; i++)
DestroyWindow(data->all[i]);
LocalFree(data);
}
break;
/* commands */
case WM_COMMAND:
switch (LOWORD(wParam))
{
/* ok/cancel */
case IDOK:
BroadcastCommand(hwnd, IDOK);
/* fall through */
case IDCANCEL:
EndDialog(hwnd, LOWORD(wParam));
return TRUE;
case IDC_RESET:
SendCommand(hwnd, IDC_RESET);
break;
}
break;
/* notification */
case WM_NOTIFY:
if (LOWORD(wParam) == IDC_TABS)
{
NMHDR *hdr = (NMHDR*)lParam;
switch (hdr->code)
{
case TCN_SELCHANGE:
OnSelChange(hwnd);
break;
}
}
break;
}
return 0;
}
