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