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