bool WQuerySaveSym( WAccelEditInfo *einfo, bool force_exit )
{
int ret;
UINT style;
char *title;
char *text;
if( einfo == NULL || !einfo->info->stand_alone ) {
return( TRUE );
}
if( !WRIsHashTableDirty( einfo->info->symbol_table ) ) {
return( TRUE );
}
if( force_exit ) {
style = MB_YESNO | MB_APPLMODAL | MB_ICONEXCLAMATION;
} else {
style = MB_YESNOCANCEL | MB_APPLMODAL | MB_ICONEXCLAMATION;
}
title = WCreateEditTitle( einfo );
text = AllocRCString( W_UPDATEMODIFIEDSYM );
ret = MessageBox( einfo->edit_dlg, text, title, style );
if( text != NULL ) {
FreeRCString( text );
}
if( title != NULL ) {
WRMemFree( title );
}
if( ret == IDYES ) {
if( einfo->info->symbol_file == NULL ) {
char *fname;
if( einfo->file_name == NULL ) {
fname = einfo->info->file_name;
} else {
fname = einfo->file_name;
}
einfo->info->symbol_file = WCreateSymName( fname );
}
return( WSaveSymbols( einfo, einfo->info->symbol_table,
&einfo->info->symbol_file, FALSE ) );
} else if( ret == IDCANCEL ) {
return( FALSE );
}
return( TRUE );
}
static void WRESetPasteInfo( HWND hDlg, WREPasteData *pdata )
{
WRETypeName *tn;
char *text;
tn = WREGetTypeNameFromRT( pdata->type );
if( tn != NULL ) {
text = AllocRCString( tn->name );
WRESetEditWithStr( GetDlgItem( hDlg, IDM_PASTE_TYPE ), text );
if( text != NULL ) {
FreeRCString( text );
}
}
WRESetEditWithWResID( GetDlgItem( hDlg, IDM_PASTE_NAME ), pdata->name );
}
/*
* logSysInfo - record basic system info
*/
static void logSysInfo( bool wasfault )
{
char *str;
time_t tod;
DWORD ver;
SYSTEM_INFO sysinfo;
char name[ MAX_COMPUTERNAME_LENGTH + 1 ];
DWORD bufsize;
tod = time( NULL );
str = ctime( &tod );
if( wasfault ) {
logPrintf( STR_FAULT_FOUND_ON_X, AppName, str );
} else {
logPrintf( STR_LOG_TAKEN_ON_X, AppName, str );
}
bufsize = sizeof( name );
GetComputerName( name, &bufsize );
logPrintf( STR_COMPUTER_NAME, name );
bufsize = sizeof( name );
GetUserName( name, &bufsize );
logPrintf( STR_USER_NAME, name );
#ifndef _WIN64
ver = GetVersion();
#ifdef CHICAGO // TEMPORARY FIX UNTIL WE CAN CHECK FOR WIN 95
logPrintf( STR_OPERATING_SYSTEM, "Windows 95" );
#else
logPrintf( STR_OPERATING_SYSTEM, IsNT( ver ) ? "Windows NT":"Win32s" );
#endif
logPrintf( STR_OS_VERSION, (int)GetMajVer( ver ), (int)GetMinVer( ver ) );
#else
logPrintf( STR_OPERATING_SYSTEM, "Windows NT 64-bit" );
#endif
GetSystemInfo( &sysinfo );
str = SrchMsg( sysinfo.dwProcessorType, ProcessorNames, NULL );
if( str == NULL ) {
str = AllocRCString( STR_UNKNOWN );
logPrintf( STR_PROCESSOR_TYPE, str );
FreeRCString( str );
} else {
logPrintf( STR_PROCESSOR_TYPE, str );
}
logPrintf( STR_NUM_PROCESSORS, sysinfo.dwNumberOfProcessors );
}
bool WHandleGetKeyValue( WAccelEditInfo *einfo, bool ignore_first )
{
RECT r;
bool ok;
char *text;
text = NULL;
ok = (einfo != NULL);
if( ok ) {
if( einfo->current_entry == NULL ) {
ok = WInsertAccelEntry( einfo );
}
}
if( ok ) {
text = AllocRCString( W_SELECTKEY );
ok = (text != NULL);
}
if( ok ) {
WGetKeyPressProc( NULL, 0, 0, 0 );
einfo->key_info.key = 0;
GetWindowRect( GetDlgItem( einfo->edit_dlg, IDM_ACCEDLIST ), &r );
MapWindowPoints( (HWND)NULL, einfo->edit_dlg, (POINT *)&r, 2 );
einfo->key_info.text_win = CreateWindow( "static", text,
WS_CHILD | WS_VISIBLE | SS_LEFT, r.left, r.top,
r.right - r.left, r.bottom - r.top, einfo->edit_dlg, (HMENU)NULL,
WGetEditInstance(), NULL );
ok = (einfo->key_info.text_win != (HWND)NULL);
}
if( ok ) {
einfo->info->modified = true;
SetFocus( einfo->win );
SetCapture( einfo->win );
einfo->key_info.ignore_first_key = ignore_first;
einfo->getting_key = TRUE;
}
if( text != NULL ) {
FreeRCString( text );
}
return( ok );
}
bool WREQuerySaveSymOnDeleteRes( WREResInfo *res_info, bool fatal_exit )
{
int ret;
UINT style;
char *text;
char *file;
HWND frame;
if( WRENoInterface ) {
return( TRUE );
}
if( res_info == NULL || res_info->symbol_table == NULL ) {
return( TRUE );
}
if( WRIsHashTableDirty( res_info->symbol_table ) ) {
if( fatal_exit ) {
style = MB_YESNO | MB_APPLMODAL | MB_ICONEXCLAMATION;
} else {
style = MB_YESNOCANCEL | MB_APPLMODAL | MB_ICONEXCLAMATION;
}
WRECheckIfActiveWindow();
frame = WREGetMDIWindowHandle();
SendMessage( frame, WM_MDIRESTORE, (WPARAM)res_info->res_win, 0 );
SendMessage( frame, WM_MDIACTIVATE, (WPARAM)res_info->res_win, 0 );
file = WREGetQueryName( res_info );
text = AllocRCString( WRE_SAVEMODIFIEDSYM );
ret = MessageBox( res_info->res_win, text, file, style );
if( text != NULL ) {
FreeRCString( text );
}
if( ret == IDYES ) {
if( res_info->symbol_file == NULL ) {
res_info->symbol_file = WRECreateSymName( file );
}
if( !WRESaveSymbols( res_info->symbol_table, &res_info->symbol_file, FALSE ) ) {
return( FALSE );
}
} else if( ret == IDCANCEL ) {
return( FALSE );
}
}
return( TRUE );
}
char *WCreateEditTitle( WAccelEditInfo *einfo )
{
char *title;
char *fname;
char *text;
int offset;
size_t len;
title = NULL;
fname = NULL;
if( einfo == NULL ) {
return( NULL );
}
if( einfo->file_name == NULL ) {
fname = einfo->info->file_name;
} else {
fname = einfo->file_name;
}
text = AllocRCString( W_ACCELAPPTITLE );
if( fname == NULL || text == NULL ) {
return( NULL );
}
offset = WRFindFnOffset( fname );
fname = &fname[offset];
len = strlen( fname ) + strlen( text ) + 6;
title = (char *)WRMemAlloc( len );
if( title != NULL ) {
strcpy( title, text );
strcat( title, " - [" );
strcat( title, fname );
strcat( title, "]" );
}
if( text != NULL ) {
FreeRCString( text );
}
return( title );
}
bool WQuerySaveRes( WStringEditInfo *einfo, bool force_exit )
{
int msg_ret;
bool ret;
UINT style;
char *title;
char *text;
ret = true;
if( einfo != NULL && einfo->info->modified ) {
msg_ret = IDYES;
if( einfo->info->stand_alone ) {
if( force_exit ) {
style = MB_YESNO | MB_APPLMODAL | MB_ICONEXCLAMATION;
} else {
style = MB_YESNOCANCEL | MB_APPLMODAL | MB_ICONEXCLAMATION;
}
title = WCreateEditTitle( einfo );
text = AllocRCString( W_UPDATEMODIFIEDSTRING );
msg_ret = MessageBox( einfo->edit_dlg, text, title, style );
if( text != NULL ) {
FreeRCString( text );
}
if( title != NULL ) {
WRMemFree( title );
}
}
if( msg_ret == IDYES ) {
if( einfo->info->stand_alone ) {
ret = WSaveObject( einfo, FALSE, FALSE );
} else {
SendMessage( einfo->info->parent, STRING_PLEASE_SAVEME, 0,
(LPARAM)einfo->hndl );
}
} else if( msg_ret == IDCANCEL ) {
ret = false;
}
}
return( ret );
}
/*
* InitSrchTable - load the strings for a search table from the resource
* file
* - WARNING: this function must not be called more
* than once for each table
* - buf must be large enough to hold any message in the table
*/
BOOL InitSrchTable( HANDLE inst, msglist *tbl )
{
msglist *curmsg;
curmsg = tbl;
inst = inst;
for( ;; ) {
if( (DWORD)curmsg->msg == (DWORD)-1 ) {
break;
}
curmsg->msg = AllocRCString( (DWORD)curmsg->msg );
if( curmsg->msg == NULL ) {
return( FALSE );
}
curmsg++;
}
curmsg->msg = NULL;
return( TRUE );
} /* InitSrchTable */
/*
* makePushWin - create the push window headers for a window
*/
static void makePushWin( DDETrackInfo *info, HWND hwnd,
TrackHeaderInfo *hdrinfo, WORD hdrcnt )
{
WORD i;
SIZE sz;
char test[40];
int left;
HDC dc;
HFONT font;
HFONT old_font;
char *win_title;
if( info->hdr == NULL ) {
info->hdr = MemAlloc( hdrcnt * sizeof( HWND ) );
info->hdrcnt = hdrcnt;
info->hdrinfo = hdrinfo;
}
left = 0;
font = GetMonoFont();
for( i = 0; i < hdrcnt; i++ ) {
if( IsWindow( info->hdr[i] ) ) {
DestroyWindow( info->hdr[i] );
}
win_title = AllocRCString( hdrinfo[i].textid );
info->hdr[i] = CreatePushWin( hwnd, win_title, hdrinfo[i].id, font, Instance );
FreeRCString( win_title );
memset( test, '0', hdrinfo[i].size );
test[hdrinfo[i].size] = '\0';
dc = GetDC( info->hdr[i] );
old_font = SelectObject( dc, font );
GetTextExtentPoint( dc, test, hdrinfo[i].size, &sz );
SelectObject( dc, old_font );
ReleaseDC( info->hdr[i], dc );
MoveWindow( info->hdr[i], left, 0, sz.cx, sz.cy, TRUE );
ShowWindow( info->hdr[i], SW_SHOW );
left += sz.cx;
}
info->list.ypos = sz.cy + 1;
} /* makePushWin */
/*
* updateHintText - updated the text shown when a menu item is selected
*/
static void updateHintText( statwnd *wnd, msg_id msgid )
{
HDC dc;
HFONT font;
char *str;
HWND hint;
HLOCAL hinfo;
HintWndInfo *info;
hint = GetHintHwnd( wnd );
dc = GetDC( hint );
font = GetMonoFont();
str = AllocRCString( msgid );
StatusWndDrawLine( wnd, dc, font, str, DT_LEFT | DT_SINGLELINE | DT_VCENTER );
ReleaseDC( hint, dc );
FreeRCString( str );
hinfo = GetProp( hint, HINT_PROP_ID );
info = LocalLock( hinfo );
info->curmsg = msgid;
LocalUnlock( hinfo );
} /* updateHintText */
void WSetEditTitle( WAccelEditInfo *einfo )
{
char *title;
bool is_rc;
title = WCreateEditTitle( einfo );
is_rc = FALSE;
if( title == NULL ) {
title = AllocRCString( W_ACCELAPPTITLE );
is_rc = TRUE;
}
if( title != NULL ) {
SendMessage( einfo->win, WM_SETTEXT, 0, (LPARAM)title );
if( is_rc ) {
FreeRCString( title );
} else {
WRMemFree( title );
}
}
}
bool WREDeleteStringResources( WRECurrentResInfo *curr, bool removing )
{
WResTypeNode *tnode;
char *text;
bool ok;
ok = true;
if( !removing ) {
text = AllocRCString( WRE_ALLSTRINGS );
ok = WREQueryDeleteName( text );
if( text != NULL ) {
FreeRCString( text );
}
}
if( ok ) {
tnode = curr->type;
if( tnode == NULL ) {
tnode = WRFindTypeNode( curr->info->info->dir, RESOURCE2INT( RT_STRING ), NULL );
}
if( tnode != NULL ) {
curr->info->modified = true;
ok = WRRemoveTypeNodeFromDir( curr->info->info->dir, tnode );
}
}
// nuke any edit sessions on these string resources
if( ok ) {
curr->type = NULL;
if( !removing ) {
WREEndResStringSessions( curr->info );
}
curr->info->current_type = 0;
ok = WREInitResourceWindow( curr->info, 0 );
}
return( ok );
}
WResID *WRECreateAccTitle( void )
{
char *text;
char *title;
WResID *name;
WRENumAccTitles++;
name = NULL;
text = AllocRCString( WRE_DEFACCELNAME );
if( text != NULL ) {
title = (char *)WRMemAlloc( strlen( text ) + 20 + 1 );
if( title != NULL ) {
title[0] = '\0';
sprintf( title, text, WRENumAccTitles );
name = WResIDFromStr( title );
WRMemFree( title );
}
FreeRCString( text );
}
return( name );
}
UINT CALLBACK WREOpenHookProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
char *title;
_wre_touch( wparam );
_wre_touch( lparam );
switch( msg ) {
case WM_INITDIALOG:
// We must call this to subclass the directory listbox even
// if the app calls Ctl3dAutoSubclass (commdlg bug)
//WRECtl3dSubclassDlg( hwnd, CTL3D_ALL );
title = AllocRCString( WRE_GETFNCOMBOTITLE );
if( title != NULL ) {
SendDlgItemMessage( hwnd, stc2, WM_SETTEXT, 0, (LPARAM)title );
FreeRCString( title );
}
return( TRUE );
}
return( FALSE );
}
/*
* getLogName - get a filename for the log and check if the file already exists
*/
static BOOL getLogName( char *buf, HWND hwnd )
{
OPENFILENAME of;
int rc;
static char fname[LOG_MAX_FNAME];
static char filterList[] = "File (*.*)" \
"\0" \
"*.*" \
"\0\0";
strcpy( fname, LogCurInfo.config.name );
memset( &of, 0, sizeof( OPENFILENAME ) );
of.lStructSize = sizeof( OPENFILENAME );
of.hwndOwner = hwnd;
of.lpstrFilter = (LPSTR)filterList;
of.lpstrDefExt = NULL;
of.nFilterIndex = 1L;
of.lpstrFile = fname;
of.nMaxFile = LOG_MAX_FNAME;
of.lpstrTitle = AllocRCString( LOG_CHOOSE_LOG_NAME );
of.Flags = OFN_HIDEREADONLY;
#ifndef NOUSE3D
of.Flags |= OFN_ENABLEHOOK;
of.lpfnHook = (LPOFNHOOKPROC)MakeOpenFileHookProcInstance( LogSaveHook, LogCurInfo.instance );
#endif
rc = GetSaveFileName( &of );
#ifndef NOUSE3D
FreeProcInstance( (FARPROC)of.lpfnHook );
#endif
FreeRCString( (char *)of.lpstrTitle );
if( !rc ) {
return( FALSE );
}
strcpy( buf, fname );
return( TRUE );
} /* getLogName */
/*
* ThreadCtlProc
*/
BOOL CALLBACK ThreadCtlProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
WORD cmd;
ThreadCtlInfo *info;
LRESULT index;
char buf[200];
DWORD threadid;
ThreadNode *thread;
ProcNode *process;
DWORD susp_cnt;
DWORD rc;
char *action;
info = (ThreadCtlInfo *)GET_DLGDATA( hwnd );
switch( msg ) {
case WM_INITDIALOG:
info = MemAlloc( sizeof( ThreadCtlInfo ) );
if( !GetProcessInfo( lparam, &info->procinfo ) ) {
RCsprintf( buf, STR_CANT_GET_PROC_INFO, info->procid );
MessageBox( hwnd, buf, AppName, MB_OK | MB_ICONEXCLAMATION );
SendMessage( hwnd, WM_CLOSE, 0, 0 );
}
info->procid = lparam;
ThreadDlg = hwnd;
SET_DLGDATA( hwnd, info );
fillThreadCtl( hwnd, &info->procinfo, buf );
RCsprintf( buf, STR_THREAD_4_PROC_X, lparam );
SetDlgItemText( hwnd, THREAD_PROC_NAME, buf );
sprintf( buf, "(%s)", info->procinfo.name );
SetDlgItemText( hwnd, THREAD_PROC_PATH, buf );
SendDlgItemMessage( hwnd, THREAD_LIST, LB_SETCURSEL, 0, 0L );
index = SendDlgItemMessage( hwnd, THREAD_LIST, LB_GETCURSEL, 0, 0L );
if( index != LB_ERR ) {
enableChoices( hwnd, TRUE );
}
fillThreadInfo( hwnd, &info->procinfo );
break;
case WM_COMMAND:
cmd = LOWORD( wparam );
if( cmd == THREAD_SUSPEND || cmd == THREAD_RESUME ||
cmd == THREAD_KILL || cmd == THREAD_SET_PRIORITY ) {
index = SendDlgItemMessage( hwnd, THREAD_LIST, LB_GETCURSEL, 0, 0L );
if( index == LB_ERR ) {
RCMessageBox( hwnd, STR_NO_SELECTED_THREAD, AppName, MB_OK | MB_ICONEXCLAMATION );
break;
}
SendDlgItemMessage( hwnd, THREAD_LIST, LB_GETTEXT, (WPARAM)index, (LPARAM)(LPSTR)buf );
threadid = getThreadId( buf );
process = FindProcess( info->procinfo.pid );
thread = FindThread( process, threadid );
}
switch( cmd ) {
case IDOK:
SendMessage( hwnd, WM_CLOSE, 0, 0L );
break;
case THREAD_REFRESH:
RefreshInfo();
if( GetProcessInfo( info->procid, &info->procinfo ) ) {
fillThreadCtl( hwnd, &info->procinfo, buf );
fillThreadInfo( hwnd, &info->procinfo );
} else {
action = AllocRCString( STR_REFRESH );
RCMessageBox( hwnd, STR_CANT_REFRESH_THRD, action,
MB_OK | MB_ICONEXCLAMATION );
FreeRCString( action );
}
break;
case THREAD_SUSPEND:
action = AllocRCString( STR_THREAD_SUSPEND );
if( thread == NULL ) {
RCsprintf( buf, STR_CANT_GET_HDL_4_THD_X, threadid );
MessageBox( hwnd, buf, action, MB_OK | MB_ICONEXCLAMATION );
} else {
susp_cnt = SuspendThread( thread->threadhdl );
if( susp_cnt == -1 ) {
RCsprintf( buf, STR_CANT_SUSPEND_THRD_X, threadid );
MessageBox( hwnd, buf, action, MB_ICONQUESTION | MB_OK );
} else if( susp_cnt > 0 ) {
RCsprintf( buf, STR_THREAD_ALREADY_SUSP, threadid, susp_cnt );
index = MessageBox( hwnd, buf, action, MB_ICONQUESTION | MB_YESNO );
if( index == IDNO ) {
ResumeThread( thread->threadhdl );
}
}
SendMessage( hwnd, WM_COMMAND, THREAD_REFRESH, 0L );
}
FreeRCString( action );
break;
case THREAD_RESUME:
action = AllocRCString( STR_RESUME );
if( thread == NULL ) {
RCsprintf( buf, STR_THREAD_NOT_RESUMED , threadid );
MessageBox( hwnd, buf, action, MB_OK | MB_ICONEXCLAMATION );
} else {
susp_cnt = ResumeThread( thread->threadhdl );
if( susp_cnt == -1 ) {
RCsprintf( buf, STR_CANT_RESUME_THRD_X, threadid );
MessageBox( hwnd, buf, action,
MB_ICONEXCLAMATION | MB_OK );
} else if( susp_cnt == 0 ) {
RCsprintf( buf, STR_THRD_IS_NOT_SUSP, threadid );
MessageBox( hwnd, buf, action,
MB_ICONEXCLAMATION | MB_OK );
} else if( susp_cnt > 1 ) {
RCsprintf( buf, STR_SUSP_COUNT_DECREMENTED,
threadid, susp_cnt );
MessageBox( hwnd, buf, action,
MB_ICONEXCLAMATION | MB_OK );
}
SendMessage( hwnd, WM_COMMAND, THREAD_REFRESH, 0L );
}
FreeRCString( action );
break;
case THREAD_KILL:
action = AllocRCString( STR_KILL );
if( thread == NULL ) {
RCsprintf( buf, STR_THRD_NOT_TERMINATED, threadid );
MessageBox( hwnd, buf, action, MB_OK | MB_ICONEXCLAMATION );
} else if( GetRetCode( hwnd, RETCD_THREAD, thread->threadid, &rc ) ) {
if( !TerminateThread( thread->threadhdl, rc ) ) {
RCsprintf( buf, STR_CANT_KILL_THRD_X, threadid );
MessageBox( hwnd, buf, action,
MB_OK | MB_ICONEXCLAMATION );
}
SendMessage( hwnd, WM_COMMAND, THREAD_REFRESH, 0L );
}
FreeRCString( action );
break;
case THREAD_SET_PRIORITY:
// {
// ThreadPriorityInfo prinfo;
//
// if( thread == NULL ) {
// sprintf( buf, "Unable to get a handle for thread %08X.\n",
// threadid );
// MessageBox( hwnd, buf, "Set Priority",
// MB_OK | MB_ICONEXCLAMATION );
// } else {
// prinfo.procid = info->procid;
// prinfo.thread = thread;
// prinfo.priority = GetThreadPriority( thread->threadhdl );
// prinfo.procinfo = &info->procinfo;
// DialogBoxParam( Instance, "THREAD_PRIORITY_DLG", hwnd,
// ThreadPriorityDlgProc, (DWORD)&prinfo );
// fillThreadInfo( hwnd, &info->procinfo );
// }
// }
// break;
case THREAD_LIST:
if( HIWORD( wparam ) == LBN_SELCHANGE ) {
fillThreadInfo( hwnd, &info->procinfo );
}
break;
}
break;
case DR_TASK_LIST_CHANGE:
/* make sure this process still exists */
//here if( FindProcess( info->procid ) == NULL ) {
//here SendDlgItemMessage( hwnd, THREAD_LIST, LB_RESETCONTENT, 0, 0L );
//here enableChoices( hwnd, FALSE );
//here info->proc = NULL;
//here } else {
//here fillThreadCtl( hwnd, info->proc, buf );
//here }
break;
case WM_CLOSE:
EndDialog( hwnd, 0 );
break;
case WM_DESTROY:
MemFree( info );
ThreadDlg = NULL;
break;
default:
return( FALSE );
}
return( TRUE );
}
/*
* WinMain - entry point for the uninstaller
*/
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow )
{
char szExePath[MAX_PATH];
char szCheckPath[MAX_PATH];
char szInstallPath[MAX_PATH];
char *pch;
char *pszTitle;
char *pszMessage;
char *pszUninstallFile;
HWND hDlg;
WIN32_FIND_DATA wfd;
HANDLE hFindFile;
LPITEMIDLIST pidlPrograms;
char szProgramsPath[MAX_PATH];
/*
* Load the title for message boxes.
*/
pszTitle = AllocRCString( UNINS_TITLE );
/*
* Get the directory where the uninstaller is located.
*/
GetModuleFileName( NULL, szExePath, MAX_PATH );
strcpy( szInstallPath, szExePath );
pch = strrchr( szInstallPath, '\\' );
*pch = '\0';
/*
* Look for the check file to ensure that the uninstaller is being actually run from
* an Open Watcom installation directory.
*/
strcpy( szCheckPath, szInstallPath );
strcat( szCheckPath, "\\" );
strcat( szCheckPath, CHECK_FILE_NAME );
hFindFile = FindFirstFile( szCheckPath, &wfd );
if( hFindFile == INVALID_HANDLE_VALUE ) {
pszMessage = GetRCString( UNINS_NO_OW_INST );
MessageBox( NULL, pszMessage, pszTitle, MB_OK | MB_ICONSTOP );
FreeRCString( pszTitle );
return( 1 );
}
FindClose( hFindFile );
/*
* Check that the user actually wants to uninstall Open Watcom.
*/
pszMessage = GetRCString( UNINS_CONFIRM );
if( MessageBox( NULL, pszMessage, pszTitle, MB_YESNO | MB_ICONQUESTION ) == IDNO ) {
FreeRCString( pszTitle );
return( 0 );
}
/*
* Display the progress dialog box during the uninstallation.
*/
hDlg = CreateDialog( hInstance, "PROGRESS", NULL, ProgressDlgProc );
/*
* Get the name of the uninstaller.
*/
pszUninstallFile = strrchr( szExePath, '\\' );
pszUninstallFile++;
/*
* Delete all files except the uninstaller.
*/
DeleteFolder( hDlg, szInstallPath, pszUninstallFile );
/*
* Delete the Open Watcom program folder from the start menu.
*/
if( SUCCEEDED( SHGetSpecialFolderLocation( NULL, CSIDL_PROGRAMS, &pidlPrograms ) ) ) {
if( SHGetPathFromIDList( pidlPrograms, szProgramsPath ) ) {
pch = szProgramsPath + strlen( szProgramsPath );
*pch = '\\';
pch++;
strcpy( pch, "Open Watcom C - C++" );
DeleteFolder( hDlg, szProgramsPath, NULL );
RemoveDirectory( szProgramsPath );
strcpy( pch, "Open Watcom C - C++ Tools Help" );
DeleteFolder( hDlg, szProgramsPath, NULL );
RemoveDirectory( szProgramsPath );
}
}
/*
* Tell Windows to delete the uninstaller and the folder in which it lives the next
* time the computer is restarted.
*/
MoveFileEx( szExePath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT );
MoveFileEx( szInstallPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT );
/*
* Remove the uninstaller from the Add/Remove Programs list.
*/
RegDeleteKey( HKEY_LOCAL_MACHINE,
"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\"
UNINSTALL_NAME );
/*
* Take away the progress dialog.
*/
EndDialog( hDlg, 0 );
/*
* Inform the user that the uninstallation has been completed.
*/
pszMessage = GetRCString( UNINS_COMPLETED );
MessageBox( NULL, pszMessage, pszTitle, MB_OK );
FreeRCString( pszTitle );
return( 0 );
} /* WinMain */
WINEXPORT LRESULT CALLBACK WMainWndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
HMENU menu;
#if 0
HWND win;
#endif
LRESULT ret;
Bool pass_to_def;
WMenuEditInfo *einfo;
WORD wp;
MINMAXINFO *minmax;
about_info ai;
pass_to_def = TRUE;
ret = FALSE;
einfo = (WMenuEditInfo *)GET_WNDLONGPTR( hWnd, 0 );
WSetCurrentEditInfo( einfo );
switch( message ) {
case WM_ACTIVATE:
if( GET_WM_ACTIVATE_FACTIVE( wParam, lParam ) &&
!GET_WM_ACTIVATE_FMINIMIZED( wParam, lParam ) &&
einfo != NULL && einfo->edit_dlg != (HWND)NULL ) {
SetFocus( einfo->edit_dlg );
pass_to_def = FALSE;
}
break;
case WM_INITMENU:
if( wParam == (WPARAM)GetMenu( hWnd ) ) {
// set the cut and copy menu items
ret = SendDlgItemMessage( einfo->edit_dlg, IDM_MENUEDLIST, LB_GETCURSEL, 0, 0 );
if( ret != LB_ERR ) {
EnableMenuItem( (HMENU)wParam, IDM_MENU_CUT, MF_ENABLED );
EnableMenuItem( (HMENU)wParam, IDM_MENU_COPY, MF_ENABLED );
} else {
EnableMenuItem( (HMENU)wParam, IDM_MENU_CUT, MF_GRAYED );
EnableMenuItem( (HMENU)wParam, IDM_MENU_COPY, MF_GRAYED );
}
// set the paste menu item
if( OpenClipboard( hWnd ) ) {
if( //IsClipboardFormatAvailable( WClipbdFormat ) ||
IsClipboardFormatAvailable( WItemClipbdFormat ) ) {
EnableMenuItem( (HMENU)wParam, IDM_MENU_PASTE, MF_ENABLED );
} else {
EnableMenuItem( (HMENU)wParam, IDM_MENU_PASTE, MF_GRAYED );
}
CloseClipboard();
}
ret = FALSE;
}
break;
case WM_CREATE:
einfo = ((CREATESTRUCT *)lParam)->lpCreateParams;
SET_WNDLONGPTR( hWnd, 0, (LONG_PTR)einfo );
break;
case WM_MENUSELECT:
if( einfo != NULL ) {
menu = WGetMenuHandle( einfo );
WHandleMenuSelect( einfo->wsb, menu, wParam, lParam );
}
break;
case WM_GETMINMAXINFO:
minmax = (MINMAXINFO *)lParam;
minmax->ptMinTrackSize.x = appWidth;
minmax->ptMinTrackSize.y = appHeight;
break;
case WM_MOVE:
if( einfo != NULL ) {
if( IsZoomed( hWnd ) ) {
WSetOption( WOptScreenMax, TRUE );
} else if( !IsIconic( hWnd ) ) {
WUpdateScreenPosOpt( hWnd );
WSetOption( WOptScreenMax, FALSE );
}
WMovePrevWindow( einfo );
}
break;
case WM_SETFOCUS:
if( einfo != NULL && einfo->preview_window != (HWND)NULL ) {
SendMessage( einfo->preview_window, WM_NCACTIVATE, (WPARAM)TRUE, (LPARAM)NULL );
}
break;
case WM_SHOWWINDOW:
if( wParam ) {
ShowWindow( einfo->preview_window, SW_SHOWNA );
} else {
ShowWindow( einfo->preview_window, SW_HIDE );
}
break;
case WM_SIZE:
if( einfo != NULL ) {
if( wParam == SIZE_MAXIMIZED ) {
WSetOption( WOptScreenMax, TRUE );
} else if ( wParam != SIZE_MINIMIZED ) {
WUpdateScreenPosOpt( hWnd );
WSetOption( WOptScreenMax, FALSE );
}
if( einfo->preview_window != (HWND)NULL ) {
if( wParam == SIZE_MINIMIZED ) {
ShowWindow( einfo->preview_window, SW_HIDE );
} else {
ShowWindow( einfo->preview_window, SW_SHOWNA );
}
}
if( wParam != SIZE_MINIMIZED ) {
WResizeWindows( einfo );
}
}
break;
#if 0
case WM_ACTIVATE:
if( GET_WM_ACTIVATE_FACTIVE( wParam, lParam ) != WA_INACTIVE ) {
win = GET_WM_ACTIVATE_HWND( wParam, lParam );
einfo = (WMenuEditInfo *)GET_WNDLONGPTR( win, 0 );
WSetCurrentEditInfo( einfo );
} else {
WSetCurrentEditInfo( NULL );
}
break;
#endif
case WM_COMMAND:
wp = LOWORD( wParam );
switch( wp ) {
case IDM_MENU_CLEAR:
WHandleClear( einfo );
pass_to_def = FALSE;
break;
case IDM_MENU_UPDATE:
SendMessage( einfo->info->parent, MENU_PLEASE_SAVEME, 0,
(LPARAM)einfo->hndl );
pass_to_def = FALSE;
break;
case IDM_MENU_OPEN:
pass_to_def = FALSE;
if( einfo->info->modified ) {
ret = WQuerySave( einfo, FALSE );
if( !ret ) {
break;
}
}
ret = SendMessage( einfo->info->parent, MENU_PLEASE_OPENME, 0,
(LPARAM)einfo->hndl );
ret = FALSE;
break;
case IDM_MENU_SAVE:
WSaveObject( einfo, FALSE, FALSE );
pass_to_def = FALSE;
break;
case IDM_MENU_SAVEAS:
WSaveObject( einfo, TRUE, FALSE );
pass_to_def = FALSE;
break;
case IDM_MENU_SAVEINTO:
WSaveObject( einfo, TRUE, TRUE );
pass_to_def = FALSE;
break;
case IDM_MENU_EXIT:
/* clean up before we exit */
PostMessage( einfo->win, WM_CLOSE, 0, 0 );
break;
case IDM_MENU_PASTE:
WPasteMenuItem( einfo );
pass_to_def = FALSE;
break;
case IDM_MENU_CUT:
case IDM_MENU_COPY:
WClipMenuItem( einfo, wp == IDM_MENU_CUT );
pass_to_def = FALSE;
break;
case IDM_MENU_DELETE:
WDeleteMenuEntry( einfo );
pass_to_def = FALSE;
break;
case IDM_MENU_INSERTSUBITEMS:
WToggleInsertSubitems( einfo );
break;
case IDM_MENU_INSERTBEFORE:
if( !einfo->insert_before ) {
WToggleInsertBitmap( einfo );
}
break;
case IDM_MENU_INSERTAFTER:
if( einfo->insert_before ) {
WToggleInsertBitmap( einfo );
}
break;
case IDM_MENU_INSERTTOGGLE:
WToggleInsertBitmap( einfo );
break;
#if 0
case IDM_MENU_NEWITEM:
WInsertNewMenuEntry( einfo, FALSE, FALSE );
pass_to_def = FALSE;
break;
case IDM_MENU_NEWPOPUP:
WInsertNewMenuEntry( einfo, TRUE, FALSE );
pass_to_def = FALSE;
break;
case IDM_MENU_NEWSEPARATOR:
WInsertNewMenuEntry( einfo, FALSE, TRUE );
pass_to_def = FALSE;
break;
#else
case IDM_MENU_NEWITEM:
WInsertNew( einfo );
pass_to_def = FALSE;
break;
#endif
case IDM_MENU_SYMBOLS:
handleSymbols( einfo );
pass_to_def = FALSE;
break;
case IDM_MENU_LOAD_SYMBOLS:
handleLoadSymbols( einfo );
pass_to_def = FALSE;
break;
case IDM_MENU_SHOWRIBBON:
menu = WGetMenuHandle( einfo );
WShowRibbon( einfo, menu );
pass_to_def = FALSE;
break;
case IDM_MENU_MEM_FLAGS:
WSetStatusByID( einfo->wsb, W_CHANGEMENUMEMFLAGS, -1 );
einfo->info->modified |= WChangeMemFlags( einfo->win, &einfo->info->MemFlags,
einfo->info->res_name,
WGetEditInstance(),
WMenuHelpRoutine );
WSetStatusReadyText( einfo->wsb );
pass_to_def = FALSE;
break;
case IDM_MENU_RENAME:
WHandleRename( einfo );
pass_to_def = FALSE;
break;
case IDM_HELP:
WMenuHelpRoutine();
pass_to_def = FALSE;
break;
case IDM_HELP_SEARCH:
WMenuHelpSearchRoutine();
pass_to_def = FALSE;
break;
case IDM_HELP_ON_HELP:
WMenuHelpOnHelpRoutine();
pass_to_def = FALSE;
break;
case IDM_MENU_ABOUT:
ai.owner = hWnd;
ai.inst = WGetEditInstance();
ai.name = AllocRCString( W_ABOUT_NAME );
ai.version = AllocRCString( W_ABOUT_VERSION );
ai.first_cr_year = "2002";
ai.title = AllocRCString( W_ABOUT_TITLE );
DoAbout( &ai );
FreeRCString( ai.name );
FreeRCString( ai.version );
FreeRCString( ai.title );
pass_to_def = FALSE;
break;
}
break;
case WM_DESTROY:
WWinHelp( hWnd, "resmnu.hlp", HELP_QUIT, 0 );
WCleanup( einfo );
break;
case WM_CLOSE:
ret = TRUE;
pass_to_def = WHandleWM_CLOSE( einfo, (Bool)wParam );
wParam = 0;
break;
}
if( pass_to_def ) {
ret = DefWindowProc( hWnd, message, wParam, lParam );
}
return( ret );
}
WINEXPORT LRESULT CALLBACK WdeMainWndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
HMENU menu;
LRESULT ret;
bool pass_to_def;
WdeResInfo *res_info;
WORD wp;
about_info ai;
if( WdeCleanupStarted ) {
if( message == WM_DESTROY ) {
PostQuitMessage( 0 );
}
return( DefFrameProc( hWnd, hWinWdeMDIClient, message, wParam, lParam ) );
}
pass_to_def = TRUE;
ret = FALSE;
res_info = WdeGetCurrentRes();
menu = WdeGetMenuHandle();
switch( message ) {
case WM_INITMENU:
handleInitMenu( menu );
break;
case WM_USER:
WdeSetStatusByID( -1, WDE_ONLYONEINSTANCE );
break;
case WM_MENUSELECT:
WdeHandleMenuSelect( wParam, lParam );
break;
case WM_MEASUREITEM:
WdeHandleMeasureItem( (MEASUREITEMSTRUCT *)lParam );
ret = TRUE;
pass_to_def = FALSE;
break;
case WM_DRAWITEM:
WdeHandleDrawItem( (DRAWITEMSTRUCT *)lParam );
ret = TRUE;
pass_to_def = FALSE;
break;
case WM_MOVE:
if( IsZoomed( hWnd ) ) {
WdeSetOption( WdeOptIsScreenMax, TRUE );
} else if( !IsIconic( hWnd ) ) {
WdeUpdateScreenPosOpt();
WdeSetOption( WdeOptIsScreenMax, FALSE );
}
break;
case WM_SIZE:
if( wParam == SIZE_MAXIMIZED ) {
WdeSetOption( WdeOptIsScreenMax, TRUE );
} else if( wParam != SIZE_MINIMIZED ) {
WdeUpdateScreenPosOpt();
WdeSetOption( WdeOptIsScreenMax, FALSE );
}
if( wParam != SIZE_MINIMIZED ) {
WdeResizeWindows();
}
pass_to_def = FALSE;
break;
case WM_COMMAND:
wp = LOWORD( wParam );
if( !WdeIsMenuIDValid( menu, wp ) ) {
break;
}
switch( wp ) {
case IDM_SELECT_MODE:
case IDM_DIALOG_TOOL:
case IDM_PBUTTON_TOOL:
case IDM_CBUTTON_TOOL:
case IDM_RBUTTON_TOOL:
case IDM_GBUTTON_TOOL:
case IDM_FRAME_TOOL:
case IDM_TEXT_TOOL:
case IDM_ICON_TOOL:
case IDM_EDIT_TOOL:
case IDM_LISTBOX_TOOL:
case IDM_COMBOBOX_TOOL:
case IDM_HSCROLL_TOOL:
case IDM_VSCROLL_TOOL:
case IDM_SIZEBOX_TOOL:
case IDM_STATUSBAR_TOOL:
case IDM_LISTVIEW_TOOL:
case IDM_TREEVIEW_TOOL:
case IDM_TABCNTL_TOOL:
case IDM_ANIMATE_TOOL:
case IDM_UPDOWN_TOOL:
case IDM_TRACKBAR_TOOL:
case IDM_PROGRESS_TOOL:
case IDM_HOTKEY_TOOL:
case IDM_HEADER_TOOL:
case IDM_CUSTOM1_TOOL:
case IDM_CUSTOM2_TOOL:
WdeSetBaseObject( wp );
pass_to_def = FALSE;
break;
case IDM_STICKY_TOOLS:
WdeToggleStickyTools();
pass_to_def = FALSE;
break;
case IDM_FMLEFT:
case IDM_FMRIGHT:
case IDM_FMTOP:
case IDM_FMBOTTOM:
case IDM_FMVCENTRE:
case IDM_FMHCENTRE:
case IDM_ESCAPE:
case IDM_DELETEOBJECT:
case IDM_SPACE_HORZ:
case IDM_SPACE_VERT:
ret = WdePassToEdit( message, wParam, lParam );
pass_to_def = FALSE;
break;
case IDM_SELECT_DIALOG:
WdeSelectDialog( res_info );
pass_to_def = FALSE;
break;
case IDM_OPTIONS:
WdeDisplayOptions ();
pass_to_def = FALSE;
break;
case IDM_NEW_RES:
WdeCreateNewResource( NULL );
pass_to_def = FALSE;
break;
case IDM_DDE_CLEAR:
WdeClearCurrentResource();
pass_to_def = FALSE;
break;
case IDM_OPEN_RES:
WdeOpenResource( NULL );
pass_to_def = FALSE;
break;
case IDM_SAVE_RES:
WdeSaveResource( res_info, FALSE );
pass_to_def = FALSE;
break;
case IDM_SAVEAS_RES:
WdeSaveResource( res_info, TRUE );
pass_to_def = FALSE;
break;
case IDM_DDE_UPDATE_PRJ:
WdeUpdateDDEEditSession();
break;
case IDM_PASTEOBJECT:
if( FMPasteValid() ) {
ret = WdePassToEdit( message, wParam, lParam );
}
pass_to_def = FALSE;
break;
case IDM_CUTOBJECT:
case IDM_COPYOBJECT:
ret = WdePassToEdit( message, wParam, lParam );
pass_to_def = FALSE;
break;
case IDM_SAME_WIDTH:
WdeSameSize( R_RIGHT );
pass_to_def = FALSE;
break;
case IDM_SAME_HEIGHT:
WdeSameSize( R_BOTTOM );
pass_to_def = FALSE;
break;
case IDM_SAME_SIZE:
WdeSameSize( R_BOTTOM | R_RIGHT );
pass_to_def = FALSE;
break;
case IDM_SIZETOTEXT:
WdeHandleSizeToText();
pass_to_def = FALSE;
break;
case IDM_GOTO_INFOBAR:
WdeSetFocusToInfo();
pass_to_def = FALSE;
break;
case IDM_GOTO_OBJECT:
WdeHandleGotoCurrentObject();
pass_to_def = FALSE;
break;
case IDM_DIALOG_RESTORE:
WdeRestoreCurrentDialog();
pass_to_def = FALSE;
break;
case IDM_TAB:
case IDM_STAB:
WdeHandleTabEvent( wp == IDM_TAB );
pass_to_def = FALSE;
break;
#if 0
/* this strategy has been rejected in favor of the hide option */
case IDM_REMOVE_DIALOG:
WdeRemoveDialog( res_info );
pass_to_def = FALSE;
break;
#endif
case IDM_HIDE_DIALOG:
WdeHideCurrentDialog();
pass_to_def = FALSE;
break;
case IDM_TEST_MODE:
WdeHandleTestModeMenu( res_info );
pass_to_def = FALSE;
break;
case IDM_DIALOG_NEW:
if( WdeCreateNewDialog( NULL, res_info->is32bit ) ) {
WdeHandleGotoCurrentObject();
}
pass_to_def = FALSE;
break;
case IDM_DIALOG_SAVE:
case IDM_DIALOG_SAVEAS:
case IDM_DIALOG_SAVEINTO:
WdeSaveCurrentDialog( wp );
pass_to_def = FALSE;
break;
case IDM_SET_ORDER:
case IDM_SET_TABS:
case IDM_SET_GROUPS:
WdeSetDialogMode( wp );
pass_to_def = FALSE;
break;
case IDM_DEFINEOBJECT:
case IDM_GEN_DEFINEOBJECT:
if( !WdeDefineCurrentObject( wp ) ) {
WdeWriteTrail( "WdeResWndProc: Define failed!" );
}
pass_to_def = FALSE;
break;
case IDM_MDI_CASCADE:
case IDM_MDI_TILEV:
case IDM_MDI_TILEH:
case IDM_MDI_ARRANGE:
WdeHandleMDIArrangeEvents( wp );
pass_to_def = FALSE;
break;
case IDM_EXIT:
/* clean up before we exit */
PostMessage( hWinWdeMain, WM_CLOSE, 0, 0 );
break;
case IDM_SELCUST1:
case IDM_SELCUST2:
if( !WdeSetCurrentCustControl( wp - IDM_SELCUST1 ) ) {
WdeWriteTrail( "WdeMainWndProc: WdeSetCurrentCustControl failed!" );
WdeSetStatusByID( -1, WDE_SETFAILED );
}
pass_to_def = FALSE;
break;
case IDM_MS_CUSTOM:
WdeLoadCustomLib( TRUE, FALSE );
pass_to_def = FALSE;
break;
#ifndef __NT__
case IDM_BOR_CUSTOM:
WdeLoadCustomLib( FALSE, FALSE );
pass_to_def = FALSE;
break;
#endif
case IDM_LOADLIB:
WdeLoadCustomLib( FALSE, TRUE );
pass_to_def = FALSE;
break;
case IDM_WRITE_SYMBOLS:
WdeResourceHashTableAction( res_info, WRITE_HASH );
pass_to_def = FALSE;
break;
case IDM_LOAD_SYMBOLS:
WdeResourceHashTableAction( res_info, LOAD_HASH );
pass_to_def = FALSE;
break;
case IDM_VIEW_SYMBOLS:
WdeResourceHashTableAction( res_info, VIEW_HASH );
pass_to_def = FALSE;
break;
case IDM_SHOW_TOOLS:
WdeHandleShowToolsMenu();
pass_to_def = FALSE;
break;
case IDM_SHOW_RIBBON:
WdeShowRibbon();
pass_to_def = FALSE;
break;
case IDM_HELP:
WdeHelpRoutine();
pass_to_def = FALSE;
break;
case IDM_HELP_SEARCH:
WdeHelpSearchRoutine();
pass_to_def = FALSE;
break;
case IDM_HELP_ON_HELP:
WdeHelpOnHelpRoutine();
pass_to_def = FALSE;
break;
case IDM_ABOUT:
ai.owner = hWnd;
ai.inst = hInstWde;
ai.name = AllocRCString( WDE_ABOUT_NAME );
ai.version = AllocRCString( WDE_ABOUT_VERSION );
ai.first_cr_year = "1984";
ai.title = AllocRCString( WDE_ABOUT_TITLE );
DoAbout( &ai );
FreeRCString( ai.name );
FreeRCString( ai.version );
FreeRCString( ai.title );
pass_to_def = FALSE;
break;
}
break;
case WM_DESTROY:
WWinHelp( hWinWdeMain, "resdlg.hlp", HELP_QUIT, 0 );
PostQuitMessage( 0 );
break;
case WDE_FATAL_EXIT:
WdeFatalExit = TRUE;
WdeQueryKillApp( TRUE );
PostMessage( hWinWdeMain, WM_CLOSE, 0, 0 );
break;
case WM_ENDSESSION:
if ( !wParam ) {
WdeFatalExit = FALSE;
}
break;
case WM_QUERYENDSESSION:
ret = WdeQueryKillApp( FALSE );
if( ret ) {
WdeFatalExit = TRUE;
pass_to_def = FALSE;
}
break;
case WM_CLOSE:
// this prevents the user from closing the editor during
// DDE initialization
if( !wParam && !EnableMenuInput ) {
return( 0 );
}
/* clean up before we exit */
WdeCleanupStarted = TRUE;
if( wParam ) { // wParam is non-zero if the DDE connection died
WdeFatalExit = TRUE;
WdeQueryKillApp( TRUE );
wParam = 0;
}
if( !WdeCleanup( res_info, WdeFatalExit ) ) {
WdeCleanupStarted = FALSE;
pass_to_def = FALSE;
}
}
if( pass_to_def ) {
ret = DefFrameProc( hWnd, hWinWdeMDIClient, message, wParam, lParam );
}
return( ret );
}
bool WCreateEditWindow( HINSTANCE inst, WAccelEditInfo *einfo )
{
int x, y, width, height;
char *title;
HMENU hmenu;
HMENU menu;
bool is_rc;
RECT rect;
if( einfo == NULL ) {
return( FALSE );
}
x = CW_USEDEFAULT;
y = CW_USEDEFAULT;
width = appWidth;
height = appHeight;
if( einfo->info->stand_alone ) {
WGetScreenPosOption( &rect );
if( !IsRectEmpty( &rect ) ) {
x = rect.left;
y = rect.top;
width = appWidth;
if( width < rect.right - rect.left )
width = rect.right - rect.left;
height = appHeight;
if( height < rect.bottom - rect.top ) {
height = rect.bottom - rect.top;
}
}
}
is_rc = FALSE;
title = WCreateEditTitle( einfo );
if( title == NULL ) {
title = AllocRCString( W_ACCELAPPTITLE );
is_rc = TRUE;
}
menu = (HMENU)NULL;
if( einfo->info->stand_alone ) {
menu = LoadMenu( inst, WMainSOMenuName );
}
einfo->win = CreateWindow( WMainClass, title, WS_OVERLAPPEDWINDOW,
x, y, width, height, einfo->info->parent,
menu, inst, einfo );
if( title != NULL ) {
if( is_rc ) {
FreeRCString( title );
} else {
WRMemFree( title );
}
}
if( einfo->win == (HWND)NULL ) {
return( FALSE );
}
if( !WCreateRibbon( einfo ) ) {
return( FALSE );
}
einfo->wsb = WCreateStatusLine( einfo->win, inst );
if( einfo->wsb == NULL ) {
return( FALSE );
}
if( !WCreateAccelEditWindow( einfo, inst ) ) {
return( FALSE );
}
hmenu = GetMenu( einfo->win );
if( hmenu != (HMENU)NULL ) {
EnableMenuItem( hmenu, IDM_ACC_CUT, MF_GRAYED );
EnableMenuItem( hmenu, IDM_ACC_COPY, MF_GRAYED );
}
if( WGetOption( WOptScreenMax ) ) {
ShowWindow( einfo->win, SW_SHOWMAXIMIZED );
} else {
ShowWindow( einfo->win, SW_SHOWNORMAL );
}
UpdateWindow( einfo->win );
WResizeWindows( einfo );
SetFocus( einfo->edit_dlg );
return( TRUE );
}
WINEXPORT LRESULT CALLBACK WMainWndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
HMENU menu;
#if 0
HWND win;
#endif
LRESULT ret;
bool pass_to_def;
WAccelEditInfo *einfo;
WORD wp;
MINMAXINFO *minmax;
about_info ai;
pass_to_def = TRUE;
ret = FALSE;
einfo = (WAccelEditInfo *)GET_WNDLONGPTR( hWnd, 0 );
WSetCurrentEditInfo( einfo );
if( einfo != NULL && einfo->getting_key ) {
if( WGetKeyPressProc( einfo, message, wParam, lParam ) ) {
einfo->getting_key = FALSE;
DestroyWindow( einfo->key_info.text_win );
ReleaseCapture();
WHandleChange( einfo );
pass_to_def = FALSE;
}
}
switch( message ) {
case WM_ACTIVATE:
if( GET_WM_ACTIVATE_FACTIVE( wParam, lParam ) &&
!GET_WM_ACTIVATE_FMINIMIZED( wParam, lParam ) &&
einfo != NULL && einfo->edit_dlg != (HWND)NULL ) {
SetFocus( einfo->edit_dlg );
pass_to_def = FALSE;
}
break;
case WM_INITMENU:
if( wParam == (WPARAM)GetMenu( hWnd ) ) {
// set the cut and copy menu items
if( SendDlgItemMessage( einfo->edit_dlg, IDM_ACCEDLIST, LB_GETCURSEL, 0, 0 ) != LB_ERR ) {
EnableMenuItem( (HMENU)wParam, IDM_ACC_CUT, MF_ENABLED );
EnableMenuItem( (HMENU)wParam, IDM_ACC_COPY, MF_ENABLED );
} else {
EnableMenuItem( (HMENU)wParam, IDM_ACC_CUT, MF_GRAYED );
EnableMenuItem( (HMENU)wParam, IDM_ACC_COPY, MF_GRAYED );
}
// set the paste menu item
if( OpenClipboard( hWnd ) ) {
if( //IsClipboardFormatAvailable( WClipbdFormat ) ||
IsClipboardFormatAvailable( WItemClipbdFormat ) ) {
EnableMenuItem( (HMENU)wParam, IDM_ACC_PASTE, MF_ENABLED );
} else {
EnableMenuItem( (HMENU)wParam, IDM_ACC_PASTE, MF_GRAYED );
}
CloseClipboard();
}
}
break;
case WM_CREATE:
einfo = ((CREATESTRUCT *)lParam)->lpCreateParams;
SET_WNDLONGPTR( hWnd, 0, (LONG_PTR)einfo );
break;
case WM_MENUSELECT:
if( einfo != NULL ) {
menu = WGetMenuHandle( einfo );
WHandleMenuSelect( einfo->wsb, menu, wParam, lParam );
setLastMenuSelect( einfo, wParam, lParam );
}
break;
case WM_GETMINMAXINFO:
minmax = (MINMAXINFO *)lParam;
minmax->ptMinTrackSize.x = appWidth;
minmax->ptMinTrackSize.y = appHeight;
break;
case WM_MOVE:
if( einfo != NULL ) {
if( IsZoomed( hWnd ) ) {
WSetOption( WOptScreenMax, TRUE );
} else if( !IsIconic( hWnd ) ) {
WUpdateScreenPosOpt( hWnd );
WSetOption( WOptScreenMax, FALSE );
}
}
break;
case WM_SIZE:
if( einfo != NULL ) {
if( wParam == SIZE_MAXIMIZED ) {
WSetOption( WOptScreenMax, TRUE );
} else if( wParam != SIZE_MINIMIZED ) {
WUpdateScreenPosOpt( hWnd );
WSetOption( WOptScreenMax, FALSE );
}
WResizeWindows( einfo );
}
break;
#if 0
case WM_ACTIVATE:
if( GET_WM_ACTIVATE_FACTIVE( wParam, lParam ) != WA_INACTIVE ) {
einfo = (WAccelEditInfo *)GET_WNDLONGPTR( hWnd, 0 );
if( einfo != NULL && einfo->edit_dlg != (HWND)NULL ) {
SetFocus( einfo->edit_dlg );
}
WSetCurrentEditInfo( einfo );
} else {
WSetCurrentEditInfo( NULL );
}
break;
#endif
case WM_COMMAND:
wp = LOWORD( wParam );
switch( wp ) {
case IDM_ACC_CLEAR:
WHandleClear( einfo );
pass_to_def = FALSE;
break;
case IDM_ACC_UPDATE:
SendMessage( einfo->info->parent, ACCEL_PLEASE_SAVEME, 0, (LPARAM)einfo->hndl );
pass_to_def = FALSE;
break;
case IDM_ACC_OPEN:
pass_to_def = FALSE;
if( einfo->info->modified ) {
ret = WQuerySave( einfo, FALSE );
if( !ret ) {
break;
}
}
ret = SendMessage( einfo->info->parent, ACCEL_PLEASE_OPENME, 0,
(LPARAM)einfo->hndl );
ret = FALSE;
break;
case IDM_ACC_SAVE:
WSaveObject( einfo, FALSE, FALSE );
pass_to_def = FALSE;
break;
case IDM_ACC_SAVEAS:
WSaveObject( einfo, TRUE, FALSE );
pass_to_def = FALSE;
break;
case IDM_ACC_SAVEINTO:
WSaveObject( einfo, TRUE, TRUE );
pass_to_def = FALSE;
break;
case IDM_ACC_EXIT:
/* clean up before we exit */
PostMessage( einfo->win, WM_CLOSE, 0, 0 );
break;
case IDM_ACC_PASTE:
WPasteAccelItem( einfo );
pass_to_def = FALSE;
break;
case IDM_ACC_COPY:
case IDM_ACC_CUT:
WClipAccelItem( einfo, wp == IDM_ACC_CUT );
pass_to_def = FALSE;
break;
case IDM_ACC_DELETE:
WDeleteAccelEntry( einfo );
pass_to_def = FALSE;
break;
case IDM_ACC_NEWITEM:
WInsertAccelEntry( einfo );
pass_to_def = FALSE;
break;
case IDM_ACC_KEYVALUE:
WSetStatusByID( einfo->wsb, W_GETTINGKEYS, -1 );
WHandleGetKeyValue( einfo, einfo->last_menu_select == IDM_ACC_KEYVALUE );
WSetStatusReadyText( einfo->wsb );
pass_to_def = FALSE;
break;
case IDM_ACC_SYMBOLS:
handleSymbols( einfo );
pass_to_def = FALSE;
break;
case IDM_ACC_LOAD_SYMBOLS:
handleLoadSymbols( einfo );
pass_to_def = FALSE;
break;
case IDM_ACC_SHOWRIBBON:
menu = WGetMenuHandle( einfo );
WShowRibbon( einfo, menu );
pass_to_def = FALSE;
break;
case IDM_ACC_MEM_FLAGS:
WSetStatusByID( einfo->wsb, W_CHANGEACCELMEMFLAGS, -1 );
einfo->info->modified |= WChangeMemFlags( einfo->win, &einfo->info->MemFlags,
einfo->info->res_name,
WGetEditInstance(),
WAccHelpRoutine );
pass_to_def = FALSE;
WSetStatusReadyText( einfo->wsb );
break;
case IDM_ACC_RENAME:
WHandleRename( einfo );
pass_to_def = FALSE;
break;
case IDM_HELP:
WAccHelpRoutine();
pass_to_def = FALSE;
break;
case IDM_HELP_SEARCH:
WAccHelpSearchRoutine();
pass_to_def = FALSE;
break;
case IDM_HELP_ON_HELP:
WAccHelpOnHelpRoutine();
pass_to_def = FALSE;
break;
case IDM_ACC_ABOUT:
ai.owner = hWnd;
ai.inst = WGetEditInstance();
ai.name = AllocRCString( W_ABOUT_NAME );
ai.version = AllocRCString( W_ABOUT_VERSION );
ai.first_cr_year = "2002";
ai.title = AllocRCString( W_ABOUT_TITLE );
DoAbout( &ai );
FreeRCString( ai.name );
FreeRCString( ai.version );
FreeRCString( ai.title );
pass_to_def = FALSE;
break;
}
break;
case WM_DESTROY:
WWinHelp( hWnd, "resacc.hlp", HELP_QUIT, 0 );
WCleanup( einfo );
break;
case WM_CLOSE:
ret = TRUE;
pass_to_def = WHandleWM_CLOSE( einfo, wParam != 0 );
wParam = 0;
break;
}
if( pass_to_def ) {
ret = DefWindowProc( hWnd, message, wParam, lParam );
}
return( ret );
}
char *WRAllocRCString( msg_id id )
{
return( AllocRCString( id ) );
}
bool WRECreateStatusLine( HWND main, HINSTANCE inst )
{
RECT rect;
LOGFONT lf;
TEXTMETRIC tm;
HFONT old_font;
HDC dc;
status_block_desc sbd;
char *font_facename;
char *cp;
int font_pointsize;
bool use_default;
memset( &lf, 0, sizeof( LOGFONT ) );
dc = GetDC( main );
lf.lfWeight = FW_BOLD;
use_default = true;
font_facename = AllocRCString( WRE_STATUSFONT );
if( font_facename != NULL ) {
cp = (char *)_mbschr( (unsigned char const *)font_facename, '.' );
if( cp != NULL ) {
*cp = '\0';
strcpy( lf.lfFaceName, font_facename );
cp++;
font_pointsize = atoi( cp );
use_default = false;
}
FreeRCString( font_facename );
}
if( use_default ) {
strcpy( lf.lfFaceName, STATUS_FONTFACENAME );
font_pointsize = STATUS_FONTPOINTSIZE;
}
lf.lfHeight = -MulDiv( font_pointsize, GetDeviceCaps( dc, LOGPIXELSY ), 72 );
WREStatusFont = CreateFontIndirect( &lf );
old_font = SelectObject( dc, WREStatusFont );
GetTextMetrics( dc, &tm );
SelectObject( dc, old_font );
ReleaseDC( main, dc );
GetClientRect( main, &rect );
WREStatusDepth = tm.tmHeight + STATUS_LINE_PAD + VERT_BORDER * 2;
rect.top = rect.bottom - WREStatusDepth;
StatusWndInit( inst, WREStatusHookProc, 0, (HCURSOR)NULL );
WREStatusBar = StatusWndStart();
sbd.separator_width = STATUS_LINE_PAD;
sbd.width = STATUS1_WIDTH;
sbd.width_is_percent = FALSE;
sbd.width_is_pixels = TRUE;
StatusWndSetSeparators( WREStatusBar, 1, &sbd );
WREStatusWindow = StatusWndCreate( WREStatusBar, main, &rect, inst, NULL );
if( WREStatusWindow == NULL ) {
WREDisplayErrorMsg( WRE_NOCREATESTATUS );
return( false );
}
/* set the text in the status window */
WRESetStatusReadyText();
GetWindowRect( WREStatusWindow, &rect );
WREStatusDepth = rect.bottom - rect.top;
return( true );
}
bool pleaseOpenFile( UINT msg )
{
char *filter;
char *title;
char *name;
WREResInfo *res_info;
WREResInfo *old_info;
WREGetFileStruct gf;
uint_16 type;
bool ok;
old_info = WREGetCurrentRes();
res_info = NULL;
filter = NULL;
title = NULL;
name = NULL;
if( msg == ACCEL_PLEASE_OPENME ) {
filter = WREAccelFilter;
title = AllocRCString( WRE_OPENACCEL );
type = (uint_16)(pointer_int)RT_ACCELERATOR;
} else if( msg == MENU_PLEASE_OPENME ) {
filter = WREMenuFilter;
title = AllocRCString( WRE_OPENMENU );
type = (uint_16)(pointer_int)RT_MENU;
} else if( msg == STRING_PLEASE_OPENME ) {
filter = WREStringFilter;
title = AllocRCString( WRE_OPENSTRING );
type = (uint_16)(pointer_int)RT_STRING;
}
ok = (filter != NULL && title != NULL);
if( ok ) {
gf.file_name = NULL;
gf.title = title;
gf.filter = filter;
gf.save_ext = FALSE;
ok = ((name = WREGetOpenFileName( &gf )) != NULL);
}
if( ok ) {
ok = ((res_info = WRELoadResource( name )) != NULL);
}
if( ok ) {
WREFindAndLoadSymbols( res_info );
ok = WRECreateResourceWindow( res_info );
}
if( ok ) {
ListAddElt( &WREResList, (void *)res_info );
}
if( ok ) {
ok = (WREFindTypeNode( res_info->info->dir, type, NULL ) != NULL);
}
if( ok ) {
ok = WRESetResNamesFromType( res_info, type, FALSE, NULL, 0 );
}
if( ok ) {
ok = WREHandleResEdit();
}
if( ok ) {
SendMessage( old_info->res_win, WM_CLOSE, 0, 0 );
}
if( !ok ) {
if( res_info != NULL ) {
WREFreeResInfo( res_info );
res_info = NULL;
}
}
if( name != NULL ) {
WRMemFree( name );
}
if( title != NULL ) {
FreeRCString( title );
}
return( ok );
}
static bool WREInitStaticVars( void )
{
bool ok;
WREResUntitled = AllocRCString( WRE_UNTITLED );
ok = (WREResUntitled != NULL);
if( ok ) {
WREResOpenTitle = AllocRCString( WRE_OPENPROJECTTITLE );
ok = (WREResOpenTitle != NULL);
}
if( ok ) {
WREResSaveTitle = AllocRCString( WRE_SAVEPROJECTTITLE );
ok = (WREResSaveTitle != NULL);
}
if( ok ) {
WREResSaveIntoTitle = AllocRCString( WRE_COPYINTOPROJECTTITLE );
ok = (WREResSaveIntoTitle != NULL);
}
if( ok ) {
WREResSaveAsTitle = AllocRCString( WRE_SAVEASPROJECTTITLE );
ok = (WREResSaveAsTitle != NULL);
}
if( ok ) {
WREResFilter = AllocRCString( WRE_PROJECTFILTER );
ok = (WREResFilter != NULL);
if( ok ) {
WREMassageFilter( WREResFilter );
}
}
if( ok ) {
WREResSaveMltFilter = AllocRCString( WRE_SAVEMLTFILTER );
ok = (WREResSaveMltFilter != NULL);
if( ok ) {
WREMassageFilter( WREResSaveMltFilter );
}
}
if( ok ) {
WRESymSaveFilter = AllocRCString( WRE_SYMFILTER );
ok = (WRESymSaveFilter != NULL);
if( ok ) {
WREMassageFilter( WRESymSaveFilter );
}
}
if( ok ) {
WRESymLoadTitle = AllocRCString( WRE_LOADSYMTITLE );
ok = (WRESymLoadTitle != NULL);
}
if( ok ) {
WRESymSaveTitle = AllocRCString( WRE_SAVESYMTITLE );
ok = (WRESymSaveTitle != NULL);
}
if( ok ) {
WREAccelFilter = AllocRCString( WRE_ACCELFILTER );
ok = (WREAccelFilter != NULL);
if( ok ) {
WREMassageFilter( WREAccelFilter );
}
}
if( ok ) {
WREMenuFilter = AllocRCString( WRE_MENUFILTER );
ok = (WREMenuFilter != NULL);
if( ok ) {
WREMassageFilter( WREMenuFilter );
}
}
if( ok ) {
WREStringFilter = AllocRCString( WRE_STRINGFILTER );
ok = (WREStringFilter != NULL);
if( ok ) {
WREMassageFilter( WREStringFilter );
}
}
if( !ok ) {
WREFiniStaticVars();
}
return( ok );
}
/*
* WindowProc - main window message handler
*/
LONG CALLBACK MainWindowProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
WORD cmd;
about_info ai;
HMENU mh;
CommunicationBuffer *dbginfo;
switch ( msg ) {
case WM_CREATE:
setupSystemMenu( hwnd );
MainLBox = CreateListBox( hwnd );
mh = GetMenu( hwnd );
if( ConfigData.auto_attatch ) {
CheckMenuItem( mh, MENU_AUTO_ATTATCH, MF_BYCOMMAND | MF_CHECKED );
}
if( ConfigData.continue_exception ) {
CheckMenuItem( mh, MENU_EXCEPTION_CONTINUE,
MF_BYCOMMAND | MF_CHECKED );
}
LBPrintf( MainLBox, STR_DRNT_STARTED, AppName );
break;
case WM_SIZE:
MoveListBox( MainLBox, 0, 0, LOWORD( lparam ), HIWORD( lparam ) );
ClearAlert();
break;
case WM_SYSCOMMAND:
switch( wparam ) {
case MENU_LOG_CURRENT_STATE:
case MENU_LOG_OPTIONS:
case MENU_TASK_CTL:
SendMessage( hwnd, WM_COMMAND, wparam, 0 );
break;
default:
return( DefWindowProc( hwnd, msg, wparam, lparam ) );
}
break;
case WM_COMMAND:
cmd = LOWORD( wparam );
switch( cmd ) {
case LISTBOX_1:
break;
case MENU_EXCEPTION_CONTINUE:
ConfigData.continue_exception = !ConfigData.continue_exception;
mh = GetMenu( hwnd );
if( ConfigData.continue_exception ) {
CheckMenuItem( mh, MENU_EXCEPTION_CONTINUE,
MF_BYCOMMAND | MF_CHECKED );
} else {
CheckMenuItem( mh, MENU_EXCEPTION_CONTINUE,
MF_BYCOMMAND | MF_UNCHECKED );
}
break;
case MENU_LOG_VIEW:
ViewLog();
break;
case MENU_NEW_TASK:
CallProcCtl( MENU_NEW_TASK, NULL, NULL );
break;
case MENU_AUTO_ATTATCH:
ConfigData.auto_attatch = ! ConfigData.auto_attatch;
mh = GetMenu( hwnd );
if( ConfigData.auto_attatch ) {
CheckMenuItem( mh, MENU_AUTO_ATTATCH,
MF_BYCOMMAND | MF_CHECKED );
} else {
CheckMenuItem( mh, MENU_AUTO_ATTATCH,
MF_BYCOMMAND | MF_UNCHECKED );
}
break;
case MENU_SHOW_DIP_STATUS:
ShowDIPStatus( hwnd );
break;
case MENU_CLEAR:
ClearListBox( MainLBox );
break;
case MENU_SAVE_AS:
SaveListBox( SLB_SAVE_AS, SaveExtra, "", AppName, hwnd,
GetListBoxHwnd( MainLBox ) );
break;
case MENU_SAVE:
SaveListBox( SLB_SAVE_TMP, SaveExtra, ".\\drwat.txt", AppName,
hwnd, GetListBoxHwnd( MainLBox ) );
break;
case MENU_FONT:
if( ChooseMonoFont( hwnd ) ) {
SetListBoxFont( MainLBox );
}
break;
case MENU_MARK:
ProcessMark( hwnd, Instance, MarkPrint );
break;
case MENU_ABOUT:
ai.owner = hwnd;
ai.inst = Instance;
ai.name = AllocRCString( STR_ABOUT_NAME );
ai.version = AllocRCString( STR_ABOUT_VERSION );
ai.first_cr_year = "1993";
ai.title = AllocRCString( STR_ABOUT_TITLE );
DoAbout( &ai );
FreeRCString( ai.name );
FreeRCString( ai.version );
FreeRCString( ai.title );
break;
case MENU_HELP_CONTENTS:
if( !WHtmlHelp( hwnd, DR_CHM_FILE, HELP_CONTENTS, 0 ) ) {
WWinHelp( hwnd, DR_HELP_FILE, HELP_CONTENTS, 0 );
}
break;
case MENU_HELP_SRCH:
if( !WHtmlHelp( hwnd, DR_CHM_FILE, HELP_PARTIALKEY, (HELP_DATA)"" ) ) {
WWinHelp( hwnd, DR_HELP_FILE, HELP_PARTIALKEY, (HELP_DATA)"" );
}
break;
case MENU_HELP_ON_HELP:
WWinHelp( hwnd, HELP_HELP_FILE, HELP_HELPONHELP, 0 );
break;
case MENU_TASK_CTL:
DisplayProcList();
break;
case MENU_LOG_CURRENT_STATE:
MakeLog( NULL );
break;
case MENU_ERASE_LOG_FILE:
EraseLog();
break;
case MENU_LOG_OPTIONS:
SetLogOptions( hwnd );
break;
case MENU_EXIT:
SendMessage( hwnd, WM_CLOSE, 0, 0L );
break;
default:
MessageBox( hwnd, "This function is not yet available",
AppName, MB_OK );
break;
}
break;
case DR_DEBUG_EVENT:
dbginfo = (CommunicationBuffer *)lparam;
dbginfo->action = DebugEventHandler( &dbginfo->dbginfo );
break;
case WM_COPYDATA:
{
COPYDATASTRUCT *copydata;
copydata = (COPYDATASTRUCT *)lparam;
ProcessCommandLine( copydata->lpData );
}
break;
case WM_CLOSE:
if( QueryEnd( hwnd ) ) {
SendMessage( hwnd, WM_DESTROY, 0, 0L );
}
break;
case WM_DESTROY:
FiniListBox( MainLBox );
PutProfileInfo();
DestroyMonoFonts();
WWinHelp( hwnd, DR_HELP_FILE, HELP_QUIT, 0 );
PostQuitMessage( 0 );
break;
default:
return( DefWindowProc( hwnd, msg, wparam, lparam ) );
}
return( 0L );
} /* WindowProc */
char *WLoadSymbols( WRHashTable **table, char *file_name, HWND parent, bool prompt )
{
char *name;
int c;
unsigned flags;
char *inc_path;
WGetFileStruct gf;
bool ret;
bool ok;
name = NULL;
ok = (table != NULL);
if( ok ) {
if( file_name == NULL || prompt ) {
gf.file_name = file_name;
gf.title = AllocRCString( W_LOADSYMTITLE );
gf.filter = AllocRCString( W_SYMFILTER );
WMassageFilter( gf.filter );
name = WGetOpenFileName( parent, &gf );
if( gf.title != NULL ) {
FreeRCString( gf.title );
}
if( gf.filter != NULL ) {
FreeRCString( gf.filter );
}
} else {
name = WStrDup( file_name );
}
ok = (name != NULL);
}
WSetWaitCursor( parent, TRUE );
if( ok ) {
flags = PPFLAG_IGNORE_INCLUDE | PPFLAG_EMIT_LINE;
inc_path = NULL;
ret = setjmp( SymEnv ) != 0;
if( ret ) {
PP_Fini();
WDisplayErrorMsg( W_SYMOUTOFMEM );
ok = false;
}
}
if( ok ) {
ok = !PP_Init( name, flags, inc_path );
if( !ok ) {
WDisplayErrorMsg( W_NOOPENSYMFILE );
}
}
if( ok ) {
do {
c = PP_Char();
} while( c != EOF );
if( *table == NULL ) {
*table = WRInitHashTable();
}
addSymbols( *table );
WRMakeHashTableClean( *table );
PP_Fini();
}
if( !ok ) {
if( name != NULL ) {
WRMemFree( name );
name = NULL;
}
}
WSetWaitCursor( parent, FALSE );
return( name );
}
/*
* memDumpHeader - put summary information at the top of a memory dump
*/
static void memDumpHeader( int hdl, MemWndInfo *info )
{
time_t tm;
char buf[80];
unsigned len;
unsigned type_index;
char *rcstr;
#ifndef __NT__
GLOBALENTRY ge;
descriptor desc;
char access[20];
#endif
tm = time( NULL );
RCsprintf( buf, MWND_MEM_DMP_CREATED, asctime( localtime( &tm ) ), &len );
write( hdl, buf, len );
#ifndef __NT__
if( info->isdpmi ) {
rcstr = AllocRCString( MWND_DPMI_ITEM );
len = strlen( rcstr );
write( hdl, rcstr, len );
FreeRCString( rcstr );
GetADescriptor( info->sel, &desc );
RCsprintf( buf, MWND_SELECTOR, info->sel, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_BASE, GET_DESC_BASE( desc ), &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_LIMIT, GET_DESC_LIMIT( desc), &len );
write( hdl, buf, len );
if( desc.type == 2 ) {
RCsprintf( buf, MWND_TYPE_DATA, &len );
} else {
RCsprintf( buf, MWND_TYPE_CODE, &len );
}
write( hdl, buf, len );
sprintf( buf, "DPL: \t%1d\n%n", desc.dpl, &len );
write( hdl, buf, len );
if( desc.granularity ) {
RCsprintf( buf, MWND_GRANULARITY_PAGE, &len );
} else {
RCsprintf( buf, MWND_GRANULARITY_BYTE, &len );
}
write( hdl, buf, len );
createAccessString( access, &desc );
RCsprintf( buf, MWND_ACCESS, access, &len );
write( hdl, buf, len );
} else {
ge.dwSize = sizeof( GLOBALENTRY );
GlobalEntryHandle( &ge, (HGLOBAL)info->sel );
RCsprintf( buf, MWND_BLOCK_ADDR, ge.dwAddress, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_BLOCK_HDL, ge.hBlock, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_BLOCK_SIZE, ge.dwBlockSize, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_LOCK_CNT, ge.wcLock, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_PAGE_LOCK_CNT, ge.wcPageLock, &len );
write( hdl, buf, len );
}
#endif
type_index = info->disp_type - MEMINFO_BYTE;
rcstr = AllocRCString( Disp_Types[type_index] );
sprintf( buf, "%s\n\n%n", rcstr, &len );
FreeRCString( rcstr );
write( hdl, buf, len );
} /* MemDumpHeader */
bool WSaveObjectInto( WAccelEditInfo *einfo )
{
char *fname;
WGetFileStruct gf;
bool dup;
WRSaveIntoData idata;
WRFileType ftype;
bool ok;
fname = NULL;
dup = false;
ok = (einfo != NULL);
if( ok ) {
idata.next = NULL;
idata.type = WResIDFromNum( RESOURCE2INT( RT_ACCELERATOR ) );
ok = (idata.type != NULL);
}
if( ok ) {
gf.file_name = NULL;
gf.title = AllocRCString( W_SAVERESINTO );
gf.filter = AllocRCString( W_SAVERESFILTER );
WMassageFilter( gf.filter );
fname = WGetOpenFileName ( einfo->win, &gf );
if( gf.title != NULL ) {
FreeRCString( gf.title );
}
if( gf.filter != NULL ) {
FreeRCString( gf.filter );
}
ok = (fname != NULL);
}
if( ok ) {
ftype = WSelectFileType( einfo->win, fname, einfo->info->is32bit,
TRUE, WGetEditInstance(), WAccHelpRoutine );
if( ftype == WR_WIN_RC_ACCEL ) {
ok = WSaveObjectToRC( einfo, fname, FALSE, TRUE );
} else {
idata.name = einfo->info->res_name;
idata.data = einfo->info->data;
idata.lang = einfo->info->lang;
idata.size = (uint_32)einfo->info->data_size;
idata.MemFlags = einfo->info->MemFlags;
ok = WRSaveObjectInto( fname, &idata, &dup ) && !dup;
}
}
if( dup ) {
WDisplayErrorMsg( W_RESDUPNAMEINFILE );
}
if( fname != NULL ) {
WRMemFree( fname );
}
if( idata.type != NULL ) {
WRMemFree( idata.type );
}
return( ok );
}
LRESULT WINEXPORT WREMainWndProc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam )
{
HMENU menu;
LRESULT ret;
Bool pass_to_def;
WREResInfo *res_info;
WORD wp;
about_info ai;
if( WRECleanupStarted && message != WM_CLOSE ) {
if( message == WM_DESTROY ) {
PostQuitMessage( 0 );
}
return( DefFrameProc( hWnd, WREMDIWin, message, wParam, lParam ) );
}
pass_to_def = TRUE;
ret = FALSE;
res_info = WREGetCurrentRes();
menu = WREGetMenuHandle();
switch( message ) {
case WM_DESTROYCLIPBOARD:
WRForgetBitmapName();
break;
case WM_INITMENU:
if( wParam == (WPARAM)GetMenu( hWnd ) ) {
WRESetCopyMenuItem( hWnd );
WRESetPasteMenuItem( hWnd );
}
break;
case WM_MENUSELECT:
WREHandleMenuSelect( wParam, lParam );
break;
case WM_MOVE:
if( IsZoomed( hWnd ) ) {
WRESetOption( WREOptScreenMax, TRUE );
} else if( !IsIconic( hWnd ) ) {
WREUpdateScreenPosOpt();
WRESetOption( WREOptScreenMax, FALSE );
}
break;
case WM_SIZE:
if( wParam == SIZE_MAXIMIZED ) {
WRESetOption( WREOptScreenMax, TRUE );
} else if( wParam == SIZE_MINIMIZED ) {
WREHideSessions( FALSE );
WREIsMinimized = TRUE;
} else {
WREUpdateScreenPosOpt();
WRESetOption( WREOptScreenMax, FALSE );
}
if( wParam != SIZE_MINIMIZED && WREIsMinimized ) {
WREHideSessions( TRUE );
BringWindowToTop( hWnd );
WREIsMinimized = FALSE;
}
WREResizeWindows();
pass_to_def = FALSE;
break;
case ACCEL_I_HAVE_CLOSED:
WREEndEditAccelResource( (WAccelHandle)lParam );
if( WRENoInterface ) {
WRERemoveResource( res_info );
}
pass_to_def = FALSE;
break;
case ACCEL_PLEASE_SAVEME:
WRESaveEditAccelResource( (WAccelHandle)lParam );
pass_to_def = FALSE;
break;
case MENU_I_HAVE_CLOSED:
WREEndEditMenuResource( (WMenuHandle)lParam );
if( WRENoInterface ) {
WRERemoveResource( res_info );
}
pass_to_def = FALSE;
break;
case MENU_PLEASE_SAVEME:
WRESaveEditMenuResource( (WMenuHandle)lParam );
pass_to_def = FALSE;
break;
case STRING_I_HAVE_CLOSED:
WREEndEditStringResource( (WStringHandle)lParam );
if( WRENoInterface ) {
WRERemoveResource( res_info );
}
pass_to_def = FALSE;
break;
case STRING_PLEASE_SAVEME:
WRESaveEditStringResource( (WStringHandle)lParam );
pass_to_def = FALSE;
break;
case ACCEL_PLEASE_OPENME:
case MENU_PLEASE_OPENME:
case STRING_PLEASE_OPENME:
ret = pleaseOpenFile( message );
pass_to_def = FALSE;
break;
case WM_COMMAND:
wp = LOWORD( wParam );
switch( wp ) {
case IDM_OPTIONS:
pass_to_def = FALSE;
break;
case IDM_LOAD_SYMBOLS:
WRELoadResourceSymbols( res_info );
pass_to_def = FALSE;
break;
case IDM_EDIT_SYMBOLS:
WREEditResourceSymbols( res_info );
pass_to_def = FALSE;
break;
case IDM_SAVE_SYMBOLS:
WREResourceSaveSymbols( res_info );
pass_to_def = FALSE;
break;
case IDM_NEW:
WRECreateNewResource( NULL );
pass_to_def = FALSE;
break;
case IDM_OPEN:
WREOpenResource( NULL );
pass_to_def = FALSE;
break;
case IDM_SAVE:
WRESaveResource( res_info, FALSE );
pass_to_def = FALSE;
break;
case IDM_SAVEAS:
WRESaveResource( res_info, TRUE );
pass_to_def = FALSE;
break;
case IDM_DELETE:
WREDeleteCurrResource( FALSE );
pass_to_def = FALSE;
break;
case IDM_PASTE:
WREPasteResource( hWnd );
pass_to_def = FALSE;
break;
case IDM_CUT:
WREClipCurrentResource( hWnd, TRUE );
pass_to_def = FALSE;
break;
case IDM_COPY:
WREClipCurrentResource( hWnd, FALSE );
pass_to_def = FALSE;
break;
case IDM_NEW_CURSOR:
WRENewImageResource( CursorService, (uint_16)RT_GROUP_CURSOR );
break;
case IDM_NEW_BITMAP:
WRENewImageResource( BitmapService, (uint_16)RT_BITMAP );
break;
case IDM_NEW_ICON:
WRENewImageResource( IconService, (uint_16)RT_GROUP_ICON );
break;
case IDM_NEW_DIALOG:
WRENewDialogResource();
break;
case IDM_NEW_FONT:
case IDM_NEW_RCDATA:
pass_to_def = FALSE;
break;
case IDM_NEW_ACCELERATOR:
WRENewAccelResource();
pass_to_def = FALSE;
break;
case IDM_NEW_MENU:
WRENewMenuResource();
pass_to_def = FALSE;
break;
case IDM_NEW_STRING:
WRENewStringResource();
pass_to_def = FALSE;
break;
case IDM_RES_SAVEAS:
case IDM_RES_SAVE_INTO:
if( res_info != NULL ) {
if( res_info->current_type == (uint_16)RT_STRING ) {
SaveMultObjects( wp == IDM_RES_SAVE_INTO );
} else {
SaveObject( wp == IDM_RES_SAVE_INTO );
}
}
pass_to_def = FALSE;
break;
case IDM_RES_EDIT:
WREHandleResEdit();
pass_to_def = FALSE;
break;
case IDM_RES_MEM_FLAGS:
WREChangeMemFlags();
pass_to_def = FALSE;
break;
case IDM_RES_RENAME:
WRERenameResource();
pass_to_def = FALSE;
break;
case IDM_MDI_CASCADE:
case IDM_MDI_TILEV:
case IDM_MDI_TILEH:
case IDM_MDI_ARRANGE:
WREHandleMDIArrangeEvents( wp );
pass_to_def = FALSE;
break;
case IDM_EXIT:
/* clean up before we exit */
PostMessage( WREMainWin, WM_CLOSE, 0, 0 );
break;
case IDM_SHOW_RIBBON:
WREShowRibbon( menu );
pass_to_def = FALSE;
break;
case IDM_HELP:
WREHelpRoutine();
pass_to_def = FALSE;
break;
case IDM_HELP_SEARCH:
WREHelpSearchRoutine();
pass_to_def = FALSE;
break;
case IDM_HELP_ON_HELP:
WREHelpOnHelpRoutine();
pass_to_def = FALSE;
break;
case IDM_ABOUT:
ai.owner = hWnd;
ai.inst = WREInst;
ai.name = AllocRCString( WRE_ABOUT_NAME );
ai.version = banner1p2( _RESEDIT_VERSION_ );
ai.first_cr_year = AllocRCString( WRE_ABOUT_COPYRIGHT_YEAR );
ai.title = AllocRCString( WRE_ABOUT_TITLE );
DoAbout( &ai );
FreeRCString( ai.name );
FreeRCString( ai.first_cr_year );
FreeRCString( ai.title );
pass_to_def = FALSE;
break;
}
break;
case WM_DESTROY:
WWinHelp( WREMainWin, "resedt.hlp", HELP_QUIT, 0 );
PostQuitMessage( 0 );
break;
case WRE_FATAL_EXIT:
WREFatalExit = TRUE;
WREQueryKillApp( TRUE );
PostMessage( WREMainWin, WM_CLOSE, 0, 0 );
break;
case WM_ENDSESSION:
if( !wParam ) {
WREFatalExit = FALSE;
}
break;
case WM_QUERYENDSESSION:
if( ret = WREQueryKillApp( FALSE ) ) {
WREFatalExit = TRUE;
}
pass_to_def = FALSE;
break;
case WM_CLOSE:
/* clean up before we exit */
if( WRECleanupStarted ) {
pass_to_def = FALSE;
break;
}
WRECleanupStarted = TRUE;
if( !WRECleanup( WREFatalExit ) ) {
WRECleanupStarted = FALSE;
pass_to_def = FALSE;
}
}
if( pass_to_def ) {
ret = DefFrameProc( hWnd, WREMDIWin, message, wParam, lParam );
}
return( ret );
}
