src/os2/frame.cpp

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