projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix border size computation in wxAuiTabArt.
[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 wxAuiNotebookPage& page = pages.Item(i);
1547 int border_space = m_tabs->GetArtProvider()->GetAdditionalBorderSpace(page.window);
1548
1549 int height = m_rect.height - m_tabCtrlHeight - border_space;
1550 if ( height < 0 )
1551 {
1552 // avoid passing negative height to wxWindow::SetSize(), this
1553 // results in assert failures/GTK+ warnings
1554 height = 0;
1555 }
1556
1557 if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
1558 {
1559 page.window->SetSize(m_rect.x + border_space,
1560 m_rect.y + border_space,
1561 m_rect.width - 2 * border_space,
1562 height);
1563 }
1564 else //TODO: if (GetFlags() & wxAUI_NB_TOP)
1565 {
1566 page.window->SetSize(m_rect.x + border_space,
1567 m_rect.y + m_tabCtrlHeight,
1568 m_rect.width - 2 * border_space,
1569 height);
1570 }
1571 // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
1572 // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
1573
1574 #if wxUSE_MDI
1575 if (wxDynamicCast(page.window, wxAuiMDIChildFrame))
1576 {
1577 wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
1578 wnd->ApplyMDIChildFrameRect();
1579 }
1580 #endif
1581 }
1582 }
1583
1584 protected:
1585 void DoGetSize(int* x, int* y) const
1586 {
1587 if (x)
1588 *x = m_rect.GetWidth();
1589 if (y)
1590 *y = m_rect.GetHeight();
1591 }
1592
1593 public:
1594 void Update()
1595 {
1596 // does nothing
1597 }
1598
1599 wxRect m_rect;
1600 wxRect m_tab_rect;
1601 wxAuiTabCtrl* m_tabs;
1602 int m_tabCtrlHeight;
1603 };
1604
1605
1606 const int wxAuiBaseTabCtrlId = 5380;
1607
1608
1609 // -- wxAuiNotebook class implementation --
1610
1611 #define EVT_AUI_RANGE(id1, id2, event, func) \
1612 wx__DECLARE_EVT2(event, id1, id2, wxAuiNotebookEventHandler(func))
1613
1614 BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
1615 EVT_SIZE(wxAuiNotebook::OnSize)
1616 EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocusNotebook)
1617 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1618 wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
1619 wxAuiNotebook::OnTabClicked)
1620 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1621 wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
1622 wxAuiNotebook::OnTabBeginDrag)
1623 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1624 wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
1625 wxAuiNotebook::OnTabEndDrag)
1626 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1627 wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG,
1628 wxAuiNotebook::OnTabCancelDrag)
1629 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1630 wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
1631 wxAuiNotebook::OnTabDragMotion)
1632 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1633 wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
1634 wxAuiNotebook::OnTabButton)
1635 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1636 wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN,
1637 wxAuiNotebook::OnTabMiddleDown)
1638 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1639 wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP,
1640 wxAuiNotebook::OnTabMiddleUp)
1641 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1642 wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN,
1643 wxAuiNotebook::OnTabRightDown)
1644 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1645 wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP,
1646 wxAuiNotebook::OnTabRightUp)
1647 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
1648 wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK,
1649 wxAuiNotebook::OnTabBgDClick)
1650 EVT_NAVIGATION_KEY(wxAuiNotebook::OnNavigationKeyNotebook)
1651 END_EVENT_TABLE()
1652
1653 void wxAuiNotebook::Init()
1654 {
1655 m_curPage = -1;
1656 m_tabIdCounter = wxAuiBaseTabCtrlId;
1657 m_dummyWnd = NULL;
1658 m_tabCtrlHeight = 20;
1659 m_requestedBmpSize = wxDefaultSize;
1660 m_requestedTabCtrlHeight = -1;
1661 }
1662
1663 bool wxAuiNotebook::Create(wxWindow* parent,
1664 wxWindowID id,
1665 const wxPoint& pos,
1666 const wxSize& size,
1667 long style)
1668 {
1669 if (!wxControl::Create(parent, id, pos, size, style))
1670 return false;
1671
1672 InitNotebook(style);
1673
1674 return true;
1675 }
1676
1677 // InitNotebook() contains common initialization
1678 // code called by all constructors
1679 void wxAuiNotebook::InitNotebook(long style)
1680 {
1681 SetName(wxT("wxAuiNotebook"));
1682 m_curPage = -1;
1683 m_tabIdCounter = wxAuiBaseTabCtrlId;
1684 m_dummyWnd = NULL;
1685 m_flags = (unsigned int)style;
1686 m_tabCtrlHeight = 20;
1687
1688 m_normalFont = *wxNORMAL_FONT;
1689 m_selectedFont = *wxNORMAL_FONT;
1690 m_selectedFont.SetWeight(wxBOLD);
1691
1692 SetArtProvider(new wxAuiDefaultTabArt);
1693
1694 m_dummyWnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
1695 m_dummyWnd->SetSize(200, 200);
1696 m_dummyWnd->Show(false);
1697
1698 m_mgr.SetManagedWindow(this);
1699 m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
1700 m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint
1701
1702 m_mgr.AddPane(m_dummyWnd,
1703 wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
1704
1705 m_mgr.Update();
1706 }
1707
1708 wxAuiNotebook::~wxAuiNotebook()
1709 {
1710 // Indicate we're deleting pages
1711 SendDestroyEvent();
1712
1713 while ( GetPageCount() > 0 )
1714 DeletePage(0);
1715
1716 m_mgr.UnInit();
1717 }
1718
1719 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
1720 {
1721 m_tabs.SetArtProvider(art);
1722
1723 // Update the height and do nothing else if it did something but otherwise
1724 // (i.e. if the new art provider uses the same height as the old one) we
1725 // need to manually set the art provider for all tabs ourselves.
1726 if ( !UpdateTabCtrlHeight() )
1727 {
1728 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
1729 const size_t pane_count = all_panes.GetCount();
1730 for (size_t i = 0; i < pane_count; ++i)
1731 {
1732 wxAuiPaneInfo& pane = all_panes.Item(i);
1733 if (pane.name == wxT("dummy"))
1734 continue;
1735 wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
1736 wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
1737 tabctrl->SetArtProvider(art->Clone());
1738 }
1739 }
1740 }
1741
1742 // SetTabCtrlHeight() is the highest-level override of the
1743 // tab height. A call to this function effectively enforces a
1744 // specified tab ctrl height, overriding all other considerations,
1745 // such as text or bitmap height. It overrides any call to
1746 // SetUniformBitmapSize(). Specifying a height of -1 reverts
1747 // any previous call and returns to the default behaviour
1748
1749 void wxAuiNotebook::SetTabCtrlHeight(int height)
1750 {
1751 m_requestedTabCtrlHeight = height;
1752
1753 // if window is already initialized, recalculate the tab height
1754 if (m_dummyWnd)
1755 {
1756 UpdateTabCtrlHeight();
1757 }
1758 }
1759
1760
1761 // SetUniformBitmapSize() ensures that all tabs will have
1762 // the same height, even if some tabs don't have bitmaps
1763 // Passing wxDefaultSize to this function will instruct
1764 // the control to use dynamic tab height-- so when a tab
1765 // with a large bitmap is added, the tab ctrl's height will
1766 // automatically increase to accommodate the bitmap
1767
1768 void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
1769 {
1770 m_requestedBmpSize = size;
1771
1772 // if window is already initialized, recalculate the tab height
1773 if (m_dummyWnd)
1774 {
1775 UpdateTabCtrlHeight();
1776 }
1777 }
1778
1779 // UpdateTabCtrlHeight() does the actual tab resizing. It's meant
1780 // to be used internally
1781 bool wxAuiNotebook::UpdateTabCtrlHeight()
1782 {
1783 // get the tab ctrl height we will use
1784 int height = CalculateTabCtrlHeight();
1785
1786 // if the tab control height needs to change, update
1787 // all of our tab controls with the new height
1788 if (m_tabCtrlHeight == height)
1789 return false;
1790
1791 wxAuiTabArt* art = m_tabs.GetArtProvider();
1792
1793 m_tabCtrlHeight = height;
1794
1795 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
1796 size_t i, pane_count = all_panes.GetCount();
1797 for (i = 0; i < pane_count; ++i)
1798 {
1799 wxAuiPaneInfo& pane = all_panes.Item(i);
1800 if (pane.name == wxT("dummy"))
1801 continue;
1802 wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
1803 wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
1804 tab_frame->SetTabCtrlHeight(m_tabCtrlHeight);
1805 tabctrl->SetArtProvider(art->Clone());
1806 tab_frame->DoSizing();
1807 }
1808
1809 return true;
1810 }
1811
1812 void wxAuiNotebook::UpdateHintWindowSize()
1813 {
1814 wxSize size = CalculateNewSplitSize();
1815
1816 // the placeholder hint window should be set to this size
1817 wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
1818 if (info.IsOk())
1819 {
1820 info.MinSize(size);
1821 info.BestSize(size);
1822 m_dummyWnd->SetSize(size);
1823 }
1824 }
1825
1826
1827 // calculates the size of the new split
1828 wxSize wxAuiNotebook::CalculateNewSplitSize()
1829 {
1830 // count number of tab controls
1831 int tab_ctrl_count = 0;
1832 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
1833 size_t i, pane_count = all_panes.GetCount();
1834 for (i = 0; i < pane_count; ++i)
1835 {
1836 wxAuiPaneInfo& pane = all_panes.Item(i);
1837 if (pane.name == wxT("dummy"))
1838 continue;
1839 tab_ctrl_count++;
1840 }
1841
1842 wxSize new_split_size;
1843
1844 // if there is only one tab control, the first split
1845 // should happen around the middle
1846 if (tab_ctrl_count < 2)
1847 {
1848 new_split_size = GetClientSize();
1849 new_split_size.x /= 2;
1850 new_split_size.y /= 2;
1851 }
1852 else
1853 {
1854 // this is in place of a more complicated calculation
1855 // that needs to be implemented
1856 new_split_size = wxSize(180,180);
1857 }
1858
1859 return new_split_size;
1860 }
1861
1862 int wxAuiNotebook::CalculateTabCtrlHeight()
1863 {
1864 // if a fixed tab ctrl height is specified,
1865 // just return that instead of calculating a
1866 // tab height
1867 if (m_requestedTabCtrlHeight != -1)
1868 return m_requestedTabCtrlHeight;
1869
1870 // find out new best tab height
1871 wxAuiTabArt* art = m_tabs.GetArtProvider();
1872
1873 return art->GetBestTabCtrlSize(this,
1874 m_tabs.GetPages(),
1875 m_requestedBmpSize);
1876 }
1877
1878
1879 wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
1880 {
1881 return m_tabs.GetArtProvider();
1882 }
1883
1884 void wxAuiNotebook::SetWindowStyleFlag(long style)
1885 {
1886 wxControl::SetWindowStyleFlag(style);
1887
1888 m_flags = (unsigned int)style;
1889
1890 // if the control is already initialized
1891 if (m_mgr.GetManagedWindow() == (wxWindow*)this)
1892 {
1893 // let all of the tab children know about the new style
1894
1895 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
1896 size_t i, pane_count = all_panes.GetCount();
1897 for (i = 0; i < pane_count; ++i)
1898 {
1899 wxAuiPaneInfo& pane = all_panes.Item(i);
1900 if (pane.name == wxT("dummy"))
1901 continue;
1902 wxTabFrame* tabframe = (wxTabFrame*)pane.window;
1903 wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
1904 tabctrl->SetFlags(m_flags);
1905 tabframe->DoSizing();
1906 tabctrl->Refresh();
1907 tabctrl->Update();
1908 }
1909 }
1910 }
1911
1912
1913 bool wxAuiNotebook::AddPage(wxWindow* page,
1914 const wxString& caption,
1915 bool select,
1916 const wxBitmap& bitmap)
1917 {
1918 return InsertPage(GetPageCount(), page, caption, select, bitmap);
1919 }
1920
1921 bool wxAuiNotebook::InsertPage(size_t page_idx,
1922 wxWindow* page,
1923 const wxString& caption,
1924 bool select,
1925 const wxBitmap& bitmap)
1926 {
1927 wxASSERT_MSG(page, wxT("page pointer must be non-NULL"));
1928 if (!page)
1929 return false;
1930
1931 page->Reparent(this);
1932
1933 wxAuiNotebookPage info;
1934 info.window = page;
1935 info.caption = caption;
1936 info.bitmap = bitmap;
1937 info.active = false;
1938
1939 // if there are currently no tabs, the first added
1940 // tab must be active
1941 if (m_tabs.GetPageCount() == 0)
1942 info.active = true;
1943
1944 m_tabs.InsertPage(page, info, page_idx);
1945
1946 // if that was the first page added, even if
1947 // select is false, it must become the "current page"
1948 // (though no select events will be fired)
1949 if (!select && m_tabs.GetPageCount() == 1)
1950 select = true;
1951 //m_curPage = GetPageIndex(page);
1952
1953 wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
1954 if (page_idx >= active_tabctrl->GetPageCount())
1955 active_tabctrl->AddPage(page, info);
1956 else
1957 active_tabctrl->InsertPage(page, info, page_idx);
1958
1959 UpdateTabCtrlHeight();
1960 DoSizing();
1961 active_tabctrl->DoShowHide();
1962
1963 // adjust selected index
1964 if(m_curPage >= (int) page_idx)
1965 m_curPage++;
1966
1967 if (select)
1968 {
1969 SetSelectionToWindow(page);
1970 }
1971
1972 return true;
1973 }
1974
1975
1976 // DeletePage() removes a tab from the multi-notebook,
1977 // and destroys the window as well
1978 bool wxAuiNotebook::DeletePage(size_t page_idx)
1979 {
1980 if (page_idx >= m_tabs.GetPageCount())
1981 return false;
1982
1983 wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
1984
1985 // hide the window in advance, as this will
1986 // prevent flicker
1987 ShowWnd(wnd, false);
1988
1989 if (!RemovePage(page_idx))
1990 return false;
1991
1992 #if wxUSE_MDI
1993 // actually destroy the window now
1994 if (wxDynamicCast(wnd, wxAuiMDIChildFrame))
1995 {
1996 // delete the child frame with pending delete, as is
1997 // customary with frame windows
1998 if (!wxPendingDelete.Member(wnd))
1999 wxPendingDelete.Append(wnd);
2000 }
2001 else
2002 #endif
2003 {
2004 wnd->Destroy();
2005 }
2006
2007 return true;
2008 }
2009
2010
2011
2012 // RemovePage() removes a tab from the multi-notebook,
2013 // but does not destroy the window
2014 bool wxAuiNotebook::RemovePage(size_t page_idx)
2015 {
2016 // save active window pointer
2017 wxWindow* active_wnd = NULL;
2018 if (m_curPage >= 0)
2019 active_wnd = m_tabs.GetWindowFromIdx(m_curPage);
2020
2021 // save pointer of window being deleted
2022 wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
2023 wxWindow* new_active = NULL;
2024
2025 // make sure we found the page
2026 if (!wnd)
2027 return false;
2028
2029 // find out which onscreen tab ctrl owns this tab
2030 wxAuiTabCtrl* ctrl;
2031 int ctrl_idx;
2032 if (!FindTab(wnd, &ctrl, &ctrl_idx))
2033 return false;
2034
2035 bool is_curpage = (m_curPage == (int)page_idx);
2036 bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
2037
2038
2039 // remove the tab from main catalog
2040 if (!m_tabs.RemovePage(wnd))
2041 return false;
2042
2043 // remove the tab from the onscreen tab ctrl
2044 ctrl->RemovePage(wnd);
2045
2046 if (is_active_in_split)
2047 {
2048 int ctrl_new_page_count = (int)ctrl->GetPageCount();
2049
2050 if (ctrl_idx >= ctrl_new_page_count)
2051 ctrl_idx = ctrl_new_page_count-1;
2052
2053 if (ctrl_idx >= 0 && ctrl_idx < (int)ctrl->GetPageCount())
2054 {
2055 // set new page as active in the tab split
2056 ctrl->SetActivePage(ctrl_idx);
2057
2058 // if the page deleted was the current page for the
2059 // entire tab control, then record the window
2060 // pointer of the new active page for activation
2061 if (is_curpage)
2062 {
2063 new_active = ctrl->GetWindowFromIdx(ctrl_idx);
2064 }
2065 }
2066 }
2067 else
2068 {
2069 // we are not deleting the active page, so keep it the same
2070 new_active = active_wnd;
2071 }
2072
2073
2074 if (!new_active)
2075 {
2076 // we haven't yet found a new page to active,
2077 // so select the next page from the main tab
2078 // catalogue
2079
2080 if (page_idx < m_tabs.GetPageCount())
2081 {
2082 new_active = m_tabs.GetPage(page_idx).window;
2083 }
2084
2085 if (!new_active && m_tabs.GetPageCount() > 0)
2086 {
2087 new_active = m_tabs.GetPage(0).window;
2088 }
2089 }
2090
2091
2092 RemoveEmptyTabFrames();
2093
2094 m_curPage = wxNOT_FOUND;
2095
2096 // set new active pane unless we're being destroyed anyhow
2097 if (new_active && !m_isBeingDeleted)
2098 SetSelectionToWindow(new_active);
2099
2100 return true;
2101 }
2102
2103 // GetPageIndex() returns the index of the page, or -1 if the
2104 // page could not be located in the notebook
2105 int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
2106 {
2107 return m_tabs.GetIdxFromWindow(page_wnd);
2108 }
2109
2110
2111
2112 // SetPageText() changes the tab caption of the specified page
2113 bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
2114 {
2115 if (page_idx >= m_tabs.GetPageCount())
2116 return false;
2117
2118 // update our own tab catalog
2119 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2120 page_info.caption = text;
2121
2122 // update what's on screen
2123 wxAuiTabCtrl* ctrl;
2124 int ctrl_idx;
2125 if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2126 {
2127 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2128 info.caption = text;
2129 ctrl->Refresh();
2130 ctrl->Update();
2131 }
2132
2133 return true;
2134 }
2135
2136 // returns the page caption
2137 wxString wxAuiNotebook::GetPageText(size_t page_idx) const
2138 {
2139 if (page_idx >= m_tabs.GetPageCount())
2140 return wxEmptyString;
2141
2142 // update our own tab catalog
2143 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2144 return page_info.caption;
2145 }
2146
2147 bool wxAuiNotebook::SetPageToolTip(size_t page_idx, const wxString& text)
2148 {
2149 if (page_idx >= m_tabs.GetPageCount())
2150 return false;
2151
2152 // update our own tab catalog
2153 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2154 page_info.tooltip = text;
2155
2156 wxAuiTabCtrl* ctrl;
2157 int ctrl_idx;
2158 if (!FindTab(page_info.window, &ctrl, &ctrl_idx))
2159 return false;
2160
2161 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2162 info.tooltip = text;
2163
2164 // NB: we don't update the tooltip if it is already being displayed, it
2165 // typically never happens, no need to code that
2166 return true;
2167 }
2168
2169 wxString wxAuiNotebook::GetPageToolTip(size_t page_idx) const
2170 {
2171 if (page_idx >= m_tabs.GetPageCount())
2172 return wxString();
2173
2174 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2175 return page_info.tooltip;
2176 }
2177
2178 bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
2179 {
2180 if (page_idx >= m_tabs.GetPageCount())
2181 return false;
2182
2183 // update our own tab catalog
2184 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2185 page_info.bitmap = bitmap;
2186
2187 // tab height might have changed
2188 UpdateTabCtrlHeight();
2189
2190 // update what's on screen
2191 wxAuiTabCtrl* ctrl;
2192 int ctrl_idx;
2193 if (FindTab(page_info.window, &ctrl, &ctrl_idx))
2194 {
2195 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
2196 info.bitmap = bitmap;
2197 ctrl->Refresh();
2198 ctrl->Update();
2199 }
2200
2201 return true;
2202 }
2203
2204 // returns the page bitmap
2205 wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
2206 {
2207 if (page_idx >= m_tabs.GetPageCount())
2208 return wxBitmap();
2209
2210 // update our own tab catalog
2211 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
2212 return page_info.bitmap;
2213 }
2214
2215 // GetSelection() returns the index of the currently active page
2216 int wxAuiNotebook::GetSelection() const
2217 {
2218 return m_curPage;
2219 }
2220
2221 // SetSelection() sets the currently active page
2222 int wxAuiNotebook::SetSelection(size_t new_page)
2223 {
2224 return DoModifySelection(new_page, true);
2225 }
2226
2227 void wxAuiNotebook::SetSelectionToWindow(wxWindow *win)
2228 {
2229 const int idx = m_tabs.GetIdxFromWindow(win);
2230 wxCHECK_RET( idx != wxNOT_FOUND, wxT("invalid notebook page") );
2231
2232
2233 // since a tab was clicked, let the parent know that we received
2234 // the focus, even if we will assign that focus immediately
2235 // to the child tab in the SetSelection call below
2236 // (the child focus event will also let wxAuiManager, if any,
2237 // know that the notebook control has been activated)
2238
2239 wxWindow* parent = GetParent();
2240 if (parent)
2241 {
2242 wxChildFocusEvent eventFocus(this);
2243 parent->GetEventHandler()->ProcessEvent(eventFocus);
2244 }
2245
2246
2247 SetSelection(idx);
2248 }
2249
2250 // GetPageCount() returns the total number of
2251 // pages managed by the multi-notebook
2252 size_t wxAuiNotebook::GetPageCount() const
2253 {
2254 return m_tabs.GetPageCount();
2255 }
2256
2257 // GetPage() returns the wxWindow pointer of the
2258 // specified page
2259 wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
2260 {
2261 wxASSERT(page_idx < m_tabs.GetPageCount());
2262
2263 return m_tabs.GetWindowFromIdx(page_idx);
2264 }
2265
2266 // DoSizing() performs all sizing operations in each tab control
2267 void wxAuiNotebook::DoSizing()
2268 {
2269 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2270 size_t i, pane_count = all_panes.GetCount();
2271 for (i = 0; i < pane_count; ++i)
2272 {
2273 if (all_panes.Item(i).name == wxT("dummy"))
2274 continue;
2275
2276 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2277 tabframe->DoSizing();
2278 }
2279 }
2280
2281 // GetActiveTabCtrl() returns the active tab control. It is
2282 // called to determine which control gets new windows being added
2283 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
2284 {
2285 if (m_curPage >= 0 && m_curPage < (int)m_tabs.GetPageCount())
2286 {
2287 wxAuiTabCtrl* ctrl;
2288 int idx;
2289
2290 // find the tab ctrl with the current page
2291 if (FindTab(m_tabs.GetPage(m_curPage).window,
2292 &ctrl, &idx))
2293 {
2294 return ctrl;
2295 }
2296 }
2297
2298 // no current page, just find the first tab ctrl
2299 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2300 size_t i, pane_count = all_panes.GetCount();
2301 for (i = 0; i < pane_count; ++i)
2302 {
2303 if (all_panes.Item(i).name == wxT("dummy"))
2304 continue;
2305
2306 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2307 return tabframe->m_tabs;
2308 }
2309
2310 // If there is no tabframe at all, create one
2311 wxTabFrame* tabframe = new wxTabFrame;
2312 tabframe->SetTabCtrlHeight(m_tabCtrlHeight);
2313 tabframe->m_tabs = new wxAuiTabCtrl(this,
2314 m_tabIdCounter++,
2315 wxDefaultPosition,
2316 wxDefaultSize,
2317 wxNO_BORDER|wxWANTS_CHARS);
2318 tabframe->m_tabs->SetFlags(m_flags);
2319 tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2320 m_mgr.AddPane(tabframe,
2321 wxAuiPaneInfo().Center().CaptionVisible(false));
2322
2323 m_mgr.Update();
2324
2325 return tabframe->m_tabs;
2326 }
2327
2328 // FindTab() finds the tab control that currently contains the window as well
2329 // as the index of the window in the tab control. It returns true if the
2330 // window was found, otherwise false.
2331 bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
2332 {
2333 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2334 size_t i, pane_count = all_panes.GetCount();
2335 for (i = 0; i < pane_count; ++i)
2336 {
2337 if (all_panes.Item(i).name == wxT("dummy"))
2338 continue;
2339
2340 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2341
2342 int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
2343 if (page_idx != -1)
2344 {
2345 *ctrl = tabframe->m_tabs;
2346 *idx = page_idx;
2347 return true;
2348 }
2349 }
2350
2351 return false;
2352 }
2353
2354 void wxAuiNotebook::Split(size_t page, int direction)
2355 {
2356 wxSize cli_size = GetClientSize();
2357
2358 // get the page's window pointer
2359 wxWindow* wnd = GetPage(page);
2360 if (!wnd)
2361 return;
2362
2363 // notebooks with 1 or less pages can't be split
2364 if (GetPageCount() < 2)
2365 return;
2366
2367 // find out which tab control the page currently belongs to
2368 wxAuiTabCtrl *src_tabs, *dest_tabs;
2369 int src_idx = -1;
2370 src_tabs = NULL;
2371 if (!FindTab(wnd, &src_tabs, &src_idx))
2372 return;
2373 if (!src_tabs || src_idx == -1)
2374 return;
2375
2376 // choose a split size
2377 wxSize split_size;
2378 if (GetPageCount() > 2)
2379 {
2380 split_size = CalculateNewSplitSize();
2381 }
2382 else
2383 {
2384 // because there are two panes, always split them
2385 // equally
2386 split_size = GetClientSize();
2387 split_size.x /= 2;
2388 split_size.y /= 2;
2389 }
2390
2391
2392 // create a new tab frame
2393 wxTabFrame* new_tabs = new wxTabFrame;
2394 new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
2395 new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);
2396 new_tabs->m_tabs = new wxAuiTabCtrl(this,
2397 m_tabIdCounter++,
2398 wxDefaultPosition,
2399 wxDefaultSize,
2400 wxNO_BORDER|wxWANTS_CHARS);
2401 new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2402 new_tabs->m_tabs->SetFlags(m_flags);
2403 dest_tabs = new_tabs->m_tabs;
2404
2405 // create a pane info structure with the information
2406 // about where the pane should be added
2407 wxAuiPaneInfo paneInfo = wxAuiPaneInfo().Bottom().CaptionVisible(false);
2408 wxPoint mouse_pt;
2409
2410 if (direction == wxLEFT)
2411 {
2412 paneInfo.Left();
2413 mouse_pt = wxPoint(0, cli_size.y/2);
2414 }
2415 else if (direction == wxRIGHT)
2416 {
2417 paneInfo.Right();
2418 mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
2419 }
2420 else if (direction == wxTOP)
2421 {
2422 paneInfo.Top();
2423 mouse_pt = wxPoint(cli_size.x/2, 0);
2424 }
2425 else if (direction == wxBOTTOM)
2426 {
2427 paneInfo.Bottom();
2428 mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
2429 }
2430
2431 m_mgr.AddPane(new_tabs, paneInfo, mouse_pt);
2432 m_mgr.Update();
2433
2434 // remove the page from the source tabs
2435 wxAuiNotebookPage page_info = src_tabs->GetPage(src_idx);
2436 page_info.active = false;
2437 src_tabs->RemovePage(page_info.window);
2438 if (src_tabs->GetPageCount() > 0)
2439 {
2440 src_tabs->SetActivePage((size_t)0);
2441 src_tabs->DoShowHide();
2442 src_tabs->Refresh();
2443 }
2444
2445
2446 // add the page to the destination tabs
2447 dest_tabs->InsertPage(page_info.window, page_info, 0);
2448
2449 if (src_tabs->GetPageCount() == 0)
2450 {
2451 RemoveEmptyTabFrames();
2452 }
2453
2454 DoSizing();
2455 dest_tabs->DoShowHide();
2456 dest_tabs->Refresh();
2457
2458 // force the set selection function reset the selection
2459 m_curPage = -1;
2460
2461 // set the active page to the one we just split off
2462 SetSelectionToPage(page_info);
2463
2464 UpdateHintWindowSize();
2465 }
2466
2467
2468 void wxAuiNotebook::OnSize(wxSizeEvent& evt)
2469 {
2470 UpdateHintWindowSize();
2471
2472 evt.Skip();
2473 }
2474
2475 void wxAuiNotebook::OnTabClicked(wxAuiNotebookEvent& evt)
2476 {
2477 wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
2478 wxASSERT(ctrl != NULL);
2479
2480 wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
2481 wxASSERT(wnd != NULL);
2482
2483 SetSelectionToWindow(wnd);
2484 }
2485
2486 void wxAuiNotebook::OnTabBgDClick(wxAuiNotebookEvent& WXUNUSED(evt))
2487 {
2488 // notify owner that the tabbar background has been double-clicked
2489 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
2490 e.SetEventObject(this);
2491 GetEventHandler()->ProcessEvent(e);
2492 }
2493
2494 void wxAuiNotebook::OnTabBeginDrag(wxAuiNotebookEvent&)
2495 {
2496 m_lastDragX = 0;
2497 }
2498
2499 void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)
2500 {
2501 wxPoint screen_pt = ::wxGetMousePosition();
2502 wxPoint client_pt = ScreenToClient(screen_pt);
2503 wxPoint zero(0,0);
2504
2505 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
2506 wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
2507
2508 if (dest_tabs == src_tabs)
2509 {
2510 if (src_tabs)
2511 {
2512 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
2513 }
2514
2515 // always hide the hint for inner-tabctrl drag
2516 m_mgr.HideHint();
2517
2518 // if tab moving is not allowed, leave
2519 if (!(m_flags & wxAUI_NB_TAB_MOVE))
2520 {
2521 return;
2522 }
2523
2524 wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
2525 wxWindow* dest_location_tab;
2526
2527 // this is an inner-tab drag/reposition
2528 if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
2529 {
2530 int src_idx = evt.GetSelection();
2531 int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
2532
2533 // prevent jumpy drag
2534 if ((src_idx == dest_idx) || dest_idx == -1 ||
2535 (src_idx > dest_idx && m_lastDragX <= pt.x) ||
2536 (src_idx < dest_idx && m_lastDragX >= pt.x))
2537 {
2538 m_lastDragX = pt.x;
2539 return;
2540 }
2541
2542
2543 wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
2544 dest_tabs->MovePage(src_tab, dest_idx);
2545 dest_tabs->SetActivePage((size_t)dest_idx);
2546 dest_tabs->DoShowHide();
2547 dest_tabs->Refresh();
2548 m_lastDragX = pt.x;
2549
2550 }
2551
2552 return;
2553 }
2554
2555
2556 // if external drag is allowed, check if the tab is being dragged
2557 // over a different wxAuiNotebook control
2558 if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
2559 {
2560 wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
2561
2562 // if we aren't over any window, stop here
2563 if (!tab_ctrl)
2564 return;
2565
2566 // make sure we are not over the hint window
2567 if (!wxDynamicCast(tab_ctrl, wxFrame))
2568 {
2569 while (tab_ctrl)
2570 {
2571 if (wxDynamicCast(tab_ctrl, wxAuiTabCtrl))
2572 break;
2573 tab_ctrl = tab_ctrl->GetParent();
2574 }
2575
2576 if (tab_ctrl)
2577 {
2578 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
2579
2580 if (nb != this)
2581 {
2582 wxRect hint_rect = tab_ctrl->GetClientRect();
2583 tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
2584 m_mgr.ShowHint(hint_rect);
2585 return;
2586 }
2587 }
2588 }
2589 else
2590 {
2591 if (!dest_tabs)
2592 {
2593 // we are either over a hint window, or not over a tab
2594 // window, and there is no where to drag to, so exit
2595 return;
2596 }
2597 }
2598 }
2599
2600
2601 // if there are less than two panes, split can't happen, so leave
2602 if (m_tabs.GetPageCount() < 2)
2603 return;
2604
2605 // if tab moving is not allowed, leave
2606 if (!(m_flags & wxAUI_NB_TAB_SPLIT))
2607 return;
2608
2609
2610 if (src_tabs)
2611 {
2612 src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
2613 }
2614
2615
2616 if (dest_tabs)
2617 {
2618 wxRect hint_rect = dest_tabs->GetRect();
2619 ClientToScreen(&hint_rect.x, &hint_rect.y);
2620 m_mgr.ShowHint(hint_rect);
2621 }
2622 else
2623 {
2624 m_mgr.DrawHintRect(m_dummyWnd, client_pt, zero);
2625 }
2626 }
2627
2628
2629
2630 void wxAuiNotebook::OnTabEndDrag(wxAuiNotebookEvent& evt)
2631 {
2632 m_mgr.HideHint();
2633
2634
2635 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
2636 wxCHECK_RET( src_tabs, wxT("no source object?") );
2637
2638 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
2639
2640 // get the mouse position, which will be used to determine the drop point
2641 wxPoint mouse_screen_pt = ::wxGetMousePosition();
2642 wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
2643
2644
2645
2646 // check for an external move
2647 if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
2648 {
2649 wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
2650
2651 while (tab_ctrl)
2652 {
2653 if (wxDynamicCast(tab_ctrl, wxAuiTabCtrl))
2654 break;
2655 tab_ctrl = tab_ctrl->GetParent();
2656 }
2657
2658 if (tab_ctrl)
2659 {
2660 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
2661
2662 if (nb != this)
2663 {
2664 // find out from the destination control
2665 // if it's ok to drop this tab here
2666 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
2667 e.SetSelection(evt.GetSelection());
2668 e.SetOldSelection(evt.GetSelection());
2669 e.SetEventObject(this);
2670 e.SetDragSource(this);
2671 e.Veto(); // dropping must be explicitly approved by control owner
2672
2673 nb->GetEventHandler()->ProcessEvent(e);
2674
2675 if (!e.IsAllowed())
2676 {
2677 // no answer or negative answer
2678 m_mgr.HideHint();
2679 return;
2680 }
2681
2682 // drop was allowed
2683 int src_idx = evt.GetSelection();
2684 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
2685
2686 // Check that it's not an impossible parent relationship
2687 wxWindow* p = nb;
2688 while (p && !p->IsTopLevel())
2689 {
2690 if (p == src_page)
2691 {
2692 return;
2693 }
2694 p = p->GetParent();
2695 }
2696
2697 // get main index of the page
2698 int main_idx = m_tabs.GetIdxFromWindow(src_page);
2699 wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no source page?") );
2700
2701
2702 // make a copy of the page info
2703 wxAuiNotebookPage page_info = m_tabs.GetPage(main_idx);
2704
2705 // remove the page from the source notebook
2706 RemovePage(main_idx);
2707
2708 // reparent the page
2709 src_page->Reparent(nb);
2710
2711
2712 // found out the insert idx
2713 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
2714 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
2715
2716 wxWindow* target = NULL;
2717 int insert_idx = -1;
2718 dest_tabs->TabHitTest(pt.x, pt.y, &target);
2719 if (target)
2720 {
2721 insert_idx = dest_tabs->GetIdxFromWindow(target);
2722 }
2723
2724
2725 // add the page to the new notebook
2726 if (insert_idx == -1)
2727 insert_idx = dest_tabs->GetPageCount();
2728 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
2729 nb->m_tabs.AddPage(page_info.window, page_info);
2730
2731 nb->DoSizing();
2732 dest_tabs->DoShowHide();
2733 dest_tabs->Refresh();
2734
2735 // set the selection in the destination tab control
2736 nb->SetSelectionToPage(page_info);
2737
2738 // notify owner that the tab has been dragged
2739 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
2740 e2.SetSelection(evt.GetSelection());
2741 e2.SetOldSelection(evt.GetSelection());
2742 e2.SetEventObject(this);
2743 GetEventHandler()->ProcessEvent(e2);
2744
2745 return;
2746 }
2747 }
2748 }
2749
2750
2751
2752
2753 // only perform a tab split if it's allowed
2754 wxAuiTabCtrl* dest_tabs = NULL;
2755
2756 if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
2757 {
2758 // If the pointer is in an existing tab frame, do a tab insert
2759 wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
2760 wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
2761 int insert_idx = -1;
2762 if (tab_frame)
2763 {
2764 dest_tabs = tab_frame->m_tabs;
2765
2766 if (dest_tabs == src_tabs)
2767 return;
2768
2769
2770 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
2771 wxWindow* target = NULL;
2772 dest_tabs->TabHitTest(pt.x, pt.y, &target);
2773 if (target)
2774 {
2775 insert_idx = dest_tabs->GetIdxFromWindow(target);
2776 }
2777 }
2778 else
2779 {
2780 wxPoint zero(0,0);
2781 wxRect rect = m_mgr.CalculateHintRect(m_dummyWnd,
2782 mouse_client_pt,
2783 zero);
2784 if (rect.IsEmpty())
2785 {
2786 // there is no suitable drop location here, exit out
2787 return;
2788 }
2789
2790 // If there is no tabframe at all, create one
2791 wxTabFrame* new_tabs = new wxTabFrame;
2792 new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
2793 new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);
2794 new_tabs->m_tabs = new wxAuiTabCtrl(this,
2795 m_tabIdCounter++,
2796 wxDefaultPosition,
2797 wxDefaultSize,
2798 wxNO_BORDER|wxWANTS_CHARS);
2799 new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
2800 new_tabs->m_tabs->SetFlags(m_flags);
2801
2802 m_mgr.AddPane(new_tabs,
2803 wxAuiPaneInfo().Bottom().CaptionVisible(false),
2804 mouse_client_pt);
2805 m_mgr.Update();
2806 dest_tabs = new_tabs->m_tabs;
2807 }
2808
2809
2810
2811 // remove the page from the source tabs
2812 wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
2813 page_info.active = false;
2814 src_tabs->RemovePage(page_info.window);
2815 if (src_tabs->GetPageCount() > 0)
2816 {
2817 src_tabs->SetActivePage((size_t)0);
2818 src_tabs->DoShowHide();
2819 src_tabs->Refresh();
2820 }
2821
2822
2823
2824 // add the page to the destination tabs
2825 if (insert_idx == -1)
2826 insert_idx = dest_tabs->GetPageCount();
2827 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
2828
2829 if (src_tabs->GetPageCount() == 0)
2830 {
2831 RemoveEmptyTabFrames();
2832 }
2833
2834 DoSizing();
2835 dest_tabs->DoShowHide();
2836 dest_tabs->Refresh();
2837
2838 // force the set selection function reset the selection
2839 m_curPage = -1;
2840
2841 // set the active page to the one we just split off
2842 SetSelectionToPage(page_info);
2843
2844 UpdateHintWindowSize();
2845 }
2846
2847 // notify owner that the tab has been dragged
2848 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
2849 e.SetSelection(evt.GetSelection());
2850 e.SetOldSelection(evt.GetSelection());
2851 e.SetEventObject(this);
2852 GetEventHandler()->ProcessEvent(e);
2853 }
2854
2855
2856
2857 void wxAuiNotebook::OnTabCancelDrag(wxAuiNotebookEvent& command_evt)
2858 {
2859 wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
2860
2861 m_mgr.HideHint();
2862
2863 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
2864 wxCHECK_RET( src_tabs, wxT("no source object?") );
2865
2866 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
2867 }
2868
2869 wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
2870 {
2871 // if we've just removed the last tab from the source
2872 // tab set, the remove the tab control completely
2873 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2874 size_t i, pane_count = all_panes.GetCount();
2875 for (i = 0; i < pane_count; ++i)
2876 {
2877 if (all_panes.Item(i).name == wxT("dummy"))
2878 continue;
2879
2880 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2881 if (tabframe->m_tab_rect.Contains(pt))
2882 return tabframe->m_tabs;
2883 }
2884
2885 return NULL;
2886 }
2887
2888 wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
2889 {
2890 // if we've just removed the last tab from the source
2891 // tab set, the remove the tab control completely
2892 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2893 size_t i, pane_count = all_panes.GetCount();
2894 for (i = 0; i < pane_count; ++i)
2895 {
2896 if (all_panes.Item(i).name == wxT("dummy"))
2897 continue;
2898
2899 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
2900 if (tabframe->m_tabs == tab_ctrl)
2901 {
2902 return tabframe;
2903 }
2904 }
2905
2906 return NULL;
2907 }
2908
2909 void wxAuiNotebook::RemoveEmptyTabFrames()
2910 {
2911 // if we've just removed the last tab from the source
2912 // tab set, the remove the tab control completely
2913 wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
2914 size_t i, pane_count = all_panes.GetCount();
2915 for (i = 0; i < pane_count; ++i)
2916 {
2917 if (all_panes.Item(i).name == wxT("dummy"))
2918 continue;
2919
2920 wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
2921 if (tab_frame->m_tabs->GetPageCount() == 0)
2922 {
2923 m_mgr.DetachPane(tab_frame);
2924
2925 // use pending delete because sometimes during
2926 // window closing, refreshs are pending
2927 if (!wxPendingDelete.Member(tab_frame->m_tabs))
2928 wxPendingDelete.Append(tab_frame->m_tabs);
2929
2930 tab_frame->m_tabs = NULL;
2931
2932 delete tab_frame;
2933 }
2934 }
2935
2936
2937 // check to see if there is still a center pane;
2938 // if there isn't, make a frame the center pane
2939 wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
2940 pane_count = panes.GetCount();
2941 wxWindow* first_good = NULL;
2942 bool center_found = false;
2943 for (i = 0; i < pane_count; ++i)
2944 {
2945 if (panes.Item(i).name == wxT("dummy"))
2946 continue;
2947 if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
2948 center_found = true;
2949 if (!first_good)
2950 first_good = panes.Item(i).window;
2951 }
2952
2953 if (!center_found && first_good)
2954 {
2955 m_mgr.GetPane(first_good).Centre();
2956 }
2957
2958 if (!m_isBeingDeleted)
2959 m_mgr.Update();
2960 }
2961
2962 void wxAuiNotebook::OnChildFocusNotebook(wxChildFocusEvent& evt)
2963 {
2964 evt.Skip();
2965
2966 // if we're dragging a tab, don't change the current selection.
2967 // This code prevents a bug that used to happen when the hint window
2968 // was hidden. In the bug, the focus would return to the notebook
2969 // child, which would then enter this handler and call
2970 // SetSelection, which is not desired turn tab dragging.
2971
2972 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2973 size_t i, pane_count = all_panes.GetCount();
2974 for (i = 0; i < pane_count; ++i)
2975 {
2976 wxAuiPaneInfo& pane = all_panes.Item(i);
2977 if (pane.name == wxT("dummy"))
2978 continue;
2979 wxTabFrame* tabframe = (wxTabFrame*)pane.window;
2980 if (tabframe->m_tabs->IsDragging())
2981 return;
2982 }
2983
2984
2985 // change the tab selection to the child
2986 // which was focused
2987 int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
2988 if (idx != -1 && idx != m_curPage)
2989 {
2990 SetSelection(idx);
2991 }
2992 }
2993
2994 void wxAuiNotebook::OnNavigationKeyNotebook(wxNavigationKeyEvent& event)
2995 {
2996 if ( event.IsWindowChange() ) {
2997 // change pages
2998 // FIXME: the problem with this is that if we have a split notebook,
2999 // we selection may go all over the place.
3000 AdvanceSelection(event.GetDirection());
3001 }
3002 else {
3003 // we get this event in 3 cases
3004 //
3005 // a) one of our pages might have generated it because the user TABbed
3006 // out from it in which case we should propagate the event upwards and
3007 // our parent will take care of setting the focus to prev/next sibling
3008 //
3009 // or
3010 //
3011 // b) the parent panel wants to give the focus to us so that we
3012 // forward it to our selected page. We can't deal with this in
3013 // OnSetFocus() because we don't know which direction the focus came
3014 // from in this case and so can't choose between setting the focus to
3015 // first or last panel child
3016 //
3017 // or
3018 //
3019 // c) we ourselves (see MSWTranslateMessage) generated the event
3020 //
3021 wxWindow * const parent = GetParent();
3022
3023 // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
3024 const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
3025 const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
3026
3027 if ( isFromParent || isFromSelf )
3028 {
3029 // no, it doesn't come from child, case (b) or (c): forward to a
3030 // page but only if direction is backwards (TAB) or from ourselves,
3031 if ( GetSelection() != wxNOT_FOUND &&
3032 (!event.GetDirection() || isFromSelf) )
3033 {
3034 // so that the page knows that the event comes from it's parent
3035 // and is being propagated downwards
3036 event.SetEventObject(this);
3037
3038 wxWindow *page = GetPage(GetSelection());
3039 if ( !page->GetEventHandler()->ProcessEvent(event) )
3040 {
3041 page->SetFocus();
3042 }
3043 //else: page manages focus inside it itself
3044 }
3045 else // otherwise set the focus to the notebook itself
3046 {
3047 SetFocus();
3048 }
3049 }
3050 else
3051 {
3052 // it comes from our child, case (a), pass to the parent, but only
3053 // if the direction is forwards. Otherwise set the focus to the
3054 // notebook itself. The notebook is always the 'first' control of a
3055 // page.
3056 if ( !event.GetDirection() )
3057 {
3058 SetFocus();
3059 }
3060 else if ( parent )
3061 {
3062 event.SetCurrentFocus(this);
3063 parent->GetEventHandler()->ProcessEvent(event);
3064 }
3065 }
3066 }
3067 }
3068
3069 void wxAuiNotebook::OnTabButton(wxAuiNotebookEvent& evt)
3070 {
3071 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3072
3073 int button_id = evt.GetInt();
3074
3075 if (button_id == wxAUI_BUTTON_CLOSE)
3076 {
3077 int selection = evt.GetSelection();
3078
3079 if (selection == -1)
3080 {
3081 // if the close button is to the right, use the active
3082 // page selection to determine which page to close
3083 selection = tabs->GetActivePage();
3084 }
3085
3086 if (selection != -1)
3087 {
3088 wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
3089
3090 // ask owner if it's ok to close the tab
3091 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
3092 e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
3093 const int idx = m_tabs.GetIdxFromWindow(close_wnd);
3094 e.SetSelection(idx);
3095 e.SetOldSelection(evt.GetSelection());
3096 e.SetEventObject(this);
3097 GetEventHandler()->ProcessEvent(e);
3098 if (!e.IsAllowed())
3099 return;
3100
3101
3102 #if wxUSE_MDI
3103 if (wxDynamicCast(close_wnd, wxAuiMDIChildFrame))
3104 {
3105 close_wnd->Close();
3106 }
3107 else
3108 #endif
3109 {
3110 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
3111 wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no page to delete?") );
3112
3113 DeletePage(main_idx);
3114 }
3115
3116 // notify owner that the tab has been closed
3117 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, m_windowId);
3118 e2.SetSelection(idx);
3119 e2.SetEventObject(this);
3120 GetEventHandler()->ProcessEvent(e2);
3121 }
3122 }
3123 }
3124
3125
3126 void wxAuiNotebook::OnTabMiddleDown(wxAuiNotebookEvent& evt)
3127 {
3128 // patch event through to owner
3129 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3130 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
3131
3132 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
3133 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
3134 e.SetEventObject(this);
3135 GetEventHandler()->ProcessEvent(e);
3136 }
3137
3138 void wxAuiNotebook::OnTabMiddleUp(wxAuiNotebookEvent& evt)
3139 {
3140 // if the wxAUI_NB_MIDDLE_CLICK_CLOSE is specified, middle
3141 // click should act like a tab close action. However, first
3142 // give the owner an opportunity to handle the middle up event
3143 // for custom action
3144
3145 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3146 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
3147
3148 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
3149 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
3150 e.SetEventObject(this);
3151 if (GetEventHandler()->ProcessEvent(e))
3152 return;
3153 if (!e.IsAllowed())
3154 return;
3155
3156 // check if we are supposed to close on middle-up
3157 if ((m_flags & wxAUI_NB_MIDDLE_CLICK_CLOSE) == 0)
3158 return;
3159
3160 // simulate the user pressing the close button on the tab
3161 evt.SetInt(wxAUI_BUTTON_CLOSE);
3162 OnTabButton(evt);
3163 }
3164
3165 void wxAuiNotebook::OnTabRightDown(wxAuiNotebookEvent& evt)
3166 {
3167 // patch event through to owner
3168 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3169 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
3170
3171 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
3172 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
3173 e.SetEventObject(this);
3174 GetEventHandler()->ProcessEvent(e);
3175 }
3176
3177 void wxAuiNotebook::OnTabRightUp(wxAuiNotebookEvent& evt)
3178 {
3179 // patch event through to owner
3180 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3181 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
3182
3183 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
3184 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
3185 e.SetEventObject(this);
3186 GetEventHandler()->ProcessEvent(e);
3187 }
3188
3189 // Sets the normal font
3190 void wxAuiNotebook::SetNormalFont(const wxFont& font)
3191 {
3192 m_normalFont = font;
3193 GetArtProvider()->SetNormalFont(font);
3194 }
3195
3196 // Sets the selected tab font
3197 void wxAuiNotebook::SetSelectedFont(const wxFont& font)
3198 {
3199 m_selectedFont = font;
3200 GetArtProvider()->SetSelectedFont(font);
3201 }
3202
3203 // Sets the measuring font
3204 void wxAuiNotebook::SetMeasuringFont(const wxFont& font)
3205 {
3206 GetArtProvider()->SetMeasuringFont(font);
3207 }
3208
3209 // Sets the tab font
3210 bool wxAuiNotebook::SetFont(const wxFont& font)
3211 {
3212 wxControl::SetFont(font);
3213
3214 wxFont normalFont(font);
3215 wxFont selectedFont(normalFont);
3216 selectedFont.SetWeight(wxBOLD);
3217
3218 SetNormalFont(normalFont);
3219 SetSelectedFont(selectedFont);
3220 SetMeasuringFont(selectedFont);
3221
3222 return true;
3223 }
3224
3225 // Gets the tab control height
3226 int wxAuiNotebook::GetTabCtrlHeight() const
3227 {
3228 return m_tabCtrlHeight;
3229 }
3230
3231 // Gets the height of the notebook for a given page height
3232 int wxAuiNotebook::GetHeightForPageHeight(int pageHeight)
3233 {
3234 UpdateTabCtrlHeight();
3235
3236 int tabCtrlHeight = GetTabCtrlHeight();
3237 int decorHeight = 2;
3238 return tabCtrlHeight + pageHeight + decorHeight;
3239 }
3240
3241 // Shows the window menu
3242 bool wxAuiNotebook::ShowWindowMenu()
3243 {
3244 wxAuiTabCtrl* tabCtrl = GetActiveTabCtrl();
3245
3246 int idx = tabCtrl->GetArtProvider()->ShowDropDown(tabCtrl, tabCtrl->GetPages(), tabCtrl->GetActivePage());
3247
3248 if (idx != -1)
3249 {
3250 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl->GetId());
3251 e.SetSelection(idx);
3252 e.SetOldSelection(tabCtrl->GetActivePage());
3253 e.SetEventObject(tabCtrl);
3254 GetEventHandler()->ProcessEvent(e);
3255
3256 return true;
3257 }
3258 else
3259 return false;
3260 }
3261
3262 void wxAuiNotebook::DoThaw()
3263 {
3264 DoSizing();
3265
3266 wxBookCtrlBase::DoThaw();
3267 }
3268
3269 void wxAuiNotebook::SetPageSize (const wxSize& WXUNUSED(size))
3270 {
3271 wxFAIL_MSG("Not implemented for wxAuiNotebook");
3272 }
3273
3274 int wxAuiNotebook::HitTest (const wxPoint& WXUNUSED(pt), long* WXUNUSED(flags)) const
3275 {
3276 wxFAIL_MSG("Not implemented for wxAuiNotebook");
3277 return wxNOT_FOUND;
3278 }
3279
3280 int wxAuiNotebook::GetPageImage(size_t WXUNUSED(n)) const
3281 {
3282 wxFAIL_MSG("Not implemented for wxAuiNotebook");
3283 return -1;
3284 }
3285
3286 bool wxAuiNotebook::SetPageImage(size_t n, int imageId)
3287 {
3288 return SetPageBitmap(n, GetImageList()->GetBitmap(imageId));
3289 }
3290
3291 int wxAuiNotebook::ChangeSelection(size_t n)
3292 {
3293 return DoModifySelection(n, false);
3294 }
3295
3296 bool wxAuiNotebook::AddPage(wxWindow *page, const wxString &text, bool select,
3297 int imageId)
3298 {
3299 if(HasImageList())
3300 {
3301 return AddPage(page, text, select, GetImageList()->GetBitmap(imageId));
3302 }
3303 else
3304 {
3305 return AddPage(page, text, select, wxNullBitmap);
3306 }
3307 }
3308
3309 bool wxAuiNotebook::DeleteAllPages()
3310 {
3311 size_t count = GetPageCount();
3312 for(size_t i = 0; i < count; i++)
3313 {
3314 DeletePage(0);
3315 }
3316 return true;
3317 }
3318
3319 bool wxAuiNotebook::InsertPage(size_t index, wxWindow *page,
3320 const wxString &text, bool select,
3321 int imageId)
3322 {
3323 if(HasImageList())
3324 {
3325 return InsertPage(index, page, text, select,
3326 GetImageList()->GetBitmap(imageId));
3327 }
3328 else
3329 {
3330 return InsertPage(index, page, text, select, wxNullBitmap);
3331 }
3332 }
3333
3334 int wxAuiNotebook::DoModifySelection(size_t n, bool events)
3335 {
3336 wxWindow* wnd = m_tabs.GetWindowFromIdx(n);
3337 if (!wnd)
3338 return m_curPage;
3339
3340 // don't change the page unless necessary;
3341 // however, clicking again on a tab should give it the focus.
3342 if ((int)n == m_curPage)
3343 {
3344 wxAuiTabCtrl* ctrl;
3345 int ctrl_idx;
3346 if (FindTab(wnd, &ctrl, &ctrl_idx))
3347 {
3348 if (FindFocus() != ctrl)
3349 ctrl->SetFocus();
3350 }
3351 return m_curPage;
3352 }
3353
3354 bool vetoed = false;
3355
3356 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
3357
3358 if(events)
3359 {
3360 evt.SetSelection(n);
3361 evt.SetOldSelection(m_curPage);
3362 evt.SetEventObject(this);
3363 GetEventHandler()->ProcessEvent(evt);
3364 vetoed = !evt.IsAllowed();
3365 }
3366
3367 if (!vetoed)
3368 {
3369 int old_curpage = m_curPage;
3370 m_curPage = n;
3371
3372 // program allows the page change
3373 if(events)
3374 {
3375 evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
3376 (void)GetEventHandler()->ProcessEvent(evt);
3377 }
3378
3379
3380 wxAuiTabCtrl* ctrl;
3381 int ctrl_idx;
3382 if (FindTab(wnd, &ctrl, &ctrl_idx))
3383 {
3384 m_tabs.SetActivePage(wnd);
3385
3386 ctrl->SetActivePage(ctrl_idx);
3387 DoSizing();
3388 ctrl->DoShowHide();
3389
3390 ctrl->MakeTabVisible(ctrl_idx, ctrl);
3391
3392 // set fonts
3393 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3394 size_t i, pane_count = all_panes.GetCount();
3395 for (i = 0; i < pane_count; ++i)
3396 {
3397 wxAuiPaneInfo& pane = all_panes.Item(i);
3398 if (pane.name == wxT("dummy"))
3399 continue;
3400 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
3401 if (tabctrl != ctrl)
3402 tabctrl->SetSelectedFont(m_normalFont);
3403 else
3404 tabctrl->SetSelectedFont(m_selectedFont);
3405 tabctrl->Refresh();
3406 }
3407
3408 // Set the focus to the page if we're not currently focused on the tab.
3409 // This is Firefox-like behaviour.
3410 if (wnd->IsShownOnScreen() && FindFocus() != ctrl)
3411 wnd->SetFocus();
3412
3413 return old_curpage;
3414 }
3415 }
3416
3417 return m_curPage;
3418 }
3419
3420
3421 #endif // wxUSE_AUI
wxWidgets (Impactor)