src/os2/toplevel.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/toplevel.cpp
   3 // Purpose:     implements wxTopLevelWindow for MSW
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     30.12.01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
   9 // License:     wxWindows license
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "toplevel.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/app.h"
  33     #include "wx/toplevel.h"
  34     #include "wx/string.h"
  35     #include "wx/log.h"
  36     #include "wx/intl.h"
  37     #include "wx/frame.h"
  38     #include "wx/control.h"
  39 #endif //WX_PRECOMP
  40
  41 #include "wx/os2/private.h"
  42
  43 // ----------------------------------------------------------------------------
  44 // stubs for missing functions under MicroWindows
  45 // ----------------------------------------------------------------------------
  46
  47
  48 // ----------------------------------------------------------------------------
  49 // globals
  50 // ----------------------------------------------------------------------------
  51
  52 // list of all frames and modeless dialogs
  53 wxWindowList wxModelessWindows;
  54
  55 // the name of the default wxWindows class
  56 extern void          wxAssociateWinWithHandle( HWND         hWnd
  57                                               ,wxWindowOS2* pWin
  58                                              );
  59
  60 // ============================================================================
  61 // wxTopLevelWindowMSW implementation
  62 // ============================================================================
  63
  64 // Dialog window proc
  65 MRESULT EXPENTRY wxDlgProc( HWND WXUNUSED(hWnd)
  66                            ,UINT uMessage
  67                            ,MPARAM WXUNUSED(wParam)
  68                            ,MPARAM WXUNUSED(lParam)
  69                           )
  70 {
  71     if (uMessage == WM_INITDLG)
  72     {
  73         //
  74         // For this message, returning TRUE tells system to set focus to the
  75         // first control in the dialog box.
  76         //
  77         return (MRESULT)TRUE;
  78     }
  79     else
  80     {
  81         //
  82         // For all the other ones, FALSE means that we didn't process the
  83         // message
  84         //
  85         return (MRESULT)FALSE;
  86     }
  87 } // end of wxDlgProc
  88
  89 // ----------------------------------------------------------------------------
  90 // wxTopLevelWindowOS2 creation
  91 // ----------------------------------------------------------------------------
  92
  93 void wxTopLevelWindowOS2::Init()
  94 {
  95     m_bIconized = m_bMaximizeOnShow = FALSE;
  96
  97     //
  98     // Unlike (almost?) all other windows, frames are created hidden
  99     //
 100     m_isShown = FALSE;
 101
 102     //
 103     // Data to save/restore when calling ShowFullScreen
 104     m_lFsStyle          = 0;
 105     m_lFsOldWindowStyle = 0;
 106     m_bFsIsMaximized    = FALSE;
 107     m_bFsIsShowing      = FALSE;
 108
 109     m_hFrame    = NULLHANDLE;
 110     memset(&m_vSwp, 0, sizeof(SWP));
 111     memset(&m_vSwpClient, 0, sizeof(SWP));
 112 } // end of wxTopLevelWindowIOS2::Init
 113
 114 long wxTopLevelWindowOS2::OS2GetCreateWindowFlags(
 115   long*                             plExflags
 116 ) const
 117 {
 118     long                            lStyle = GetWindowStyle();
 119     long                            lMsflags = 0;
 120
 121     if (lStyle == wxDEFAULT_FRAME_STYLE)
 122         lMsflags = FCF_SIZEBORDER | FCF_TITLEBAR | FCF_SYSMENU |
 123                         FCF_MINMAX | FCF_TASKLIST;
 124     else
 125     {
 126         if ((lStyle & wxCAPTION) == wxCAPTION)
 127             lMsflags = FCF_TASKLIST;
 128         else
 129             lMsflags = FCF_NOMOVEWITHOWNER;
 130
 131         if ((lStyle & wxVSCROLL) == wxVSCROLL)
 132             lMsflags |= FCF_VERTSCROLL;
 133         if ((lStyle & wxHSCROLL) == wxHSCROLL)
 134             lMsflags |= FCF_HORZSCROLL;
 135         if (lStyle & wxMINIMIZE_BOX)
 136             lMsflags |= FCF_MINBUTTON;
 137         if (lStyle & wxMAXIMIZE_BOX)
 138             lMsflags |= FCF_MAXBUTTON;
 139         if (lStyle & wxTHICK_FRAME)
 140             lMsflags |= FCF_DLGBORDER;
 141         if (lStyle & wxSYSTEM_MENU)
 142             lMsflags |= FCF_SYSMENU;
 143         if (lStyle & wxCAPTION)
 144             lMsflags |= FCF_TASKLIST;
 145         if (lStyle & wxCLIP_CHILDREN)
 146         {
 147             // Invalid for frame windows under PM
 148         }
 149
 150         if (lStyle & wxTINY_CAPTION_VERT)
 151             lMsflags |= FCF_TASKLIST;
 152         if (lStyle & wxTINY_CAPTION_HORIZ)
 153             lMsflags |= FCF_TASKLIST;
 154
 155         if ((lStyle & wxTHICK_FRAME) == 0)
 156             lMsflags |= FCF_BORDER;
 157         if (lStyle & wxFRAME_TOOL_WINDOW)
 158             *plExflags = kFrameToolWindow;
 159
 160         if (lStyle & wxSTAY_ON_TOP)
 161             lMsflags |= FCF_SYSMODAL;
 162     }
 163     return lMsflags;
 164 } // end of wxTopLevelWindowOS2::OS2GetCreateWindowFlags
 165
 166 bool wxTopLevelWindowOS2::CreateDialog(
 167   ULONG                             ulDlgTemplate
 168 , const wxString&                   rsTitle
 169 , const wxPoint&                    rPos
 170 , const wxSize&                     rSize
 171 )
 172 {
 173     wxWindow*                       pParent = GetParent();
 174
 175     //
 176     // For the dialogs without wxDIALOG_NO_PARENT style, use the top level
 177     // app window as parent - this avoids creating modal dialogs without
 178     // parent
 179     //
 180     if (!pParent && !(GetWindowStyleFlag() & wxDIALOG_NO_PARENT))
 181     {
 182         pParent = wxTheApp->GetTopWindow();
 183
 184         if (pParent)
 185         {
 186             //
 187             // Don't use transient windows as parents, this is dangerous as it
 188             // can lead to a crash if the parent is destroyed before the child
 189             //
 190             // also don't use the window which is currently hidden as then the
 191             // dialog would be hidden as well
 192             if ((pParent->GetExtraStyle() & wxWS_EX_TRANSIENT) ||
 193                  !pParent->IsShown())
 194             {
 195                 pParent = NULL;
 196             }
 197         }
 198     }
 199
 200     HWND                            hWndDlg;
 201     HWND                            hWndOwner;
 202
 203     if (pParent)
 204         hWndOwner = GetHwndOf(pParent);
 205     else
 206         hWndOwner = HWND_DESKTOP;
 207
 208     hWndDlg = ::WinLoadDlg( HWND_DESKTOP
 209                            ,hWndOwner
 210                            ,(PFNWP)wxDlgProc
 211                            ,NULL
 212                            ,(ULONG)ulDlgTemplate
 213                            ,(PVOID)this
 214                           );
 215
 216     m_hWnd = (WXHWND) hWndDlg;
 217
 218     if ( !m_hWnd )
 219     {
 220         wxFAIL_MSG(_("Did you forget to include wx/os2/wx.rc in your resources?"));
 221
 222         wxLogSysError(_("Can't create dialog using template '%ul'"), ulDlgTemplate);
 223
 224         return FALSE;
 225     }
 226
 227     //
 228     // Move the dialog to its initial position without forcing repainting
 229     //
 230     int                             nX;
 231     int                             nY;
 232     int                             nWidth;
 233     int                             nHeight;
 234
 235     if (!OS2GetCreateWindowCoords( rPos
 236                                   ,rSize
 237                                   ,nX
 238                                   ,nY
 239                                   ,nWidth
 240                                   ,nHeight
 241                                  ))
 242     {
 243         nX = nWidth = (int)CW_USEDEFAULT;
 244     }
 245
 246     //
 247     // We can't use CW_USEDEFAULT here as we're not calling CreateWindow()
 248     // and passing CW_USEDEFAULT to MoveWindow() results in resizing the
 249     // window to (0, 0) size which breaks quite a lot of things, e.g. the
 250     // sizer calculation in wxSizer::Fit()
 251     //
 252     if (nWidth == (int)CW_USEDEFAULT)
 253     {
 254         //
 255         // The exact number doesn't matter, the dialog will be resized
 256         // again soon anyhow but it should be big enough to allow
 257         // calculation relying on "totalSize - clientSize > 0" work, i.e.
 258         // at least greater than the title bar height
 259         //
 260         nWidth = nHeight = 100;
 261     }
 262     if (nX == (int)CW_USEDEFAULT)
 263     {
 264         //
 265         // Centre it on the screen - what else can we do?
 266         //
 267         wxSize                      vSizeDpy = wxGetDisplaySize();
 268
 269         nX = (vSizeDpy.x - nWidth) / 2;
 270         nY = (vSizeDpy.y - nHeight) / 2;
 271     }
 272     ::WinSetWindowPos( GetHwnd()
 273                       ,HWND_TOP
 274                       ,nX
 275                       ,nY
 276                       ,nWidth
 277                       ,nHeight
 278                       ,SWP_MOVE | SWP_SIZE | SWP_ZORDER | SWP_SHOW
 279                      );
 280     SubclassWin(m_hWnd);
 281     return TRUE;
 282 } // end of wxTopLevelWindowOS2::CreateDialog
 283
 284 bool wxTopLevelWindowOS2::CreateFrame(
 285   const wxString&                   rsTitle
 286 , const wxPoint&                    rPos
 287 , const wxSize&                     rSize
 288 )
 289 {
 290     long                            lExflags;
 291     long                            lFlags = OS2GetCreateWindowFlags(&lExflags);
 292     long                            lStyle = GetWindowStyleFlag();
 293     int                             nX = rPos.x;
 294     int                             nY = rPos.y;
 295     int                             nWidth = rSize.x;
 296     int                             nHeight = rSize.y;
 297     ULONG                           ulStyleFlags = 0L;
 298     ERRORID                         vError;
 299     wxString                        sError;
 300     wxWindow*                       pParent = GetParent();
 301     HWND                            hParent;
 302     HWND                            hFrame;
 303     HWND                            hClient;
 304
 305     if (pParent)
 306         hParent = GetHwndOf(pParent);
 307     else
 308         hParent = HWND_DESKTOP;
 309
 310     if ((lStyle & wxMINIMIZE) || (lStyle & wxICONIZE))
 311         ulStyleFlags |= WS_MINIMIZED;
 312     if (lStyle & wxMAXIMIZE)
 313         ulStyleFlags |= WS_MAXIMIZED;
 314
 315     //
 316     // Clear the visible flag, we always call show
 317     //
 318     ulStyleFlags &= (unsigned long)~WS_VISIBLE;
 319     m_bIconized = FALSE;
 320
 321     //
 322     // Create the frame window:  We break ranks with other ports now
 323     // and instead of calling down into the base wxWindow class' OS2Create
 324     // we do all our own stuff here.  We will set the needed pieces
 325     // of wxWindow manually, here.
 326     //
 327
 328      hFrame = ::WinCreateStdWindow( hParent
 329                                    ,ulStyleFlags          // frame-window style
 330                                    ,(PULONG)&lFlags       // window style
 331                                    ,(PSZ)wxFrameClassName // class name
 332                                    ,(PSZ)rsTitle.c_str()  // window title
 333                                    ,0L                    // default client style
 334                                    ,NULLHANDLE            // resource in executable file
 335                                    ,0                     // resource id
 336                                    ,&hClient              // receives client window handle
 337                                   );
 338     if (!hFrame)
 339     {
 340         vError = ::WinGetLastError(vHabmain);
 341         sError = wxPMErrorToStr(vError);
 342         wxLogError("Error creating frame. Error: %s\n", sError);
 343         return FALSE;
 344     }
 345
 346     //
 347     // wxWindow class' m_hWnd set here and needed associations
 348     //
 349     m_hFrame = hFrame;
 350     m_hWnd   = hClient;
 351     wxAssociateWinWithHandle(m_hWnd, this);
 352     wxAssociateWinWithHandle(m_hFrame, this);
 353
 354     m_backgroundColour.Set(wxString("GREY"));
 355
 356     LONG                            lColor = (LONG)m_backgroundColour.GetPixel();
 357
 358     if (!::WinSetPresParam( m_hWnd
 359                            ,PP_BACKGROUNDCOLOR
 360                            ,sizeof(LONG)
 361                            ,(PVOID)&lColor
 362                           ))
 363     {
 364         vError = ::WinGetLastError(vHabmain);
 365         sError = wxPMErrorToStr(vError);
 366         wxLogError("Error creating frame. Error: %s\n", sError);
 367         return FALSE;
 368     }
 369
 370     //
 371     // Now need to subclass window.  Instead of calling the SubClassWin in wxWindow
 372     // we manually subclass here because we don't want to use the main wxWndProc
 373     // by default
 374     //
 375     m_fnOldWndProc = (WXFARPROC) ::WinSubclassWindow(m_hFrame, (PFNWP)wxFrameMainWndProc);
 376
 377     //
 378     // Now size everything.  If adding a menu the client will need to be resized.
 379     //
 380
 381     if (pParent)
 382     {
 383         nY = pParent->GetSize().y - (nY + nHeight);
 384     }
 385     else
 386     {
 387         RECTL                   vRect;
 388
 389         ::WinQueryWindowRect(HWND_DESKTOP, &vRect);
 390         nY = vRect.yTop - (nY + nHeight);
 391     }
 392     if (!::WinSetWindowPos( m_hFrame
 393                            ,HWND_TOP
 394                            ,nX
 395                            ,nY
 396                            ,nWidth
 397                            ,nHeight
 398                            ,SWP_SIZE | SWP_MOVE | SWP_ACTIVATE | SWP_ZORDER
 399                           ))
 400     {
 401         vError = ::WinGetLastError(vHabmain);
 402         sError = wxPMErrorToStr(vError);
 403         wxLogError("Error sizing frame. Error: %s\n", sError);
 404         return FALSE;
 405     }
 406     return TRUE;
 407 } // end of wxTopLevelWindowOS2::CreateFrame
 408
 409 bool wxTopLevelWindowOS2::Create(
 410   wxWindow*                         pParent
 411 , wxWindowID                        vId
 412 , const wxString&                   rsTitle
 413 , const wxPoint&                    rPos
 414 , const wxSize&                     rSize
 415 , long                              lStyle
 416 , const wxString&                   rsName
 417 )
 418 {
 419     //
 420     // Init our fields
 421     //
 422     Init();
 423     m_windowStyle = lStyle;
 424     SetName(rsName);
 425     m_windowId = vId == -1 ? NewControlId() : vId;
 426     wxTopLevelWindows.Append(this);
 427     if (pParent)
 428         pParent->AddChild(this);
 429
 430     if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
 431     {
 432         //
 433         // We have different dialog templates to allows creation of dialogs
 434         // with & without captions under OS2indows, resizeable or not (but a
 435         // resizeable dialog always has caption - otherwise it would look too
 436         // strange)
 437         //
 438         ULONG                       ulDlgTemplate;
 439
 440         if (lStyle & wxRESIZE_BORDER)
 441             ulDlgTemplate = (ULONG)kResizeableDialog;
 442         else if (lStyle & wxCAPTION)
 443             ulDlgTemplate = (ULONG)kCaptionDialog;
 444         else
 445             ulDlgTemplate = (ULONG)kNoCaptionDialog;
 446         return CreateDialog( ulDlgTemplate
 447                             ,rsTitle
 448                             ,rPos
 449                             ,rSize
 450                            );
 451     }
 452     else // !dialog
 453     {
 454         return CreateFrame( rsTitle
 455                            ,rPos
 456                            ,rSize
 457                           );
 458     }
 459 } // end of wxTopLevelWindowOS2::Create
 460
 461 wxTopLevelWindowOS2::~wxTopLevelWindowOS2()
 462 {
 463     wxTopLevelWindows.DeleteObject(this);
 464
 465     if (wxModelessWindows.Find(this))
 466         wxModelessWindows.DeleteObject(this);
 467
 468     //
 469     // If this is the last top-level window, exit.
 470     //
 471     if (wxTheApp && (wxTopLevelWindows.Number() == 0))
 472     {
 473         wxTheApp->SetTopWindow(NULL);
 474         if ( wxTheApp->GetExitOnFrameDelete() )
 475         {
 476             ::WinPostMsg(NULL, WM_QUIT, 0, 0);
 477         }
 478     }
 479 } // end of wxTopLevelWindowOS2::~wxTopLevelWindowOS2
 480
 481 //
 482 //  IF we have child controls in the Frame's client we need to alter
 483 //  the y position, because, OS/2 controls are positioned relative to
 484 //  wxWindows orgin (top left) not the OS/2 origin (bottom left)
 485 //
 486 void wxTopLevelWindowOS2::AlterChildPos()
 487 {
 488     //
 489     // OS/2 is the only OS concerned about this
 490     //
 491     wxWindow*                               pChild = NULL;
 492     wxControl*                              pCtrl = NULL;
 493     RECTL                                   vRect;
 494     SWP                                     vSwp;
 495
 496     ::WinQueryWindowRect(GetHwnd(), &vRect);
 497     for (wxWindowList::Node* pNode = GetChildren().GetFirst();
 498          pNode;
 499          pNode = pNode->GetNext())
 500     {
 501         wxWindow*                   pChild = pNode->GetData();
 502
 503         ::WinQueryWindowPos(pChild->GetHWND(), &vSwp);
 504         vSwp.y += (vRect.yTop - m_vSwpClient.cy);
 505         if (pChild->IsKindOf(CLASSINFO(wxControl)))
 506         {
 507             pCtrl = wxDynamicCast(pChild, wxControl);
 508             //
 509             // Must deal with controls that have margins like ENTRYFIELD.  The SWP
 510             // struct of such a control will have and origin offset from its intended
 511             // position by the width of the margins.
 512             //
 513             vSwp.y -= pCtrl->GetYComp();
 514             vSwp.x -= pCtrl->GetXComp();
 515         }
 516         ::WinSetWindowPos( pChild->GetHWND()
 517                           ,HWND_TOP
 518                           ,vSwp.x
 519                           ,vSwp.y
 520                           ,vSwp.cx
 521                           ,vSwp.cy
 522                           ,SWP_MOVE
 523                          );
 524         ::WinQueryWindowPos(pChild->GetHWND(), &vSwp);
 525         pChild = NULL;
 526     }
 527     ::WinQueryWindowPos(GetHwnd(), &m_vSwpClient);
 528 } // end of wxTopLevelWindowOS2::AlterChildPos
 529
 530 void wxTopLevelWindowOS2::UpdateInternalSize(
 531   wxWindow*                         pChild
 532 , int                               nHeight
 533 )
 534 {
 535     pChild->MoveChildren(m_vSwpClient.cy - nHeight);
 536     ::WinQueryWindowPos(GetHwnd(), &m_vSwpClient);
 537 } // end of wxTopLevelWindowOS2::UpdateInternalSize
 538
 539 // ----------------------------------------------------------------------------
 540 // wxTopLevelWindowOS2 client size
 541 // ----------------------------------------------------------------------------
 542
 543 void wxTopLevelWindowOS2::DoSetClientSize(
 544   int                               nWidth
 545 , int                               nHeight
 546 )
 547 {
 548     //
 549     // Call GetClientAreaOrigin() to take the toolbar into account
 550     //
 551     wxPoint                         vPt = GetClientAreaOrigin();
 552
 553     nWidth  += vPt.x;
 554     nHeight += vPt.y;
 555
 556     wxWindow::DoSetClientSize( nWidth
 557                               ,nHeight
 558                              );
 559 } // end of wxTopLevelWindowOS2::DoSetClientSize
 560
 561 void wxTopLevelWindowOS2::DoGetClientSize(
 562   int*                              pnX
 563 , int*                              pnY
 564 ) const
 565 {
 566     wxWindow::DoGetClientSize( pnX
 567                               ,pnY
 568                              );
 569
 570     wxPoint                         vPt = GetClientAreaOrigin();
 571
 572     if (pnX)
 573         *pnX -= vPt.x;
 574
 575     if (pnY)
 576         *pnY += vPt.y;
 577 } // end of wxTopLevelWindowOS2::DoGetClientSize
 578
 579 // ----------------------------------------------------------------------------
 580 // wxTopLevelWindowOS2 showing
 581 // ----------------------------------------------------------------------------
 582
 583 void wxTopLevelWindowOS2::DoShowWindow(
 584   int                               nShowCmd
 585 )
 586 {
 587     ::WinShowWindow(m_hFrame, (BOOL)nShowCmd);
 588     m_bIconized = nShowCmd == SWP_MINIMIZE;
 589 } // end of wxTopLevelWindowOS2::DoShowWindow
 590
 591 bool wxTopLevelWindowOS2::Show(
 592   bool                              bShow
 593 )
 594 {
 595     int                             nShowCmd;
 596     SWP                             vSwp;
 597     RECTL                           vRect;
 598
 599     if (bShow)
 600     {
 601         if (m_bMaximizeOnShow)
 602         {
 603             nShowCmd = SWP_SHOW;
 604             m_bMaximizeOnShow = FALSE;
 605         }
 606         else
 607         {
 608             nShowCmd = SWP_HIDE;
 609         }
 610     }
 611     else // hide
 612     {
 613         nShowCmd = SWP_HIDE;
 614     }
 615     DoShowWindow(nShowCmd);
 616
 617     if (bShow)
 618     {
 619         wxActivateEvent             vEvent(wxEVT_ACTIVATE, TRUE, m_windowId);
 620
 621         ::WinQueryWindowPos(m_hFrame, &vSwp);
 622         m_bIconized = vSwp.fl & SWP_MINIMIZE;
 623         ::WinQueryWindowPos(m_hWnd, &m_vSwpClient);
 624         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
 625         ::WinEnableWindow(m_hFrame, TRUE);
 626         vEvent.SetEventObject(this);
 627         GetEventHandler()->ProcessEvent(vEvent);
 628     }
 629     else
 630     {
 631         //
 632         // Try to highlight the correct window (the parent)
 633         //
 634         if (GetParent())
 635         {
 636             HWND                    hWndParent = GetHwndOf(GetParent());
 637
 638             ::WinQueryWindowPos(hWndParent, &vSwp);
 639             m_bIconized = vSwp.fl & SWP_MINIMIZE;
 640             if (hWndParent)
 641                 ::WinSetWindowPos( hWndParent
 642                                   ,HWND_TOP
 643                                   ,vSwp.x
 644                                   ,vSwp.y
 645                                   ,vSwp.cx
 646                                   ,vSwp.cy
 647                                   ,SWP_ZORDER | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE
 648                                  );
 649             ::WinEnableWindow(hWndParent, TRUE);
 650         }
 651     }
 652     return TRUE;
 653 } // end of wxTopLevelWindowOS2::Show
 654
 655 // ----------------------------------------------------------------------------
 656 // wxTopLevelWindowOS2 maximize/minimize
 657 // ----------------------------------------------------------------------------
 658
 659 void wxTopLevelWindowOS2::Maximize(
 660   bool                              bMaximize
 661 )
 662 {
 663     if (IsShown())
 664     {
 665         //
 666         // Just maximize it directly
 667         //
 668         DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);
 669     }
 670     else // hidden
 671     {
 672         //
 673         // We can't maximize the hidden frame because it shows it as well, so
 674         // just remember that we should do it later in this case
 675         //
 676         m_bMaximizeOnShow = TRUE;
 677     }
 678 } // end of wxTopLevelWindowOS2::Maximize
 679
 680 bool wxTopLevelWindowOS2::IsMaximized() const
 681 {
 682     bool                            bIconic;
 683
 684     ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
 685     return (m_vSwp.fl & SWP_MAXIMIZE);
 686 } // end of wxTopLevelWindowOS2::IsMaximized
 687
 688 void wxTopLevelWindowOS2::Iconize(
 689   bool                              bIconize
 690 )
 691 {
 692     DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
 693 } // end of wxTopLevelWindowOS2::Iconize
 694
 695 bool wxTopLevelWindowOS2::IsIconized() const
 696 {
 697     // also update the current state
 698     ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
 699     if (m_vSwp.fl & SWP_MINIMIZE)
 700         ((wxTopLevelWindow*)this)->m_bIconized = TRUE;
 701     else
 702         ((wxTopLevelWindow*)this)->m_bIconized = FALSE;
 703     return m_bIconized;
 704 } // end of wxTopLevelWindowOS2::IsIconized
 705
 706 void wxTopLevelWindowOS2::Restore()
 707 {
 708     DoShowWindow(SWP_RESTORE);
 709 } // end of wxTopLevelWindowOS2::Restore
 710
 711 // ----------------------------------------------------------------------------
 712 // wxTopLevelWindowOS2 fullscreen
 713 // ----------------------------------------------------------------------------
 714
 715 bool wxTopLevelWindowOS2::ShowFullScreen(
 716   bool                              bShow
 717 , long                              lStyle
 718 )
 719 {
 720     if (bShow)
 721     {
 722         if (IsFullScreen())
 723             return FALSE;
 724
 725         m_bFsIsShowing = TRUE;
 726         m_lFsStyle = lStyle;
 727
 728         //
 729         // Zap the frame borders
 730         //
 731
 732         //
 733         // Save the 'normal' window lStyle
 734         //
 735         m_lFsOldWindowStyle = ::WinQueryWindowULong( (HWND)GetHWND()
 736                                                     ,QWL_STYLE
 737                                                    );
 738
 739         //
 740         // Save the old position, width & height, maximize state
 741         //
 742         m_vFsOldSize = GetRect();
 743         m_bFsIsMaximized = IsMaximized();
 744
 745         //
 746         // Decide which window lStyle flags to turn off
 747         //
 748         LONG                        lNewStyle = m_lFsOldWindowStyle;
 749         LONG                        lOffFlags = 0;
 750
 751         if (lStyle & wxFULLSCREEN_NOBORDER)
 752             lOffFlags |= FCF_BORDER;
 753         if (lStyle & wxFULLSCREEN_NOCAPTION)
 754             lOffFlags |= (FCF_TASKLIST | FCF_SYSMENU);
 755
 756         lNewStyle &= (~lOffFlags);
 757
 758         //
 759         // Change our window style to be compatible with full-screen mode
 760         //
 761         ::WinSetWindowULong( (HWND)GetHWND()
 762                             ,QWL_STYLE
 763                             ,lNewStyle
 764                            );
 765
 766         //
 767         // Resize to the size of the desktop
 768         //
 769         int                         nWidth;
 770         int                         nHeight;
 771         RECTL                       vRect = wxGetWindowRect(HWND_DESKTOP);
 772
 773         nWidth = vRect.xRight - vRect.xLeft;
 774         nHeight = vRect.yTop - vRect.yBottom;
 775
 776         SetSize( nWidth
 777                 ,nHeight
 778                );
 779
 780         //
 781         // Now flush the window style cache and actually go full-screen
 782         //
 783         ::WinSetWindowPos( m_hFrame
 784                           ,HWND_TOP
 785                           ,0
 786                           ,0
 787                           ,nWidth
 788                           ,nHeight
 789                           ,SWP_SIZE | SWP_MOVE
 790                          );
 791
 792         wxSizeEvent                 vEvent( wxSize( nWidth
 793                                                    ,nHeight
 794                                                   )
 795                                            ,GetId()
 796                                           );
 797
 798         GetEventHandler()->ProcessEvent(vEvent);
 799         return TRUE;
 800     }
 801     else
 802     {
 803         if (!IsFullScreen())
 804             return FALSE;
 805
 806         m_bFsIsShowing = FALSE;
 807         Maximize(m_bFsIsMaximized);
 808         ::WinSetWindowULong( (HWND)GetHWND()
 809                             ,QWL_STYLE
 810                             ,m_lFsOldWindowStyle
 811                            );
 812         ::WinSetWindowPos( m_hFrame
 813                           ,HWND_TOP
 814                           ,m_vFsOldSize.x
 815                           ,m_vFsOldSize.y
 816                           ,m_vFsOldSize.width
 817                           ,m_vFsOldSize.height
 818                           ,SWP_SIZE | SWP_MOVE
 819                          );
 820         return TRUE;
 821     }
 822 } // end of wxTopLevelWindowOS2::ShowFullScreen
 823
 824 // ----------------------------------------------------------------------------
 825 // wxTopLevelWindowOS2 misc
 826 // ----------------------------------------------------------------------------
 827
 828 void wxTopLevelWindowOS2::SetIcon(
 829   const wxIcon&                     rIcon
 830 )
 831 {
 832     //
 833     // This sets m_icon
 834     //
 835     wxTopLevelWindowBase::SetIcon(rIcon);
 836
 837     if (m_icon.Ok())
 838     {
 839         ::WinSendMsg( m_hFrame
 840                      ,WM_SETICON
 841                      ,(MPARAM)((HPOINTER)m_icon.GetHICON())
 842                      ,NULL
 843                     );
 844         ::WinSendMsg( m_hFrame
 845                      ,WM_UPDATEFRAME
 846                      ,(MPARAM)FCF_ICON
 847                      ,(MPARAM)0
 848                     );
 849     }
 850 } // end of wxTopLevelWindowOS2::SetIcon
 851
 852 bool wxTopLevelWindowOS2::EnableCloseButton(
 853   bool                              bEnable
 854 )
 855 {
 856     //
 857     // Get system (a.k.a. window) menu
 858     //
 859     HMENU                           hMenu = ::WinWindowFromID(m_hFrame, FID_SYSMENU);
 860
 861     if (!hMenu)
 862     {
 863         wxLogLastError(_T("GetSystemMenu"));
 864         return FALSE;
 865     }
 866
 867     //
 868     // Enabling/disabling the close item from it also automatically
 869     // disables/enables the close title bar button
 870     //
 871     if (bEnable)
 872         (void)::WinSendMsg( hMenu
 873                            ,MM_SETITEMATTR
 874                            ,MPFROM2SHORT(SC_CLOSE, FALSE)
 875                            ,MPFROM2SHORT(MIA_DISABLED, FALSE)
 876                           );
 877     else
 878         (void)::WinSendMsg( hMenu
 879                            ,MM_SETITEMATTR
 880                            ,MPFROM2SHORT(SC_CLOSE, FALSE)
 881                            ,MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED)
 882                           );
 883
 884     //
 885     // Update appearance immediately
 886     //
 887     ::WinSendMsg( m_hFrame
 888                  ,WM_UPDATEFRAME
 889                  ,(MPARAM)FCF_MENU
 890                  ,(MPARAM)0
 891                 );
 892     return TRUE;
 893 } // end of wxTopLevelWindowOS2::EnableCloseButton
 894