projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
silence warnings about shadowed variables with GCC -Wshadow
[wxWidgets.git] / src / aui / auibook.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/aui/auibook.cpp
3 // Purpose: wxaui: wx advanced user interface - notebook
4 // Author: Benjamin I. Williams
5 // Modified by: Jens Lody
6 // Created: 2006-06-28
7 // Copyright: (C) Copyright 2006, Kirix Corporation, All Rights Reserved
8 // Licence: wxWindows Library Licence, Version 3.1
9 ///////////////////////////////////////////////////////////////////////////////
10
11 // ----------------------------------------------------------------------------
12 // headers
13 // ----------------------------------------------------------------------------
14
15 #include "wx/wxprec.h"
16
17 #ifdef __BORLANDC__
18 #pragma hdrstop
19 #endif
20
21 #if wxUSE_AUI
22
23 #include "wx/aui/auibook.h"
24
25 #ifndef WX_PRECOMP
26 #include "wx/settings.h"
27 #include "wx/dcclient.h"
28 #include "wx/dcmemory.h"
29 #endif
30
31 #include "wx/aui/tabmdi.h"
32
33 #ifdef __WXMAC__
34 #include "wx/osx/private.h"
35 #endif
36
37 #include "wx/arrimpl.cpp"
38 WX_DEFINE_OBJARRAY(wxAuiNotebookPageArray)
39 WX_DEFINE_OBJARRAY(wxAuiTabContainerButtonArray)
40
41 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, wxAuiNotebookEvent);
42 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, wxAuiNotebookEvent);
43 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, wxAuiNotebookEvent);
44 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, wxAuiNotebookEvent);
45 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, wxAuiNotebookEvent);
46 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, wxAuiNotebookEvent);
47 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, wxAuiNotebookEvent);
48 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, wxAuiNotebookEvent);
49 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, wxAuiNotebookEvent);
50 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, wxAuiNotebookEvent);
51 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, wxAuiNotebookEvent);
52 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, wxAuiNotebookEvent);
53 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, wxAuiNotebookEvent);
54 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, wxAuiNotebookEvent);
55 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, wxAuiNotebookEvent);
56 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, wxAuiNotebookEvent);
57
58 IMPLEMENT_CLASS(wxAuiNotebook, wxControl)
59 IMPLEMENT_CLASS(wxAuiTabCtrl, wxControl)
60 IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxBookCtrlEvent)
61
62
63 // -- wxAuiTabContainer class implementation --
64
65
66 // wxAuiTabContainer is a class which contains information about each
67 // tab. It also can render an entire tab control to a specified DC.
68 // It's not a window class itself, because this code will be used by
69 // the wxFrameMananger, where it is disadvantageous to have separate
70 // windows for each tab control in the case of "docked tabs"
71
72 // A derived class, wxAuiTabCtrl, is an actual wxWindow-derived window
73 // which can be used as a tab control in the normal sense.
74
75
76 wxAuiTabContainer::wxAuiTabContainer()
77 {
78 m_tabOffset = 0;
79 m_flags = 0;
80 m_art = new wxAuiDefaultTabArt;
81
82 AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
83 AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
84 AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
85 AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
86 }
87
88 wxAuiTabContainer::~wxAuiTabContainer()
89 {
90 delete m_art;
91 }
92
93 void wxAuiTabContainer::SetArtProvider(wxAuiTabArt* art)
94 {
95 delete m_art;
96 m_art = art;
97
98 if (m_art)
99 {
100 m_art->SetFlags(m_flags);
101 }
102 }
103
104 wxAuiTabArt* wxAuiTabContainer::GetArtProvider() const
105 {
106 return m_art;
107 }
108
109 void wxAuiTabContainer::SetFlags(unsigned int flags)
110 {
111 m_flags = flags;
112
113 // check for new close button settings
114 RemoveButton(wxAUI_BUTTON_LEFT);
115 RemoveButton(wxAUI_BUTTON_RIGHT);
116 RemoveButton(wxAUI_BUTTON_WINDOWLIST);
117 RemoveButton(wxAUI_BUTTON_CLOSE);
118
119
120 if (flags & wxAUI_NB_SCROLL_BUTTONS)
121 {
122 AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
123 AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
124 }
125
126 if (flags & wxAUI_NB_WINDOWLIST_BUTTON)
127 {
128 AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
129 }
130
131 if (flags & wxAUI_NB_CLOSE_BUTTON)
132 {
133 AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
134 }
135
136 if (m_art)
137 {
138 m_art->SetFlags(m_flags);
139 }
140 }
141
142 unsigned int wxAuiTabContainer::GetFlags() const
143 {
144 return m_flags;
145 }
146
147
148 void wxAuiTabContainer::SetNormalFont(const wxFont& font)
149 {
150 m_art->SetNormalFont(font);
151 }
152
153 void wxAuiTabContainer::SetSelectedFont(const wxFont& font)
154 {
155 m_art->SetSelectedFont(font);
156 }
157
158 void wxAuiTabContainer::SetMeasuringFont(const wxFont& font)
159 {
160 m_art->SetMeasuringFont(font);
161 }
162
163 void wxAuiTabContainer::SetColour(const wxColour& colour)
164 {
165 m_art->SetColour(colour);
166 }
167
168 void wxAuiTabContainer::SetActiveColour(const wxColour& colour)
169 {
170 m_art->SetActiveColour(colour);
171 }
172
173 void wxAuiTabContainer::SetRect(const wxRect& rect)
174 {
175 m_rect = rect;
176
177 if (m_art)
178 {
179 m_art->SetSizingInfo(rect.GetSize(), m_pages.GetCount());
180 }
181 }
182
183 bool wxAuiTabContainer::AddPage(wxWindow* page,
184 const wxAuiNotebookPage& info)
185 {
186 wxAuiNotebookPage page_info;
187 page_info = info;
188 page_info.window = page;
189
190 m_pages.Add(page_info);
191
192 // let the art provider know how many pages we have
193 if (m_art)
194 {
195 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
196 }
197
198 return true;
199 }
200
201 bool wxAuiTabContainer::InsertPage(wxWindow* page,
202 const wxAuiNotebookPage& info,
203 size_t idx)
204 {
205 wxAuiNotebookPage page_info;
206 page_info = info;
207 page_info.window = page;
208
209 if (idx >= m_pages.GetCount())
210 m_pages.Add(page_info);
211 else
212 m_pages.Insert(page_info, idx);
213
214 // let the art provider know how many pages we have
215 if (m_art)
216 {
217 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
218 }
219
220 return true;
221 }
222
223 bool wxAuiTabContainer::MovePage(wxWindow* page,
224 size_t new_idx)
225 {
226 int idx = GetIdxFromWindow(page);
227 if (idx == -1)
228 return false;
229
230 // get page entry, make a copy of it
231 wxAuiNotebookPage p = GetPage(idx);
232
233 // remove old page entry
234 RemovePage(page);
235
236 // insert page where it should be
237 InsertPage(page, p, new_idx);
238
239 return true;
240 }
241
242 bool wxAuiTabContainer::RemovePage(wxWindow* wnd)
243 {
244 size_t i, page_count = m_pages.GetCount();
245 for (i = 0; i < page_count; ++i)
246 {
247 wxAuiNotebookPage& page = m_pages.Item(i);
248 if (page.window == wnd)
249 {
250 m_pages.RemoveAt(i);
251
252 // let the art provider know how many pages we have
253 if (m_art)
254 {
255 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
256 }
257
258 return true;
259 }
260 }
261
262 return false;
263 }
264
265 bool wxAuiTabContainer::SetActivePage(wxWindow* wnd)
266 {
267 bool found = false;
268
269 size_t i, page_count = m_pages.GetCount();
270 for (i = 0; i < page_count; ++i)
271 {
272 wxAuiNotebookPage& page = m_pages.Item(i);
273 if (page.window == wnd)
274 {
275 page.active = true;
276 found = true;
277 }
278 else
279 {
280 page.active = false;
281 }
282 }
283
284 return found;
285 }
286
287 void wxAuiTabContainer::SetNoneActive()
288 {
289 size_t i, page_count = m_pages.GetCount();
290 for (i = 0; i < page_count; ++i)
291 {
292 wxAuiNotebookPage& page = m_pages.Item(i);
293 page.active = false;
294 }
295 }
296
297 bool wxAuiTabContainer::SetActivePage(size_t page)
298 {
299 if (page >= m_pages.GetCount())
300 return false;
301
302 return SetActivePage(m_pages.Item(page).window);
303 }
304
305 int wxAuiTabContainer::GetActivePage() const
306 {
307 size_t i, page_count = m_pages.GetCount();
308 for (i = 0; i < page_count; ++i)
309 {
310 wxAuiNotebookPage& page = m_pages.Item(i);
311 if (page.active)
312 return i;
313 }
314
315 return -1;
316 }
317
318 wxWindow* wxAuiTabContainer::GetWindowFromIdx(size_t idx) const
319 {
320 if (idx >= m_pages.GetCount())
321 return NULL;
322
323 return m_pages[idx].window;
324 }
325
326 int wxAuiTabContainer::GetIdxFromWindow(wxWindow* wnd) const
327 {
328 const size_t page_count = m_pages.GetCount();
329 for ( size_t i = 0; i < page_count; ++i )
330 {
331 wxAuiNotebookPage& page = m_pages.Item(i);
332 if (page.window == wnd)
333 return i;
334 }
335 return wxNOT_FOUND;
336 }
337
338 wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx)
339 {
340 wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
341
342 return m_pages[idx];
343 }
344
345 const wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx) const
346 {
347 wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
348
349 return m_pages[idx];
350 }
351
352 wxAuiNotebookPageArray& wxAuiTabContainer::GetPages()
353 {
354 return m_pages;
355 }
356
357 size_t wxAuiTabContainer::GetPageCount() const
358 {
359 return m_pages.GetCount();
360 }
361
362 void wxAuiTabContainer::AddButton(int id,
363 int location,
364 const wxBitmap& normalBitmap,
365 const wxBitmap& disabledBitmap)
366 {
367 wxAuiTabContainerButton button;
368 button.id = id;
369 button.bitmap = normalBitmap;
370 button.disBitmap = disabledBitmap;
371 button.location = location;
372 button.curState = wxAUI_BUTTON_STATE_NORMAL;
373
374 m_buttons.Add(button);
375 }
376
377 void wxAuiTabContainer::RemoveButton(int id)
378 {
379 size_t i, button_count = m_buttons.GetCount();
380
381 for (i = 0; i < button_count; ++i)
382 {
383 if (m_buttons.Item(i).id == id)
384 {
385 m_buttons.RemoveAt(i);
386 return;
387 }
388 }
389 }
390
391
392
393 size_t wxAuiTabContainer::GetTabOffset() const
394 {
395 return m_tabOffset;
396 }
397
398 void wxAuiTabContainer::SetTabOffset(size_t offset)
399 {
400 m_tabOffset = offset;
401 }
402
403
404
405
406 // Render() renders the tab catalog to the specified DC
407 // It is a virtual function and can be overridden to
408 // provide custom drawing capabilities
409 void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
410 {
411 if (!raw_dc || !raw_dc->IsOk())
412 return;
413
414 wxMemoryDC dc;
415
416 // use the same layout direction as the window DC uses to ensure that the
417 // text is rendered correctly
418 dc.SetLayoutDirection(raw_dc->GetLayoutDirection());
419
420 wxBitmap bmp;
421 size_t i;
422 size_t page_count = m_pages.GetCount();
423 size_t button_count = m_buttons.GetCount();
424
425 // create off-screen bitmap
426 bmp.Create(m_rect.GetWidth(), m_rect.GetHeight());
427 dc.SelectObject(bmp);
428
429 if (!dc.IsOk())
430 return;
431
432 // find out if size of tabs is larger than can be
433 // afforded on screen
434 int total_width = 0;
435 int visible_width = 0;
436 for (i = 0; i < page_count; ++i)
437 {
438 wxAuiNotebookPage& page = m_pages.Item(i);
439
440 // determine if a close button is on this tab
441 bool close_button = false;
442 if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
443 ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
444 {
445 close_button = true;
446 }
447
448
449 int x_extent = 0;
450 wxSize size = m_art->GetTabSize(dc,
451 wnd,
452 page.caption,
453 page.bitmap,
454 page.active,
455 close_button ?
456 wxAUI_BUTTON_STATE_NORMAL :
457 wxAUI_BUTTON_STATE_HIDDEN,
458 &x_extent);
459
460 if (i+1 < page_count)
461 total_width += x_extent;
462 else
463 total_width += size.x;
464
465 if (i >= m_tabOffset)
466 {
467 if (i+1 < page_count)
468 visible_width += x_extent;
469 else
470 visible_width += size.x;
471 }
472 }
473
474 if (total_width > m_rect.GetWidth() || m_tabOffset != 0)
475 {
476 // show left/right buttons
477 for (i = 0; i < button_count; ++i)
478 {
479 wxAuiTabContainerButton& button = m_buttons.Item(i);
480 if (button.id == wxAUI_BUTTON_LEFT ||
481 button.id == wxAUI_BUTTON_RIGHT)
482 {
483 button.curState &= ~wxAUI_BUTTON_STATE_HIDDEN;
484 }
485 }
486 }
487 else
488 {
489 // hide left/right buttons
490 for (i = 0; i < button_count; ++i)
491 {
492 wxAuiTabContainerButton& button = m_buttons.Item(i);
493 if (button.id == wxAUI_BUTTON_LEFT ||
494 button.id == wxAUI_BUTTON_RIGHT)
495 {
496 button.curState |= wxAUI_BUTTON_STATE_HIDDEN;
497 }
498 }
499 }
500
501 // determine whether left button should be enabled
502 for (i = 0; i < button_count; ++i)
503 {
504 wxAuiTabContainerButton& button = m_buttons.Item(i);
505 if (button.id == wxAUI_BUTTON_LEFT)
506 {
507 if (m_tabOffset == 0)
508 button.curState |= wxAUI_BUTTON_STATE_DISABLED;
509 else
510 button.curState &= ~wxAUI_BUTTON_STATE_DISABLED;
511 }
512 if (button.id == wxAUI_BUTTON_RIGHT)
513 {
514 if (visible_width < m_rect.GetWidth() - ((int)button_count*16))
515 button.curState |= wxAUI_BUTTON_STATE_DISABLED;
516 else
517 button.curState &= ~wxAUI_BUTTON_STATE_DISABLED;
518 }
519 }
520
521
522
523 // draw background
524 m_art->DrawBackground(dc, wnd, m_rect);
525
526 // draw buttons
527 int left_buttons_width = 0;
528 int right_buttons_width = 0;
529
530 // draw the buttons on the right side
531 int offset = m_rect.x + m_rect.width;
532 for (i = 0; i < button_count; ++i)
533 {
534 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
535
536 if (button.location != wxRIGHT)
537 continue;
538 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
539 continue;
540
541 wxRect button_rect = m_rect;
542 button_rect.SetY(1);
543 button_rect.SetWidth(offset);
544
545 m_art->DrawButton(dc,
546 wnd,
547 button_rect,
548 button.id,
549 button.curState,
550 wxRIGHT,
551 &button.rect);
552
553 offset -= button.rect.GetWidth();
554 right_buttons_width += button.rect.GetWidth();
555 }
556
557
558
559 offset = 0;
560
561 // draw the buttons on the left side
562
563 for (i = 0; i < button_count; ++i)
564 {
565 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
566
567 if (button.location != wxLEFT)
568 continue;
569 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
570 continue;
571
572 wxRect button_rect(offset, 1, 1000, m_rect.height);
573
574 m_art->DrawButton(dc,
575 wnd,
576 button_rect,
577 button.id,
578 button.curState,
579 wxLEFT,
580 &button.rect);
581
582 offset += button.rect.GetWidth();
583 left_buttons_width += button.rect.GetWidth();
584 }
585
586 offset = left_buttons_width;
587
588 if (offset == 0)
589 offset += m_art->GetIndentSize();
590
591
592 // prepare the tab-close-button array
593 // make sure tab button entries which aren't used are marked as hidden
594 for (i = page_count; i < m_tabCloseButtons.GetCount(); ++i)
595 m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
596
597 // make sure there are enough tab button entries to accommodate all tabs
598 while (m_tabCloseButtons.GetCount() < page_count)
599 {
600 wxAuiTabContainerButton tempbtn;
601 tempbtn.id = wxAUI_BUTTON_CLOSE;
602 tempbtn.location = wxCENTER;
603 tempbtn.curState = wxAUI_BUTTON_STATE_HIDDEN;
604 m_tabCloseButtons.Add(tempbtn);
605 }
606
607
608 // buttons before the tab offset must be set to hidden
609 for (i = 0; i < m_tabOffset; ++i)
610 {
611 m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
612 }
613
614
615 // draw the tabs
616
617 size_t active = 999;
618 int active_offset = 0;
619 wxRect active_rect;
620
621 int x_extent = 0;
622 wxRect rect = m_rect;
623 rect.y = 0;
624 rect.height = m_rect.height;
625
626 for (i = m_tabOffset; i < page_count; ++i)
627 {
628 wxAuiNotebookPage& page = m_pages.Item(i);
629 wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(i);
630
631 // determine if a close button is on this tab
632 if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
633 ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
634 {
635 if (tab_button.curState == wxAUI_BUTTON_STATE_HIDDEN)
636 {
637 tab_button.id = wxAUI_BUTTON_CLOSE;
638 tab_button.curState = wxAUI_BUTTON_STATE_NORMAL;
639 tab_button.location = wxCENTER;
640 }
641 }
642 else
643 {
644 tab_button.curState = wxAUI_BUTTON_STATE_HIDDEN;
645 }
646
647 rect.x = offset;
648 rect.width = m_rect.width - right_buttons_width - offset - 2;
649
650 if (rect.width <= 0)
651 break;
652
653 m_art->DrawTab(dc,
654 wnd,
655 page,
656 rect,
657 tab_button.curState,
658 &page.rect,
659 &tab_button.rect,
660 &x_extent);
661
662 if (page.active)
663 {
664 active = i;
665 active_offset = offset;
666 active_rect = rect;
667 }
668
669 offset += x_extent;
670 }
671
672
673 // make sure to deactivate buttons which are off the screen to the right
674 for (++i; i < m_tabCloseButtons.GetCount(); ++i)
675 {
676 m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
677 }
678
679
680 // draw the active tab again so it stands in the foreground
681 if (active >= m_tabOffset && active < m_pages.GetCount())
682 {
683 wxAuiNotebookPage& page = m_pages.Item(active);
684
685 wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(active);
686
687 rect.x = active_offset;
688 m_art->DrawTab(dc,
689 wnd,
690 page,
691 active_rect,
692 tab_button.curState,
693 &page.rect,
694 &tab_button.rect,
695 &x_extent);
696 }
697
698
699 raw_dc->Blit(m_rect.x, m_rect.y,
700 m_rect.GetWidth(), m_rect.GetHeight(),
701 &dc, 0, 0);
702 }
703
704 // Is the tab visible?
705 bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWindow* wnd)
706 {
707 if (!dc || !dc->IsOk())
708 return false;
709
710 size_t i;
711 size_t page_count = m_pages.GetCount();
712 size_t button_count = m_buttons.GetCount();
713
714 // Hasn't been rendered yet; assume it's visible
715 if (m_tabCloseButtons.GetCount() < page_count)
716 return true;
717
718 // First check if both buttons are disabled - if so, there's no need to
719 // check further for visibility.
720 int arrowButtonVisibleCount = 0;
721 for (i = 0; i < button_count; ++i)
722 {
723 wxAuiTabContainerButton& button = m_buttons.Item(i);
724 if (button.id == wxAUI_BUTTON_LEFT ||
725 button.id == wxAUI_BUTTON_RIGHT)
726 {
727 if ((button.curState & wxAUI_BUTTON_STATE_HIDDEN) == 0)
728 arrowButtonVisibleCount ++;
729 }
730 }
731
732 // Tab must be visible
733 if (arrowButtonVisibleCount == 0)
734 return true;
735
736 // If tab is less than the given offset, it must be invisible by definition
737 if (tabPage < tabOffset)
738 return false;
739
740 // draw buttons
741 int left_buttons_width = 0;
742 int right_buttons_width = 0;
743
744 // calculate size of the buttons on the right side
745 int offset = m_rect.x + m_rect.width;
746 for (i = 0; i < button_count; ++i)
747 {
748 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
749
750 if (button.location != wxRIGHT)
751 continue;
752 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
753 continue;
754
755 offset -= button.rect.GetWidth();
756 right_buttons_width += button.rect.GetWidth();
757 }
758
759 offset = 0;
760
761 // calculate size of the buttons on the left side
762 for (i = 0; i < button_count; ++i)
763 {
764 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
765
766 if (button.location != wxLEFT)
767 continue;
768 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
769 continue;
770
771 offset += button.rect.GetWidth();
772 left_buttons_width += button.rect.GetWidth();
773 }
774
775 offset = left_buttons_width;
776
777 if (offset == 0)
778 offset += m_art->GetIndentSize();
779
780 wxRect active_rect;
781
782 wxRect rect = m_rect;
783 rect.y = 0;
784 rect.height = m_rect.height;
785
786 // See if the given page is visible at the given tab offset (effectively scroll position)
787 for (i = tabOffset; i < page_count; ++i)
788 {
789 wxAuiNotebookPage& page = m_pages.Item(i);
790 wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(i);
791
792 rect.x = offset;
793 rect.width = m_rect.width - right_buttons_width - offset - 2;
794
795 if (rect.width <= 0)
796 return false; // haven't found the tab, and we've run out of space, so return false
797
798 int x_extent = 0;
799 m_art->GetTabSize(*dc,
800 wnd,
801 page.caption,
802 page.bitmap,
803 page.active,
804 tab_button.curState,
805 &x_extent);
806
807 offset += x_extent;
808
809 if (i == (size_t) tabPage)
810 {
811 // If not all of the tab is visible, and supposing there's space to display it all,
812 // we could do better so we return false.
813 if (((m_rect.width - right_buttons_width - offset - 2) <= 0) && ((m_rect.width - right_buttons_width - left_buttons_width) > x_extent))
814 return false;
815 else
816 return true;
817 }
818 }
819
820 // Shouldn't really get here, but if it does, assume the tab is visible to prevent
821 // further looping in calling code.
822 return true;
823 }
824
825 // Make the tab visible if it wasn't already
826 void wxAuiTabContainer::MakeTabVisible(int tabPage, wxWindow* win)
827 {
828 wxClientDC dc(win);
829 if (!IsTabVisible(tabPage, GetTabOffset(), & dc, win))
830 {
831 int i;
832 for (i = 0; i < (int) m_pages.GetCount(); i++)
833 {
834 if (IsTabVisible(tabPage, i, & dc, win))
835 {
836 SetTabOffset(i);
837 win->Refresh();
838 return;
839 }
840 }
841 }
842 }
843
844 // TabHitTest() tests if a tab was hit, passing the window pointer
845 // back if that condition was fulfilled. The function returns
846 // true if a tab was hit, otherwise false
847 bool wxAuiTabContainer::TabHitTest(int x, int y, wxWindow** hit) const
848 {
849 if (!m_rect.Contains(x,y))
850 return false;
851
852 wxAuiTabContainerButton* btn = NULL;
853 if (ButtonHitTest(x, y, &btn) && !(btn->curState & wxAUI_BUTTON_STATE_DISABLED))
854 {
855 if (m_buttons.Index(*btn) != wxNOT_FOUND)
856 return false;
857 }
858
859 size_t i, page_count = m_pages.GetCount();
860
861 for (i = m_tabOffset; i < page_count; ++i)
862 {
863 wxAuiNotebookPage& page = m_pages.Item(i);
864 if (page.rect.Contains(x,y))
865 {
866 if (hit)
867 *hit = page.window;
868 return true;
869 }
870 }
871
872 return false;
873 }
874
875 // ButtonHitTest() tests if a button was hit. The function returns
876 // true if a button was hit, otherwise false
877 bool wxAuiTabContainer::ButtonHitTest(int x, int y,
878 wxAuiTabContainerButton** hit) const
879 {
880 if (!m_rect.Contains(x,y))
881 return false;
882
883 size_t i, button_count;
884
885
886 button_count = m_buttons.GetCount();
887 for (i = 0; i < button_count; ++i)
888 {
889 wxAuiTabContainerButton& button = m_buttons.Item(i);
890 if (button.rect.Contains(x,y) &&
891 !(button.curState & wxAUI_BUTTON_STATE_HIDDEN ))
892 {
893 if (hit)
894 *hit = &button;
895 return true;
896 }
897 }
898
899 button_count = m_tabCloseButtons.GetCount();
900 for (i = 0; i < button_count; ++i)
901 {
902 wxAuiTabContainerButton& button = m_tabCloseButtons.Item(i);
903 if (button.rect.Contains(x,y) &&
904 !(button.curState & (wxAUI_BUTTON_STATE_HIDDEN |
905 wxAUI_BUTTON_STATE_DISABLED)))
906 {
907 if (hit)
908 *hit = &button;
909 return true;
910 }
911 }
912
913 return false;
914 }
915
916
917
918 // the utility function ShowWnd() is the same as show,
919 // except it handles wxAuiMDIChildFrame windows as well,
920 // as the Show() method on this class is "unplugged"
921 static void ShowWnd(wxWindow* wnd, bool show)
922 {
923 #if wxUSE_MDI
924 if (wxDynamicCast(wnd, wxAuiMDIChildFrame))
925 {
926 wxAuiMDIChildFrame* cf = (wxAuiMDIChildFrame*)wnd;
927 cf->DoShow(show);
928 }
929 else
930 #endif
931 {
932 wnd->Show(show);
933 }
934 }
935
936
937 // DoShowHide() this function shows the active window, then
938 // hides all of the other windows (in that order)
939 void wxAuiTabContainer::DoShowHide()
940 {
941 wxAuiNotebookPageArray& pages = GetPages();
942 size_t i, page_count = pages.GetCount();
943
944 // show new active page first
945 for (i = 0; i < page_count; ++i)
946 {
947 wxAuiNotebookPage& page = pages.Item(i);
948 if (page.active)
949 {
950 ShowWnd(page.window, true);
951 break;
952 }
953 }
954
955 // hide all other pages
956 for (i = 0; i < page_count; ++i)
957 {
958 wxAuiNotebookPage& page = pages.Item(i);
959 if (!page.active)
960 ShowWnd(page.window, false);
961 }
962 }
963
964
965
966
967
968
969 // -- wxAuiTabCtrl class implementation --
970
971
972
973 BEGIN_EVENT_TABLE(wxAuiTabCtrl, wxControl)
974 EVT_PAINT(wxAuiTabCtrl::OnPaint)
975 EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
976 EVT_SIZE(wxAuiTabCtrl::OnSize)
977 EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)
978 EVT_LEFT_DCLICK(wxAuiTabCtrl::OnLeftDClick)
979 EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
980 EVT_MIDDLE_DOWN(wxAuiTabCtrl::OnMiddleDown)
981 EVT_MIDDLE_UP(wxAuiTabCtrl::OnMiddleUp)
982 EVT_RIGHT_DOWN(wxAuiTabCtrl::OnRightDown)
983 EVT_RIGHT_UP(wxAuiTabCtrl::OnRightUp)
984 EVT_MOTION(wxAuiTabCtrl::OnMotion)
985 EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
986 EVT_AUINOTEBOOK_BUTTON(wxID_ANY, wxAuiTabCtrl::OnButton)
987 EVT_SET_FOCUS(wxAuiTabCtrl::OnSetFocus)
988 EVT_KILL_FOCUS(wxAuiTabCtrl::OnKillFocus)
989 EVT_CHAR(wxAuiTabCtrl::OnChar)
990 EVT_MOUSE_CAPTURE_LOST(wxAuiTabCtrl::OnCaptureLost)
991 END_EVENT_TABLE()
992
993
994 wxAuiTabCtrl::wxAuiTabCtrl(wxWindow* parent,
995 wxWindowID id,
996 const wxPoint& pos,
997 const wxSize& size,
998 long style) : wxControl(parent, id, pos, size, style)
999 {
1000 SetName(wxT("wxAuiTabCtrl"));
1001 m_clickPt = wxDefaultPosition;
1002 m_isDragging = false;
1003 m_hoverButton = NULL;
1004 m_pressedButton = NULL;
1005 }
1006
1007 wxAuiTabCtrl::~wxAuiTabCtrl()
1008 {
1009 }
1010
1011 void wxAuiTabCtrl::OnPaint(wxPaintEvent&)
1012 {
1013 wxPaintDC dc(this);
1014
1015 dc.SetFont(GetFont());
1016
1017 if (GetPageCount() > 0)
1018 Render(&dc, this);
1019 }
1020
1021 void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
1022 {
1023 }
1024
1025 void wxAuiTabCtrl::OnSize(wxSizeEvent& evt)
1026 {
1027 wxSize s = evt.GetSize();
1028 wxRect r(0, 0, s.GetWidth(), s.GetHeight());
1029 SetRect(r);
1030 }
1031
1032 void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
1033 {
1034 CaptureMouse();
1035 m_clickPt = wxDefaultPosition;
1036 m_isDragging = false;
1037 m_clickTab = NULL;
1038 m_pressedButton = NULL;
1039
1040
1041 wxWindow* wnd;
1042 if (TabHitTest(evt.m_x, evt.m_y, &wnd))
1043 {
1044 int new_selection = GetIdxFromWindow(wnd);
1045
1046 // wxAuiNotebooks always want to receive this event
1047 // even if the tab is already active, because they may
1048 // have multiple tab controls
1049 if ((new_selection != GetActivePage() ||
1050 wxDynamicCast(GetParent(), wxAuiNotebook)) && !m_hoverButton)
1051 {
1052 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
1053 e.SetSelection(new_selection);
1054 e.SetOldSelection(GetActivePage());
1055 e.SetEventObject(this);
1056 GetEventHandler()->ProcessEvent(e);
1057 }
1058
1059 m_clickPt.x = evt.m_x;
1060 m_clickPt.y = evt.m_y;
1061 m_clickTab = wnd;
1062 }
1063
1064 if (m_hoverButton)
1065 {
1066 m_pressedButton = m_hoverButton;
1067 m_pressedButton->curState = wxAUI_BUTTON_STATE_PRESSED;
1068 Refresh();
1069 Update();
1070 }
1071 }
1072
1073 void wxAuiTabCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
1074 {
1075 if (m_isDragging)
1076 {
1077 m_isDragging = false;
1078
1079 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, m_windowId);
1080 evt.SetSelection(GetIdxFromWindow(m_clickTab));
1081 evt.SetOldSelection(evt.GetSelection());
1082 evt.SetEventObject(this);
1083 GetEventHandler()->ProcessEvent(evt);
1084 }
1085 }
1086
1087 void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
1088 {
1089 if (GetCapture() == this)
1090 ReleaseMouse();
1091
1092 if (m_isDragging)
1093 {
1094 m_isDragging = false;
1095
1096 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);
1097 e.SetSelection(GetIdxFromWindow(m_clickTab));
1098 e.SetOldSelection(e.GetSelection());
1099 e.SetEventObject(this);
1100 GetEventHandler()->ProcessEvent(e);
1101
1102 return;
1103 }
1104
1105 if (m_pressedButton)
1106 {
1107 // make sure we're still clicking the button
1108 wxAuiTabContainerButton* button = NULL;
1109 if (!ButtonHitTest(evt.m_x, evt.m_y, &button) ||
1110 button->curState & wxAUI_BUTTON_STATE_DISABLED)
1111 return;
1112
1113 if (button != m_pressedButton)
1114 {
1115 m_pressedButton = NULL;
1116 return;
1117 }
1118
1119 Refresh();
1120 Update();
1121
1122 if (!(m_pressedButton->curState & wxAUI_BUTTON_STATE_DISABLED))
1123 {
1124 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
1125 e.SetSelection(GetIdxFromWindow(m_clickTab));
1126 e.SetInt(m_pressedButton->id);
1127 e.SetEventObject(this);
1128 GetEventHandler()->ProcessEvent(e);
1129 }
1130
1131 m_pressedButton = NULL;
1132 }
1133
1134 m_clickPt = wxDefaultPosition;
1135 m_isDragging = false;
1136 m_clickTab = NULL;
1137 }
1138
1139 void wxAuiTabCtrl::OnMiddleUp(wxMouseEvent& evt)
1140 {
1141 wxWindow* wnd = NULL;
1142 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
1143 return;
1144
1145 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
1146 e.SetEventObject(this);
1147 e.SetSelection(GetIdxFromWindow(wnd));
1148 GetEventHandler()->ProcessEvent(e);
1149 }
1150
1151 void wxAuiTabCtrl::OnMiddleDown(wxMouseEvent& evt)
1152 {
1153 wxWindow* wnd = NULL;
1154 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
1155 return;
1156
1157 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
1158 e.SetEventObject(this);
1159 e.SetSelection(GetIdxFromWindow(wnd));
1160 GetEventHandler()->ProcessEvent(e);
1161 }
1162
1163 void wxAuiTabCtrl::OnRightUp(wxMouseEvent& evt)
1164 {
1165 wxWindow* wnd = NULL;
1166 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
1167 return;
1168
1169 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
1170 e.SetEventObject(this);
1171 e.SetSelection(GetIdxFromWindow(wnd));
1172 GetEventHandler()->ProcessEvent(e);
1173 }
1174
1175 void wxAuiTabCtrl::OnRightDown(wxMouseEvent& evt)
1176 {
1177 wxWindow* wnd = NULL;
1178 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
1179 return;
1180
1181 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
1182 e.SetEventObject(this);
1183 e.SetSelection(GetIdxFromWindow(wnd));
1184 GetEventHandler()->ProcessEvent(e);
1185 }
1186
1187 void wxAuiTabCtrl::OnLeftDClick(wxMouseEvent& evt)
1188 {
1189 wxWindow* wnd;
1190 wxAuiTabContainerButton* button;
1191 if (!TabHitTest(evt.m_x, evt.m_y, &wnd) && !ButtonHitTest(evt.m_x, evt.m_y, &button))
1192 {
1193 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
1194 e.SetEventObject(this);
1195 GetEventHandler()->ProcessEvent(e);
1196 }
1197 }
1198
1199 void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
1200 {
1201 wxPoint pos = evt.GetPosition();
1202
1203 // check if the mouse is hovering above a button
1204 wxAuiTabContainerButton* button;
1205 if (ButtonHitTest(pos.x, pos.y, &button) && !(button->curState & wxAUI_BUTTON_STATE_DISABLED))
1206 {
1207 if (m_hoverButton && button != m_hoverButton)
1208 {
1209 m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
1210 m_hoverButton = NULL;
1211 Refresh();
1212 Update();
1213 }
1214
1215 if (button->curState != wxAUI_BUTTON_STATE_HOVER)
1216 {
1217 button->curState = wxAUI_BUTTON_STATE_HOVER;
1218 Refresh();
1219 Update();
1220
1221 m_hoverButton = button;
1222 return;
1223 }
1224 }
1225 else
1226 {
1227 if (m_hoverButton)
1228 {
1229 m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
1230 m_hoverButton = NULL;
1231 Refresh();
1232 Update();
1233 }
1234 }
1235
1236 wxWindow* wnd = NULL;
1237
1238 #if wxUSE_TOOLTIPS
1239 if (evt.Moving() && TabHitTest(evt.m_x, evt.m_y, &wnd))
1240 {
1241 wxString tooltip(m_pages[GetIdxFromWindow(wnd)].tooltip);
1242
1243 // If the text changes, set it else, keep old, to avoid
1244 // 'moving tooltip' effect
1245 if (GetToolTipText() != tooltip)
1246 SetToolTip(tooltip);
1247 }
1248 else
1249 UnsetToolTip();
1250 #endif
1251
1252 if (!evt.LeftIsDown() || m_clickPt == wxDefaultPosition)
1253 return;
1254
1255 if (m_isDragging)
1256 {
1257 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
1258 e.SetSelection(GetIdxFromWindow(m_clickTab));
1259 e.SetOldSelection(e.GetSelection());
1260 e.SetEventObject(this);
1261 GetEventHandler()->ProcessEvent(e);
1262 return;
1263 }
1264
1265
1266 int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
1267 int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
1268
1269 if (abs(pos.x - m_clickPt.x) > drag_x_threshold ||
1270 abs(pos.y - m_clickPt.y) > drag_y_threshold)
1271 {
1272 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
1273 e.SetSelection(GetIdxFromWindow(m_clickTab));
1274 e.SetOldSelection(e.GetSelection());
1275 e.SetEventObject(this);
1276 GetEventHandler()->ProcessEvent(e);
1277
1278 m_isDragging = true;
1279 }
1280 }
1281
1282 void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
1283 {
1284 if (m_hoverButton)
1285 {
1286 m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
1287 m_hoverButton = NULL;
1288 Refresh();
1289 Update();
1290 }
1291 }
1292
1293 void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
1294 {
1295 int button = event.GetInt();
1296
1297 if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
1298 {
1299 if (button == wxAUI_BUTTON_LEFT)
1300 {
1301 if (GetTabOffset() > 0)
1302 {
1303 SetTabOffset(GetTabOffset()-1);
1304 Refresh();
1305 Update();
1306 }
1307 }
1308 else
1309 {
1310 SetTabOffset(GetTabOffset()+1);
1311 Refresh();
1312 Update();
1313 }
1314 }
1315 else if (button == wxAUI_BUTTON_WINDOWLIST)
1316 {
1317 int idx = GetArtProvider()->ShowDropDown(this, m_pages, GetActivePage());
1318
1319 if (idx != -1)
1320 {
1321 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
1322 e.SetSelection(idx);
1323 e.SetOldSelection(GetActivePage());
1324 e.SetEventObject(this);
1325 GetEventHandler()->ProcessEvent(e);
1326 }
1327 }
1328 else
1329 {
1330 event.Skip();
1331 }
1332 }
1333
1334 void wxAuiTabCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
1335 {
1336 Refresh();
1337 }
1338
1339 void wxAuiTabCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
1340 {
1341 Refresh();
1342 }
1343
1344 void wxAuiTabCtrl::OnChar(wxKeyEvent& event)
1345 {
1346 if (GetActivePage() == -1)
1347 {
1348 event.Skip();
1349 return;
1350 }
1351
1352 // We can't leave tab processing to the system; on Windows, tabs and keys
1353 // get eaten by the system and not processed properly if we specify both
1354 // wxTAB_TRAVERSAL and wxWANTS_CHARS. And if we specify just wxTAB_TRAVERSAL,
1355 // we don't key arrow key events.
1356
1357 int key = event.GetKeyCode();
1358
1359 if (key == WXK_NUMPAD_PAGEUP)
1360 key = WXK_PAGEUP;
1361 if (key == WXK_NUMPAD_PAGEDOWN)
1362 key = WXK_PAGEDOWN;
1363 if (key == WXK_NUMPAD_HOME)
1364 key = WXK_HOME;
1365 if (key == WXK_NUMPAD_END)
1366 key = WXK_END;
1367 if (key == WXK_NUMPAD_LEFT)
1368 key = WXK_LEFT;
1369 if (key == WXK_NUMPAD_RIGHT)
1370 key = WXK_RIGHT;
1371
1372 if (key == WXK_TAB || key == WXK_PAGEUP || key == WXK_PAGEDOWN)
1373 {
1374 bool bCtrlDown = event.ControlDown();
1375 bool bShiftDown = event.ShiftDown();
1376
1377 bool bForward = (key == WXK_TAB && !bShiftDown) || (key == WXK_PAGEDOWN);
1378 bool bWindowChange = (key == WXK_PAGEUP) || (key == WXK_PAGEDOWN) || bCtrlDown;
1379 bool bFromTab = (key == WXK_TAB);
1380
1381 wxAuiNotebook* nb = wxDynamicCast(GetParent(), wxAuiNotebook);
1382 if (!nb)
1383 {
1384 event.Skip();
1385 return;
1386 }
1387
1388 wxNavigationKeyEvent keyEvent;
1389 keyEvent.SetDirection(bForward);
1390 keyEvent.SetWindowChange(bWindowChange);
1391 keyEvent.SetFromTab(bFromTab);
1392 keyEvent.SetEventObject(nb);
1393
1394 if (!nb->GetEventHandler()->ProcessEvent(keyEvent))
1395 {
1396 // Not processed? Do an explicit tab into the page.
1397 wxWindow* win = GetWindowFromIdx(GetActivePage());
1398 if (win)
1399 win->SetFocus();
1400 }
1401 return;
1402 }
1403
1404 if (m_pages.GetCount() < 2)
1405 {
1406 event.Skip();
1407 return;
1408 }
1409
1410 int newPage = -1;
1411
1412 int forwardKey, backwardKey;
1413 if (GetLayoutDirection() == wxLayout_RightToLeft)
1414 {
1415 forwardKey = WXK_LEFT;
1416 backwardKey = WXK_RIGHT;
1417 }
1418 else
1419 {
1420 forwardKey = WXK_RIGHT;
1421 backwardKey = WXK_LEFT;
1422 }
1423
1424 if (key == forwardKey)
1425 {
1426 if (m_pages.GetCount() > 1)
1427 {
1428 if (GetActivePage() == -1)
1429 newPage = 0;
1430 else if (GetActivePage() < (int) (m_pages.GetCount() - 1))
1431 newPage = GetActivePage() + 1;
1432 }
1433 }
1434 else if (key == backwardKey)
1435 {
1436 if (m_pages.GetCount() > 1)
1437 {
1438 if (GetActivePage() == -1)
1439 newPage = (int) (m_pages.GetCount() - 1);
1440 else if (GetActivePage() > 0)
1441 newPage = GetActivePage() - 1;
1442 }
1443 }
1444 else if (key == WXK_HOME)
1445 {
1446 newPage = 0;
1447 }
1448 else if (key == WXK_END)
1449 {
1450 newPage = (int) (m_pages.GetCount() - 1);
1451 }
1452 else
1453 event.Skip();
1454
1455 if (newPage != -1)
1456 {
1457 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
1458 e.SetSelection(newPage);
1459 e.SetOldSelection(newPage);
1460 e.SetEventObject(this);
1461 this->GetEventHandler()->ProcessEvent(e);
1462 }
1463 else
1464 event.Skip();
1465 }
1466
1467 // wxTabFrame is an interesting case. It's important that all child pages
1468 // of the multi-notebook control are all actually children of that control
1469 // (and not grandchildren). wxTabFrame facilitates this. There is one
1470 // instance of wxTabFrame for each tab control inside the multi-notebook.
1471 // It's important to know that wxTabFrame is not a real window, but it merely
1472 // used to capture the dimensions/positioning of the internal tab control and
1473 // it's managed page windows
1474
1475 class wxTabFrame : public wxWindow
1476 {
1477 public:
1478
1479 wxTabFrame()
1480 {
1481 m_tabs = NULL;
1482 m_rect = wxRect(0,0,200,200);
1483 m_tabCtrlHeight = 20;
1484 }
1485
1486 ~wxTabFrame()
1487 {
1488 wxDELETE(m_tabs);
1489 }
1490
1491 void SetTabCtrlHeight(int h)
1492 {
1493 m_tabCtrlHeight = h;
1494 }
1495
1496 protected:
1497 void DoSetSize(int x, int y,
1498 int width, int height,
1499 int WXUNUSED(sizeFlags = wxSIZE_AUTO))
1500 {
1501 m_rect = wxRect(x, y, width, height);
1502 DoSizing();
1503 }
1504
1505 void DoGetClientSize(int* x, int* y) const
1506 {
1507 *x = m_rect.width;
1508 *y = m_rect.height;
1509 }
1510
1511 public:
1512 bool Show( bool WXUNUSED(show = true) ) { return false; }
1513
1514 void DoSizing()
1515 {
1516 if (!m_tabs)
1517 return;
1518
1519 if (m_tabs->IsFrozen() || m_tabs->GetParent()->IsFrozen())
1520 return;
1521
1522 m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
1523 if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
1524 {
1525 m_tab_rect = wxRect (m_rect.x, m_rect.y + m_rect.height - m_tabCtrlHeight, m_rect.width, m_tabCtrlHeight);
1526 m_tabs->SetSize (m_rect.x, m_rect.y + m_rect.height - m_tabCtrlHeight, m_rect.width, m_tabCtrlHeight);
1527 m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tabCtrlHeight));
1528 }
1529 else //TODO: if (GetFlags() & wxAUI_NB_TOP)
1530 {
1531 m_tab_rect = wxRect (m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
1532 m_tabs->SetSize (m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
1533 m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tabCtrlHeight));
1534 }
1535 // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
1536 // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
1537
1538 m_tabs->Refresh();
1539 m_tabs->Update();
1540
1541 wxAuiNotebookPageArray& pages = m_tabs->GetPages();
1542 size_t i, page_count = pages.GetCount();
1543
1544 for (i = 0; i < page_count; ++i)
1545 {
1546 int height = m_rect.height - m_tabCtrlHeight;
1547 if ( height < 0 )
1548 {
1549 // avoid passing negative height to wxWindow::SetSize(), this
1550 // results in assert failures/GTK+ warnings
1551 height = 0;
1552 }
1553
1554 wxAuiNotebookPage& page = pages.Item(i);
1555 if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
1556 {
1557 page.window->SetSize(m_rect.x, m_rect.y, m_rect.width, height);
1558 }
1559 else //TODO: if (GetFlags() & wxAUI_NB_TOP)
1560 {
1561 page.window->SetSize(m_rect.x, m_rect.y + m_tabCtrlHeight,
1562 m_rect.width, height);
1563 }
1564 // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
1565 // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
1566
1567 #if wxUSE_MDI
1568 if (wxDynamicCast(page.window, wxAuiMDIChildFrame))
1569 {
1570 wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
1571 wnd->ApplyMDIChildFrameRect();
1572 }
1573 #endif
1574 }
1575 }
1576
1577 protected:
1578 void DoGetSize(int* x, int* y) const
1579 {
1580 if (x)
1581 *x = m_rect.GetWidth();
1582 if (y)
1583 *y = m_rect.GetHeight();
1584 }
1585
1586 public:
1587 void Update()
1588 {
1589 // does nothing
1590 }
1591
1592 wxRect m_rect;
1593 wxRect m_tab_rect;
1594 wxAuiTabCtrl* m_tabs;
1595 int m_tabCtrlHeight;
1596 };
1597
1598
1599 const int wxAuiBaseTabCtrlId = 5380;
1600
1601
1602 // -- wxAuiNotebook class implementation --
1603
1604 #define EVT_AUI_RANGE(id1, id2, event, func) \
1605 wx__DECLARE_EVT2(event, id1, id2, wxAuiNotebookEventHandler(func))
1606
1607 BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
1608 EVT_SIZE(wxAuiNotebook::OnSize)
1609 EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocusNotebook)
1610 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1611 wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
1612 wxAuiNotebook::OnTabClicked)
1613 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1614 wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
1615 wxAuiNotebook::OnTabBeginDrag)
1616 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1617 wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
1618 wxAuiNotebook::OnTabEndDrag)
1619 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1620 wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG,
1621 wxAuiNotebook::OnTabCancelDrag)
1622 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1623 wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
1624 wxAuiNotebook::OnTabDragMotion)
1625 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1626 wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
1627 wxAuiNotebook::OnTabButton)
1628 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1629 wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN,
1630 wxAuiNotebook::OnTabMiddleDown)
1631 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1632 wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP,
1633 wxAuiNotebook::OnTabMiddleUp)
1634 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1635 wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN,
1636 wxAuiNotebook::OnTabRightDown)
1637 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1638 wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP,
1639 wxAuiNotebook::OnTabRightUp)
1640 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1641 wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK,
1642 wxAuiNotebook::OnTabBgDClick)
1643 EVT_NAVIGATION_KEY(wxAuiNotebook::OnNavigationKeyNotebook)
1644 END_EVENT_TABLE()
1645
1646 void wxAuiNotebook::Init()
1647 {
1648 m_curPage = -1;
1649 m_tabIdCounter = wxAuiBaseTabCtrlId;
1650 m_dummyWnd = NULL;
1651 m_tabCtrlHeight = 20;
1652 m_requestedBmpSize = wxDefaultSize;
1653 m_requestedTabCtrlHeight = -1;
1654 }
1655
1656 bool wxAuiNotebook::Create(wxWindow* parent,
1657 wxWindowID id,
1658 const wxPoint& pos,
1659 const wxSize& size,
1660 long style)
1661 {
1662 if (!wxControl::Create(parent, id, pos, size, style))
1663 return false;
1664
1665 InitNotebook(style);
1666
1667 return true;
1668 }
1669
1670 // InitNotebook() contains common initialization
1671 // code called by all constructors
1672 void wxAuiNotebook::InitNotebook(long style)
1673 {
1674 SetName(wxT("wxAuiNotebook"));
1675 m_curPage = -1;
1676 m_tabIdCounter = wxAuiBaseTabCtrlId;
1677 m_dummyWnd = NULL;
1678 m_flags = (unsigned int)style;
1679 m_tabCtrlHeight = 20;
1680
1681 m_normalFont = *wxNORMAL_FONT;
1682 m_selectedFont = *wxNORMAL_FONT;
1683 m_selectedFont.SetWeight(wxBOLD);
1684
1685 SetArtProvider(new wxAuiDefaultTabArt);
1686
1687 m_dummyWnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
1688 m_dummyWnd->SetSize(200, 200);
1689 m_dummyWnd->Show(false);
1690
1691 m_mgr.SetManagedWindow(this);
1692 m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
1693 m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint
1694
1695 m_mgr.AddPane(m_dummyWnd,
1696 wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
1697
1698 m_mgr.Update();
1699 }
1700
1701 wxAuiNotebook::~wxAuiNotebook()
1702 {
1703 // Indicate we're deleting pages
1704 SendDestroyEvent();
1705
1706 while ( GetPageCount() > 0 )
1707 DeletePage(0);
1708
1709 m_mgr.UnInit();
1710 }
1711
1712 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
1713 {
1714 m_tabs.SetArtProvider(art);
1715
1716 // Update the height and do nothing else if it did something but otherwise
1717 // (i.e. if the new art provider uses the same height as the old one) we
1718 // need to manually set the art provider for all tabs ourselves.
1719 if ( !UpdateTabCtrlHeight() )
1720 {
1721 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
1722 const size_t pane_count = all_panes.GetCount();
1723 for (size_t i = 0; i < pane_count; ++i)
1724 {
1725 wxAuiPaneInfo& pane = all_panes.Item(i);
1726 if (pane.name == wxT("dummy"))
1727 continue;
1728 wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
1729 wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
1730 tabctrl->SetArtProvider(art->Clone());
1731 }
1732 }
1733 }
1734
1735 // SetTabCtrlHeight() is the highest-level override of the
1736 // tab height. A call to this function effectively enforces a
1737 // specified tab ctrl height, overriding all other considerations,
1738 // such as text or bitmap height. It overrides any call to
1739 // SetUniformBitmapSize(). Specifying a height of -1 reverts
1740 // any previous call and returns to the default behaviour
1741
1742 void wxAuiNotebook::SetTabCtrlHeight(int height)
1743 {
1744 m_requestedTabCtrlHeight = height;
1745
1746 // if window is already initialized, recalculate the tab height
1747 if (m_dummyWnd)
1748 {
1749 UpdateTabCtrlHeight();
1750 }
1751 }
1752
1753
1754 // SetUniformBitmapSize() ensures that all tabs will have
1755 // the same height, even if some tabs don't have bitmaps
1756 // Passing wxDefaultSize to this function will instruct
1757 // the control to use dynamic tab height-- so when a tab
1758 // with a large bitmap is added, the tab ctrl's height will
1759 // automatically increase to accommodate the bitmap
1760
1761 void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
1762 {
1763 m_requestedBmpSize = size;
1764
1765 // if window is already initialized, recalculate the tab height
1766 if (m_dummyWnd)
1767 {
1768 UpdateTabCtrlHeight();
1769 }
1770 }
1771
1772 // UpdateTabCtrlHeight() does the actual tab resizing. It's meant
1773 // to be used internally
1774 bool wxAuiNotebook::UpdateTabCtrlHeight()
1775 {
1776 // get the tab ctrl height we will use
1777 int height = CalculateTabCtrlHeight();
1778
1779 // if the tab control height needs to change, update
1780 // all of our tab controls with the new height
1781 if (m_tabCtrlHeight == height)
1782 return false;
1783
1784 wxAuiTabArt* art = m_tabs.GetArtProvider();
1785
1786 m_tabCtrlHeight = height;
1787
1788 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
1789 size_t i, pane_count = all_panes.GetCount();
1790 for (i = 0; i < pane_count; ++i)
1791 {
1792 wxAuiPaneInfo& pane = all_panes.Item(i);
1793 if (pane.name == wxT("dummy"))
1794 continue;
1795 wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
1796 wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
1797 tab_frame->SetTabCtrlHeight(m_tabCtrlHeight);
1798 tabctrl->SetArtProvider(art->Clone());
1799 tab_frame->DoSizing();
1800 }
1801
1802 return true;
1803 }
1804
1805 void wxAuiNotebook::UpdateHintWindowSize()
1806 {
1807 wxSize size = CalculateNewSplitSize();
1808
1809 // the placeholder hint window should be set to this size
1810 wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
1811 if (info.IsOk())
1812 {
1813 info.MinSize(size);
1814 info.BestSize(size);
1815 m_dummyWnd->SetSize(size);
1816 }
1817 }
1818
1819
1820 // calculates the size of the new split
1821 wxSize wxAuiNotebook::CalculateNewSplitSize()
1822 {
1823 // count number of tab controls
1824 int tab_ctrl_count = 0;
1825 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
1826 size_t i, pane_count = all_panes.GetCount();
1827 for (i = 0; i < pane_count; ++i)
1828 {
1829 wxAuiPaneInfo& pane = all_panes.Item(i);
1830 if (pane.name == wxT("dummy"))
1831 continue;
1832 tab_ctrl_count++;
1833 }
1834
1835 wxSize new_split_size;
1836
1837 // if there is only one tab control, the first split
1838 // should happen around the middle
1839 if (tab_ctrl_count < 2)
1840 {
1841 new_split_size = GetClientSize();
1842 new_split_size.x /= 2;
1843 new_split_size.y /= 2;
1844 }
1845 else
1846 {
1847 // this is in place of a more complicated calculation
1848 // that needs to be implemented
1849 new_split_size = wxSize(180,180);
1850 }
1851
1852 return new_split_size;
1853 }
1854
1855 int wxAuiNotebook::CalculateTabCtrlHeight()
1856 {
1857 // if a fixed tab ctrl height is specified,
1858 // just return that instead of calculating a
1859 // tab height
1860 if (m_requestedTabCtrlHeight != -1)
1861 return m_requestedTabCtrlHeight;
1862
1863 // find out new best tab height
1864 wxAuiTabArt* art = m_tabs.GetArtProvider();
1865
1866 return art->GetBestTabCtrlSize(this,
1867 m_tabs.GetPages(),
1868 m_requestedBmpSize);
1869 }
1870
1871
1872 wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
1873 {
1874 return m_tabs.GetArtProvider();
1875 }
1876
1877 void wxAuiNotebook::SetWindowStyleFlag(long style)
1878 {
1879 wxControl::SetWindowStyleFlag(style);
1880
1881 m_flags = (unsigned int)style;
1882
1883 // if the control is already initialized
1884 if (m_mgr.GetManagedWindow() == (wxWindow*)this)
1885 {
1886 // let all of the tab children know about the new style
1887
1888 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
1889 size_t i, pane_count = all_panes.GetCount();
1890 for (i = 0; i < pane_count; ++i)
1891 {
1892 wxAuiPaneInfo& pane = all_panes.Item(i);
1893 if (pane.name == wxT("dummy"))
1894 continue;
1895 wxTabFrame* tabframe = (wxTabFrame*)pane.window;
1896 wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
1897 tabctrl->SetFlags(m_flags);
1898 tabframe->DoSizing();
1899 tabctrl->Refresh();
1900 tabctrl->Update();
1901 }
1902 }
1903 }
1904
1905
1906 bool wxAuiNotebook::AddPage(wxWindow* page,
1907 const wxString& caption,
1908 bool select,
1909 const wxBitmap& bitmap)
1910 {
1911 return InsertPage(GetPageCount(), page, caption, select, bitmap);
1912 }
1913
1914 bool wxAuiNotebook::InsertPage(size_t page_idx,
1915 wxWindow* page,
1916 const wxString& caption,
1917 bool select,
1918 const wxBitmap& bitmap)
1919 {
1920 wxASSERT_MSG(page, wxT("page pointer must be non-NULL"));
1921 if (!page)
1922 return false;
1923
1924 page->Reparent(this);
1925
1926 wxAuiNotebookPage info;
1927 info.window = page;
1928 info.caption = caption;
1929 info.bitmap = bitmap;
1930 info.active = false;
1931
1932 // if there are currently no tabs, the first added
1933 // tab must be active
1934 if (m_tabs.GetPageCount() == 0)
1935 info.active = true;
1936
1937 m_tabs.InsertPage(page, info, page_idx);
1938
1939 // if that was the first page added, even if
1940 // select is false, it must become the "current page"
1941 // (though no select events will be fired)
1942 if (!select && m_tabs.GetPageCount() == 1)
1943 select = true;
1944 //m_curPage = GetPageIndex(page);
1945
1946 wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
1947 if (page_idx >= active_tabctrl->GetPageCount())
1948 active_tabctrl->AddPage(page, info);
1949 else
1950 active_tabctrl->InsertPage(page, info, page_idx);
1951
1952 UpdateTabCtrlHeight();
1953 DoSizing();
1954 active_tabctrl->DoShowHide();
1955
1956 // adjust selected index
1957 if(m_curPage >= (int) page_idx)
1958 m_curPage++;
1959
1960 if (select)
1961 {
1962 SetSelectionToWindow(page);
1963 }
1964
1965 return true;
1966 }
1967
1968
1969 // DeletePage() removes a tab from the multi-notebook,
1970 // and destroys the window as well
1971 bool wxAuiNotebook::DeletePage(size_t page_idx)
1972 {
1973 if (page_idx >= m_tabs.GetPageCount())
1974 return false;
1975
1976 wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
1977
1978 // hide the window in advance, as this will
1979 // prevent flicker
1980 ShowWnd(wnd, false);
1981
1982 if (!RemovePage(page_idx))
1983 return false;
1984
1985 #if wxUSE_MDI
1986 // actually destroy the window now
1987 if (wxDynamicCast(wnd, wxAuiMDIChildFrame))
1988 {
1989 // delete the child frame with pending delete, as is
1990 // customary with frame windows
1991 if (!wxPendingDelete.Member(wnd))
1992 wxPendingDelete.Append(wnd);
1993 }
1994 else
1995 #endif
1996 {
1997 wnd->Destroy();
1998 }
1999
2000 return true;
2001 }
2002
2003
2004
2005 // RemovePage() removes a tab from the multi-notebook,
2006 // but does not destroy the window
2007 bool wxAuiNotebook::RemovePage(size_t page_idx)
2008 {
2009 // save active window pointer
2010 wxWindow* active_wnd = NULL;
2011 if (m_curPage >= 0)
2012 active_wnd = m_tabs.GetWindowFromIdx(m_curPage);
2013
2014 // save pointer of window being deleted
2015 wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
2016 wxWindow* new_active = NULL;
2017
2018 // make sure we found the page
2019 if (!wnd)
2020 return false;
2021
2022 // find out which onscreen tab ctrl owns this tab
2023 wxAuiTabCtrl* ctrl;
2024 int ctrl_idx;
2025 if (!FindTab(wnd, &ctrl, &ctrl_idx))
2026 return false;
2027
2028 bool is_curpage = (m_curPage == (int)page_idx);
2029 bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
2030
2031
2032 // remove the tab from main catalog
2033 if (!m_tabs.RemovePage(wnd))
2034 return false;
2035
2036 // remove the tab from the onscreen tab ctrl
2037 ctrl->RemovePage(wnd);
2038
2039 if (is_active_in_split)
2040 {
2041 int ctrl_new_page_count = (int)ctrl->GetPageCount();
2042
2043 if (ctrl_idx >= ctrl_new_page_count)
2044 ctrl_idx = ctrl_new_page_count-1;
2045
2046 if (ctrl_idx >= 0 && ctrl_idx < (int)ctrl->GetPageCount())
2047 {
2048 // set new page as active in the tab split
2049 ctrl->SetActivePage(ctrl_idx);
2050
2051 // if the page deleted was the current page for the
2052 // entire tab control, then record the window
2053 // pointer of the new active page for activation
2054 if (is_curpage)
2055 {
2056 new_active = ctrl->GetWindowFromIdx(ctrl_idx);
2057 }
2058 }
2059 }
2060 else
2061 {
2062 // we are not deleting the active page, so keep it the same
2063 new_active = active_wnd;
2064 }
2065
2066
2067 if (!new_active)
2068 {
2069 // we haven't yet found a new page to active,
2070 // so select the next page from the main tab
2071 // catalogue
2072
2073 if (page_idx < m_tabs.GetPageCount())
2074 {
2075 new_active = m_tabs.GetPage(page_idx).window;
2076 }
2077
2078 if (!new_active && m_tabs.GetPageCount() > 0)
2079 {
2080 new_active = m_tabs.GetPage(0).window;
2081 }
2082 }
2083
2084
2085 RemoveEmptyTabFrames();
2086
2087 m_curPage = wxNOT_FOUND;
2088
2089 // set new active pane unless we're being destroyed anyhow
2090 if (new_active && !m_isBeingDeleted)
2091 SetSelectionToWindow(new_active);
2092
2093 return true;
2094 }
2095
2096 // GetPageIndex() returns the index of the page, or -1 if the
2097 // page could not be located in the notebook
2098 int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
2099 {
2100 return m_tabs.GetIdxFromWindow(page_wnd);
2101 }
2102
2103
2104
2105 // SetPageText() changes the tab caption of the specified page
2106 bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
2107 {
2108 if (page_idx >= m_tabs.GetPageCount())
2109 return false;
2110
2111 // update our own tab catalog
2112 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2113 page_info.caption = text;
2114
2115 // update what's on screen
2116 wxAuiTabCtrl* ctrl;
2117 int ctrl_idx;
2118 if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2119 {
2120 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2121 info.caption = text;
2122 ctrl->Refresh();
2123 ctrl->Update();
2124 }
2125
2126 return true;
2127 }
2128
2129 // returns the page caption
2130 wxString wxAuiNotebook::GetPageText(size_t page_idx) const
2131 {
2132 if (page_idx >= m_tabs.GetPageCount())
2133 return wxEmptyString;
2134
2135 // update our own tab catalog
2136 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2137 return page_info.caption;
2138 }
2139
2140 bool wxAuiNotebook::SetPageToolTip(size_t page_idx, const wxString& text)
2141 {
2142 if (page_idx >= m_tabs.GetPageCount())
2143 return false;
2144
2145 // update our own tab catalog
2146 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2147 page_info.tooltip = text;
2148
2149 wxAuiTabCtrl* ctrl;
2150 int ctrl_idx;
2151 if (!FindTab(page_info.window, &ctrl, &ctrl_idx))
2152 return false;
2153
2154 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2155 info.tooltip = text;
2156
2157 // NB: we don't update the tooltip if it is already being displayed, it
2158 // typically never happens, no need to code that
2159 return true;
2160 }
2161
2162 wxString wxAuiNotebook::GetPageToolTip(size_t page_idx) const
2163 {
2164 if (page_idx >= m_tabs.GetPageCount())
2165 return wxString();
2166
2167 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2168 return page_info.tooltip;
2169 }
2170
2171 bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
2172 {
2173 if (page_idx >= m_tabs.GetPageCount())
2174 return false;
2175
2176 // update our own tab catalog
2177 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2178 page_info.bitmap = bitmap;
2179
2180 // tab height might have changed
2181 UpdateTabCtrlHeight();
2182
2183 // update what's on screen
2184 wxAuiTabCtrl* ctrl;
2185 int ctrl_idx;
2186 if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2187 {
2188 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2189 info.bitmap = bitmap;
2190 ctrl->Refresh();
2191 ctrl->Update();
2192 }
2193
2194 return true;
2195 }
2196
2197 // returns the page bitmap
2198 wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
2199 {
2200 if (page_idx >= m_tabs.GetPageCount())
2201 return wxBitmap();
2202
2203 // update our own tab catalog
2204 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2205 return page_info.bitmap;
2206 }
2207
2208 // GetSelection() returns the index of the currently active page
2209 int wxAuiNotebook::GetSelection() const
2210 {
2211 return m_curPage;
2212 }
2213
2214 // SetSelection() sets the currently active page
2215 int wxAuiNotebook::SetSelection(size_t new_page)
2216 {
2217 return DoModifySelection(new_page, true);
2218 }
2219
2220 void wxAuiNotebook::SetSelectionToWindow(wxWindow *win)
2221 {
2222 const int idx = m_tabs.GetIdxFromWindow(win);
2223 wxCHECK_RET( idx != wxNOT_FOUND, wxT("invalid notebook page") );
2224
2225
2226 // since a tab was clicked, let the parent know that we received
2227 // the focus, even if we will assign that focus immediately
2228 // to the child tab in the SetSelection call below
2229 // (the child focus event will also let wxAuiManager, if any,
2230 // know that the notebook control has been activated)
2231
2232 wxWindow* parent = GetParent();
2233 if (parent)
2234 {
2235 wxChildFocusEvent eventFocus(this);
2236 parent->GetEventHandler()->ProcessEvent(eventFocus);
2237 }
2238
2239
2240 SetSelection(idx);
2241 }
2242
2243 // GetPageCount() returns the total number of
2244 // pages managed by the multi-notebook
2245 size_t wxAuiNotebook::GetPageCount() const
2246 {
2247 return m_tabs.GetPageCount();
2248 }
2249
2250 // GetPage() returns the wxWindow pointer of the
2251 // specified page
2252 wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
2253 {
2254 wxASSERT(page_idx < m_tabs.GetPageCount());
2255
2256 return m_tabs.GetWindowFromIdx(page_idx);
2257 }
2258
2259 // DoSizing() performs all sizing operations in each tab control
2260 void wxAuiNotebook::DoSizing()
2261 {
2262 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2263 size_t i, pane_count = all_panes.GetCount();
2264 for (i = 0; i < pane_count; ++i)
2265 {
2266 if (all_panes.Item(i).name == wxT("dummy"))
2267 continue;
2268
2269 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2270 tabframe->DoSizing();
2271 }
2272 }
2273
2274 // GetActiveTabCtrl() returns the active tab control. It is
2275 // called to determine which control gets new windows being added
2276 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
2277 {
2278 if (m_curPage >= 0 && m_curPage < (int)m_tabs.GetPageCount())
2279 {
2280 wxAuiTabCtrl* ctrl;
2281 int idx;
2282
2283 // find the tab ctrl with the current page
2284 if (FindTab(m_tabs.GetPage(m_curPage).window,
2285 &ctrl, &idx))
2286 {
2287 return ctrl;
2288 }
2289 }
2290
2291 // no current page, just find the first tab ctrl
2292 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2293 size_t i, pane_count = all_panes.GetCount();
2294 for (i = 0; i < pane_count; ++i)
2295 {
2296 if (all_panes.Item(i).name == wxT("dummy"))
2297 continue;
2298
2299 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2300 return tabframe->m_tabs;
2301 }
2302
2303 // If there is no tabframe at all, create one
2304 wxTabFrame* tabframe = new wxTabFrame;
2305 tabframe->SetTabCtrlHeight(m_tabCtrlHeight);
2306 tabframe->m_tabs = new wxAuiTabCtrl(this,
2307 m_tabIdCounter++,
2308 wxDefaultPosition,
2309 wxDefaultSize,
2310 wxNO_BORDER|wxWANTS_CHARS);
2311 tabframe->m_tabs->SetFlags(m_flags);
2312 tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2313 m_mgr.AddPane(tabframe,
2314 wxAuiPaneInfo().Center().CaptionVisible(false));
2315
2316 m_mgr.Update();
2317
2318 return tabframe->m_tabs;
2319 }
2320
2321 // FindTab() finds the tab control that currently contains the window as well
2322 // as the index of the window in the tab control. It returns true if the
2323 // window was found, otherwise false.
2324 bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
2325 {
2326 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2327 size_t i, pane_count = all_panes.GetCount();
2328 for (i = 0; i < pane_count; ++i)
2329 {
2330 if (all_panes.Item(i).name == wxT("dummy"))
2331 continue;
2332
2333 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2334
2335 int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
2336 if (page_idx != -1)
2337 {
2338 *ctrl = tabframe->m_tabs;
2339 *idx = page_idx;
2340 return true;
2341 }
2342 }
2343
2344 return false;
2345 }
2346
2347 void wxAuiNotebook::Split(size_t page, int direction)
2348 {
2349 wxSize cli_size = GetClientSize();
2350
2351 // get the page's window pointer
2352 wxWindow* wnd = GetPage(page);
2353 if (!wnd)
2354 return;
2355
2356 // notebooks with 1 or less pages can't be split
2357 if (GetPageCount() < 2)
2358 return;
2359
2360 // find out which tab control the page currently belongs to
2361 wxAuiTabCtrl *src_tabs, *dest_tabs;
2362 int src_idx = -1;
2363 src_tabs = NULL;
2364 if (!FindTab(wnd, &src_tabs, &src_idx))
2365 return;
2366 if (!src_tabs || src_idx == -1)
2367 return;
2368
2369 // choose a split size
2370 wxSize split_size;
2371 if (GetPageCount() > 2)
2372 {
2373 split_size = CalculateNewSplitSize();
2374 }
2375 else
2376 {
2377 // because there are two panes, always split them
2378 // equally
2379 split_size = GetClientSize();
2380 split_size.x /= 2;
2381 split_size.y /= 2;
2382 }
2383
2384
2385 // create a new tab frame
2386 wxTabFrame* new_tabs = new wxTabFrame;
2387 new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
2388 new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);
2389 new_tabs->m_tabs = new wxAuiTabCtrl(this,
2390 m_tabIdCounter++,
2391 wxDefaultPosition,
2392 wxDefaultSize,
2393 wxNO_BORDER|wxWANTS_CHARS);
2394 new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2395 new_tabs->m_tabs->SetFlags(m_flags);
2396 dest_tabs = new_tabs->m_tabs;
2397
2398 // create a pane info structure with the information
2399 // about where the pane should be added
2400 wxAuiPaneInfo paneInfo = wxAuiPaneInfo().Bottom().CaptionVisible(false);
2401 wxPoint mouse_pt;
2402
2403 if (direction == wxLEFT)
2404 {
2405 paneInfo.Left();
2406 mouse_pt = wxPoint(0, cli_size.y/2);
2407 }
2408 else if (direction == wxRIGHT)
2409 {
2410 paneInfo.Right();
2411 mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
2412 }
2413 else if (direction == wxTOP)
2414 {
2415 paneInfo.Top();
2416 mouse_pt = wxPoint(cli_size.x/2, 0);
2417 }
2418 else if (direction == wxBOTTOM)
2419 {
2420 paneInfo.Bottom();
2421 mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
2422 }
2423
2424 m_mgr.AddPane(new_tabs, paneInfo, mouse_pt);
2425 m_mgr.Update();
2426
2427 // remove the page from the source tabs
2428 wxAuiNotebookPage page_info = src_tabs->GetPage(src_idx);
2429 page_info.active = false;
2430 src_tabs->RemovePage(page_info.window);
2431 if (src_tabs->GetPageCount() > 0)
2432 {
2433 src_tabs->SetActivePage((size_t)0);
2434 src_tabs->DoShowHide();
2435 src_tabs->Refresh();
2436 }
2437
2438
2439 // add the page to the destination tabs
2440 dest_tabs->InsertPage(page_info.window, page_info, 0);
2441
2442 if (src_tabs->GetPageCount() == 0)
2443 {
2444 RemoveEmptyTabFrames();
2445 }
2446
2447 DoSizing();
2448 dest_tabs->DoShowHide();
2449 dest_tabs->Refresh();
2450
2451 // force the set selection function reset the selection
2452 m_curPage = -1;
2453
2454 // set the active page to the one we just split off
2455 SetSelectionToPage(page_info);
2456
2457 UpdateHintWindowSize();
2458 }
2459
2460
2461 void wxAuiNotebook::OnSize(wxSizeEvent& evt)
2462 {
2463 UpdateHintWindowSize();
2464
2465 evt.Skip();
2466 }
2467
2468 void wxAuiNotebook::OnTabClicked(wxAuiNotebookEvent& evt)
2469 {
2470 wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
2471 wxASSERT(ctrl != NULL);
2472
2473 wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
2474 wxASSERT(wnd != NULL);
2475
2476 SetSelectionToWindow(wnd);
2477 }
2478
2479 void wxAuiNotebook::OnTabBgDClick(wxAuiNotebookEvent& WXUNUSED(evt))
2480 {
2481 // notify owner that the tabbar background has been double-clicked
2482 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
2483 e.SetEventObject(this);
2484 GetEventHandler()->ProcessEvent(e);
2485 }
2486
2487 void wxAuiNotebook::OnTabBeginDrag(wxAuiNotebookEvent&)
2488 {
2489 m_lastDragX = 0;
2490 }
2491
2492 void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)
2493 {
2494 wxPoint screen_pt = ::wxGetMousePosition();
2495 wxPoint client_pt = ScreenToClient(screen_pt);
2496 wxPoint zero(0,0);
2497
2498 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
2499 wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
2500
2501 if (dest_tabs == src_tabs)
2502 {
2503 if (src_tabs)
2504 {
2505 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
2506 }
2507
2508 // always hide the hint for inner-tabctrl drag
2509 m_mgr.HideHint();
2510
2511 // if tab moving is not allowed, leave
2512 if (!(m_flags & wxAUI_NB_TAB_MOVE))
2513 {
2514 return;
2515 }
2516
2517 wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
2518 wxWindow* dest_location_tab;
2519
2520 // this is an inner-tab drag/reposition
2521 if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
2522 {
2523 int src_idx = evt.GetSelection();
2524 int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
2525
2526 // prevent jumpy drag
2527 if ((src_idx == dest_idx) || dest_idx == -1 ||
2528 (src_idx > dest_idx && m_lastDragX <= pt.x) ||
2529 (src_idx < dest_idx && m_lastDragX >= pt.x))
2530 {
2531 m_lastDragX = pt.x;
2532 return;
2533 }
2534
2535
2536 wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
2537 dest_tabs->MovePage(src_tab, dest_idx);
2538 dest_tabs->SetActivePage((size_t)dest_idx);
2539 dest_tabs->DoShowHide();
2540 dest_tabs->Refresh();
2541 m_lastDragX = pt.x;
2542
2543 }
2544
2545 return;
2546 }
2547
2548
2549 // if external drag is allowed, check if the tab is being dragged
2550 // over a different wxAuiNotebook control
2551 if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
2552 {
2553 wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
2554
2555 // if we aren't over any window, stop here
2556 if (!tab_ctrl)
2557 return;
2558
2559 // make sure we are not over the hint window
2560 if (!wxDynamicCast(tab_ctrl, wxFrame))
2561 {
2562 while (tab_ctrl)
2563 {
2564 if (wxDynamicCast(tab_ctrl, wxAuiTabCtrl))
2565 break;
2566 tab_ctrl = tab_ctrl->GetParent();
2567 }
2568
2569 if (tab_ctrl)
2570 {
2571 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
2572
2573 if (nb != this)
2574 {
2575 wxRect hint_rect = tab_ctrl->GetClientRect();
2576 tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
2577 m_mgr.ShowHint(hint_rect);
2578 return;
2579 }
2580 }
2581 }
2582 else
2583 {
2584 if (!dest_tabs)
2585 {
2586 // we are either over a hint window, or not over a tab
2587 // window, and there is no where to drag to, so exit
2588 return;
2589 }
2590 }
2591 }
2592
2593
2594 // if there are less than two panes, split can't happen, so leave
2595 if (m_tabs.GetPageCount() < 2)
2596 return;
2597
2598 // if tab moving is not allowed, leave
2599 if (!(m_flags & wxAUI_NB_TAB_SPLIT))
2600 return;
2601
2602
2603 if (src_tabs)
2604 {
2605 src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
2606 }
2607
2608
2609 if (dest_tabs)
2610 {
2611 wxRect hint_rect = dest_tabs->GetRect();
2612 ClientToScreen(&hint_rect.x, &hint_rect.y);
2613 m_mgr.ShowHint(hint_rect);
2614 }
2615 else
2616 {
2617 m_mgr.DrawHintRect(m_dummyWnd, client_pt, zero);
2618 }
2619 }
2620
2621
2622
2623 void wxAuiNotebook::OnTabEndDrag(wxAuiNotebookEvent& evt)
2624 {
2625 m_mgr.HideHint();
2626
2627
2628 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
2629 wxCHECK_RET( src_tabs, wxT("no source object?") );
2630
2631 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
2632
2633 // get the mouse position, which will be used to determine the drop point
2634 wxPoint mouse_screen_pt = ::wxGetMousePosition();
2635 wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
2636
2637
2638
2639 // check for an external move
2640 if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
2641 {
2642 wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
2643
2644 while (tab_ctrl)
2645 {
2646 if (wxDynamicCast(tab_ctrl, wxAuiTabCtrl))
2647 break;
2648 tab_ctrl = tab_ctrl->GetParent();
2649 }
2650
2651 if (tab_ctrl)
2652 {
2653 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
2654
2655 if (nb != this)
2656 {
2657 // find out from the destination control
2658 // if it's ok to drop this tab here
2659 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
2660 e.SetSelection(evt.GetSelection());
2661 e.SetOldSelection(evt.GetSelection());
2662 e.SetEventObject(this);
2663 e.SetDragSource(this);
2664 e.Veto(); // dropping must be explicitly approved by control owner
2665
2666 nb->GetEventHandler()->ProcessEvent(e);
2667
2668 if (!e.IsAllowed())
2669 {
2670 // no answer or negative answer
2671 m_mgr.HideHint();
2672 return;
2673 }
2674
2675 // drop was allowed
2676 int src_idx = evt.GetSelection();
2677 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
2678
2679 // Check that it's not an impossible parent relationship
2680 wxWindow* p = nb;
2681 while (p && !p->IsTopLevel())
2682 {
2683 if (p == src_page)
2684 {
2685 return;
2686 }
2687 p = p->GetParent();
2688 }
2689
2690 // get main index of the page
2691 int main_idx = m_tabs.GetIdxFromWindow(src_page);
2692 wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no source page?") );
2693
2694
2695 // make a copy of the page info
2696 wxAuiNotebookPage page_info = m_tabs.GetPage(main_idx);
2697
2698 // remove the page from the source notebook
2699 RemovePage(main_idx);
2700
2701 // reparent the page
2702 src_page->Reparent(nb);
2703
2704
2705 // found out the insert idx
2706 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
2707 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
2708
2709 wxWindow* target = NULL;
2710 int insert_idx = -1;
2711 dest_tabs->TabHitTest(pt.x, pt.y, &target);
2712 if (target)
2713 {
2714 insert_idx = dest_tabs->GetIdxFromWindow(target);
2715 }
2716
2717
2718 // add the page to the new notebook
2719 if (insert_idx == -1)
2720 insert_idx = dest_tabs->GetPageCount();
2721 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
2722 nb->m_tabs.AddPage(page_info.window, page_info);
2723
2724 nb->DoSizing();
2725 dest_tabs->DoShowHide();
2726 dest_tabs->Refresh();
2727
2728 // set the selection in the destination tab control
2729 nb->SetSelectionToPage(page_info);
2730
2731 // notify owner that the tab has been dragged
2732 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
2733 e2.SetSelection(evt.GetSelection());
2734 e2.SetOldSelection(evt.GetSelection());
2735 e2.SetEventObject(this);
2736 GetEventHandler()->ProcessEvent(e2);
2737
2738 return;
2739 }
2740 }
2741 }
2742
2743
2744
2745
2746 // only perform a tab split if it's allowed
2747 wxAuiTabCtrl* dest_tabs = NULL;
2748
2749 if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
2750 {
2751 // If the pointer is in an existing tab frame, do a tab insert
2752 wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
2753 wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
2754 int insert_idx = -1;
2755 if (tab_frame)
2756 {
2757 dest_tabs = tab_frame->m_tabs;
2758
2759 if (dest_tabs == src_tabs)
2760 return;
2761
2762
2763 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
2764 wxWindow* target = NULL;
2765 dest_tabs->TabHitTest(pt.x, pt.y, &target);
2766 if (target)
2767 {
2768 insert_idx = dest_tabs->GetIdxFromWindow(target);
2769 }
2770 }
2771 else
2772 {
2773 wxPoint zero(0,0);
2774 wxRect rect = m_mgr.CalculateHintRect(m_dummyWnd,
2775 mouse_client_pt,
2776 zero);
2777 if (rect.IsEmpty())
2778 {
2779 // there is no suitable drop location here, exit out
2780 return;
2781 }
2782
2783 // If there is no tabframe at all, create one
2784 wxTabFrame* new_tabs = new wxTabFrame;
2785 new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
2786 new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);
2787 new_tabs->m_tabs = new wxAuiTabCtrl(this,
2788 m_tabIdCounter++,
2789 wxDefaultPosition,
2790 wxDefaultSize,
2791 wxNO_BORDER|wxWANTS_CHARS);
2792 new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2793 new_tabs->m_tabs->SetFlags(m_flags);
2794
2795 m_mgr.AddPane(new_tabs,
2796 wxAuiPaneInfo().Bottom().CaptionVisible(false),
2797 mouse_client_pt);
2798 m_mgr.Update();
2799 dest_tabs = new_tabs->m_tabs;
2800 }
2801
2802
2803
2804 // remove the page from the source tabs
2805 wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
2806 page_info.active = false;
2807 src_tabs->RemovePage(page_info.window);
2808 if (src_tabs->GetPageCount() > 0)
2809 {
2810 src_tabs->SetActivePage((size_t)0);
2811 src_tabs->DoShowHide();
2812 src_tabs->Refresh();
2813 }
2814
2815
2816
2817 // add the page to the destination tabs
2818 if (insert_idx == -1)
2819 insert_idx = dest_tabs->GetPageCount();
2820 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
2821
2822 if (src_tabs->GetPageCount() == 0)
2823 {
2824 RemoveEmptyTabFrames();
2825 }
2826
2827 DoSizing();
2828 dest_tabs->DoShowHide();
2829 dest_tabs->Refresh();
2830
2831 // force the set selection function reset the selection
2832 m_curPage = -1;
2833
2834 // set the active page to the one we just split off
2835 SetSelectionToPage(page_info);
2836
2837 UpdateHintWindowSize();
2838 }
2839
2840 // notify owner that the tab has been dragged
2841 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
2842 e.SetSelection(evt.GetSelection());
2843 e.SetOldSelection(evt.GetSelection());
2844 e.SetEventObject(this);
2845 GetEventHandler()->ProcessEvent(e);
2846 }
2847
2848
2849
2850 void wxAuiNotebook::OnTabCancelDrag(wxAuiNotebookEvent& command_evt)
2851 {
2852 wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
2853
2854 m_mgr.HideHint();
2855
2856 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
2857 wxCHECK_RET( src_tabs, wxT("no source object?") );
2858
2859 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
2860 }
2861
2862 wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
2863 {
2864 // if we've just removed the last tab from the source
2865 // tab set, the remove the tab control completely
2866 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2867 size_t i, pane_count = all_panes.GetCount();
2868 for (i = 0; i < pane_count; ++i)
2869 {
2870 if (all_panes.Item(i).name == wxT("dummy"))
2871 continue;
2872
2873 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2874 if (tabframe->m_tab_rect.Contains(pt))
2875 return tabframe->m_tabs;
2876 }
2877
2878 return NULL;
2879 }
2880
2881 wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
2882 {
2883 // if we've just removed the last tab from the source
2884 // tab set, the remove the tab control completely
2885 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2886 size_t i, pane_count = all_panes.GetCount();
2887 for (i = 0; i < pane_count; ++i)
2888 {
2889 if (all_panes.Item(i).name == wxT("dummy"))
2890 continue;
2891
2892 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2893 if (tabframe->m_tabs == tab_ctrl)
2894 {
2895 return tabframe;
2896 }
2897 }
2898
2899 return NULL;
2900 }
2901
2902 void wxAuiNotebook::RemoveEmptyTabFrames()
2903 {
2904 // if we've just removed the last tab from the source
2905 // tab set, the remove the tab control completely
2906 wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
2907 size_t i, pane_count = all_panes.GetCount();
2908 for (i = 0; i < pane_count; ++i)
2909 {
2910 if (all_panes.Item(i).name == wxT("dummy"))
2911 continue;
2912
2913 wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
2914 if (tab_frame->m_tabs->GetPageCount() == 0)
2915 {
2916 m_mgr.DetachPane(tab_frame);
2917
2918 // use pending delete because sometimes during
2919 // window closing, refreshs are pending
2920 if (!wxPendingDelete.Member(tab_frame->m_tabs))
2921 wxPendingDelete.Append(tab_frame->m_tabs);
2922
2923 tab_frame->m_tabs = NULL;
2924
2925 delete tab_frame;
2926 }
2927 }
2928
2929
2930 // check to see if there is still a center pane;
2931 // if there isn't, make a frame the center pane
2932 wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
2933 pane_count = panes.GetCount();
2934 wxWindow* first_good = NULL;
2935 bool center_found = false;
2936 for (i = 0; i < pane_count; ++i)
2937 {
2938 if (panes.Item(i).name == wxT("dummy"))
2939 continue;
2940 if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
2941 center_found = true;
2942 if (!first_good)
2943 first_good = panes.Item(i).window;
2944 }
2945
2946 if (!center_found && first_good)
2947 {
2948 m_mgr.GetPane(first_good).Centre();
2949 }
2950
2951 if (!m_isBeingDeleted)
2952 m_mgr.Update();
2953 }
2954
2955 void wxAuiNotebook::OnChildFocusNotebook(wxChildFocusEvent& evt)
2956 {
2957 evt.Skip();
2958
2959 // if we're dragging a tab, don't change the current selection.
2960 // This code prevents a bug that used to happen when the hint window
2961 // was hidden. In the bug, the focus would return to the notebook
2962 // child, which would then enter this handler and call
2963 // SetSelection, which is not desired turn tab dragging.
2964
2965 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2966 size_t i, pane_count = all_panes.GetCount();
2967 for (i = 0; i < pane_count; ++i)
2968 {
2969 wxAuiPaneInfo& pane = all_panes.Item(i);
2970 if (pane.name == wxT("dummy"))
2971 continue;
2972 wxTabFrame* tabframe = (wxTabFrame*)pane.window;
2973 if (tabframe->m_tabs->IsDragging())
2974 return;
2975 }
2976
2977
2978 // change the tab selection to the child
2979 // which was focused
2980 int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
2981 if (idx != -1 && idx != m_curPage)
2982 {
2983 SetSelection(idx);
2984 }
2985 }
2986
2987 void wxAuiNotebook::OnNavigationKeyNotebook(wxNavigationKeyEvent& event)
2988 {
2989 if ( event.IsWindowChange() ) {
2990 // change pages
2991 // FIXME: the problem with this is that if we have a split notebook,
2992 // we selection may go all over the place.
2993 AdvanceSelection(event.GetDirection());
2994 }
2995 else {
2996 // we get this event in 3 cases
2997 //
2998 // a) one of our pages might have generated it because the user TABbed
2999 // out from it in which case we should propagate the event upwards and
3000 // our parent will take care of setting the focus to prev/next sibling
3001 //
3002 // or
3003 //
3004 // b) the parent panel wants to give the focus to us so that we
3005 // forward it to our selected page. We can't deal with this in
3006 // OnSetFocus() because we don't know which direction the focus came
3007 // from in this case and so can't choose between setting the focus to
3008 // first or last panel child
3009 //
3010 // or
3011 //
3012 // c) we ourselves (see MSWTranslateMessage) generated the event
3013 //
3014 wxWindow * const parent = GetParent();
3015
3016 // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
3017 const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
3018 const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
3019
3020 if ( isFromParent || isFromSelf )
3021 {
3022 // no, it doesn't come from child, case (b) or (c): forward to a
3023 // page but only if direction is backwards (TAB) or from ourselves,
3024 if ( GetSelection() != wxNOT_FOUND &&
3025 (!event.GetDirection() || isFromSelf) )
3026 {
3027 // so that the page knows that the event comes from it's parent
3028 // and is being propagated downwards
3029 event.SetEventObject(this);
3030
3031 wxWindow *page = GetPage(GetSelection());
3032 if ( !page->GetEventHandler()->ProcessEvent(event) )
3033 {
3034 page->SetFocus();
3035 }
3036 //else: page manages focus inside it itself
3037 }
3038 else // otherwise set the focus to the notebook itself
3039 {
3040 SetFocus();
3041 }
3042 }
3043 else
3044 {
3045 // it comes from our child, case (a), pass to the parent, but only
3046 // if the direction is forwards. Otherwise set the focus to the
3047 // notebook itself. The notebook is always the 'first' control of a
3048 // page.
3049 if ( !event.GetDirection() )
3050 {
3051 SetFocus();
3052 }
3053 else if ( parent )
3054 {
3055 event.SetCurrentFocus(this);
3056 parent->GetEventHandler()->ProcessEvent(event);
3057 }
3058 }
3059 }
3060 }
3061
3062 void wxAuiNotebook::OnTabButton(wxAuiNotebookEvent& evt)
3063 {
3064 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3065
3066 int button_id = evt.GetInt();
3067
3068 if (button_id == wxAUI_BUTTON_CLOSE)
3069 {
3070 int selection = evt.GetSelection();
3071
3072 if (selection == -1)
3073 {
3074 // if the close button is to the right, use the active
3075 // page selection to determine which page to close
3076 selection = tabs->GetActivePage();
3077 }
3078
3079 if (selection != -1)
3080 {
3081 wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
3082
3083 // ask owner if it's ok to close the tab
3084 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
3085 e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
3086 const int idx = m_tabs.GetIdxFromWindow(close_wnd);
3087 e.SetSelection(idx);
3088 e.SetOldSelection(evt.GetSelection());
3089 e.SetEventObject(this);
3090 GetEventHandler()->ProcessEvent(e);
3091 if (!e.IsAllowed())
3092 return;
3093
3094
3095 #if wxUSE_MDI
3096 if (wxDynamicCast(close_wnd, wxAuiMDIChildFrame))
3097 {
3098 close_wnd->Close();
3099 }
3100 else
3101 #endif
3102 {
3103 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
3104 wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no page to delete?") );
3105
3106 DeletePage(main_idx);
3107 }
3108
3109 // notify owner that the tab has been closed
3110 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, m_windowId);
3111 e2.SetSelection(idx);
3112 e2.SetEventObject(this);
3113 GetEventHandler()->ProcessEvent(e2);
3114 }
3115 }
3116 }
3117
3118
3119 void wxAuiNotebook::OnTabMiddleDown(wxAuiNotebookEvent& evt)
3120 {
3121 // patch event through to owner
3122 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3123 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
3124
3125 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
3126 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
3127 e.SetEventObject(this);
3128 GetEventHandler()->ProcessEvent(e);
3129 }
3130
3131 void wxAuiNotebook::OnTabMiddleUp(wxAuiNotebookEvent& evt)
3132 {
3133 // if the wxAUI_NB_MIDDLE_CLICK_CLOSE is specified, middle
3134 // click should act like a tab close action. However, first
3135 // give the owner an opportunity to handle the middle up event
3136 // for custom action
3137
3138 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3139 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
3140
3141 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
3142 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
3143 e.SetEventObject(this);
3144 if (GetEventHandler()->ProcessEvent(e))
3145 return;
3146 if (!e.IsAllowed())
3147 return;
3148
3149 // check if we are supposed to close on middle-up
3150 if ((m_flags & wxAUI_NB_MIDDLE_CLICK_CLOSE) == 0)
3151 return;
3152
3153 // simulate the user pressing the close button on the tab
3154 evt.SetInt(wxAUI_BUTTON_CLOSE);
3155 OnTabButton(evt);
3156 }
3157
3158 void wxAuiNotebook::OnTabRightDown(wxAuiNotebookEvent& evt)
3159 {
3160 // patch event through to owner
3161 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3162 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
3163
3164 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
3165 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
3166 e.SetEventObject(this);
3167 GetEventHandler()->ProcessEvent(e);
3168 }
3169
3170 void wxAuiNotebook::OnTabRightUp(wxAuiNotebookEvent& evt)
3171 {
3172 // patch event through to owner
3173 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3174 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
3175
3176 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
3177 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
3178 e.SetEventObject(this);
3179 GetEventHandler()->ProcessEvent(e);
3180 }
3181
3182 // Sets the normal font
3183 void wxAuiNotebook::SetNormalFont(const wxFont& font)
3184 {
3185 m_normalFont = font;
3186 GetArtProvider()->SetNormalFont(font);
3187 }
3188
3189 // Sets the selected tab font
3190 void wxAuiNotebook::SetSelectedFont(const wxFont& font)
3191 {
3192 m_selectedFont = font;
3193 GetArtProvider()->SetSelectedFont(font);
3194 }
3195
3196 // Sets the measuring font
3197 void wxAuiNotebook::SetMeasuringFont(const wxFont& font)
3198 {
3199 GetArtProvider()->SetMeasuringFont(font);
3200 }
3201
3202 // Sets the tab font
3203 bool wxAuiNotebook::SetFont(const wxFont& font)
3204 {
3205 wxControl::SetFont(font);
3206
3207 wxFont normalFont(font);
3208 wxFont selectedFont(normalFont);
3209 selectedFont.SetWeight(wxBOLD);
3210
3211 SetNormalFont(normalFont);
3212 SetSelectedFont(selectedFont);
3213 SetMeasuringFont(selectedFont);
3214
3215 return true;
3216 }
3217
3218 // Gets the tab control height
3219 int wxAuiNotebook::GetTabCtrlHeight() const
3220 {
3221 return m_tabCtrlHeight;
3222 }
3223
3224 // Gets the height of the notebook for a given page height
3225 int wxAuiNotebook::GetHeightForPageHeight(int pageHeight)
3226 {
3227 UpdateTabCtrlHeight();
3228
3229 int tabCtrlHeight = GetTabCtrlHeight();
3230 int decorHeight = 2;
3231 return tabCtrlHeight + pageHeight + decorHeight;
3232 }
3233
3234 // Shows the window menu
3235 bool wxAuiNotebook::ShowWindowMenu()
3236 {
3237 wxAuiTabCtrl* tabCtrl = GetActiveTabCtrl();
3238
3239 int idx = tabCtrl->GetArtProvider()->ShowDropDown(tabCtrl, tabCtrl->GetPages(), tabCtrl->GetActivePage());
3240
3241 if (idx != -1)
3242 {
3243 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl->GetId());
3244 e.SetSelection(idx);
3245 e.SetOldSelection(tabCtrl->GetActivePage());
3246 e.SetEventObject(tabCtrl);
3247 GetEventHandler()->ProcessEvent(e);
3248
3249 return true;
3250 }
3251 else
3252 return false;
3253 }
3254
3255 void wxAuiNotebook::DoThaw()
3256 {
3257 DoSizing();
3258
3259 wxBookCtrlBase::DoThaw();
3260 }
3261
3262 void wxAuiNotebook::SetPageSize (const wxSize& WXUNUSED(size))
3263 {
3264 wxFAIL_MSG("Not implemented for wxAuiNotebook");
3265 }
3266
3267 int wxAuiNotebook::HitTest (const wxPoint& WXUNUSED(pt), long* WXUNUSED(flags)) const
3268 {
3269 wxFAIL_MSG("Not implemented for wxAuiNotebook");
3270 return wxNOT_FOUND;
3271 }
3272
3273 int wxAuiNotebook::GetPageImage(size_t WXUNUSED(n)) const
3274 {
3275 wxFAIL_MSG("Not implemented for wxAuiNotebook");
3276 return -1;
3277 }
3278
3279 bool wxAuiNotebook::SetPageImage(size_t n, int imageId)
3280 {
3281 return SetPageBitmap(n, GetImageList()->GetBitmap(imageId));
3282 }
3283
3284 int wxAuiNotebook::ChangeSelection(size_t n)
3285 {
3286 return DoModifySelection(n, false);
3287 }
3288
3289 bool wxAuiNotebook::AddPage(wxWindow *page, const wxString &text, bool select,
3290 int imageId)
3291 {
3292 if(HasImageList())
3293 {
3294 return AddPage(page, text, select, GetImageList()->GetBitmap(imageId));
3295 }
3296 else
3297 {
3298 return AddPage(page, text, select, wxNullBitmap);
3299 }
3300 }
3301
3302 bool wxAuiNotebook::DeleteAllPages()
3303 {
3304 size_t count = GetPageCount();
3305 for(size_t i = 0; i < count; i++)
3306 {
3307 DeletePage(0);
3308 }
3309 return true;
3310 }
3311
3312 bool wxAuiNotebook::InsertPage(size_t index, wxWindow *page,
3313 const wxString &text, bool select,
3314 int imageId)
3315 {
3316 if(HasImageList())
3317 {
3318 return InsertPage(index, page, text, select,
3319 GetImageList()->GetBitmap(imageId));
3320 }
3321 else
3322 {
3323 return InsertPage(index, page, text, select, wxNullBitmap);
3324 }
3325 }
3326
3327 int wxAuiNotebook::DoModifySelection(size_t n, bool events)
3328 {
3329 wxWindow* wnd = m_tabs.GetWindowFromIdx(n);
3330 if (!wnd)
3331 return m_curPage;
3332
3333 // don't change the page unless necessary;
3334 // however, clicking again on a tab should give it the focus.
3335 if ((int)n == m_curPage)
3336 {
3337 wxAuiTabCtrl* ctrl;
3338 int ctrl_idx;
3339 if (FindTab(wnd, &ctrl, &ctrl_idx))
3340 {
3341 if (FindFocus() != ctrl)
3342 ctrl->SetFocus();
3343 }
3344 return m_curPage;
3345 }
3346
3347 bool vetoed = false;
3348
3349 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
3350
3351 if(events)
3352 {
3353 evt.SetSelection(n);
3354 evt.SetOldSelection(m_curPage);
3355 evt.SetEventObject(this);
3356 GetEventHandler()->ProcessEvent(evt);
3357 vetoed = !evt.IsAllowed();
3358 }
3359
3360 if (!vetoed)
3361 {
3362 int old_curpage = m_curPage;
3363 m_curPage = n;
3364
3365 // program allows the page change
3366 if(events)
3367 {
3368 evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
3369 (void)GetEventHandler()->ProcessEvent(evt);
3370 }
3371
3372
3373 wxAuiTabCtrl* ctrl;
3374 int ctrl_idx;
3375 if (FindTab(wnd, &ctrl, &ctrl_idx))
3376 {
3377 m_tabs.SetActivePage(wnd);
3378
3379 ctrl->SetActivePage(ctrl_idx);
3380 DoSizing();
3381 ctrl->DoShowHide();
3382
3383 ctrl->MakeTabVisible(ctrl_idx, ctrl);
3384
3385 // set fonts
3386 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3387 size_t i, pane_count = all_panes.GetCount();
3388 for (i = 0; i < pane_count; ++i)
3389 {
3390 wxAuiPaneInfo& pane = all_panes.Item(i);
3391 if (pane.name == wxT("dummy"))
3392 continue;
3393 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
3394 if (tabctrl != ctrl)
3395 tabctrl->SetSelectedFont(m_normalFont);
3396 else
3397 tabctrl->SetSelectedFont(m_selectedFont);
3398 tabctrl->Refresh();
3399 }
3400
3401 // Set the focus to the page if we're not currently focused on the tab.
3402 // This is Firefox-like behaviour.
3403 if (wnd->IsShownOnScreen() && FindFocus() != ctrl)
3404 wnd->SetFocus();
3405
3406 return old_curpage;
3407 }
3408 }
3409
3410 return m_curPage;
3411 }
3412
3413
3414 #endif // wxUSE_AUI
wxWidgets (Impactor)