projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Avoid GTK+ errors when using AUI wxPseudoTransparentFrame hack.
[wxWidgets.git] / src / aui / framemanager.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/aui/framemanager.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/dockart.h"
30 #include "wx/aui/floatpane.h"
31 #include "wx/aui/tabmdi.h"
32 #include "wx/aui/auibar.h"
33 #include "wx/mdi.h"
34
35 #ifndef WX_PRECOMP
36 #include "wx/panel.h"
37 #include "wx/settings.h"
38 #include "wx/app.h"
39 #include "wx/dcclient.h"
40 #include "wx/dcscreen.h"
41 #include "wx/toolbar.h"
42 #include "wx/image.h"
43 #include "wx/statusbr.h"
44 #endif
45
46 WX_CHECK_BUILD_OPTIONS("wxAUI")
47
48 #include "wx/arrimpl.cpp"
49 WX_DECLARE_OBJARRAY(wxRect, wxAuiRectArray);
50 WX_DEFINE_OBJARRAY(wxAuiRectArray)
51 WX_DEFINE_OBJARRAY(wxAuiDockUIPartArray)
52 WX_DEFINE_OBJARRAY(wxAuiDockInfoArray)
53 WX_DEFINE_OBJARRAY(wxAuiPaneButtonArray)
54 WX_DEFINE_OBJARRAY(wxAuiPaneInfoArray)
55
56 wxAuiPaneInfo wxAuiNullPaneInfo;
57 wxAuiDockInfo wxAuiNullDockInfo;
58 wxDEFINE_EVENT( wxEVT_AUI_PANE_BUTTON, wxAuiManagerEvent );
59 wxDEFINE_EVENT( wxEVT_AUI_PANE_CLOSE, wxAuiManagerEvent );
60 wxDEFINE_EVENT( wxEVT_AUI_PANE_MAXIMIZE, wxAuiManagerEvent );
61 wxDEFINE_EVENT( wxEVT_AUI_PANE_RESTORE, wxAuiManagerEvent );
62 wxDEFINE_EVENT( wxEVT_AUI_RENDER, wxAuiManagerEvent );
63 wxDEFINE_EVENT( wxEVT_AUI_FIND_MANAGER, wxAuiManagerEvent );
64
65 #ifdef __WXMAC__
66 // a few defines to avoid nameclashes
67 #define __MAC_OS_X_MEMORY_MANAGER_CLEAN__ 1
68 #define __AIFF__
69 #include "wx/osx/private.h"
70 #endif
71
72 #ifdef __WXMSW__
73 #include "wx/msw/wrapwin.h"
74 #include "wx/msw/private.h"
75 #include "wx/msw/dc.h"
76 #endif
77
78 IMPLEMENT_DYNAMIC_CLASS(wxAuiManagerEvent, wxEvent)
79 IMPLEMENT_CLASS(wxAuiManager, wxEvtHandler)
80
81
82
83 const int auiToolBarLayer = 10;
84
85 #ifndef __WXGTK20__
86
87
88 class wxPseudoTransparentFrame : public wxFrame
89 {
90 public:
91 wxPseudoTransparentFrame(wxWindow* parent = NULL,
92 wxWindowID id = wxID_ANY,
93 const wxString& title = wxEmptyString,
94 const wxPoint& pos = wxDefaultPosition,
95 const wxSize& size = wxDefaultSize,
96 long style = wxDEFAULT_FRAME_STYLE,
97 const wxString &name = wxT("frame"))
98 : wxFrame(parent, id, title, pos, size, style | wxFRAME_SHAPED, name)
99 {
100 SetBackgroundStyle(wxBG_STYLE_CUSTOM);
101 m_Amount=0;
102 m_MaxWidth=0;
103 m_MaxHeight=0;
104 m_lastWidth=0;
105 m_lastHeight=0;
106 #ifdef __WXGTK__
107 m_CanSetShape = false; // have to wait for window create event on GTK
108 #else
109 m_CanSetShape = true;
110 #endif
111 m_Region = wxRegion(0, 0, 0, 0);
112 SetTransparent(0);
113 }
114
115 virtual bool SetTransparent(wxByte alpha)
116 {
117 if (m_CanSetShape)
118 {
119 int w=100; // some defaults
120 int h=100;
121 GetClientSize(&w, &h);
122
123 m_MaxWidth = w;
124 m_MaxHeight = h;
125 m_Amount = alpha;
126 m_Region.Clear();
127 // m_Region.Union(0, 0, 1, m_MaxWidth);
128 if (m_Amount)
129 {
130 for (int y=0; y<m_MaxHeight; y++)
131 {
132 // Reverse the order of the bottom 4 bits
133 int j=((y&8)?1:0)|((y&4)?2:0)|((y&2)?4:0)|((y&1)?8:0);
134 if ((j*16+8)<m_Amount)
135 m_Region.Union(0, y, m_MaxWidth, 1);
136 }
137 }
138 SetShape(m_Region);
139 Refresh();
140 }
141 return true;
142 }
143
144 void OnPaint(wxPaintEvent& WXUNUSED(event))
145 {
146 wxPaintDC dc(this);
147
148 if (m_Region.IsEmpty())
149 return;
150
151 #ifdef __WXMAC__
152 dc.SetBrush(wxColour(128, 192, 255));
153 #else
154 dc.SetBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));
155 #endif
156 dc.SetPen(*wxTRANSPARENT_PEN);
157
158 wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
159
160 while (upd)
161 {
162 wxRect rect(upd.GetRect());
163 dc.DrawRectangle(rect.x, rect.y, rect.width, rect.height);
164
165 ++upd;
166 }
167 }
168
169 #ifdef __WXGTK__
170 void OnWindowCreate(wxWindowCreateEvent& WXUNUSED(event))
171 {
172 m_CanSetShape=true;
173 SetTransparent(0);
174 }
175 #endif
176
177 void OnSize(wxSizeEvent& event)
178 {
179 // We sometimes get surplus size events
180 if ((event.GetSize().GetWidth() == m_lastWidth) &&
181 (event.GetSize().GetHeight() == m_lastHeight))
182 {
183 event.Skip();
184 return;
185 }
186 m_lastWidth = event.GetSize().GetWidth();
187 m_lastHeight = event.GetSize().GetHeight();
188
189 SetTransparent(m_Amount);
190 m_Region.Intersect(0, 0, event.GetSize().GetWidth(),
191 event.GetSize().GetHeight());
192 SetShape(m_Region);
193 Refresh();
194 event.Skip();
195 }
196
197 private:
198 wxByte m_Amount;
199 int m_MaxWidth;
200 int m_MaxHeight;
201 bool m_CanSetShape;
202 int m_lastWidth,m_lastHeight;
203
204 wxRegion m_Region;
205
206 DECLARE_DYNAMIC_CLASS(wxPseudoTransparentFrame)
207 DECLARE_EVENT_TABLE()
208 };
209
210
211 IMPLEMENT_DYNAMIC_CLASS(wxPseudoTransparentFrame, wxFrame)
212
213 BEGIN_EVENT_TABLE(wxPseudoTransparentFrame, wxFrame)
214 EVT_PAINT(wxPseudoTransparentFrame::OnPaint)
215 EVT_SIZE(wxPseudoTransparentFrame::OnSize)
216 #ifdef __WXGTK__
217 EVT_WINDOW_CREATE(wxPseudoTransparentFrame::OnWindowCreate)
218 #endif
219 END_EVENT_TABLE()
220
221
222 #else
223 // __WXGTK20__
224
225 #include <gtk/gtk.h>
226
227 static void
228 gtk_pseudo_window_realized_callback( GtkWidget *m_widget, void *WXUNUSED(win) )
229 {
230 wxSize disp = wxGetDisplaySize();
231 int amount = 128;
232 wxRegion region;
233 for (int y=0; y<disp.y; y++)
234 {
235 // Reverse the order of the bottom 4 bits
236 int j=((y&8)?1:0)|((y&4)?2:0)|((y&2)?4:0)|((y&1)?8:0);
237 if ((j*16+8)<amount)
238 region.Union(0, y, disp.x, 1);
239 }
240 gdk_window_shape_combine_region(m_widget->window, region.GetRegion(), 0, 0);
241 }
242
243
244 class wxPseudoTransparentFrame: public wxFrame
245 {
246 public:
247 wxPseudoTransparentFrame(wxWindow* parent = NULL,
248 wxWindowID id = wxID_ANY,
249 const wxString& title = wxEmptyString,
250 const wxPoint& pos = wxDefaultPosition,
251 const wxSize& size = wxDefaultSize,
252 long style = wxDEFAULT_FRAME_STYLE,
253 const wxString &name = wxT("frame"))
254 {
255 if (!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
256 return;
257
258 m_title = title;
259
260 m_widget = gtk_window_new( GTK_WINDOW_POPUP );
261 g_object_ref(m_widget);
262
263 if (parent) parent->AddChild(this);
264
265 g_signal_connect( m_widget, "realize",
266 G_CALLBACK (gtk_pseudo_window_realized_callback), this );
267
268 GdkColor col;
269 col.red = 128 * 256;
270 col.green = 192 * 256;
271 col.blue = 255 * 256;
272 gtk_widget_modify_bg( m_widget, GTK_STATE_NORMAL, &col );
273 }
274
275 bool SetTransparent(wxByte WXUNUSED(alpha))
276 {
277 return true;
278 }
279
280 protected:
281 virtual void DoSetSizeHints( int minW, int minH,
282 int maxW, int maxH,
283 int incW, int incH)
284 {
285 // the real wxFrame method doesn't work for us because we're not really
286 // a top level window so skip it
287 wxWindow::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
288 }
289
290 private:
291 DECLARE_DYNAMIC_CLASS(wxPseudoTransparentFrame)
292 };
293
294 IMPLEMENT_DYNAMIC_CLASS(wxPseudoTransparentFrame, wxFrame)
295
296 #endif
297 // __WXGTK20__
298
299
300
301 // -- static utility functions --
302
303 static wxBitmap wxPaneCreateStippleBitmap()
304 {
305 unsigned char data[] = { 0,0,0,192,192,192, 192,192,192,0,0,0 };
306 wxImage img(2,2,data,true);
307 return wxBitmap(img);
308 }
309
310 static void DrawResizeHint(wxDC& dc, const wxRect& rect)
311 {
312 wxBitmap stipple = wxPaneCreateStippleBitmap();
313 wxBrush brush(stipple);
314 dc.SetBrush(brush);
315 #ifdef __WXMSW__
316 wxMSWDCImpl *impl = (wxMSWDCImpl*) dc.GetImpl();
317 PatBlt(GetHdcOf(*impl), rect.GetX(), rect.GetY(), rect.GetWidth(), rect.GetHeight(), PATINVERT);
318 #else
319 dc.SetPen(*wxTRANSPARENT_PEN);
320
321 dc.SetLogicalFunction(wxXOR);
322 dc.DrawRectangle(rect);
323 #endif
324 }
325
326
327
328 // CopyDocksAndPanes() - this utility function creates copies of
329 // the dock and pane info. wxAuiDockInfo's usually contain pointers
330 // to wxAuiPaneInfo classes, thus this function is necessary to reliably
331 // reconstruct that relationship in the new dock info and pane info arrays
332
333 static void CopyDocksAndPanes(wxAuiDockInfoArray& dest_docks,
334 wxAuiPaneInfoArray& dest_panes,
335 const wxAuiDockInfoArray& src_docks,
336 const wxAuiPaneInfoArray& src_panes)
337 {
338 dest_docks = src_docks;
339 dest_panes = src_panes;
340 int i, j, k, dock_count, pc1, pc2;
341 for (i = 0, dock_count = dest_docks.GetCount(); i < dock_count; ++i)
342 {
343 wxAuiDockInfo& dock = dest_docks.Item(i);
344 for (j = 0, pc1 = dock.panes.GetCount(); j < pc1; ++j)
345 for (k = 0, pc2 = src_panes.GetCount(); k < pc2; ++k)
346 if (dock.panes.Item(j) == &src_panes.Item(k))
347 dock.panes.Item(j) = &dest_panes.Item(k);
348 }
349 }
350
351 // GetMaxLayer() is an internal function which returns
352 // the highest layer inside the specified dock
353 static int GetMaxLayer(const wxAuiDockInfoArray& docks,
354 int dock_direction)
355 {
356 int i, dock_count, max_layer = 0;
357 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
358 {
359 wxAuiDockInfo& dock = docks.Item(i);
360 if (dock.dock_direction == dock_direction &&
361 dock.dock_layer > max_layer && !dock.fixed)
362 max_layer = dock.dock_layer;
363 }
364 return max_layer;
365 }
366
367
368 // GetMaxRow() is an internal function which returns
369 // the highest layer inside the specified dock
370 static int GetMaxRow(const wxAuiPaneInfoArray& panes, int direction, int layer)
371 {
372 int i, pane_count, max_row = 0;
373 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
374 {
375 wxAuiPaneInfo& pane = panes.Item(i);
376 if (pane.dock_direction == direction &&
377 pane.dock_layer == layer &&
378 pane.dock_row > max_row)
379 max_row = pane.dock_row;
380 }
381 return max_row;
382 }
383
384
385
386 // DoInsertDockLayer() is an internal function that inserts a new dock
387 // layer by incrementing all existing dock layer values by one
388 static void DoInsertDockLayer(wxAuiPaneInfoArray& panes,
389 int dock_direction,
390 int dock_layer)
391 {
392 int i, pane_count;
393 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
394 {
395 wxAuiPaneInfo& pane = panes.Item(i);
396 if (!pane.IsFloating() &&
397 pane.dock_direction == dock_direction &&
398 pane.dock_layer >= dock_layer)
399 pane.dock_layer++;
400 }
401 }
402
403 // DoInsertDockLayer() is an internal function that inserts a new dock
404 // row by incrementing all existing dock row values by one
405 static void DoInsertDockRow(wxAuiPaneInfoArray& panes,
406 int dock_direction,
407 int dock_layer,
408 int dock_row)
409 {
410 int i, pane_count;
411 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
412 {
413 wxAuiPaneInfo& pane = panes.Item(i);
414 if (!pane.IsFloating() &&
415 pane.dock_direction == dock_direction &&
416 pane.dock_layer == dock_layer &&
417 pane.dock_row >= dock_row)
418 pane.dock_row++;
419 }
420 }
421
422 // DoInsertDockLayer() is an internal function that inserts a space for
423 // another dock pane by incrementing all existing dock row values by one
424 static void DoInsertPane(wxAuiPaneInfoArray& panes,
425 int dock_direction,
426 int dock_layer,
427 int dock_row,
428 int dock_pos)
429 {
430 int i, pane_count;
431 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
432 {
433 wxAuiPaneInfo& pane = panes.Item(i);
434 if (!pane.IsFloating() &&
435 pane.dock_direction == dock_direction &&
436 pane.dock_layer == dock_layer &&
437 pane.dock_row == dock_row &&
438 pane.dock_pos >= dock_pos)
439 pane.dock_pos++;
440 }
441 }
442
443 // FindDocks() is an internal function that returns a list of docks which meet
444 // the specified conditions in the parameters and returns a sorted array
445 // (sorted by layer and then row)
446 static void FindDocks(wxAuiDockInfoArray& docks,
447 int dock_direction,
448 int dock_layer,
449 int dock_row,
450 wxAuiDockInfoPtrArray& arr)
451 {
452 int begin_layer = dock_layer;
453 int end_layer = dock_layer;
454 int begin_row = dock_row;
455 int end_row = dock_row;
456 int dock_count = docks.GetCount();
457 int layer, row, i, max_row = 0, max_layer = 0;
458
459 // discover the maximum dock layer and the max row
460 for (i = 0; i < dock_count; ++i)
461 {
462 max_row = wxMax(max_row, docks.Item(i).dock_row);
463 max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
464 }
465
466 // if no dock layer was specified, search all dock layers
467 if (dock_layer == -1)
468 {
469 begin_layer = 0;
470 end_layer = max_layer;
471 }
472
473 // if no dock row was specified, search all dock row
474 if (dock_row == -1)
475 {
476 begin_row = 0;
477 end_row = max_row;
478 }
479
480 arr.Clear();
481
482 for (layer = begin_layer; layer <= end_layer; ++layer)
483 for (row = begin_row; row <= end_row; ++row)
484 for (i = 0; i < dock_count; ++i)
485 {
486 wxAuiDockInfo& d = docks.Item(i);
487 if (dock_direction == -1 || dock_direction == d.dock_direction)
488 {
489 if (d.dock_layer == layer && d.dock_row == row)
490 arr.Add(&d);
491 }
492 }
493 }
494
495 // FindPaneInDock() looks up a specified window pointer inside a dock.
496 // If found, the corresponding wxAuiPaneInfo pointer is returned, otherwise NULL.
497 static wxAuiPaneInfo* FindPaneInDock(const wxAuiDockInfo& dock, wxWindow* window)
498 {
499 int i, count = dock.panes.GetCount();
500 for (i = 0; i < count; ++i)
501 {
502 wxAuiPaneInfo* p = dock.panes.Item(i);
503 if (p->window == window)
504 return p;
505 }
506 return NULL;
507 }
508
509 // RemovePaneFromDocks() removes a pane window from all docks
510 // with a possible exception specified by parameter "ex_cept"
511 static void RemovePaneFromDocks(wxAuiDockInfoArray& docks,
512 wxAuiPaneInfo& pane,
513 wxAuiDockInfo* ex_cept = NULL )
514 {
515 int i, dock_count;
516 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
517 {
518 wxAuiDockInfo& d = docks.Item(i);
519 if (&d == ex_cept)
520 continue;
521 wxAuiPaneInfo* pi = FindPaneInDock(d, pane.window);
522 if (pi)
523 d.panes.Remove(pi);
524 }
525 }
526
527 /*
528 // This function works fine, and may be used in the future
529
530 // RenumberDockRows() takes a dock and assigns sequential numbers
531 // to existing rows. Basically it takes out the gaps; so if a
532 // dock has rows with numbers 0,2,5, they will become 0,1,2
533 static void RenumberDockRows(wxAuiDockInfoPtrArray& docks)
534 {
535 int i, dock_count;
536 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
537 {
538 wxAuiDockInfo& dock = *docks.Item(i);
539 dock.dock_row = i;
540
541 int j, pane_count;
542 for (j = 0, pane_count = dock.panes.GetCount(); j < pane_count; ++j)
543 dock.panes.Item(j)->dock_row = i;
544 }
545 }
546 */
547
548
549 // SetActivePane() sets the active pane, as well as cycles through
550 // every other pane and makes sure that all others' active flags
551 // are turned off
552 static void SetActivePane(wxAuiPaneInfoArray& panes, wxWindow* active_pane)
553 {
554 int i, pane_count;
555 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
556 {
557 wxAuiPaneInfo& pane = panes.Item(i);
558 pane.state &= ~wxAuiPaneInfo::optionActive;
559 if (pane.window == active_pane)
560 pane.state |= wxAuiPaneInfo::optionActive;
561 }
562 }
563
564
565 // this function is used to sort panes by dock position
566 static int PaneSortFunc(wxAuiPaneInfo** p1, wxAuiPaneInfo** p2)
567 {
568 return ((*p1)->dock_pos < (*p2)->dock_pos) ? -1 : 1;
569 }
570
571
572
573
574 // this utility class implements a proportional sizer
575 // as it existed in wxWidgets 2.8 and before.
576
577 class wxAuiProportionalBoxSizer : public wxBoxSizer
578 {
579 public:
580 wxAuiProportionalBoxSizer(int orientation) : wxBoxSizer(orientation) { }
581
582 void RecalcSizes()
583 {
584 if (m_children.GetCount() == 0)
585 return;
586
587 int fixed_height = 0;
588 int fixed_width = 0;
589 int stretchable = 0;
590 wxSizerItemList::compatibility_iterator node;
591
592 // find fixed width and height, as well
593 // as the total stretchable proportions
594 node = m_children.GetFirst();
595 while (node)
596 {
597 wxSizerItem *item = node->GetData();
598
599 if (item->IsShown())
600 {
601 stretchable += item->GetProportion();
602
603 wxSize size(item->GetMinSizeWithBorder());
604 if (item->GetProportion() == 0)
605 {
606 if (m_orient == wxVERTICAL)
607 {
608 fixed_height += size.y;
609 fixed_width = wxMax(fixed_width, size.x);
610 }
611 else
612 {
613 fixed_width += size.x;
614 fixed_height = wxMax(fixed_height, size.y);
615 }
616 }
617 }
618
619 node = node->GetNext();
620 }
621
622
623 // delta specifies the total amount to be allocated to stretch spaces
624 int delta = 0;
625 if (stretchable)
626 {
627 if (m_orient == wxHORIZONTAL)
628 delta = m_size.x - fixed_width;
629 else
630 delta = m_size.y - fixed_height;
631 }
632
633 // go through each item and assign sizes
634 wxPoint pt(m_position);
635 node = m_children.GetFirst();
636 while (node)
637 {
638 wxSizerItem* item = node->GetData();
639
640 if (item->IsShown())
641 {
642 wxSize size(item->GetMinSizeWithBorder());
643
644 if (m_orient == wxVERTICAL)
645 {
646 wxCoord height = size.y;
647 if (item->GetProportion())
648 {
649 height = (delta * item->GetProportion()) / stretchable;
650 delta -= height;
651 stretchable -= item->GetProportion();
652 }
653
654 wxPoint child_pos(pt);
655 wxSize child_size(size.x, height);
656
657 if (item->GetFlag() & (wxEXPAND | wxSHAPED))
658 child_size.x = m_size.x;
659 else if (item->GetFlag() & wxALIGN_RIGHT)
660 child_pos.x += m_size.x - size.x;
661 else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_HORIZONTAL))
662 child_pos.x += (m_size.x - size.x) / 2;
663
664 item->SetDimension(child_pos, child_size);
665
666 pt.y += height;
667 }
668 else
669 {
670 wxCoord width = size.x;
671 if (item->GetProportion())
672 {
673 width = (delta * item->GetProportion()) / stretchable;
674 delta -= width;
675 stretchable -= item->GetProportion();
676 }
677
678 wxPoint child_pos(pt);
679 wxSize child_size(width, size.y);
680
681 if (item->GetFlag() & (wxEXPAND | wxSHAPED))
682 child_size.y = m_size.y;
683 else if (item->GetFlag() & wxALIGN_BOTTOM)
684 child_pos.y += m_size.y - size.y;
685 else if (item->GetFlag() & (wxCENTER | wxALIGN_CENTER_VERTICAL))
686 child_pos.y += (m_size.y - size.y) / 2;
687
688 item->SetDimension(child_pos, child_size);
689
690 pt.x += width;
691 }
692 }
693
694 node = node->GetNext();
695 }
696 }
697 };
698
699
700
701
702 // -- wxAuiManager class implementation --
703
704
705 BEGIN_EVENT_TABLE(wxAuiManager, wxEvtHandler)
706 EVT_AUI_PANE_BUTTON(wxAuiManager::OnPaneButton)
707 EVT_AUI_RENDER(wxAuiManager::OnRender)
708 EVT_PAINT(wxAuiManager::OnPaint)
709 EVT_ERASE_BACKGROUND(wxAuiManager::OnEraseBackground)
710 EVT_SIZE(wxAuiManager::OnSize)
711 EVT_SET_CURSOR(wxAuiManager::OnSetCursor)
712 EVT_LEFT_DOWN(wxAuiManager::OnLeftDown)
713 EVT_LEFT_UP(wxAuiManager::OnLeftUp)
714 EVT_MOTION(wxAuiManager::OnMotion)
715 EVT_LEAVE_WINDOW(wxAuiManager::OnLeaveWindow)
716 EVT_MOUSE_CAPTURE_LOST(wxAuiManager::OnCaptureLost)
717 EVT_CHILD_FOCUS(wxAuiManager::OnChildFocus)
718 EVT_AUI_FIND_MANAGER(wxAuiManager::OnFindManager)
719 END_EVENT_TABLE()
720
721
722 wxAuiManager::wxAuiManager(wxWindow* managed_wnd, unsigned int flags)
723 {
724 m_action = actionNone;
725 m_action_window = NULL;
726 m_last_mouse_move = wxPoint();
727 m_hover_button = NULL;
728 m_art = new wxAuiDefaultDockArt;
729 m_hint_wnd = NULL;
730 m_flags = flags;
731 m_skipping = false;
732 m_has_maximized = false;
733 m_frame = NULL;
734 m_dock_constraint_x = 0.3;
735 m_dock_constraint_y = 0.3;
736 m_reserved = NULL;
737 m_currentDragItem = -1;
738
739 if (managed_wnd)
740 {
741 SetManagedWindow(managed_wnd);
742 }
743 }
744
745 wxAuiManager::~wxAuiManager()
746 {
747 // NOTE: It's possible that the windows have already been destroyed by the
748 // time this dtor is called, so this loop can result in memory access via
749 // invalid pointers, resulting in a crash. So it will be disabled while
750 // waiting for a better solution.
751 #if 0
752 for ( size_t i = 0; i < m_panes.size(); i++ )
753 {
754 wxAuiPaneInfo& pinfo = m_panes[i];
755 if (pinfo.window && !pinfo.window->GetParent())
756 delete pinfo.window;
757 }
758 #endif
759
760 delete m_art;
761 }
762
763 // creates a floating frame for the windows
764 wxAuiFloatingFrame* wxAuiManager::CreateFloatingFrame(wxWindow* parent,
765 const wxAuiPaneInfo& pane_info)
766 {
767 return new wxAuiFloatingFrame(parent, this, pane_info);
768 }
769
770 bool wxAuiManager::CanDockPanel(const wxAuiPaneInfo & WXUNUSED(p))
771 {
772 // if a key modifier is pressed while dragging the frame,
773 // don't dock the window
774 return !(wxGetKeyState(WXK_CONTROL) || wxGetKeyState(WXK_ALT));
775 }
776
777 // GetPane() looks up a wxAuiPaneInfo structure based
778 // on the supplied window pointer. Upon failure, GetPane()
779 // returns an empty wxAuiPaneInfo, a condition which can be checked
780 // by calling wxAuiPaneInfo::IsOk().
781 //
782 // The pane info's structure may then be modified. Once a pane's
783 // info is modified, wxAuiManager::Update() must be called to
784 // realize the changes in the UI.
785
786 wxAuiPaneInfo& wxAuiManager::GetPane(wxWindow* window)
787 {
788 int i, pane_count;
789 for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
790 {
791 wxAuiPaneInfo& p = m_panes.Item(i);
792 if (p.window == window)
793 return p;
794 }
795 return wxAuiNullPaneInfo;
796 }
797
798 // this version of GetPane() looks up a pane based on a
799 // 'pane name', see above comment for more info
800 wxAuiPaneInfo& wxAuiManager::GetPane(const wxString& name)
801 {
802 int i, pane_count;
803 for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
804 {
805 wxAuiPaneInfo& p = m_panes.Item(i);
806 if (p.name == name)
807 return p;
808 }
809 return wxAuiNullPaneInfo;
810 }
811
812 // GetAllPanes() returns a reference to all the pane info structures
813 wxAuiPaneInfoArray& wxAuiManager::GetAllPanes()
814 {
815 return m_panes;
816 }
817
818 // HitTest() is an internal function which determines
819 // which UI item the specified coordinates are over
820 // (x,y) specify a position in client coordinates
821 wxAuiDockUIPart* wxAuiManager::HitTest(int x, int y)
822 {
823 wxAuiDockUIPart* result = NULL;
824
825 int i, part_count;
826 for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
827 {
828 wxAuiDockUIPart* item = &m_uiparts.Item(i);
829
830 // we are not interested in typeDock, because this space
831 // isn't used to draw anything, just for measurements;
832 // besides, the entire dock area is covered with other
833 // rectangles, which we are interested in.
834 if (item->type == wxAuiDockUIPart::typeDock)
835 continue;
836
837 // if we already have a hit on a more specific item, we are not
838 // interested in a pane hit. If, however, we don't already have
839 // a hit, returning a pane hit is necessary for some operations
840 if ((item->type == wxAuiDockUIPart::typePane ||
841 item->type == wxAuiDockUIPart::typePaneBorder) && result)
842 continue;
843
844 // if the point is inside the rectangle, we have a hit
845 if (item->rect.Contains(x,y))
846 result = item;
847 }
848
849 return result;
850 }
851
852
853 // SetFlags() and GetFlags() allow the owner to set various
854 // options which are global to wxAuiManager
855 void wxAuiManager::SetFlags(unsigned int flags)
856 {
857 // find out if we have to call UpdateHintWindowConfig()
858 bool update_hint_wnd = false;
859 unsigned int hint_mask = wxAUI_MGR_TRANSPARENT_HINT |
860 wxAUI_MGR_VENETIAN_BLINDS_HINT |
861 wxAUI_MGR_RECTANGLE_HINT;
862 if ((flags & hint_mask) != (m_flags & hint_mask))
863 update_hint_wnd = true;
864
865
866 // set the new flags
867 m_flags = flags;
868
869 if (update_hint_wnd)
870 {
871 UpdateHintWindowConfig();
872 }
873 }
874
875 unsigned int wxAuiManager::GetFlags() const
876 {
877 return m_flags;
878 }
879
880 // Convenience function
881 bool wxAuiManager_HasLiveResize(wxAuiManager& manager)
882 {
883 // With Core Graphics on Mac, it's not possible to show sash feedback,
884 // so we'll always use live update instead.
885 #if defined(__WXMAC__)
886 wxUnusedVar(manager);
887 return true;
888 #else
889 return (manager.GetFlags() & wxAUI_MGR_LIVE_RESIZE) == wxAUI_MGR_LIVE_RESIZE;
890 #endif
891 }
892
893 // don't use these anymore as they are deprecated
894 // use Set/GetManagedFrame() instead
895 void wxAuiManager::SetFrame(wxFrame* frame)
896 {
897 SetManagedWindow((wxWindow*)frame);
898 }
899
900 wxFrame* wxAuiManager::GetFrame() const
901 {
902 return (wxFrame*)m_frame;
903 }
904
905
906 // this function will return the aui manager for a given
907 // window. The |window| parameter should be any child window
908 // or grand-child window (and so on) of the frame/window
909 // managed by wxAuiManager. The |window| parameter does not
910 // need to be managed by the manager itself.
911 wxAuiManager* wxAuiManager::GetManager(wxWindow* window)
912 {
913 wxAuiManagerEvent evt(wxEVT_AUI_FIND_MANAGER);
914 evt.SetManager(NULL);
915 evt.ResumePropagation(wxEVENT_PROPAGATE_MAX);
916 if (!window->GetEventHandler()->ProcessEvent(evt))
917 return NULL;
918
919 return evt.GetManager();
920 }
921
922
923 void wxAuiManager::UpdateHintWindowConfig()
924 {
925 // find out if the the system can do transparent frames
926 bool can_do_transparent = false;
927
928 wxWindow* w = m_frame;
929 while (w)
930 {
931 if (w->IsKindOf(CLASSINFO(wxFrame)))
932 {
933 wxFrame* f = static_cast<wxFrame*>(w);
934 can_do_transparent = f->CanSetTransparent();
935
936 break;
937 }
938
939 w = w->GetParent();
940 }
941
942 // if there is an existing hint window, delete it
943 if (m_hint_wnd)
944 {
945 m_hint_wnd->Destroy();
946 m_hint_wnd = NULL;
947 }
948
949 m_hint_fademax = 50;
950 m_hint_wnd = NULL;
951
952 if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) && can_do_transparent)
953 {
954 // Make a window to use for a transparent hint
955 #if defined(__WXMSW__) || defined(__WXGTK__)
956 m_hint_wnd = new wxFrame(m_frame, wxID_ANY, wxEmptyString,
957 wxDefaultPosition, wxSize(1,1),
958 wxFRAME_TOOL_WINDOW |
959 wxFRAME_FLOAT_ON_PARENT |
960 wxFRAME_NO_TASKBAR |
961 wxNO_BORDER);
962
963 m_hint_wnd->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));
964 #elif defined(__WXMAC__)
965 // Using a miniframe with float and tool styles keeps the parent
966 // frame activated and highlighted as such...
967 m_hint_wnd = new wxMiniFrame(m_frame, wxID_ANY, wxEmptyString,
968 wxDefaultPosition, wxSize(1,1),
969 wxFRAME_FLOAT_ON_PARENT
970 | wxFRAME_TOOL_WINDOW );
971 m_hint_wnd->Connect(wxEVT_ACTIVATE,
972 wxActivateEventHandler(wxAuiManager::OnHintActivate), NULL, this);
973
974 // Can't set the bg colour of a Frame in wxMac
975 wxPanel* p = new wxPanel(m_hint_wnd);
976
977 // The default wxSYS_COLOUR_ACTIVECAPTION colour is a light silver
978 // color that is really hard to see, especially transparent.
979 // Until a better system color is decided upon we'll just use
980 // blue.
981 p->SetBackgroundColour(*wxBLUE);
982 #endif
983
984 }
985 else
986 {
987 if ((m_flags & wxAUI_MGR_TRANSPARENT_HINT) != 0 ||
988 (m_flags & wxAUI_MGR_VENETIAN_BLINDS_HINT) != 0)
989 {
990 // system can't support transparent fade, or the venetian
991 // blinds effect was explicitly requested
992 m_hint_wnd = new wxPseudoTransparentFrame(m_frame,
993 wxID_ANY,
994 wxEmptyString,
995 wxDefaultPosition,
996 wxSize(1,1),
997 wxFRAME_TOOL_WINDOW |
998 wxFRAME_FLOAT_ON_PARENT |
999 wxFRAME_NO_TASKBAR |
1000 wxNO_BORDER);
1001 m_hint_fademax = 128;
1002 }
1003 }
1004 }
1005
1006
1007 // SetManagedWindow() is usually called once when the frame
1008 // manager class is being initialized. "frame" specifies
1009 // the frame which should be managed by the frame mananger
1010 void wxAuiManager::SetManagedWindow(wxWindow* wnd)
1011 {
1012 wxASSERT_MSG(wnd, wxT("specified window must be non-NULL"));
1013
1014 m_frame = wnd;
1015 m_frame->PushEventHandler(this);
1016
1017 #if wxUSE_MDI
1018 // if the owner is going to manage an MDI parent frame,
1019 // we need to add the MDI client window as the default
1020 // center pane
1021
1022 if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
1023 {
1024 wxMDIParentFrame* mdi_frame = (wxMDIParentFrame*)m_frame;
1025 wxWindow* client_window = mdi_frame->GetClientWindow();
1026
1027 wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
1028
1029 AddPane(client_window,
1030 wxAuiPaneInfo().Name(wxT("mdiclient")).
1031 CenterPane().PaneBorder(false));
1032 }
1033 else if (m_frame->IsKindOf(CLASSINFO(wxAuiMDIParentFrame)))
1034 {
1035 wxAuiMDIParentFrame* mdi_frame = (wxAuiMDIParentFrame*)m_frame;
1036 wxAuiMDIClientWindow* client_window = mdi_frame->GetClientWindow();
1037 wxASSERT_MSG(client_window, wxT("Client window is NULL!"));
1038
1039 AddPane(client_window,
1040 wxAuiPaneInfo().Name(wxT("mdiclient")).
1041 CenterPane().PaneBorder(false));
1042 }
1043
1044 #endif
1045
1046 UpdateHintWindowConfig();
1047 }
1048
1049
1050 // UnInit() must be called, usually in the destructor
1051 // of the frame class. If it is not called, usually this
1052 // will result in a crash upon program exit
1053 void wxAuiManager::UnInit()
1054 {
1055 if (m_frame)
1056 {
1057 m_frame->RemoveEventHandler(this);
1058 }
1059 }
1060
1061 // GetManagedWindow() returns the window pointer being managed
1062 wxWindow* wxAuiManager::GetManagedWindow() const
1063 {
1064 return m_frame;
1065 }
1066
1067 wxAuiDockArt* wxAuiManager::GetArtProvider() const
1068 {
1069 return m_art;
1070 }
1071
1072 void wxAuiManager::ProcessMgrEvent(wxAuiManagerEvent& event)
1073 {
1074 // first, give the owner frame a chance to override
1075 if (m_frame)
1076 {
1077 if (m_frame->GetEventHandler()->ProcessEvent(event))
1078 return;
1079 }
1080
1081 ProcessEvent(event);
1082 }
1083
1084 // SetArtProvider() instructs wxAuiManager to use the
1085 // specified art provider for all drawing calls. This allows
1086 // plugable look-and-feel features. The pointer that is
1087 // passed to this method subsequently belongs to wxAuiManager,
1088 // and is deleted in the frame manager destructor
1089 void wxAuiManager::SetArtProvider(wxAuiDockArt* art_provider)
1090 {
1091 // delete the last art provider, if any
1092 delete m_art;
1093
1094 // assign the new art provider
1095 m_art = art_provider;
1096 }
1097
1098
1099 bool wxAuiManager::AddPane(wxWindow* window, const wxAuiPaneInfo& pane_info)
1100 {
1101 wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed"));
1102
1103 // check if the pane has a valid window
1104 if (!window)
1105 return false;
1106
1107 // check if the window is already managed by us
1108 if (GetPane(pane_info.window).IsOk())
1109 return false;
1110
1111 // check if the pane name already exists, this could reveal a
1112 // bug in the library user's application
1113 bool already_exists = false;
1114 if (!pane_info.name.empty() && GetPane(pane_info.name).IsOk())
1115 {
1116 wxFAIL_MSG(wxT("A pane with that name already exists in the manager!"));
1117 already_exists = true;
1118 }
1119
1120 // if the new pane is docked then we should undo maximize
1121 if (pane_info.IsDocked())
1122 RestoreMaximizedPane();
1123
1124 m_panes.Add(pane_info);
1125
1126 wxAuiPaneInfo& pinfo = m_panes.Last();
1127
1128 // set the pane window
1129 pinfo.window = window;
1130
1131
1132 // if the pane's name identifier is blank, create a random string
1133 if (pinfo.name.empty() || already_exists)
1134 {
1135 pinfo.name.Printf(wxT("%08lx%08x%08x%08lx"),
1136 wxPtrToUInt(pinfo.window) & 0xffffffff,
1137 (unsigned int)time(NULL),
1138 #ifdef __WXWINCE__
1139 (unsigned int)GetTickCount(),
1140 #else
1141 (unsigned int)clock(),
1142 #endif
1143 (unsigned long)m_panes.GetCount());
1144 }
1145
1146 // set initial proportion (if not already set)
1147 if (pinfo.dock_proportion == 0)
1148 pinfo.dock_proportion = 100000;
1149
1150 if (pinfo.HasMaximizeButton())
1151 {
1152 wxAuiPaneButton button;
1153 button.button_id = wxAUI_BUTTON_MAXIMIZE_RESTORE;
1154 pinfo.buttons.Add(button);
1155 }
1156
1157 if (pinfo.HasPinButton())
1158 {
1159 wxAuiPaneButton button;
1160 button.button_id = wxAUI_BUTTON_PIN;
1161 pinfo.buttons.Add(button);
1162 }
1163
1164 if (pinfo.HasCloseButton())
1165 {
1166 wxAuiPaneButton button;
1167 button.button_id = wxAUI_BUTTON_CLOSE;
1168 pinfo.buttons.Add(button);
1169 }
1170
1171 if (pinfo.HasGripper())
1172 {
1173 if (pinfo.window->IsKindOf(CLASSINFO(wxAuiToolBar)))
1174 {
1175 // prevent duplicate gripper -- both wxAuiManager and wxAuiToolBar
1176 // have a gripper control. The toolbar's built-in gripper
1177 // meshes better with the look and feel of the control than ours,
1178 // so turn wxAuiManager's gripper off, and the toolbar's on.
1179
1180 wxAuiToolBar* tb = static_cast<wxAuiToolBar*>(pinfo.window);
1181 pinfo.SetFlag(wxAuiPaneInfo::optionGripper, false);
1182 tb->SetGripperVisible(true);
1183 }
1184 }
1185
1186
1187 if (pinfo.best_size == wxDefaultSize &&
1188 pinfo.window)
1189 {
1190 pinfo.best_size = pinfo.window->GetClientSize();
1191
1192 #if wxUSE_TOOLBAR
1193 if (pinfo.window->IsKindOf(CLASSINFO(wxToolBar)))
1194 {
1195 // GetClientSize() doesn't get the best size for
1196 // a toolbar under some newer versions of wxWidgets,
1197 // so use GetBestSize()
1198 pinfo.best_size = pinfo.window->GetBestSize();
1199 }
1200 #endif // wxUSE_TOOLBAR
1201
1202 if (pinfo.min_size != wxDefaultSize)
1203 {
1204 if (pinfo.best_size.x < pinfo.min_size.x)
1205 pinfo.best_size.x = pinfo.min_size.x;
1206 if (pinfo.best_size.y < pinfo.min_size.y)
1207 pinfo.best_size.y = pinfo.min_size.y;
1208 }
1209 }
1210
1211
1212
1213 return true;
1214 }
1215
1216 bool wxAuiManager::AddPane(wxWindow* window,
1217 int direction,
1218 const wxString& caption)
1219 {
1220 wxAuiPaneInfo pinfo;
1221 pinfo.Caption(caption);
1222 switch (direction)
1223 {
1224 case wxTOP: pinfo.Top(); break;
1225 case wxBOTTOM: pinfo.Bottom(); break;
1226 case wxLEFT: pinfo.Left(); break;
1227 case wxRIGHT: pinfo.Right(); break;
1228 case wxCENTER: pinfo.CenterPane(); break;
1229 }
1230 return AddPane(window, pinfo);
1231 }
1232
1233 bool wxAuiManager::AddPane(wxWindow* window,
1234 const wxAuiPaneInfo& pane_info,
1235 const wxPoint& drop_pos)
1236 {
1237 if (!AddPane(window, pane_info))
1238 return false;
1239
1240 wxAuiPaneInfo& pane = GetPane(window);
1241
1242 DoDrop(m_docks, m_panes, pane, drop_pos, wxPoint(0,0));
1243
1244 return true;
1245 }
1246
1247 bool wxAuiManager::InsertPane(wxWindow* window, const wxAuiPaneInfo& pane_info,
1248 int insert_level)
1249 {
1250 wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed"));
1251
1252 // shift the panes around, depending on the insert level
1253 switch (insert_level)
1254 {
1255 case wxAUI_INSERT_PANE:
1256 DoInsertPane(m_panes,
1257 pane_info.dock_direction,
1258 pane_info.dock_layer,
1259 pane_info.dock_row,
1260 pane_info.dock_pos);
1261 break;
1262 case wxAUI_INSERT_ROW:
1263 DoInsertDockRow(m_panes,
1264 pane_info.dock_direction,
1265 pane_info.dock_layer,
1266 pane_info.dock_row);
1267 break;
1268 case wxAUI_INSERT_DOCK:
1269 DoInsertDockLayer(m_panes,
1270 pane_info.dock_direction,
1271 pane_info.dock_layer);
1272 break;
1273 }
1274
1275 // if the window already exists, we are basically just moving/inserting the
1276 // existing window. If it doesn't exist, we need to add it and insert it
1277 wxAuiPaneInfo& existing_pane = GetPane(window);
1278 if (!existing_pane.IsOk())
1279 {
1280 return AddPane(window, pane_info);
1281 }
1282 else
1283 {
1284 if (pane_info.IsFloating())
1285 {
1286 existing_pane.Float();
1287 if (pane_info.floating_pos != wxDefaultPosition)
1288 existing_pane.FloatingPosition(pane_info.floating_pos);
1289 if (pane_info.floating_size != wxDefaultSize)
1290 existing_pane.FloatingSize(pane_info.floating_size);
1291 }
1292 else
1293 {
1294 // if the new pane is docked then we should undo maximize
1295 RestoreMaximizedPane();
1296
1297 existing_pane.Direction(pane_info.dock_direction);
1298 existing_pane.Layer(pane_info.dock_layer);
1299 existing_pane.Row(pane_info.dock_row);
1300 existing_pane.Position(pane_info.dock_pos);
1301 }
1302 }
1303
1304 return true;
1305 }
1306
1307
1308 // DetachPane() removes a pane from the frame manager. This
1309 // method will not destroy the window that is removed.
1310 bool wxAuiManager::DetachPane(wxWindow* window)
1311 {
1312 wxASSERT_MSG(window, wxT("NULL window ptrs are not allowed"));
1313
1314 int i, count;
1315 for (i = 0, count = m_panes.GetCount(); i < count; ++i)
1316 {
1317 wxAuiPaneInfo& p = m_panes.Item(i);
1318 if (p.window == window)
1319 {
1320 if (p.frame)
1321 {
1322 // we have a floating frame which is being detached. We need to
1323 // reparent it to m_frame and destroy the floating frame
1324
1325 // reduce flicker
1326 p.window->SetSize(1,1);
1327
1328 if (p.frame->IsShown())
1329 p.frame->Show(false);
1330
1331 // reparent to m_frame and destroy the pane
1332 if (m_action_window == p.frame)
1333 {
1334 m_action_window = NULL;
1335 }
1336
1337 p.window->Reparent(m_frame);
1338 p.frame->SetSizer(NULL);
1339 p.frame->Destroy();
1340 p.frame = NULL;
1341 }
1342
1343 // make sure there are no references to this pane in our uiparts,
1344 // just in case the caller doesn't call Update() immediately after
1345 // the DetachPane() call. This prevets obscure crashes which would
1346 // happen at window repaint if the caller forgets to call Update()
1347 int pi, part_count;
1348 for (pi = 0, part_count = (int)m_uiparts.GetCount(); pi < part_count; ++pi)
1349 {
1350 wxAuiDockUIPart& part = m_uiparts.Item(pi);
1351 if (part.pane == &p)
1352 {
1353 m_uiparts.RemoveAt(pi);
1354 part_count--;
1355 pi--;
1356 continue;
1357 }
1358 }
1359
1360 m_panes.RemoveAt(i);
1361 return true;
1362 }
1363 }
1364 return false;
1365 }
1366
1367 // ClosePane() destroys or hides the pane depending on its flags
1368 void wxAuiManager::ClosePane(wxAuiPaneInfo& pane_info)
1369 {
1370 // if we were maximized, restore
1371 if (pane_info.IsMaximized())
1372 {
1373 RestorePane(pane_info);
1374 }
1375
1376 // first, hide the window
1377 if (pane_info.window && pane_info.window->IsShown())
1378 {
1379 pane_info.window->Show(false);
1380 }
1381
1382 // make sure that we are the parent of this window
1383 if (pane_info.window && pane_info.window->GetParent() != m_frame)
1384 {
1385 pane_info.window->Reparent(m_frame);
1386 }
1387
1388 // if we have a frame, destroy it
1389 if (pane_info.frame)
1390 {
1391 pane_info.frame->Destroy();
1392 pane_info.frame = NULL;
1393 }
1394
1395 // now we need to either destroy or hide the pane
1396 if (pane_info.IsDestroyOnClose())
1397 {
1398 wxWindow * window = pane_info.window;
1399 DetachPane(window);
1400 if (window)
1401 {
1402 window->Destroy();
1403 }
1404 }
1405 else
1406 {
1407 pane_info.Hide();
1408 }
1409 }
1410
1411 void wxAuiManager::MaximizePane(wxAuiPaneInfo& pane_info)
1412 {
1413 int i, pane_count;
1414
1415 // un-maximize and hide all other panes
1416 for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
1417 {
1418 wxAuiPaneInfo& p = m_panes.Item(i);
1419 if (!p.IsToolbar() && !p.IsFloating())
1420 {
1421 p.Restore();
1422
1423 // save hidden state
1424 p.SetFlag(wxAuiPaneInfo::savedHiddenState,
1425 p.HasFlag(wxAuiPaneInfo::optionHidden));
1426
1427 // hide the pane, because only the newly
1428 // maximized pane should show
1429 p.Hide();
1430 }
1431 }
1432
1433 // mark ourselves maximized
1434 pane_info.Maximize();
1435 pane_info.Show();
1436 m_has_maximized = true;
1437
1438 // last, show the window
1439 if (pane_info.window && !pane_info.window->IsShown())
1440 {
1441 pane_info.window->Show(true);
1442 }
1443 }
1444
1445 void wxAuiManager::RestorePane(wxAuiPaneInfo& pane_info)
1446 {
1447 int i, pane_count;
1448
1449 // restore all the panes
1450 for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
1451 {
1452 wxAuiPaneInfo& p = m_panes.Item(i);
1453 if (!p.IsToolbar())
1454 {
1455 p.SetFlag(wxAuiPaneInfo::optionHidden,
1456 p.HasFlag(wxAuiPaneInfo::savedHiddenState));
1457 }
1458 }
1459
1460 // mark ourselves non-maximized
1461 pane_info.Restore();
1462 m_has_maximized = false;
1463
1464 // last, show the window
1465 if (pane_info.window && !pane_info.window->IsShown())
1466 {
1467 pane_info.window->Show(true);
1468 }
1469 }
1470
1471 void wxAuiManager::RestoreMaximizedPane()
1472 {
1473 int i, pane_count;
1474
1475 // restore all the panes
1476 for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
1477 {
1478 wxAuiPaneInfo& p = m_panes.Item(i);
1479 if (p.IsMaximized())
1480 {
1481 RestorePane(p);
1482 break;
1483 }
1484 }
1485 }
1486
1487 // EscapeDelimiters() changes ";" into "\;" and "|" into "\|"
1488 // in the input string. This is an internal functions which is
1489 // used for saving perspectives
1490 static wxString EscapeDelimiters(const wxString& s)
1491 {
1492 wxString result;
1493 result.Alloc(s.length());
1494 const wxChar* ch = s.c_str();
1495 while (*ch)
1496 {
1497 if (*ch == wxT(';') || *ch == wxT('|'))
1498 result += wxT('\\');
1499 result += *ch;
1500 ++ch;
1501 }
1502 return result;
1503 }
1504
1505 wxString wxAuiManager::SavePaneInfo(wxAuiPaneInfo& pane)
1506 {
1507 wxString result = wxT("name=");
1508 result += EscapeDelimiters(pane.name);
1509 result += wxT(";");
1510
1511 result += wxT("caption=");
1512 result += EscapeDelimiters(pane.caption);
1513 result += wxT(";");
1514
1515 result += wxString::Format(wxT("state=%u;"), pane.state);
1516 result += wxString::Format(wxT("dir=%d;"), pane.dock_direction);
1517 result += wxString::Format(wxT("layer=%d;"), pane.dock_layer);
1518 result += wxString::Format(wxT("row=%d;"), pane.dock_row);
1519 result += wxString::Format(wxT("pos=%d;"), pane.dock_pos);
1520 result += wxString::Format(wxT("prop=%d;"), pane.dock_proportion);
1521 result += wxString::Format(wxT("bestw=%d;"), pane.best_size.x);
1522 result += wxString::Format(wxT("besth=%d;"), pane.best_size.y);
1523 result += wxString::Format(wxT("minw=%d;"), pane.min_size.x);
1524 result += wxString::Format(wxT("minh=%d;"), pane.min_size.y);
1525 result += wxString::Format(wxT("maxw=%d;"), pane.max_size.x);
1526 result += wxString::Format(wxT("maxh=%d;"), pane.max_size.y);
1527 result += wxString::Format(wxT("floatx=%d;"), pane.floating_pos.x);
1528 result += wxString::Format(wxT("floaty=%d;"), pane.floating_pos.y);
1529 result += wxString::Format(wxT("floatw=%d;"), pane.floating_size.x);
1530 result += wxString::Format(wxT("floath=%d"), pane.floating_size.y);
1531
1532 return result;
1533 }
1534
1535 // Load a "pane" with the pane infor settings in pane_part
1536 void wxAuiManager::LoadPaneInfo(wxString pane_part, wxAuiPaneInfo &pane)
1537 {
1538 // replace escaped characters so we can
1539 // split up the string easily
1540 pane_part.Replace(wxT("\\|"), wxT("\a"));
1541 pane_part.Replace(wxT("\\;"), wxT("\b"));
1542
1543 while(1)
1544 {
1545 wxString val_part = pane_part.BeforeFirst(wxT(';'));
1546 pane_part = pane_part.AfterFirst(wxT(';'));
1547 wxString val_name = val_part.BeforeFirst(wxT('='));
1548 wxString value = val_part.AfterFirst(wxT('='));
1549 val_name.MakeLower();
1550 val_name.Trim(true);
1551 val_name.Trim(false);
1552 value.Trim(true);
1553 value.Trim(false);
1554
1555 if (val_name.empty())
1556 break;
1557
1558 if (val_name == wxT("name"))
1559 pane.name = value;
1560 else if (val_name == wxT("caption"))
1561 pane.caption = value;
1562 else if (val_name == wxT("state"))
1563 pane.state = (unsigned int)wxAtoi(value.c_str());
1564 else if (val_name == wxT("dir"))
1565 pane.dock_direction = wxAtoi(value.c_str());
1566 else if (val_name == wxT("layer"))
1567 pane.dock_layer = wxAtoi(value.c_str());
1568 else if (val_name == wxT("row"))
1569 pane.dock_row = wxAtoi(value.c_str());
1570 else if (val_name == wxT("pos"))
1571 pane.dock_pos = wxAtoi(value.c_str());
1572 else if (val_name == wxT("prop"))
1573 pane.dock_proportion = wxAtoi(value.c_str());
1574 else if (val_name == wxT("bestw"))
1575 pane.best_size.x = wxAtoi(value.c_str());
1576 else if (val_name == wxT("besth"))
1577 pane.best_size.y = wxAtoi(value.c_str());
1578 else if (val_name == wxT("minw"))
1579 pane.min_size.x = wxAtoi(value.c_str());
1580 else if (val_name == wxT("minh"))
1581 pane.min_size.y = wxAtoi(value.c_str());
1582 else if (val_name == wxT("maxw"))
1583 pane.max_size.x = wxAtoi(value.c_str());
1584 else if (val_name == wxT("maxh"))
1585 pane.max_size.y = wxAtoi(value.c_str());
1586 else if (val_name == wxT("floatx"))
1587 pane.floating_pos.x = wxAtoi(value.c_str());
1588 else if (val_name == wxT("floaty"))
1589 pane.floating_pos.y = wxAtoi(value.c_str());
1590 else if (val_name == wxT("floatw"))
1591 pane.floating_size.x = wxAtoi(value.c_str());
1592 else if (val_name == wxT("floath"))
1593 pane.floating_size.y = wxAtoi(value.c_str());
1594 else {
1595 wxFAIL_MSG(wxT("Bad Perspective String"));
1596 }
1597 }
1598
1599 // replace escaped characters so we can
1600 // split up the string easily
1601 pane.name.Replace(wxT("\a"), wxT("|"));
1602 pane.name.Replace(wxT("\b"), wxT(";"));
1603 pane.caption.Replace(wxT("\a"), wxT("|"));
1604 pane.caption.Replace(wxT("\b"), wxT(";"));
1605 pane_part.Replace(wxT("\a"), wxT("|"));
1606 pane_part.Replace(wxT("\b"), wxT(";"));
1607
1608 return;
1609 }
1610
1611
1612 // SavePerspective() saves all pane information as a single string.
1613 // This string may later be fed into LoadPerspective() to restore
1614 // all pane settings. This save and load mechanism allows an
1615 // exact pane configuration to be saved and restored at a later time
1616
1617 wxString wxAuiManager::SavePerspective()
1618 {
1619 wxString result;
1620 result.Alloc(500);
1621 result = wxT("layout2|");
1622
1623 int pane_i, pane_count = m_panes.GetCount();
1624 for (pane_i = 0; pane_i < pane_count; ++pane_i)
1625 {
1626 wxAuiPaneInfo& pane = m_panes.Item(pane_i);
1627 result += SavePaneInfo(pane)+wxT("|");
1628 }
1629
1630 int dock_i, dock_count = m_docks.GetCount();
1631 for (dock_i = 0; dock_i < dock_count; ++dock_i)
1632 {
1633 wxAuiDockInfo& dock = m_docks.Item(dock_i);
1634
1635 result += wxString::Format(wxT("dock_size(%d,%d,%d)=%d|"),
1636 dock.dock_direction, dock.dock_layer,
1637 dock.dock_row, dock.size);
1638 }
1639
1640 return result;
1641 }
1642
1643 // LoadPerspective() loads a layout which was saved with SavePerspective()
1644 // If the "update" flag parameter is true, the GUI will immediately be updated
1645
1646 bool wxAuiManager::LoadPerspective(const wxString& layout, bool update)
1647 {
1648 wxString input = layout;
1649 wxString part;
1650
1651 // check layout string version
1652 // 'layout1' = wxAUI 0.9.0 - wxAUI 0.9.2
1653 // 'layout2' = wxAUI 0.9.2 (wxWidgets 2.8)
1654 part = input.BeforeFirst(wxT('|'));
1655 input = input.AfterFirst(wxT('|'));
1656 part.Trim(true);
1657 part.Trim(false);
1658 if (part != wxT("layout2"))
1659 return false;
1660
1661 // mark all panes currently managed as docked and hidden
1662 int pane_i, pane_count = m_panes.GetCount();
1663 for (pane_i = 0; pane_i < pane_count; ++pane_i)
1664 m_panes.Item(pane_i).Dock().Hide();
1665
1666 // clear out the dock array; this will be reconstructed
1667 m_docks.Clear();
1668
1669 // replace escaped characters so we can
1670 // split up the string easily
1671 input.Replace(wxT("\\|"), wxT("\a"));
1672 input.Replace(wxT("\\;"), wxT("\b"));
1673
1674 while (1)
1675 {
1676 wxAuiPaneInfo pane;
1677
1678 wxString pane_part = input.BeforeFirst(wxT('|'));
1679 input = input.AfterFirst(wxT('|'));
1680 pane_part.Trim(true);
1681
1682 // if the string is empty, we're done parsing
1683 if (pane_part.empty())
1684 break;
1685
1686 if (pane_part.Left(9) == wxT("dock_size"))
1687 {
1688 wxString val_name = pane_part.BeforeFirst(wxT('='));
1689 wxString value = pane_part.AfterFirst(wxT('='));
1690
1691 long dir, layer, row, size;
1692 wxString piece = val_name.AfterFirst(wxT('('));
1693 piece = piece.BeforeLast(wxT(')'));
1694 piece.BeforeFirst(wxT(',')).ToLong(&dir);
1695 piece = piece.AfterFirst(wxT(','));
1696 piece.BeforeFirst(wxT(',')).ToLong(&layer);
1697 piece.AfterFirst(wxT(',')).ToLong(&row);
1698 value.ToLong(&size);
1699
1700 wxAuiDockInfo dock;
1701 dock.dock_direction = dir;
1702 dock.dock_layer = layer;
1703 dock.dock_row = row;
1704 dock.size = size;
1705 m_docks.Add(dock);
1706 continue;
1707 }
1708
1709 // Undo our escaping as LoadPaneInfo needs to take an unescaped
1710 // name so it can be called by external callers
1711 pane_part.Replace(wxT("\a"), wxT("|"));
1712 pane_part.Replace(wxT("\b"), wxT(";"));
1713
1714 LoadPaneInfo(pane_part, pane);
1715
1716 wxAuiPaneInfo& p = GetPane(pane.name);
1717 if (!p.IsOk())
1718 {
1719 // the pane window couldn't be found
1720 // in the existing layout -- skip it
1721 continue;
1722 }
1723
1724 p.SafeSet(pane);
1725 }
1726
1727 if (update)
1728 Update();
1729
1730 return true;
1731 }
1732
1733 void wxAuiManager::GetPanePositionsAndSizes(wxAuiDockInfo& dock,
1734 wxArrayInt& positions,
1735 wxArrayInt& sizes)
1736 {
1737 int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
1738 int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
1739 int gripper_size = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
1740
1741 positions.Empty();
1742 sizes.Empty();
1743
1744 int offset, action_pane = -1;
1745 int pane_i, pane_count = dock.panes.GetCount();
1746
1747 // find the pane marked as our action pane
1748 for (pane_i = 0; pane_i < pane_count; ++pane_i)
1749 {
1750 wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
1751
1752 if (pane.HasFlag(wxAuiPaneInfo::actionPane))
1753 {
1754 wxASSERT_MSG(action_pane==-1, wxT("Too many fixed action panes"));
1755 action_pane = pane_i;
1756 }
1757 }
1758
1759 // set up each panes default position, and
1760 // determine the size (width or height, depending
1761 // on the dock's orientation) of each pane
1762 for (pane_i = 0; pane_i < pane_count; ++pane_i)
1763 {
1764 wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
1765 positions.Add(pane.dock_pos);
1766 int size = 0;
1767
1768 if (pane.HasBorder())
1769 size += (pane_border_size*2);
1770
1771 if (dock.IsHorizontal())
1772 {
1773 if (pane.HasGripper() && !pane.HasGripperTop())
1774 size += gripper_size;
1775 size += pane.best_size.x;
1776 }
1777 else
1778 {
1779 if (pane.HasGripper() && pane.HasGripperTop())
1780 size += gripper_size;
1781
1782 if (pane.HasCaption())
1783 size += caption_size;
1784 size += pane.best_size.y;
1785 }
1786
1787 sizes.Add(size);
1788 }
1789
1790 // if there is no action pane, just return the default
1791 // positions (as specified in pane.pane_pos)
1792 if (action_pane == -1)
1793 return;
1794
1795 offset = 0;
1796 for (pane_i = action_pane-1; pane_i >= 0; --pane_i)
1797 {
1798 int amount = positions[pane_i+1] - (positions[pane_i] + sizes[pane_i]);
1799
1800 if (amount >= 0)
1801 offset += amount;
1802 else
1803 positions[pane_i] -= -amount;
1804
1805 offset += sizes[pane_i];
1806 }
1807
1808 // if the dock mode is fixed, make sure none of the panes
1809 // overlap; we will bump panes that overlap
1810 offset = 0;
1811 for (pane_i = action_pane; pane_i < pane_count; ++pane_i)
1812 {
1813 int amount = positions[pane_i] - offset;
1814 if (amount >= 0)
1815 offset += amount;
1816 else
1817 positions[pane_i] += -amount;
1818
1819 offset += sizes[pane_i];
1820 }
1821 }
1822
1823
1824 void wxAuiManager::LayoutAddPane(wxSizer* cont,
1825 wxAuiDockInfo& dock,
1826 wxAuiPaneInfo& pane,
1827 wxAuiDockUIPartArray& uiparts,
1828 bool spacer_only)
1829 {
1830 wxAuiDockUIPart part;
1831 wxSizerItem* sizer_item;
1832
1833 int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
1834 int gripper_size = m_art->GetMetric(wxAUI_DOCKART_GRIPPER_SIZE);
1835 int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
1836 int pane_button_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BUTTON_SIZE);
1837
1838 // find out the orientation of the item (orientation for panes
1839 // is the same as the dock's orientation)
1840 int orientation;
1841 if (dock.IsHorizontal())
1842 orientation = wxHORIZONTAL;
1843 else
1844 orientation = wxVERTICAL;
1845
1846 // this variable will store the proportion
1847 // value that the pane will receive
1848 int pane_proportion = pane.dock_proportion;
1849
1850 wxAuiProportionalBoxSizer* horz_pane_sizer = new wxAuiProportionalBoxSizer(wxHORIZONTAL);
1851 wxAuiProportionalBoxSizer* vert_pane_sizer = new wxAuiProportionalBoxSizer(wxVERTICAL);
1852
1853 if (pane.HasGripper())
1854 {
1855 if (pane.HasGripperTop())
1856 sizer_item = vert_pane_sizer ->Add(1, gripper_size, 0, wxEXPAND);
1857 else
1858 sizer_item = horz_pane_sizer ->Add(gripper_size, 1, 0, wxEXPAND);
1859
1860 part.type = wxAuiDockUIPart::typeGripper;
1861 part.dock = &dock;
1862 part.pane = &pane;
1863 part.button = NULL;
1864 part.orientation = orientation;
1865 part.cont_sizer = horz_pane_sizer;
1866 part.sizer_item = sizer_item;
1867 uiparts.Add(part);
1868 }
1869
1870 if (pane.HasCaption())
1871 {
1872 // create the caption sizer
1873 wxAuiProportionalBoxSizer* caption_sizer = new wxAuiProportionalBoxSizer(wxHORIZONTAL);
1874
1875 sizer_item = caption_sizer->Add(1, caption_size, 1, wxEXPAND);
1876
1877 part.type = wxAuiDockUIPart::typeCaption;
1878 part.dock = &dock;
1879 part.pane = &pane;
1880 part.button = NULL;
1881 part.orientation = orientation;
1882 part.cont_sizer = vert_pane_sizer;
1883 part.sizer_item = sizer_item;
1884 int caption_part_idx = uiparts.GetCount();
1885 uiparts.Add(part);
1886
1887 // add pane buttons to the caption
1888 int i, button_count;
1889 for (i = 0, button_count = pane.buttons.GetCount();
1890 i < button_count; ++i)
1891 {
1892 wxAuiPaneButton& button = pane.buttons.Item(i);
1893
1894 sizer_item = caption_sizer->Add(pane_button_size,
1895 caption_size,
1896 0, wxEXPAND);
1897
1898 part.type = wxAuiDockUIPart::typePaneButton;
1899 part.dock = &dock;
1900 part.pane = &pane;
1901 part.button = &button;
1902 part.orientation = orientation;
1903 part.cont_sizer = caption_sizer;
1904 part.sizer_item = sizer_item;
1905 uiparts.Add(part);
1906 }
1907
1908 // if we have buttons, add a little space to the right
1909 // of them to ease visual crowding
1910 if (button_count >= 1)
1911 {
1912 caption_sizer->Add(3,1);
1913 }
1914
1915 // add the caption sizer
1916 sizer_item = vert_pane_sizer->Add(caption_sizer, 0, wxEXPAND);
1917
1918 uiparts.Item(caption_part_idx).sizer_item = sizer_item;
1919 }
1920
1921 // add the pane window itself
1922 if (spacer_only)
1923 {
1924 sizer_item = vert_pane_sizer->Add(1, 1, 1, wxEXPAND);
1925 }
1926 else
1927 {
1928 sizer_item = vert_pane_sizer->Add(pane.window, 1, wxEXPAND);
1929 // Don't do this because it breaks the pane size in floating windows
1930 // BIW: Right now commenting this out is causing problems with
1931 // an mdi client window as the center pane.
1932 vert_pane_sizer->SetItemMinSize(pane.window, 1, 1);
1933 }
1934
1935 part.type = wxAuiDockUIPart::typePane;
1936 part.dock = &dock;
1937 part.pane = &pane;
1938 part.button = NULL;
1939 part.orientation = orientation;
1940 part.cont_sizer = vert_pane_sizer;
1941 part.sizer_item = sizer_item;
1942 uiparts.Add(part);
1943
1944
1945 // determine if the pane should have a minimum size; if the pane is
1946 // non-resizable (fixed) then we must set a minimum size. Alternatively,
1947 // if the pane.min_size is set, we must use that value as well
1948
1949 wxSize min_size = pane.min_size;
1950 if (pane.IsFixed())
1951 {
1952 if (min_size == wxDefaultSize)
1953 {
1954 min_size = pane.best_size;
1955 pane_proportion = 0;
1956 }
1957 }
1958
1959 if (min_size != wxDefaultSize)
1960 {
1961 vert_pane_sizer->SetItemMinSize(
1962 vert_pane_sizer->GetChildren().GetCount()-1,
1963 min_size.x, min_size.y);
1964 }
1965
1966
1967 // add the verticle sizer (caption, pane window) to the
1968 // horizontal sizer (gripper, verticle sizer)
1969 horz_pane_sizer->Add(vert_pane_sizer, 1, wxEXPAND);
1970
1971 // finally, add the pane sizer to the dock sizer
1972
1973 if (pane.HasBorder())
1974 {
1975 // allowing space for the pane's border
1976 sizer_item = cont->Add(horz_pane_sizer, pane_proportion,
1977 wxEXPAND | wxALL, pane_border_size);
1978
1979 part.type = wxAuiDockUIPart::typePaneBorder;
1980 part.dock = &dock;
1981 part.pane = &pane;
1982 part.button = NULL;
1983 part.orientation = orientation;
1984 part.cont_sizer = cont;
1985 part.sizer_item = sizer_item;
1986 uiparts.Add(part);
1987 }
1988 else
1989 {
1990 sizer_item = cont->Add(horz_pane_sizer, pane_proportion, wxEXPAND);
1991 }
1992 }
1993
1994 void wxAuiManager::LayoutAddDock(wxSizer* cont,
1995 wxAuiDockInfo& dock,
1996 wxAuiDockUIPartArray& uiparts,
1997 bool spacer_only)
1998 {
1999 wxSizerItem* sizer_item;
2000 wxAuiDockUIPart part;
2001
2002 int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE);
2003 int orientation = dock.IsHorizontal() ? wxHORIZONTAL : wxVERTICAL;
2004
2005 // resizable bottom and right docks have a sash before them
2006 if (!m_has_maximized && !dock.fixed && (dock.dock_direction == wxAUI_DOCK_BOTTOM ||
2007 dock.dock_direction == wxAUI_DOCK_RIGHT))
2008 {
2009 sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
2010
2011 part.type = wxAuiDockUIPart::typeDockSizer;
2012 part.orientation = orientation;
2013 part.dock = &dock;
2014 part.pane = NULL;
2015 part.button = NULL;
2016 part.cont_sizer = cont;
2017 part.sizer_item = sizer_item;
2018 uiparts.Add(part);
2019 }
2020
2021 // create the sizer for the dock
2022 wxSizer* dock_sizer = new wxAuiProportionalBoxSizer(orientation);
2023
2024 // add each pane to the dock
2025 bool has_maximized_pane = false;
2026 int pane_i, pane_count = dock.panes.GetCount();
2027
2028 if (dock.fixed)
2029 {
2030 wxArrayInt pane_positions, pane_sizes;
2031
2032 // figure out the real pane positions we will
2033 // use, without modifying the each pane's pane_pos member
2034 GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
2035
2036 int offset = 0;
2037 for (pane_i = 0; pane_i < pane_count; ++pane_i)
2038 {
2039 wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
2040 int pane_pos = pane_positions.Item(pane_i);
2041
2042 if (pane.IsMaximized())
2043 has_maximized_pane = true;
2044
2045
2046 int amount = pane_pos - offset;
2047 if (amount > 0)
2048 {
2049 if (dock.IsVertical())
2050 sizer_item = dock_sizer->Add(1, amount, 0, wxEXPAND);
2051 else
2052 sizer_item = dock_sizer->Add(amount, 1, 0, wxEXPAND);
2053
2054 part.type = wxAuiDockUIPart::typeBackground;
2055 part.dock = &dock;
2056 part.pane = NULL;
2057 part.button = NULL;
2058 part.orientation = (orientation==wxHORIZONTAL) ? wxVERTICAL:wxHORIZONTAL;
2059 part.cont_sizer = dock_sizer;
2060 part.sizer_item = sizer_item;
2061 uiparts.Add(part);
2062
2063 offset += amount;
2064 }
2065
2066 LayoutAddPane(dock_sizer, dock, pane, uiparts, spacer_only);
2067
2068 offset += pane_sizes.Item(pane_i);
2069 }
2070
2071 // at the end add a very small stretchable background area
2072 sizer_item = dock_sizer->Add(0,0, 1, wxEXPAND);
2073
2074 part.type = wxAuiDockUIPart::typeBackground;
2075 part.dock = &dock;
2076 part.pane = NULL;
2077 part.button = NULL;
2078 part.orientation = orientation;
2079 part.cont_sizer = dock_sizer;
2080 part.sizer_item = sizer_item;
2081 uiparts.Add(part);
2082 }
2083 else
2084 {
2085 for (pane_i = 0; pane_i < pane_count; ++pane_i)
2086 {
2087 wxAuiPaneInfo& pane = *(dock.panes.Item(pane_i));
2088
2089 if (pane.IsMaximized())
2090 has_maximized_pane = true;
2091
2092 // if this is not the first pane being added,
2093 // we need to add a pane sizer
2094 if (!m_has_maximized && pane_i > 0)
2095 {
2096 sizer_item = dock_sizer->Add(sash_size, sash_size, 0, wxEXPAND);
2097
2098 part.type = wxAuiDockUIPart::typePaneSizer;
2099 part.dock = &dock;
2100 part.pane = dock.panes.Item(pane_i-1);
2101 part.button = NULL;
2102 part.orientation = (orientation==wxHORIZONTAL) ? wxVERTICAL:wxHORIZONTAL;
2103 part.cont_sizer = dock_sizer;
2104 part.sizer_item = sizer_item;
2105 uiparts.Add(part);
2106 }
2107
2108 LayoutAddPane(dock_sizer, dock, pane, uiparts, spacer_only);
2109 }
2110 }
2111
2112 if (dock.dock_direction == wxAUI_DOCK_CENTER || has_maximized_pane)
2113 sizer_item = cont->Add(dock_sizer, 1, wxEXPAND);
2114 else
2115 sizer_item = cont->Add(dock_sizer, 0, wxEXPAND);
2116
2117 part.type = wxAuiDockUIPart::typeDock;
2118 part.dock = &dock;
2119 part.pane = NULL;
2120 part.button = NULL;
2121 part.orientation = orientation;
2122 part.cont_sizer = cont;
2123 part.sizer_item = sizer_item;
2124 uiparts.Add(part);
2125
2126 if (dock.IsHorizontal())
2127 cont->SetItemMinSize(dock_sizer, 0, dock.size);
2128 else
2129 cont->SetItemMinSize(dock_sizer, dock.size, 0);
2130
2131 // top and left docks have a sash after them
2132 if (!m_has_maximized &&
2133 !dock.fixed &&
2134 (dock.dock_direction == wxAUI_DOCK_TOP ||
2135 dock.dock_direction == wxAUI_DOCK_LEFT))
2136 {
2137 sizer_item = cont->Add(sash_size, sash_size, 0, wxEXPAND);
2138
2139 part.type = wxAuiDockUIPart::typeDockSizer;
2140 part.dock = &dock;
2141 part.pane = NULL;
2142 part.button = NULL;
2143 part.orientation = orientation;
2144 part.cont_sizer = cont;
2145 part.sizer_item = sizer_item;
2146 uiparts.Add(part);
2147 }
2148 }
2149
2150 wxSizer* wxAuiManager::LayoutAll(wxAuiPaneInfoArray& panes,
2151 wxAuiDockInfoArray& docks,
2152 wxAuiDockUIPartArray& uiparts,
2153 bool spacer_only)
2154 {
2155 wxAuiProportionalBoxSizer* container = new wxAuiProportionalBoxSizer(wxVERTICAL);
2156
2157 int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
2158 int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
2159 wxSize cli_size = m_frame->GetClientSize();
2160 int i, dock_count, pane_count;
2161
2162
2163 // empty all docks out
2164 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
2165 {
2166 wxAuiDockInfo& dock = docks.Item(i);
2167
2168 // empty out all panes, as they will be readded below
2169 dock.panes.Empty();
2170
2171 if (dock.fixed)
2172 {
2173 // always reset fixed docks' sizes, because
2174 // the contained windows may have been resized
2175 dock.size = 0;
2176 }
2177 }
2178
2179
2180 // iterate through all known panes, filing each
2181 // of them into the appropriate dock. If the
2182 // pane does not exist in the dock, add it
2183 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
2184 {
2185 wxAuiPaneInfo& p = panes.Item(i);
2186
2187 // find any docks with the same dock direction, dock layer, and
2188 // dock row as the pane we are working on
2189 wxAuiDockInfo* dock;
2190 wxAuiDockInfoPtrArray arr;
2191 FindDocks(docks, p.dock_direction, p.dock_layer, p.dock_row, arr);
2192
2193 if (arr.GetCount() > 0)
2194 {
2195 // found the right dock
2196 dock = arr.Item(0);
2197 }
2198 else
2199 {
2200 // dock was not found, so we need to create a new one
2201 wxAuiDockInfo d;
2202 d.dock_direction = p.dock_direction;
2203 d.dock_layer = p.dock_layer;
2204 d.dock_row = p.dock_row;
2205 docks.Add(d);
2206 dock = &docks.Last();
2207 }
2208
2209
2210 if (p.IsDocked() && p.IsShown())
2211 {
2212 // remove the pane from any existing docks except this one
2213 RemovePaneFromDocks(docks, p, dock);
2214
2215 // pane needs to be added to the dock,
2216 // if it doesn't already exist
2217 if (!FindPaneInDock(*dock, p.window))
2218 dock->panes.Add(&p);
2219 }
2220 else
2221 {
2222 // remove the pane from any existing docks
2223 RemovePaneFromDocks(docks, p);
2224 }
2225
2226 }
2227
2228 // remove any empty docks
2229 for (i = docks.GetCount()-1; i >= 0; --i)
2230 {
2231 if (docks.Item(i).panes.GetCount() == 0)
2232 docks.RemoveAt(i);
2233 }
2234
2235 // configure the docks further
2236 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
2237 {
2238 wxAuiDockInfo& dock = docks.Item(i);
2239 int j, dock_pane_count = dock.panes.GetCount();
2240
2241 // sort the dock pane array by the pane's
2242 // dock position (dock_pos), in ascending order
2243 dock.panes.Sort(PaneSortFunc);
2244
2245 // for newly created docks, set up their initial size
2246 if (dock.size == 0)
2247 {
2248 int size = 0;
2249
2250 for (j = 0; j < dock_pane_count; ++j)
2251 {
2252 wxAuiPaneInfo& pane = *dock.panes.Item(j);
2253 wxSize pane_size = pane.best_size;
2254 if (pane_size == wxDefaultSize)
2255 pane_size = pane.min_size;
2256 if (pane_size == wxDefaultSize)
2257 pane_size = pane.window->GetSize();
2258
2259 if (dock.IsHorizontal())
2260 size = wxMax(pane_size.y, size);
2261 else
2262 size = wxMax(pane_size.x, size);
2263 }
2264
2265 // add space for the border (two times), but only
2266 // if at least one pane inside the dock has a pane border
2267 for (j = 0; j < dock_pane_count; ++j)
2268 {
2269 if (dock.panes.Item(j)->HasBorder())
2270 {
2271 size += (pane_border_size*2);
2272 break;
2273 }
2274 }
2275
2276 // if pane is on the top or bottom, add the caption height,
2277 // but only if at least one pane inside the dock has a caption
2278 if (dock.IsHorizontal())
2279 {
2280 for (j = 0; j < dock_pane_count; ++j)
2281 {
2282 if (dock.panes.Item(j)->HasCaption())
2283 {
2284 size += caption_size;
2285 break;
2286 }
2287 }
2288 }
2289
2290
2291 // new dock's size may not be more than the dock constraint
2292 // parameter specifies. See SetDockSizeConstraint()
2293
2294 int max_dock_x_size = (int)(m_dock_constraint_x * ((double)cli_size.x));
2295 int max_dock_y_size = (int)(m_dock_constraint_y * ((double)cli_size.y));
2296
2297 if (dock.IsHorizontal())
2298 size = wxMin(size, max_dock_y_size);
2299 else
2300 size = wxMin(size, max_dock_x_size);
2301
2302 // absolute minimum size for a dock is 10 pixels
2303 if (size < 10)
2304 size = 10;
2305
2306 dock.size = size;
2307 }
2308
2309
2310 // determine the dock's minimum size
2311 bool plus_border = false;
2312 bool plus_caption = false;
2313 int dock_min_size = 0;
2314 for (j = 0; j < dock_pane_count; ++j)
2315 {
2316 wxAuiPaneInfo& pane = *dock.panes.Item(j);
2317 if (pane.min_size != wxDefaultSize)
2318 {
2319 if (pane.HasBorder())
2320 plus_border = true;
2321 if (pane.HasCaption())
2322 plus_caption = true;
2323 if (dock.IsHorizontal())
2324 {
2325 if (pane.min_size.y > dock_min_size)
2326 dock_min_size = pane.min_size.y;
2327 }
2328 else
2329 {
2330 if (pane.min_size.x > dock_min_size)
2331 dock_min_size = pane.min_size.x;
2332 }
2333 }
2334 }
2335
2336 if (plus_border)
2337 dock_min_size += (pane_border_size*2);
2338 if (plus_caption && dock.IsHorizontal())
2339 dock_min_size += (caption_size);
2340
2341 dock.min_size = dock_min_size;
2342
2343
2344 // if the pane's current size is less than it's
2345 // minimum, increase the dock's size to it's minimum
2346 if (dock.size < dock.min_size)
2347 dock.size = dock.min_size;
2348
2349
2350 // determine the dock's mode (fixed or proportional);
2351 // determine whether the dock has only toolbars
2352 bool action_pane_marked = false;
2353 dock.fixed = true;
2354 dock.toolbar = true;
2355 for (j = 0; j < dock_pane_count; ++j)
2356 {
2357 wxAuiPaneInfo& pane = *dock.panes.Item(j);
2358 if (!pane.IsFixed())
2359 dock.fixed = false;
2360 if (!pane.IsToolbar())
2361 dock.toolbar = false;
2362 if (pane.HasFlag(wxAuiPaneInfo::optionDockFixed))
2363 dock.fixed = true;
2364 if (pane.HasFlag(wxAuiPaneInfo::actionPane))
2365 action_pane_marked = true;
2366 }
2367
2368
2369 // if the dock mode is proportional and not fixed-pixel,
2370 // reassign the dock_pos to the sequential 0, 1, 2, 3;
2371 // e.g. remove gaps like 1, 2, 30, 500
2372 if (!dock.fixed)
2373 {
2374 for (j = 0; j < dock_pane_count; ++j)
2375 {
2376 wxAuiPaneInfo& pane = *dock.panes.Item(j);
2377 pane.dock_pos = j;
2378 }
2379 }
2380
2381 // if the dock mode is fixed, and none of the panes
2382 // are being moved right now, make sure the panes
2383 // do not overlap each other. If they do, we will
2384 // adjust the positions of the panes
2385 if (dock.fixed && !action_pane_marked)
2386 {
2387 wxArrayInt pane_positions, pane_sizes;
2388 GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
2389
2390 int offset = 0;
2391 for (j = 0; j < dock_pane_count; ++j)
2392 {
2393 wxAuiPaneInfo& pane = *(dock.panes.Item(j));
2394 pane.dock_pos = pane_positions[j];
2395
2396 int amount = pane.dock_pos - offset;
2397 if (amount >= 0)
2398 offset += amount;
2399 else
2400 pane.dock_pos += -amount;
2401
2402 offset += pane_sizes[j];
2403 }
2404 }
2405 }
2406
2407 // discover the maximum dock layer
2408 int max_layer = 0;
2409 for (i = 0; i < dock_count; ++i)
2410 max_layer = wxMax(max_layer, docks.Item(i).dock_layer);
2411
2412
2413 // clear out uiparts
2414 uiparts.Empty();
2415
2416 // create a bunch of box sizers,
2417 // from the innermost level outwards.
2418 wxSizer* cont = NULL;
2419 wxSizer* middle = NULL;
2420 int layer = 0;
2421 int row, row_count;
2422
2423 for (layer = 0; layer <= max_layer; ++layer)
2424 {
2425 wxAuiDockInfoPtrArray arr;
2426
2427 // find any docks in this layer
2428 FindDocks(docks, -1, layer, -1, arr);
2429
2430 // if there aren't any, skip to the next layer
2431 if (arr.IsEmpty())
2432 continue;
2433
2434 wxSizer* old_cont = cont;
2435
2436 // create a container which will hold this layer's
2437 // docks (top, bottom, left, right)
2438 cont = new wxAuiProportionalBoxSizer(wxVERTICAL);
2439
2440
2441 // find any top docks in this layer
2442 FindDocks(docks, wxAUI_DOCK_TOP, layer, -1, arr);
2443 if (!arr.IsEmpty())
2444 {
2445 for (row = 0, row_count = arr.GetCount(); row < row_count; ++row)
2446 LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only);
2447 }
2448
2449
2450 // fill out the middle layer (which consists
2451 // of left docks, content area and right docks)
2452
2453 middle = new wxAuiProportionalBoxSizer(wxHORIZONTAL);
2454
2455 // find any left docks in this layer
2456 FindDocks(docks, wxAUI_DOCK_LEFT, layer, -1, arr);
2457 if (!arr.IsEmpty())
2458 {
2459 for (row = 0, row_count = arr.GetCount(); row < row_count; ++row)
2460 LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
2461 }
2462
2463 // add content dock (or previous layer's sizer
2464 // to the middle
2465 if (!old_cont)
2466 {
2467 // find any center docks
2468 FindDocks(docks, wxAUI_DOCK_CENTER, -1, -1, arr);
2469 if (!arr.IsEmpty())
2470 {
2471 for (row = 0,row_count = arr.GetCount(); row<row_count; ++row)
2472 LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
2473 }
2474 else if (!m_has_maximized)
2475 {
2476 // there are no center docks, add a background area
2477 wxSizerItem* sizer_item = middle->Add(1,1, 1, wxEXPAND);
2478 wxAuiDockUIPart part;
2479 part.type = wxAuiDockUIPart::typeBackground;
2480 part.pane = NULL;
2481 part.dock = NULL;
2482 part.button = NULL;
2483 part.cont_sizer = middle;
2484 part.sizer_item = sizer_item;
2485 uiparts.Add(part);
2486 }
2487 }
2488 else
2489 {
2490 middle->Add(old_cont, 1, wxEXPAND);
2491 }
2492
2493 // find any right docks in this layer
2494 FindDocks(docks, wxAUI_DOCK_RIGHT, layer, -1, arr);
2495 if (!arr.IsEmpty())
2496 {
2497 for (row = arr.GetCount()-1; row >= 0; --row)
2498 LayoutAddDock(middle, *arr.Item(row), uiparts, spacer_only);
2499 }
2500
2501 if (middle->GetChildren().GetCount() > 0)
2502 cont->Add(middle, 1, wxEXPAND);
2503 else
2504 delete middle;
2505
2506
2507
2508 // find any bottom docks in this layer
2509 FindDocks(docks, wxAUI_DOCK_BOTTOM, layer, -1, arr);
2510 if (!arr.IsEmpty())
2511 {
2512 for (row = arr.GetCount()-1; row >= 0; --row)
2513 LayoutAddDock(cont, *arr.Item(row), uiparts, spacer_only);
2514 }
2515
2516 }
2517
2518 if (!cont)
2519 {
2520 // no sizer available, because there are no docks,
2521 // therefore we will create a simple background area
2522 cont = new wxAuiProportionalBoxSizer(wxVERTICAL);
2523 wxSizerItem* sizer_item = cont->Add(1,1, 1, wxEXPAND);
2524 wxAuiDockUIPart part;
2525 part.type = wxAuiDockUIPart::typeBackground;
2526 part.pane = NULL;
2527 part.dock = NULL;
2528 part.button = NULL;
2529 part.cont_sizer = middle;
2530 part.sizer_item = sizer_item;
2531 uiparts.Add(part);
2532 }
2533
2534 container->Add(cont, 1, wxEXPAND);
2535 return container;
2536 }
2537
2538
2539 // SetDockSizeConstraint() allows the dock constraints to be set. For example,
2540 // specifying values of 0.5, 0.5 will mean that upon dock creation, a dock may
2541 // not be larger than half of the window's size
2542
2543 void wxAuiManager::SetDockSizeConstraint(double width_pct, double height_pct)
2544 {
2545 m_dock_constraint_x = wxMax(0.0, wxMin(1.0, width_pct));
2546 m_dock_constraint_y = wxMax(0.0, wxMin(1.0, height_pct));
2547 }
2548
2549 void wxAuiManager::GetDockSizeConstraint(double* width_pct, double* height_pct) const
2550 {
2551 if (width_pct)
2552 *width_pct = m_dock_constraint_x;
2553
2554 if (height_pct)
2555 *height_pct = m_dock_constraint_y;
2556 }
2557
2558
2559
2560 // Update() updates the layout. Whenever changes are made to
2561 // one or more panes, this function should be called. It is the
2562 // external entry point for running the layout engine.
2563
2564 void wxAuiManager::Update()
2565 {
2566 m_hover_button = NULL;
2567 m_action_part = NULL;
2568
2569 wxSizer* sizer;
2570 int i, pane_count = m_panes.GetCount();
2571
2572
2573 // destroy floating panes which have been
2574 // redocked or are becoming non-floating
2575 for (i = 0; i < pane_count; ++i)
2576 {
2577 wxAuiPaneInfo& p = m_panes.Item(i);
2578
2579 if (!p.IsFloating() && p.frame)
2580 {
2581 // because the pane is no longer in a floating, we need to
2582 // reparent it to m_frame and destroy the floating frame
2583
2584 // reduce flicker
2585 p.window->SetSize(1,1);
2586
2587
2588 // the following block is a workaround for bug #1531361
2589 // (see wxWidgets sourceforge page). On wxGTK (only), when
2590 // a frame is shown/hidden, a move event unfortunately
2591 // also gets fired. Because we may be dragging around
2592 // a pane, we need to cancel that action here to prevent
2593 // a spurious crash.
2594 if (m_action_window == p.frame)
2595 {
2596 if (wxWindow::GetCapture() == m_frame)
2597 m_frame->ReleaseMouse();
2598 m_action = actionNone;
2599 m_action_window = NULL;
2600 }
2601
2602 // hide the frame
2603 if (p.frame->IsShown())
2604 p.frame->Show(false);
2605
2606 // reparent to m_frame and destroy the pane
2607 if (m_action_window == p.frame)
2608 {
2609 m_action_window = NULL;
2610 }
2611
2612 p.window->Reparent(m_frame);
2613 p.frame->SetSizer(NULL);
2614 p.frame->Destroy();
2615 p.frame = NULL;
2616 }
2617 }
2618
2619
2620 // delete old sizer first
2621 m_frame->SetSizer(NULL);
2622
2623 // create a layout for all of the panes
2624 sizer = LayoutAll(m_panes, m_docks, m_uiparts, false);
2625
2626 // hide or show panes as necessary,
2627 // and float panes as necessary
2628 for (i = 0; i < pane_count; ++i)
2629 {
2630 wxAuiPaneInfo& p = m_panes.Item(i);
2631
2632 if (p.IsFloating())
2633 {
2634 if (p.frame == NULL)
2635 {
2636 // we need to create a frame for this
2637 // pane, which has recently been floated
2638 wxAuiFloatingFrame* frame = CreateFloatingFrame(m_frame, p);
2639
2640 // on MSW and Mac, if the owner desires transparent dragging, and
2641 // the dragging is happening right now, then the floating
2642 // window should have this style by default
2643 if (m_action == actionDragFloatingPane &&
2644 (m_flags & wxAUI_MGR_TRANSPARENT_DRAG))
2645 frame->SetTransparent(150);
2646
2647 frame->SetPaneWindow(p);
2648 p.frame = frame;
2649
2650 if (p.IsShown() && !frame->IsShown())
2651 frame->Show();
2652 }
2653 else
2654 {
2655 // frame already exists, make sure it's position
2656 // and size reflect the information in wxAuiPaneInfo
2657 if ((p.frame->GetPosition() != p.floating_pos) || (p.frame->GetSize() != p.floating_size))
2658 {
2659 p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
2660 p.floating_size.x, p.floating_size.y,
2661 wxSIZE_USE_EXISTING);
2662 /*
2663 p.frame->SetSize(p.floating_pos.x, p.floating_pos.y,
2664 wxDefaultCoord, wxDefaultCoord,
2665 wxSIZE_USE_EXISTING);
2666 //p.frame->Move(p.floating_pos.x, p.floating_pos.y);
2667 */
2668 }
2669
2670 if (p.frame->IsShown() != p.IsShown())
2671 p.frame->Show(p.IsShown());
2672 }
2673 }
2674 else
2675 {
2676 if (p.window->IsShown() != p.IsShown())
2677 p.window->Show(p.IsShown());
2678 }
2679
2680 // if "active panes" are no longer allowed, clear
2681 // any optionActive values from the pane states
2682 if ((m_flags & wxAUI_MGR_ALLOW_ACTIVE_PANE) == 0)
2683 {
2684 p.state &= ~wxAuiPaneInfo::optionActive;
2685 }
2686 }
2687
2688
2689 // keep track of the old window rectangles so we can
2690 // refresh those windows whose rect has changed
2691 wxAuiRectArray old_pane_rects;
2692 for (i = 0; i < pane_count; ++i)
2693 {
2694 wxRect r;
2695 wxAuiPaneInfo& p = m_panes.Item(i);
2696
2697 if (p.window && p.IsShown() && p.IsDocked())
2698 r = p.rect;
2699
2700 old_pane_rects.Add(r);
2701 }
2702
2703
2704
2705
2706 // apply the new sizer
2707 m_frame->SetSizer(sizer);
2708 m_frame->SetAutoLayout(false);
2709 DoFrameLayout();
2710
2711
2712
2713 // now that the frame layout is done, we need to check
2714 // the new pane rectangles against the old rectangles that
2715 // we saved a few lines above here. If the rectangles have
2716 // changed, the corresponding panes must also be updated
2717 for (i = 0; i < pane_count; ++i)
2718 {
2719 wxAuiPaneInfo& p = m_panes.Item(i);
2720 if (p.window && p.window->IsShown() && p.IsDocked())
2721 {
2722 if (p.rect != old_pane_rects[i])
2723 {
2724 p.window->Refresh();
2725 p.window->Update();
2726 }
2727 }
2728 }
2729
2730
2731 Repaint();
2732
2733 // set frame's minimum size
2734
2735 /*
2736 // N.B. More work needs to be done on frame minimum sizes;
2737 // this is some intresting code that imposes the minimum size,
2738 // but we may want to include a more flexible mechanism or
2739 // options for multiple minimum-size modes, e.g. strict or lax
2740 wxSize min_size = sizer->GetMinSize();
2741 wxSize frame_size = m_frame->GetSize();
2742 wxSize client_size = m_frame->GetClientSize();
2743
2744 wxSize minframe_size(min_size.x+frame_size.x-client_size.x,
2745 min_size.y+frame_size.y-client_size.y );
2746
2747 m_frame->SetMinSize(minframe_size);
2748
2749 if (frame_size.x < minframe_size.x ||
2750 frame_size.y < minframe_size.y)
2751 sizer->Fit(m_frame);
2752 */
2753 }
2754
2755
2756 // DoFrameLayout() is an internal function which invokes wxSizer::Layout
2757 // on the frame's main sizer, then measures all the various UI items
2758 // and updates their internal rectangles. This should always be called
2759 // instead of calling m_frame->Layout() directly
2760
2761 void wxAuiManager::DoFrameLayout()
2762 {
2763 m_frame->Layout();
2764
2765 int i, part_count;
2766 for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
2767 {
2768 wxAuiDockUIPart& part = m_uiparts.Item(i);
2769
2770 // get the rectangle of the UI part
2771 // originally, this code looked like this:
2772 // part.rect = wxRect(part.sizer_item->GetPosition(),
2773 // part.sizer_item->GetSize());
2774 // this worked quite well, with one exception: the mdi
2775 // client window had a "deferred" size variable
2776 // that returned the wrong size. It looks like
2777 // a bug in wx, because the former size of the window
2778 // was being returned. So, we will retrieve the part's
2779 // rectangle via other means
2780
2781
2782 part.rect = part.sizer_item->GetRect();
2783 int flag = part.sizer_item->GetFlag();
2784 int border = part.sizer_item->GetBorder();
2785 if (flag & wxTOP)
2786 {
2787 part.rect.y -= border;
2788 part.rect.height += border;
2789 }
2790 if (flag & wxLEFT)
2791 {
2792 part.rect.x -= border;
2793 part.rect.width += border;
2794 }
2795 if (flag & wxBOTTOM)
2796 part.rect.height += border;
2797 if (flag & wxRIGHT)
2798 part.rect.width += border;
2799
2800
2801 if (part.type == wxAuiDockUIPart::typeDock)
2802 part.dock->rect = part.rect;
2803 if (part.type == wxAuiDockUIPart::typePane)
2804 part.pane->rect = part.rect;
2805 }
2806 }
2807
2808 // GetPanePart() looks up the pane the pane border UI part (or the regular
2809 // pane part if there is no border). This allows the caller to get the exact
2810 // rectangle of the pane in question, including decorations like
2811 // caption and border (if any).
2812
2813 wxAuiDockUIPart* wxAuiManager::GetPanePart(wxWindow* wnd)
2814 {
2815 int i, part_count;
2816 for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
2817 {
2818 wxAuiDockUIPart& part = m_uiparts.Item(i);
2819 if (part.type == wxAuiDockUIPart::typePaneBorder &&
2820 part.pane && part.pane->window == wnd)
2821 return &part;
2822 }
2823 for (i = 0, part_count = m_uiparts.GetCount(); i < part_count; ++i)
2824 {
2825 wxAuiDockUIPart& part = m_uiparts.Item(i);
2826 if (part.type == wxAuiDockUIPart::typePane &&
2827 part.pane && part.pane->window == wnd)
2828 return &part;
2829 }
2830 return NULL;
2831 }
2832
2833
2834
2835 // GetDockPixelOffset() is an internal function which returns
2836 // a dock's offset in pixels from the left side of the window
2837 // (for horizontal docks) or from the top of the window (for
2838 // vertical docks). This value is necessary for calculating
2839 // fixel-pane/toolbar offsets when they are dragged.
2840
2841 int wxAuiManager::GetDockPixelOffset(wxAuiPaneInfo& test)
2842 {
2843 // the only way to accurately calculate the dock's
2844 // offset is to actually run a theoretical layout
2845
2846 int i, part_count, dock_count;
2847 wxAuiDockInfoArray docks;
2848 wxAuiPaneInfoArray panes;
2849 wxAuiDockUIPartArray uiparts;
2850 CopyDocksAndPanes(docks, panes, m_docks, m_panes);
2851 panes.Add(test);
2852
2853 wxSizer* sizer = LayoutAll(panes, docks, uiparts, true);
2854 wxSize client_size = m_frame->GetClientSize();
2855 sizer->SetDimension(0, 0, client_size.x, client_size.y);
2856 sizer->Layout();
2857
2858 for (i = 0, part_count = uiparts.GetCount(); i < part_count; ++i)
2859 {
2860 wxAuiDockUIPart& part = uiparts.Item(i);
2861 part.rect = wxRect(part.sizer_item->GetPosition(),
2862 part.sizer_item->GetSize());
2863 if (part.type == wxAuiDockUIPart::typeDock)
2864 part.dock->rect = part.rect;
2865 }
2866
2867 delete sizer;
2868
2869 for (i = 0, dock_count = docks.GetCount(); i < dock_count; ++i)
2870 {
2871 wxAuiDockInfo& dock = docks.Item(i);
2872 if (test.dock_direction == dock.dock_direction &&
2873 test.dock_layer==dock.dock_layer && test.dock_row==dock.dock_row)
2874 {
2875 if (dock.IsVertical())
2876 return dock.rect.y;
2877 else
2878 return dock.rect.x;
2879 }
2880 }
2881
2882 return 0;
2883 }
2884
2885
2886
2887 // ProcessDockResult() is a utility function used by DoDrop() - it checks
2888 // if a dock operation is allowed, the new dock position is copied into
2889 // the target info. If the operation was allowed, the function returns true.
2890
2891 bool wxAuiManager::ProcessDockResult(wxAuiPaneInfo& target,
2892 const wxAuiPaneInfo& new_pos)
2893 {
2894 bool allowed = false;
2895 switch (new_pos.dock_direction)
2896 {
2897 case wxAUI_DOCK_TOP: allowed = target.IsTopDockable(); break;
2898 case wxAUI_DOCK_BOTTOM: allowed = target.IsBottomDockable(); break;
2899 case wxAUI_DOCK_LEFT: allowed = target.IsLeftDockable(); break;
2900 case wxAUI_DOCK_RIGHT: allowed = target.IsRightDockable(); break;
2901 }
2902
2903 if (allowed)
2904 target = new_pos;
2905
2906 return allowed;
2907 }
2908
2909
2910 // DoDrop() is an important function. It basically takes a mouse position,
2911 // and determines where the pane's new position would be. If the pane is to be
2912 // dropped, it performs the drop operation using the specified dock and pane
2913 // arrays. By specifying copied dock and pane arrays when calling, a "what-if"
2914 // scenario can be performed, giving precise coordinates for drop hints.
2915 // If, however, wxAuiManager:m_docks and wxAuiManager::m_panes are specified
2916 // as parameters, the changes will be made to the main state arrays
2917
2918 const int auiInsertRowPixels = 10;
2919 const int auiNewRowPixels = 40;
2920 const int auiLayerInsertPixels = 40;
2921 const int auiLayerInsertOffset = 5;
2922
2923 bool wxAuiManager::DoDrop(wxAuiDockInfoArray& docks,
2924 wxAuiPaneInfoArray& panes,
2925 wxAuiPaneInfo& target,
2926 const wxPoint& pt,
2927 const wxPoint& offset)
2928 {
2929 wxSize cli_size = m_frame->GetClientSize();
2930
2931 wxAuiPaneInfo drop = target;
2932
2933
2934 // The result should always be shown
2935 drop.Show();
2936
2937
2938 // Check to see if the pane has been dragged outside of the window
2939 // (or near to the outside of the window), if so, dock it along the edge
2940
2941
2942 int layer_insert_offset = auiLayerInsertOffset;
2943 if (drop.IsToolbar())
2944 layer_insert_offset = 0;
2945
2946
2947 if (pt.x < layer_insert_offset &&
2948 pt.x > layer_insert_offset-auiLayerInsertPixels)
2949 {
2950 int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT),
2951 GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)),
2952 GetMaxLayer(docks, wxAUI_DOCK_TOP)) + 1;
2953
2954 if (drop.IsToolbar())
2955 new_layer = auiToolBarLayer;
2956
2957 drop.Dock().Left().
2958 Layer(new_layer).
2959 Row(0).
2960 Position(pt.y - GetDockPixelOffset(drop) - offset.y);
2961 return ProcessDockResult(target, drop);
2962 }
2963 else if (pt.y < layer_insert_offset &&
2964 pt.y > layer_insert_offset-auiLayerInsertPixels)
2965 {
2966 int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP),
2967 GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
2968 GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1;
2969
2970 if (drop.IsToolbar())
2971 new_layer = auiToolBarLayer;
2972
2973 drop.Dock().Top().
2974 Layer(new_layer).
2975 Row(0).
2976 Position(pt.x - GetDockPixelOffset(drop) - offset.x);
2977 return ProcessDockResult(target, drop);
2978 }
2979 else if (pt.x >= cli_size.x - layer_insert_offset &&
2980 pt.x < cli_size.x - layer_insert_offset + auiLayerInsertPixels)
2981 {
2982 int new_layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
2983 GetMaxLayer(docks, wxAUI_DOCK_TOP)),
2984 GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)) + 1;
2985
2986 if (drop.IsToolbar())
2987 new_layer = auiToolBarLayer;
2988
2989 drop.Dock().Right().
2990 Layer(new_layer).
2991 Row(0).
2992 Position(pt.y - GetDockPixelOffset(drop) - offset.y);
2993 return ProcessDockResult(target, drop);
2994 }
2995 else if (pt.y >= cli_size.y - layer_insert_offset &&
2996 pt.y < cli_size.y - layer_insert_offset + auiLayerInsertPixels)
2997 {
2998 int new_layer = wxMax( wxMax( GetMaxLayer(docks, wxAUI_DOCK_BOTTOM),
2999 GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
3000 GetMaxLayer(docks, wxAUI_DOCK_RIGHT)) + 1;
3001
3002 if (drop.IsToolbar())
3003 new_layer = auiToolBarLayer;
3004
3005 drop.Dock().Bottom().
3006 Layer(new_layer).
3007 Row(0).
3008 Position(pt.x - GetDockPixelOffset(drop) - offset.x);
3009 return ProcessDockResult(target, drop);
3010 }
3011
3012
3013 wxAuiDockUIPart* part = HitTest(pt.x, pt.y);
3014
3015
3016 if (drop.IsToolbar())
3017 {
3018 if (!part || !part->dock)
3019 return false;
3020
3021 // calculate the offset from where the dock begins
3022 // to the point where the user dropped the pane
3023 int dock_drop_offset = 0;
3024 if (part->dock->IsHorizontal())
3025 dock_drop_offset = pt.x - part->dock->rect.x - offset.x;
3026 else
3027 dock_drop_offset = pt.y - part->dock->rect.y - offset.y;
3028
3029
3030 // toolbars may only be moved in and to fixed-pane docks,
3031 // otherwise we will try to float the pane. Also, the pane
3032 // should float if being dragged over center pane windows
3033 if (!part->dock->fixed || part->dock->dock_direction == wxAUI_DOCK_CENTER ||
3034 pt.x >= cli_size.x || pt.x <= 0 || pt.y >= cli_size.y || pt.y <= 0)
3035 {
3036 if (m_last_rect.IsEmpty() || m_last_rect.Contains(pt.x, pt.y ))
3037 {
3038 m_skipping = true;
3039 }
3040 else
3041 {
3042 if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) && drop.IsFloatable())
3043 {
3044 drop.Float();
3045 }
3046
3047 m_skipping = false;
3048
3049 return ProcessDockResult(target, drop);
3050 }
3051
3052 drop.Position(pt.x - GetDockPixelOffset(drop) - offset.x);
3053
3054 return ProcessDockResult(target, drop);
3055 }
3056
3057 m_skipping = false;
3058
3059 m_last_rect = part->dock->rect;
3060 m_last_rect.Inflate( 15, 15 );
3061
3062 drop.Dock().
3063 Direction(part->dock->dock_direction).
3064 Layer(part->dock->dock_layer).
3065 Row(part->dock->dock_row).
3066 Position(dock_drop_offset);
3067
3068 if ((
3069 ((pt.y < part->dock->rect.y + 1) && part->dock->IsHorizontal()) ||
3070 ((pt.x < part->dock->rect.x + 1) && part->dock->IsVertical())
3071 ) && part->dock->panes.GetCount() > 1)
3072 {
3073 if ((part->dock->dock_direction == wxAUI_DOCK_TOP) ||
3074 (part->dock->dock_direction == wxAUI_DOCK_LEFT))
3075 {
3076 int row = drop.dock_row;
3077 DoInsertDockRow(panes, part->dock->dock_direction,
3078 part->dock->dock_layer,
3079 part->dock->dock_row);
3080 drop.dock_row = row;
3081 }
3082 else
3083 {
3084 DoInsertDockRow(panes, part->dock->dock_direction,
3085 part->dock->dock_layer,
3086 part->dock->dock_row+1);
3087 drop.dock_row = part->dock->dock_row+1;
3088 }
3089 }
3090
3091 if ((
3092 ((pt.y > part->dock->rect.y + part->dock->rect.height - 2 ) && part->dock->IsHorizontal()) ||
3093 ((pt.x > part->dock->rect.x + part->dock->rect.width - 2 ) && part->dock->IsVertical())
3094 ) && part->dock->panes.GetCount() > 1)
3095 {
3096 if ((part->dock->dock_direction == wxAUI_DOCK_TOP) ||
3097 (part->dock->dock_direction == wxAUI_DOCK_LEFT))
3098 {
3099 DoInsertDockRow(panes, part->dock->dock_direction,
3100 part->dock->dock_layer,
3101 part->dock->dock_row+1);
3102 drop.dock_row = part->dock->dock_row+1;
3103 }
3104 else
3105 {
3106 int row = drop.dock_row;
3107 DoInsertDockRow(panes, part->dock->dock_direction,
3108 part->dock->dock_layer,
3109 part->dock->dock_row);
3110 drop.dock_row = row;
3111 }
3112 }
3113
3114 return ProcessDockResult(target, drop);
3115 }
3116
3117
3118
3119
3120 if (!part)
3121 return false;
3122
3123 if (part->type == wxAuiDockUIPart::typePaneBorder ||
3124 part->type == wxAuiDockUIPart::typeCaption ||
3125 part->type == wxAuiDockUIPart::typeGripper ||
3126 part->type == wxAuiDockUIPart::typePaneButton ||
3127 part->type == wxAuiDockUIPart::typePane ||
3128 part->type == wxAuiDockUIPart::typePaneSizer ||
3129 part->type == wxAuiDockUIPart::typeDockSizer ||
3130 part->type == wxAuiDockUIPart::typeBackground)
3131 {
3132 if (part->type == wxAuiDockUIPart::typeDockSizer)
3133 {
3134 if (part->dock->panes.GetCount() != 1)
3135 return false;
3136 part = GetPanePart(part->dock->panes.Item(0)->window);
3137 if (!part)
3138 return false;
3139 }
3140
3141
3142
3143 // If a normal frame is being dragged over a toolbar, insert it
3144 // along the edge under the toolbar, but over all other panes.
3145 // (this could be done much better, but somehow factoring this
3146 // calculation with the one at the beginning of this function)
3147 if (part->dock && part->dock->toolbar)
3148 {
3149 int layer = 0;
3150
3151 switch (part->dock->dock_direction)
3152 {
3153 case wxAUI_DOCK_LEFT:
3154 layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_LEFT),
3155 GetMaxLayer(docks, wxAUI_DOCK_BOTTOM)),
3156 GetMaxLayer(docks, wxAUI_DOCK_TOP));
3157 break;
3158 case wxAUI_DOCK_TOP:
3159 layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_TOP),
3160 GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
3161 GetMaxLayer(docks, wxAUI_DOCK_RIGHT));
3162 break;
3163 case wxAUI_DOCK_RIGHT:
3164 layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_RIGHT),
3165 GetMaxLayer(docks, wxAUI_DOCK_TOP)),
3166 GetMaxLayer(docks, wxAUI_DOCK_BOTTOM));
3167 break;
3168 case wxAUI_DOCK_BOTTOM:
3169 layer = wxMax(wxMax(GetMaxLayer(docks, wxAUI_DOCK_BOTTOM),
3170 GetMaxLayer(docks, wxAUI_DOCK_LEFT)),
3171 GetMaxLayer(docks, wxAUI_DOCK_RIGHT));
3172 break;
3173 }
3174
3175 DoInsertDockRow(panes, part->dock->dock_direction,
3176 layer, 0);
3177 drop.Dock().
3178 Direction(part->dock->dock_direction).
3179 Layer(layer).Row(0).Position(0);
3180 return ProcessDockResult(target, drop);
3181 }
3182
3183
3184 if (!part->pane)
3185 return false;
3186
3187 part = GetPanePart(part->pane->window);
3188 if (!part)
3189 return false;
3190
3191 bool insert_dock_row = false;
3192 int insert_row = part->pane->dock_row;
3193 int insert_dir = part->pane->dock_direction;
3194 int insert_layer = part->pane->dock_layer;
3195
3196 switch (part->pane->dock_direction)
3197 {
3198 case wxAUI_DOCK_TOP:
3199 if (pt.y >= part->rect.y &&
3200 pt.y < part->rect.y+auiInsertRowPixels)
3201 insert_dock_row = true;
3202 break;
3203 case wxAUI_DOCK_BOTTOM:
3204 if (pt.y > part->rect.y+part->rect.height-auiInsertRowPixels &&
3205 pt.y <= part->rect.y + part->rect.height)
3206 insert_dock_row = true;
3207 break;
3208 case wxAUI_DOCK_LEFT:
3209 if (pt.x >= part->rect.x &&
3210 pt.x < part->rect.x+auiInsertRowPixels)
3211 insert_dock_row = true;
3212 break;
3213 case wxAUI_DOCK_RIGHT:
3214 if (pt.x > part->rect.x+part->rect.width-auiInsertRowPixels &&
3215 pt.x <= part->rect.x+part->rect.width)
3216 insert_dock_row = true;
3217 break;
3218 case wxAUI_DOCK_CENTER:
3219 {
3220 // "new row pixels" will be set to the default, but
3221 // must never exceed 20% of the window size
3222 int new_row_pixels_x = auiNewRowPixels;
3223 int new_row_pixels_y = auiNewRowPixels;
3224
3225 if (new_row_pixels_x > (part->rect.width*20)/100)
3226 new_row_pixels_x = (part->rect.width*20)/100;
3227
3228 if (new_row_pixels_y > (part->rect.height*20)/100)
3229 new_row_pixels_y = (part->rect.height*20)/100;
3230
3231
3232 // determine if the mouse pointer is in a location that
3233 // will cause a new row to be inserted. The hot spot positions
3234 // are along the borders of the center pane
3235
3236 insert_layer = 0;
3237 insert_dock_row = true;
3238 const wxRect& pr = part->rect;
3239 if (pt.x >= pr.x && pt.x < pr.x + new_row_pixels_x)
3240 insert_dir = wxAUI_DOCK_LEFT;
3241 else if (pt.y >= pr.y && pt.y < pr.y + new_row_pixels_y)
3242 insert_dir = wxAUI_DOCK_TOP;
3243 else if (pt.x >= pr.x + pr.width - new_row_pixels_x &&
3244 pt.x < pr.x + pr.width)
3245 insert_dir = wxAUI_DOCK_RIGHT;
3246 else if (pt.y >= pr.y+ pr.height - new_row_pixels_y &&
3247 pt.y < pr.y + pr.height)
3248 insert_dir = wxAUI_DOCK_BOTTOM;
3249 else
3250 return false;
3251
3252 insert_row = GetMaxRow(panes, insert_dir, insert_layer) + 1;
3253 }
3254 }
3255
3256 if (insert_dock_row)
3257 {
3258 DoInsertDockRow(panes, insert_dir, insert_layer, insert_row);
3259 drop.Dock().Direction(insert_dir).
3260 Layer(insert_layer).
3261 Row(insert_row).
3262 Position(0);
3263 return ProcessDockResult(target, drop);
3264 }
3265
3266 // determine the mouse offset and the pane size, both in the
3267 // direction of the dock itself, and perpendicular to the dock
3268
3269 int offset, size;
3270
3271 if (part->orientation == wxVERTICAL)
3272 {
3273 offset = pt.y - part->rect.y;
3274 size = part->rect.GetHeight();
3275 }
3276 else
3277 {
3278 offset = pt.x - part->rect.x;
3279 size = part->rect.GetWidth();
3280 }
3281
3282 int drop_position = part->pane->dock_pos;
3283
3284 // if we are in the top/left part of the pane,
3285 // insert the pane before the pane being hovered over
3286 if (offset <= size/2)
3287 {
3288 drop_position = part->pane->dock_pos;
3289 DoInsertPane(panes,
3290 part->pane->dock_direction,
3291 part->pane->dock_layer,
3292 part->pane->dock_row,
3293 part->pane->dock_pos);
3294 }
3295
3296 // if we are in the bottom/right part of the pane,
3297 // insert the pane before the pane being hovered over
3298 if (offset > size/2)
3299 {
3300 drop_position = part->pane->dock_pos+1;
3301 DoInsertPane(panes,
3302 part->pane->dock_direction,
3303 part->pane->dock_layer,
3304 part->pane->dock_row,
3305 part->pane->dock_pos+1);
3306 }
3307
3308 drop.Dock().
3309 Direction(part->dock->dock_direction).
3310 Layer(part->dock->dock_layer).
3311 Row(part->dock->dock_row).
3312 Position(drop_position);
3313 return ProcessDockResult(target, drop);
3314 }
3315
3316 return false;
3317 }
3318
3319
3320 void wxAuiManager::OnHintFadeTimer(wxTimerEvent& WXUNUSED(event))
3321 {
3322 if (!m_hint_wnd || m_hint_fadeamt >= m_hint_fademax)
3323 {
3324 m_hint_fadetimer.Stop();
3325 Disconnect(m_hint_fadetimer.GetId(), wxEVT_TIMER,
3326 wxTimerEventHandler(wxAuiManager::OnHintFadeTimer));
3327 return;
3328 }
3329
3330 m_hint_fadeamt += 4;
3331 m_hint_wnd->SetTransparent(m_hint_fadeamt);
3332 }
3333
3334 void wxAuiManager::ShowHint(const wxRect& rect)
3335 {
3336 if (m_hint_wnd)
3337 {
3338 // if the hint rect is the same as last time, don't do anything
3339 if (m_last_hint == rect)
3340 return;
3341 m_last_hint = rect;
3342
3343 m_hint_fadeamt = m_hint_fademax;
3344
3345 if ((m_flags & wxAUI_MGR_HINT_FADE)
3346 && !((m_hint_wnd->IsKindOf(CLASSINFO(wxPseudoTransparentFrame))) &&
3347 (m_flags & wxAUI_MGR_NO_VENETIAN_BLINDS_FADE))
3348 )
3349 m_hint_fadeamt = 0;
3350
3351 m_hint_wnd->SetSize(rect);
3352 m_hint_wnd->SetTransparent(m_hint_fadeamt);
3353
3354 if (!m_hint_wnd->IsShown())
3355 m_hint_wnd->Show();
3356
3357 // if we are dragging a floating pane, set the focus
3358 // back to that floating pane (otherwise it becomes unfocused)
3359 if (m_action == actionDragFloatingPane && m_action_window)
3360 m_action_window->SetFocus();
3361
3362 m_hint_wnd->Raise();
3363
3364
3365 if (m_hint_fadeamt != m_hint_fademax) // Only fade if we need to
3366 {
3367 // start fade in timer
3368 m_hint_fadetimer.SetOwner(this);
3369 m_hint_fadetimer.Start(5);
3370 Connect(m_hint_fadetimer.GetId(), wxEVT_TIMER,
3371 wxTimerEventHandler(wxAuiManager::OnHintFadeTimer));
3372 }
3373 }
3374 else // Not using a transparent hint window...
3375 {
3376 if (!(m_flags & wxAUI_MGR_RECTANGLE_HINT))
3377 return;
3378
3379 if (m_last_hint != rect)
3380 {
3381 // remove the last hint rectangle
3382 m_last_hint = rect;
3383 m_frame->Refresh();
3384 m_frame->Update();
3385 }
3386
3387 wxScreenDC screendc;
3388 wxRegion clip(1, 1, 10000, 10000);
3389
3390 // clip all floating windows, so we don't draw over them
3391 int i, pane_count;
3392 for (i = 0, pane_count = m_panes.GetCount(); i < pane_count; ++i)
3393 {
3394 wxAuiPaneInfo& pane = m_panes.Item(i);
3395
3396 if (pane.IsFloating() &&
3397 pane.frame->IsShown())
3398 {
3399 wxRect rect = pane.frame->GetRect();
3400 #ifdef __WXGTK__
3401 // wxGTK returns the client size, not the whole frame size
3402 rect.width += 15;
3403 rect.height += 35;
3404 rect.Inflate(5);
3405 #endif
3406
3407 clip.Subtract(rect);
3408 }
3409 }
3410
3411 // As we can only hide the hint by redrawing the managed window, we
3412 // need to clip the region to the managed window too or we get
3413 // nasty redrawn problems.
3414 clip.Intersect(m_frame->GetRect());
3415
3416 screendc.SetDeviceClippingRegion(clip);
3417
3418 wxBitmap stipple = wxPaneCreateStippleBitmap();
3419 wxBrush brush(stipple);
3420 screendc.SetBrush(brush);
3421 screendc.SetPen(*wxTRANSPARENT_PEN);
3422
3423 screendc.DrawRectangle(rect.x, rect.y, 5, rect.height);
3424 screendc.DrawRectangle(rect.x+5, rect.y, rect.width-10, 5);
3425 screendc.DrawRectangle(rect.x+rect.width-5, rect.y, 5, rect.height);
3426 screendc.DrawRectangle(rect.x+5, rect.y+rect.height-5, rect.width-10, 5);
3427 }
3428 }
3429
3430 void wxAuiManager::HideHint()
3431 {
3432 // hides a transparent window hint, if there is one
3433 if (m_hint_wnd)
3434 {
3435 if (m_hint_wnd->IsShown())
3436 m_hint_wnd->Show(false);
3437 m_hint_wnd->SetTransparent(0);
3438 m_hint_fadetimer.Stop();
3439 // In case this is called while a hint fade is going, we need to
3440 // disconnect the event handler.
3441 Disconnect(m_hint_fadetimer.GetId(), wxEVT_TIMER,
3442 wxTimerEventHandler(wxAuiManager::OnHintFadeTimer));
3443 m_last_hint = wxRect();
3444 return;
3445 }
3446
3447 // hides a painted hint by redrawing the frame window
3448 if (!m_last_hint.IsEmpty())
3449 {
3450 m_frame->Refresh();
3451 m_frame->Update();
3452 m_last_hint = wxRect();
3453 }
3454 }
3455
3456 void wxAuiManager::OnHintActivate(wxActivateEvent& WXUNUSED(event))
3457 {
3458 // Do nothing so this event isn't handled in the base handlers.
3459
3460 // Letting the hint window activate without this handler can lead to
3461 // weird behavior on Mac where the menu is switched out to the top
3462 // window's menu in MDI applications when it shouldn't be. So since
3463 // we don't want user interaction with the hint window anyway, we just
3464 // prevent it from activating here.
3465 }
3466
3467
3468
3469 void wxAuiManager::StartPaneDrag(wxWindow* pane_window,
3470 const wxPoint& offset)
3471 {
3472 wxAuiPaneInfo& pane = GetPane(pane_window);
3473 if (!pane.IsOk())
3474 return;
3475
3476 if (pane.IsToolbar())
3477 {
3478 m_action = actionDragToolbarPane;
3479 }
3480 else
3481 {
3482 m_action = actionDragFloatingPane;
3483 }
3484
3485 m_action_window = pane_window;
3486 m_action_offset = offset;
3487 m_frame->CaptureMouse();
3488 }
3489
3490
3491 // CalculateHintRect() calculates the drop hint rectangle. The method
3492 // first calls DoDrop() to determine the exact position the pane would
3493 // be at were if dropped. If the pane would indeed become docked at the
3494 // specified drop point, the the rectangle hint will be returned in
3495 // screen coordinates. Otherwise, an empty rectangle is returned.
3496 // |pane_window| is the window pointer of the pane being dragged, |pt| is
3497 // the mouse position, in client coordinates. |offset| describes the offset
3498 // that the mouse is from the upper-left corner of the item being dragged
3499
3500 wxRect wxAuiManager::CalculateHintRect(wxWindow* pane_window,
3501 const wxPoint& pt,
3502 const wxPoint& offset)
3503 {
3504 wxRect rect;
3505
3506 // we need to paint a hint rectangle; to find out the exact hint rectangle,
3507 // we will create a new temporary layout and then measure the resulting
3508 // rectangle; we will create a copy of the docking structures (m_dock)
3509 // so that we don't modify the real thing on screen
3510
3511 int i, pane_count, part_count;
3512 wxAuiDockInfoArray docks;
3513 wxAuiPaneInfoArray panes;
3514 wxAuiDockUIPartArray uiparts;
3515 wxAuiPaneInfo hint = GetPane(pane_window);
3516 hint.name = wxT("__HINT__");
3517 hint.PaneBorder(true);
3518 hint.Show();
3519
3520 if (!hint.IsOk())
3521 return rect;
3522
3523 CopyDocksAndPanes(docks, panes, m_docks, m_panes);
3524
3525 // remove any pane already there which bears the same window;
3526 // this happens when you are moving a pane around in a dock
3527 for (i = 0, pane_count = panes.GetCount(); i < pane_count; ++i)
3528 {
3529 if (panes.Item(i).window == pane_window)
3530 {
3531 RemovePaneFromDocks(docks, panes.Item(i));
3532 panes.RemoveAt(i);
3533 break;
3534 }
3535 }
3536
3537 // find out where the new pane would be
3538 if (!DoDrop(docks, panes, hint, pt, offset))
3539 {
3540 return rect;
3541 }
3542
3543 panes.Add(hint);
3544
3545 wxSizer* sizer = LayoutAll(panes, docks, uiparts, true);
3546 wxSize client_size = m_frame->GetClientSize();
3547 sizer->SetDimension(0, 0, client_size.x, client_size.y);
3548 sizer->Layout();
3549
3550 for (i = 0, part_count = uiparts.GetCount();
3551 i < part_count; ++i)
3552 {
3553 wxAuiDockUIPart& part = uiparts.Item(i);
3554
3555 if (part.type == wxAuiDockUIPart::typePaneBorder &&
3556 part.pane && part.pane->name == wxT("__HINT__"))
3557 {
3558 rect = wxRect(part.sizer_item->GetPosition(),
3559 part.sizer_item->GetSize());
3560 break;
3561 }
3562 }
3563
3564 delete sizer;
3565
3566 if (rect.IsEmpty())
3567 {
3568 return rect;
3569 }
3570
3571 // actually show the hint rectangle on the screen
3572 m_frame->ClientToScreen(&rect.x, &rect.y);
3573
3574 if ( m_frame->GetLayoutDirection() == wxLayout_RightToLeft )
3575 {
3576 // Mirror rectangle in RTL mode
3577 rect.x -= rect.GetWidth();
3578 }
3579
3580 return rect;
3581 }
3582
3583 // DrawHintRect() calculates the hint rectangle by calling
3584 // CalculateHintRect(). If there is a rectangle, it shows it
3585 // by calling ShowHint(), otherwise it hides any hint
3586 // rectangle currently shown
3587 void wxAuiManager::DrawHintRect(wxWindow* pane_window,
3588 const wxPoint& pt,
3589 const wxPoint& offset)
3590 {
3591 wxRect rect = CalculateHintRect(pane_window, pt, offset);
3592
3593 if (rect.IsEmpty())
3594 {
3595 HideHint();
3596 }
3597 else
3598 {
3599 ShowHint(rect);
3600 }
3601 }
3602
3603 void wxAuiManager::OnFloatingPaneMoveStart(wxWindow* wnd)
3604 {
3605 // try to find the pane
3606 wxAuiPaneInfo& pane = GetPane(wnd);
3607 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3608
3609 if(!pane.frame)
3610 return;
3611
3612 if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
3613 pane.frame->SetTransparent(150);
3614 }
3615
3616 void wxAuiManager::OnFloatingPaneMoving(wxWindow* wnd, wxDirection dir)
3617 {
3618 // try to find the pane
3619 wxAuiPaneInfo& pane = GetPane(wnd);
3620 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3621
3622 if(!pane.frame)
3623 return;
3624
3625 wxPoint pt = ::wxGetMousePosition();
3626
3627 #if 0
3628 // Adapt pt to direction
3629 if (dir == wxNORTH)
3630 {
3631 // move to pane's upper border
3632 wxPoint pos( 0,0 );
3633 pos = wnd->ClientToScreen( pos );
3634 pt.y = pos.y;
3635 // and some more pixels for the title bar
3636 pt.y -= 5;
3637 }
3638 else if (dir == wxWEST)
3639 {
3640 // move to pane's left border
3641 wxPoint pos( 0,0 );
3642 pos = wnd->ClientToScreen( pos );
3643 pt.x = pos.x;
3644 }
3645 else if (dir == wxEAST)
3646 {
3647 // move to pane's right border
3648 wxPoint pos( wnd->GetSize().x, 0 );
3649 pos = wnd->ClientToScreen( pos );
3650 pt.x = pos.x;
3651 }
3652 else if (dir == wxSOUTH)
3653 {
3654 // move to pane's bottom border
3655 wxPoint pos( 0, wnd->GetSize().y );
3656 pos = wnd->ClientToScreen( pos );
3657 pt.y = pos.y;
3658 }
3659 #else
3660 wxUnusedVar(dir);
3661 #endif
3662
3663 wxPoint client_pt = m_frame->ScreenToClient(pt);
3664
3665 // calculate the offset from the upper left-hand corner
3666 // of the frame to the mouse pointer
3667 wxPoint frame_pos = pane.frame->GetPosition();
3668 wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y);
3669
3670 // no hint for toolbar floating windows
3671 if (pane.IsToolbar() && m_action == actionDragFloatingPane)
3672 {
3673 wxAuiDockInfoArray docks;
3674 wxAuiPaneInfoArray panes;
3675 wxAuiDockUIPartArray uiparts;
3676 wxAuiPaneInfo hint = pane;
3677
3678 CopyDocksAndPanes(docks, panes, m_docks, m_panes);
3679
3680 // find out where the new pane would be
3681 if (!DoDrop(docks, panes, hint, client_pt))
3682 return;
3683 if (hint.IsFloating())
3684 return;
3685
3686 pane = hint;
3687 m_action = actionDragToolbarPane;
3688 m_action_window = pane.window;
3689
3690 Update();
3691
3692 return;
3693 }
3694
3695
3696 // if a key modifier is pressed while dragging the frame,
3697 // don't dock the window
3698 if (!CanDockPanel(pane))
3699 {
3700 HideHint();
3701 return;
3702 }
3703
3704
3705 DrawHintRect(wnd, client_pt, action_offset);
3706
3707 #ifdef __WXGTK__
3708 // this cleans up some screen artifacts that are caused on GTK because
3709 // we aren't getting the exact size of the window (see comment
3710 // in DrawHintRect)
3711 //Refresh();
3712 #endif
3713
3714
3715 // reduces flicker
3716 m_frame->Update();
3717 }
3718
3719 void wxAuiManager::OnFloatingPaneMoved(wxWindow* wnd, wxDirection dir)
3720 {
3721 // try to find the pane
3722 wxAuiPaneInfo& pane = GetPane(wnd);
3723 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3724
3725 if(!pane.frame)
3726 return;
3727
3728 wxPoint pt = ::wxGetMousePosition();
3729
3730 #if 0
3731 // Adapt pt to direction
3732 if (dir == wxNORTH)
3733 {
3734 // move to pane's upper border
3735 wxPoint pos( 0,0 );
3736 pos = wnd->ClientToScreen( pos );
3737 pt.y = pos.y;
3738 // and some more pixels for the title bar
3739 pt.y -= 10;
3740 }
3741 else if (dir == wxWEST)
3742 {
3743 // move to pane's left border
3744 wxPoint pos( 0,0 );
3745 pos = wnd->ClientToScreen( pos );
3746 pt.x = pos.x;
3747 }
3748 else if (dir == wxEAST)
3749 {
3750 // move to pane's right border
3751 wxPoint pos( wnd->GetSize().x, 0 );
3752 pos = wnd->ClientToScreen( pos );
3753 pt.x = pos.x;
3754 }
3755 else if (dir == wxSOUTH)
3756 {
3757 // move to pane's bottom border
3758 wxPoint pos( 0, wnd->GetSize().y );
3759 pos = wnd->ClientToScreen( pos );
3760 pt.y = pos.y;
3761 }
3762 #else
3763 wxUnusedVar(dir);
3764 #endif
3765
3766 wxPoint client_pt = m_frame->ScreenToClient(pt);
3767
3768 // calculate the offset from the upper left-hand corner
3769 // of the frame to the mouse pointer
3770 wxPoint frame_pos = pane.frame->GetPosition();
3771 wxPoint action_offset(pt.x-frame_pos.x, pt.y-frame_pos.y);
3772
3773 // if a key modifier is pressed while dragging the frame,
3774 // don't dock the window
3775 if (CanDockPanel(pane))
3776 {
3777 // do the drop calculation
3778 DoDrop(m_docks, m_panes, pane, client_pt, action_offset);
3779 }
3780
3781 // if the pane is still floating, update it's floating
3782 // position (that we store)
3783 if (pane.IsFloating())
3784 {
3785 pane.floating_pos = pane.frame->GetPosition();
3786
3787 if (m_flags & wxAUI_MGR_TRANSPARENT_DRAG)
3788 pane.frame->SetTransparent(255);
3789 }
3790 else if (m_has_maximized)
3791 {
3792 RestoreMaximizedPane();
3793 }
3794
3795 Update();
3796
3797 HideHint();
3798 }
3799
3800 void wxAuiManager::OnFloatingPaneResized(wxWindow* wnd, const wxSize& size)
3801 {
3802 // try to find the pane
3803 wxAuiPaneInfo& pane = GetPane(wnd);
3804 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3805
3806 pane.floating_size = size;
3807 }
3808
3809
3810 void wxAuiManager::OnFloatingPaneClosed(wxWindow* wnd, wxCloseEvent& evt)
3811 {
3812 // try to find the pane
3813 wxAuiPaneInfo& pane = GetPane(wnd);
3814 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
3815
3816
3817 // fire pane close event
3818 wxAuiManagerEvent e(wxEVT_AUI_PANE_CLOSE);
3819 e.SetPane(&pane);
3820 e.SetCanVeto(evt.CanVeto());
3821 ProcessMgrEvent(e);
3822
3823 if (e.GetVeto())
3824 {
3825 evt.Veto();
3826 return;
3827 }
3828 else
3829 {
3830 // close the pane, but check that it
3831 // still exists in our pane array first
3832 // (the event handler above might have removed it)
3833
3834 wxAuiPaneInfo& check = GetPane(wnd);
3835 if (check.IsOk())
3836 {
3837 ClosePane(pane);
3838 }
3839 }
3840 }
3841
3842
3843
3844 void wxAuiManager::OnFloatingPaneActivated(wxWindow* wnd)
3845 {
3846 if ((GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE) && GetPane(wnd).IsOk())
3847 {
3848 SetActivePane(m_panes, wnd);
3849 Repaint();
3850 }
3851 }
3852
3853 // OnRender() draws all of the pane captions, sashes,
3854 // backgrounds, captions, grippers, pane borders and buttons.
3855 // It renders the entire user interface.
3856
3857 void wxAuiManager::OnRender(wxAuiManagerEvent& evt)
3858 {
3859 // if the frame is about to be deleted, don't bother
3860 if (!m_frame || wxPendingDelete.Member(m_frame))
3861 return;
3862
3863 wxDC* dc = evt.GetDC();
3864
3865 #ifdef __WXMAC__
3866 dc->Clear() ;
3867 #endif
3868 int i, part_count;
3869 for (i = 0, part_count = m_uiparts.GetCount();
3870 i < part_count; ++i)
3871 {
3872 wxAuiDockUIPart& part = m_uiparts.Item(i);
3873
3874 // don't draw hidden pane items or items that aren't windows
3875 if (part.sizer_item && ((!part.sizer_item->IsWindow() && !part.sizer_item->IsSpacer() && !part.sizer_item->IsSizer()) || !part.sizer_item->IsShown()))
3876 continue;
3877
3878 switch (part.type)
3879 {
3880 case wxAuiDockUIPart::typeDockSizer:
3881 case wxAuiDockUIPart::typePaneSizer:
3882 m_art->DrawSash(*dc, m_frame, part.orientation, part.rect);
3883 break;
3884 case wxAuiDockUIPart::typeBackground:
3885 m_art->DrawBackground(*dc, m_frame, part.orientation, part.rect);
3886 break;
3887 case wxAuiDockUIPart::typeCaption:
3888 m_art->DrawCaption(*dc, m_frame, part.pane->caption, part.rect, *part.pane);
3889 break;
3890 case wxAuiDockUIPart::typeGripper:
3891 m_art->DrawGripper(*dc, m_frame, part.rect, *part.pane);
3892 break;
3893 case wxAuiDockUIPart::typePaneBorder:
3894 m_art->DrawBorder(*dc, m_frame, part.rect, *part.pane);
3895 break;
3896 case wxAuiDockUIPart::typePaneButton:
3897 m_art->DrawPaneButton(*dc, m_frame, part.button->button_id,
3898 wxAUI_BUTTON_STATE_NORMAL, part.rect, *part.pane);
3899 break;
3900 }
3901 }
3902 }
3903
3904
3905 // Render() fire a render event, which is normally handled by
3906 // wxAuiManager::OnRender(). This allows the render function to
3907 // be overridden via the render event. This can be useful for paintin
3908 // custom graphics in the main window. Default behavior can be
3909 // invoked in the overridden function by calling OnRender()
3910
3911 void wxAuiManager::Render(wxDC* dc)
3912 {
3913 wxAuiManagerEvent e(wxEVT_AUI_RENDER);
3914 e.SetManager(this);
3915 e.SetDC(dc);
3916 ProcessMgrEvent(e);
3917 }
3918
3919 void wxAuiManager::Repaint(wxDC* dc)
3920 {
3921 #ifdef __WXMAC__
3922 if ( dc == NULL )
3923 {
3924 m_frame->Refresh() ;
3925 m_frame->Update() ;
3926 return ;
3927 }
3928 #endif
3929 int w, h;
3930 m_frame->GetClientSize(&w, &h);
3931
3932 // figure out which dc to use; if one
3933 // has been specified, use it, otherwise
3934 // make a client dc
3935 wxClientDC* client_dc = NULL;
3936 if (!dc)
3937 {
3938 client_dc = new wxClientDC(m_frame);
3939 dc = client_dc;
3940 }
3941
3942 // if the frame has a toolbar, the client area
3943 // origin will not be (0,0).
3944 wxPoint pt = m_frame->GetClientAreaOrigin();
3945 if (pt.x != 0 || pt.y != 0)
3946 dc->SetDeviceOrigin(pt.x, pt.y);
3947
3948 // render all the items
3949 Render(dc);
3950
3951 // if we created a client_dc, delete it
3952 if (client_dc)
3953 delete client_dc;
3954 }
3955
3956 void wxAuiManager::OnPaint(wxPaintEvent& WXUNUSED(event))
3957 {
3958 wxPaintDC dc(m_frame);
3959 Repaint(&dc);
3960 }
3961
3962 void wxAuiManager::OnEraseBackground(wxEraseEvent& event)
3963 {
3964 #ifdef __WXMAC__
3965 event.Skip() ;
3966 #else
3967 wxUnusedVar(event);
3968 #endif
3969 }
3970
3971 void wxAuiManager::OnSize(wxSizeEvent& event)
3972 {
3973 if (m_frame)
3974 {
3975 DoFrameLayout();
3976 Repaint();
3977
3978 #if wxUSE_MDI
3979 if (m_frame->IsKindOf(CLASSINFO(wxMDIParentFrame)))
3980 {
3981 // for MDI parent frames, this event must not
3982 // be "skipped". In other words, the parent frame
3983 // must not be allowed to resize the client window
3984 // after we are finished processing sizing changes
3985 return;
3986 }
3987 #endif
3988 }
3989 event.Skip();
3990 }
3991
3992 void wxAuiManager::OnFindManager(wxAuiManagerEvent& evt)
3993 {
3994 // get the window we are managing, if none, return NULL
3995 wxWindow* window = GetManagedWindow();
3996 if (!window)
3997 {
3998 evt.SetManager(NULL);
3999 return;
4000 }
4001
4002 // if we are managing a child frame, get the 'real' manager
4003 if (window->IsKindOf(CLASSINFO(wxAuiFloatingFrame)))
4004 {
4005 wxAuiFloatingFrame* float_frame = static_cast<wxAuiFloatingFrame*>(window);
4006 evt.SetManager(float_frame->GetOwnerManager());
4007 return;
4008 }
4009
4010 // return pointer to ourself
4011 evt.SetManager(this);
4012 }
4013
4014 void wxAuiManager::OnSetCursor(wxSetCursorEvent& event)
4015 {
4016 // determine cursor
4017 wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY());
4018 wxCursor cursor = wxNullCursor;
4019
4020 if (part)
4021 {
4022 if (part->type == wxAuiDockUIPart::typeDockSizer ||
4023 part->type == wxAuiDockUIPart::typePaneSizer)
4024 {
4025 // a dock may not be resized if it has a single
4026 // pane which is not resizable
4027 if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock &&
4028 part->dock->panes.GetCount() == 1 &&
4029 part->dock->panes.Item(0)->IsFixed())
4030 return;
4031
4032 // panes that may not be resized do not get a sizing cursor
4033 if (part->pane && part->pane->IsFixed())
4034 return;
4035
4036 if (part->orientation == wxVERTICAL)
4037 cursor = wxCursor(wxCURSOR_SIZEWE);
4038 else
4039 cursor = wxCursor(wxCURSOR_SIZENS);
4040 }
4041 else if (part->type == wxAuiDockUIPart::typeGripper)
4042 {
4043 cursor = wxCursor(wxCURSOR_SIZING);
4044 }
4045 }
4046
4047 event.SetCursor(cursor);
4048 }
4049
4050
4051
4052 void wxAuiManager::UpdateButtonOnScreen(wxAuiDockUIPart* button_ui_part,
4053 const wxMouseEvent& event)
4054 {
4055 wxAuiDockUIPart* hit_test = HitTest(event.GetX(), event.GetY());
4056 if (!hit_test || !button_ui_part)
4057 return;
4058
4059 int state = wxAUI_BUTTON_STATE_NORMAL;
4060
4061 if (hit_test == button_ui_part)
4062 {
4063 if (event.LeftDown())
4064 state = wxAUI_BUTTON_STATE_PRESSED;
4065 else
4066 state = wxAUI_BUTTON_STATE_HOVER;
4067 }
4068 else
4069 {
4070 if (event.LeftDown())
4071 state = wxAUI_BUTTON_STATE_HOVER;
4072 }
4073
4074 // now repaint the button with hover state
4075 wxClientDC cdc(m_frame);
4076
4077 // if the frame has a toolbar, the client area
4078 // origin will not be (0,0).
4079 wxPoint pt = m_frame->GetClientAreaOrigin();
4080 if (pt.x != 0 || pt.y != 0)
4081 cdc.SetDeviceOrigin(pt.x, pt.y);
4082
4083 if (hit_test->pane)
4084 {
4085 m_art->DrawPaneButton(cdc, m_frame,
4086 button_ui_part->button->button_id,
4087 state,
4088 button_ui_part->rect,
4089 *hit_test->pane);
4090 }
4091 }
4092
4093 void wxAuiManager::OnLeftDown(wxMouseEvent& event)
4094 {
4095 m_currentDragItem = -1;
4096
4097 wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY());
4098 if (part)
4099 {
4100 if (part->type == wxAuiDockUIPart::typeDockSizer ||
4101 part->type == wxAuiDockUIPart::typePaneSizer)
4102 {
4103 // Removing this restriction so that a centre pane can be resized
4104 //if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
4105 // return;
4106
4107 // a dock may not be resized if it has a single
4108 // pane which is not resizable
4109 if (part->type == wxAuiDockUIPart::typeDockSizer && part->dock &&
4110 part->dock->panes.GetCount() == 1 &&
4111 part->dock->panes.Item(0)->IsFixed())
4112 return;
4113
4114 // panes that may not be resized should be ignored here
4115 if (part->pane && part->pane->IsFixed())
4116 return;
4117
4118 m_action = actionResize;
4119 m_action_part = part;
4120 m_action_hintrect = wxRect();
4121 m_action_start = wxPoint(event.m_x, event.m_y);
4122 m_action_offset = wxPoint(event.m_x - part->rect.x,
4123 event.m_y - part->rect.y);
4124 m_frame->CaptureMouse();
4125 }
4126 else if (part->type == wxAuiDockUIPart::typePaneButton)
4127 {
4128 m_action = actionClickButton;
4129 m_action_part = part;
4130 m_action_start = wxPoint(event.m_x, event.m_y);
4131 m_frame->CaptureMouse();
4132
4133 UpdateButtonOnScreen(part, event);
4134 }
4135 else if (part->type == wxAuiDockUIPart::typeCaption ||
4136 part->type == wxAuiDockUIPart::typeGripper)
4137 {
4138 // if we are managing a wxAuiFloatingFrame window, then
4139 // we are an embedded wxAuiManager inside the wxAuiFloatingFrame.
4140 // We want to initiate a toolbar drag in our owner manager
4141 wxWindow* managed_wnd = GetManagedWindow();
4142
4143 if (part->pane &&
4144 part->pane->window &&
4145 managed_wnd &&
4146 managed_wnd->IsKindOf(CLASSINFO(wxAuiFloatingFrame)))
4147 {
4148 wxAuiFloatingFrame* floating_frame = (wxAuiFloatingFrame*)managed_wnd;
4149 wxAuiManager* owner_mgr = floating_frame->GetOwnerManager();
4150 owner_mgr->StartPaneDrag(part->pane->window,
4151 wxPoint(event.m_x - part->rect.x,
4152 event.m_y - part->rect.y));
4153 return;
4154 }
4155
4156
4157
4158 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
4159 {
4160 // set the caption as active
4161 SetActivePane(m_panes, part->pane->window);
4162 Repaint();
4163 }
4164
4165 if (part->dock && part->dock->dock_direction == wxAUI_DOCK_CENTER)
4166 return;
4167
4168 m_action = actionClickCaption;
4169 m_action_part = part;
4170 m_action_start = wxPoint(event.m_x, event.m_y);
4171 m_action_offset = wxPoint(event.m_x - part->rect.x,
4172 event.m_y - part->rect.y);
4173 m_frame->CaptureMouse();
4174 }
4175 #ifdef __WXMAC__
4176 else
4177 {
4178 event.Skip();
4179 }
4180 #endif
4181 }
4182 #ifdef __WXMAC__
4183 else
4184 {
4185 event.Skip();
4186 }
4187 #else
4188 event.Skip();
4189 #endif
4190 }
4191
4192 /// Ends a resize action, or for live update, resizes the sash
4193 bool wxAuiManager::DoEndResizeAction(wxMouseEvent& event)
4194 {
4195 // resize the dock or the pane
4196 if (m_action_part && m_action_part->type==wxAuiDockUIPart::typeDockSizer)
4197 {
4198 // first, we must calculate the maximum size the dock may be
4199 int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE);
4200
4201 int used_width = 0, used_height = 0;
4202
4203 wxSize client_size = m_frame->GetClientSize();
4204
4205 size_t dock_i, dock_count = m_docks.GetCount();
4206 for (dock_i = 0; dock_i < dock_count; ++dock_i)
4207 {
4208 wxAuiDockInfo& dock = m_docks.Item(dock_i);
4209 if (dock.dock_direction == wxAUI_DOCK_TOP ||
4210 dock.dock_direction == wxAUI_DOCK_BOTTOM)
4211 {
4212 used_height += dock.size;
4213 }
4214 if (dock.dock_direction == wxAUI_DOCK_LEFT ||
4215 dock.dock_direction == wxAUI_DOCK_RIGHT)
4216 {
4217 used_width += dock.size;
4218 }
4219 if (dock.resizable)
4220 used_width += sash_size;
4221 }
4222
4223
4224 int available_width = client_size.GetWidth() - used_width;
4225 int available_height = client_size.GetHeight() - used_height;
4226
4227
4228 #if wxUSE_STATUSBAR
4229 // if there's a status control, the available
4230 // height decreases accordingly
4231 if (m_frame && m_frame->IsKindOf(CLASSINFO(wxFrame)))
4232 {
4233 wxFrame* frame = static_cast<wxFrame*>(m_frame);
4234 wxStatusBar* status = frame->GetStatusBar();
4235 if (status)
4236 {
4237 wxSize status_client_size = status->GetClientSize();
4238 available_height -= status_client_size.GetHeight();
4239 }
4240 }
4241 #endif
4242
4243 wxRect& rect = m_action_part->dock->rect;
4244
4245 wxPoint new_pos(event.m_x - m_action_offset.x,
4246 event.m_y - m_action_offset.y);
4247 int new_size, old_size = m_action_part->dock->size;
4248
4249 switch (m_action_part->dock->dock_direction)
4250 {
4251 case wxAUI_DOCK_LEFT:
4252 new_size = new_pos.x - rect.x;
4253 if (new_size-old_size > available_width)
4254 new_size = old_size+available_width;
4255 m_action_part->dock->size = new_size;
4256 break;
4257 case wxAUI_DOCK_TOP:
4258 new_size = new_pos.y - rect.y;
4259 if (new_size-old_size > available_height)
4260 new_size = old_size+available_height;
4261 m_action_part->dock->size = new_size;
4262 break;
4263 case wxAUI_DOCK_RIGHT:
4264 new_size = rect.x + rect.width - new_pos.x -
4265 m_action_part->rect.GetWidth();
4266 if (new_size-old_size > available_width)
4267 new_size = old_size+available_width;
4268 m_action_part->dock->size = new_size;
4269 break;
4270 case wxAUI_DOCK_BOTTOM:
4271 new_size = rect.y + rect.height -
4272 new_pos.y - m_action_part->rect.GetHeight();
4273 if (new_size-old_size > available_height)
4274 new_size = old_size+available_height;
4275 m_action_part->dock->size = new_size;
4276 break;
4277 }
4278
4279 Update();
4280 Repaint(NULL);
4281 }
4282 else if (m_action_part &&
4283 m_action_part->type == wxAuiDockUIPart::typePaneSizer)
4284 {
4285 wxAuiDockInfo& dock = *m_action_part->dock;
4286 wxAuiPaneInfo& pane = *m_action_part->pane;
4287
4288 int total_proportion = 0;
4289 int dock_pixels = 0;
4290 int new_pixsize = 0;
4291
4292 int caption_size = m_art->GetMetric(wxAUI_DOCKART_CAPTION_SIZE);
4293 int pane_border_size = m_art->GetMetric(wxAUI_DOCKART_PANE_BORDER_SIZE);
4294 int sash_size = m_art->GetMetric(wxAUI_DOCKART_SASH_SIZE);
4295
4296 wxPoint new_pos(event.m_x - m_action_offset.x,
4297 event.m_y - m_action_offset.y);
4298
4299 // determine the pane rectangle by getting the pane part
4300 wxAuiDockUIPart* pane_part = GetPanePart(pane.window);
4301 wxASSERT_MSG(pane_part,
4302 wxT("Pane border part not found -- shouldn't happen"));
4303
4304 // determine the new pixel size that the user wants;
4305 // this will help us recalculate the pane's proportion
4306 if (dock.IsHorizontal())
4307 new_pixsize = new_pos.x - pane_part->rect.x;
4308 else
4309 new_pixsize = new_pos.y - pane_part->rect.y;
4310
4311 // determine the size of the dock, based on orientation
4312 if (dock.IsHorizontal())
4313 dock_pixels = dock.rect.GetWidth();
4314 else
4315 dock_pixels = dock.rect.GetHeight();
4316
4317 // determine the total proportion of all resizable panes,
4318 // and the total size of the dock minus the size of all
4319 // the fixed panes
4320 int i, dock_pane_count = dock.panes.GetCount();
4321 int pane_position = -1;
4322 for (i = 0; i < dock_pane_count; ++i)
4323 {
4324 wxAuiPaneInfo& p = *dock.panes.Item(i);
4325 if (p.window == pane.window)
4326 pane_position = i;
4327
4328 // while we're at it, subtract the pane sash
4329 // width from the dock width, because this would
4330 // skew our proportion calculations
4331 if (i > 0)
4332 dock_pixels -= sash_size;
4333
4334 // also, the whole size (including decorations) of
4335 // all fixed panes must also be subtracted, because they
4336 // are not part of the proportion calculation
4337 if (p.IsFixed())
4338 {
4339 if (dock.IsHorizontal())
4340 dock_pixels -= p.best_size.x;
4341 else
4342 dock_pixels -= p.best_size.y;
4343 }
4344 else
4345 {
4346 total_proportion += p.dock_proportion;
4347 }
4348 }
4349
4350 // new size can never be more than the number of dock pixels
4351 if (new_pixsize > dock_pixels)
4352 new_pixsize = dock_pixels;
4353
4354
4355 // find a pane in our dock to 'steal' space from or to 'give'
4356 // space to -- this is essentially what is done when a pane is
4357 // resized; the pane should usually be the first non-fixed pane
4358 // to the right of the action pane
4359 int borrow_pane = -1;
4360 for (i = pane_position+1; i < dock_pane_count; ++i)
4361 {
4362 wxAuiPaneInfo& p = *dock.panes.Item(i);
4363 if (!p.IsFixed())
4364 {
4365 borrow_pane = i;
4366 break;
4367 }
4368 }
4369
4370
4371 // demand that the pane being resized is found in this dock
4372 // (this assert really never should be raised)
4373 wxASSERT_MSG(pane_position != -1, wxT("Pane not found in dock"));
4374
4375 // prevent division by zero
4376 if (dock_pixels == 0 || total_proportion == 0 || borrow_pane == -1)
4377 {
4378 m_action = actionNone;
4379 return false;
4380 }
4381
4382 // calculate the new proportion of the pane
4383 int new_proportion = (new_pixsize*total_proportion)/dock_pixels;
4384
4385 // default minimum size
4386 int min_size = 0;
4387
4388 // check against the pane's minimum size, if specified. please note
4389 // that this is not enough to ensure that the minimum size will
4390 // not be violated, because the whole frame might later be shrunk,
4391 // causing the size of the pane to violate it's minimum size
4392 if (pane.min_size.IsFullySpecified())
4393 {
4394 min_size = 0;
4395
4396 if (pane.HasBorder())
4397 min_size += (pane_border_size*2);
4398
4399 // calculate minimum size with decorations (border,caption)
4400 if (pane_part->orientation == wxVERTICAL)
4401 {
4402 min_size += pane.min_size.y;
4403 if (pane.HasCaption())
4404 min_size += caption_size;
4405 }
4406 else
4407 {
4408 min_size += pane.min_size.x;
4409 }
4410 }
4411
4412
4413 // for some reason, an arithmatic error somewhere is causing
4414 // the proportion calculations to always be off by 1 pixel;
4415 // for now we will add the 1 pixel on, but we really should
4416 // determine what's causing this.
4417 min_size++;
4418
4419 int min_proportion = (min_size*total_proportion)/dock_pixels;
4420
4421 if (new_proportion < min_proportion)
4422 new_proportion = min_proportion;
4423
4424
4425
4426 int prop_diff = new_proportion - pane.dock_proportion;
4427
4428 // borrow the space from our neighbor pane to the
4429 // right or bottom (depending on orientation);
4430 // also make sure we don't make the neighbor too small
4431 int prop_borrow = dock.panes.Item(borrow_pane)->dock_proportion;
4432
4433 if (prop_borrow - prop_diff < 0)
4434 {
4435 // borrowing from other pane would make it too small,
4436 // so cancel the resize operation
4437 prop_borrow = min_proportion;
4438 }
4439 else
4440 {
4441 prop_borrow -= prop_diff;
4442 }
4443
4444
4445 dock.panes.Item(borrow_pane)->dock_proportion = prop_borrow;
4446 pane.dock_proportion = new_proportion;
4447
4448
4449 // repaint
4450 Update();
4451 Repaint(NULL);
4452 }
4453
4454 return true;
4455 }
4456
4457 void wxAuiManager::OnLeftUp(wxMouseEvent& event)
4458 {
4459 if (m_action == actionResize)
4460 {
4461 m_frame->ReleaseMouse();
4462
4463 if (!wxAuiManager_HasLiveResize(*this))
4464 {
4465 // get rid of the hint rectangle
4466 wxScreenDC dc;
4467 DrawResizeHint(dc, m_action_hintrect);
4468 }
4469 if (m_currentDragItem != -1 && wxAuiManager_HasLiveResize(*this))
4470 m_action_part = & (m_uiparts.Item(m_currentDragItem));
4471
4472 DoEndResizeAction(event);
4473
4474 m_currentDragItem = -1;
4475
4476 }
4477 else if (m_action == actionClickButton)
4478 {
4479 m_hover_button = NULL;
4480 m_frame->ReleaseMouse();
4481
4482 if (m_action_part)
4483 {
4484 UpdateButtonOnScreen(m_action_part, event);
4485
4486 // make sure we're still over the item that was originally clicked
4487 if (m_action_part == HitTest(event.GetX(), event.GetY()))
4488 {
4489 // fire button-click event
4490 wxAuiManagerEvent e(wxEVT_AUI_PANE_BUTTON);
4491 e.SetManager(this);
4492 e.SetPane(m_action_part->pane);
4493 e.SetButton(m_action_part->button->button_id);
4494 ProcessMgrEvent(e);
4495 }
4496 }
4497 }
4498 else if (m_action == actionClickCaption)
4499 {
4500 m_frame->ReleaseMouse();
4501 }
4502 else if (m_action == actionDragFloatingPane)
4503 {
4504 m_frame->ReleaseMouse();
4505 }
4506 else if (m_action == actionDragToolbarPane)
4507 {
4508 m_frame->ReleaseMouse();
4509
4510 wxAuiPaneInfo& pane = GetPane(m_action_window);
4511 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
4512
4513 // save the new positions
4514 wxAuiDockInfoPtrArray docks;
4515 FindDocks(m_docks, pane.dock_direction,
4516 pane.dock_layer, pane.dock_row, docks);
4517 if (docks.GetCount() == 1)
4518 {
4519 wxAuiDockInfo& dock = *docks.Item(0);
4520
4521 wxArrayInt pane_positions, pane_sizes;
4522 GetPanePositionsAndSizes(dock, pane_positions, pane_sizes);
4523
4524 int i, dock_pane_count = dock.panes.GetCount();
4525 for (i = 0; i < dock_pane_count; ++i)
4526 dock.panes.Item(i)->dock_pos = pane_positions[i];
4527 }
4528
4529 pane.state &= ~wxAuiPaneInfo::actionPane;
4530 Update();
4531 }
4532 else
4533 {
4534 event.Skip();
4535 }
4536
4537 m_action = actionNone;
4538 m_last_mouse_move = wxPoint(); // see comment in OnMotion()
4539 }
4540
4541
4542 void wxAuiManager::OnMotion(wxMouseEvent& event)
4543 {
4544 // sometimes when Update() is called from inside this method,
4545 // a spurious mouse move event is generated; this check will make
4546 // sure that only real mouse moves will get anywhere in this method;
4547 // this appears to be a bug somewhere, and I don't know where the
4548 // mouse move event is being generated. only verified on MSW
4549
4550 wxPoint mouse_pos = event.GetPosition();
4551 if (m_last_mouse_move == mouse_pos)
4552 return;
4553 m_last_mouse_move = mouse_pos;
4554
4555
4556 if (m_action == actionResize)
4557 {
4558 // It's necessary to reset m_action_part since it destroyed
4559 // by the Update within DoEndResizeAction.
4560 if (m_currentDragItem != -1)
4561 m_action_part = & (m_uiparts.Item(m_currentDragItem));
4562 else
4563 m_currentDragItem = m_uiparts.Index(* m_action_part);
4564
4565 if (m_action_part)
4566 {
4567 wxPoint pos = m_action_part->rect.GetPosition();
4568 if (m_action_part->orientation == wxHORIZONTAL)
4569 pos.y = wxMax(0, event.m_y - m_action_offset.y);
4570 else
4571 pos.x = wxMax(0, event.m_x - m_action_offset.x);
4572
4573 if (wxAuiManager_HasLiveResize(*this))
4574 {
4575 m_frame->ReleaseMouse();
4576 DoEndResizeAction(event);
4577 m_frame->CaptureMouse();
4578 }
4579 else
4580 {
4581 wxRect rect(m_frame->ClientToScreen(pos),
4582 m_action_part->rect.GetSize());
4583 wxScreenDC dc;
4584
4585 if (!m_action_hintrect.IsEmpty())
4586 {
4587 // remove old resize hint
4588 DrawResizeHint(dc, m_action_hintrect);
4589 m_action_hintrect = wxRect();
4590 }
4591
4592 // draw new resize hint, if it's inside the managed frame
4593 wxRect frame_screen_rect = m_frame->GetScreenRect();
4594 if (frame_screen_rect.Contains(rect))
4595 {
4596 DrawResizeHint(dc, rect);
4597 m_action_hintrect = rect;
4598 }
4599 }
4600 }
4601 }
4602 else if (m_action == actionClickCaption)
4603 {
4604 int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
4605 int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
4606
4607 // caption has been clicked. we need to check if the mouse
4608 // is now being dragged. if it is, we need to change the
4609 // mouse action to 'drag'
4610 if (m_action_part &&
4611 (abs(event.m_x - m_action_start.x) > drag_x_threshold ||
4612 abs(event.m_y - m_action_start.y) > drag_y_threshold))
4613 {
4614 wxAuiPaneInfo* pane_info = m_action_part->pane;
4615
4616 if (!pane_info->IsToolbar())
4617 {
4618 if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
4619 pane_info->IsFloatable())
4620 {
4621 m_action = actionDragFloatingPane;
4622
4623 // set initial float position
4624 wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
4625 pane_info->floating_pos = wxPoint(pt.x - m_action_offset.x,
4626 pt.y - m_action_offset.y);
4627
4628 // float the window
4629 if (pane_info->IsMaximized())
4630 RestorePane(*pane_info);
4631 pane_info->Float();
4632 Update();
4633
4634 m_action_window = pane_info->frame;
4635
4636 // action offset is used here to make it feel "natural" to the user
4637 // to drag a docked pane and suddenly have it become a floating frame.
4638 // Sometimes, however, the offset where the user clicked on the docked
4639 // caption is bigger than the width of the floating frame itself, so
4640 // in that case we need to set the action offset to a sensible value
4641 wxSize frame_size = m_action_window->GetSize();
4642 if (frame_size.x <= m_action_offset.x)
4643 m_action_offset.x = 30;
4644 }
4645 }
4646 else
4647 {
4648 m_action = actionDragToolbarPane;
4649 m_action_window = pane_info->window;
4650 }
4651 }
4652 }
4653 else if (m_action == actionDragFloatingPane)
4654 {
4655 if (m_action_window)
4656 {
4657 wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
4658 m_action_window->Move(pt.x - m_action_offset.x,
4659 pt.y - m_action_offset.y);
4660 }
4661 }
4662 else if (m_action == actionDragToolbarPane)
4663 {
4664 wxAuiPaneInfo& pane = GetPane(m_action_window);
4665 wxASSERT_MSG(pane.IsOk(), wxT("Pane window not found"));
4666
4667 pane.SetFlag(wxAuiPaneInfo::actionPane, true);
4668
4669 wxPoint pt = event.GetPosition();
4670 DoDrop(m_docks, m_panes, pane, pt, m_action_offset);
4671
4672 // if DoDrop() decided to float the pane, set up
4673 // the floating pane's initial position
4674 if (pane.IsFloating())
4675 {
4676 wxPoint pt = m_frame->ClientToScreen(event.GetPosition());
4677 pane.floating_pos = wxPoint(pt.x - m_action_offset.x,
4678 pt.y - m_action_offset.y);
4679 }
4680
4681 // this will do the actiual move operation;
4682 // in the case that the pane has been floated,
4683 // this call will create the floating pane
4684 // and do the reparenting
4685 Update();
4686
4687 // if the pane has been floated, change the mouse
4688 // action actionDragFloatingPane so that subsequent
4689 // EVT_MOTION() events will move the floating pane
4690 if (pane.IsFloating())
4691 {
4692 pane.state &= ~wxAuiPaneInfo::actionPane;
4693 m_action = actionDragFloatingPane;
4694 m_action_window = pane.frame;
4695 }
4696 }
4697 else
4698 {
4699 wxAuiDockUIPart* part = HitTest(event.GetX(), event.GetY());
4700 if (part && part->type == wxAuiDockUIPart::typePaneButton)
4701 {
4702 if (part != m_hover_button)
4703 {
4704 // make the old button normal
4705 if (m_hover_button)
4706 {
4707 UpdateButtonOnScreen(m_hover_button, event);
4708 Repaint();
4709 }
4710
4711 // mouse is over a button, so repaint the
4712 // button in hover mode
4713 UpdateButtonOnScreen(part, event);
4714 m_hover_button = part;
4715
4716 }
4717 }
4718 else
4719 {
4720 if (m_hover_button)
4721 {
4722 m_hover_button = NULL;
4723 Repaint();
4724 }
4725 else
4726 {
4727 event.Skip();
4728 }
4729 }
4730 }
4731 }
4732
4733 void wxAuiManager::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
4734 {
4735 if (m_hover_button)
4736 {
4737 m_hover_button = NULL;
4738 Repaint();
4739 }
4740 }
4741
4742 void wxAuiManager::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
4743 {
4744 // cancel the operation in progress, if any
4745 if ( m_action != actionNone )
4746 {
4747 m_action = actionNone;
4748 HideHint();
4749 }
4750 }
4751
4752 void wxAuiManager::OnChildFocus(wxChildFocusEvent& event)
4753 {
4754 // when a child pane has it's focus set, we should change the
4755 // pane's active state to reflect this. (this is only true if
4756 // active panes are allowed by the owner)
4757 if (GetFlags() & wxAUI_MGR_ALLOW_ACTIVE_PANE)
4758 {
4759 wxAuiPaneInfo& pane = GetPane(event.GetWindow());
4760 if (pane.IsOk() && (pane.state & wxAuiPaneInfo::optionActive) == 0)
4761 {
4762 SetActivePane(m_panes, event.GetWindow());
4763 m_frame->Refresh();
4764 }
4765 }
4766
4767 event.Skip();
4768 }
4769
4770
4771 // OnPaneButton() is an event handler that is called
4772 // when a pane button has been pressed.
4773 void wxAuiManager::OnPaneButton(wxAuiManagerEvent& evt)
4774 {
4775 wxASSERT_MSG(evt.pane, wxT("Pane Info passed to wxAuiManager::OnPaneButton must be non-null"));
4776
4777 wxAuiPaneInfo& pane = *(evt.pane);
4778
4779 if (evt.button == wxAUI_BUTTON_CLOSE)
4780 {
4781 // fire pane close event
4782 wxAuiManagerEvent e(wxEVT_AUI_PANE_CLOSE);
4783 e.SetManager(this);
4784 e.SetPane(evt.pane);
4785 ProcessMgrEvent(e);
4786
4787 if (!e.GetVeto())
4788 {
4789 // close the pane, but check that it
4790 // still exists in our pane array first
4791 // (the event handler above might have removed it)
4792
4793 wxAuiPaneInfo& check = GetPane(pane.window);
4794 if (check.IsOk())
4795 {
4796 ClosePane(pane);
4797 }
4798
4799 Update();
4800 }
4801 }
4802 else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && !pane.IsMaximized())
4803 {
4804 // fire pane close event
4805 wxAuiManagerEvent e(wxEVT_AUI_PANE_MAXIMIZE);
4806 e.SetManager(this);
4807 e.SetPane(evt.pane);
4808 ProcessMgrEvent(e);
4809
4810 if (!e.GetVeto())
4811 {
4812 MaximizePane(pane);
4813 Update();
4814 }
4815 }
4816 else if (evt.button == wxAUI_BUTTON_MAXIMIZE_RESTORE && pane.IsMaximized())
4817 {
4818 // fire pane close event
4819 wxAuiManagerEvent e(wxEVT_AUI_PANE_RESTORE);
4820 e.SetManager(this);
4821 e.SetPane(evt.pane);
4822 ProcessMgrEvent(e);
4823
4824 if (!e.GetVeto())
4825 {
4826 RestorePane(pane);
4827 Update();
4828 }
4829 }
4830 else if (evt.button == wxAUI_BUTTON_PIN)
4831 {
4832 if ((m_flags & wxAUI_MGR_ALLOW_FLOATING) &&
4833 pane.IsFloatable())
4834 pane.Float();
4835 Update();
4836 }
4837 }
4838
4839 #endif // wxUSE_AUI
wxWidgets (Impactor)