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     m_mgr.UnInit();
  81 }
  82
  83 void wxAuiFloatingFrame::SetPaneWindow(const wxAuiPaneInfo& pane)
  84 {
  85     m_pane_window = pane.window;
  86     m_pane_window->Reparent(this);
  87
  88     wxAuiPaneInfo contained_pane = pane;
  89     contained_pane.Dock().Center().Show().
  90                     CaptionVisible(false).
  91                     PaneBorder(false).
  92                     Layer(0).Row(0).Position(0);
  93
  94     // Carry over the minimum size
  95     SetMinSize(pane.window->GetMinSize());
  96
  97     m_mgr.AddPane(m_pane_window, contained_pane);
  98     m_mgr.Update();
  99
 100     if (pane.min_size.IsFullySpecified())
 101     {
 102         // because SetSizeHints() calls Fit() too (which sets the window
 103         // size to its minimum allowed), we keep the size before calling
 104         // SetSizeHints() and reset it afterwards...
 105         wxSize tmp = GetSize();
 106         GetSizer()->SetSizeHints(this);
 107         SetSize(tmp);
 108     }
 109
 110     SetTitle(pane.caption);
 111
 112     if (pane.floating_size != wxDefaultSize)
 113     {
 114         SetSize(pane.floating_size);
 115     }
 116         else
 117     {
 118         wxSize size = pane.best_size;
 119         if (size == wxDefaultSize)
 120             size = pane.min_size;
 121         if (size == wxDefaultSize)
 122             size = m_pane_window->GetSize();
 123         if (pane.HasGripper())
 124         {
 125             if (pane.HasGripperTop())
 126                 size.y += m_owner_mgr->m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
 127             else
 128                 size.x += m_owner_mgr->m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
 129         }
 130
 131         SetClientSize(size);
 132     }
 133 }
 134
 135 wxAuiManager* wxAuiFloatingFrame::GetOwnerManager() const
 136 {
 137     return m_owner_mgr;
 138 }
 139
 140
 141 void wxAuiFloatingFrame::OnSize(wxSizeEvent& event)
 142 {
 143     m_owner_mgr->OnFloatingPaneResized(m_pane_window, event.GetSize());
 144 }
 145
 146 void wxAuiFloatingFrame::OnClose(wxCloseEvent& evt)
 147 {
 148     m_owner_mgr->OnFloatingPaneClosed(m_pane_window, evt);
 149     if (!evt.GetVeto())
 150         Destroy();
 151 }
 152
 153 void wxAuiFloatingFrame::OnMoveEvent(wxMoveEvent& event)
 154 {
 155     if (!m_solid_drag)
 156     {
 157         // systems without solid window dragging need to be
 158         // handled slightly differently, due to the lack of
 159         // the constant stream of EVT_MOVING events
 160         if (!isMouseDown())
 161             return;
 162         OnMoveStart();
 163         OnMoving(event.GetRect(), wxNORTH);
 164         m_moving = true;
 165         return;
 166     }
 167
 168
 169     wxRect win_rect = GetRect();
 170
 171     if (win_rect == m_last_rect)
 172         return;
 173
 174     // skip the first move event
 175     if (m_last_rect.IsEmpty())
 176     {
 177         m_last_rect = win_rect;
 178         return;
 179     }
 180
 181     // skip if moving too fast to avoid massive redraws and
 182     // jumping hint windows
 183     if ((abs(win_rect.x - m_last_rect.x) > 3) ||
 184         (abs(win_rect.y - m_last_rect.y) > 3))
 185     {
 186         m_last3_rect = m_last2_rect;
 187         m_last2_rect = m_last_rect;
 188         m_last_rect = win_rect;
 189         return;
 190     }
 191
 192     // prevent frame redocking during resize
 193     if (m_last_rect.GetSize() != win_rect.GetSize())
 194     {
 195         m_last3_rect = m_last2_rect;
 196         m_last2_rect = m_last_rect;
 197         m_last_rect = win_rect;
 198         return;
 199     }
 200
 201     wxDirection dir = wxALL;
 202
 203     int horiz_dist = abs(win_rect.x - m_last3_rect.x);
 204     int vert_dist = abs(win_rect.y - m_last3_rect.y);
 205
 206     if (vert_dist >= horiz_dist)
 207     {
 208         if (win_rect.y < m_last3_rect.y)
 209             dir = wxNORTH;
 210         else
 211             dir = wxSOUTH;
 212     }
 213     else
 214     {
 215         if (win_rect.x < m_last3_rect.x)
 216             dir = wxWEST;
 217         else
 218             dir = wxEAST;
 219     }
 220
 221     m_last3_rect = m_last2_rect;
 222     m_last2_rect = m_last_rect;
 223     m_last_rect = win_rect;
 224
 225     if (!isMouseDown())
 226         return;
 227
 228     if (!m_moving)
 229     {
 230         OnMoveStart();
 231         m_moving = true;
 232     }
 233
 234     if (m_last3_rect.IsEmpty())
 235         return;
 236
 237     OnMoving(event.GetRect(), dir);
 238 }
 239
 240 void wxAuiFloatingFrame::OnIdle(wxIdleEvent& event)
 241 {
 242     if (m_moving)
 243     {
 244         if (!isMouseDown())
 245         {
 246             m_moving = false;
 247             OnMoveFinished();
 248         }
 249          else
 250         {
 251             event.RequestMore();
 252         }
 253     }
 254 }
 255
 256 void wxAuiFloatingFrame::OnMoveStart()
 257 {
 258     // notify the owner manager that the pane has started to move
 259     m_owner_mgr->OnFloatingPaneMoveStart(m_pane_window);
 260 }
 261
 262 void wxAuiFloatingFrame::OnMoving(const wxRect& WXUNUSED(window_rect), wxDirection dir)
 263 {
 264     // notify the owner manager that the pane is moving
 265     m_owner_mgr->OnFloatingPaneMoving(m_pane_window, dir);
 266     m_lastDirection = dir;
 267 }
 268
 269 void wxAuiFloatingFrame::OnMoveFinished()
 270 {
 271     // notify the owner manager that the pane has finished moving
 272     m_owner_mgr->OnFloatingPaneMoved(m_pane_window, m_lastDirection);
 273 }
 274
 275 void wxAuiFloatingFrame::OnActivate(wxActivateEvent& event)
 276 {
 277     if (event.GetActive())
 278     {
 279         m_owner_mgr->OnFloatingPaneActivated(m_pane_window);
 280     }
 281 }
 282
 283 // utility function which determines the state of the mouse button
 284 // (independant of having a wxMouseEvent handy) - utimately a better
 285 // mechanism for this should be found (possibly by adding the
 286 // functionality to wxWidgets itself)
 287 bool wxAuiFloatingFrame::isMouseDown()
 288 {
 289     return wxGetMouseState().LeftDown();
 290 }
 291
 292
 293 BEGIN_EVENT_TABLE(wxAuiFloatingFrame, wxAuiFloatingFrameBaseClass)
 294     EVT_SIZE(wxAuiFloatingFrame::OnSize)
 295     EVT_MOVE(wxAuiFloatingFrame::OnMoveEvent)
 296     EVT_MOVING(wxAuiFloatingFrame::OnMoveEvent)
 297     EVT_CLOSE(wxAuiFloatingFrame::OnClose)
 298     EVT_IDLE(wxAuiFloatingFrame::OnIdle)
 299     EVT_ACTIVATE(wxAuiFloatingFrame::OnActivate)
 300 END_EVENT_TABLE()
 301
 302
 303 #endif // wxUSE_AUI