void GUIDestroyWnd( gui_window *wnd )
{
HWND hwnd;
gui_window *curr;
if( wnd == NULL ) {
curr = GUIGetFront();
while( curr != NULL ) {
if( curr->flags & DOING_CLOSE ) {
curr = GUIGetNextWindow( curr );
} else if( _wpi_getparent( GUIGetParentFrameHWND( curr ) ) == HWND_DESKTOP ) {
GUIDestroyWnd( curr );
curr = GUIGetFront();
} else {
curr = GUIGetNextWindow( curr );
}
}
} else {
if ( GUIIsOpen( wnd ) ) {
/* this will make a new window be chosen as current if this
* window was current */
hwnd = GUIGetParentFrameHWND( wnd );
wnd->flags |= DOING_CLOSE;
if( NumWindows == 1 || ( _wpi_getparent( hwnd ) == HWND_DESKTOP ) &&
!( wnd->style & GUI_POPUP ) ) {
_wpi_sendmessage( hwnd, WM_CLOSE, 0, 0 );
} else {
DestroyWindow( hwnd );
}
}
}
}
void GUISetMenu( gui_window *wnd, HMENU hmenu )
{
HWND frame;
WPI_RECT rect;
gui_coord size;
int height;
#ifndef __OS2_PM__
HMENU omenu;
#endif
#ifndef __OS2_PM__
omenu = GUIGetHMENU( wnd );
#endif
frame = GUIGetParentFrameHWND( wnd );
_wpi_getclientrect( frame, &rect );
height = _wpi_getheightrect( rect );
_wpi_setmenu( frame, hmenu );
_wpi_getclientrect( frame, &rect );
if( height != ( size.y = _wpi_getheightrect( rect ) ) ) {
size.x = _wpi_getwidthrect( rect );
GUIDoResize( wnd, GUIGetParentHWND( wnd ), &size );
}
#ifndef __OS2_PM__
if( omenu != (HMENU)NULL ) {
_wpi_destroymenu( omenu );
}
#endif
}
void GUISetRestoredSize( gui_window *wnd, gui_rect *rect )
{
gui_coord pos;
gui_coord size;
gui_window *parent;
HWND frame;
HWND phwnd;
WPI_RECT new_rect;
if( GUIIsMaximized( wnd ) || GUIIsMinimized( wnd ) ) {
if( wnd->hwnd != NULLHANDLE ) {
frame = GUIGetParentFrameHWND( wnd );
parent = wnd->parent;
phwnd = HWND_DESKTOP;
if( parent ) {
phwnd = parent->hwnd;
}
GUICalcLocation( rect, &pos, &size, phwnd );
_wpi_setrectvalues( &new_rect, pos.x, pos.y, pos.x + size.x,
pos.y + size.y );
if( GUIMDIMaximized( wnd ) ) {
GUISetMDIRestoredSize( frame, &new_rect );
} else {
_wpi_setrestoredrect( frame, &new_rect );
}
}
} else {
GUIResizeWindow( wnd, rect );
}
}
bool GUIMDIMaximized( gui_window *wnd )
{
if( IsMaximized != NULL ) {
return( (*IsMaximized)( wnd ) );
}
return( _wpi_iszoomed( GUIGetParentFrameHWND( wnd ) ) );
}
void GUIRestoreWindow( gui_window *wnd )
{
if( GUIIsMDIChildWindow( wnd ) && GUIMDIMaximized( wnd ) ) {
GUIMDIMaximize( false, GUIGetFront() );
} else {
_wpi_restorewindow( GUIGetParentFrameHWND( wnd ) );
}
}
bool GUIEnableSysMenuItem( gui_window *wnd, gui_ctl_id id, bool enable )
{
HMENU hmenu;
hmenu = _wpi_getsystemmenu( GUIGetParentFrameHWND( wnd ) );
if( hmenu != (HMENU)NULL ) {
EnableItem( hmenu, id, enable );
}
return( true );
}
extern void GUIMaximizeWindow( gui_window *wnd )
{
if( wnd->style & GUI_MAXIMIZE ) {
if( GUIIsMDIChildWindow( wnd ) ) {
GUIMDIMaximize( true, GUIGetFront() );
} else {
_wpi_maximizewindow( GUIGetParentFrameHWND( wnd ) );
}
}
}
bool GUIIsMaximized( gui_window *wnd )
{
bool maximized;
if( GUIMDI ) {
maximized = GUIMDIMaximized( wnd );
} else {
maximized = _wpi_iszoomed( GUIGetParentFrameHWND( wnd ) );
}
return( maximized );
}
bool GUIIsWindowVisible( gui_window *wnd )
{
HWND hwnd;
hwnd = GUIGetParentFrameHWND( wnd );
if( hwnd != NULLHANDLE ) {
if( IsWindowVisible( hwnd ) ) {
return( true );
}
}
return( false );
}
void GUIWndDirty( gui_window *wnd )
{
gui_window *curr;
if( wnd == NULL ) {
for( curr = GUIGetFront(); curr != NULL; curr = GUIGetNextWindow( curr ) ) {
if( GUIGetParentFrameHWND( curr ) != NULLHANDLE ) {
GUIWndDirty( curr );
}
}
} else {
//GUIInvalidatePaintHandles( wnd );
_wpi_invalidaterect( wnd->hwnd, NULL, TRUE );
wnd->flags &= ~NEEDS_RESIZE_REDRAW;
_wpi_updatewindow( wnd->hwnd );
}
}
bool GUIGetRestoredSize( gui_window *wnd, gui_rect *rect )
{
HWND top_hwnd;
HWND parent;
WPI_RECT new_rect;
if( wnd->hwnd != NULLHANDLE ) {
top_hwnd = GUIGetParentFrameHWND( wnd );
parent = _wpi_getparent( top_hwnd );
_wpi_getrestoredrect( top_hwnd, &new_rect );
_wpi_mapwindowpoints( parent, HWND_DESKTOP, (WPI_LPPOINT)&new_rect, 2 );
DoGetRelRect( top_hwnd, &new_rect, rect, ( wnd->style & GUI_POPUP ) );
return( true );
}
return( false );
}
bool GUIResizeWindow( gui_window *wnd, gui_rect *rect )
{
gui_coord pos;
gui_coord size;
gui_window *parent;
HWND frame;
HWND phwnd;
HWND rphwnd;
WPI_POINT pt;
GUIInvalidatePaintHandles( wnd );
if( wnd->hwnd != NULLHANDLE ) {
frame = GUIGetParentFrameHWND( wnd );
parent = wnd->parent;
phwnd = HWND_DESKTOP;
if( parent ) {
phwnd = parent->hwnd;
}
GUICalcLocation( rect, &pos, &size, phwnd );
if( wnd->flags & IS_DIALOG ) {
// dialogs are owned by, but not children of, phwnd
// so lets map pos to its real parent
pt.x = pos.x;
pt.y = pos.y;
rphwnd = _wpi_getparent( frame );
_wpi_mapwindowpoints( phwnd, rphwnd, &pt, 1 );
_wpi_movewindow( frame, pt.x, pt.y, size.x, size.y, TRUE );
// The following is a bandaid 'till I find out why WM_SIZE's aren't
// generated for PM GUI dialogs by this fuction
#ifdef __OS2_PM__
_wpi_getclientrect( frame, &wnd->hwnd_client );
wnd->root_client = wnd->hwnd_client;
GUISetRowCol( wnd, NULL );
GUIScreenToScaleR( &size );
GUIEVENTWND( wnd, GUI_RESIZE, &size );
#endif
} else {
_wpi_setwindowpos( frame, NULLHANDLE, pos.x, pos.y, size.x, size.y,
SWP_NOACTIVATE | SWP_NOZORDER | SWP_SIZE | SWP_MOVE );
//SWP_NOREDRAW | SWP_NOACTIVATE | SWP_NOZORDER | SWP_SIZE | SWP_MOVE );
}
}
return( true );
}
bool GUISetWindowText( gui_window *wnd, const char *data )
{
_wpi_setwindowtext( GUIGetParentFrameHWND( wnd ), data );
GUIChangeMDITitle( wnd );
return( true );
}
size_t GUIGetWindowText( gui_window *wnd, char *data, size_t max_length )
{
return( _wpi_getwindowtext( GUIGetParentFrameHWND( wnd ), data, max_length ) );
}
bool GUIIsMinimized( gui_window *wnd )
{
return( _wpi_isiconic( GUIGetParentFrameHWND( wnd ) ) );
}
size_t GUIGetWindowTextLength( gui_window *wnd )
{
return( _wpi_getwindowtextlength( GUIGetParentFrameHWND( wnd ) ) );
}
WPI_MRESULT CALLBACK GUIWindowProc( HWND hwnd, WPI_MSG msg, WPI_PARAM1 wparam,
WPI_PARAM2 lparam )
{
gui_window *wnd;
gui_window *root;
WORD param;
WPI_POINT currentpoint;
gui_coord point;
gui_coord size;
WPI_MRESULT ret;
WPI_MINMAXINFO _W386FAR *info;
WPI_RECT rect;
HWND parent;
CREATESTRUCT FAR *lpcs;
wmcreate_info _W386FAR *wmcreateinfo;
gui_create_info *createinfo;
bool use_defproc;
unsigned control_id;
HWND win;
#ifndef __OS2_PM__
gui_key_state key_state;
RECT rc;
#endif
root = NULL;
ret = 0L;
use_defproc = FALSE;
if( msg == WM_CREATE ) {
lpcs = ( CREATESTRUCT FAR * )MK_FP32( (void *)lparam );
wmcreateinfo = (wmcreate_info _W386FAR *)MK_FP32( _wpi_getcreateparms( lpcs ) );
if ( wmcreateinfo != NULL ) {
wnd = wmcreateinfo->wnd;
createinfo = wmcreateinfo->info;
if( wnd->hwnd == NULLHANDLE ) {
#ifdef __OS2_PM__
if( wnd->root_frame != NULLHANDLE && wnd->root == NULLHANDLE ) {
wnd->root = hwnd;
} else {
wnd->hwnd = hwnd;
}
#else
if( _wpi_getparent( hwnd ) == HWND_DESKTOP ) {
wnd->root = hwnd;
wnd->root_frame = hwnd;
} else {
wnd->hwnd = hwnd;
wnd->hwnd_frame = hwnd;
}
#endif
}
DoSetWindowLong( hwnd, wnd );
}
}
wnd = GUIGetWindow( hwnd );
if( wnd == NULL ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
}
if( GUIMDIProcessMessage( wnd, hwnd, msg, wparam, lparam, &ret ) ) {
return( ret );
}
if( wnd->root == hwnd ) {
/* message for root window */
switch( msg ) {
case WM_CREATE :
#ifdef __OS2_PM__
wnd->root_pinfo.normal_pres =
_wpi_createos2normpres( GUIMainHInst, hwnd );
#endif
_wpi_getclientrect( wnd->root_frame, &wnd->root_client );
if( CreateBackgroundWnd( wnd, createinfo ) ) {
return( 0 );
}
return( (WPI_MRESULT)WPI_ERROR_ON_CREATE );
break;
case WM_DESTROY :
wnd->flags |= DOING_DESTROY;
GUICloseToolBar( wnd );
//ret = _wpi_defwindowproc( hwnd, msg, wparam, lparam );
//wnd->root = NULL;
//wnd->root_frame = NULL;
return( 0L );
}
} else if( ( wnd->root != NULLHANDLE ) && ( hwnd == wnd->hwnd ) ) {
/* message for container window */
switch( msg ) {
case WM_SIZE :
if( !_wpi_isiconic( _wpi_getframe( hwnd ) ) ) {
size.x = _wpi_getwmsizex( wparam, lparam );
size.y = _wpi_getwmsizey( wparam, lparam );
GUIDoResize( wnd, hwnd, &size );
}
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
break;
case WM_MOVE :
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
break;
case WM_VSCROLL :
case WM_HSCROLL :
case WM_CLOSE :
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
break;
}
}
switch( msg ) {
case WM_CREATE :
#ifdef __OS2_PM__
wnd->hwnd_pinfo.normal_pres =
_wpi_createos2normpres( GUIMainHInst, hwnd );
#endif
NumWindows++; // even if -1 is returned, window will get WM_DESTROY
win = GUIGetParentFrameHWND( wnd );
if( ( wnd->root_frame != NULLHANDLE ) ||
( createinfo->style & GUI_POPUP ) ) {
if( !GUIAddToSystemMenu( wnd, win, 0, NULL,
createinfo->style ) ) {
return( (WPI_MRESULT)WPI_ERROR_ON_CREATE );
}
} else {
if( !GUIAddToSystemMenu( wnd, win, createinfo->num_menus,
createinfo->menu, createinfo->style ) ) {
return( (WPI_MRESULT)WPI_ERROR_ON_CREATE );
}
}
_wpi_getclientrect( hwnd, &wnd->hwnd_client );
GUISetRowCol( wnd, NULL );
if( ( hwnd == wnd->hwnd ) && ( wnd->root == NULLHANDLE ) ) {
GUIMDINewWindow( hwnd );
}
if( GUIEVENTWND( wnd, GUI_INIT_WINDOW, NULL ) ) {
wnd->flags |= SENT_INIT;
GUISetScroll( wnd ); /* initalize scroll ranges */
GUIBringToFront( wnd );
return( 0 );
} else {
/* app decided not to create window */
return( (WPI_MRESULT)WPI_ERROR_ON_CREATE );
}
break;
#if defined(__NT__) || defined(WILLOWS)
case WM_CTLCOLORBTN :
case WM_CTLCOLORDLG :
//case WM_CTLCOLORLISTBOX :
case WM_CTLCOLORSTATIC :
//case WM_CTLCOLOREDIT :
ret = (WPI_MRESULT)GUICtl3dCtlColorEx( msg, wparam, lparam );
if( ret == (HBRUSH)NULL ) {
SetBkColor( (HDC)wparam, GetNearestColor( (HDC)wparam,
GUIGetBack( wnd, GUI_BACKGROUND ) ) );
ret = (WPI_MRESULT)wnd->bk_brush;
}
return( ret );
#elif !defined( __OS2_PM__ )
case WM_CTLCOLOR :
switch( HIWORD( lparam ) ) {
case CTLCOLOR_BTN :
case CTLCOLOR_DLG :
case CTLCOLOR_EDIT :
case CTLCOLOR_LISTBOX :
case CTLCOLOR_MSGBOX :
case CTLCOLOR_STATIC :
ret = (WPI_MRESULT)GUICtl3dCtlColorEx( msg, wparam, lparam );
if( ret == (HBRUSH)NULL ) {
SetBkColor( (HDC)wparam, GetNearestColor( (HDC)wparam,
GUIGetBack( wnd, GUI_BACKGROUND ) ) );
ret = (WPI_MRESULT)wnd->bk_brush;
}
break;
}
return( ret );
#endif
#ifndef __OS2_PM__
case WM_INITMENUPOPUP :
return( GUIProcessInitMenuPopup( wnd, hwnd, msg, wparam, lparam ) );
case WM_MENUSELECT :
return( GUIProcessMenuSelect( wnd, hwnd, msg, wparam, lparam ) );
#endif
case WM_GETMINMAXINFO :
info = (WPI_MINMAXINFO _W386FAR *)MK_FP32( (void *)lparam );
ret = _wpi_defwindowproc( hwnd, msg, wparam, lparam );
if( wnd->root == NULLHANDLE ) {
parent = _wpi_getparent( hwnd );
_wpi_getclientrect( parent, &rect );
_wpi_setmaxposition( *info, 0, 0 );
_wpi_setmaxtracksize( info, _wpi_getwidthrect( rect ),
_wpi_getheightrect( rect ) );
}
return( ret );
case WM_ERASEBKGND:
#ifdef __OS2_PM__
//GUIInvalidatePaintHandles( wnd );
return( (WPI_MRESULT)TRUE );
#else
if( !_wpi_isiconic( hwnd ) ) {
GetClientRect( hwnd, &rc );
FillRect( (HDC)wparam, &rc, wnd->bk_brush );
}
use_defproc = TRUE;
break;
#endif
#if !defined(__OS2_PM__) && !defined(WILLOWS)
case WM_PAINTICON :
{
HICON old;
old = SET_HICON( wnd->hwnd, wnd->icon );
ret = _wpi_defwindowproc( hwnd, msg, wparam, lparam );
SET_HICON( wnd->hwnd, old );
return( ret );
}
#endif
case WM_PAINT:
if( _wpi_isiconic( hwnd ) ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
} else {
GUIPaint( wnd, hwnd, FALSE );
}
break;
#ifndef __OS2_PM__
case WM_ACTIVATEAPP :
root = GUIGetRootWindow();
ActivateNC( root, wparam );
if( GUICurrWnd != NULL ) {
ActivateNC( GUICurrWnd, wparam );
}
use_defproc = (bool)wparam; // I'm cheating and using 'use_defproc'
// outside of its self-documented purpose
if( root ) GUIEVENTWND( root, GUI_ACTIVATEAPP, &use_defproc );
use_defproc = TRUE;
break;
#if 0
// this repaints the nc client area when the window loses focus to
// a window that is not a descendant of a GUI window
case WM_KILLFOCUS :
if( !GUIIsGUIChild( (HWND)wparam ) ) {
ActivateNC( wnd, FALSE );
}
break;
#endif
case WM_SETFOCUS :
if( !_wpi_ismsgsetfocus( msg, lparam ) ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
}
if( !EditControlHasFocus ) {
if( SetFocusToParent() ) {
return( 0L );
}
}
break;
#endif
case WM_VSCROLL :
case WM_HSCROLL :
GUIProcessScrollMsg( wnd, msg, wparam, lparam );
return( 0L );
#ifdef __NT__
case WM_MOUSEWHEEL :
{
// Try to handle mousewheel messages...
// Fake them into GUIProcessScrollMsg()
// as "normal" vertical scroll messages.
short gcWheelDelta; //wheel delta from roll
WORD wKey;
// The wnd I get is not the same as WM_VSCROLL : above gets...
// Note to self: Fix it...
// Seems like the main app window gets the message, rather than
// the MDI clients...
gcWheelDelta = HIWORD(wparam);
wKey = LOWORD(wparam);
// Scroll wheel upwards gives 120
// " " downward " -120
if( wnd != GUICurrWnd ) // Send to child window with focus
wnd = GUICurrWnd;
if( gcWheelDelta > 0 ) {
// positive - scroll up
if( wKey == MK_CONTROL || wKey == MK_SHIFT )
GUIProcessScrollMsg( wnd, WM_VSCROLL, SB_PAGEUP, 0L );
else
GUIProcessScrollMsg( wnd, WM_VSCROLL, SB_LINEUP, 0L );
} else {
// negative - scroll down
if( wKey == MK_CONTROL || wKey == MK_SHIFT )
GUIProcessScrollMsg( wnd, WM_VSCROLL, SB_PAGEDOWN, 0L );
else
GUIProcessScrollMsg( wnd, WM_VSCROLL, SB_LINEDOWN, 0L );
}
// Inform GUI system we are done with scrolling for now.
GUIProcessScrollMsg( wnd, WM_VSCROLL, SB_ENDSCROLL, 0 );
}
return( 0L );
#endif
case WM_MOVE :
use_defproc = TRUE;
if( wnd->flags & DOING_CLOSE ) {
break;
}
if( !GUIParentHasFlags( wnd, IS_MINIMIZED ) ) {
GUIEVENTWND( wnd, GUI_MOVE, NULL );
}
use_defproc = TRUE;
break;
case WM_SIZE:
use_defproc = TRUE;
if( wnd->flags & DOING_CLOSE ) {
break;
}
if( _wpi_isiconic( _wpi_getframe( hwnd ) ) ) {
wnd->flags |= IS_MINIMIZED;
if( wnd->style & GUI_CHANGEABLE_FONT ) {
GUIEnableSysMenuItem( wnd, GUI_CHANGE_FONT, FALSE );
}
GUIEVENTWND( wnd, GUI_ICONIFIED, NULL );
if( GUIMDI ) {
GUIBringNewToFront( wnd );
}
} else {
wnd->flags &= ~IS_MINIMIZED;
size.x = _wpi_getwmsizex( wparam, lparam );
size.y = _wpi_getwmsizey( wparam, lparam );
GUIDoResize( wnd, hwnd, &size );
if( wnd->flags & IS_ROOT ) {
win = GUIGetParentFrameHWND( wnd );
if( !_wpi_isiconic( win ) ) {
GUIMaximizeZoomedChildren( wnd );
}
}
}
//Call back to tell about resizing so system tray can be used
WndSizeChange( hwnd, wparam, lparam );
break;
case WM_MOUSEMOVE:
currentpoint.x = GET_WM_MOUSEMOVE_POSX( wparam, lparam );
currentpoint.y = GET_WM_MOUSEMOVE_POSY( wparam, lparam );
point.x = currentpoint.x;
point.y = currentpoint.y;
GUIScreenToScaleR( &point );
if( ( currentpoint.x != prevpoint.x ) ||
( currentpoint.y != prevpoint.y ) ) {
prevpoint.x = currentpoint.x;
prevpoint.y = currentpoint.y;
SendPointEvent( wparam, lparam, wnd, GUI_MOUSEMOVE, TRUE );
}
break;
#ifndef __OS2_PM__
case WM_NCLBUTTONDOWN :
case WM_NCMBUTTONDOWN :
case WM_NCRBUTTONDOWN :
CheckDoFront( wnd );
use_defproc = TRUE;
break;
case WM_RBUTTONDOWN:
_wpi_setcapture( hwnd );
CheckDoFront( wnd );
SendPointEvent( wparam, lparam, wnd, GUI_RBUTTONDOWN, TRUE );
break;
#else
case WM_RBUTTONDOWN :
WPI_MAKEPOINT( wparam, lparam, currentpoint );
win = PM1632WinWindowFromPoint( hwnd, ¤tpoint, FALSE );
if( ( win != (HWND)NULL) && ( win != hwnd ) ) {
control_id = _wpi_getdlgctrlid( win );
if( control_id != 0 ) {
GUIEVENTWND( wnd, GUI_CONTROL_RCLICKED, &control_id );
}
} else {
_wpi_setcapture( hwnd );
CheckDoFront( wnd );
SendPointEvent( wparam, lparam, wnd, GUI_RBUTTONDOWN, TRUE );
}
break;
#endif
case WM_LBUTTONDOWN:
_wpi_setcapture( hwnd );
CheckDoFront( wnd );
SendPointEvent( wparam, lparam, wnd, GUI_LBUTTONDOWN, TRUE );
use_defproc = TRUE;
break;
case WM_LBUTTONUP:
_wpi_releasecapture();
SendPointEvent( wparam, lparam, wnd, GUI_LBUTTONUP, TRUE );
use_defproc = TRUE;
break;
case WM_RBUTTONUP:
_wpi_releasecapture();
SendPointEvent( wparam, lparam, wnd, GUI_RBUTTONUP, TRUE );
break;
case WM_LBUTTONDBLCLK:
CheckDoFront( wnd );
SendPointEvent( wparam, lparam, wnd, GUI_LBUTTONDBLCLK, TRUE );
break;
case WM_RBUTTONDBLCLK:
CheckDoFront( wnd );
SendPointEvent( wparam, lparam, wnd, GUI_RBUTTONDBLCLK, TRUE );
break;
case WM_SYSCOMMAND:
param = _wpi_getid( wparam );
switch( param ) {
case SC_NEXTWINDOW :
if( GUIMDI ) {
NextWndToFront( hwnd );
return( 0L );
}
default :
if( ( param & 0xf000 ) == ( SC_NEXTWINDOW & 0xf000 ) ) {
/* top value same for all SC_* values */
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
} else {
ProcessMenu( wnd, param );
}
break;
}
break;
#ifdef __OS2_PM__
case WM_CONTROL :
GUIProcessControlNotification( SHORT1FROMMP(wparam),
SHORT2FROMMP(wparam), wnd );
break;
#else
case WM_PARENTNOTIFY:
if( ( LOWORD(wparam) == WM_RBUTTONDOWN ) ||
( LOWORD(wparam) == WM_LBUTTONDOWN ) ||
( LOWORD(wparam) == WM_MBUTTONDOWN ) ) {
if( wnd->root == NULLHANDLE ) {
CheckDoFront( wnd );
}
}
if( LOWORD(wparam) == WM_RBUTTONDOWN ) {
WPI_MAKEPOINT( wparam, lparam, currentpoint );
MapWindowPoints( hwnd, (HWND)NULL, ¤tpoint, 1 );
win = _wpi_windowfrompoint( currentpoint );
control_id = _wpi_getdlgctrlid( win );
if( control_id != 0 ) {
if( _wpi_getparent(win) == hwnd ) {
GUIEVENTWND( wnd, GUI_CONTROL_RCLICKED, &control_id );
}
}
}
break;
case WM_ENDSESSION : {
gui_end_session es;
es.endsession = (bool)wparam;
es.logoff = (bool)( lparam == 0x80000000L );
GUIEVENTWND( wnd, GUI_ENDSESSION, &es );
return( 0L );
}
case WM_QUERYENDSESSION : {
gui_end_session es;
es.endsession = (bool)wparam;
es.logoff = (bool)( lparam == 0x80000000L ); // ENDSESSION_LOGOFF
if( !GUIEVENTWND( wnd, GUI_QUERYENDSESSION, &es ) ) {
return( TRUE );
}
return( 0L );
}
#endif
case WM_COMMAND:
if( _wpi_ismenucommand( wparam, lparam ) ||
IsToolBarCommand( wnd, wparam, lparam ) ) { /* from menu or toolbar */
ProcessMenu( wnd, _wpi_getid( wparam ) );
//SetFocusToParent();
} else {
GUIProcessControlMsg( wparam, lparam, wnd, NULL );
}
use_defproc = TRUE;
break;
#ifndef __OS2_PM__
case WM_VKEYTOITEM :
use_defproc = FALSE;
ret = -1;
GUIGetKeyState( &key_state.state );
if( ( GUIWindowsMapKey( wparam, lparam, &key_state.key ) ) ) {
ret = GUIEVENTWND( wnd, GUI_KEYTOITEM, &key_state );
}
break;
#endif
#ifdef __OS2_PM__
case WM_CHAR :
case WM_TRANSLATEACCEL :
#else
case WM_MENUCHAR :
case WM_SYSKEYDOWN :
case WM_SYSKEYUP :
case WM_KEYUP :
case WM_KEYDOWN :
#endif
return( GUIProcesskey( hwnd, msg, wparam, lparam ) );
case WM_CLOSE :
if( wnd->flags & DOING_CLOSE ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
} else if( wnd->style & GUI_CLOSEABLE ) {
if( GUIEVENTWND( wnd, GUI_CLOSE, NULL ) ) {
wnd->flags |= DOING_CLOSE;
if( wnd->flags & IS_ROOT ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
} else {
_wpi_destroywindow( wnd->hwnd_frame );
}
}
}
return( 0L );
// Message to deal with tray icons (Win 95 and NT 4.0 ).
case WM_TRAYCALLBACK :
TrayCallBack( hwnd, wparam, lparam );
return( 0L );
case WM_DESTROY :
wnd->flags |= DOING_DESTROY;
NumWindows--;
GUIEVENTWND( wnd, GUI_DESTROY, NULL );
//ret = _wpi_defwindowproc( hwnd, msg, wparam, lparam );
GUIDestroyAllChildren( wnd );
if( wnd->flags & IS_ROOT ) {
GUIDestroyAllPopupsWithNoParent();
}
GUIFreeWindowMemory( wnd, FALSE, FALSE );
if( NumWindows == 0 ) {
_wpi_postquitmessage( 0 );
Posted = TRUE;
}
return( 0L );
default:
use_defproc = TRUE;
}
if( use_defproc ) {
return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
} else {
return( ret );
}
}
int GUIGetFileName( gui_window *wnd, open_file_name *ofn )
{
OPENFILENAME wofn;
bool issave;
int rc;
unsigned drive;
#if defined(HAVE_DRIVES)
unsigned old_drive;
unsigned drives;
#endif
LastPath = NULL;
if( ofn->initial_dir != NULL && ofn->initial_dir[0] != '\0' && ofn->initial_dir[1] == ':' ) {
drive = ofn->initial_dir[0];
memmove( ofn->initial_dir, ofn->initial_dir+2, strlen( ofn->initial_dir+2 ) + 1 );
} else {
drive = 0;
}
memset( &wofn, 0 , sizeof( wofn ) );
if( ofn->flags & OFN_ISSAVE ) {
issave = true;
} else {
issave = false;
}
wofn.Flags = 0;
if( hookFileDlg ) {
wofn.Flags |= OFN_ENABLEHOOK;
}
if( !(ofn->flags & OFN_CHANGEDIR) ) {
wofn.Flags |= OFN_NOCHANGEDIR;
}
if( ofn->flags & OFN_OVERWRITEPROMPT ) {
wofn.Flags |= OFN_OVERWRITEPROMPT;
}
if( ofn->flags & OFN_HIDEREADONLY ) {
wofn.Flags |= OFN_HIDEREADONLY;
}
if( ofn->flags & OFN_FILEMUSTEXIST ) {
wofn.Flags |= OFN_FILEMUSTEXIST;
}
if( ofn->flags & OFN_PATHMUSTEXIST ) {
wofn.Flags |= OFN_PATHMUSTEXIST;
}
if( ofn->flags & OFN_ALLOWMULTISELECT ) {
wofn.Flags |= OFN_ALLOWMULTISELECT;
}
wofn.hwndOwner = GUIGetParentFrameHWND( wnd );
wofn.hInstance = GUIMainHInst;
wofn.lStructSize = sizeof( wofn );
wofn.lpstrFilter = ofn->filter_list;
wofn.nFilterIndex = ofn->filter_index;
wofn.lpstrFile = ofn->file_name;
wofn.nMaxFile = ofn->max_file_name;
wofn.lpstrFileTitle = ofn->base_file_name;
wofn.nMaxFileTitle = ofn->max_base_file_name;
wofn.lpstrTitle = ofn->title;
wofn.lpstrInitialDir = ofn->initial_dir;
wofn.lpfnHook = (LPOFNHOOKPROC)NULL;
if( hookFileDlg ) {
wofn.lpfnHook = (LPOFNHOOKPROC)MakeOpenFileHookProcInstance( OpenHook, GUIMainHInst );
}
#if defined( HAVE_DRIVES )
if( drive ) {
_dos_getdrive( &old_drive );
_dos_setdrive( tolower( drive ) - 'a' + 1, &drives );
}
#endif
if( issave ) {
rc = GetSaveFileName( &wofn );
} else {
rc = GetOpenFileName( &wofn );
}
if( hookFileDlg ) {
(void)FreeProcInstance( (FARPROC)wofn.lpfnHook );
}
if( LastPath && ( !rc || !( ofn->flags & OFN_WANT_LAST_PATH ) ) ) {
GUIMemFree( LastPath );
LastPath = NULL;
}
ofn->last_path = LastPath;
#if defined( HAVE_DRIVES )
if( drive ) {
_dos_setdrive( old_drive, &drives );
}
#endif
if( rc ) {
return( OFN_RC_FILE_SELECTED );
}
if( !CommDlgExtendedError() ) {
return( OFN_RC_NO_FILE_SELECTED );
}
return( OFN_RC_FAILED_TO_INITIALIZE );
} /* _GUIGetFileName */
void GUIMinimizeWindow( gui_window *wnd )
{
if( wnd->style & GUI_MINIMIZE ) {
_wpi_minimizewindow( GUIGetParentFrameHWND( wnd ) );
}
}
int GUIGetFileName( gui_window *wnd, open_file_name *ofn )
{
#ifdef _M_I86
wnd = wnd;
ofn = ofn;
#else
FILEDLG fdlg;
int str_index;
int rc;
ULONG i;
ULONG slen, flen;
unsigned drive;
unsigned old_drive;
unsigned drives;
char initial_path[_MAX_PATH];
char old_path[_MAX_PATH];
char fname[_MAX_FNAME + _MAX_EXT];
char *cwd;
old_path[0] = '\0';
fname[0] = '\0';
cwd = getcwd( initial_path, _MAX_PATH );
if( cwd ) {
_splitpath( cwd, NULL, old_path, NULL, NULL );
}
drive = 0;
initial_path[0] = '\0';
if( ofn->initial_dir != NULL && ofn->initial_dir[0] != '\0' ) {
if( ofn->initial_dir[1] == ':' ) {
drive = ofn->initial_dir[0];
}
_splitpath( ofn->initial_dir, NULL, initial_path, NULL, NULL );
}
memset( &fdlg, 0 , sizeof( fdlg ) );
fdlg.cbSize = sizeof( fdlg );
fdlg.fl = FDS_CENTER | FDS_ENABLEFILELB;
if( ofn->flags & OFN_ISSAVE ) {
fdlg.fl |= FDS_SAVEAS_DIALOG;
fdlg.pszOKButton = (PSZ)LIT( FDlg_Save_Text );
} else {
fdlg.fl |= FDS_OPEN_DIALOG;
fdlg.pszOKButton = (PSZ)LIT( FDlg_Open_Text );
}
if( ofn->flags & OFN_ALLOWMULTISELECT ) {
fdlg.fl |= FDS_MULTIPLESEL;
}
fdlg.pszTitle = ofn->title;
if( ofn->file_name ) {
strncpy( fdlg.szFullFile, ofn->file_name, CCHMAXPATH );
fdlg.szFullFile[CCHMAXPATH-1] = '\0';
}
if( ( !ofn->file_name || !*ofn->file_name ) && ofn->filter_index >= 0 ) {
str_index = 0;
for( i=0; ;i++ ) {
if( ofn->filter_list[i] == '\0' ) {
if( ofn->filter_list[i+1] == '\0' ) {
break;
}
str_index++;
if( str_index == ofn->filter_index * 2 - 1 ) {
i++;
break;
}
}
}
if( ofn->filter_list[i] != '\0' ) {
strncpy( fdlg.szFullFile, ofn->filter_list + i, CCHMAXPATH );
fdlg.szFullFile[CCHMAXPATH-1] = '\0';
}
}
#if defined( HAVE_DRIVES )
if( drive ) {
_dos_getdrive( &old_drive );
_dos_setdrive( tolower( drive ) - 'a' + 1, &drives );
if( *initial_path && *old_path ) {
chdir( initial_path );
}
}
#endif
rc = (int)WinFileDlg( HWND_DESKTOP, GUIGetParentFrameHWND( wnd ), &fdlg );
if( fdlg.papszFQFilename ) {
ofn->file_name[0] = '\0';
slen = 0;
for( i=0; i<fdlg.ulFQFCount; i++ ) {
flen = strlen( fdlg.papszFQFilename[0][i] );
if( ( slen + flen + 2 ) > ofn->max_file_name ) {
return( OFN_RC_FAILED_TO_INITIALIZE );
}
if( slen ) {
ofn->file_name[slen++] = ' ';
}
memcpy( &ofn->file_name[slen], fdlg.papszFQFilename[0][i], flen + 1);
slen += flen;
}
WinFreeFileDlgList( fdlg.papszFQFilename );
if( ofn->base_file_name != NULL ) {
ofn->base_file_name[0] = '\0';
}
} else {
if( strlen( fdlg.szFullFile ) > ( ofn->max_file_name - 1 ) ) {
return( OFN_RC_FAILED_TO_INITIALIZE );
} else {
strcpy( ofn->file_name, fdlg.szFullFile );
_splitpath( fdlg.szFullFile, NULL, NULL, fname, NULL );
_splitpath( fdlg.szFullFile, NULL, NULL, NULL, fname+strlen(fname) );
}
if( ofn->base_file_name != NULL ) {
ofn->base_file_name[0] = '\0';
if( strlen( fname ) <= ofn->max_base_file_name ) {
strcpy( ofn->base_file_name, fname );
}
}
}
#if defined( HAVE_DRIVES )
if( drive ) {
_dos_setdrive( old_drive, &drives );
if( *initial_path && *old_path ) {
chdir( old_path );
}
}
#endif
if( fdlg.lReturn == DID_CANCEL ) {
return( OFN_RC_NO_FILE_SELECTED );
}
if( rc ) {
return( OFN_RC_FILE_SELECTED );
}
#endif
return( OFN_RC_FAILED_TO_INITIALIZE );
} /* GUIGetFileName */
void GUIHideWindow( gui_window *wnd )
{
_wpi_showwindow( GUIGetParentFrameHWND( wnd ), SW_HIDE );
}