src/os2/frame.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        frame.cpp
   3 // Purpose:     wxFrame
   4 // Author:      David Webster
   5 // Modified by:
   6 // Created:     10/27/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) David Webster
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifndef WX_PRECOMP
  16     #include "wx/defs.h"
  17     #include "wx/object.h"
  18     #include "wx/dynarray.h"
  19     #include "wx/list.h"
  20     #include "wx/hash.h"
  21     #include "wx/string.h"
  22     #include "wx/intl.h"
  23     #include "wx/log.h"
  24     #include "wx/event.h"
  25     #include "wx/setup.h"
  26     #include "wx/frame.h"
  27     #include "wx/menu.h"
  28     #include "wx/app.h"
  29     #include "wx/utils.h"
  30     #include "wx/dialog.h"
  31     #include "wx/settings.h"
  32     #include "wx/dcclient.h"
  33     #include "wx/mdi.h"
  34 #endif // WX_PRECOMP
  35
  36 #include "wx/os2/private.h"
  37
  38 #if wxUSE_STATUSBAR
  39     #include "wx/statusbr.h"
  40     #include "wx/generic/statusbr.h"
  41 #endif // wxUSE_STATUSBAR
  42
  43 #if wxUSE_TOOLBAR
  44     #include "wx/toolbar.h"
  45 #endif // wxUSE_TOOLBAR
  46
  47 #include "wx/menuitem.h"
  48 #include "wx/log.h"
  49
  50 // ----------------------------------------------------------------------------
  51 // globals
  52 // ----------------------------------------------------------------------------
  53
  54 extern wxWindowList wxModelessWindows;
  55 extern wxList WXDLLEXPORT wxPendingDelete;
  56
  57 #if wxUSE_MENUS_NATIVE
  58 extern wxMenu *wxCurrentPopupMenu;
  59 #endif
  60
  61 extern void  wxAssociateWinWithHandle( HWND         hWnd
  62                                       ,wxWindowOS2* pWin
  63                                      );
  64
  65 // ----------------------------------------------------------------------------
  66 // event tables
  67 // ----------------------------------------------------------------------------
  68
  69 BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
  70     EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
  71 END_EVENT_TABLE()
  72
  73 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
  74
  75 // ============================================================================
  76 // implementation
  77 // ============================================================================
  78
  79 // ----------------------------------------------------------------------------
  80 // static class members
  81 // ----------------------------------------------------------------------------
  82 #if wxUSE_STATUSBAR
  83
  84 #if wxUSE_NATIVE_STATUSBAR
  85     bool wxFrame::m_bUseNativeStatusBar = TRUE;
  86 #else
  87     bool wxFrame::m_bUseNativeStatusBar = FALSE;
  88 #endif
  89
  90 #endif //wxUSE_STATUSBAR
  91
  92 // ----------------------------------------------------------------------------
  93 // creation/destruction
  94 // ----------------------------------------------------------------------------
  95
  96 void wxFrame::Init()
  97 {
  98     m_nFsStatusBarFields = 0;
  99     m_nFsStatusBarHeight = 0;
 100     m_nFsToolBarHeight   = 0;
 101     m_hWndToolTip        = 0L;
 102     m_bWasMinimized      = FALSE;
 103
 104
 105     m_frameMenuBar   = NULL;
 106     m_frameToolBar   = NULL;
 107     m_frameStatusBar = NULL;
 108
 109     m_hTitleBar = NULLHANDLE;
 110     m_hHScroll  = NULLHANDLE;
 111     m_hVScroll  = NULLHANDLE;
 112
 113     //
 114     // Initialize SWP's
 115     //
 116     memset(&m_vSwpTitleBar, 0, sizeof(SWP));
 117     memset(&m_vSwpMenuBar, 0, sizeof(SWP));
 118     memset(&m_vSwpHScroll, 0, sizeof(SWP));
 119     memset(&m_vSwpVScroll, 0, sizeof(SWP));
 120     memset(&m_vSwpStatusBar, 0, sizeof(SWP));
 121     memset(&m_vSwpToolBar, 0, sizeof(SWP));
 122     m_bIconized = FALSE;
 123
 124 } // end of wxFrame::Init
 125
 126 bool wxFrame::Create(
 127   wxWindow*                         pParent
 128 , wxWindowID                        vId
 129 , const wxString&                   rsTitle
 130 , const wxPoint&                    rPos
 131 , const wxSize&                     rSize
 132 , long                              lStyle
 133 , const wxString&                   rsName
 134 )
 135 {
 136     if (!wxTopLevelWindow::Create( pParent
 137                                   ,vId
 138                                   ,rsTitle
 139                                   ,rPos
 140                                   ,rSize
 141                                   ,lStyle
 142                                   ,rsName
 143                                  ))
 144         return FALSE;
 145     wxModelessWindows.Append(this);
 146     return TRUE;
 147 } // end of wxFrame::Create
 148
 149 wxFrame::~wxFrame()
 150 {
 151     m_isBeingDeleted = TRUE;
 152     DeleteAllBars();
 153 } // end of wxFrame::~wxFrame
 154
 155 //
 156 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
 157 //
 158 void wxFrame::DoGetClientSize(
 159   int*                              pX
 160 , int*                              pY
 161 ) const
 162 {
 163     wxTopLevelWindow::DoGetClientSize( pX
 164                                       ,pY
 165                                      );
 166     //
 167     // No need to use statusbar code as in WIN32 as the FORMATFRAME
 168     // window procedure ensures PM knows about the new frame client
 169     // size internally.  A ::WinQueryWindowRect (that is called in
 170     // wxWindow's GetClient size from above) is all that is needed!
 171     //
 172 } // end of wxFrame::DoGetClientSize
 173
 174 //
 175 // Set the client size (i.e. leave the calculation of borders etc.
 176 // to wxWindows)
 177 //
 178 void wxFrame::DoSetClientSize(
 179   int                               nWidth
 180 , int                               nHeight
 181 )
 182 {
 183     //
 184     // Statusbars are not part of the OS/2 Client but parent frame
 185     // so no statusbar consideration
 186     //
 187     wxTopLevelWindow::DoSetClientSize( nWidth
 188                                       ,nHeight
 189                                      );
 190 } // end of wxFrame::DoSetClientSize
 191
 192 // ----------------------------------------------------------------------------
 193 // wxFrame: various geometry-related functions
 194 // ----------------------------------------------------------------------------
 195
 196 void wxFrame::Raise()
 197 {
 198     wxFrameBase::Raise();
 199     ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
 200                       ,HWND_TOP
 201                       ,0
 202                       ,0
 203                       ,0
 204                       ,0
 205                       ,SWP_ZORDER
 206                      );
 207 }
 208
 209 #if wxUSE_STATUSBAR
 210 wxStatusBar* wxFrame::OnCreateStatusBar(
 211   int                               nNumber
 212 , long                              lulStyle
 213 , wxWindowID                        vId
 214 , const wxString&                   rName
 215 )
 216 {
 217     wxStatusBar*                    pStatusBar = NULL;
 218     wxString                        sError;
 219
 220     pStatusBar = wxFrameBase::OnCreateStatusBar( nNumber
 221                                                 ,lulStyle
 222                                                 ,vId
 223                                                 ,rName
 224                                                  );
 225
 226     if( !pStatusBar )
 227         return NULL;
 228
 229     wxClientDC                      vDC(pStatusBar);
 230     int                             nY;
 231
 232     //
 233     // Set the height according to the font and the border size
 234     //
 235     vDC.SetFont(pStatusBar->GetFont()); // Screws up the menues for some reason
 236     vDC.GetTextExtent( "X"
 237                       ,NULL
 238                       ,&nY
 239                      );
 240
 241     int                             nHeight = ((11 * nY) / 10 + 2 * pStatusBar->GetBorderY());
 242
 243     pStatusBar->SetSize( -1
 244                         ,-1
 245                         ,-1
 246                         ,nHeight
 247                        );
 248
 249     ::WinSetParent( pStatusBar->GetHWND()
 250                    ,m_hFrame
 251                    ,FALSE
 252                   );
 253     ::WinSetOwner( pStatusBar->GetHWND()
 254                   ,m_hFrame
 255                  );
 256     //
 257     // to show statusbar
 258     //
 259     if(::WinIsWindowShowing(m_hFrame))
 260         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
 261
 262     return pStatusBar;
 263 } // end of wxFrame::OnCreateStatusBar
 264
 265 void wxFrame::PositionStatusBar()
 266 {
 267     SWP                             vSwp;
 268     ERRORID                         vError;
 269     wxString                        sError;
 270
 271     //
 272     // Native status bar positions itself
 273     //
 274     if (m_frameStatusBar)
 275     {
 276         int                         nWidth;
 277         int                         nY;
 278         int                         nStatbarWidth;
 279         int                         nStatbarHeight;
 280         RECTL                       vRect;
 281         RECTL                       vFRect;
 282
 283         ::WinQueryWindowRect(m_hFrame, &vRect);
 284         nY = vRect.yTop;
 285         ::WinMapWindowPoints(m_hFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2);
 286         vFRect = vRect;
 287         ::WinCalcFrameRect(m_hFrame, &vRect, TRUE);
 288         nWidth = vRect.xRight - vRect.xLeft;
 289         nY = nY - (vRect.yBottom - vFRect.yBottom);
 290
 291         m_frameStatusBar->GetSize( &nStatbarWidth
 292                                   ,&nStatbarHeight
 293                                  );
 294
 295         nY= nY - nStatbarHeight;
 296         //
 297         // Since we wish the status bar to be directly under the client area,
 298         // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
 299         //
 300         m_frameStatusBar->SetSize( vRect.xLeft - vFRect.xLeft
 301                                   ,nY
 302                                   ,nWidth
 303                                   ,nStatbarHeight
 304                                  );
 305         if (!::WinQueryWindowPos(m_frameStatusBar->GetHWND(), &vSwp))
 306         {
 307             vError = ::WinGetLastError(vHabmain);
 308             sError = wxPMErrorToStr(vError);
 309             wxLogError("Error setting parent for StautsBar. Error: %s\n", sError.c_str());
 310             return;
 311         }
 312     }
 313 } // end of wxFrame::PositionStatusBar
 314 #endif // wxUSE_STATUSBAR
 315
 316 #if wxUSE_TOOLBAR
 317 wxToolBar* wxFrame::OnCreateToolBar(
 318   long                              lStyle
 319 , wxWindowID                        vId
 320 , const wxString&                   rsName
 321 )
 322 {
 323     wxToolBar*                      pToolBar = wxFrameBase::OnCreateToolBar( lStyle
 324                                                                             ,vId
 325                                                                             ,rsName
 326                                                                            );
 327
 328     ::WinSetParent( pToolBar->GetHWND()
 329                    ,m_hFrame
 330                    ,FALSE
 331                   );
 332     ::WinSetOwner( pToolBar->GetHWND()
 333                   ,m_hFrame
 334                  );
 335     return pToolBar;
 336 } // end of WinGuiBase_CFrame::OnCreateToolBar
 337 #endif
 338
 339 #if wxUSE_MENUS_NATIVE
 340 void wxFrame::DetachMenuBar()
 341 {
 342     if (m_frameMenuBar)
 343     {
 344         m_frameMenuBar->Detach();
 345         m_frameMenuBar = NULL;
 346     }
 347 } // end of wxFrame::DetachMenuBar
 348
 349 void wxFrame::SetMenuBar(
 350   wxMenuBar*                        pMenuBar
 351 )
 352 {
 353     wxString                        sError;
 354
 355     if (!pMenuBar)
 356     {
 357         DetachMenuBar();
 358
 359         //
 360         // Actually remove the menu from the frame
 361         //
 362         m_hMenu = (WXHMENU)0;
 363         InternalSetMenuBar();
 364     }
 365     else // set new non NULL menu bar
 366     {
 367         m_frameMenuBar = NULL;
 368
 369         //
 370         // Can set a menubar several times.
 371         // TODO: how to prevent a memory leak if you have a currently-unattached
 372         // menubar? wxWindows assumes that the frame will delete the menu (otherwise
 373         // there are problems for MDI).
 374         //
 375         if (pMenuBar->GetHMenu())
 376         {
 377             m_hMenu = pMenuBar->GetHMenu();
 378         }
 379         else
 380         {
 381             pMenuBar->Detach();
 382             m_hMenu = pMenuBar->Create();
 383             if (!m_hMenu)
 384                 return;
 385         }
 386         InternalSetMenuBar();
 387         m_frameMenuBar = pMenuBar;
 388         pMenuBar->Attach((wxFrame*)this);
 389     }
 390 } // end of wxFrame::SetMenuBar
 391
 392 void wxFrame::AttachMenuBar(
 393   wxMenuBar*                        pMenubar
 394 )
 395 {
 396     wxFrameBase::AttachMenuBar(pMenubar);
 397
 398     m_frameMenuBar = pMenubar;
 399
 400     if (!pMenubar)
 401     {
 402         //
 403         // Actually remove the menu from the frame
 404         //
 405         m_hMenu = (WXHMENU)0;
 406         InternalSetMenuBar();
 407     }
 408     else // Set new non NULL menu bar
 409     {
 410         //
 411         // Can set a menubar several times.
 412         //
 413         if (pMenubar->GetHMenu())
 414         {
 415             m_hMenu = pMenubar->GetHMenu();
 416         }
 417         else
 418         {
 419             if (pMenubar->IsAttached())
 420                 pMenubar->Detach();
 421
 422             m_hMenu = pMenubar->Create();
 423
 424             if (!m_hMenu)
 425                 return;
 426         }
 427         InternalSetMenuBar();
 428     }
 429 } // end of wxFrame::AttachMenuBar
 430
 431 void wxFrame::InternalSetMenuBar()
 432 {
 433     ERRORID                         vError;
 434     wxString                        sError;
 435     //
 436     // Set the parent and owner of the menubar to be the frame
 437     //
 438     if (!::WinSetParent(m_hMenu, m_hFrame, FALSE))
 439     {
 440         vError = ::WinGetLastError(vHabmain);
 441         sError = wxPMErrorToStr(vError);
 442         wxLogError("Error setting parent for submenu. Error: %s\n", sError.c_str());
 443     }
 444
 445     if (!::WinSetOwner(m_hMenu, m_hFrame))
 446     {
 447         vError = ::WinGetLastError(vHabmain);
 448         sError = wxPMErrorToStr(vError);
 449         wxLogError("Error setting parent for submenu. Error: %s\n", sError.c_str());
 450     }
 451     ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
 452 } // end of wxFrame::InternalSetMenuBar
 453 #endif // wxUSE_MENUS_NATIVE
 454
 455 //
 456 // Responds to colour changes, and passes event on to children
 457 //
 458 void wxFrame::OnSysColourChanged(
 459   wxSysColourChangedEvent&          rEvent
 460 )
 461 {
 462     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE));
 463     Refresh();
 464
 465 #if wxUSE_STATUSBAR
 466     if (m_frameStatusBar)
 467     {
 468         wxSysColourChangedEvent     vEvent2;
 469
 470         vEvent2.SetEventObject(m_frameStatusBar);
 471         m_frameStatusBar->GetEventHandler()->ProcessEvent(vEvent2);
 472     }
 473 #endif //wxUSE_STATUSBAR
 474
 475     //
 476     // Propagate the event to the non-top-level children
 477     //
 478     wxWindow::OnSysColourChanged(rEvent);
 479 } // end of wxFrame::OnSysColourChanged
 480
 481 // Pass TRUE to show full screen, FALSE to restore.
 482 bool wxFrame::ShowFullScreen(
 483   bool                              bShow
 484 , long                              lStyle
 485 )
 486 {
 487     if (bShow)
 488     {
 489         if (IsFullScreen())
 490             return FALSE;
 491
 492         m_bFsIsShowing = TRUE;
 493         m_lFsStyle = lStyle;
 494
 495 #if wxUSE_TOOLBAR
 496         wxToolBar*                  pTheToolBar = GetToolBar();
 497 #endif //wxUSE_TOOLBAR
 498
 499 #if wxUSE_STATUSBAR
 500         wxStatusBar*                pTheStatusBar = GetStatusBar();
 501 #endif //wxUSE_STATUSBAR
 502
 503         int                         nDummyWidth;
 504
 505 #if wxUSE_TOOLBAR
 506         if (pTheToolBar)
 507             pTheToolBar->GetSize(&nDummyWidth, &m_nFsToolBarHeight);
 508 #endif //wxUSE_TOOLBAR
 509
 510 #if wxUSE_STATUSBAR
 511         if (pTheStatusBar)
 512             pTheStatusBar->GetSize(&nDummyWidth, &m_nFsStatusBarHeight);
 513 #endif //wxUSE_STATUSBAR
 514
 515 #if wxUSE_TOOLBAR
 516         //
 517         // Zap the toolbar, menubar, and statusbar
 518         //
 519         if ((lStyle & wxFULLSCREEN_NOTOOLBAR) && pTheToolBar)
 520         {
 521             pTheToolBar->SetSize(-1,0);
 522             pTheToolBar->Show(FALSE);
 523         }
 524 #endif //wxUSE_TOOLBAR
 525
 526         if (lStyle & wxFULLSCREEN_NOMENUBAR)
 527         {
 528             ::WinSetParent(m_hMenu, m_hFrame, FALSE);
 529             ::WinSetOwner(m_hMenu, m_hFrame);
 530             ::WinSendMsg((HWND)m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
 531         }
 532
 533 #if wxUSE_STATUSBAR
 534         //
 535         // Save the number of fields in the statusbar
 536         //
 537         if ((lStyle & wxFULLSCREEN_NOSTATUSBAR) && pTheStatusBar)
 538         {
 539             m_nFsStatusBarFields = pTheStatusBar->GetFieldsCount();
 540             SetStatusBar((wxStatusBar*) NULL);
 541             delete pTheStatusBar;
 542         }
 543         else
 544             m_nFsStatusBarFields = 0;
 545 #endif //wxUSE_STATUSBAR
 546
 547         //
 548         // Zap the frame borders
 549         //
 550
 551         //
 552         // Save the 'normal' window style
 553         //
 554         m_lFsOldWindowStyle = ::WinQueryWindowULong(m_hFrame, QWL_STYLE);
 555
 556         //
 557         // Save the old position, width & height, maximize state
 558         //
 559         m_vFsOldSize = GetRect();
 560         m_bFsIsMaximized = IsMaximized();
 561
 562         //
 563         // Decide which window style flags to turn off
 564         //
 565         LONG                        lNewStyle = m_lFsOldWindowStyle;
 566         LONG                        lOffFlags = 0;
 567
 568         if (lStyle & wxFULLSCREEN_NOBORDER)
 569             lOffFlags |= FCF_BORDER;
 570         if (lStyle & wxFULLSCREEN_NOCAPTION)
 571             lOffFlags |= (FCF_TASKLIST | FCF_SYSMENU);
 572
 573         lNewStyle &= (~lOffFlags);
 574
 575         //
 576         // Change our window style to be compatible with full-screen mode
 577         //
 578         ::WinSetWindowULong((HWND)m_hFrame, QWL_STYLE, (ULONG)lNewStyle);
 579
 580         //
 581         // Resize to the size of the desktop
 582         int                         nWidth;
 583         int                         nHeight;
 584
 585         RECTL                       vRect;
 586
 587         ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
 588         nWidth = vRect.xRight - vRect.xLeft;
 589         //
 590         // Rmember OS/2 is backwards!
 591         //
 592         nHeight = vRect.yTop - vRect.yBottom;
 593
 594         SetSize( nWidth
 595                 ,nHeight
 596                );
 597
 598         //
 599         // Now flush the window style cache and actually go full-screen
 600         //
 601         ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
 602                           ,HWND_TOP
 603                           ,0
 604                           ,0
 605                           ,nWidth
 606                           ,nHeight
 607                           ,SWP_SIZE | SWP_SHOW
 608                          );
 609
 610         wxSizeEvent                 vEvent( wxSize( nWidth
 611                                                    ,nHeight
 612                                                   )
 613                                            ,GetId()
 614                                           );
 615
 616         GetEventHandler()->ProcessEvent(vEvent);
 617         return TRUE;
 618     }
 619     else
 620     {
 621         if (!IsFullScreen())
 622             return FALSE;
 623
 624         m_bFsIsShowing = FALSE;
 625
 626 #if wxUSE_TOOLBAR
 627         wxToolBar*                  pTheToolBar = GetToolBar();
 628
 629         //
 630         // Restore the toolbar, menubar, and statusbar
 631         //
 632         if (pTheToolBar && (m_lFsStyle & wxFULLSCREEN_NOTOOLBAR))
 633         {
 634             pTheToolBar->SetSize(-1, m_nFsToolBarHeight);
 635             pTheToolBar->Show(TRUE);
 636         }
 637 #endif //wxUSE_TOOLBAR
 638
 639 #if wxUSE_STATUSBAR
 640         if ((m_lFsStyle & wxFULLSCREEN_NOSTATUSBAR) && (m_nFsStatusBarFields > 0))
 641         {
 642             CreateStatusBar(m_nFsStatusBarFields);
 643 //          PositionStatusBar();
 644         }
 645 #endif //wxUSE_STATUSBAR
 646
 647         if ((m_lFsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
 648         {
 649             ::WinSetParent(m_hMenu, m_hFrame, FALSE);
 650             ::WinSetOwner(m_hMenu, m_hFrame);
 651             ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
 652         }
 653         Maximize(m_bFsIsMaximized);
 654
 655         ::WinSetWindowULong( m_hFrame
 656                             ,QWL_STYLE
 657                             ,(ULONG)m_lFsOldWindowStyle
 658                            );
 659         ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
 660                           ,HWND_TOP
 661                           ,m_vFsOldSize.x
 662                           ,m_vFsOldSize.y
 663                           ,m_vFsOldSize.width
 664                           ,m_vFsOldSize.height
 665                           ,SWP_SIZE | SWP_SHOW
 666                          );
 667     }
 668     return wxFrameBase::ShowFullScreen(bShow, lStyle);
 669 } // end of wxFrame::ShowFullScreen
 670
 671 //
 672 // Frame window
 673 //
 674 // ----------------------------------------------------------------------------
 675 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
 676 // from the client area, so the client area is what's really available for the
 677 // frame contents
 678 // ----------------------------------------------------------------------------
 679
 680 // Checks if there is a toolbar, and returns the first free client position
 681 wxPoint wxFrame::GetClientAreaOrigin() const
 682 {
 683     wxPoint                         vPoint = wxTopLevelWindow::GetClientAreaOrigin();
 684
 685     //
 686     // In OS/2 the toolbar and statusbar are frame extensions so there is no
 687     // adjustment.  The client is supposedly resized for a toolbar in OS/2
 688     // as it is for the status bar.
 689     //
 690     return vPoint;
 691 } // end of wxFrame::GetClientAreaOrigin
 692
 693 // ----------------------------------------------------------------------------
 694 // tool/status bar stuff
 695 // ----------------------------------------------------------------------------
 696
 697 #if wxUSE_TOOLBAR
 698
 699 wxToolBar* wxFrame::CreateToolBar(
 700   long                              lStyle
 701 , wxWindowID                        vId
 702 , const wxString&                   rName
 703 )
 704 {
 705     if (wxFrameBase::CreateToolBar( lStyle
 706                                    ,vId
 707                                    ,rName
 708                                   ))
 709     {
 710         PositionToolBar();
 711     }
 712     return m_frameToolBar;
 713 } // end of wxFrame::CreateToolBar
 714
 715 void wxFrame::PositionToolBar()
 716 {
 717     wxToolBar*                      pToolBar = GetToolBar();
 718     wxCoord                         vWidth;
 719     wxCoord                         vHeight;
 720     wxCoord                         vTWidth;
 721     wxCoord                         vTHeight;
 722
 723     if (!pToolBar)
 724         return;
 725
 726     RECTL                           vRect;
 727     RECTL                           vFRect;
 728     wxPoint                         vPos;
 729
 730     ::WinQueryWindowRect(m_hFrame, &vRect);
 731     vPos.y = (wxCoord)vRect.yTop;
 732     ::WinMapWindowPoints(m_hFrame, HWND_DESKTOP, (PPOINTL)&vRect, 2);
 733     vFRect = vRect;
 734     ::WinCalcFrameRect(m_hFrame, &vRect, TRUE);
 735
 736     vPos.y = (wxCoord)(vFRect.yTop - vRect.yTop);
 737     pToolBar->GetSize( &vTWidth
 738                       ,&vTHeight
 739                      );
 740
 741     if (pToolBar->GetWindowStyleFlag() & wxTB_HORIZONTAL)
 742     {
 743         vWidth = (wxCoord)(vRect.xRight - vRect.xLeft);
 744         pToolBar->SetSize( vRect.xLeft - vFRect.xLeft
 745                           ,vPos.y
 746                           ,vWidth
 747                           ,vTHeight
 748                          );
 749     }
 750     else
 751     {
 752         wxCoord                     vSwidth = 0;
 753         wxCoord                     vSheight = 0;
 754
 755         if (m_frameStatusBar)
 756             m_frameStatusBar->GetSize( &vSwidth
 757                                       ,&vSheight
 758                                      );
 759         vHeight = (wxCoord)(vRect.yTop - vRect.yBottom);
 760         pToolBar->SetSize( vRect.xLeft - vFRect.xLeft
 761                           ,vPos.y
 762                           ,vTWidth
 763                           ,vHeight - vSheight
 764                          );
 765     }
 766     if( ::WinIsWindowShowing(m_hFrame) )
 767         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
 768 } // end of wxFrame::PositionToolBar
 769 #endif // wxUSE_TOOLBAR
 770
 771 // ----------------------------------------------------------------------------
 772 // frame state (iconized/maximized/...)
 773 // ----------------------------------------------------------------------------
 774
 775 //
 776 // propagate our state change to all child frames: this allows us to emulate X
 777 // Windows behaviour where child frames float independently of the parent one
 778 // on the desktop, but are iconized/restored with it
 779 //
 780 void wxFrame::IconizeChildFrames(
 781   bool                              bIconize
 782 )
 783 {
 784     for (wxWindowList::Node* pNode = GetChildren().GetFirst();
 785          pNode;
 786          pNode = pNode->GetNext() )
 787     {
 788         wxWindow*                   pWin = pNode->GetData();
 789         wxFrame*                    pFrame = wxDynamicCast(pWin, wxFrame);
 790
 791         if ( pFrame
 792 #if wxUSE_MDI_ARCHITECTURE
 793                 && !wxDynamicCast(pFrame, wxMDIChildFrame)
 794 #endif // wxUSE_MDI_ARCHITECTURE
 795            )
 796         {
 797             //
 798             // We don't want to restore the child frames which had been
 799             // iconized even before we were iconized, so save the child frame
 800             // status when iconizing the parent frame and check it when
 801             // restoring it.
 802             //
 803             if (bIconize)
 804             {
 805                 pFrame->m_bWasMinimized = pFrame->IsIconized();
 806             }
 807
 808             //
 809             // This test works for both iconizing and restoring
 810             //
 811             if (!pFrame->m_bWasMinimized)
 812                 pFrame->Iconize(bIconize);
 813         }
 814     }
 815 } // end of wxFrame::IconizeChildFrames
 816
 817 WXHICON wxFrame::GetDefaultIcon() const
 818 {
 819     return (WXHICON)(wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON
 820                                       : wxDEFAULT_FRAME_ICON);
 821 }
 822 // ===========================================================================
 823 // message processing
 824 // ===========================================================================
 825
 826 // ---------------------------------------------------------------------------
 827 // preprocessing
 828 // ---------------------------------------------------------------------------
 829 bool wxFrame::OS2TranslateMessage(
 830   WXMSG*                            pMsg
 831 )
 832 {
 833     //
 834     // try the menu bar accels
 835     //
 836     wxMenuBar*                      pMenuBar = GetMenuBar();
 837
 838     if (!pMenuBar)
 839         return FALSE;
 840
 841 #if wxUSE_ACCEL && wxUSE_MENUS_NATIVE
 842     const wxAcceleratorTable&       rAcceleratorTable = pMenuBar->GetAccelTable();
 843     return rAcceleratorTable.Translate(GetHWND(), pMsg);
 844 #else
 845     return FALSE;
 846 #endif //wxUSE_ACCEL
 847 } // end of wxFrame::OS2TranslateMessage
 848
 849 // ---------------------------------------------------------------------------
 850 // our private (non virtual) message handlers
 851 // ---------------------------------------------------------------------------
 852 bool wxFrame::HandlePaint()
 853 {
 854     RECTL                           vRect;
 855
 856     if (::WinQueryUpdateRect(GetHWND(), &vRect))
 857     {
 858         if (m_bIconized)
 859         {
 860             //
 861             // Icons in PM are the same as "pointers"
 862             //
 863             const wxIcon&           vIcon = GetIcon();
 864             HPOINTER                hIcon;
 865
 866             if (vIcon.Ok())
 867                 hIcon = (HPOINTER)::WinSendMsg(m_hFrame, WM_QUERYICON, 0L, 0L);
 868             else
 869                 hIcon = (HPOINTER)m_hDefaultIcon;
 870
 871             //
 872             // Hold a pointer to the dc so long as the OnPaint() message
 873             // is being processed
 874             //
 875             RECTL                   vRect2;
 876             HPS                     hPs = ::WinBeginPaint(GetHwnd(), NULLHANDLE, &vRect2);
 877
 878             //
 879             // Erase background before painting or we get white background
 880             //
 881             OS2DefWindowProc(WM_ERASEBACKGROUND, (MPARAM)hPs, (MPARAM)&vRect2);
 882
 883             if (hIcon)
 884             {
 885                 RECTL                           vRect3;
 886
 887                 ::WinQueryWindowRect(GetHwnd(), &vRect3);
 888
 889                 static const int    nIconWidth = 32;
 890                 static const int    nIconHeight = 32;
 891                 int                 nIconX = (int)((vRect3.xRight - nIconWidth)/2);
 892                 int                 nIconY = (int)((vRect3.yBottom + nIconHeight)/2);
 893
 894                 ::WinDrawPointer(hPs, nIconX, nIconY, hIcon, DP_NORMAL);
 895             }
 896             ::WinEndPaint(hPs);
 897             return TRUE;
 898         }
 899         else
 900         {
 901             if (!wxWindow::HandlePaint())
 902             {
 903                 HPS                     hPS;
 904                 RECTL                   vRect;
 905
 906                 hPS = ::WinBeginPaint( GetHwnd()
 907                                       ,NULLHANDLE
 908                                       ,&vRect
 909                                      );
 910                 if(hPS)
 911                 {
 912                     ::GpiCreateLogColorTable( hPS
 913                                              ,0L
 914                                              ,LCOLF_CONSECRGB
 915                                              ,0L
 916                                              ,(LONG)wxTheColourDatabase->m_nSize
 917                                              ,(PLONG)wxTheColourDatabase->m_palTable
 918                                             );
 919                     ::GpiCreateLogColorTable( hPS
 920                                              ,0L
 921                                              ,LCOLF_RGB
 922                                              ,0L
 923                                              ,0L
 924                                              ,NULL
 925                                             );
 926
 927                     ::WinFillRect( hPS
 928                                   ,&vRect
 929                                   ,GetBackgroundColour().GetPixel()
 930                                  );
 931                    ::WinEndPaint(hPS);
 932                 }
 933             }
 934             return TRUE;
 935         }
 936     }
 937     else
 938     {
 939         // nothing to paint - processed
 940         return TRUE;
 941     }
 942     return FALSE;
 943 } // end of wxFrame::HandlePaint
 944
 945 bool wxFrame::HandleSize(
 946   int                               nX
 947 , int                               nY
 948 , WXUINT                            nId
 949 )
 950 {
 951     bool                            bProcessed = FALSE;
 952
 953     switch (nId)
 954     {
 955         case kSizeNormal:
 956             //
 957             // Only do it it if we were iconized before, otherwise resizing the
 958             // parent frame has a curious side effect of bringing it under it's
 959             // children
 960             if (!m_bIconized )
 961                 break;
 962
 963             //
 964             // restore all child frames too
 965             //
 966             IconizeChildFrames(FALSE);
 967             (void)SendIconizeEvent(FALSE);
 968
 969             //
 970             // fall through
 971             //
 972
 973         case kSizeMax:
 974             m_bIconized = FALSE;
 975             break;
 976
 977         case kSizeMin:
 978             //
 979             // Iconize all child frames too
 980             //
 981             IconizeChildFrames(TRUE);
 982             (void)SendIconizeEvent();
 983             m_bIconized = TRUE;
 984             break;
 985     }
 986
 987     if (!m_bIconized)
 988     {
 989         //
 990         // forward WM_SIZE to status bar control
 991         //
 992 #if wxUSE_NATIVE_STATUSBAR
 993         if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
 994         {
 995             wxSizeEvent             vEvent( wxSize( nX
 996                                                    ,nY
 997                                                   )
 998                                            ,m_frameStatusBar->GetId()
 999                                           );
1000
1001             vEvent.SetEventObject(m_frameStatusBar);
1002             m_frameStatusBar->OnSize(vEvent);
1003         }
1004 #endif // wxUSE_NATIVE_STATUSBAR
1005
1006         PositionStatusBar();
1007 #if  wxUSE_TOOLBAR
1008         PositionToolBar();
1009 #endif // wxUSE_TOOLBAR
1010
1011         bProcessed = wxWindow::HandleSize( nX
1012                                           ,nY
1013                                           ,nId
1014                                          );
1015     }
1016     return bProcessed;
1017 } // end of wxFrame::HandleSize
1018
1019 bool wxFrame::HandleCommand(
1020   WXWORD                            nId
1021 , WXWORD                            nCmd
1022 , WXHWND                            hControl
1023 )
1024 {
1025     if (hControl)
1026     {
1027         //
1028         // In case it's e.g. a toolbar.
1029         //
1030         wxWindow*                   pWin = wxFindWinFromHandle(hControl);
1031
1032         if (pWin)
1033             return pWin->OS2Command( nCmd
1034                                     ,nId
1035                                    );
1036     }
1037
1038     //
1039     // Handle here commands from menus and accelerators
1040     //
1041     if (nCmd == CMDSRC_MENU || nCmd == CMDSRC_ACCELERATOR)
1042     {
1043 #if wxUSE_MENUS_NATIVE
1044         if (wxCurrentPopupMenu)
1045         {
1046             wxMenu*                 pPopupMenu = wxCurrentPopupMenu;
1047
1048             wxCurrentPopupMenu = NULL;
1049
1050             return pPopupMenu->OS2Command( nCmd
1051                                           ,nId
1052                                          );
1053             return TRUE;
1054         }
1055 #endif
1056
1057         if (ProcessCommand(nId))
1058         {
1059             return TRUE;
1060         }
1061     }
1062     return FALSE;
1063 } // end of wxFrame::HandleCommand
1064
1065 bool wxFrame::HandleMenuSelect(
1066   WXWORD                            nItem
1067 , WXWORD                            nFlags
1068 , WXHMENU                           hMenu
1069 )
1070 {
1071     if( !nFlags )
1072     {
1073         MENUITEM mItem;
1074         MRESULT  rc;
1075
1076         rc = ::WinSendMsg(hMenu, MM_QUERYITEM, MPFROM2SHORT(nItem, TRUE), (MPARAM)&mItem);
1077
1078         if(rc && !(mItem.afStyle & (MIS_SUBMENU | MIS_SEPARATOR)))
1079         {
1080             wxMenuEvent                     vEvent(wxEVT_MENU_HIGHLIGHT, nItem);
1081
1082             vEvent.SetEventObject(this);
1083             GetEventHandler()->ProcessEvent(vEvent); // return value would be ignored by PM
1084         }
1085         else
1086         {
1087             DoGiveHelp(wxEmptyString, FALSE);
1088             return FALSE;
1089         }
1090     }
1091     return TRUE;
1092 } // end of wxFrame::HandleMenuSelect
1093
1094 // ---------------------------------------------------------------------------
1095 // Main Frame window proc
1096 // ---------------------------------------------------------------------------
1097 MRESULT EXPENTRY wxFrameMainWndProc(
1098   HWND                              hWnd
1099 , ULONG                             ulMsg
1100 , MPARAM                            wParam
1101 , MPARAM                            lParam
1102 )
1103 {
1104     MRESULT                         rc = (MRESULT)0;
1105     bool                            bProcessed = FALSE;
1106     wxFrame*                        pWnd  = NULL;
1107
1108     pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
1109     switch (ulMsg)
1110     {
1111         case WM_QUERYFRAMECTLCOUNT:
1112             if(pWnd && pWnd->m_fnOldWndProc)
1113             {
1114                 USHORT              uItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
1115
1116                 rc = MRFROMSHORT(uItemCount);
1117             }
1118             break;
1119
1120         case WM_FORMATFRAME:
1121 /////////////////////////////////////////////////////////////////////////////////
1122 // Applications that subclass frame controls may find that the frame is already
1123 // subclassed the number of frame controls is variable.
1124 // The WM_FORMATFRAME and WM_QUERYFRAMECTLCOUNT messages must always be
1125 // subclassed by calling the previous window procedure and modifying its result.
1126 ////////////////////////////////////////////////////////////////////////////////
1127             {
1128                 int                 nItemCount;
1129                 int                 i;
1130                 PSWP                pSWP = NULL;
1131                 RECTL               vRectl;
1132                 RECTL               vRstb;
1133                 RECTL               vRtlb;
1134                 int                 nHeight = 0;
1135                 int                 nHeight2 = 0;
1136                 int                 nWidth = 0;
1137
1138                 pSWP = (PSWP)PVOIDFROMMP(wParam);
1139                 nItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam));
1140                 if(pWnd->m_frameStatusBar)
1141                 {
1142                     ::WinQueryWindowRect(pWnd->m_frameStatusBar->GetHWND(), &vRstb);
1143                     pWnd->m_frameStatusBar->GetSize(NULL, &nHeight);
1144                 }
1145                 if(pWnd->m_frameToolBar)
1146                 {
1147                     ::WinQueryWindowRect(pWnd->m_frameToolBar->GetHWND(), &vRtlb);
1148                     pWnd->m_frameToolBar->GetSize(&nWidth, &nHeight2);
1149                 }
1150                 ::WinQueryWindowRect(pWnd->m_hFrame, &vRectl);
1151                 ::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2);
1152                 ::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE);
1153                 ::WinMapWindowPoints(HWND_DESKTOP, pWnd->m_hFrame, (PPOINTL)&vRectl, 2);
1154                 for(i = 0; i < nItemCount; i++)
1155                 {
1156                     if(pWnd->m_hWnd && pSWP[i].hwnd == pWnd->m_hWnd)
1157                     {
1158                         if (pWnd->m_frameToolBar && pWnd->m_frameToolBar->GetWindowStyleFlag() & wxTB_HORIZONTAL)
1159                         {
1160                             pSWP[i].x    = vRectl.xLeft;
1161                             pSWP[i].y    = vRectl.yBottom + nHeight;
1162                             pSWP[i].cx   = vRectl.xRight - vRectl.xLeft;
1163                             pSWP[i].cy   = vRectl.yTop - vRectl.yBottom - (nHeight + nHeight2);
1164                         }
1165                         else
1166                         {
1167                             pSWP[i].x    = vRectl.xLeft + nWidth;
1168                             pSWP[i].y    = vRectl.yBottom + nHeight;
1169                             pSWP[i].cx   = vRectl.xRight - (vRectl.xLeft + nWidth);
1170                             pSWP[i].cy   = vRectl.yTop - vRectl.yBottom - nHeight;
1171                         }
1172                         pSWP[i].fl   = SWP_SIZE | SWP_MOVE | SWP_SHOW;
1173                         pSWP[i].hwndInsertBehind = HWND_TOP;
1174                     }
1175                 }
1176                 bProcessed = TRUE;
1177                 rc = MRFROMSHORT(nItemCount);
1178             }
1179             break;
1180
1181        default:
1182             if(pWnd && pWnd->m_fnOldWndProc)
1183                 rc = pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam);
1184             else
1185                 rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
1186     }
1187     return rc;
1188 } // end of wxFrameMainWndProc
1189
1190 MRESULT EXPENTRY wxFrameWndProc(
1191   HWND                              hWnd
1192 , ULONG                             ulMsg
1193 , MPARAM                            wParam
1194 , MPARAM                            lParam
1195 )
1196 {
1197     //
1198     // Trace all ulMsgs - useful for the debugging
1199     //
1200     HWND                            parentHwnd;
1201     wxFrame*                        pWnd  = NULL;
1202
1203     parentHwnd  = WinQueryWindow(hWnd,QW_PARENT);
1204     pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd);
1205
1206     //
1207     // When we get the first message for the HWND we just created, we associate
1208     // it with wxWindow stored in wxWndHook
1209     //
1210
1211     MRESULT                         rc = (MRESULT)0;
1212
1213     //
1214     // Stop right here if we don't have a valid handle in our wxWindow object.
1215     //
1216     if (pWnd && !pWnd->GetHWND())
1217     {
1218         pWnd->SetHWND((WXHWND) hWnd);
1219         rc = pWnd->OS2DefWindowProc(ulMsg, wParam, lParam );
1220         pWnd->SetHWND(0);
1221     }
1222     else
1223     {
1224         if (pWnd)
1225             rc = pWnd->OS2WindowProc(ulMsg, wParam, lParam);
1226         else
1227             rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam);
1228     }
1229     return rc;
1230 } // end of wxFrameWndProc
1231
1232 MRESULT wxFrame::OS2WindowProc(
1233   WXUINT                            uMessage
1234 , WXWPARAM                          wParam
1235 , WXLPARAM                          lParam
1236 )
1237 {
1238     MRESULT                         mRc = 0L;
1239     bool                            bProcessed = FALSE;
1240
1241     switch (uMessage)
1242     {
1243         case WM_CLOSE:
1244             //
1245             // If we can't close, tell the system that we processed the
1246             // message - otherwise it would close us
1247             //
1248             bProcessed = !Close();
1249             break;
1250
1251         case WM_PAINT:
1252             bProcessed = HandlePaint();
1253             mRc = (MRESULT)FALSE;
1254             break;
1255
1256          case WM_ERASEBACKGROUND:
1257             //
1258             // Returning TRUE to requests PM to paint the window background
1259             // in SYSCLR_WINDOW. We capture this here because the PS returned
1260             // in Frames is the PS for the whole frame, which we can't really
1261             // use at all. If you want to paint a different background, do it
1262             // in an OnPaint using a wxPaintDC.
1263             //
1264             mRc = (MRESULT)(TRUE);
1265             break;
1266
1267       case WM_COMMAND:
1268             {
1269                 WORD                wId;
1270                 WORD                wCmd;
1271                 WXHWND              hWnd;
1272
1273                 UnpackCommand( (WXWPARAM)wParam
1274                               ,(WXLPARAM)lParam
1275                               ,&wId
1276                               ,&hWnd
1277                               ,&wCmd
1278                              );
1279
1280                 bProcessed = HandleCommand( wId
1281                                            ,wCmd
1282                                            ,(WXHWND)hWnd
1283                                           );
1284             }
1285             break;
1286
1287         case WM_MENUSELECT:
1288             {
1289                 WXWORD              wItem;
1290                 WXWORD              wFlags;
1291                 WXHMENU             hMenu;
1292
1293                 UnpackMenuSelect( wParam
1294                                  ,lParam
1295                                  ,&wItem
1296                                  ,&wFlags
1297                                  ,&hMenu
1298                                 );
1299                 bProcessed = HandleMenuSelect( wItem
1300                                               ,wFlags
1301                                               ,hMenu
1302                                              );
1303                 mRc = (MRESULT)TRUE;
1304             }
1305             break;
1306
1307         case WM_SIZE:
1308             {
1309                 SHORT               nScxnew = SHORT1FROMMP(lParam); // New horizontal size.
1310                 SHORT               nScynew = SHORT2FROMMP(lParam); // New vertical size.
1311
1312                 lParam = MRFROM2SHORT( nScxnew - 20
1313                                       ,nScynew - 30
1314                                      );
1315             }
1316             bProcessed = HandleSize(LOWORD(lParam), HIWORD(lParam), (WXUINT)wParam);
1317             mRc = (MRESULT)FALSE;
1318             break;
1319
1320         case CM_QUERYDRAGIMAGE:
1321             {
1322                 const wxIcon&           vIcon = GetIcon();
1323                 HPOINTER                hIcon;
1324
1325                 if (vIcon.Ok())
1326                     hIcon = (HPOINTER)::WinSendMsg(GetHWND(), WM_QUERYICON, 0L, 0L);
1327                 else
1328                     hIcon = (HPOINTER)m_hDefaultIcon;
1329                 mRc = (MRESULT)hIcon;
1330                 bProcessed = mRc != 0;
1331             }
1332             break;
1333     }
1334
1335     if (!bProcessed )
1336         mRc = wxWindow::OS2WindowProc( uMessage
1337                                       ,wParam
1338                                       ,lParam
1339                                      );
1340     return (MRESULT)mRc;
1341 } // wxFrame::OS2WindowProc
1342
1343 void wxFrame::SetClient(WXHWND c_Hwnd)
1344 {
1345    // Duh...nothing to do under OS/2
1346 }
1347
1348 void wxFrame::SetClient(
1349   wxWindow*                         pWindow
1350 )
1351 {
1352     wxWindow*                       pOldClient      = this->GetClient();
1353     bool                            bClientHasFocus = pOldClient && (pOldClient == wxWindow::FindFocus());
1354
1355     if(pOldClient == pWindow)  // nothing to do
1356         return;
1357     if(pWindow == NULL) // just need to remove old client
1358     {
1359         if(pOldClient == NULL) // nothing to do
1360             return;
1361
1362         if(bClientHasFocus )
1363             this->SetFocus();
1364
1365         pOldClient->Enable( FALSE );
1366         pOldClient->Show( FALSE );
1367         ::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
1368         // to avoid OS/2 bug need to update frame
1369         ::WinSendMsg((HWND)this->GetFrame(), WM_UPDATEFRAME, (MPARAM)~0, 0);
1370         return;
1371     }
1372
1373     //
1374     // Else need to change client
1375     //
1376     if(bClientHasFocus)
1377          this->SetFocus();
1378
1379     ::WinEnableWindowUpdate((HWND)GetHWND(), FALSE);
1380     if(pOldClient)
1381     {
1382         pOldClient->Enable(FALSE);
1383         pOldClient->Show(FALSE);
1384         ::WinSetWindowUShort(pOldClient->GetHWND(), QWS_ID, (USHORT)pOldClient->GetId());
1385     }
1386     pWindow->Reparent(this);
1387     ::WinSetWindowUShort(pWindow->GetHWND(), QWS_ID, FID_CLIENT);
1388     ::WinEnableWindowUpdate((HWND)GetHWND(), TRUE);
1389     pWindow->Enable();
1390     pWindow->Show();   // ensure client is showing
1391     if( this->IsShown() )
1392     {
1393         this->Show();
1394         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
1395     }
1396 }
1397
1398 wxWindow* wxFrame::GetClient()
1399 {
1400     return wxFindWinFromHandle((WXHWND)::WinWindowFromID(m_hFrame, FID_CLIENT));
1401 }
1402
1403 void wxFrame::SendSizeEvent()
1404 {
1405     if (!m_bIconized)
1406     {
1407         RECTL                       vRect = wxGetWindowRect(GetHwnd());
1408
1409         ::WinPostMsg( GetHwnd()
1410                      ,WM_SIZE
1411                      ,MPFROM2SHORT( vRect.xRight - vRect.xLeft
1412                                    ,vRect.xRight - vRect.xLeft
1413                                   )
1414                      ,MPFROM2SHORT( vRect.yTop - vRect.yBottom
1415                                    ,vRect.yTop - vRect.yBottom
1416                                   )
1417                     );
1418     }
1419 }
1420