src/aui/floatpane.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/aui/floatpane.cpp
   3 // Purpose:     wxaui: wx advanced user interface - docking window manager
   4 // Author:      Benjamin I. Williams
   5 // Modified by:
   6 // Created:     2005-05-17
   7 // RCS-ID:      $Id$
   8 // Copyright:   (C) Copyright 2005-2006, Kirix Corporation, All Rights Reserved
   9 // Licence:     wxWindows Library Licence, Version 3.1
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_AUI
  27
  28 #include "wx/aui/framemanager.h"
  29 #include "wx/aui/floatpane.h"
  30 #include "wx/aui/dockart.h"
  31
  32 #ifndef WX_PRECOMP
  33 #endif
  34
  35 #ifdef __WXMSW__
  36 #include "wx/msw/private.h"
  37 #endif
  38
  39 IMPLEMENT_CLASS(wxAuiFloatingFrame, wxAuiFloatingFrameBaseClass)
  40
  41 wxAuiFloatingFrame::wxAuiFloatingFrame(wxWindow* parent,
  42                 wxAuiManager* owner_mgr,
  43                 const wxAuiPaneInfo& pane,
  44                 wxWindowID id /*= wxID_ANY*/,
  45                 long style /*=wxRESIZE_BORDER | wxSYSTEM_MENU | wxCAPTION |
  46                               wxFRAME_NO_TASKBAR | wxFRAME_FLOAT_ON_PARENT |
  47                               wxCLIP_CHILDREN
  48                            */)
  49                 : wxAuiFloatingFrameBaseClass(parent, id, wxEmptyString,
  50                         pane.floating_pos, pane.floating_size,
  51                         style |
  52                         (pane.HasCloseButton()?wxCLOSE_BOX:0) |
  53                         (pane.HasMaximizeButton()?wxMAXIMIZE_BOX:0) |
  54                         (pane.IsFixed()?0:wxRESIZE_BORDER)
  55                         )
  56 {
  57     m_owner_mgr = owner_mgr;
  58     m_moving = false;
  59     m_mgr.SetManagedWindow(this);
  60     m_solid_drag = true;
  61
  62     // find out if the system supports solid window drag.
  63     // on non-msw systems, this is assumed to be the case
  64 #ifdef __WXMSW__
  65     BOOL b = TRUE;
  66     SystemParametersInfo(38 /*SPI_GETDRAGFULLWINDOWS*/, 0, &b, 0);
  67     m_solid_drag = b ? true : false;
  68 #endif
  69
  70     SetExtraStyle(wxWS_EX_PROCESS_IDLE);
  71 }
  72
  73 wxAuiFloatingFrame::~wxAuiFloatingFrame()
  74 {
  75     // if we do not do this, then we can crash...
  76     if (m_owner_mgr && m_owner_mgr->m_action_window == this)
  77     {
  78         m_owner_mgr->m_action_window = NULL;
  79     }
  80
  81     m_mgr.UnInit();
  82 }
  83
  84 void wxAuiFloatingFrame::SetPaneWindow(const wxAuiPaneInfo& pane)
  85 {
  86     m_pane_window = pane.window;
  87     m_pane_window->Reparent(this);
  88
  89     wxAuiPaneInfo contained_pane = pane;
  90     contained_pane.Dock().Center().Show().
  91                     CaptionVisible(false).
  92                     PaneBorder(false).
  93                     Layer(0).Row(0).Position(0);
  94
  95     // Carry over the minimum size
  96     wxSize pane_min_size = pane.window->GetMinSize();
  97
  98     // if the frame window's max size is greater than the min size
  99     // then set the max size to the min size as well
 100     wxSize cur_max_size = GetMaxSize();
 101     if (cur_max_size.IsFullySpecified() &&
 102           (cur_max_size.x < pane.min_size.x ||
 103            cur_max_size.y < pane.min_size.y)
 104        )
 105     {
 106         SetMaxSize(pane_min_size);
 107     }
 108
 109     SetMinSize(pane.window->GetMinSize());
 110
 111     m_mgr.AddPane(m_pane_window, contained_pane);
 112     m_mgr.Update();
 113
 114     if (pane.min_size.IsFullySpecified())
 115     {
 116         // because SetSizeHints() calls Fit() too (which sets the window
 117         // size to its minimum allowed), we keep the size before calling
 118         // SetSizeHints() and reset it afterwards...
 119         wxSize tmp = GetSize();
 120         GetSizer()->SetSizeHints(this);
 121         SetSize(tmp);
 122     }
 123
 124     SetTitle(pane.caption);
 125
 126     if (pane.floating_size != wxDefaultSize)
 127     {
 128         SetSize(pane.floating_size);
 129     }
 130     else
 131     {
 132         wxSize size = pane.best_size;
 133         if (size == wxDefaultSize)
 134             size = pane.min_size;
 135         if (size == wxDefaultSize)
 136             size = m_pane_window->GetSize();
 137         if (m_owner_mgr && pane.HasGripper())
 138         {
 139             if (pane.HasGripperTop())
 140                 size.y += m_owner_mgr->m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
 141             else
 142                 size.x += m_owner_mgr->m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
 143         }
 144
 145         SetClientSize(size);
 146     }
 147
 148     if (pane.IsFixed())
 149     {
 150         SetWindowStyleFlag(GetWindowStyleFlag() & ~wxRESIZE_BORDER);
 151     }
 152 }
 153
 154 wxAuiManager* wxAuiFloatingFrame::GetOwnerManager() const
 155 {
 156     return m_owner_mgr;
 157 }
 158
 159
 160 void wxAuiFloatingFrame::OnSize(wxSizeEvent& WXUNUSED(event))
 161 {
 162     if (m_owner_mgr)
 163     {
 164         m_owner_mgr->OnFloatingPaneResized(m_pane_window, GetRect());
 165     }
 166 }
 167
 168 void wxAuiFloatingFrame::OnClose(wxCloseEvent& evt)
 169 {
 170     if (m_owner_mgr)
 171     {
 172         m_owner_mgr->OnFloatingPaneClosed(m_pane_window, evt);
 173     }
 174     if (!evt.GetVeto())
 175     {
 176         m_mgr.DetachPane(m_pane_window);
 177         Destroy();
 178     }
 179 }
 180
 181 void wxAuiFloatingFrame::OnMoveEvent(wxMoveEvent& event)
 182 {
 183     if (!m_solid_drag)
 184     {
 185         // systems without solid window dragging need to be
 186         // handled slightly differently, due to the lack of
 187         // the constant stream of EVT_MOVING events
 188         if (!isMouseDown())
 189             return;
 190         OnMoveStart();
 191         OnMoving(event.GetRect(), wxNORTH);
 192         m_moving = true;
 193         return;
 194     }
 195
 196
 197     wxRect win_rect = GetRect();
 198
 199     if (win_rect == m_last_rect)
 200         return;
 201
 202     // skip the first move event
 203     if (m_last_rect.IsEmpty())
 204     {
 205         m_last_rect = win_rect;
 206         return;
 207     }
 208
 209     // skip if moving too fast to avoid massive redraws and
 210     // jumping hint windows
 211     if ((abs(win_rect.x - m_last_rect.x) > 3) ||
 212         (abs(win_rect.y - m_last_rect.y) > 3))
 213     {
 214         m_last3_rect = m_last2_rect;
 215         m_last2_rect = m_last_rect;
 216         m_last_rect = win_rect;
 217
 218         // However still update the internally stored position to avoid
 219         // snapping back to the old one later.
 220         if (m_owner_mgr)
 221         {
 222             m_owner_mgr->GetPane(m_pane_window).
 223                 floating_pos = win_rect.GetPosition();
 224         }
 225
 226         return;
 227     }
 228
 229     // prevent frame redocking during resize
 230     if (m_last_rect.GetSize() != win_rect.GetSize())
 231     {
 232         m_last3_rect = m_last2_rect;
 233         m_last2_rect = m_last_rect;
 234         m_last_rect = win_rect;
 235         return;
 236     }
 237
 238     wxDirection dir = wxALL;
 239
 240     int horiz_dist = abs(win_rect.x - m_last3_rect.x);
 241     int vert_dist = abs(win_rect.y - m_last3_rect.y);
 242
 243     if (vert_dist >= horiz_dist)
 244     {
 245         if (win_rect.y < m_last3_rect.y)
 246             dir = wxNORTH;
 247         else
 248             dir = wxSOUTH;
 249     }
 250     else
 251     {
 252         if (win_rect.x < m_last3_rect.x)
 253             dir = wxWEST;
 254         else
 255             dir = wxEAST;
 256     }
 257
 258     m_last3_rect = m_last2_rect;
 259     m_last2_rect = m_last_rect;
 260     m_last_rect = win_rect;
 261
 262     if (!isMouseDown())
 263         return;
 264
 265     if (!m_moving)
 266     {
 267         OnMoveStart();
 268         m_moving = true;
 269     }
 270
 271     if (m_last3_rect.IsEmpty())
 272         return;
 273
 274     OnMoving(event.GetRect(), dir);
 275 }
 276
 277 void wxAuiFloatingFrame::OnIdle(wxIdleEvent& event)
 278 {
 279     if (m_moving)
 280     {
 281         if (!isMouseDown())
 282         {
 283             m_moving = false;
 284             OnMoveFinished();
 285         }
 286         else
 287         {
 288             event.RequestMore();
 289         }
 290     }
 291 }
 292
 293 void wxAuiFloatingFrame::OnMoveStart()
 294 {
 295     // notify the owner manager that the pane has started to move
 296     if (m_owner_mgr)
 297     {
 298         m_owner_mgr->OnFloatingPaneMoveStart(m_pane_window);
 299     }
 300 }
 301
 302 void wxAuiFloatingFrame::OnMoving(const wxRect& WXUNUSED(window_rect), wxDirection dir)
 303 {
 304     // notify the owner manager that the pane is moving
 305     if (m_owner_mgr)
 306     {
 307         m_owner_mgr->OnFloatingPaneMoving(m_pane_window, dir);
 308     }
 309     m_lastDirection = dir;
 310 }
 311
 312 void wxAuiFloatingFrame::OnMoveFinished()
 313 {
 314     // notify the owner manager that the pane has finished moving
 315     if (m_owner_mgr)
 316     {
 317         m_owner_mgr->OnFloatingPaneMoved(m_pane_window, m_lastDirection);
 318     }
 319 }
 320
 321 void wxAuiFloatingFrame::OnActivate(wxActivateEvent& event)
 322 {
 323     if (m_owner_mgr && event.GetActive())
 324     {
 325         m_owner_mgr->OnFloatingPaneActivated(m_pane_window);
 326     }
 327 }
 328
 329 // utility function which determines the state of the mouse button
 330 // (independant of having a wxMouseEvent handy) - utimately a better
 331 // mechanism for this should be found (possibly by adding the
 332 // functionality to wxWidgets itself)
 333 bool wxAuiFloatingFrame::isMouseDown()
 334 {
 335     return wxGetMouseState().LeftIsDown();
 336 }
 337
 338
 339 BEGIN_EVENT_TABLE(wxAuiFloatingFrame, wxAuiFloatingFrameBaseClass)
 340     EVT_SIZE(wxAuiFloatingFrame::OnSize)
 341     EVT_MOVE(wxAuiFloatingFrame::OnMoveEvent)
 342     EVT_MOVING(wxAuiFloatingFrame::OnMoveEvent)
 343     EVT_CLOSE(wxAuiFloatingFrame::OnClose)
 344     EVT_IDLE(wxAuiFloatingFrame::OnIdle)
 345     EVT_ACTIVATE(wxAuiFloatingFrame::OnActivate)
 346 END_EVENT_TABLE()
 347
 348
 349 #endif // wxUSE_AUI