/*
* Dialog-box function for the main PuTTYgen dialog box.
*/
static int CALLBACK MainDlgProc(HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam)
{
static const char generating_msg[] =
"Please wait while a key is generated...";
static const char entropy_msg[] =
"Please generate some randomness by moving the mouse over the blank area.";
struct MainDlgState *state;
switch (msg) {
case WM_INITDIALOG:
if (help_path)
SetWindowLong(hwnd, GWL_EXSTYLE,
GetWindowLong(hwnd, GWL_EXSTYLE) | WS_EX_CONTEXTHELP);
else {
/*
* If we add a Help button, this is where we destroy it
* if the help file isn't present.
*/
}
requested_help = FALSE;
SendMessage(hwnd, WM_SETICON, (WPARAM) ICON_BIG,
(LPARAM) LoadIcon(hinst, MAKEINTRESOURCE(200)));
state = snew(struct MainDlgState);
state->generation_thread_exists = FALSE;
state->collecting_entropy = FALSE;
state->entropy = NULL;
state->key_exists = FALSE;
SetWindowLong(hwnd, GWL_USERDATA, (LONG) state);
{
HMENU menu, menu1;
menu = CreateMenu();
menu1 = CreateMenu();
AppendMenu(menu1, MF_ENABLED, IDC_LOAD, "&Load private key");
AppendMenu(menu1, MF_ENABLED, IDC_SAVEPUB, "Save p&ublic key");
AppendMenu(menu1, MF_ENABLED, IDC_SAVE, "&Save private key");
AppendMenu(menu1, MF_SEPARATOR, 0, 0);
AppendMenu(menu1, MF_ENABLED, IDC_QUIT, "E&xit");
AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&File");
state->filemenu = menu1;
menu1 = CreateMenu();
AppendMenu(menu1, MF_ENABLED, IDC_GENERATE, "&Generate key pair");
AppendMenu(menu1, MF_SEPARATOR, 0, 0);
AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH1, "SSH&1 key (RSA)");
AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2RSA, "SSH2 &RSA key");
AppendMenu(menu1, MF_ENABLED, IDC_KEYSSH2DSA, "SSH2 &DSA key");
AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Key");
state->keymenu = menu1;
menu1 = CreateMenu();
AppendMenu(menu1, MF_ENABLED, IDC_IMPORT, "&Import key");
AppendMenu(menu1, MF_SEPARATOR, 0, 0);
AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_OPENSSH,
"Export &OpenSSH key");
AppendMenu(menu1, MF_ENABLED, IDC_EXPORT_SSHCOM,
"Export &ssh.com key");
AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1,
"Con&versions");
state->cvtmenu = menu1;
menu1 = CreateMenu();
AppendMenu(menu1, MF_ENABLED, IDC_ABOUT, "&About");
if (help_path)
AppendMenu(menu1, MF_ENABLED, IDC_GIVEHELP, "&Help");
AppendMenu(menu, MF_POPUP | MF_ENABLED, (UINT) menu1, "&Help");
SetMenu(hwnd, menu);
}
/*
* Centre the window.
*/
{ /* centre the window */
RECT rs, rd;
HWND hw;
hw = GetDesktopWindow();
if (GetWindowRect(hw, &rs) && GetWindowRect(hwnd, &rd))
MoveWindow(hwnd,
(rs.right + rs.left + rd.left - rd.right) / 2,
(rs.bottom + rs.top + rd.top - rd.bottom) / 2,
rd.right - rd.left, rd.bottom - rd.top, TRUE);
}
{
struct ctlpos cp, cp2;
/* Accelerators used: acglops1rbd */
ctlposinit(&cp, hwnd, 4, 4, 4);
beginbox(&cp, "Key", IDC_BOX_KEY);
cp2 = cp;
statictext(&cp2, "No key.", 1, IDC_NOKEY);
cp2 = cp;
statictext(&cp2, "", 1, IDC_GENERATING);
progressbar(&cp2, IDC_PROGRESS);
bigeditctrl(&cp,
"&Public key for pasting into authorized_keys file:",
IDC_PKSTATIC, IDC_KEYDISPLAY, 5);
SendDlgItemMessage(hwnd, IDC_KEYDISPLAY, EM_SETREADONLY, 1, 0);
staticedit(&cp, "Key f&ingerprint:", IDC_FPSTATIC,
IDC_FINGERPRINT, 75);
SendDlgItemMessage(hwnd, IDC_FINGERPRINT, EM_SETREADONLY, 1,
0);
staticedit(&cp, "Key &comment:", IDC_COMMENTSTATIC,
IDC_COMMENTEDIT, 75);
staticpassedit(&cp, "Key p&assphrase:", IDC_PASSPHRASE1STATIC,
IDC_PASSPHRASE1EDIT, 75);
staticpassedit(&cp, "C&onfirm passphrase:",
IDC_PASSPHRASE2STATIC, IDC_PASSPHRASE2EDIT, 75);
endbox(&cp);
beginbox(&cp, "Actions", IDC_BOX_ACTIONS);
staticbtn(&cp, "Generate a public/private key pair",
IDC_GENSTATIC, "&Generate", IDC_GENERATE);
staticbtn(&cp, "Load an existing private key file",
IDC_LOADSTATIC, "&Load", IDC_LOAD);
static2btn(&cp, "Save the generated key", IDC_SAVESTATIC,
"Save p&ublic key", IDC_SAVEPUB,
"&Save private key", IDC_SAVE);
endbox(&cp);
beginbox(&cp, "Parameters", IDC_BOX_PARAMS);
radioline(&cp, "Type of key to generate:", IDC_TYPESTATIC, 3,
"SSH&1 (RSA)", IDC_KEYSSH1,
"SSH2 &RSA", IDC_KEYSSH2RSA,
"SSH2 &DSA", IDC_KEYSSH2DSA, NULL);
staticedit(&cp, "Number of &bits in a generated key:",
IDC_BITSSTATIC, IDC_BITS, 20);
endbox(&cp);
}
CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA, IDC_KEYSSH2RSA);
CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
IDC_KEYSSH2RSA, MF_BYCOMMAND);
SetDlgItemInt(hwnd, IDC_BITS, DEFAULT_KEYSIZE, FALSE);
/*
* Initially, hide the progress bar and the key display,
* and show the no-key display. Also disable the Save
* buttons, because with no key we obviously can't save
* anything.
*/
ui_set_state(hwnd, state, 0);
/*
* Load a key file if one was provided on the command line.
*/
if (cmdline_keyfile)
load_key_file(hwnd, state, filename_from_str(cmdline_keyfile), 0);
return 1;
case WM_MOUSEMOVE:
state = (struct MainDlgState *) GetWindowLong(hwnd, GWL_USERDATA);
if (state->collecting_entropy &&
state->entropy && state->entropy_got < state->entropy_required) {
state->entropy[state->entropy_got++] = lParam;
state->entropy[state->entropy_got++] = GetMessageTime();
SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS,
state->entropy_got, 0);
if (state->entropy_got >= state->entropy_required) {
struct rsa_key_thread_params *params;
DWORD threadid;
/*
* Seed the entropy pool
*/
random_add_heavynoise(state->entropy, state->entropy_size);
memset(state->entropy, 0, state->entropy_size);
sfree(state->entropy);
state->collecting_entropy = FALSE;
SetDlgItemText(hwnd, IDC_GENERATING, generating_msg);
SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETRANGE, 0,
MAKELPARAM(0, PROGRESSRANGE));
SendDlgItemMessage(hwnd, IDC_PROGRESS, PBM_SETPOS, 0, 0);
params = snew(struct rsa_key_thread_params);
params->progressbar = GetDlgItem(hwnd, IDC_PROGRESS);
params->dialog = hwnd;
params->keysize = state->keysize;
params->is_dsa = state->is_dsa;
params->key = &state->key;
params->dsskey = &state->dsskey;
if (!CreateThread(NULL, 0, generate_rsa_key_thread,
params, 0, &threadid)) {
MessageBox(hwnd, "Out of thread resources",
"Key generation error",
MB_OK | MB_ICONERROR);
sfree(params);
} else {
state->generation_thread_exists = TRUE;
}
}
}
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_KEYSSH1:
case IDC_KEYSSH2RSA:
case IDC_KEYSSH2DSA:
{
state = (struct MainDlgState *)
GetWindowLong(hwnd, GWL_USERDATA);
if (!IsDlgButtonChecked(hwnd, LOWORD(wParam)))
CheckRadioButton(hwnd, IDC_KEYSSH1, IDC_KEYSSH2DSA,
LOWORD(wParam));
CheckMenuRadioItem(state->keymenu, IDC_KEYSSH1, IDC_KEYSSH2DSA,
LOWORD(wParam), MF_BYCOMMAND);
}
break;
case IDC_QUIT:
PostMessage(hwnd, WM_CLOSE, 0, 0);
break;
case IDC_COMMENTEDIT:
if (HIWORD(wParam) == EN_CHANGE) {
state = (struct MainDlgState *)
GetWindowLong(hwnd, GWL_USERDATA);
if (state->key_exists) {
HWND editctl = GetDlgItem(hwnd, IDC_COMMENTEDIT);
int len = GetWindowTextLength(editctl);
if (*state->commentptr)
sfree(*state->commentptr);
*state->commentptr = snewn(len + 1, char);
GetWindowText(editctl, *state->commentptr, len + 1);
if (state->ssh2) {
setupbigedit2(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
&state->ssh2key);
} else {
setupbigedit1(hwnd, IDC_KEYDISPLAY, IDC_PKSTATIC,
&state->key);
}
}
}
Menu::Menu(const String& label)
: MenuOperator(CreateMenu())
, m_label(label)
{
}
LRESULT CALLBACK RamWatchProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RECT r;
RECT r2;
int dx1, dy1, dx2, dy2;
static int watchIndex=0;
Update_RAM_Watch();
switch(uMsg)
{
case WM_MOVE: {
RECT wrect;
GetWindowRect(hDlg,&wrect);
ramw_x = wrect.left;
ramw_y = wrect.top;
break;
};
case WM_INITDIALOG: {
GetWindowRect(MainWindow->getHWnd(), &r); //Ramwatch window
dx1 = (r.right - r.left) / 2;
dy1 = (r.bottom - r.top) / 2;
GetWindowRect(hDlg, &r2); // Gens window
dx2 = (r2.right - r2.left) / 2;
dy2 = (r2.bottom - r2.top) / 2;
// push it away from the main window if we can
const int width = (r.right-r.left);
const int height = (r.bottom - r.top);
const int width2 = (r2.right-r2.left);
if(r.left+width2 + width < GetSystemMetrics(SM_CXSCREEN))
{
r.right += width;
r.left += width;
}
else if((int)r.left - (int)width2 > 0)
{
r.right -= width2;
r.left -= width2;
}
//-----------------------------------------------------------------------------------
//If user has Save Window Pos selected, override default positioning
if (RWSaveWindowPos)
{
//If ramwindow is for some reason completely off screen, use default instead
if (ramw_x > (-width*2) || ramw_x < (width*2 + GetSystemMetrics(SM_CYSCREEN)) )
r.left = ramw_x; //This also ignores cases of windows -32000 error codes
//If ramwindow is for some reason completely off screen, use default instead
if (ramw_y > (0-height*2) ||ramw_y < (height*2 + GetSystemMetrics(SM_CYSCREEN)) )
r.top = ramw_y; //This also ignores cases of windows -32000 error codes
}
//-------------------------------------------------------------------------------------
SetWindowPos(hDlg, NULL, r.left, r.top, NULL, NULL, SWP_NOSIZE | SWP_NOZORDER | SWP_SHOWWINDOW);
ramwatchmenu=GetMenu(hDlg);
rwrecentmenu=CreateMenu();
UpdateRW_RMenu(rwrecentmenu, RAMMENU_FILE_RECENT, RW_MENU_FIRST_RECENT_FILE);
const char* names[3] = {"Address","Value","Notes"};
int widths[3] = {62,64,64+51+53};
init_list_box(GetDlgItem(hDlg,IDC_WATCHLIST),names,3,widths);
/* if (!ResultCount) //TODO what do these do
reset_address_info();
else
signal_new_frame();*/
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
// if (!noMisalign) SendDlgItemMessage(hDlg, IDC_MISALIGN, BM_SETCHECK, BST_CHECKED, 0);
// if (littleEndian) SendDlgItemMessage(hDlg, IDC_ENDIAN, BM_SETCHECK, BST_CHECKED, 0);
RamWatchAccels = LoadAccelerators(hAppInst, MAKEINTRESOURCE(IDR_ACCELERATOR1));
// due to some bug in windows, the arrow button width from the resource gets ignored, so we have to set it here
SetWindowPos(GetDlgItem(hDlg,ID_WATCHES_UPDOWN), 0,0,0, 30,60, SWP_NOMOVE);
Update_RAM_Watch();
DragAcceptFiles(hDlg, TRUE);
RefreshWatchListSelectedCountControlStatus(hDlg);
return true;
break;
}
case WM_INITMENU:
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_AUTOLOAD, AutoRWLoad ? MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_SAVEWINDOW, RWSaveWindowPos ? MF_CHECKED : MF_UNCHECKED);
break;
case WM_MENUSELECT:
case WM_ENTERSIZEMOVE:
break;
case WM_NOTIFY:
{
switch(wParam)
{
case ID_WATCHES_UPDOWN:
{
switch(((LPNMUPDOWN)lParam)->hdr.code)
{
case UDN_DELTAPOS:
int delta = ((LPNMUPDOWN)lParam)->iDelta;
SendMessage(hDlg, WM_COMMAND, delta<0 ? IDC_C_WATCH_UP : IDC_C_WATCH_DOWN,0);
break;
}
}
default:
{
LPNMHDR lP = (LPNMHDR) lParam;
switch (lP->code)
{
case LVN_ITEMCHANGED: // selection changed event
{
NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)lP;
if(pNMListView->uNewState & LVIS_FOCUSED ||
(pNMListView->uNewState ^ pNMListView->uOldState) & LVIS_SELECTED)
{
// disable buttons that we don't have the right number of selected items for
RefreshWatchListSelectedCountControlStatus(hDlg);
}
} break;
case LVN_GETDISPINFO:
{
LV_DISPINFO *Item = (LV_DISPINFO *)lParam;
Item->item.mask = LVIF_TEXT;
Item->item.state = 0;
Item->item.iImage = 0;
const unsigned int iNum = Item->item.iItem;
static char num[11];
switch (Item->item.iSubItem)
{
case 0:
sprintf(num,"%08X",rswatches[iNum].Address);
Item->item.pszText = num;
return true;
case 1: {
int i = rswatches[iNum].CurValue;
int t = rswatches[iNum].Type;
int size = rswatches[iNum].Size;
const char* formatString = ((t=='s') ? "%d" : (t=='u') ? "%u" : (size=='d' ? "%08X" : size=='w' ? "%04X" : "%02X"));
if(t=='f')
{
sprintf(num,"%f",i/4096.0f);
}
else
switch (size)
{
case 'b':
default: sprintf(num, formatString, t=='s' ? (char)(i&0xff) : (unsigned char)(i&0xff)); break;
case 'w': sprintf(num, formatString, t=='s' ? (short)(i&0xffff) : (unsigned short)(i&0xffff)); break;
case 'd': sprintf(num, formatString, t=='s' ? (long)(i&0xffffffff) : (unsigned long)(i&0xffffffff)); break;
}
Item->item.pszText = num;
} return true;
case 2:
Item->item.pszText = rswatches[iNum].comment ? rswatches[iNum].comment : "";
return true;
default:
return false;
}
}
case LVN_ODFINDITEM:
{
// disable search by keyboard typing,
// because it interferes with some of the accelerators
// and it isn't very useful here anyway
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST)));
return 1;
}
}
}
}
break;
}
case WM_COMMAND:
switch(LOWORD(wParam))
{
case RAMMENU_FILE_SAVE:
QuickSaveWatches();
break;
case RAMMENU_FILE_SAVEAS:
return Save_Watches();
case RAMMENU_FILE_OPEN:
return Load_Watches(true);
case RAMMENU_FILE_APPEND:
return Load_Watches(false);
case RAMMENU_FILE_NEW:
ResetWatches();
return true;
case IDC_C_WATCH_REMOVE:
{
HWND watchListControl = GetDlgItem(hDlg, IDC_WATCHLIST);
watchIndex = ListView_GetNextItem(watchListControl, -1, LVNI_ALL | LVNI_SELECTED);
while (watchIndex >= 0)
{
RemoveWatch(watchIndex);
ListView_DeleteItem(watchListControl, watchIndex);
watchIndex = ListView_GetNextItem(watchListControl, -1, LVNI_ALL | LVNI_SELECTED);
}
RWfileChanged=true;
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
}
case IDC_C_WATCH_EDIT:
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
if(watchIndex != -1)
{
DialogBoxParam(hAppInst, MAKEINTRESOURCE(IDD_EDITWATCH), hDlg, (DLGPROC) EditWatchProc,(LPARAM) watchIndex);
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
}
return true;
case IDC_C_WATCH:
rswatches[WatchCount].Address = rswatches[WatchCount].WrongEndian = 0;
rswatches[WatchCount].Size = 'b';
rswatches[WatchCount].Type = 's';
DialogBoxParam(hAppInst, MAKEINTRESOURCE(IDD_EDITWATCH), hDlg, (DLGPROC) EditWatchProc,(LPARAM) WatchCount);
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
case IDC_C_WATCH_DUPLICATE:
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
if(watchIndex != -1)
{
rswatches[WatchCount].Address = rswatches[watchIndex].Address;
rswatches[WatchCount].WrongEndian = rswatches[watchIndex].WrongEndian;
rswatches[WatchCount].Size = rswatches[watchIndex].Size;
rswatches[WatchCount].Type = rswatches[watchIndex].Type;
DialogBoxParam(hAppInst, MAKEINTRESOURCE(IDD_EDITWATCH), hDlg, (DLGPROC) EditWatchProc,(LPARAM) WatchCount);
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
}
return true;
case IDC_C_WATCH_SEPARATE:
AddressWatcher separator;
separator.Address = 0;
separator.WrongEndian = false;
separator.Size = 'S';
separator.Type = 'S';
InsertWatch(separator, "----------------------------");
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
return true;
case IDC_C_WATCH_UP:
{
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
if (watchIndex == 0 || watchIndex == -1)
return true;
void *tmp = malloc(sizeof(AddressWatcher));
memcpy(tmp,&(rswatches[watchIndex]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex]),&(rswatches[watchIndex - 1]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex - 1]),tmp,sizeof(AddressWatcher));
free(tmp);
ListView_SetItemState(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex,0,LVIS_FOCUSED|LVIS_SELECTED);
ListView_SetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex-1);
ListView_SetItemState(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex-1,LVIS_FOCUSED|LVIS_SELECTED,LVIS_FOCUSED|LVIS_SELECTED);
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
RWfileChanged=true;
return true;
}
case IDC_C_WATCH_DOWN:
{
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
if (watchIndex >= WatchCount - 1 || watchIndex == -1)
return true;
void *tmp = malloc(sizeof(AddressWatcher));
memcpy(tmp,&(rswatches[watchIndex]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex]),&(rswatches[watchIndex + 1]),sizeof(AddressWatcher));
memcpy(&(rswatches[watchIndex + 1]),tmp,sizeof(AddressWatcher));
free(tmp);
ListView_SetItemState(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex,0,LVIS_FOCUSED|LVIS_SELECTED);
ListView_SetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex+1);
ListView_SetItemState(GetDlgItem(hDlg,IDC_WATCHLIST),watchIndex+1,LVIS_FOCUSED|LVIS_SELECTED,LVIS_FOCUSED|LVIS_SELECTED);
ListView_SetItemCount(GetDlgItem(hDlg,IDC_WATCHLIST),WatchCount);
RWfileChanged=true;
return true;
}
case RAMMENU_FILE_AUTOLOAD:
{
AutoRWLoad ^= 1;
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_AUTOLOAD, AutoRWLoad ? MF_CHECKED : MF_UNCHECKED);
break;
}
case RAMMENU_FILE_SAVEWINDOW:
{
RWSaveWindowPos ^=1;
CheckMenuItem(ramwatchmenu, RAMMENU_FILE_SAVEWINDOW, RWSaveWindowPos ? MF_CHECKED : MF_UNCHECKED);
break;
}
case IDC_C_ADDCHEAT:
{
watchIndex = ListView_GetSelectionMark(GetDlgItem(hDlg,IDC_WATCHLIST));
if(watchIndex != -1)
{
u32 address = rswatches[watchIndex].Address;
u8 size = (rswatches[watchIndex].Size=='b') ? 1 : (rswatches[watchIndex].Size=='w' ? 2 : 4);
u32 value = rswatches[watchIndex].CurValue;
const char* desc = rswatches[watchIndex].comment;
CheatsAddDialog(hDlg, address, value, size, desc);
}
break;
}
case IDCANCEL:
RamWatchHWnd = NULL;
DragAcceptFiles(hDlg, FALSE);
EndDialog(hDlg, true);
return true;
default:
if (LOWORD(wParam) >= RW_MENU_FIRST_RECENT_FILE && LOWORD(wParam) < RW_MENU_FIRST_RECENT_FILE+MAX_RECENT_WATCHES)
OpenRWRecentFile(LOWORD(wParam) - RW_MENU_FIRST_RECENT_FILE);
}
break;
case WM_KEYDOWN: // handle accelerator keys
{
SetFocus(GetDlgItem(hDlg,IDC_WATCHLIST));
MSG msg;
msg.hwnd = hDlg;
msg.message = uMsg;
msg.wParam = wParam;
msg.lParam = lParam;
if(RamWatchAccels && TranslateAccelerator(hDlg, RamWatchAccels, &msg))
return true;
} break;
case WM_CLOSE:
RamWatchHWnd = NULL;
DragAcceptFiles(hDlg, FALSE);
EndDialog(hDlg, true);
return true;
case WM_DROPFILES:
{
HDROP hDrop = (HDROP)wParam;
DragQueryFile(hDrop, 0, Str_Tmp, 1024);
DragFinish(hDrop);
return Load_Watches(true, Str_Tmp);
} break;
}
return false;
}
MedSLTPatWindow::MedSLTPatWindow(MedSLTPatWindowObserver& observer)
: m_observer(observer),
m_list_index(0),
m_list_items(0),
m_is_fullscreen(FALSE),
m_back_translation(""),
m_ui_state(UI_STATE_DISCONNECTED)
{
ACE_TRACE("[MedSLTPatWindow::MedSLTPatWindow()]");
GtkBox* hbox;
GtkBox* coverbox;
GtkBox* textbox;
GtkBox* buthbox;
GtkWidget* menu;
GtkWidget* appimage;
GtkWidget* scroll1;
GtkWidget* scroll2;
GtkWidget* scroll3;
PangoFontDescription* font1;
PangoFontDescription* font2;
GtkStyle* style;
GtkAccelGroup* accel = gtk_accel_group_new();
// Window
#ifdef _MAEMO
m_window = GTK_WINDOW(hildon_window_new());
#else
m_window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_default_size(m_window, 450, -1);
#endif
gtk_window_add_accel_group(m_window, accel);
gtk_window_set_icon_from_file(m_window, app_icon, NULL);
gtk_container_set_border_width(GTK_CONTAINER(m_window), 5);
// Boxes
coverbox = GTK_BOX(gtk_vbox_new(False, 5));
hbox = GTK_BOX(gtk_hbox_new(False, 5));
textbox = GTK_BOX(gtk_vbox_new(False, 5));
buthbox = GTK_BOX(gtk_vbox_new(False, 5));
// Image
appimage = gtk_image_new_from_file(app_icon_big);
// Fonts
font1 = pango_font_description_from_string("Monospace Bold 20");
font2 = pango_font_description_from_string("Monospace Bold 16");
// Styles
style = gtk_style_new();
style->font_desc = font1;
gdk_color_parse ("red", &(style->fg[GTK_STATE_NORMAL]));
// Lists
m_list = gtk_clist_new(1);
gtk_widget_set_size_request(GTK_WIDGET(m_list), 550, 130);
gtk_widget_modify_font(m_list, font1);
/*gchar* text[3][1] = { {"où avez vous mal?"},
{"avez vous mal sous le devant de la tête?"},
{"la douleur survient elle le matin?"}}; */
gchar* text[3][1] = { {"sí mucho"},
{"no sé"},
{"la cabeza"}};
gtk_clist_append((GtkCList*)m_list, text[0]);
gtk_clist_append((GtkCList*)m_list, text[1]);
gtk_clist_append((GtkCList*)m_list, text[2]);
m_list_items = 3;
gtk_clist_select_row((GtkCList*)m_list, 0, 0);
// Text Boxes
m_txtbox1 = gtk_text_view_new();
gtk_widget_modify_font(m_txtbox1, font1);
gtk_widget_set_size_request(GTK_WIDGET(m_txtbox1), 550, 50);
gtk_text_view_set_editable(GTK_TEXT_VIEW(m_txtbox1), false);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(m_txtbox1), GTK_WRAP_WORD_CHAR);
gtk_widget_set_style (m_txtbox1, style);
m_txtbox2 = gtk_text_view_new();
gtk_widget_modify_font(m_txtbox2, font1);
gtk_widget_set_size_request(GTK_WIDGET(m_txtbox2), 550, 50);
gtk_text_view_set_editable(GTK_TEXT_VIEW(m_txtbox2), false);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(m_txtbox2), GTK_WRAP_WORD_CHAR);
// Scroll bars
scroll1 = gtk_scrolled_window_new(NULL, NULL);
scroll2 = gtk_scrolled_window_new(NULL, NULL);
scroll3 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll1), GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll2), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll3), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll1), GTK_SHADOW_IN);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll2), GTK_SHADOW_IN);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll3), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(scroll1), GTK_WIDGET(m_list));
gtk_container_add(GTK_CONTAINER(scroll2), GTK_WIDGET(m_txtbox1));
gtk_container_add(GTK_CONTAINER(scroll3), GTK_WIDGET(m_txtbox2));
// Text labels
m_understood = gtk_label_new("Understood");
m_question = gtk_label_new("Question");
m_translation = gtk_label_new("Translation");
gtk_widget_modify_font(m_understood, font2);
gtk_widget_modify_font(m_question, font2);
gtk_widget_modify_font(m_translation, font2);
gtk_label_set_justify(GTK_LABEL(m_understood), GTK_JUSTIFY_LEFT);
gtk_label_set_justify(GTK_LABEL(m_question), GTK_JUSTIFY_LEFT);
gtk_label_set_justify(GTK_LABEL(m_translation), GTK_JUSTIFY_LEFT);
gtk_label_set_ellipsize(GTK_LABEL(m_understood), PANGO_ELLIPSIZE_END);
gtk_label_set_ellipsize(GTK_LABEL(m_question), PANGO_ELLIPSIZE_END);
gtk_label_set_ellipsize(GTK_LABEL(m_translation), PANGO_ELLIPSIZE_END);
// Buttons
m_rec = gtk_button_new();
m_speech = gtk_button_new();
m_abort = gtk_button_new();
m_up = gtk_button_new();
m_select = gtk_button_new();
m_down = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(m_rec),
gtk_image_new_from_file(record_icon));
gtk_button_set_image(GTK_BUTTON(m_speech),
gtk_image_new_from_file(speech_icon));
gtk_button_set_image(GTK_BUTTON(m_abort),
gtk_image_new_from_file(stop_icon));
gtk_button_set_image(GTK_BUTTON(m_up),
gtk_image_new_from_file(up_icon));
gtk_button_set_image(GTK_BUTTON(m_select),
gtk_image_new_from_file(select_icon));
gtk_button_set_image(GTK_BUTTON(m_down),
gtk_image_new_from_file(down_icon));
// Menu
// Recheck: Is it destroyed somewhere
menu = CreateMenu(accel);
// Progress bar
m_progressbar = gtk_progress_bar_new();
gtk_progress_set_text_alignment(GTK_PROGRESS(m_progressbar),
0.5, 0.5);
gtk_widget_set_size_request(GTK_WIDGET(m_progressbar), 150, 50);
//gtk_container_add(GTK_CONTAINER(m_window), GTK_WIDGET(vbox));
gtk_box_pack_start(textbox, m_understood, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, scroll1, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, m_question, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, scroll2, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, m_translation, TRUE, TRUE, 0);
gtk_box_pack_start(textbox, scroll3, TRUE, TRUE, 0);
//gtk_box_pack_start(buthbox, appimage, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_rec, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_speech, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_abort, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_up, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_select, TRUE, TRUE, 0);
gtk_box_pack_start(buthbox, m_down, TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(textbox), TRUE, TRUE, 0);
gtk_box_pack_start(hbox, GTK_WIDGET(buthbox), TRUE, TRUE, 0);
gtk_box_pack_start(coverbox, GTK_WIDGET(hbox), TRUE, TRUE, 0);
gtk_box_pack_start(coverbox, m_progressbar, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(m_window), GTK_WIDGET(coverbox));
#ifdef _MAEMO
hildon_window_set_menu(HILDON_WINDOW(m_window), GTK_MENU(menu));
#else
gtk_box_pack_start(vbox, menu, FALSE, FALSE, 0);
#endif
// Signals
g_signal_connect(G_OBJECT(m_rec), "clicked",
G_CALLBACK(RecognizeClicked), this);
g_signal_connect(G_OBJECT(m_speech), "clicked",
G_CALLBACK(AbortClicked), this);
g_signal_connect(G_OBJECT(m_abort), "clicked",
G_CALLBACK(AbortClicked), this);
g_signal_connect(G_OBJECT(m_up), "clicked",
G_CALLBACK(UpClicked), this);
g_signal_connect(G_OBJECT(m_select), "clicked",
G_CALLBACK(SelectClicked), this);
g_signal_connect(G_OBJECT(m_down), "clicked",
G_CALLBACK(DownClicked), this);
g_signal_connect(G_OBJECT(m_list), "select_row",
G_CALLBACK(ListRowSelected), this);
g_signal_connect(G_OBJECT(m_window), "destroy",
G_CALLBACK(CloseApp), this);
g_signal_connect(G_OBJECT(m_window), "delete_event",
G_CALLBACK(CloseApp), this);
// Shortcuts
#ifndef _MAEMO
gtk_widget_add_accelerator(m_rec, "clicked", accel, GDK_space,
0, 0);
gtk_widget_add_accelerator(m_speech, "clicked", accel, GDK_space,
0, 0);
gtk_widget_add_accelerator(m_abort, "clicked", accel, GDK_space,
0, 0);
gtk_widget_add_accelerator(m_next, "clicked", accel, GDK_Right,
GDK_CONTROL_MASK, 0);
#endif
// Initial state
SetUiState(UI_STATE_DISCONNECTED);
return;
}
STDMETHODIMP CDeskBand::QueryContextMenu(HMENU hMenu,
UINT indexMenu,
UINT idCmdFirst,
UINT /*idCmdLast*/,
UINT uFlags)
{
if ((uFlags & CMF_DEFAULTONLY)!=0)
return S_OK; //we don't change the default action
if (((uFlags & 0x000f)!=CMF_NORMAL)&&(!(uFlags & CMF_EXPLORE))&&(!(uFlags & CMF_VERBSONLY)))
return S_OK;
if ((m_ContextDirectory.empty()) && (m_ContextItems.empty()))
return S_OK;
if (m_ContextDirectory.empty())
{
// folder is empty, but maybe files are selected
if (m_ContextItems.empty())
return S_OK; // nothing selected - we don't have a menu to show
// check whether a selected entry is an UID - those are namespace extensions
// which we can't handle
for (std::map<tstring, ULONG>::const_iterator it = m_ContextItems.begin(); it != m_ContextItems.end(); ++it)
{
if (_tcsncmp(it->first.c_str(), _T("::{"), 3)==0)
return S_OK;
}
}
else
{
// ignore namespace extensions
if (_tcsncmp(m_ContextDirectory.c_str(), _T("::{"), 3)==0)
return S_OK;
}
if (DWORD(CRegStdDWORD(_T("Software\\StefansTools\\StExBar\\ContextMenu"), TRUE)) == FALSE)
return S_OK;
//check if we already added our menu entry for a folder.
//we check that by iterating through all menu entries and check if
//the dwItemData member points to our global ID string. That string is set
//by our shell extension when the folder menu is inserted.
TCHAR menubuf[MAX_PATH];
int count = GetMenuItemCount(hMenu);
for (int i=0; i<count; ++i)
{
MENUITEMINFO miif;
SecureZeroMemory(&miif, sizeof(MENUITEMINFO));
miif.cbSize = sizeof(MENUITEMINFO);
miif.fMask = MIIM_DATA;
miif.dwTypeData = menubuf;
miif.cch = _countof(menubuf);
GetMenuItemInfo(hMenu, i, TRUE, &miif);
if (miif.dwItemData == (ULONG_PTR)g_MenuIDString)
return S_OK;
}
UINT idCmd = idCmdFirst;
//create the sub menu
HMENU subMenu = CreateMenu();
int indexSubMenu = 0;
m_commands.LoadFromFile();
int index = 0;
for (int j = 0; j < m_commands.GetCount(); ++j)
{
MENUITEMINFO menuiteminfo = {0};
Command cmd = m_commands.GetCommand(j);
m_hotkeys[cmd.key] = j;
if ((cmd.commandline.compare(INTERNALCOMMANDHIDDEN)==0)&&(cmd.name.compare(_T("Options")) == 0))
{
cmd.commandline = INTERNALCOMMAND; // make sure the options button is never hidden.
m_commands.SetCommand(j, cmd);
}
if ((cmd.name.compare(_T("StexBar Internal Edit Box")) == 0)||
(cmd.commandline.compare(INTERNALCOMMANDHIDDEN) == 0)||
(cmd.name.compare(_T("New Folder")) == 0))
{
continue;
}
bool bEnabled = cmd.enabled_viewpath ||
(cmd.enabled_fileselected && !m_ContextItems.empty()) ||
(cmd.enabled_folderselected && (!m_ContextItems.empty() || !m_ContextDirectory.empty())) ||
(cmd.enabled_noselection && (m_ContextItems.empty())) ||
(cmd.enabled_selectedcount && (cmd.enabled_selectedcount == (int)!m_ContextItems.empty()));
HICON hIcon = LoadCommandIcon(cmd);
if (hIcon)
{
menuiteminfo.hbmpItem = IsWindowsVistaOrGreater() ? IconToBitmapPARGB32(hIcon) : HBMMENU_CALLBACK;
DestroyIcon(hIcon);
}
else
menuiteminfo.hbmpItem = NULL;
if (!cmd.separator)
m_tooltips[j] = cmd.name.c_str();
myIDMap[idCmd - idCmdFirst] = j;
myIDMap[idCmd] = j;
menuiteminfo.cbSize = sizeof(menuiteminfo);
menuiteminfo.fMask = cmd.separator ? MIIM_FTYPE : MIIM_FTYPE | MIIM_ID | MIIM_BITMAP | MIIM_STRING | MIIM_STATE;
menuiteminfo.fType = cmd.separator ? MFT_SEPARATOR : MFT_STRING;
menuiteminfo.fState = bEnabled ? MFS_ENABLED : MFS_DISABLED;
TCHAR menutextbuf[100];
_tcscpy_s(menutextbuf, _countof(menutextbuf), m_commands.GetCommandPtr(j)->name.c_str());
menuiteminfo.dwTypeData = menutextbuf;
menuiteminfo.wID = idCmd++;
InsertMenuItem(subMenu, indexSubMenu++, TRUE, &menuiteminfo);
index++;
}
//add sub menu to main context menu
//don't use InsertMenu because this will lead to multiple menu entries in the explorer file menu.
//see http://support.microsoft.com/default.aspx?scid=kb;en-us;214477 for details of that.
MENUITEMINFO menuiteminfo = {0};
SecureZeroMemory(&menuiteminfo, sizeof(menuiteminfo));
menuiteminfo.cbSize = sizeof(menuiteminfo);
menuiteminfo.fMask = MIIM_FTYPE | MIIM_ID | MIIM_SUBMENU | MIIM_DATA | MIIM_STRING;
menuiteminfo.fType = MFT_STRING;
menuiteminfo.dwTypeData = _T("StEx");
menuiteminfo.hSubMenu = subMenu;
menuiteminfo.wID = idCmd++;
InsertMenuItem(hMenu, indexMenu++, TRUE, &menuiteminfo);
//return number of menu items added
return ResultFromScode(MAKE_SCODE(SEVERITY_SUCCESS, 0, (USHORT)(idCmd - idCmdFirst)));
}
PlayerMenuItem *PlayerMenuServiceWin::addItem(const std::string &menuId,
const std::string &title,
const std::string &parentId,
int order /* = MAX_ORDER */)
{
if (menuId.length() == 0 || title.length() == 0)
{
CCLOG("MenuServiceWin::addItem() - menuId and title must is non-empty");
return nullptr;
}
// check menu id is exists
if (_items.find(menuId) != _items.end())
{
CCLOG("MenuServiceWin::addItem() - menu id (%s) is exists", menuId.c_str());
return false;
}
// set parent
PlayerMenuItemWin *parent = &_root;
if (parentId.length())
{
// query parent menu
auto it = _items.find(parentId);
if (it != _items.end())
{
parent = it->second;
}
}
if (!parent->_hmenu)
{
// create menu handle for parent (convert parent to submenu)
parent->_hmenu = CreateMenu();
parent->_isGroup = true;
MENUITEMINFO menuitem;
menuitem.cbSize = sizeof(menuitem);
menuitem.fMask = MIIM_SUBMENU;
menuitem.hSubMenu = parent->_hmenu;
if (!SetMenuItemInfo(parent->_parent->_hmenu, parent->_commandId, MF_BYCOMMAND, &menuitem))
{
DWORD err = GetLastError();
CCLOG("MenuServiceWin::addItem() - set menu handle failed, menu id (%s). error code = %u", parent->_menuId.c_str(), err);
return nullptr;
}
}
// create new menu item
_newCommandId++;
PlayerMenuItemWin *item = PlayerMenuItemWin::create(menuId, title);
item->_commandId = _newCommandId;
item->_parent = parent;
item->_parent->retain();
// add menu item to menu bar
MENUITEMINFO menuitem;
menuitem.cbSize = sizeof(menuitem);
menuitem.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STATE | MIIM_STRING;
menuitem.fType = (item->_title.compare("-") == 0) ? MFT_SEPARATOR : MFT_STRING;
menuitem.fState = (item->_isEnabled) ? MFS_ENABLED : MFS_DISABLED;
menuitem.fState |= (item->_isChecked) ? MFS_CHECKED : MFS_UNCHECKED;
std::u16string u16title;
cocos2d::StringUtils::UTF8ToUTF16(item->_title, u16title);
menuitem.dwTypeData = (LPTSTR)u16title.c_str();
menuitem.wID = _newCommandId;
// check new menu item position
if (order > parent->_children.size())
{
order = parent->_children.size();
}
else if (order < 0)
{
order = 0;
}
// create new menu item
if (!InsertMenuItem(parent->_hmenu, order, TRUE, &menuitem))
{
DWORD err = GetLastError();
CCLOG("MenuServiceWin::addItem() - insert new menu item failed, menu id (%s). error code = %u", item->_menuId.c_str(), err);
item->release();
return nullptr;
}
// update menu state
parent->_children.insert(order, item);
_items[item->_menuId] = item;
_commandId2menuId[item->_commandId] = item->_menuId;
updateChildrenOrder(parent);
return item;
}
CDROM* GetCDROM()
{
CDROM* first = NULL;
CDROM* last = NULL;
wchar_t* name = L"²¥·Å¹âÅÌ(&G)";
HMENU menu = GetMenu(main_wnd.hWnd);
HMENU sub = GetSubMenu(menu, 0);
MENUITEMINFO item = {0};
item.fMask = MIIM_STRING | MIIM_ID | MIIM_SUBMENU;
item.fType = MFT_STRING;
item.fState = MFS_ENABLED;
item.cbSize = sizeof(MENUITEMINFO);
item.cch = wcslen(name);
item.dwTypeData = name;
item.hSubMenu = CreateMenu();
InsertMenuItem(sub, 1, TRUE, &item);
DWORD n = GetLogicalDriveStrings(0, NULL);
if (n > 0)
{
wchar_t* buffer = new wchar_t[n];
DWORD len = GetLogicalDriveStrings(n, buffer);
wchar_t* ptr = buffer;
DWORD i = 0;
while (len > 0)
{
UINT type = GetDriveType(ptr);
if (type == DRIVE_CDROM)
{
wchar_t driver[16] = {0};
StrCat(driver, L"\\\\.\\");
StrNCat(driver, ptr, 3);
name = CDROMName(driver);
if (name != NULL)
{
StrTrim(name, L" ");
CDROM* cdrom = new CDROM();
ZeroMemory(cdrom, sizeof(CDROM));
StrNCat(cdrom->letter, ptr, 3);
StrCat(cdrom->driver, driver);
DWORD length = wcslen(name) + 16;
cdrom->name = new wchar_t[length];
wmemset(cdrom->name, 0, length);
StrCat(cdrom->name, L"[");
StrCat(cdrom->name, cdrom->letter);
StrCat(cdrom->name, L"] ");
StrCat(cdrom->name, name);
SAFE_DELETE_ARRAY(name);
cdrom->msgId = WM_USER + WM_CDROM + i;
cdrom->next = NULL;
i++;
if (first == NULL)
{
first = cdrom;
last = cdrom;
}
else
{
last->next = cdrom;
last = cdrom;
}
MENUITEMINFO child = {0};
child.fMask = MIIM_STRING | MIIM_ID;
child.fType = MFT_STRING;
child.fState = MFS_ENABLED;
child.cbSize = sizeof(MENUITEMINFO);
child.cch = wcslen(cdrom->name);
child.dwTypeData = cdrom->name;
child.wID = cdrom->msgId;
InsertMenuItem(item.hSubMenu, 0, FALSE, &child);
}
}
ptr += 4;
len -= 4;
}
SAFE_DELETE_ARRAY(buffer);
}
return first;
}
HMENU CreateTheMenu (int iNumDevs)
{
TCHAR szBuffer [32] ;
HMENU hMenu, hMenuPopup, hMenuSubPopup ;
int i, iFam, iIns ;
MIDIOUTCAPS moc ;
hMenu = CreateMenu () ;
// Create "On/Off" popup menu
hMenuPopup = CreateMenu () ;
AppendMenu (hMenuPopup, MF_STRING, IDM_OPEN, TEXT ("&Open")) ;
AppendMenu (hMenuPopup, MF_STRING | MF_CHECKED, IDM_CLOSE,
TEXT ("&Closed")) ;
AppendMenu (hMenu, MF_STRING | MF_POPUP, (UINT) hMenuPopup,
TEXT ("&Status")) ;
// Create "Device" popup menu
hMenuPopup = CreateMenu () ;
// Put MIDI Mapper on menu if it's installed
if (!midiOutGetDevCaps (MIDIMAPPER, &moc, sizeof (moc)))
AppendMenu (hMenuPopup, MF_STRING, IDM_DEVICE + (int) MIDIMAPPER,
moc.szPname) ;
else
iDevice = 0 ;
// Add the rest of the MIDI devices
for (i = 0 ; i < iNumDevs ; i++)
{
midiOutGetDevCaps (i, &moc, sizeof (moc)) ;
AppendMenu (hMenuPopup, MF_STRING, IDM_DEVICE + i, moc.szPname) ;
}
CheckMenuItem (hMenuPopup, 0, MF_BYPOSITION | MF_CHECKED) ;
AppendMenu (hMenu, MF_STRING | MF_POPUP, (UINT) hMenuPopup,
TEXT ("&Device")) ;
// Create "Channel" popup menu
hMenuPopup = CreateMenu () ;
for (i = 0 ; i < 16 ; i++)
{
wsprintf (szBuffer, TEXT ("%d"), i + 1) ;
AppendMenu (hMenuPopup, MF_STRING | (i ? MF_UNCHECKED : MF_CHECKED),
IDM_CHANNEL + i, szBuffer) ;
}
AppendMenu (hMenu, MF_STRING | MF_POPUP, (UINT) hMenuPopup,
TEXT ("&Channel")) ;
// Create "Voice" popup menu
hMenuPopup = CreateMenu () ;
for (iFam = 0 ; iFam < 16 ; iFam++)
{
hMenuSubPopup = CreateMenu () ;
for (iIns = 0 ; iIns < 8 ; iIns++)
{
wsprintf (szBuffer, TEXT ("&%d.\t%s"), iIns + 1,
fam[iFam].inst[iIns].szInst) ;
AppendMenu (hMenuSubPopup,
MF_STRING | (fam[iFam].inst[iIns].iVoice ?
MF_UNCHECKED : MF_CHECKED),
fam[iFam].inst[iIns].iVoice + IDM_VOICE,
szBuffer) ;
}
wsprintf (szBuffer, TEXT ("&%c.\t%s"), 'A' + iFam,
fam[iFam].szFam) ;
AppendMenu (hMenuPopup, MF_STRING | MF_POPUP, (UINT) hMenuSubPopup,
szBuffer) ;
}
AppendMenu (hMenu, MF_STRING | MF_POPUP, (UINT) hMenuPopup,
TEXT ("&Voice")) ;
return hMenu ;
}
/** Show the menu associated with a task list item. */
void ShowClientList(TaskBarType *bar, TaskEntry *tp)
{
Menu *menu;
MenuItem *item;
ClientEntry *cp;
const ScreenType *sp;
int x, y;
Window w;
if(settings.groupTasks) {
menu = CreateMenu();
item = CreateMenuItem(MENU_ITEM_NORMAL);
item->name = CopyString(_("Close"));
item->action.type = MA_CLOSE | MA_GROUP_MASK;
item->action.context = tp;
item->next = menu->items;
menu->items = item;
item = CreateMenuItem(MENU_ITEM_NORMAL);
item->name = CopyString(_("Minimize"));
item->action.type = MA_MINIMIZE | MA_GROUP_MASK;
item->action.context = tp;
item->next = menu->items;
menu->items = item;
item = CreateMenuItem(MENU_ITEM_NORMAL);
item->name = CopyString(_("Restore"));
item->action.type = MA_RESTORE | MA_GROUP_MASK;
item->action.context = tp;
item->next = menu->items;
menu->items = item;
item = CreateMenuItem(MENU_ITEM_SUBMENU);
item->name = CopyString(_("Send To"));
item->action.type = MA_SENDTO_MENU | MA_GROUP_MASK;
item->action.context = tp;
item->next = menu->items;
menu->items = item;
/* Load the separator and group actions. */
item = CreateMenuItem(MENU_ITEM_SEPARATOR);
item->next = menu->items;
menu->items = item;
/* Load the clients into the menu. */
for(cp = tp->clients; cp; cp = cp->next) {
if(!ShouldFocus(cp->client, 0)) {
continue;
}
item = CreateMenuItem(MENU_ITEM_NORMAL);
if(cp->client->state.status & STAT_MINIMIZED) {
size_t len = 0;
if(cp->client->name) {
len = strlen(cp->client->name);
}
item->name = Allocate(len + 3);
item->name[0] = '[';
memcpy(&item->name[1], cp->client->name, len);
item->name[len + 1] = ']';
item->name[len + 2] = 0;
} else {
item->name = CopyString(cp->client->name);
}
item->icon = cp->client->icon ? cp->client->icon : GetDefaultIcon();
item->action.type = MA_EXECUTE;
item->action.context = cp->client;
item->next = menu->items;
menu->items = item;
}
} else {
/* Not grouping clients. */
menu = CreateWindowMenu(tp->clients->client);
}
/* Initialize and position the menu. */
InitializeMenu(menu);
sp = GetCurrentScreen(bar->cp->screenx, bar->cp->screeny);
GetMousePosition(&x, &y, &w);
if(bar->layout == LAYOUT_HORIZONTAL) {
if(bar->cp->screeny + bar->cp->height / 2 < sp->y + sp->height / 2) {
/* Bottom of the screen: menus go up. */
y = bar->cp->screeny + bar->cp->height;
} else {
/* Top of the screen: menus go down. */
y = bar->cp->screeny - menu->height;
}
x -= menu->width / 2;
x = Max(x, sp->x);
} else {
if(bar->cp->screenx + bar->cp->width / 2 < sp->x + sp->width / 2) {
/* Left side: menus go right. */
x = bar->cp->screenx + bar->cp->width;
} else {
/* Right side: menus go left. */
x = bar->cp->screenx - menu->width;
}
y -= menu->height / 2;
y = Max(y, sp->y);
}
ShowMenu(menu, RunTaskBarCommand, x, y, 0);
DestroyMenu(menu);
}
LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
// Child windows' handles
static HWND hwndListBox, hwndNewItem, hwndAddButton, hwndRemoveButton, hwndClearButton, hwndHeightScroll, hwndWidthScroll;
static HINSTANCE hInstance;
// Size and position variables
int iSysWidth;
int iSysHeight;
int iWinWidth;
int iWinHeight;
int iWidth = 60; // Button width
int iHeight = 30; // Button height
int x;
int y;
int i, cxChar, cyChar;
// Menu & menu items
HMENU hMenu;
HMENU hSubMenu;
// String
char* szText;
int iTextLength;
// Paint and size structs
TEXTMETRIC tm;
SCROLLINFO si;
HBRUSH brush;
RECT rect, rct;
int color;
HDC hdc;
hdc = GetDC(hwnd);
GetTextMetrics(hdc, &tm);
cxChar = tm.tmAveCharWidth;
cyChar = tm.tmHeight;
ReleaseDC(hwnd, hdc);
switch(message) {
case WM_CREATE:
hwndListBox = CreateWindowEx(
(DWORD)NULL,
TEXT("ListBox"),
NULL,
WS_CHILD | WS_VISIBLE | WS_BORDER | LBS_NOTIFY | LBS_WANTKEYBOARDINPUT,
0, 0, 0, 0, hwnd,
(HMENU)IDC_LIST_BOX,
hProgramInstance,
NULL);
hwndNewItem = CreateWindowEx(
(DWORD)NULL,
TEXT("Edit"),
TEXT("Input candidates"),
WS_CHILD | WS_VISIBLE | WS_BORDER |ES_AUTOVSCROLL | ES_AUTOHSCROLL,
0, 0, 0, 0, hwnd,
(HMENU)IDC_NEW_ITEM,
hProgramInstance,
NULL);
hwndWidthScroll = CreateWindow(
"Scrollbar",
NULL,
WS_CHILD | WS_VISIBLE | SBS_HORZ | SBS_BOTTOMALIGN,
0, 0, 0, 0, hwnd,
(HMENU)IDC_WIDTH_SCROLL,
hProgramInstance,
NULL);
SetScrollRange(hwndWidthScroll, SB_CTL, 0, 100, FALSE);
SetScrollPos(hwndWidthScroll, SB_CTL, 0, FALSE);
hwndHeightScroll = CreateWindow(
"Scrollbar",
NULL,
WS_CHILD | WS_VISIBLE | SBS_VERT | SBS_BOTTOMALIGN,
0, 0, 0, 0, hwnd,
(HMENU)IDC_HEIGHT_SCROLL,
hProgramInstance,
NULL);
SetScrollRange(hwndHeightScroll, SB_CTL, 0, 100, TRUE);
SetScrollPos(hwndHeightScroll, SB_CTL, 0, FALSE);
hwndAddButton = CreateWindowEx(
(DWORD)NULL,
TEXT("Button"),
TEXT("Add"),
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
0, 0, 0, 0, hwnd,
(HMENU)IDC_ADD_BUTTON,
hProgramInstance,
NULL);
hwndRemoveButton = CreateWindowEx(
(DWORD)NULL,
TEXT("Button"),
TEXT("Remove"),
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
0, 0, 0, 0, hwnd,
(HMENU)IDC_REMOVE_BUTTON,
hProgramInstance,
NULL);
hwndClearButton = CreateWindowEx(
(DWORD)NULL,
TEXT("Button"),
TEXT("Clear"),
WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
0, 0, 0, 0, hwnd,
(HMENU)IDC_CLEAR_BUTTON,
hProgramInstance,
NULL);
// Create menu
hMenu = CreateMenu();
// Add "File" menu, with "Exit" submenu
hSubMenu = CreatePopupMenu();
AppendMenu(hMenu, MF_STRING | MF_POPUP, (UINT)hSubMenu, "&File");
AppendMenu(hSubMenu, MF_STRING, IDC_FILE_EXIT, "&Exit");
hSubMenu = CreatePopupMenu();
AppendMenu(hMenu, MF_STRING | MF_POPUP, (UINT)hSubMenu, "&Edit");
AppendMenu(hSubMenu, MF_STRING, IDC_MOVE, "&Jump around");
hSubMenu = CreatePopupMenu();
AppendMenu(hMenu, MF_STRING | MF_POPUP, (UINT)hSubMenu, "&Help");
AppendMenu(hSubMenu, MF_STRING, IDC_HELP_ABOUT, "&About");
// Set the menu
SetMenu(hwnd, hMenu);
break;
case WM_SIZE:
iWidth = LOWORD(lParam);
iHeight = HIWORD(lParam);
// Set vertical scroll bar range and page size
si.cbSize = sizeof(si);
si.fMask = SIF_RANGE | SIF_PAGE;
si.nMin = 0;
si.nMax = ((iMinWindowHeight - 70) / cyChar);
si.nPage = iHeight / cyChar;
SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
// Set horizontal scroll bar range and page size
si.cbSize = sizeof(si);
si.fMask = SIF_RANGE | SIF_PAGE;
si.nMin = 0;
si.nMax = ((iMinWindowWidth - 20) / cxChar);
si.nPage = iWidth / cxChar;
SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
// CHILD WINDOWS REPOSITION BEGIN
MoveWindow(hwndListBox, iWidth/2 - 210, iHeight/2 - 150, 300, 350, TRUE);
MoveWindow(hwndNewItem, iWidth/2 - 210, iHeight/2 - 220, 300, 50, TRUE);
MoveWindow(hwndWidthScroll, iWidth/2 - 210, iHeight/2 + 200, 410, 20, TRUE);
MoveWindow(hwndHeightScroll, iWidth/2 + 180, iHeight/2 - 220, 20, 410, TRUE);
MoveWindow(hwndAddButton, iWidth/2 + 100, iHeight/2 - 210, 60, 30, TRUE);
MoveWindow(hwndRemoveButton, iWidth/2 + 100, iHeight/2 - 140, 60, 30, TRUE);
MoveWindow(hwndClearButton, iWidth/2 + 100 , iHeight/2- 100, 60, 30, TRUE);
// CHILD WINDOWS REPOSITION END
GetWindowRect(hwnd, &rect);
iWinWidth = rect.right - rect.left;
iWinHeight = rect.bottom - rect.top;
iSysWidth = GetSystemMetrics(SM_CXSCREEN);
iSysHeight = GetSystemMetrics(SM_CYSCREEN);
// Set width scrollbar position
SetScrollPos(hwndWidthScroll, SB_CTL, (iWinWidth * 100 / iSysWidth), TRUE);
// Set height scrollbar position
SetScrollPos(hwndHeightScroll, SB_CTL, (iWinHeight * 100 / iSysHeight), TRUE);
break;
case WM_VSCROLL:
GetWindowRect(hwnd, &rect);
iWinWidth = rect.right - rect.left;
iWinHeight = rect.bottom - rect.top;
iSysWidth = GetSystemMetrics(SM_CXSCREEN);
iSysHeight = GetSystemMetrics(SM_CYSCREEN);
if(GetWindowLong((HWND)lParam, GWL_ID) == IDC_HEIGHT_SCROLL) {
si.cbSize = sizeof(si);
si.fMask = SIF_ALL;
GetScrollInfo(hwndHeightScroll, SB_CTL, &si);
y = si.nPos;
switch(LOWORD(wParam)) {
case SB_LINELEFT:
si.nPos -= 1;
break;
case SB_LINERIGHT:
si.nPos += 1;
break;
case SB_THUMBPOSITION:
si.nPos = si.nTrackPos;
break;
default:
break;
}
si.fMask = SIF_POS;
SetScrollInfo(hwndHeightScroll, SB_CTL, &si, TRUE);
GetScrollInfo(hwndHeightScroll, SB_CTL, &si);
if(si.nPos != y) {
SetScrollPos(hwndHeightScroll, SB_CTL, si.nPos, TRUE);
}
// Set window height
MoveWindow(hwnd, rect.left, rect.top, iWinWidth, (si.nPos * iSysHeight / 100), TRUE);
break;
}
// Get all the vertical scroll bar information
si.cbSize = sizeof(si);
si.fMask = SIF_ALL;
GetScrollInfo(hwnd, SB_VERT, &si);
// Save the position for later comparison
x = si.nPos;
switch(LOWORD(wParam)) {
case SB_TOP:
si.nPos = si.nMin;
break;
case SB_BOTTOM:
si.nPos = si.nMax;
break;
case SB_LINEUP:
si.nPos -= 1;
break;
case SB_LINEDOWN:
si.nPos += 1;
break;
case SB_PAGEUP:
si.nPos -= si.nPage;
break;
case SB_PAGEDOWN:
si.nPos += si.nPage;
break;
case SB_THUMBTRACK:
si.nPos = si.nTrackPos;
break;
default:
break;
}
// Set the position and then retrieve it
si.fMask = SIF_POS;
SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
GetScrollInfo(hwnd, SB_VERT, &si);
// If the position has changed, scroll the window and update it
if(si.nPos != x) {
ScrollWindow(hwnd, 0, cyChar * (y - si.nPos), NULL, NULL);
UpdateWindow(hwnd);
}
break;
case WM_HSCROLL:
GetWindowRect(hwnd, &rect);
iWinWidth = rect.right - rect.left;
iWinHeight = rect.bottom - rect.top;
iSysWidth = GetSystemMetrics(SM_CXSCREEN);
iSysHeight = GetSystemMetrics(SM_CYSCREEN);
if(GetWindowLong((HWND)lParam, GWL_ID) == IDC_WIDTH_SCROLL) {
si.cbSize = sizeof(si);
si.fMask = SIF_ALL;
GetScrollInfo(hwndWidthScroll, SB_CTL, &si);
x = si.nPos;
switch(LOWORD(wParam)) {
case SB_LINELEFT:
si.nPos -= 1;
break;
case SB_LINERIGHT:
si.nPos += 1;
break;
case SB_THUMBPOSITION:
si.nPos = si.nTrackPos;
break;
default:
break;
}
si.fMask = SIF_POS;
SetScrollInfo(hwndWidthScroll, SB_CTL, &si, TRUE);
GetScrollInfo(hwndWidthScroll, SB_CTL, &si);
if(si.nPos != x) {
SetScrollPos(hwndWidthScroll, SB_CTL, si.nPos, TRUE);
}
// Set window width
MoveWindow(hwnd, rect.left, rect.top, (si.nPos * iSysWidth / 100), iWinHeight, TRUE);
break;
}
// Get all the vertical scroll bar information
si.cbSize = sizeof(si);
si.fMask = SIF_ALL;
GetScrollInfo(hwnd, SB_HORZ, &si);
// Save the position for later comparison
x = si.nPos;
switch(LOWORD(wParam)) {
case SB_LINELEFT:
si.nPos -= 1;
break;
case SB_LINERIGHT:
si.nPos += 1;
break;
case SB_PAGELEFT:
si.nPos -= si.nPage;
break;
case SB_PAGERIGHT:
si.nPos += si.nPage;
break;
case SB_THUMBPOSITION:
si.nPos = si.nTrackPos;
break;
default:
break;
}
// Set the position and then retrieve it
si.fMask = SIF_POS;
SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
GetScrollInfo(hwnd, SB_HORZ, &si);
// If the position has changed, scroll the window and update it
if(si.nPos != x) {
ScrollWindow(hwnd, cxChar * (x - si.nPos), 0, NULL, 0);
UpdateWindow(hwnd);
}
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDC_LIST_BOX:
switch (HIWORD(wParam)) {
case LBN_DBLCLK:
MessageBox(NULL, TEXT("Candidate Selected!"), TEXT("Congrats!"), MB_OK);
break;
}
break;
case IDC_ADD_BUTTON:
iTextLength = SendMessage(hwndNewItem, WM_GETTEXTLENGTH, 0, 0);
szText = (char*)malloc(iTextLength+1);
SendMessage(hwndNewItem, WM_GETTEXT, iTextLength+1, (LPARAM)szText);
SendMessage(hwndListBox, LB_ADDSTRING, 0, (LPARAM)szText);
SendMessage(hwndNewItem, WM_SETTEXT, 0, (LPARAM)"");
free(szText);
break;
case IDC_REMOVE_BUTTON:
i = SendMessage(hwndListBox, LB_GETCURSEL, 0, 0);
if(i != LB_ERR) {
SendMessage(hwndListBox, LB_DELETESTRING, i, 0);
}
break;
case IDC_CLEAR_BUTTON:
SendMessage(hwndListBox, LB_RESETCONTENT, 0, 0);
break;
case IDC_FILE_EXIT:
SendMessage(hwnd, WM_DESTROY, 0, 0);
break;
case IDC_MOVE:
int xPos, yPos;
xPos = rand() % 1000;
yPos = rand() % 800;
SetWindowPos(hwnd, HWND_TOP, xPos, yPos, 0, 0, SWP_NOSIZE);
break;
case IDC_HELP_ABOUT:
return DialogBox(hProgramInstance, MAKEINTRESOURCE(IDD_ABOUT), NULL, (DLGPROC)DialogProcedure);
break;
default:
DefWindowProc(hwnd, WM_COMMAND, wParam, lParam);
break;
}
break;
case WM_KEYDOWN:
GetWindowRect(hwnd, &rect);
iWinWidth = rect.right - rect.left;
iWinHeight = rect.bottom - rect.top;
iSysWidth = GetSystemMetrics(SM_CXSCREEN);
iSysHeight = GetSystemMetrics(SM_CYSCREEN);
// Move window right on Shift + Arrow Right
if((wParam == VK_RIGHT)&&(HIBYTE(GetKeyState(VK_SHIFT)) > 1)) {
if(rect.left >= iSysWidth - iWinWidth) {
MoveWindow(hwnd, iSysWidth - iWinWidth, rect.top, iWinWidth, iWinHeight, TRUE);
}
else {
MoveWindow(hwnd, rect.left + 5, rect.top, iWinWidth, iWinHeight, TRUE);
}
break;
}
// Move window left on Shift + Arrow Left
if((wParam == VK_LEFT)&&(HIBYTE(GetKeyState(VK_SHIFT)) > 1)) {
if(rect.left <= 0) {
MoveWindow(hwnd, 0, rect.top, iWinWidth, iWinHeight, TRUE);
}
else {
MoveWindow(hwnd, rect.left - 5, rect.top, iWinWidth, iWinHeight, TRUE);
}
break;
}
// Move window down on Shift + Arrow Down
if((wParam == VK_DOWN)&&(HIBYTE(GetKeyState(VK_SHIFT)) > 1)) {
if(rect.top >= iSysHeight - iWinHeight) {
MoveWindow(hwnd, rect.left, iSysHeight - iWinHeight, iWinWidth, iWinHeight, TRUE);
}
else {
MoveWindow(hwnd, rect.left, rect.top + 5, iWinWidth, iWinHeight, TRUE);
}
break;
}
// Move window up on Shift + Arrow Up
if((wParam == VK_UP)&&(HIBYTE(GetKeyState(VK_SHIFT)) > 1)) {
if(rect.top <= 0) {
MoveWindow(hwnd, rect.left, 0, iWinWidth, iWinHeight, TRUE);
}
else {
MoveWindow(hwnd, rect.left, rect.top - 5, iWinWidth, iWinHeight, TRUE);
}
break;
}
return DefWindowProc (hwnd, WM_PAINT, wParam, lParam);
case WM_PAINT:
return DefWindowProc (hwnd, WM_PAINT, wParam, lParam);
break;
case WM_DESTROY:
PostQuitMessage (0);
break;
default:
return DefWindowProc (hwnd, message, wParam, lParam);
}
return 0;
}