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