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("MEDIUM 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     lStyle =  ::WinQueryWindowULong( m_hWnd
 407                                     ,QWL_STYLE
 408                                    );
 409     lStyle |= WS_CLIPCHILDREN;
 410     ::WinSetWindowULong( m_hWnd
 411                         ,QWL_STYLE
 412                         ,lStyle
 413                        );
 414     return TRUE;
 415 } // end of wxTopLevelWindowOS2::CreateFrame
 416
 417 bool wxTopLevelWindowOS2::Create(
 418   wxWindow*                         pParent
 419 , wxWindowID                        vId
 420 , const wxString&                   rsTitle
 421 , const wxPoint&                    rPos
 422 , const wxSize&                     rSize
 423 , long                              lStyle
 424 , const wxString&                   rsName
 425 )
 426 {
 427     //
 428     // Init our fields
 429     //
 430     Init();
 431     m_windowStyle = lStyle;
 432     SetName(rsName);
 433     m_windowId = vId == -1 ? NewControlId() : vId;
 434     wxTopLevelWindows.Append(this);
 435     if (pParent)
 436         pParent->AddChild(this);
 437
 438     if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
 439     {
 440         //
 441         // We have different dialog templates to allows creation of dialogs
 442         // with & without captions under OS2indows, resizeable or not (but a
 443         // resizeable dialog always has caption - otherwise it would look too
 444         // strange)
 445         //
 446         ULONG                       ulDlgTemplate;
 447
 448         if (lStyle & wxRESIZE_BORDER)
 449             ulDlgTemplate = (ULONG)kResizeableDialog;
 450         else if (lStyle & wxCAPTION)
 451             ulDlgTemplate = (ULONG)kCaptionDialog;
 452         else
 453             ulDlgTemplate = (ULONG)kNoCaptionDialog;
 454         return CreateDialog( ulDlgTemplate
 455                             ,rsTitle
 456                             ,rPos
 457                             ,rSize
 458                            );
 459     }
 460     else // !dialog
 461     {
 462         return CreateFrame( rsTitle
 463                            ,rPos
 464                            ,rSize
 465                           );
 466     }
 467 } // end of wxTopLevelWindowOS2::Create
 468
 469 wxTopLevelWindowOS2::~wxTopLevelWindowOS2()
 470 {
 471     wxTopLevelWindows.DeleteObject(this);
 472
 473     if (wxModelessWindows.Find(this))
 474         wxModelessWindows.DeleteObject(this);
 475
 476     //
 477     // If this is the last top-level window, exit.
 478     //
 479     if (wxTheApp && (wxTopLevelWindows.Number() == 0))
 480     {
 481         wxTheApp->SetTopWindow(NULL);
 482         if ( wxTheApp->GetExitOnFrameDelete() )
 483         {
 484             ::WinPostMsg(NULL, WM_QUIT, 0, 0);
 485         }
 486     }
 487 } // end of wxTopLevelWindowOS2::~wxTopLevelWindowOS2
 488
 489 //
 490 //  IF we have child controls in the Frame's client we need to alter
 491 //  the y position, because, OS/2 controls are positioned relative to
 492 //  wxWindows orgin (top left) not the OS/2 origin (bottom left)
 493 //
 494 void wxTopLevelWindowOS2::AlterChildPos()
 495 {
 496     //
 497     // OS/2 is the only OS concerned about this
 498     //
 499     wxWindow*                               pChild = NULL;
 500     wxControl*                              pCtrl = NULL;
 501     RECTL                                   vRect;
 502     SWP                                     vSwp;
 503
 504     ::WinQueryWindowRect(GetHwnd(), &vRect);
 505     for (wxWindowList::Node* pNode = GetChildren().GetFirst();
 506          pNode;
 507          pNode = pNode->GetNext())
 508     {
 509         wxWindow*                   pChild = pNode->GetData();
 510
 511         ::WinQueryWindowPos(pChild->GetHWND(), &vSwp);
 512         vSwp.y += (vRect.yTop - m_vSwpClient.cy);
 513         if (pChild->IsKindOf(CLASSINFO(wxControl)))
 514         {
 515             pCtrl = wxDynamicCast(pChild, wxControl);
 516             //
 517             // Must deal with controls that have margins like ENTRYFIELD.  The SWP
 518             // struct of such a control will have and origin offset from its intended
 519             // position by the width of the margins.
 520             //
 521             vSwp.y -= pCtrl->GetYComp();
 522             vSwp.x -= pCtrl->GetXComp();
 523         }
 524         ::WinSetWindowPos( pChild->GetHWND()
 525                           ,HWND_TOP
 526                           ,vSwp.x
 527                           ,vSwp.y
 528                           ,vSwp.cx
 529                           ,vSwp.cy
 530                           ,SWP_MOVE
 531                          );
 532         ::WinQueryWindowPos(pChild->GetHWND(), &vSwp);
 533         pChild = NULL;
 534     }
 535     ::WinQueryWindowPos(GetHwnd(), &m_vSwpClient);
 536 } // end of wxTopLevelWindowOS2::AlterChildPos
 537
 538 void wxTopLevelWindowOS2::UpdateInternalSize(
 539   wxWindow*                         pChild
 540 , int                               nHeight
 541 )
 542 {
 543     pChild->MoveChildren(m_vSwpClient.cy - nHeight);
 544     ::WinQueryWindowPos(GetHwnd(), &m_vSwpClient);
 545 } // end of wxTopLevelWindowOS2::UpdateInternalSize
 546
 547 // ----------------------------------------------------------------------------
 548 // wxTopLevelWindowOS2 client size
 549 // ----------------------------------------------------------------------------
 550
 551 void wxTopLevelWindowOS2::DoSetClientSize(
 552   int                               nWidth
 553 , int                               nHeight
 554 )
 555 {
 556     //
 557     // Call GetClientAreaOrigin() to take the toolbar into account
 558     //
 559     wxPoint                         vPt = GetClientAreaOrigin();
 560
 561     nWidth  += vPt.x;
 562     nHeight += vPt.y;
 563
 564     wxWindow::DoSetClientSize( nWidth
 565                               ,nHeight
 566                              );
 567 } // end of wxTopLevelWindowOS2::DoSetClientSize
 568
 569 void wxTopLevelWindowOS2::DoGetClientSize(
 570   int*                              pnX
 571 , int*                              pnY
 572 ) const
 573 {
 574     wxWindow::DoGetClientSize( pnX
 575                               ,pnY
 576                              );
 577
 578     wxPoint                         vPt = GetClientAreaOrigin();
 579
 580     if (pnX)
 581         *pnX -= vPt.x;
 582
 583     if (pnY)
 584         *pnY += vPt.y;
 585 } // end of wxTopLevelWindowOS2::DoGetClientSize
 586
 587 // ----------------------------------------------------------------------------
 588 // wxTopLevelWindowOS2 showing
 589 // ----------------------------------------------------------------------------
 590
 591 void wxTopLevelWindowOS2::DoShowWindow(
 592   int                               nShowCmd
 593 )
 594 {
 595     ::WinShowWindow(m_hFrame, (BOOL)(nShowCmd & SWP_SHOW));
 596     m_bIconized = nShowCmd == SWP_MINIMIZE;
 597 } // end of wxTopLevelWindowOS2::DoShowWindow
 598
 599 bool wxTopLevelWindowOS2::Show(
 600   bool                              bShow
 601 )
 602 {
 603     int                             nShowCmd;
 604     SWP                             vSwp;
 605     RECTL                           vRect;
 606
 607     if (bShow)
 608     {
 609         if (m_bMaximizeOnShow)
 610         {
 611             nShowCmd = SWP_MAXIMIZE;
 612             m_bMaximizeOnShow = FALSE;
 613         }
 614         else
 615         {
 616             nShowCmd = SWP_SHOW;
 617         }
 618     }
 619     else // hide
 620     {
 621         nShowCmd = SWP_HIDE;
 622     }
 623     DoShowWindow(nShowCmd);
 624
 625     if (bShow)
 626     {
 627         wxActivateEvent             vEvent(wxEVT_ACTIVATE, TRUE, m_windowId);
 628
 629         ::WinQueryWindowPos(m_hFrame, &vSwp);
 630         m_bIconized = vSwp.fl & SWP_MINIMIZE;
 631         ::WinQueryWindowPos(m_hWnd, &m_vSwpClient);
 632         ::WinSendMsg(m_hFrame, WM_UPDATEFRAME, (MPARAM)~0, 0);
 633         ::WinEnableWindow(m_hFrame, TRUE);
 634         vEvent.SetEventObject(this);
 635         GetEventHandler()->ProcessEvent(vEvent);
 636     }
 637     else
 638     {
 639         //
 640         // Try to highlight the correct window (the parent)
 641         //
 642         if (GetParent())
 643         {
 644             HWND                    hWndParent = GetHwndOf(GetParent());
 645
 646             ::WinQueryWindowPos(hWndParent, &vSwp);
 647             m_bIconized = vSwp.fl & SWP_MINIMIZE;
 648             if (hWndParent)
 649                 ::WinSetWindowPos( hWndParent
 650                                   ,HWND_TOP
 651                                   ,vSwp.x
 652                                   ,vSwp.y
 653                                   ,vSwp.cx
 654                                   ,vSwp.cy
 655                                   ,SWP_ZORDER | SWP_ACTIVATE | SWP_SHOW | SWP_MOVE
 656                                  );
 657             ::WinEnableWindow(hWndParent, TRUE);
 658         }
 659     }
 660     return TRUE;
 661 } // end of wxTopLevelWindowOS2::Show
 662
 663 // ----------------------------------------------------------------------------
 664 // wxTopLevelWindowOS2 maximize/minimize
 665 // ----------------------------------------------------------------------------
 666
 667 void wxTopLevelWindowOS2::Maximize(
 668   bool                              bMaximize
 669 )
 670 {
 671     if (IsShown())
 672     {
 673         //
 674         // Just maximize it directly
 675         //
 676         DoShowWindow(bMaximize ? SWP_MAXIMIZE : SWP_RESTORE);
 677     }
 678     else // hidden
 679     {
 680         //
 681         // We can't maximize the hidden frame because it shows it as well, so
 682         // just remember that we should do it later in this case
 683         //
 684         m_bMaximizeOnShow = TRUE;
 685     }
 686 } // end of wxTopLevelWindowOS2::Maximize
 687
 688 bool wxTopLevelWindowOS2::IsMaximized() const
 689 {
 690     bool                            bIconic;
 691
 692     ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
 693     return (m_vSwp.fl & SWP_MAXIMIZE);
 694 } // end of wxTopLevelWindowOS2::IsMaximized
 695
 696 void wxTopLevelWindowOS2::Iconize(
 697   bool                              bIconize
 698 )
 699 {
 700     DoShowWindow(bIconize ? SWP_MINIMIZE : SWP_RESTORE);
 701 } // end of wxTopLevelWindowOS2::Iconize
 702
 703 bool wxTopLevelWindowOS2::IsIconized() const
 704 {
 705     // also update the current state
 706     ::WinQueryWindowPos(m_hFrame, (PSWP)&m_vSwp);
 707     if (m_vSwp.fl & SWP_MINIMIZE)
 708         ((wxTopLevelWindow*)this)->m_bIconized = TRUE;
 709     else
 710         ((wxTopLevelWindow*)this)->m_bIconized = FALSE;
 711     return m_bIconized;
 712 } // end of wxTopLevelWindowOS2::IsIconized
 713
 714 void wxTopLevelWindowOS2::Restore()
 715 {
 716     DoShowWindow(SWP_RESTORE);
 717 } // end of wxTopLevelWindowOS2::Restore
 718
 719 // ----------------------------------------------------------------------------
 720 // wxTopLevelWindowOS2 fullscreen
 721 // ----------------------------------------------------------------------------
 722
 723 bool wxTopLevelWindowOS2::ShowFullScreen(
 724   bool                              bShow
 725 , long                              lStyle
 726 )
 727 {
 728     if (bShow)
 729     {
 730         if (IsFullScreen())
 731             return FALSE;
 732
 733         m_bFsIsShowing = TRUE;
 734         m_lFsStyle = lStyle;
 735
 736         //
 737         // Zap the frame borders
 738         //
 739
 740         //
 741         // Save the 'normal' window lStyle
 742         //
 743         m_lFsOldWindowStyle = ::WinQueryWindowULong( (HWND)GetHWND()
 744                                                     ,QWL_STYLE
 745                                                    );
 746
 747         //
 748         // Save the old position, width & height, maximize state
 749         //
 750         m_vFsOldSize = GetRect();
 751         m_bFsIsMaximized = IsMaximized();
 752
 753         //
 754         // Decide which window lStyle flags to turn off
 755         //
 756         LONG                        lNewStyle = m_lFsOldWindowStyle;
 757         LONG                        lOffFlags = 0;
 758
 759         if (lStyle & wxFULLSCREEN_NOBORDER)
 760             lOffFlags |= FCF_BORDER;
 761         if (lStyle & wxFULLSCREEN_NOCAPTION)
 762             lOffFlags |= (FCF_TASKLIST | FCF_SYSMENU);
 763
 764         lNewStyle &= (~lOffFlags);
 765
 766         //
 767         // Change our window style to be compatible with full-screen mode
 768         //
 769         ::WinSetWindowULong( (HWND)GetHWND()
 770                             ,QWL_STYLE
 771                             ,lNewStyle
 772                            );
 773
 774         //
 775         // Resize to the size of the desktop
 776         //
 777         int                         nWidth;
 778         int                         nHeight;
 779         RECTL                       vRect = wxGetWindowRect(HWND_DESKTOP);
 780
 781         nWidth = vRect.xRight - vRect.xLeft;
 782         nHeight = vRect.yTop - vRect.yBottom;
 783
 784         SetSize( nWidth
 785                 ,nHeight
 786                );
 787
 788         //
 789         // Now flush the window style cache and actually go full-screen
 790         //
 791         ::WinSetWindowPos( m_hFrame
 792                           ,HWND_TOP
 793                           ,0
 794                           ,0
 795                           ,nWidth
 796                           ,nHeight
 797                           ,SWP_SIZE | SWP_MOVE
 798                          );
 799
 800         wxSizeEvent                 vEvent( wxSize( nWidth
 801                                                    ,nHeight
 802                                                   )
 803                                            ,GetId()
 804                                           );
 805
 806         GetEventHandler()->ProcessEvent(vEvent);
 807         return TRUE;
 808     }
 809     else
 810     {
 811         if (!IsFullScreen())
 812             return FALSE;
 813
 814         m_bFsIsShowing = FALSE;
 815         Maximize(m_bFsIsMaximized);
 816         ::WinSetWindowULong( (HWND)GetHWND()
 817                             ,QWL_STYLE
 818                             ,m_lFsOldWindowStyle
 819                            );
 820         ::WinSetWindowPos( m_hFrame
 821                           ,HWND_TOP
 822                           ,m_vFsOldSize.x
 823                           ,m_vFsOldSize.y
 824                           ,m_vFsOldSize.width
 825                           ,m_vFsOldSize.height
 826                           ,SWP_SIZE | SWP_MOVE
 827                          );
 828         return TRUE;
 829     }
 830 } // end of wxTopLevelWindowOS2::ShowFullScreen
 831
 832 // ----------------------------------------------------------------------------
 833 // wxTopLevelWindowOS2 misc
 834 // ----------------------------------------------------------------------------
 835
 836 void wxTopLevelWindowOS2::SetIcon(
 837   const wxIcon&                     rIcon
 838 )
 839 {
 840     //
 841     // This sets m_icon
 842     //
 843     wxTopLevelWindowBase::SetIcon(rIcon);
 844
 845     if (m_icon.Ok())
 846     {
 847         ::WinSendMsg( m_hFrame
 848                      ,WM_SETICON
 849                      ,(MPARAM)((HPOINTER)m_icon.GetHICON())
 850                      ,NULL
 851                     );
 852         ::WinSendMsg( m_hFrame
 853                      ,WM_UPDATEFRAME
 854                      ,(MPARAM)FCF_ICON
 855                      ,(MPARAM)0
 856                     );
 857     }
 858 } // end of wxTopLevelWindowOS2::SetIcon
 859
 860 bool wxTopLevelWindowOS2::EnableCloseButton(
 861   bool                              bEnable
 862 )
 863 {
 864     //
 865     // Get system (a.k.a. window) menu
 866     //
 867     HMENU                           hMenu = ::WinWindowFromID(m_hFrame, FID_SYSMENU);
 868
 869     if (!hMenu)
 870     {
 871         wxLogLastError(_T("GetSystemMenu"));
 872         return FALSE;
 873     }
 874
 875     //
 876     // Enabling/disabling the close item from it also automatically
 877     // disables/enables the close title bar button
 878     //
 879     if (bEnable)
 880         (void)::WinSendMsg( hMenu
 881                            ,MM_SETITEMATTR
 882                            ,MPFROM2SHORT(SC_CLOSE, FALSE)
 883                            ,MPFROM2SHORT(MIA_DISABLED, FALSE)
 884                           );
 885     else
 886         (void)::WinSendMsg( hMenu
 887                            ,MM_SETITEMATTR
 888                            ,MPFROM2SHORT(SC_CLOSE, FALSE)
 889                            ,MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED)
 890                           );
 891
 892     //
 893     // Update appearance immediately
 894     //
 895     ::WinSendMsg( m_hFrame
 896                  ,WM_UPDATEFRAME
 897                  ,(MPARAM)FCF_MENU
 898                  ,(MPARAM)0
 899                 );
 900     return TRUE;
 901 } // end of wxTopLevelWindowOS2::EnableCloseButton
 902