src/univ/topluniv.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        topluniv.cpp
   3 // Author:      Vaclav Slavik
   4 // Id:          $Id$
   5 // Copyright:   (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com)
   6 // Licence:     wxWindows licence
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 // ============================================================================
  10 // declarations
  11 // ============================================================================
  12
  13 // ----------------------------------------------------------------------------
  14 // headers
  15 // ----------------------------------------------------------------------------
  16
  17 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  18     #pragma implementation "univtoplevel.h"
  19 #endif
  20
  21 // For compilers that support precompilation, includes "wx.h".
  22 #include "wx/wxprec.h"
  23
  24 #ifdef __BORLANDC__
  25 #pragma hdrstop
  26 #endif
  27
  28 #include "wx/defs.h"
  29
  30 #ifndef WX_PRECOMP
  31     #include "wx/dcclient.h"
  32     #include "wx/settings.h"
  33 #endif
  34
  35 #include "wx/toplevel.h"
  36 #include "wx/univ/renderer.h"
  37 #include "wx/bitmap.h"
  38 #include "wx/image.h"
  39 #include "wx/cshelp.h"
  40 #include "wx/evtloop.h"
  41
  42
  43 // ----------------------------------------------------------------------------
  44 // event tables
  45 // ----------------------------------------------------------------------------
  46
  47 BEGIN_EVENT_TABLE(wxTopLevelWindow, wxTopLevelWindowNative)
  48     WX_EVENT_TABLE_INPUT_CONSUMER(wxTopLevelWindow)
  49     EVT_NC_PAINT(wxTopLevelWindow::OnNcPaint)
  50     EVT_MENU_RANGE(wxID_CLOSE_FRAME, wxID_RESTORE_FRAME, wxTopLevelWindow::OnSystemMenu)
  51 END_EVENT_TABLE()
  52
  53 WX_FORWARD_TO_INPUT_CONSUMER(wxTopLevelWindow)
  54
  55 // ============================================================================
  56 // implementation
  57 // ============================================================================
  58
  59 int wxTopLevelWindow::ms_drawDecorations = -1;
  60 int wxTopLevelWindow::ms_canIconize = -1;
  61
  62 void wxTopLevelWindow::Init()
  63 {
  64     m_isActive = false;
  65     m_windowStyle = 0;
  66     m_pressedButton = 0;
  67 }
  68
  69 bool wxTopLevelWindow::Create(wxWindow *parent,
  70                               wxWindowID id,
  71                               const wxString& title,
  72                               const wxPoint& pos,
  73                               const wxSize& size,
  74                               long style,
  75                               const wxString &name)
  76 {
  77     // init them to avoid compiler warnings
  78     long styleOrig = 0,
  79          exstyleOrig = 0;
  80
  81     if ( ms_drawDecorations == -1 )
  82     {
  83         ms_drawDecorations =
  84             !wxSystemSettings::HasFeature(wxSYS_CAN_DRAW_FRAME_DECORATIONS)
  85             || wxGetEnv(wxT("WXDECOR"), NULL);
  86         // FIXME -- wxUniv should provide a way to force non-native decorations!
  87         //          $WXDECOR is just a hack in absence of better wxUniv solution
  88     }
  89
  90     if ( ms_canIconize == -1 )
  91     {
  92         ms_canIconize = wxSystemSettings::HasFeature(wxSYS_CAN_ICONIZE_FRAME);
  93     }
  94
  95     if ( ms_drawDecorations )
  96     {
  97         CreateInputHandler(wxINP_HANDLER_TOPLEVEL);
  98
  99         styleOrig = style;
 100         exstyleOrig = GetExtraStyle();
 101         style &= ~(wxCAPTION | wxMINIMIZE_BOX | wxMAXIMIZE_BOX |
 102                    wxSYSTEM_MENU | wxRESIZE_BORDER | wxFRAME_TOOL_WINDOW |
 103                    wxTHICK_FRAME);
 104         style |= wxSIMPLE_BORDER;
 105         SetExtraStyle(exstyleOrig &
 106                       ~(wxFRAME_EX_CONTEXTHELP | wxDIALOG_EX_CONTEXTHELP));
 107     }
 108
 109     if ( !wxTopLevelWindowNative::Create(parent, id, title, pos,
 110                                          size, style, name) )
 111         return false;
 112
 113     if ( ms_drawDecorations )
 114     {
 115         m_windowStyle = styleOrig;
 116         m_exStyle = exstyleOrig;
 117     }
 118
 119     return true;
 120 }
 121
 122 bool wxTopLevelWindow::ShowFullScreen(bool show, long style)
 123 {
 124     if ( show == IsFullScreen() ) return false;
 125
 126     if ( ms_drawDecorations )
 127     {
 128         if ( show )
 129         {
 130             m_fsSavedStyle = m_windowStyle;
 131             if ( style & wxFULLSCREEN_NOBORDER )
 132                 m_windowStyle |= wxSIMPLE_BORDER;
 133             if ( style & wxFULLSCREEN_NOCAPTION )
 134                 m_windowStyle &= ~wxCAPTION;
 135         }
 136         else
 137         {
 138             m_windowStyle = m_fsSavedStyle;
 139         }
 140     }
 141
 142     return wxTopLevelWindowNative::ShowFullScreen(show, style);
 143 }
 144
 145 long wxTopLevelWindow::GetDecorationsStyle() const
 146 {
 147     long style = 0;
 148
 149     if ( m_windowStyle & wxCAPTION )
 150     {
 151         style |= wxTOPLEVEL_TITLEBAR | wxTOPLEVEL_BUTTON_CLOSE;
 152         if ( (m_windowStyle & wxMINIMIZE_BOX) && ms_canIconize )
 153             style |= wxTOPLEVEL_BUTTON_ICONIZE;
 154         if ( m_windowStyle & wxMAXIMIZE_BOX )
 155         {
 156             if ( IsMaximized() )
 157                 style |= wxTOPLEVEL_BUTTON_RESTORE;
 158             else
 159                 style |= wxTOPLEVEL_BUTTON_MAXIMIZE;
 160         }
 161 #if wxUSE_HELP
 162         if ( m_exStyle & (wxFRAME_EX_CONTEXTHELP | wxDIALOG_EX_CONTEXTHELP))
 163             style |= wxTOPLEVEL_BUTTON_HELP;
 164 #endif
 165     }
 166     if ( (m_windowStyle & (wxSIMPLE_BORDER | wxNO_BORDER)) == 0 )
 167         style |= wxTOPLEVEL_BORDER;
 168     if ( m_windowStyle & (wxRESIZE_BORDER | wxTHICK_FRAME) )
 169         style |= wxTOPLEVEL_RESIZEABLE;
 170
 171     if ( IsMaximized() )
 172         style |= wxTOPLEVEL_MAXIMIZED;
 173     if ( GetIcon().Ok() )
 174         style |= wxTOPLEVEL_ICON;
 175     if ( m_isActive )
 176         style |= wxTOPLEVEL_ACTIVE;
 177
 178     return style;
 179 }
 180
 181 void wxTopLevelWindow::RefreshTitleBar()
 182 {
 183     wxNcPaintEvent event(GetId());
 184     event.SetEventObject(this);
 185     GetEventHandler()->ProcessEvent(event);
 186 }
 187
 188 // ----------------------------------------------------------------------------
 189 // client area handling
 190 // ----------------------------------------------------------------------------
 191
 192 wxPoint wxTopLevelWindow::GetClientAreaOrigin() const
 193 {
 194     if ( ms_drawDecorations )
 195     {
 196         int w, h;
 197         wxTopLevelWindowNative::DoGetClientSize(&w, &h);
 198         wxRect rect = wxRect(wxTopLevelWindowNative::GetClientAreaOrigin(),
 199                              wxSize(w, h));
 200         rect = m_renderer->GetFrameClientArea(rect,
 201                                               GetDecorationsStyle());
 202         return rect.GetPosition();
 203     }
 204     else
 205     {
 206         return wxTopLevelWindowNative::GetClientAreaOrigin();
 207     }
 208 }
 209
 210 void wxTopLevelWindow::DoGetClientSize(int *width, int *height) const
 211 {
 212     if ( ms_drawDecorations )
 213     {
 214         int w, h;
 215         wxTopLevelWindowNative::DoGetClientSize(&w, &h);
 216         wxRect rect = wxRect(wxTopLevelWindowNative::GetClientAreaOrigin(),
 217                              wxSize(w, h));
 218         rect = m_renderer->GetFrameClientArea(rect,
 219                                               GetDecorationsStyle());
 220         if ( width )
 221             *width = rect.width;
 222         if ( height )
 223             *height = rect.height;
 224     }
 225     else
 226         wxTopLevelWindowNative::DoGetClientSize(width, height);
 227 }
 228
 229 void wxTopLevelWindow::DoSetClientSize(int width, int height)
 230 {
 231     if ( ms_drawDecorations )
 232     {
 233         wxSize size = m_renderer->GetFrameTotalSize(wxSize(width, height),
 234                                                GetDecorationsStyle());
 235         wxTopLevelWindowNative::DoSetClientSize(size.x, size.y);
 236     }
 237     else
 238         wxTopLevelWindowNative::DoSetClientSize(width, height);
 239 }
 240
 241 void wxTopLevelWindow::OnNcPaint(wxNcPaintEvent& event)
 242 {
 243     if ( !ms_drawDecorations || !m_renderer )
 244         event.Skip();
 245     else
 246     {
 247         // get the window rect
 248         wxRect rect;
 249         wxSize size = GetSize();
 250         rect.x =
 251         rect.y = 0;
 252         rect.width = size.x;
 253         rect.height = size.y;
 254
 255         wxWindowDC dc(this);
 256         m_renderer->DrawFrameTitleBar(dc, rect,
 257                                       GetTitle(), m_titlebarIcon,
 258                                       GetDecorationsStyle(),
 259                                       m_pressedButton,
 260                                       wxCONTROL_PRESSED);
 261     }
 262 }
 263
 264 long wxTopLevelWindow::HitTest(const wxPoint& pt) const
 265 {
 266     int w, h;
 267     wxTopLevelWindowNative::DoGetClientSize(&w, &h);
 268     wxRect rect(wxTopLevelWindowNative::GetClientAreaOrigin(), wxSize(w, h));
 269
 270     return m_renderer->HitTestFrame(rect, pt+GetClientAreaOrigin(), GetDecorationsStyle());
 271 }
 272
 273 int wxTopLevelWindow::GetMinWidth() const
 274 {
 275     if ( ms_drawDecorations )
 276     {
 277         return wxMax(wxTopLevelWindowNative::GetMinWidth(),
 278                      m_renderer->GetFrameMinSize(GetDecorationsStyle()).x);
 279     }
 280     else
 281         return wxTopLevelWindowNative::GetMinWidth();
 282 }
 283
 284 int wxTopLevelWindow::GetMinHeight() const
 285 {
 286     if ( ms_drawDecorations )
 287     {
 288         return wxMax(wxTopLevelWindowNative::GetMinHeight(),
 289                      m_renderer->GetFrameMinSize(GetDecorationsStyle()).y);
 290     }
 291     else
 292         return wxTopLevelWindowNative::GetMinHeight();
 293 }
 294
 295 // ----------------------------------------------------------------------------
 296 // icons
 297 // ----------------------------------------------------------------------------
 298
 299 void wxTopLevelWindow::SetIcons(const wxIconBundle& icons)
 300 {
 301     wxTopLevelWindowNative::SetIcons(icons);
 302
 303     if ( ms_drawDecorations && m_renderer )
 304     {
 305         wxSize size = m_renderer->GetFrameIconSize();
 306         const wxIcon& icon = icons.GetIcon( size );
 307
 308         if ( !icon.Ok() || size.x == wxDefaultCoord  )
 309             m_titlebarIcon = icon;
 310         else
 311         {
 312             wxBitmap bmp1;
 313             bmp1.CopyFromIcon(icon);
 314             if ( !bmp1.Ok() )
 315                 m_titlebarIcon = wxNullIcon;
 316             else if ( bmp1.GetWidth() == size.x && bmp1.GetHeight() == size.y )
 317                 m_titlebarIcon = icon;
 318             else
 319             {
 320                 wxImage img = bmp1.ConvertToImage();
 321                 img.Rescale(size.x, size.y);
 322                 m_titlebarIcon.CopyFromBitmap(wxBitmap(img));
 323             }
 324         }
 325     }
 326 }
 327
 328 // ----------------------------------------------------------------------------
 329 // interactive manipulation
 330 // ----------------------------------------------------------------------------
 331
 332
 333 static bool wxGetResizingCursor(long hitTestResult, wxCursor& cursor)
 334 {
 335     if ( hitTestResult & wxHT_TOPLEVEL_ANY_BORDER )
 336     {
 337         switch (hitTestResult)
 338         {
 339             case wxHT_TOPLEVEL_BORDER_N:
 340             case wxHT_TOPLEVEL_BORDER_S:
 341                 cursor = wxCursor(wxCURSOR_SIZENS);
 342                 break;
 343             case wxHT_TOPLEVEL_BORDER_W:
 344             case wxHT_TOPLEVEL_BORDER_E:
 345                 cursor = wxCursor(wxCURSOR_SIZEWE);
 346                 break;
 347             case wxHT_TOPLEVEL_BORDER_NE:
 348             case wxHT_TOPLEVEL_BORDER_SW:
 349                 cursor = wxCursor(wxCURSOR_SIZENESW);
 350                 break;
 351             case wxHT_TOPLEVEL_BORDER_NW:
 352             case wxHT_TOPLEVEL_BORDER_SE:
 353                 cursor = wxCursor(wxCURSOR_SIZENWSE);
 354                 break;
 355             default:
 356                 return false;
 357                 #if 0
 358                 // not rachable due to earlier return
 359                 break;
 360                 #endif
 361         }
 362         return true;
 363     }
 364
 365     return false;
 366 }
 367
 368 #define wxINTERACTIVE_RESIZE_DIR \
 369           (wxINTERACTIVE_RESIZE_W | wxINTERACTIVE_RESIZE_E | \
 370            wxINTERACTIVE_RESIZE_S | wxINTERACTIVE_RESIZE_N)
 371
 372 struct wxInteractiveMoveData
 373 {
 374     wxTopLevelWindow     *m_window;
 375     wxEventLoop          *m_evtLoop;
 376     int                   m_flags;
 377     wxRect                m_rect;
 378     wxRect                m_rectOrig;
 379     wxPoint               m_pos;
 380     wxSize                m_minSize, m_maxSize;
 381     bool                  m_sizingCursor;
 382 };
 383
 384 class wxInteractiveMoveHandler : public wxEvtHandler
 385 {
 386 public:
 387     wxInteractiveMoveHandler(wxInteractiveMoveData& data) : m_data(data) {}
 388
 389 private:
 390     DECLARE_EVENT_TABLE()
 391     void OnMouseMove(wxMouseEvent& event);
 392     void OnMouseDown(wxMouseEvent& event);
 393     void OnMouseUp(wxMouseEvent& event);
 394     void OnKeyDown(wxKeyEvent& event);
 395
 396     wxInteractiveMoveData& m_data;
 397 };
 398
 399 BEGIN_EVENT_TABLE(wxInteractiveMoveHandler, wxEvtHandler)
 400     EVT_MOTION(wxInteractiveMoveHandler::OnMouseMove)
 401     EVT_LEFT_DOWN(wxInteractiveMoveHandler::OnMouseDown)
 402     EVT_LEFT_UP(wxInteractiveMoveHandler::OnMouseUp)
 403     EVT_KEY_DOWN(wxInteractiveMoveHandler::OnKeyDown)
 404 END_EVENT_TABLE()
 405
 406
 407 static inline LINKAGEMODE
 408 void wxApplyResize(wxInteractiveMoveData& data, const wxPoint& diff)
 409 {
 410     if ( data.m_flags & wxINTERACTIVE_RESIZE_W )
 411     {
 412         data.m_rect.x += diff.x;
 413         data.m_rect.width -= diff.x;
 414     }
 415     else if ( data.m_flags & wxINTERACTIVE_RESIZE_E )
 416     {
 417         data.m_rect.width += diff.x;
 418     }
 419     if ( data.m_flags & wxINTERACTIVE_RESIZE_N )
 420     {
 421         data.m_rect.y += diff.y;
 422         data.m_rect.height -= diff.y;
 423     }
 424     else if ( data.m_flags & wxINTERACTIVE_RESIZE_S )
 425     {
 426         data.m_rect.height += diff.y;
 427     }
 428
 429     if ( data.m_minSize.x != wxDefaultCoord && data.m_rect.width < data.m_minSize.x )
 430     {
 431         if ( data.m_flags & wxINTERACTIVE_RESIZE_W )
 432             data.m_rect.x -= data.m_minSize.x - data.m_rect.width;
 433         data.m_rect.width = data.m_minSize.x;
 434     }
 435     if ( data.m_maxSize.x != wxDefaultCoord && data.m_rect.width > data.m_maxSize.x )
 436     {
 437         if ( data.m_flags & wxINTERACTIVE_RESIZE_W )
 438             data.m_rect.x -= data.m_minSize.x - data.m_rect.width;
 439         data.m_rect.width = data.m_maxSize.x;
 440     }
 441     if ( data.m_minSize.y != wxDefaultCoord && data.m_rect.height < data.m_minSize.y )
 442     {
 443         if ( data.m_flags & wxINTERACTIVE_RESIZE_N )
 444             data.m_rect.y -= data.m_minSize.y - data.m_rect.height;
 445         data.m_rect.height = data.m_minSize.y;
 446     }
 447     if ( data.m_maxSize.y != wxDefaultCoord && data.m_rect.height > data.m_maxSize.y )
 448     {
 449         if ( data.m_flags & wxINTERACTIVE_RESIZE_N )
 450             data.m_rect.y -= data.m_minSize.y - data.m_rect.height;
 451         data.m_rect.height = data.m_maxSize.y;
 452     }
 453 }
 454
 455 void wxInteractiveMoveHandler::OnMouseMove(wxMouseEvent& event)
 456 {
 457     if ( m_data.m_flags & wxINTERACTIVE_WAIT_FOR_INPUT )
 458         event.Skip();
 459
 460     else if ( m_data.m_flags & wxINTERACTIVE_MOVE )
 461     {
 462         wxPoint diff = wxGetMousePosition() - m_data.m_pos;
 463         m_data.m_rect = m_data.m_rectOrig;
 464         m_data.m_rect.Offset(diff);
 465         m_data.m_window->Move(m_data.m_rect.GetPosition());
 466     }
 467
 468     else if ( m_data.m_flags & wxINTERACTIVE_RESIZE )
 469     {
 470         wxPoint diff = wxGetMousePosition() - m_data.m_pos;
 471         m_data.m_rect = m_data.m_rectOrig;
 472         wxApplyResize(m_data, diff);
 473         m_data.m_window->SetSize(m_data.m_rect);
 474     }
 475 }
 476
 477 void wxInteractiveMoveHandler::OnMouseDown(wxMouseEvent& WXUNUSED(event))
 478 {
 479     if ( m_data.m_flags & wxINTERACTIVE_WAIT_FOR_INPUT )
 480     {
 481         m_data.m_evtLoop->Exit();
 482     }
 483 }
 484
 485 void wxInteractiveMoveHandler::OnKeyDown(wxKeyEvent& event)
 486 {
 487     wxPoint diff(wxDefaultCoord,wxDefaultCoord);
 488
 489     switch ( event.GetKeyCode() )
 490     {
 491         case WXK_UP:    diff = wxPoint(0, -16); break;
 492         case WXK_DOWN:  diff = wxPoint(0, 16);  break;
 493         case WXK_LEFT:  diff = wxPoint(-16, 0); break;
 494         case WXK_RIGHT: diff = wxPoint(16, 0);  break;
 495         case WXK_ESCAPE:
 496             m_data.m_window->SetSize(m_data.m_rectOrig);
 497             m_data.m_evtLoop->Exit();
 498             return;
 499         case WXK_RETURN:
 500             m_data.m_evtLoop->Exit();
 501             return;
 502     }
 503
 504     if ( diff.x != wxDefaultCoord )
 505     {
 506         if ( m_data.m_flags & wxINTERACTIVE_WAIT_FOR_INPUT )
 507         {
 508             m_data.m_flags &= ~wxINTERACTIVE_WAIT_FOR_INPUT;
 509             if ( m_data.m_sizingCursor )
 510             {
 511                 wxEndBusyCursor();
 512                 m_data.m_sizingCursor = false;
 513             }
 514
 515             if ( m_data.m_flags & wxINTERACTIVE_MOVE )
 516             {
 517                 m_data.m_pos = m_data.m_window->GetPosition() +
 518                                wxPoint(m_data.m_window->GetSize().x/2, 8);
 519             }
 520         }
 521
 522         wxPoint warp;
 523         bool changeCur = false;
 524
 525         if ( m_data.m_flags & wxINTERACTIVE_MOVE )
 526         {
 527             m_data.m_rect.Offset(diff);
 528             m_data.m_window->Move(m_data.m_rect.GetPosition());
 529             warp = wxPoint(m_data.m_window->GetSize().x/2, 8);
 530         }
 531         else /* wxINTERACTIVE_RESIZE */
 532         {
 533             if ( !(m_data.m_flags &
 534                   (wxINTERACTIVE_RESIZE_N | wxINTERACTIVE_RESIZE_S)) )
 535             {
 536                 if ( diff.y < 0 )
 537                 {
 538                     m_data.m_flags |= wxINTERACTIVE_RESIZE_N;
 539                     m_data.m_pos.y = m_data.m_window->GetPosition().y;
 540                     changeCur = true;
 541                 }
 542                 else if ( diff.y > 0 )
 543                 {
 544                     m_data.m_flags |= wxINTERACTIVE_RESIZE_S;
 545                     m_data.m_pos.y = m_data.m_window->GetPosition().y +
 546                                      m_data.m_window->GetSize().y;
 547                     changeCur = true;
 548                 }
 549             }
 550             if ( !(m_data.m_flags &
 551                   (wxINTERACTIVE_RESIZE_W | wxINTERACTIVE_RESIZE_E)) )
 552             {
 553                 if ( diff.x < 0 )
 554                 {
 555                     m_data.m_flags |= wxINTERACTIVE_RESIZE_W;
 556                     m_data.m_pos.x = m_data.m_window->GetPosition().x;
 557                     changeCur = true;
 558                 }
 559                 else if ( diff.x > 0 )
 560                 {
 561                     m_data.m_flags |= wxINTERACTIVE_RESIZE_E;
 562                     m_data.m_pos.x = m_data.m_window->GetPosition().x +
 563                                      m_data.m_window->GetSize().x;
 564                     changeCur = true;
 565                 }
 566             }
 567
 568             wxApplyResize(m_data, diff);
 569             m_data.m_window->SetSize(m_data.m_rect);
 570
 571             if ( m_data.m_flags & wxINTERACTIVE_RESIZE_W )
 572                 warp.x = 0;
 573             else if ( m_data.m_flags & wxINTERACTIVE_RESIZE_E )
 574                 warp.x = m_data.m_window->GetSize().x-1;
 575             else
 576                 warp.x = wxGetMousePosition().x - m_data.m_window->GetPosition().x;
 577
 578             if ( m_data.m_flags & wxINTERACTIVE_RESIZE_N )
 579                 warp.y = 0;
 580             else if ( m_data.m_flags & wxINTERACTIVE_RESIZE_S )
 581                 warp.y = m_data.m_window->GetSize().y-1;
 582             else
 583                 warp.y = wxGetMousePosition().y - m_data.m_window->GetPosition().y;
 584         }
 585
 586         warp -= m_data.m_window->GetClientAreaOrigin();
 587         m_data.m_window->WarpPointer(warp.x, warp.y);
 588
 589         if ( changeCur )
 590         {
 591             long hit = m_data.m_window->HitTest(warp);
 592             wxCursor cur;
 593             if ( wxGetResizingCursor(hit, cur) )
 594             {
 595                 if ( m_data.m_sizingCursor )
 596                     wxEndBusyCursor();
 597                 wxBeginBusyCursor(&cur);
 598                 m_data.m_sizingCursor = true;
 599             }
 600         }
 601     }
 602 }
 603
 604 void wxInteractiveMoveHandler::OnMouseUp(wxMouseEvent& WXUNUSED(event))
 605 {
 606     m_data.m_evtLoop->Exit();
 607 }
 608
 609
 610 void wxTopLevelWindow::InteractiveMove(int flags)
 611 {
 612     wxASSERT_MSG( !((flags & wxINTERACTIVE_MOVE) && (flags & wxINTERACTIVE_RESIZE)),
 613                   wxT("can't move and resize window at the same time") );
 614
 615     wxASSERT_MSG( !(flags & wxINTERACTIVE_RESIZE) ||
 616                   (flags & wxINTERACTIVE_WAIT_FOR_INPUT) ||
 617                   (flags & wxINTERACTIVE_RESIZE_DIR),
 618                   wxT("direction of resizing not specified") );
 619
 620     wxInteractiveMoveData data;
 621     wxEventLoop loop;
 622
 623     SetFocus();
 624
 625 #ifndef __WXGTK__
 626     if ( flags & wxINTERACTIVE_WAIT_FOR_INPUT )
 627     {
 628         wxCursor sizingCursor(wxCURSOR_SIZING);
 629         wxBeginBusyCursor(&sizingCursor);
 630         data.m_sizingCursor = true;
 631     }
 632     else
 633 #endif
 634         data.m_sizingCursor = false;
 635
 636     data.m_window = this;
 637     data.m_evtLoop = &loop;
 638     data.m_flags = flags;
 639     data.m_rect = data.m_rectOrig = GetRect();
 640     data.m_pos = wxGetMousePosition();
 641     data.m_minSize = wxSize(GetMinWidth(), GetMinHeight());
 642     data.m_maxSize = wxSize(GetMaxWidth(), GetMaxHeight());
 643
 644     wxEvtHandler *handler = new wxInteractiveMoveHandler(data);
 645     this->PushEventHandler(handler);
 646
 647     CaptureMouse();
 648     loop.Run();
 649     ReleaseMouse();
 650
 651     this->RemoveEventHandler(handler);
 652     delete handler;
 653
 654     if ( data.m_sizingCursor )
 655         wxEndBusyCursor();
 656 }
 657
 658 // ----------------------------------------------------------------------------
 659 // actions
 660 // ----------------------------------------------------------------------------
 661
 662 void wxTopLevelWindow::ClickTitleBarButton(long button)
 663 {
 664     switch ( button )
 665     {
 666         case wxTOPLEVEL_BUTTON_CLOSE:
 667             Close();
 668             break;
 669
 670         case wxTOPLEVEL_BUTTON_ICONIZE:
 671             Iconize();
 672             break;
 673
 674         case wxTOPLEVEL_BUTTON_MAXIMIZE:
 675             Maximize();
 676             break;
 677
 678         case wxTOPLEVEL_BUTTON_RESTORE:
 679             Restore();
 680             break;
 681
 682         case wxTOPLEVEL_BUTTON_HELP:
 683 #if wxUSE_HELP
 684             {
 685             wxContextHelp contextHelp(this);
 686             }
 687 #endif
 688             break;
 689
 690         default:
 691             wxFAIL_MSG(wxT("incorrect button specification"));
 692     }
 693 }
 694
 695 bool wxTopLevelWindow::PerformAction(const wxControlAction& action,
 696                                      long numArg,
 697                                      const wxString& WXUNUSED(strArg))
 698 {
 699     bool isActive = numArg != 0;
 700
 701     if ( action == wxACTION_TOPLEVEL_ACTIVATE )
 702     {
 703         if ( m_isActive != isActive )
 704         {
 705             m_isActive = isActive;
 706             RefreshTitleBar();
 707         }
 708         return true;
 709     }
 710
 711     else if ( action == wxACTION_TOPLEVEL_BUTTON_PRESS )
 712     {
 713         m_pressedButton = numArg;
 714         RefreshTitleBar();
 715         return true;
 716     }
 717
 718     else if ( action == wxACTION_TOPLEVEL_BUTTON_RELEASE )
 719     {
 720         m_pressedButton = 0;
 721         RefreshTitleBar();
 722         return true;
 723     }
 724
 725     else if ( action == wxACTION_TOPLEVEL_BUTTON_CLICK )
 726     {
 727         m_pressedButton = 0;
 728         RefreshTitleBar();
 729         ClickTitleBarButton(numArg);
 730         return true;
 731     }
 732
 733     else if ( action == wxACTION_TOPLEVEL_MOVE )
 734     {
 735         InteractiveMove(wxINTERACTIVE_MOVE);
 736         return true;
 737     }
 738
 739     else if ( action == wxACTION_TOPLEVEL_RESIZE )
 740     {
 741         int flags = wxINTERACTIVE_RESIZE;
 742         if ( numArg & wxHT_TOPLEVEL_BORDER_N )
 743             flags |= wxINTERACTIVE_RESIZE_N;
 744         if ( numArg & wxHT_TOPLEVEL_BORDER_S )
 745             flags |= wxINTERACTIVE_RESIZE_S;
 746         if ( numArg & wxHT_TOPLEVEL_BORDER_W )
 747             flags |= wxINTERACTIVE_RESIZE_W;
 748         if ( numArg & wxHT_TOPLEVEL_BORDER_E )
 749             flags |= wxINTERACTIVE_RESIZE_E;
 750         InteractiveMove(flags);
 751         return true;
 752     }
 753
 754     else
 755         return false;
 756 }
 757
 758 void wxTopLevelWindow::OnSystemMenu(wxCommandEvent& event)
 759 {
 760     bool ret = true;
 761
 762     switch (event.GetId())
 763     {
 764         case wxID_CLOSE_FRAME:
 765             ret = PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
 766                                 wxTOPLEVEL_BUTTON_CLOSE);
 767             break;
 768         case wxID_MOVE_FRAME:
 769             InteractiveMove(wxINTERACTIVE_MOVE | wxINTERACTIVE_WAIT_FOR_INPUT);
 770             break;
 771         case wxID_RESIZE_FRAME:
 772             InteractiveMove(wxINTERACTIVE_RESIZE | wxINTERACTIVE_WAIT_FOR_INPUT);
 773             break;
 774         case wxID_MAXIMIZE_FRAME:
 775             ret = PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
 776                                 wxTOPLEVEL_BUTTON_MAXIMIZE);
 777             break;
 778         case wxID_ICONIZE_FRAME:
 779             ret = PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
 780                                 wxTOPLEVEL_BUTTON_ICONIZE);
 781             break;
 782         case wxID_RESTORE_FRAME:
 783             ret = PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK,
 784                                 wxTOPLEVEL_BUTTON_RESTORE);
 785             break;
 786
 787         default:
 788             ret = false;
 789     }
 790
 791     if ( !ret )
 792         event.Skip();
 793 }
 794
 795
 796 // ============================================================================
 797 // wxStdFrameInputHandler: handles focus, resizing and titlebar buttons clicks
 798 // ============================================================================
 799
 800 wxStdFrameInputHandler::wxStdFrameInputHandler(wxInputHandler *inphand)
 801             : wxStdInputHandler(inphand)
 802 {
 803     m_winCapture = NULL;
 804     m_winHitTest = 0;
 805     m_winPressed = 0;
 806     m_borderCursorOn = false;
 807 }
 808
 809 bool wxStdFrameInputHandler::HandleMouse(wxInputConsumer *consumer,
 810                                          const wxMouseEvent& event)
 811 {
 812     // the button has 2 states: pressed and normal with the following
 813     // transitions between them:
 814     //
 815     //      normal -> left down -> capture mouse and go to pressed state
 816     //      pressed -> left up inside -> generate click -> go to normal
 817     //                         outside ------------------>
 818     //
 819     // the other mouse buttons are ignored
 820     if ( event.Button(1) )
 821     {
 822         if ( event.ButtonDown(1) )
 823         {
 824             wxTopLevelWindow *w = wxStaticCast(consumer->GetInputWindow(), wxTopLevelWindow);
 825             long hit = w->HitTest(event.GetPosition());
 826
 827             if ( hit & wxHT_TOPLEVEL_ANY_BUTTON )
 828             {
 829                 m_winCapture = w;
 830                 m_winCapture->CaptureMouse();
 831                 m_winHitTest = hit;
 832                 m_winPressed = hit;
 833                 consumer->PerformAction(wxACTION_TOPLEVEL_BUTTON_PRESS, m_winPressed);
 834                 return true;
 835             }
 836             else if ( (hit & wxHT_TOPLEVEL_TITLEBAR) && !w->IsMaximized() )
 837             {
 838                 consumer->PerformAction(wxACTION_TOPLEVEL_MOVE);
 839                 return true;
 840             }
 841             else if ( (consumer->GetInputWindow()->GetWindowStyle() & wxRESIZE_BORDER)
 842                       && (hit & wxHT_TOPLEVEL_ANY_BORDER) )
 843             {
 844                 consumer->PerformAction(wxACTION_TOPLEVEL_RESIZE, hit);
 845                 return true;
 846             }
 847         }
 848
 849         else // up
 850         {
 851             if ( m_winCapture )
 852             {
 853                 m_winCapture->ReleaseMouse();
 854                 m_winCapture = NULL;
 855
 856                 if ( m_winHitTest == m_winPressed )
 857                 {
 858                     consumer->PerformAction(wxACTION_TOPLEVEL_BUTTON_CLICK, m_winPressed);
 859                     return true;
 860                 }
 861             }
 862             //else: the mouse was released outside the window, this doesn't
 863             //      count as a click
 864         }
 865     }
 866
 867     return wxStdInputHandler::HandleMouse(consumer, event);
 868 }
 869
 870 bool wxStdFrameInputHandler::HandleMouseMove(wxInputConsumer *consumer,
 871                                              const wxMouseEvent& event)
 872 {
 873     if ( event.GetEventObject() == m_winCapture )
 874     {
 875         long hit = m_winCapture->HitTest(event.GetPosition());
 876
 877         if ( hit != m_winHitTest )
 878         {
 879             if ( hit != m_winPressed )
 880                 consumer->PerformAction(wxACTION_TOPLEVEL_BUTTON_RELEASE, m_winPressed);
 881             else
 882                 consumer->PerformAction(wxACTION_TOPLEVEL_BUTTON_PRESS, m_winPressed);
 883
 884             m_winHitTest = hit;
 885             return true;
 886         }
 887     }
 888     else if ( consumer->GetInputWindow()->GetWindowStyle() & wxRESIZE_BORDER )
 889     {
 890         wxTopLevelWindow *win = wxStaticCast(consumer->GetInputWindow(),
 891                                              wxTopLevelWindow);
 892         long hit = win->HitTest(event.GetPosition());
 893
 894         if ( hit != m_winHitTest )
 895         {
 896             m_winHitTest = hit;
 897
 898             if ( m_borderCursorOn )
 899             {
 900                 m_borderCursorOn = false;
 901                 win->SetCursor(m_origCursor);
 902             }
 903
 904             if ( hit & wxHT_TOPLEVEL_ANY_BORDER )
 905             {
 906                 wxCursor cur;
 907
 908                 m_borderCursorOn = wxGetResizingCursor(hit, cur);
 909                 if ( m_borderCursorOn )
 910                 {
 911                     m_origCursor = win->GetCursor();
 912                     win->SetCursor(cur);
 913                 }
 914             }
 915         }
 916     }
 917
 918     return wxStdInputHandler::HandleMouseMove(consumer, event);
 919 }
 920
 921 bool wxStdFrameInputHandler::HandleActivation(wxInputConsumer *consumer,
 922                                               bool activated)
 923 {
 924     if ( m_borderCursorOn )
 925     {
 926         consumer->GetInputWindow()->SetCursor(m_origCursor);
 927         m_borderCursorOn = false;
 928     }
 929     consumer->PerformAction(wxACTION_TOPLEVEL_ACTIVATE, activated);
 930     return false;
 931 }