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