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/setup.h"
  17     #include "wx/frame.h"
  18     #include "wx/menu.h"
  19     #include "wx/app.h"
  20     #include "wx/utils.h"
  21     #include "wx/dialog.h"
  22     #include "wx/settings.h"
  23     #include "wx/dcclient.h"
  24 #endif // WX_PRECOMP
  25
  26 #include "wx/os2/private.h"
  27
  28 #if wxUSE_STATUSBAR
  29     #include "wx/statusbr.h"
  30     #include "wx/generic/statusbr.h"
  31 #endif // wxUSE_STATUSBAR
  32
  33 #if wxUSE_TOOLBAR
  34     #include "wx/toolbar.h"
  35 #endif // wxUSE_TOOLBAR
  36
  37 #include "wx/menuitem.h"
  38 #include "wx/log.h"
  39
  40 // ----------------------------------------------------------------------------
  41 // globals
  42 // ----------------------------------------------------------------------------
  43
  44 extern wxWindowList wxModelessWindows;
  45 extern wxList WXDLLEXPORT wxPendingDelete;
  46 extern wxChar wxFrameClassName[];
  47 extern wxMenu *wxCurrentPopupMenu;
  48
  49 // ----------------------------------------------------------------------------
  50 // event tables
  51 // ----------------------------------------------------------------------------
  52
  53 BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
  54     EVT_ACTIVATE(wxFrame::OnActivate)
  55     EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
  56 END_EVENT_TABLE()
  57
  58 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
  59
  60 // ============================================================================
  61 // implementation
  62 // ============================================================================
  63
  64 // ----------------------------------------------------------------------------
  65 // static class members
  66 // ----------------------------------------------------------------------------
  67
  68 #if wxUSE_NATIVE_STATUSBAR
  69     bool wxFrame::m_bUseNativeStatusBar = TRUE;
  70 #else
  71     bool wxFrame::m_bUseNativeStatusBar = FALSE;
  72 #endif
  73
  74 // ----------------------------------------------------------------------------
  75 // creation/destruction
  76 // ----------------------------------------------------------------------------
  77
  78 void wxFrame::Init()
  79 {
  80     m_bIconized = FALSE;
  81
  82 #if wxUSE_TOOLTIPS
  83     m_hWndToolTip = 0;
  84 #endif
  85     // Data to save/restore when calling ShowFullScreen
  86     m_lFsStyle           = 0L;
  87     m_lFsOldWindowStyle  = 0L;
  88     m_nFsStatusBarFields = 0;
  89     m_nFsStatusBarHeight = 0;
  90     m_nFsToolBarHeight   = 0;
  91     m_bFsIsMaximized     = FALSE;
  92     m_bFsIsShowing       = FALSE;
  93
  94     //
  95     // Initialize SWP's
  96     //
  97     memset(&m_vSwp, 0, sizeof(SWP));
  98     memset(&m_vSwpClient, 0, sizeof(SWP));
  99     memset(&m_vSwpTitleBar, 0, sizeof(SWP));
 100     memset(&m_vSwpMenuBar, 0, sizeof(SWP));
 101     memset(&m_vSwpHScroll, 0, sizeof(SWP));
 102     memset(&m_vSwpVScroll, 0, sizeof(SWP));
 103     memset(&m_vSwpStatusBar, 0, sizeof(SWP));
 104     memset(&m_vSwpToolBar, 0, sizeof(SWP));
 105 } // end of wxFrame::Init
 106
 107 bool wxFrame::Create(
 108   wxWindow*                         pParent
 109 , wxWindowID                        vId
 110 , const wxString&                   rsTitle
 111 , const wxPoint&                    rPos
 112 , const wxSize&                     rSize
 113 , long                              lulStyle
 114 , const wxString&                   rsName
 115 )
 116 {
 117     int                             nX      = rPos.x;
 118     int                             nY      = rPos.y;
 119     int                             nWidth  = rSize.x;
 120     int                             nHeight = rSize.y;
 121
 122     SetName(rsName);
 123     m_windowStyle    = lulStyle;
 124     m_frameMenuBar   = NULL;
 125     m_frameToolBar   = NULL;
 126     m_frameStatusBar = NULL;
 127
 128     SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
 129
 130     if (vId > -1 )
 131         m_windowId = vId;
 132     else
 133         m_windowId = (int)NewControlId();
 134
 135     if (pParent)
 136         pParent->AddChild(this);
 137
 138     m_bIconized = FALSE;
 139
 140     if ((m_windowStyle & wxFRAME_FLOAT_ON_PARENT) == 0)
 141         pParent = NULL;
 142
 143     if (!pParent)
 144         wxTopLevelWindows.Append(this);
 145
 146     OS2Create( m_windowId
 147               ,pParent
 148               ,wxFrameClassName
 149               ,this
 150               ,rsTitle
 151               ,nX
 152               ,nY
 153               ,nWidth
 154               ,nHeight
 155               ,lulStyle
 156              );
 157
 158     wxModelessWindows.Append(this);
 159     return TRUE;
 160 } // end of wxFrame::Create
 161
 162 wxFrame::~wxFrame()
 163 {
 164     m_isBeingDeleted = TRUE;
 165     wxTopLevelWindows.DeleteObject(this);
 166
 167     DeleteAllBars();
 168
 169     if (wxTheApp && (wxTopLevelWindows.Number() == 0))
 170     {
 171         wxTheApp->SetTopWindow(NULL);
 172
 173         if (wxTheApp->GetExitOnFrameDelete())
 174         {
 175             ::WinPostMsg(m_hFrame, WM_QUIT, 0, 0);
 176         }
 177     }
 178     wxModelessWindows.DeleteObject(this);
 179
 180     //
 181     // For some reason, wxWindows can activate another task altogether
 182     // when a frame is destroyed after a modal dialog has been invoked.
 183     // Try to bring the parent to the top.
 184     //
 185     // MT:Only do this if this frame is currently the active window, else weird
 186     // things start to happen.
 187     //
 188     if (wxGetActiveWindow() == this)
 189     {
 190         if (GetParent() && GetParent()->GetHWND())
 191         {
 192             ::WinSetWindowPos( (HWND) GetParent()->GetHWND()
 193                               ,HWND_TOP
 194                               ,0
 195                               ,0
 196                               ,0
 197                               ,0
 198                               ,SWP_ZORDER
 199                              );
 200         }
 201     }
 202 } // end of wxFrame::~wxFrame
 203
 204 //
 205 // Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
 206 //
 207 void wxFrame::DoGetClientSize(
 208   int*                              pX
 209 , int*                              pY
 210 ) const
 211 {
 212     //
 213     // OS/2 PM's coordinates go from bottom-left not
 214     // top-left thus the += instead of the -=
 215     //
 216     RECTL                           vRect;
 217
 218     //
 219     // PM has no GetClientRect that inherantly knows about the client window
 220     // We have to explicitly go fetch it!
 221     //
 222     ::WinQueryWindowRect(GetHwnd(), &vRect);
 223
 224 #if wxUSE_STATUSBAR
 225     if ( GetStatusBar() )
 226     {
 227         int                         nStatusX;
 228         int                         nStatusY;
 229
 230         GetStatusBar()->GetClientSize( &nStatusX
 231                                       ,&nStatusY
 232                                      );
 233         vRect.yBottom += nStatusY;
 234     }
 235 #endif // wxUSE_STATUSBAR
 236
 237     wxPoint                         vPoint(GetClientAreaOrigin());
 238
 239     vRect.yBottom += vPoint.y;
 240     vRect.xRight -= vPoint.x;
 241
 242     if (pX)
 243         *pX = vRect.xRight;
 244     if (pY)
 245         *pY = vRect.yBottom;
 246 } // end of wxFrame::DoGetClientSize
 247
 248 //
 249 // Set the client size (i.e. leave the calculation of borders etc.
 250 // to wxWindows)
 251 //
 252 void wxFrame::DoSetClientSize(
 253   int                               nWidth
 254 , int                               nHeight
 255 )
 256 {
 257     HWND                            hWnd = GetHwnd();
 258     RECTL                           vRect;
 259     RECTL                           vRect2;
 260
 261     ::WinQueryWindowRect(GetHwnd(), &vRect);
 262
 263     ::WinQueryWindowRect(m_hFrame, &vRect2);
 264
 265     //
 266     // Find the difference between the entire window (title bar and all)
 267     // and the client area; add this to the new client size to move the
 268     // window.  Remember OS/2's backwards y coord system!
 269     //
 270     int                             nActualWidth = vRect2.xRight - vRect2.xLeft - vRect.xRight + nWidth;
 271     int                             nActualHeight = vRect2.yTop + vRect2.yTop - vRect.yTop + nHeight;
 272
 273 #if wxUSE_STATUSBAR
 274     if ( GetStatusBar() )
 275     {
 276         int                         nStatusX;
 277         int                         nStatusY;
 278
 279         GetStatusBar()->GetClientSize( &nStatusX
 280                                       ,&nStatusY
 281                                      );
 282         nActualHeight += nStatusY;
 283     }
 284 #endif // wxUSE_STATUSBAR
 285
 286     wxPoint                         vPoint(GetClientAreaOrigin());
 287     nActualWidth  += vPoint.y;
 288     nActualHeight += vPoint.x;
 289
 290     POINTL                          vPointl;
 291
 292     vPointl.x = vRect2.xLeft;
 293     vPoint.y  = vRect2.yTop;
 294
 295     ::WinSetWindowPos( m_hFrame
 296                       ,HWND_TOP
 297                       ,vPointl.x
 298                       ,vPointl.y
 299                       ,nActualWidth
 300                       ,nActualHeight
 301                       ,SWP_MOVE | SWP_SIZE | SWP_SHOW
 302                      );
 303
 304     wxSizeEvent                     vEvent( wxSize( nWidth
 305                                                    ,nHeight
 306                                                   )
 307                                            ,m_windowId
 308                                           );
 309     vEvent.SetEventObject(this);
 310     GetEventHandler()->ProcessEvent(vEvent);
 311 } // end of wxFrame::DoSetClientSize
 312
 313 void wxFrame::DoGetSize(
 314   int*                              pWidth
 315 , int*                              pHeight
 316 ) const
 317 {
 318     RECTL                           vRect;
 319
 320     ::WinQueryWindowRect(m_hFrame, &vRect);
 321     *pWidth = vRect.xRight - vRect.xLeft;
 322     *pHeight = vRect.yTop - vRect.yBottom;
 323 } // end of wxFrame::DoGetSize
 324
 325 void wxFrame::DoGetPosition(
 326   int*                              pX
 327 , int*                              pY
 328 ) const
 329 {
 330     RECTL                           vRect;
 331     POINTL                          vPoint;
 332
 333     ::WinQueryWindowRect(m_hFrame, &vRect);
 334     vPoint.x = vRect.xLeft;
 335
 336     //
 337     // OS/2 is backwards [WIN32 it is vRect.yTop]
 338     //
 339     vPoint.y = vRect.yBottom;
 340
 341     *pX = vPoint.x;
 342     *pY = vPoint.y;
 343 } // end of wxFrame::DoGetPosition
 344
 345 // ----------------------------------------------------------------------------
 346 // variations around ::ShowWindow()
 347 // ----------------------------------------------------------------------------
 348
 349 void wxFrame::DoShowWindow(
 350   int                               bShowCmd
 351 )
 352 {
 353     HWND                            hClient = NULLHANDLE;
 354     SWP                             vSwp;
 355
 356     //
 357     // Reset the window position
 358     //
 359     WinQueryWindowPos(m_hFrame, &vSwp);
 360     WinSetWindowPos( GetHwnd()
 361                     ,HWND_TOP
 362                     ,vSwp.x
 363                     ,vSwp.y
 364                     ,vSwp.cx
 365                     ,vSwp.cy
 366                     ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE
 367                    );
 368     ::WinShowWindow(m_hFrame, (BOOL)bShowCmd);
 369     ::WinShowWindow(GetHwnd(), (BOOL)bShowCmd);
 370 } // end of wxFrame::DoShowWindow
 371
 372 bool wxFrame::Show(
 373   bool                              bShow
 374 )
 375 {
 376     SWP                             vSwp;
 377
 378     DoShowWindow((int)bShow);
 379
 380     if (bShow)
 381     {
 382         wxActivateEvent             vEvent(wxEVT_ACTIVATE, TRUE, m_windowId);
 383
 384         ::WinQueryWindowPos(m_hFrame, &vSwp);
 385         m_bIconized = vSwp.fl & SWP_MINIMIZE;
 386         ::WinEnableWindow(m_hFrame, TRUE);
 387         vEvent.SetEventObject(this);
 388         GetEventHandler()->ProcessEvent(vEvent);
 389     }
 390     else
 391     {
 392         //
 393         // Try to highlight the correct window (the parent)
 394         //
 395         if (GetParent())
 396         {
 397             HWND                    hWndParent = GetHwndOf(GetParent());
 398
 399             ::WinQueryWindowPos(hWndParent, &vSwp);
 400             m_bIconized = vSwp.fl & SWP_MINIMIZE;
 401             if (hWndParent)
 402                 ::WinSetWindowPos( hWndParent
 403                                   ,HWND_TOP
 404                                   ,vSwp.x
 405                                   ,vSwp.y
 406                                   ,vSwp.cx
 407                                   ,vSwp.cy
 408                                   ,SWP_ZORDER | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE
 409                                  );
 410             ::WinEnableWindow(hWndParent, TRUE);
 411         }
 412     }
 413     return TRUE;
 414 } // end of wxFrame::Show
 415
 416 void wxFrame::Iconize(
 417   bool                              bIconize
 418 )
 419 {
 420     DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
 421 } // end of wxFrame::Iconize
 422
 423 void wxFrame::Maximize(
 424   bool                              bMaximize)
 425 {
 426     DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);
 427 } // end of wxFrame::Maximize
 428
 429 void wxFrame::Restore()
 430 {
 431     DoShowWindow(SWP_RESTORE);
 432 } // end of wxFrame::Restore
 433
 434 bool wxFrame::IsIconized() const
 435 {
 436     SWP                             vSwp;
 437     bool                            bIconic;
 438
 439     ::WinQueryWindowPos(GetHwnd(), &vSwp);
 440
 441     if (vSwp.fl & SWP_MINIMIZE)
 442         ((wxFrame*)this)->m_bIconized = TRUE;
 443     else
 444         ((wxFrame*)this)->m_bIconized = FALSE;
 445     return m_bIconized;
 446 } // end of wxFrame::IsIconized
 447
 448 // Is it maximized?
 449 bool wxFrame::IsMaximized() const
 450 {
 451     SWP                             vSwp;
 452     bool                            bIconic;
 453
 454     ::WinQueryWindowPos(m_hFrame, &vSwp);
 455     return (vSwp.fl & SWP_MAXIMIZE);
 456 } // end of wxFrame::IsMaximized
 457
 458 void wxFrame::SetIcon(
 459   const wxIcon&                     rIcon
 460 )
 461 {
 462     wxFrameBase::SetIcon(rIcon);
 463
 464     if ((m_icon.GetHICON()) != NULLHANDLE)
 465     {
 466         ::WinSendMsg( m_hFrame
 467                      ,WM_SETICON
 468                      ,(MPARAM)((HPOINTER)m_icon.GetHICON())
 469                      ,NULL
 470                     );
 471         ::WinSendMsg( m_hFrame
 472                      ,WM_UPDATEFRAME
 473                      ,(MPARAM)FCF_ICON
 474                      ,(MPARAM)0
 475                     );
 476     }
 477 } // end of wxFrame::SetIcon
 478
 479 #if wxUSE_STATUSBAR
 480 wxStatusBar* wxFrame::OnCreateStatusBar(
 481   int                               nNumber
 482 , long                              lulStyle
 483 , wxWindowID                        vId
 484 , const wxString&                   rName
 485 )
 486 {
 487     wxStatusBar*                    pStatusBar = NULL;
 488
 489     pStatusBar = wxFrameBase::OnCreateStatusBar( nNumber
 490                                                 ,lulStyle
 491                                                 ,vId
 492                                                 ,rName
 493                                                );
 494     return pStatusBar;
 495 } // end of wxFrame::OnCreateStatusBar
 496
 497 void wxFrame::PositionStatusBar()
 498 {
 499     //
 500     // Native status bar positions itself
 501     //
 502     if (m_frameStatusBar)
 503     {
 504         int                         nWidth;
 505         int                         nHeight;
 506         int                         nStatbarWidth;
 507         int                         nStatbarHeight;
 508         HWND                        hWndClient;
 509         RECTL                       vRect;
 510
 511         ::WinQueryWindowRect(GetHwnd(), &vRect);
 512         nWidth = vRect.xRight - vRect.xLeft;
 513         nHeight = vRect.yTop - vRect.yBottom;
 514
 515         m_frameStatusBar->GetSize( &nStatbarWidth
 516                                   ,&nStatbarHeight
 517                                  );
 518
 519         //
 520         // Since we wish the status bar to be directly under the client area,
 521         // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
 522         //
 523         m_frameStatusBar->SetSize( 0
 524                                   ,nHeight
 525                                   ,nWidth
 526                                   ,nStatbarHeight
 527                                  );
 528     }
 529 } // end of wxFrame::PositionStatusBar
 530 #endif // wxUSE_STATUSBAR
 531
 532 void wxFrame::DetachMenuBar()
 533 {
 534     if (m_frameMenuBar)
 535     {
 536         m_frameMenuBar->Detach();
 537         m_frameMenuBar = NULL;
 538     }
 539 } // end of wxFrame::DetachMenuBar
 540
 541 void wxFrame::SetMenuBar(
 542   wxMenuBar*                        pMenuBar
 543 )
 544 {
 545     ERRORID                         vError;
 546     wxString                        sError;
 547     HWND                            hClient = NULLHANDLE;
 548     HWND                            hFrame = NULLHANDLE;
 549     HWND                            hTitlebar = NULLHANDLE;
 550     HWND                            hHScroll = NULLHANDLE;
 551     HWND                            hVScroll = NULLHANDLE;
 552     HWND                            hMenuBar = NULLHANDLE;
 553     SWP                             vSwp;
 554     SWP                             vSwpTitlebar;
 555     SWP                             vSwpVScroll;
 556     SWP                             vSwpHScroll;
 557     SWP                             vSwpMenu;
 558
 559     if (!pMenuBar)
 560     {
 561         DetachMenuBar();
 562         return;
 563     }
 564
 565     m_frameMenuBar = NULL;
 566
 567     // Can set a menubar several times.
 568     // TODO: how to prevent a memory leak if you have a currently-unattached
 569     // menubar? wxWindows assumes that the frame will delete the menu (otherwise
 570     // there are problems for MDI).
 571     if (pMenuBar->GetHMenu())
 572     {
 573         m_hMenu = pMenuBar->GetHMenu();
 574     }
 575     else
 576     {
 577         pMenuBar->Detach();
 578
 579         m_hMenu = pMenuBar->Create();
 580
 581         if (!m_hMenu)
 582             return;
 583     }
 584
 585     //
 586     // Set the parent and owner of the menubar to be the frame
 587     //
 588     if (!::WinSetParent(m_hMenu, m_hFrame, FALSE))
 589     {
 590         vError = ::WinGetLastError(vHabmain);
 591         sError = wxPMErrorToStr(vError);
 592         wxLogError("Error setting parent for submenu. Error: %s\n", sError);
 593     }
 594
 595     if (!::WinSetOwner(m_hMenu, m_hFrame))
 596     {
 597         vError = ::WinGetLastError(vHabmain);
 598         sError = wxPMErrorToStr(vError);
 599         wxLogError("Error setting parent for submenu. Error: %s\n", sError);
 600     }
 601     InternalSetMenuBar();
 602
 603     m_frameMenuBar = pMenuBar;
 604     pMenuBar->Attach(this);
 605
 606     //
 607     // Now resize the client to fit the new frame
 608     //
 609     WinQueryWindowPos(m_hFrame, &vSwp);
 610     hTitlebar = WinWindowFromID(m_hFrame, FID_TITLEBAR);
 611     WinQueryWindowPos(hTitlebar, &vSwpTitlebar);
 612     hHScroll = WinWindowFromID(m_hFrame, FID_HORZSCROLL);
 613     WinQueryWindowPos(hHScroll, &vSwpHScroll);
 614     hVScroll = WinWindowFromID(m_hFrame, FID_VERTSCROLL);
 615     WinQueryWindowPos(hVScroll, &vSwpVScroll);
 616     hMenuBar = WinWindowFromID(m_hFrame, FID_MENU);
 617     WinQueryWindowPos(hMenuBar, &vSwpMenu);
 618     WinSetWindowPos( GetHwnd()
 619                     ,HWND_TOP
 620                     ,SV_CXSIZEBORDER/2
 621                     ,(SV_CYSIZEBORDER/2) + vSwpHScroll.cy/2
 622                     ,vSwp.cx - ((SV_CXSIZEBORDER + 1) + vSwpVScroll.cx)
 623                     ,vSwp.cy - ((SV_CYSIZEBORDER + 1) + vSwpTitlebar.cy + vSwpMenu.cy + vSwpHScroll.cy/2)
 624                     ,SWP_SIZE | SWP_MOVE
 625                    );
 626 } // end of wxFrame::SetMenuBar
 627
 628 void wxFrame::InternalSetMenuBar()
 629 {
 630     WinSendMsg((HWND)m_hFrame, WM_UPDATEFRAME, (MPARAM)FCF_MENU, (MPARAM)0);
 631 } // end of wxFrame::InternalSetMenuBar
 632
 633 //
 634 // Responds to colour changes, and passes event on to children
 635 //
 636 void wxFrame::OnSysColourChanged(
 637   wxSysColourChangedEvent&          rEvent
 638 )
 639 {
 640     SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
 641     Refresh();
 642
 643     if (m_frameStatusBar)
 644     {
 645         wxSysColourChangedEvent     vEvent2;
 646
 647         vEvent2.SetEventObject(m_frameStatusBar);
 648         m_frameStatusBar->GetEventHandler()->ProcessEvent(vEvent2);
 649     }
 650
 651     //
 652     // Propagate the event to the non-top-level children
 653     //
 654     wxWindow::OnSysColourChanged(rEvent);
 655 } // end of wxFrame::OnSysColourChanged
 656
 657 // Pass TRUE to show full screen, FALSE to restore.
 658 bool wxFrame::ShowFullScreen(
 659   bool                              bShow
 660 , long                              lStyle
 661 )
 662 {
 663     /*
 664     // TODO
 665     if (show)
 666     {
 667         if (IsFullScreen())
 668             return FALSE;
 669
 670         m_fsIsShowing = TRUE;
 671         m_fsStyle = style;
 672
 673              wxToolBar *theToolBar = GetToolBar();
 674              wxStatusBar *theStatusBar = GetStatusBar();
 675
 676         int dummyWidth;
 677
 678         if (theToolBar)
 679             theToolBar->GetSize(&dummyWidth, &m_fsToolBarHeight);
 680         if (theStatusBar)
 681             theStatusBar->GetSize(&dummyWidth, &m_fsStatusBarHeight);
 682
 683         // zap the toolbar, menubar, and statusbar
 684
 685         if ((style & wxFULLSCREEN_NOTOOLBAR) && theToolBar)
 686         {
 687             theToolBar->SetSize(-1,0);
 688             theToolBar->Show(FALSE);
 689         }
 690
 691         if (style & wxFULLSCREEN_NOMENUBAR)
 692             SetMenu((HWND)GetHWND(), (HMENU) NULL);
 693
 694         // Save the number of fields in the statusbar
 695         if ((style & wxFULLSCREEN_NOSTATUSBAR) && theStatusBar)
 696         {
 697             m_fsStatusBarFields = theStatusBar->GetFieldsCount();
 698             SetStatusBar((wxStatusBar*) NULL);
 699                  delete theStatusBar;
 700         }
 701         else
 702             m_fsStatusBarFields = 0;
 703
 704         // zap the frame borders
 705
 706         // save the 'normal' window style
 707         m_fsOldWindowStyle = GetWindowLong((HWND)GetHWND(), GWL_STYLE);
 708
 709             // save the old position, width & height, maximize state
 710         m_fsOldSize = GetRect();
 711              m_fsIsMaximized = IsMaximized();
 712
 713             // decide which window style flags to turn off
 714         LONG newStyle = m_fsOldWindowStyle;
 715         LONG offFlags = 0;
 716
 717         if (style & wxFULLSCREEN_NOBORDER)
 718             offFlags |= WS_BORDER;
 719         if (style & wxFULLSCREEN_NOCAPTION)
 720             offFlags |= (WS_CAPTION | WS_SYSMENU);
 721
 722         newStyle &= (~offFlags);
 723
 724         // change our window style to be compatible with full-screen mode
 725         SetWindowLong((HWND)GetHWND(), GWL_STYLE, newStyle);
 726
 727         // resize to the size of the desktop
 728         int width, height;
 729
 730         RECT rect;
 731         ::GetWindowRect(GetDesktopWindow(), &rect);
 732         width = rect.right - rect.left;
 733         height = rect.bottom - rect.top;
 734
 735         SetSize(width, height);
 736
 737         // now flush the window style cache and actually go full-screen
 738         SetWindowPos((HWND)GetHWND(), HWND_TOP, 0, 0, width, height, SWP_FRAMECHANGED);
 739
 740         wxSizeEvent event(wxSize(width, height), GetId());
 741         GetEventHandler()->ProcessEvent(event);
 742
 743         return TRUE;
 744     }
 745     else
 746     {
 747         if (!IsFullScreen())
 748             return FALSE;
 749
 750         m_fsIsShowing = FALSE;
 751
 752         wxToolBar *theToolBar = GetToolBar();
 753
 754         // restore the toolbar, menubar, and statusbar
 755         if (theToolBar && (m_fsStyle & wxFULLSCREEN_NOTOOLBAR))
 756         {
 757             theToolBar->SetSize(-1, m_fsToolBarHeight);
 758             theToolBar->Show(TRUE);
 759         }
 760
 761         if ((m_fsStyle & wxFULLSCREEN_NOSTATUSBAR) && (m_fsStatusBarFields > 0))
 762         {
 763             CreateStatusBar(m_fsStatusBarFields);
 764             PositionStatusBar();
 765         }
 766
 767         if ((m_fsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
 768             SetMenu((HWND)GetHWND(), (HMENU)m_hMenu);
 769
 770         Maximize(m_fsIsMaximized);
 771         SetWindowLong((HWND)GetHWND(),GWL_STYLE, m_fsOldWindowStyle);
 772         SetWindowPos((HWND)GetHWND(),HWND_TOP,m_fsOldSize.x, m_fsOldSize.y,
 773             m_fsOldSize.width, m_fsOldSize.height, SWP_FRAMECHANGED);
 774
 775         return TRUE;
 776     }
 777 */
 778     return TRUE;
 779 } // end of wxFrame::ShowFullScreen
 780
 781 //
 782 // Frame window
 783 //
 784 bool wxFrame::OS2Create(
 785   int                               nId
 786 , wxWindow*                         pParent
 787 , const wxChar*                     zWclass
 788 , wxWindow*                         pWxWin
 789 , const wxChar*                     zTitle
 790 , int                               nX
 791 , int                               nY
 792 , int                               nWidth
 793 , int                               nHeight
 794 , long                              ulStyle
 795 )
 796 {
 797     ULONG                           ulCreateFlags = 0L;
 798     ULONG                           ulStyleFlags = 0L;
 799     ULONG                           ulExtraFlags = 0L;
 800     FRAMECDATA                      vFrameCtlData;
 801     HWND                            hParent = NULLHANDLE;
 802     HWND                            hClient = NULLHANDLE;
 803     HWND                            hFrame = NULLHANDLE;
 804     HWND                            hTitlebar = NULLHANDLE;
 805     HWND                            hHScroll = NULLHANDLE;
 806     HWND                            hVScroll = NULLHANDLE;
 807     SWP                             vSwp[10];
 808     RECTL                           vRect[10];
 809     USHORT                          uCtlCount;
 810
 811     m_hDefaultIcon = (WXHICON) (wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON : wxDEFAULT_FRAME_ICON);
 812
 813     if (pParent)
 814         hParent = GetWinHwnd(pParent);
 815     else
 816         hParent = HWND_DESKTOP;
 817
 818     if (ulStyle == wxDEFAULT_FRAME_STYLE)
 819         ulCreateFlags = FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
 820                         FCF_MINMAX | FCF_VERTSCROLL | FCF_HORZSCROLL | FCF_TASKLIST;
 821     else
 822     {
 823         if ((ulStyle & wxCAPTION) == wxCAPTION)
 824             ulCreateFlags = FCF_TASKLIST;
 825         else
 826             ulCreateFlags = FCF_NOMOVEWITHOWNER;
 827
 828         if (ulStyle & wxMINIMIZE_BOX)
 829             ulCreateFlags |= FCF_MINBUTTON;
 830         if (ulStyle & wxMAXIMIZE_BOX)
 831             ulCreateFlags |= FCF_MAXBUTTON;
 832         if (ulStyle & wxTHICK_FRAME)
 833             ulCreateFlags |= FCF_DLGBORDER;
 834         if (ulStyle & wxSYSTEM_MENU)
 835             ulCreateFlags |= FCF_SYSMENU;
 836         if (ulStyle & wxCAPTION)
 837             ulCreateFlags |= FCF_TASKLIST;
 838         if (ulStyle & wxCLIP_CHILDREN)
 839         {
 840             // Invalid for frame windows under PM
 841         }
 842
 843         if (ulStyle & wxTINY_CAPTION_VERT)
 844             ulCreateFlags |= FCF_TASKLIST;
 845         if (ulStyle & wxTINY_CAPTION_HORIZ)
 846             ulCreateFlags |= FCF_TASKLIST;
 847
 848         if ((ulStyle & wxTHICK_FRAME) == 0)
 849             ulCreateFlags |= FCF_BORDER;
 850         if (ulStyle & wxFRAME_TOOL_WINDOW)
 851             ulExtraFlags = kFrameToolWindow;
 852
 853         if (ulStyle & wxSTAY_ON_TOP)
 854             ulCreateFlags |= FCF_SYSMODAL;
 855     }
 856     if ((ulStyle & wxMINIMIZE) || (ulStyle & wxICONIZE))
 857         ulStyleFlags |= WS_MINIMIZED;
 858     if (ulStyle & wxMAXIMIZE)
 859         ulStyleFlags |= WS_MAXIMIZED;
 860
 861     //
 862     // Clear the visible flag, we always call show
 863     //
 864     ulStyleFlags &= (unsigned long)~WS_VISIBLE;
 865     m_bIconized = FALSE;
 866
 867     //
 868     // Set the frame control block
 869     //
 870     vFrameCtlData.cb            = sizeof(vFrameCtlData);
 871     vFrameCtlData.flCreateFlags = ulCreateFlags;
 872     vFrameCtlData.hmodResources = 0L;
 873     vFrameCtlData.idResources   = 0;
 874
 875     //
 876     // Create the frame window
 877     //
 878     if ((m_hFrame = ::WinCreateWindow( hParent               // Frame is parent
 879                                       ,WC_FRAME              // standard frame class
 880                                       ,(PSZ)zTitle           // Window title
 881                                       ,0                     // No styles
 882                                       ,0, 0, 0, 0            // Window position
 883                                       ,NULLHANDLE            // Owner
 884                                       ,HWND_TOP              // Sibling
 885                                       ,(ULONG)nId            // ID
 886                                       ,(PVOID)&vFrameCtlData // Creation data
 887                                      ,NULL                   // Window Pres Params
 888                                      )) == 0L)
 889     {
 890         return FALSE;
 891     }
 892
 893     if (!wxWindow::OS2Create( m_hFrame
 894                              ,wxFrameClassName
 895                              ,NULL
 896                              ,0L
 897                              ,0L
 898                              ,0L
 899                              ,0L
 900                              ,0L
 901                              ,NULLHANDLE
 902                              ,HWND_TOP
 903                              ,(unsigned long)FID_CLIENT
 904                              ,NULL
 905                              ,NULL
 906                             ))
 907     {
 908         return FALSE;
 909     }
 910
 911     //
 912     // Now size everything.  If adding a menu the client will need to be resized.
 913     //
 914     if (!::WinSetWindowPos( m_hFrame
 915                            ,HWND_TOP
 916                            ,nX
 917                            ,nY
 918                            ,nWidth
 919                            ,nHeight
 920                            ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE
 921                           ))
 922         return FALSE;
 923
 924     uCtlCount = SHORT1FROMMP(::WinSendMsg(m_hFrame, WM_FORMATFRAME, (MPARAM)vSwp, (MPARAM)vRect));
 925     for (int i = 0; i < uCtlCount; i++)
 926     {
 927         if (vSwp[i].hwnd == m_hFrame)
 928             memcpy(&m_vSwp, &vSwp[i], sizeof(SWP));
 929         else if (vSwp[i].hwnd == m_hVScroll)
 930             memcpy(&m_vSwpVScroll, &vSwp[i], sizeof(SWP));
 931         else if (vSwp[i].hwnd == m_hHScroll)
 932             memcpy(&m_vSwpVScroll, &vSwp[i], sizeof(SWP));
 933         else if (vSwp[i].hwnd == m_hTitleBar)
 934             memcpy(&m_vSwpTitleBar, &vSwp[i], sizeof(SWP));
 935     }
 936
 937     //
 938     // Now set the size of the client
 939     //
 940     WinSetWindowPos( hClient
 941                     ,HWND_TOP
 942                     ,SV_CXSIZEBORDER/2
 943                     ,(SV_CYSIZEBORDER/2) + m_vSwpHScroll.cy/2
 944                     ,m_vSwp.cx - ((SV_CXSIZEBORDER + 1) + m_vSwpVScroll.cx)
 945                     ,m_vSwp.cy - ((SV_CYSIZEBORDER + 1) + m_vSwpTitleBar.cy + m_vSwpHScroll.cy/2)
 946                     ,SWP_SIZE | SWP_MOVE
 947                    );
 948
 949     //
 950     // Set the client window's background, otherwise it is transparent!
 951     //
 952     return TRUE;
 953 } // end of wxFrame::OS2Create
 954
 955 //
 956 // Default activation behaviour - set the focus for the first child
 957 // subwindow found.
 958 //
 959 void wxFrame::OnActivate(
 960   wxActivateEvent&                  rEvent
 961 )
 962 {
 963     for (wxWindowList::Node* pNode = GetChildren().GetFirst();
 964          pNode;
 965          pNode = pNode->GetNext())
 966     {
 967         // FIXME all this is totally bogus - we need to do the same as wxPanel,
 968         //       but how to do it without duplicating the code?
 969
 970         // restore focus
 971         wxWindow*                   pChild = pNode->GetData();
 972
 973         if (!pChild->IsTopLevel()
 974 #if wxUSE_TOOLBAR
 975              && !wxDynamicCast(pChild, wxToolBar)
 976 #endif // wxUSE_TOOLBAR
 977 #if wxUSE_STATUSBAR
 978              && !wxDynamicCast(pChild, wxStatusBar)
 979 #endif // wxUSE_STATUSBAR
 980            )
 981         {
 982             pChild->SetFocus();
 983             return;
 984         }
 985     }
 986 } // end of wxFrame::OnActivate
 987
 988 // ----------------------------------------------------------------------------
 989 // wxFrame size management: we exclude the areas taken by menu/status/toolbars
 990 // from the client area, so the client area is what's really available for the
 991 // frame contents
 992 // ----------------------------------------------------------------------------
 993
 994 // Checks if there is a toolbar, and returns the first free client position
 995 wxPoint wxFrame::GetClientAreaOrigin() const
 996 {
 997     wxPoint                         vPoint(0, 0);
 998
 999     if (GetToolBar())
1000     {
1001         int                         nWidth;
1002         int                         nHeight;
1003
1004         GetToolBar()->GetSize( &nWidth
1005                               ,&nHeight
1006                              );
1007
1008         if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
1009         {
1010             vPoint.x += nWidth;
1011         }
1012         else
1013         {
1014             // PM is backwards from windows
1015             vPoint.y += nHeight;
1016         }
1017     }
1018     return vPoint;
1019 } // end of wxFrame::GetClientAreaOrigin
1020
1021 // ----------------------------------------------------------------------------
1022 // tool/status bar stuff
1023 // ----------------------------------------------------------------------------
1024
1025 #if wxUSE_TOOLBAR
1026
1027 wxToolBar* wxFrame::CreateToolBar(
1028   long                              lStyle
1029 , wxWindowID                        vId
1030 , const wxString&                   rName
1031 )
1032 {
1033     if (wxFrameBase::CreateToolBar( lStyle
1034                                    ,vId
1035                                    ,rName
1036                                   ))
1037     {
1038         PositionToolBar();
1039     }
1040     return m_frameToolBar;
1041 } // end of wxFrame::CreateToolBar
1042
1043 void wxFrame::PositionToolBar()
1044 {
1045     HWND                            hWndClient;
1046     RECTL                           vRect;
1047
1048     ::WinQueryWindowRect(GetHwnd(), &vRect);
1049
1050 #if wxUSE_STATUSBAR
1051     if (GetStatusBar())
1052     {
1053         int                         nStatusX;
1054         int                         nStatusY;
1055
1056         GetStatusBar()->GetClientSize( &nStatusX
1057                                       ,&nStatusY
1058                                      );
1059         // PM is backwards from windows
1060         vRect.yBottom += nStatusY;
1061     }
1062 #endif // wxUSE_STATUSBAR
1063
1064     if ( GetToolBar() )
1065     {
1066         int                         nToolbarWidth;
1067         int                         nToolbarHeight;
1068
1069         GetToolBar()->GetSize( &nToolbarWidth
1070                               ,&nToolbarHeight
1071                              );
1072
1073         if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
1074         {
1075             nToolbarHeight = vRect.yBottom;
1076         }
1077         else
1078         {
1079             nToolbarWidth = vRect.xRight;
1080         }
1081
1082         //
1083         // Use the 'real' PM position here
1084         //
1085         GetToolBar()->SetSize( 0
1086                               ,0
1087                               ,nToolbarWidth
1088                               ,nToolbarHeight
1089                               ,wxSIZE_NO_ADJUSTMENTS
1090                              );
1091     }
1092 } // end of wxFrame::PositionToolBar
1093 #endif // wxUSE_TOOLBAR
1094
1095 // ----------------------------------------------------------------------------
1096 // frame state (iconized/maximized/...)
1097 // ----------------------------------------------------------------------------
1098
1099 //
1100 // propagate our state change to all child frames: this allows us to emulate X
1101 // Windows behaviour where child frames float independently of the parent one
1102 // on the desktop, but are iconized/restored with it
1103 //
1104 void wxFrame::IconizeChildFrames(
1105   bool                              bIconize
1106 )
1107 {
1108     for (wxWindowList::Node* pNode = GetChildren().GetFirst();
1109          pNode;
1110          pNode = pNode->GetNext() )
1111     {
1112         wxWindow*                   pWin = pNode->GetData();
1113
1114         if (pWin->IsKindOf(CLASSINFO(wxFrame)) )
1115         {
1116             ((wxFrame *)pWin)->Iconize(bIconize);
1117         }
1118     }
1119 } // end of wxFrame::IconizeChildFrames
1120
1121 // ===========================================================================
1122 // message processing
1123 // ===========================================================================
1124
1125 // ---------------------------------------------------------------------------
1126 // preprocessing
1127 // ---------------------------------------------------------------------------
1128 bool wxFrame::OS2TranslateMessage(
1129   WXMSG*                            pMsg
1130 )
1131 {
1132     if (wxWindow::OS2TranslateMessage(pMsg))
1133         return TRUE;
1134     //
1135     // try the menu bar accels
1136     //
1137     wxMenuBar*                      pMenuBar = GetMenuBar();
1138
1139     if (!pMenuBar )
1140         return FALSE;
1141
1142     const wxAcceleratorTable&       rAcceleratorTable = pMenuBar->GetAccelTable();
1143     return rAcceleratorTable.Translate(this, pMsg);
1144 } // end of wxFrame::OS2TranslateMessage
1145
1146 // ---------------------------------------------------------------------------
1147 // our private (non virtual) message handlers
1148 // ---------------------------------------------------------------------------
1149 bool wxFrame::HandlePaint()
1150 {
1151     RECTL                           vRect;
1152
1153     if (::WinQueryUpdateRect(m_hFrame, &vRect))
1154     {
1155         if (m_bIconized)
1156         {
1157             //
1158             // Icons in PM are the same as "pointers"
1159             //
1160             HPOINTER                hIcon;
1161
1162             if (m_icon.Ok())
1163                 hIcon = (HPOINTER)::WinSendMsg(m_hFrame, WM_QUERYICON, 0L, 0L);
1164             else
1165                 hIcon = (HPOINTER)m_hDefaultIcon;
1166
1167             //
1168             // Hold a pointer to the dc so long as the OnPaint() message
1169             // is being processed
1170             //
1171             RECTL                   vRect2;
1172             HPS                     hPs = ::WinBeginPaint(m_hFrame, NULLHANDLE, &vRect2);
1173
1174             //
1175             // Erase background before painting or we get white background
1176             //
1177             OS2DefWindowProc(WM_ERASEBACKGROUND, (MPARAM)hPs, (MPARAM)&vRect2);
1178
1179             if (hIcon)
1180             {
1181                 HWND                            hWndClient;
1182                 RECTL                           vRect3;
1183
1184                 ::WinQueryWindowRect(GetHwnd(), &vRect3);
1185
1186                 static const int    nIconWidth = 32;
1187                 static const int    nIconHeight = 32;
1188                 int                 nIconX = (int)((vRect3.xRight - nIconWidth)/2);
1189                 int                 nIconY = (int)((vRect3.yBottom + nIconHeight)/2);
1190
1191                 ::WinDrawPointer(hPs, nIconX, nIconY, hIcon, DP_NORMAL);
1192             }
1193             ::WinEndPaint(hPs);
1194             return TRUE;
1195         }
1196         else
1197         {
1198             return wxWindow::HandlePaint();
1199         }
1200     }
1201     else
1202     {
1203         // nothing to paint - processed
1204         return TRUE;
1205     }
1206     return FALSE;
1207 } // end of wxFrame::HandlePaint
1208
1209 bool wxFrame::HandleSize(
1210   int                               nX
1211 , int                               nY
1212 , WXUINT                            nId
1213 )
1214 {
1215     bool                            bProcessed = FALSE;
1216
1217     switch (nId)
1218     {
1219         case kSizeNormal:
1220             //
1221             // Only do it it if we were iconized before, otherwise resizing the
1222             // parent frame has a curious side effect of bringing it under it's
1223             // children
1224             if (!m_bIconized )
1225                 break;
1226
1227             //
1228             // restore all child frames too
1229             //
1230             IconizeChildFrames(FALSE);
1231
1232             //
1233             // fall through
1234             //
1235
1236         case kSizeMax:
1237             m_bIconized = FALSE;
1238             break;
1239
1240         case kSizeMin:
1241             //
1242             // Iconize all child frames too
1243             //
1244             IconizeChildFrames(TRUE);
1245             m_bIconized = TRUE;
1246             break;
1247     }
1248
1249     if (!m_bIconized)
1250     {
1251         //
1252         // forward WM_SIZE to status bar control
1253         //
1254 #if wxUSE_NATIVE_STATUSBAR
1255         if (m_frameStatusBar && m_frameStatusBar->IsKindOf(CLASSINFO(wxStatusBar95)))
1256         {
1257             wxSizeEvent             vEvent( wxSize( nX
1258                                                    ,nY
1259                                                   )
1260                                            ,m_frameStatusBar->GetId()
1261                                           );
1262
1263             vEvent.SetEventObject(m_frameStatusBar);
1264             m_frameStatusBar->OnSize(vEvent);
1265         }
1266 #endif // wxUSE_NATIVE_STATUSBAR
1267
1268         PositionStatusBar();
1269         PositionToolBar();
1270         wxSizeEvent                 vEvent( wxSize( nX
1271                                                    ,nY
1272                                                   )
1273                                            ,m_windowId
1274                                           );
1275
1276         vEvent.SetEventObject(this);
1277         bProcessed = GetEventHandler()->ProcessEvent(vEvent);
1278     }
1279     return bProcessed;
1280 } // end of wxFrame::HandleSize
1281
1282 bool wxFrame::HandleCommand(
1283   WXWORD                            nId
1284 , WXWORD                            nCmd
1285 , WXHWND                            hControl
1286 )
1287 {
1288     if (hControl)
1289     {
1290         //
1291         // In case it's e.g. a toolbar.
1292         //
1293         wxWindow*                   pWin = wxFindWinFromHandle(hControl);
1294
1295         if (pWin)
1296             return pWin->OS2Command( nCmd
1297                                     ,nId
1298                                    );
1299     }
1300
1301     //
1302     // Handle here commands from menus and accelerators
1303     //
1304     if (nCmd == 0 || nCmd == 1)
1305     {
1306         if (wxCurrentPopupMenu)
1307         {
1308             wxMenu*                 pPopupMenu = wxCurrentPopupMenu;
1309
1310             wxCurrentPopupMenu = NULL;
1311
1312             return pPopupMenu->OS2Command( nCmd
1313                                           ,nId
1314                                          );
1315         }
1316
1317         if (ProcessCommand(nId))
1318         {
1319             return TRUE;
1320         }
1321     }
1322     return FALSE;
1323 } // end of wxFrame::HandleCommand
1324
1325 bool wxFrame::HandleMenuSelect(
1326   WXWORD                            nItem
1327 , WXWORD                            nFlags
1328 , WXHMENU                           hMenu
1329 )
1330 {
1331     int                             nMenuItem;
1332
1333     if (nFlags == 0xFFFF && hMenu == 0)
1334     {
1335         //
1336         // Menu was removed from screen
1337         //
1338         nMenuItem = -1;
1339     }
1340     else if (!(nFlags & MIS_SUBMENU) && !(nFlags & MIS_SEPARATOR))
1341     {
1342         nMenuItem = nItem;
1343     }
1344     else
1345     {
1346         //
1347         // Don't give hints for separators (doesn't make sense) nor for the
1348         // items opening popup menus (they don't have them anyhow)
1349         //
1350         return FALSE;
1351     }
1352     wxMenuEvent                     vEvent(wxEVT_MENU_HIGHLIGHT, nMenuItem);
1353
1354     vEvent.SetEventObject(this);
1355     return GetEventHandler()->ProcessEvent(vEvent);
1356 } // end of wxFrame::HandleMenuSelect
1357
1358 // ---------------------------------------------------------------------------
1359 // the window proc for wxFrame
1360 // ---------------------------------------------------------------------------
1361
1362 MRESULT wxFrame::OS2WindowProc(
1363   WXUINT                            uMessage
1364 , WXWPARAM                          wParam
1365 , WXLPARAM                          lParam
1366 )
1367 {
1368     MRESULT                         mRc = 0L;
1369     bool                            bProcessed = FALSE;
1370
1371     switch (uMessage)
1372     {
1373         case WM_CLOSE:
1374             //
1375             // If we can't close, tell the system that we processed the
1376             // message - otherwise it would close us
1377             //
1378             bProcessed = !Close();
1379             break;
1380
1381         case WM_COMMAND:
1382             {
1383                 WORD                wId;
1384                 WORD                wCmd;
1385                 WXHWND              hWnd;
1386
1387                 UnpackCommand( (WXWPARAM)wParam
1388                               ,(WXLPARAM)lParam
1389                               ,&wId
1390                               ,&hWnd
1391                               ,&wCmd
1392                              );
1393                 bProcessed = HandleCommand( wId
1394                                            ,wCmd
1395                                            ,(WXHWND)hWnd
1396                                           );
1397             }
1398             break;
1399
1400         case WM_MENUSELECT:
1401             {
1402                 WXWORD              wItem;
1403                 WXWORD              wFlags;
1404                 WXHMENU             hMenu;
1405
1406                 UnpackMenuSelect( wParam
1407                                  ,lParam
1408                                  ,&wItem
1409                                  ,&wFlags
1410                                  ,&hMenu
1411                                 );
1412                 bProcessed = HandleMenuSelect( wItem
1413                                               ,wFlags
1414                                               ,hMenu
1415                                              );
1416             }
1417             break;
1418
1419         case WM_PAINT:
1420             bProcessed = HandlePaint();
1421             break;
1422
1423         case WM_ERASEBACKGROUND:
1424             //
1425             // Return TRUE to request PM to paint the window background
1426             // in SYSCLR_WINDOW.
1427             //
1428             bProcessed = TRUE;
1429             mRc = (MRESULT)(TRUE);
1430             break;
1431
1432         case CM_QUERYDRAGIMAGE:
1433             {
1434                 HPOINTER                hIcon;
1435
1436                 if (m_icon.Ok())
1437                     hIcon = (HPOINTER)::WinSendMsg(m_hFrame, WM_QUERYICON, 0L, 0L);
1438                 else
1439                     hIcon = (HPOINTER)m_hDefaultIcon;
1440                 mRc = (MRESULT)hIcon;
1441                 bProcessed = mRc != 0;
1442             }
1443             break;
1444
1445         case WM_SIZE:
1446             bProcessed = HandleSize(LOWORD(lParam), HIWORD(lParam), (WXUINT)wParam);
1447             break;
1448     }
1449
1450     if (!bProcessed )
1451         mRc = wxWindow::OS2WindowProc( uMessage
1452                                       ,wParam
1453                                       ,lParam
1454                                      );
1455     return (MRESULT)0;
1456 } // wxFrame::OS2WindowProc
1457