static BOOL CALLBACK number_dialog_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
FRAME_BY_NUMBER *opt;
char buffer[256];
switch(msg) {
case WM_INITDIALOG:
center_dialog(hwnd);
opt = (FRAME_BY_NUMBER *)lparam;
SendMessage(GetDlgItem(hwnd, IDC_FRAME_SPIN), UDM_SETRANGE32, 0, (opt->max & 0x7fffffff));
sprintf(buffer, msg_table[opt->lang][MSG_MAX_FRAME_TEMPLATE], opt->max);
SetWindowText(GetDlgItem(hwnd, IDC_MAX_FRAME), buffer);
sprintf(buffer, "%I64d", opt->current);
SetWindowText(GetDlgItem(hwnd, IDC_FRAME_INDEX), buffer);
SetFocus(GetDlgItem(hwnd, IDC_FRAME_INDEX));
SetWindowLong(hwnd, GWL_USERDATA, (LONG)opt);
return FALSE;
case WM_COMMAND:
switch(LOWORD(wparam)) {
case IDOK:
opt = (FRAME_BY_NUMBER *)GetWindowLong(hwnd, GWL_USERDATA);
GetWindowText(GetDlgItem(hwnd, IDC_FRAME_INDEX), buffer, sizeof(buffer)-1);
opt->current = atoi(buffer);
EndDialog(hwnd, IDOK);
break;
case IDCANCEL:
EndDialog(hwnd, IDCANCEL);
break;
}
break;
}
return FALSE;
}
/*
* Function: Positions the kwin dialog either to the saved location
* or the center of the screen if no saved location.
*
* Parameters:
* hwnd - the window to center on the screen.
*/
static void
position_dialog(HWND hwnd)
{
int scrwidth, scrheight;
HDC hdc;
int x, y, cx, cy;
if (hwnd == NULL)
return;
hdc = GetDC(NULL);
scrwidth = GetDeviceCaps(hdc, HORZRES);
scrheight = GetDeviceCaps(hdc, VERTRES);
ReleaseDC(NULL, hdc);
x = cns_res.x;
y = cns_res.y;
cx = cns_res.cx;
cy = cns_res.cy;
if (x > scrwidth ||
y > scrheight ||
x + cx <= 0 ||
y + cy <= 0)
center_dialog(hwnd);
else
MoveWindow(hwnd, x, y, cx, cy, TRUE);
}
/*
* License callback
*/
INT_PTR CALLBACK license_callback(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) {
case WM_INITDIALOG:
center_dialog(hDlg);
SetDlgItemTextA(hDlg, IDC_LICENSE_TEXT, gplv3);
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
case IDCANCEL:
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
}
}
return (INT_PTR)FALSE;
}
static void show_cancel_dialog(gchar *text)
{
GtkWidget *button;
LOG(LOG_DEBUG, "IN : show_cancel_dialog()");
search_progress = 0.0;
// cancel_dialog = gtk_dialog_new();
cancel_dialog = gtk_dialog_new_with_buttons(text,
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT /* | GTK_DIALOG_NO_SEPARATOR */,
NULL);
g_signal_connect (G_OBJECT (cancel_dialog), "delete_event",
G_CALLBACK(delete_event), NULL);
gtk_widget_set_size_request(cancel_dialog, 200, -1);
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG(cancel_dialog)->vbox), 10);
button = gtk_button_new_with_label(_("Cancel"));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cancel_dialog)->action_area), button,
TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK(cancel_thread), (gpointer)NULL);
label_cancel = gtk_label_new (_("Searching"));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cancel_dialog)->vbox), label_cancel, TRUE,TRUE, 5);
progress = gtk_progress_bar_new();
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress), 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cancel_dialog)->vbox), progress, TRUE,TRUE, 5);
label_match = gtk_label_new ("0 hit");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cancel_dialog)->vbox), label_match, TRUE,TRUE, 5);
// gtk_window_set_position(GTK_WINDOW(cancel_dialog), GTK_WIN_POS_CENTER_ALWAYS);
gtk_widget_show_all(cancel_dialog);
center_dialog(main_window, cancel_dialog);
gtk_grab_add(cancel_dialog);
LOG(LOG_DEBUG, "OUT : show_cancel_dialog()");
}
void
TipButton::feel( int mouse )
{
init_dialog( Tip, NULL, NULL );
ready_dialog( Tip, NULL, NULL, tip_feel, NULL, NULL, NULL );
center_dialog( Tip );
save_under_dialog( Tip );
draw_dialog( Tip );
//CRASH//debug( "Render icon" );
gfx_blit( kyle_icon_data, Tip[ICON].sx, Tip[ICON].sy,
Tip[ICON].width, Tip[ICON].height, 15 );
_nTipOfTheDay = rand() % _nTips;
drawTipText();
do_dialog( Tip, -1 );
restore_under_dialog();
dialog_done = 0; // override inside dialog box's setting
}
/*
* Update policy and settings dialog callback
*/
INT_PTR CALLBACK UpdateCallback(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
HWND hPolicy;
static HWND hFrequency, hBeta;
int32_t freq;
char update_policy_text[4096];
switch (message) {
case WM_INITDIALOG:
set_title_bar_icon(hDlg);
center_dialog(hDlg);
hFrequency = GetDlgItem(hDlg, IDC_UPDATE_FREQUENCY);
hBeta = GetDlgItem(hDlg, IDC_INCLUDE_BETAS);
IGNORE_RETVAL(ComboBox_SetItemData(hFrequency, ComboBox_AddStringU(hFrequency, "Disabled"), -1));
IGNORE_RETVAL(ComboBox_SetItemData(hFrequency, ComboBox_AddStringU(hFrequency, "Daily (Default)"), 86400));
IGNORE_RETVAL(ComboBox_SetItemData(hFrequency, ComboBox_AddStringU(hFrequency, "Weekly"), 604800));
IGNORE_RETVAL(ComboBox_SetItemData(hFrequency, ComboBox_AddStringU(hFrequency, "Monthly"), 2629800));
freq = ReadRegistryKey32(REGKEY_HKCU, REGKEY_UPDATE_INTERVAL);
EnableWindow(GetDlgItem(hDlg, IDC_CHECK_NOW), (freq != 0));
EnableWindow(hBeta, (freq >= 0));
switch(freq) {
case -1:
IGNORE_RETVAL(ComboBox_SetCurSel(hFrequency, 0));
break;
case 0:
case 86400:
IGNORE_RETVAL(ComboBox_SetCurSel(hFrequency, 1));
break;
case 604800:
IGNORE_RETVAL(ComboBox_SetCurSel(hFrequency, 2));
break;
case 2629800:
IGNORE_RETVAL(ComboBox_SetCurSel(hFrequency, 3));
break;
default:
IGNORE_RETVAL(ComboBox_SetItemData(hFrequency, ComboBox_AddStringU(hFrequency, "Custom"), freq));
IGNORE_RETVAL(ComboBox_SetCurSel(hFrequency, 4));
break;
}
IGNORE_RETVAL(ComboBox_AddStringU(hBeta, "Yes"));
IGNORE_RETVAL(ComboBox_AddStringU(hBeta, "No"));
IGNORE_RETVAL(ComboBox_SetCurSel(hBeta, GetRegistryKeyBool(REGKEY_HKCU, REGKEY_INCLUDE_BETAS)?0:1));
hPolicy = GetDlgItem(hDlg, IDC_POLICY);
SendMessage(hPolicy, EM_AUTOURLDETECT, 1, 0);
safe_sprintf(update_policy_text, sizeof(update_policy_text), update_policy);
SendMessageA(hPolicy, EM_SETTEXTEX, (WPARAM)&friggin_microsoft_unicode_amateurs, (LPARAM)update_policy_text);
SendMessage(hPolicy, EM_SETSEL, -1, -1);
SendMessage(hPolicy, EM_SETEVENTMASK, 0, ENM_LINK);
SendMessageA(hPolicy, EM_SETBKGNDCOLOR, 0, (LPARAM)GetSysColor(COLOR_BTNFACE));
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDCLOSE:
case IDCANCEL:
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
case IDC_CHECK_NOW:
CheckForUpdates(TRUE);
return (INT_PTR)TRUE;
case IDC_UPDATE_FREQUENCY:
if (HIWORD(wParam) != CBN_SELCHANGE)
break;
freq = (int32_t)ComboBox_GetItemData(hFrequency, ComboBox_GetCurSel(hFrequency));
WriteRegistryKey32(REGKEY_HKCU, REGKEY_UPDATE_INTERVAL, (DWORD)freq);
EnableWindow(hBeta, (freq >= 0));
return (INT_PTR)TRUE;
case IDC_INCLUDE_BETAS:
if (HIWORD(wParam) != CBN_SELCHANGE)
break;
SetRegistryKeyBool(REGKEY_HKCU, REGKEY_INCLUDE_BETAS, ComboBox_GetCurSel(hBeta) == 0);
return (INT_PTR)TRUE;
}
break;
}
return (INT_PTR)FALSE;
}
/*
* We use our own MessageBox for notifications to have greater control (center, no close button, etc)
*/
INT_PTR CALLBACK notification_callback(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
LRESULT loc;
int i;
// Prevent resizing
static LRESULT disabled[9] = { HTLEFT, HTRIGHT, HTTOP, HTBOTTOM, HTSIZE,
HTTOPLEFT, HTTOPRIGHT, HTBOTTOMLEFT, HTBOTTOMRIGHT };
static HBRUSH white_brush, separator_brush;
switch (message) {
case WM_INITDIALOG:
white_brush = CreateSolidBrush(WHITE);
separator_brush = CreateSolidBrush(SEPARATOR_GREY);
set_title_bar_icon(hDlg);
center_dialog(hDlg);
// Change the default icon
if (Static_SetIcon(GetDlgItem(hDlg, IDC_NOTIFICATION_ICON), hMessageIcon) == 0) {
dprintf("Could not set dialog icon\n");
}
// Set the dialog title
if (szMessageTitle != NULL) {
SetWindowTextU(hDlg, szMessageTitle);
}
// Enable/disable the buttons and set text
if (!notification_is_question) {
SetWindowTextU(GetDlgItem(hDlg, IDNO), "Close");
} else {
ShowWindow(GetDlgItem(hDlg, IDYES), SW_SHOW);
}
if ((notification_more_info != NULL) && (notification_more_info->callback != NULL)) {
ShowWindow(GetDlgItem(hDlg, IDC_MORE_INFO), SW_SHOW);
}
// Set the control text
if (szMessageText != NULL) {
SetWindowTextU(GetDlgItem(hDlg, IDC_NOTIFICATION_TEXT), szMessageText);
}
return (INT_PTR)TRUE;
case WM_CTLCOLORSTATIC:
// Change the background colour for static text and icon
SetBkMode((HDC)wParam, TRANSPARENT);
if ((HWND)lParam == GetDlgItem(hDlg, IDC_NOTIFICATION_LINE)) {
return (INT_PTR)separator_brush;
}
return (INT_PTR)white_brush;
case WM_NCHITTEST:
// Check coordinates to prevent resize actions
loc = DefWindowProc(hDlg, message, wParam, lParam);
for(i = 0; i < 9; i++) {
if (loc == disabled[i]) {
return (INT_PTR)TRUE;
}
}
return (INT_PTR)FALSE;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
case IDCANCEL:
case IDYES:
case IDNO:
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
case IDC_MORE_INFO:
if (notification_more_info != NULL)
DialogBoxW(main_instance, MAKEINTRESOURCEW(notification_more_info->id),
hDlg, notification_more_info->callback);
break;
}
break;
}
return (INT_PTR)FALSE;
}
/*
* About dialog callback
*/
INT_PTR CALLBACK about_callback(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
int i;
const int edit_id[2] = {IDC_ABOUT_BLURB, IDC_ABOUT_COPYRIGHTS};
char about_blurb[2048];
const char* edit_text[2] = {about_blurb, additional_copyrights};
HWND hEdit[2];
TEXTRANGEW tr;
ENLINK* enl;
wchar_t wUrl[256];
switch (message) {
case WM_INITDIALOG:
dialog_showing++;
set_title_bar_icon(hDlg);
center_dialog(hDlg);
if (reg_commcheck)
ShowWindow(GetDlgItem(hDlg, IDC_ABOUT_UPDATES), SW_SHOW);
safe_sprintf(about_blurb, sizeof(about_blurb), about_blurb_format,
application_version[0], application_version[1], application_version[2]);
for (i=0; i<ARRAYSIZE(hEdit); i++) {
hEdit[i] = GetDlgItem(hDlg, edit_id[i]);
SendMessage(hEdit[i], EM_AUTOURLDETECT, 1, 0);
/* Can't use SetDlgItemText, because it only works with RichEdit20A... and VS insists
* on reverting to RichEdit20W as soon as you edit the dialog. You can try all the W
* methods you want, it JUST WON'T WORK unless you use EM_SETTEXTEX. Also see:
* http://blog.kowalczyk.info/article/eny/Setting-unicode-rtf-text-in-rich-edit-control.html */
SendMessageA(hEdit[i], EM_SETTEXTEX, (WPARAM)&friggin_microsoft_unicode_amateurs, (LPARAM)edit_text[i]);
SendMessage(hEdit[i], EM_SETSEL, -1, -1);
SendMessage(hEdit[i], EM_SETEVENTMASK, 0, ENM_LINK);
SendMessage(hEdit[i], EM_SETBKGNDCOLOR, 0, (LPARAM)GetSysColor(COLOR_BTNFACE));
}
break;
case WM_NOTIFY:
switch (((LPNMHDR)lParam)->code) {
case EN_LINK:
enl = (ENLINK*) lParam;
if (enl->msg == WM_LBUTTONUP) {
tr.lpstrText = wUrl;
tr.chrg.cpMin = enl->chrg.cpMin;
tr.chrg.cpMax = enl->chrg.cpMax;
SendMessageW(enl->nmhdr.hwndFrom, EM_GETTEXTRANGE, 0, (LPARAM)&tr);
wUrl[ARRAYSIZE(wUrl)-1] = 0;
ShellExecuteW(hDlg, L"open", wUrl, NULL, NULL, SW_SHOWNORMAL);
}
break;
}
break;
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDOK:
case IDCANCEL:
EndDialog(hDlg, LOWORD(wParam));
dialog_showing--;
return (INT_PTR)TRUE;
case IDC_ABOUT_LICENSE:
DialogBoxW(main_instance, MAKEINTRESOURCEW(IDD_LICENSE), hDlg, license_callback);
break;
case IDC_ABOUT_UPDATES:
DialogBoxW(main_instance, MAKEINTRESOURCEW(IDD_UPDATE_POLICY), hDlg, UpdateCallback);
break;
}
break;
}
return (INT_PTR)FALSE;
}
/*
* New version notification dialog
*/
INT_PTR CALLBACK new_version_callback(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
int i;
HWND hNotes;
char tmp[128], cmdline[] = APPLICATION_NAME " /W";
static char* filepath = NULL;
static int download_status = 0;
STARTUPINFOA si;
PROCESS_INFORMATION pi;
HFONT hyperlink_font = NULL;
EXT_DECL(exe_ext, NULL, __VA_GROUP__("*.exe"), __VA_GROUP__("Application"));
switch (message) {
case WM_INITDIALOG:
download_status = 0;
set_title_bar_icon(hDlg);
center_dialog(hDlg);
// Subclass the callback so that we can change the cursor
original_wndproc = (WNDPROC)SetWindowLongPtr(hDlg, GWLP_WNDPROC, (LONG_PTR)subclass_callback);
hNotes = GetDlgItem(hDlg, IDC_RELEASE_NOTES);
SendMessage(hNotes, EM_AUTOURLDETECT, 1, 0);
SendMessageA(hNotes, EM_SETTEXTEX, (WPARAM)&friggin_microsoft_unicode_amateurs, (LPARAM)update.release_notes);
SendMessage(hNotes, EM_SETSEL, -1, -1);
SendMessage(hNotes, EM_SETEVENTMASK, 0, ENM_LINK);
safe_sprintf(tmp, sizeof(tmp), "Your version: %d.%d (Build %d)",
application_version[0], application_version[1], application_version[2]);
SetWindowTextU(GetDlgItem(hDlg, IDC_YOUR_VERSION), tmp);
safe_sprintf(tmp, sizeof(tmp), "Latest version: %d.%d (Build %d)",
update.version[0], update.version[1], update.version[2]);
SetWindowTextU(GetDlgItem(hDlg, IDC_LATEST_VERSION), tmp);
SetWindowTextU(GetDlgItem(hDlg, IDC_DOWNLOAD_URL), update.download_url);
SendMessage(GetDlgItem(hDlg, IDC_PROGRESS), PBM_SETRANGE, 0, (MAX_PROGRESS<<16) & 0xFFFF0000);
if (update.download_url == NULL)
EnableWindow(GetDlgItem(hDlg, IDC_DOWNLOAD), FALSE);
break;
case WM_CTLCOLORSTATIC:
if ((HWND)lParam != GetDlgItem(hDlg, IDC_WEBSITE))
return FALSE;
// Change the font for the hyperlink
SetBkMode((HDC)wParam, TRANSPARENT);
CreateStaticFont((HDC)wParam, &hyperlink_font);
SelectObject((HDC)wParam, hyperlink_font);
SetTextColor((HDC)wParam, RGB(0,0,125)); // DARK_BLUE
return (INT_PTR)CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
case WM_COMMAND:
switch (LOWORD(wParam)) {
case IDCLOSE:
case IDCANCEL:
if (download_status != 1) {
safe_free(filepath);
EndDialog(hDlg, LOWORD(wParam));
}
return (INT_PTR)TRUE;
case IDC_WEBSITE:
ShellExecuteA(hDlg, "open", APPLICATION_URL, NULL, NULL, SW_SHOWNORMAL);
break;
case IDC_DOWNLOAD: // Also doubles as abort and launch function
switch(download_status) {
case 1: // Abort
download_status = 0;
error_code = ERROR_SEVERITY_ERROR|ERROR_CANCELLED;
break;
case 2: // Launch newer version and close this one
Sleep(1000); // Add a delay on account of antivirus scanners
memset(&si, 0, sizeof(si));
memset(&pi, 0, sizeof(pi));
si.cb = sizeof(si);
if (!CreateProcessU(filepath, cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
print_status(0, TRUE, "Failed to launch new application");
dprintf("Failed to launch new application: %s\n", WindowsErrorString());
} else {
print_status(0, FALSE, "Launching new application...");
PostMessage(hDlg, WM_COMMAND, (WPARAM)IDCLOSE, 0);
PostMessage(hMainDialog, WM_CLOSE, 0, 0);
}
break;
default: // Download
if (update.download_url == NULL) {
print_status(0, TRUE, "Could not get download URL\n");
break;
}
for (i=(int)strlen(update.download_url); (i>0)&&(update.download_url[i]!='/'); i--);
exe_ext.filename = PathFindFileNameU(update.download_url);
filepath = FileDialog(TRUE, app_dir, &exe_ext, OFN_NOCHANGEDIR);
if (filepath == NULL) {
print_status(0, TRUE, "Could not get save path\n");
break;
}
DownloadFileThreaded(update.download_url, filepath, hDlg);
break;
}
return (INT_PTR)TRUE;
}
break;
case UM_DOWNLOAD_INIT:
error_code = 0;
download_status = 1;
SetWindowTextU(GetDlgItem(hDlg, IDC_DOWNLOAD), "Abort");
return (INT_PTR)TRUE;
case UM_DOWNLOAD_EXIT:
if (wParam) {
SetWindowTextU(GetDlgItem(hDlg, IDC_DOWNLOAD), "Launch");
download_status = 2;
} else {
SetWindowTextU(GetDlgItem(hDlg, IDC_DOWNLOAD), "Download");
download_status = 0;
}
return (INT_PTR)TRUE;
}
return (INT_PTR)FALSE;
}
/*
* Callback for the run_with_progress_bar() function
*/
static LRESULT CALLBACK progress_callback(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
LRESULT loc;
HANDLE handle;
static int installation_time = 0; // active installation time, in secs
const int msg_max = ARRAYSIZE(progress_message);
static int msg_index = 0;
int i;
// coordinates that we want to disable (=> no resize)
static LRESULT disabled[9] = { HTLEFT, HTRIGHT, HTTOP, HTBOTTOM, HTSIZE,
HTTOPLEFT, HTTOPRIGHT, HTBOTTOMLEFT, HTBOTTOMRIGHT };
switch (message) {
case WM_CREATE:
// Reset static variables
installation_time = 0;
msg_index = 0;
hProgress = hDlg;
// Start modal (disable parent Window)
EnableWindow(GetParent(hDlg), FALSE);
init_children(hProgress);
center_dialog(hProgress);
// Send a WM_TIMER message every second
SetTimer(hProgress, 1, 1000, NULL);
PostMessage(hProgress, UM_PROGRESS_START, 0, 0);
return (INT_PTR)TRUE;
case WM_NCHITTEST:
// Check coordinates to prevent resize actions
loc = DefWindowProc(hDlg, message, wParam, lParam);
for(i = 0; i < 9; i++) {
if (loc == disabled[i]) {
return (INT_PTR)TRUE;
}
}
return (INT_PTR)FALSE;
case UM_PROGRESS_START:
if (progress_thid != -1L) {
wdi_err("program assertion failed - another operation is in progress");
} else {
// Using a thread prevents application freezout on security warning
progress_thid = _beginthread(progress_thread, 0, NULL);
if (progress_thid != -1L) {
return (INT_PTR)TRUE;
}
wdi_err("unable to create progress_thread");
}
// Fall through and return an error
wParam = (WPARAM)WDI_ERROR_RESOURCE;
case UM_PROGRESS_STOP:
// If you don't re-enable the parent Window before leaving
// all kind of bad things happen (other Windows get activated, etc.)
EnableWindow(GetParent(hDlg), TRUE);
PostQuitMessage((int)wParam);
DestroyWindow(hProgress);
return (INT_PTR)TRUE;
case WM_TIMER:
if (find_security_prompt() == NULL) {
installation_time++; // Only increment outside of security prompts
if ( (msg_index < msg_max) && (installation_time > 15*(msg_index+1)) ) {
// Change the progress blurb
SetWindowTextA(hProgressText, progress_message[msg_index]);
// Force a full redraw fot the transparent text background
ShowWindow(hProgressText, SW_HIDE);
UpdateWindow(hProgressText);
ShowWindow(hProgressText, SW_SHOW);
UpdateWindow(hProgressText);
msg_index++;
} else if ( (installation_time > 300) && (progress_thid != -1L) ) {
// Wait 300 (loose) seconds and kill the thread
// 300 secs is the timeout for driver installation on Vista
wdi_err("progress timeout expired - KILLING THREAD!");
handle = OpenThread(THREAD_TERMINATE, FALSE, (DWORD)progress_thid);
TerminateThread(handle, -1);
CloseHandle(handle);
PostQuitMessage(WDI_ERROR_TIMEOUT);
DestroyWindow(hProgress);
return (INT_PTR)FALSE;
}
}
return (INT_PTR)TRUE;
case WM_CLOSE: // prevent closure using Alt-F4
return (INT_PTR)TRUE;
case WM_DESTROY: // close application
hProgress = INVALID_HANDLE_VALUE;
return (INT_PTR)FALSE;
case WM_CTLCOLORSTATIC:
pSetBkMode((HDC)wParam, TRANSPARENT);
return (INT_PTR)pGetStockObject(NULL_BRUSH);
}
return DefWindowProc(hDlg, message, wParam, lParam);
}
//ִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִ¿
// do_user_interaction ³
// ³
// Entry point from client module called on startup operation. ³
//ִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִ�
void do_user_interaction()
{
int cursor;
float t1, t2;
Editable *e;
static int inited = 0;
char file[16];
char path[128];
char buff[32];
gfx_get_mform(cursor);
gfx_set_mform(C_ARROW,0);
gfx_report("");
gfx_prompt("");
gfx_prompt("");
// Force mtl_pathname to point to process directory with ESPORT.VGP
// as the filename.
gfx_get_paths(GFX_PROCESS_PATH,0,path,file);
strcpy(mtl_palpath,path);
strcpy(mtl_palname,"ESPORT.VGP");
strcpy(log_fname,path);
strcat(log_fname,"\\ESPORT.LOG");
if (! inited)
{
char buff[256];
strcpy(buff,path);
strcat(buff,"\\");
strcat(buff,"ESPORT.INI");
load_from_ini(buff);
init_dialog(Escher, Escher_edit, NULL);
inited = 1;
}
do_export=loop_done=0;
gfx_get_paths(GFX_3DS_PATH,0,path,file);
if (strstr(file,".3DS"))
{
*strstr(file,".3DS")=0;
strcpy(scene_name,file);
strcat(file,".IFF");
strcpy(output_name,file);
strcpy(output_path,path);
}
Escher[TARGET].text=output_name;
ready_dialog(Escher, Escher_edit, NULL, Escher_feel, Escher_rad,
NULL, NULL);
init_editable(&Escher[SCN_NAME], scene_name);
sprintf(buff,"%f",scale_3ds);
init_editable(&Escher[SCAL_3DS], buff);
sprintf(buff,"%f",scale_esh);
init_editable(&Escher[SCAL_ESH], buff);
Escher[INC_CAMS].radio = (cameras_flag) ? 1 : 0;
Escher[INC_LGTS].radio = (lights_flag) ? 1 : 0;
Escher[KEYFRAME].radio = (keys_flag) ? 1 : 0;
Escher[FLAGS_0].radio = (object_flags & ESCH_MSH_APP0) ? 1 : 0;
Escher[FLAGS_1].radio = (object_flags & ESCH_MSH_APP1) ? 1 : 0;
Escher[FLAGS_2].radio = (object_flags & ESCH_MSH_APP2) ? 1 : 0;
Escher[FLAGS_3].radio = (object_flags & ESCH_MSH_APP3) ? 1 : 0;
Escher[FLAGS_4].radio = (object_flags & ESCH_MSH_APP4) ? 1 : 0;
Escher[FLAGS_5].radio = (object_flags & ESCH_MSH_APP5) ? 1 : 0;
Escher[FLAGS_6].radio = (object_flags & ESCH_MSH_APP6) ? 1 : 0;
Escher[FLAGS_7].radio = (object_flags & ESCH_MSH_APP7) ? 1 : 0;
Escher[FLAGS_8].radio = (object_flags & ESCH_MSH_APP8) ? 1 : 0;
Escher[FLAGS_9].radio = (object_flags & ESCH_MSH_APP9) ? 1 : 0;
Escher[FLAGS_A].radio = (object_flags & ESCH_MSH_APPA) ? 1 : 0;
Escher[FLAGS_B].radio = (object_flags & ESCH_MSH_APPB) ? 1 : 0;
Escher[FLAGS_C].radio = (object_flags & ESCH_MSH_APPC) ? 1 : 0;
Escher[FLAGS_D].radio = (object_flags & ESCH_MSH_APPD) ? 1 : 0;
Escher[FLAGS_E].radio = (object_flags & ESCH_MSH_APPE) ? 1 : 0;
Escher[FLAGS_F].radio = (object_flags & ESCH_MSH_APPF) ? 1 : 0;
startover: ;
while (!loop_done)
{
center_dialog(Escher);
save_under_dialog(Escher);
draw_dialog(Escher);
do_dialog(Escher, -1);
}
if (do_export)
{
e=(Editable*)Escher[SCAL_3DS].text;
t1=atof(e->string);
if (t1 <= 0.0)
{
gfx_continu_line("Scale values must be positive and non-zero");
loop_done=0;
goto startover;
}
e=(Editable*)Escher[SCAL_ESH].text;
t2=atof(e->string);
if (t2 <= 0.0)
{
gfx_continu_line("Scale values must be positive and non-zero");
loop_done=0;
goto startover;
}
scale_3ds = t1;
scale_esh = t2;
scale_3ds2esch = t2 / t1;
e=(Editable*)Escher[SCN_NAME].text;
strncpy(scene_name,e->string,16);
object_flags=0;
if (Escher[FLAGS_0].radio)
object_flags |= ESCH_MSH_APP0;
if (Escher[FLAGS_1].radio)
object_flags |= ESCH_MSH_APP1;
if (Escher[FLAGS_2].radio)
object_flags |= ESCH_MSH_APP2;
if (Escher[FLAGS_3].radio)
object_flags |= ESCH_MSH_APP3;
if (Escher[FLAGS_4].radio)
object_flags |= ESCH_MSH_APP4;
if (Escher[FLAGS_5].radio)
object_flags |= ESCH_MSH_APP5;
if (Escher[FLAGS_6].radio)
object_flags |= ESCH_MSH_APP6;
if (Escher[FLAGS_7].radio)
object_flags |= ESCH_MSH_APP7;
if (Escher[FLAGS_8].radio)
object_flags |= ESCH_MSH_APP8;
if (Escher[FLAGS_9].radio)
object_flags |= ESCH_MSH_APP9;
if (Escher[FLAGS_A].radio)
object_flags |= ESCH_MSH_APPA;
if (Escher[FLAGS_B].radio)
object_flags |= ESCH_MSH_APPB;
if (Escher[FLAGS_C].radio)
object_flags |= ESCH_MSH_APPC;
if (Escher[FLAGS_D].radio)
object_flags |= ESCH_MSH_APPD;
if (Escher[FLAGS_E].radio)
object_flags |= ESCH_MSH_APPE;
if (Escher[FLAGS_F].radio)
object_flags |= ESCH_MSH_APPF;
cameras_flag = (Escher[INC_CAMS].radio) ? 1 : 0;
lights_flag = (Escher[INC_LGTS].radio) ? 1 : 0;
keys_flag = (Escher[KEYFRAME].radio) ? 1 : 0;
export();
}
static BOOL CALLBACK timecode_dialog_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
FRAME_BY_TIMECODE *opt;
char buffer[256];
char tcode[64];
TIMECODE tc;
__int64 w;
int rate;
int drop;
switch(msg) {
case WM_INITDIALOG:
center_dialog(hwnd);
SetWindowLong(hwnd, GWL_USERDATA, lparam);
opt = (FRAME_BY_TIMECODE *)lparam;
rate = (opt->rate+opt->scale-1)/opt->scale;
drop = opt->rate%opt->scale;
SendMessage(GetDlgItem(hwnd, IDC_TIMECODE_SPIN), UDM_SETRANGE32, 0, (opt->max & 0x7fffffff));
SendMessage(GetDlgItem(hwnd, IDC_TIMECODE_SPIN), UDM_SETPOS32, 0, (opt->current & 0x7fffffff));
frame2timecode(&(opt->max), &tc, rate, drop);
timecode2buffer(&tc, tcode);
sprintf(buffer, msg_table[opt->lang][MSG_MAX_TIMECODE_TEMPLATE], tcode);
SetWindowText(GetDlgItem(hwnd, IDC_MAX_TIMECODE), buffer);
frame2timecode(&(opt->current), &tc, rate, drop);
timecode2buffer(&tc, buffer);
SetWindowText(GetDlgItem(hwnd, IDC_TIMECODE_VIEW), buffer);
return FALSE;
case WM_COMMAND:
opt = (FRAME_BY_TIMECODE *)GetWindowLong(hwnd, GWL_USERDATA);
rate = (opt->rate+opt->scale-1)/opt->scale;
drop = opt->rate%opt->scale;
switch(LOWORD(wparam)) {
case IDOK:
GetWindowText(GetDlgItem(hwnd, IDC_TIMECODE_VIEW), buffer, sizeof(buffer)-1);
buffer2timecode(buffer, &tc);
timecode2frame(&tc, &(opt->current), rate, drop);
EndDialog(hwnd, IDOK);
break;
case IDCANCEL:
EndDialog(hwnd, IDCANCEL);
break;
case IDC_TIMECODE_VIEW:
if(HIWORD(wparam) == EN_KILLFOCUS) {
GetWindowText(GetDlgItem(hwnd, IDC_TIMECODE_VIEW), buffer, sizeof(buffer)-1);
buffer2timecode(buffer, &tc);
timecode2frame(&tc, &w, rate, drop);
SendMessage(GetDlgItem(hwnd, IDC_TIMECODE_SPIN), UDM_SETPOS32, 0, (w & 0x7fffffff));
}
break;
}
break;
case WM_NOTIFY:
opt = (FRAME_BY_TIMECODE *)GetWindowLong(hwnd, GWL_USERDATA);
rate = (opt->rate+opt->scale-1)/opt->scale;
drop = opt->rate%opt->scale;
if( ((NMHDR*)lparam)->code == UDN_DELTAPOS ) {
w = ((NMUPDOWN *)lparam)->iPos + ((NMUPDOWN *)lparam)->iDelta;
if(w>opt->max) {
w = opt->max;
} else if(w<0) {
w = 0;
}
frame2timecode(&w, &tc, rate, drop);
timecode2buffer(&tc, buffer);
SetWindowText(GetDlgItem(hwnd, IDC_TIMECODE_VIEW), buffer);
}
}
return FALSE;
}
//ִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִ¿
// do_mtl ³
// ³
// Do material's dialog. ³
//ִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִִ�
void do_mtl()
{
int sizex, sizey;
Editable *e;
static int inited = 0;
char buff[32];
if (! inited)
{
init_dialog(EschMtl, EschMtl_edit, NULL);
inited = 1;
}
loop_done=0;
EschMtl[PALETTE].text=mtl_palname;
EschMtl[PALETTE].radio=0;
EschMtl[COMPRESS].radio = (mtl_compress) ? 1 : 0;
ready_dialog(EschMtl, EschMtl_edit, NULL, EschMtl_feel, EschMtl_rad,
NULL, NULL);
sprintf(buff,"%d",mtl_sizex);
init_editable(&EschMtl[SIZEX], buff);
sprintf(buff,"%d",mtl_sizey);
init_editable(&EschMtl[SIZEY], buff);
startover:
;
while (!loop_done)
{
center_dialog(EschMtl);
save_under_dialog(EschMtl);
draw_dialog(EschMtl);
do_dialog(EschMtl, -1);
}
e=(Editable*)EschMtl[SIZEX].text;
sizex=atoi(e->string);
switch(sizex) {
case 16:
case 32:
case 64:
case 128:
case 256:
break;
default:
gfx_continu_line("X Size must be 16, 32, 64, 128, or 256");
loop_done=0;
goto startover;
}
e=(Editable*)EschMtl[SIZEY].text;
sizey=atoi(e->string);
switch(sizey) {
case 16:
case 32:
case 64:
case 128:
case 256:
break;
default:
gfx_continu_line("Y Size must be 16, 32, 64, 128, or 256");
loop_done=0;
goto startover;
}
mtl_sizex=sizex;
mtl_sizey=sizey;
mtl_compress = (EschMtl[COMPRESS].radio) ? 1 : 0;
}
