]> git.saurik.com Git - wxWidgets.git/blob - src/aui/auibook.cpp
projects / wxWidgets.git / blob
? search:


32b1401416614f9b95696cb62cfd1fd2a6bfd849
[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 #include "wx/renderer.h"
35
36 #ifdef __WXMAC__
37 #include "wx/osx/private.h"
38 #endif
39
40 #include "wx/arrimpl.cpp"
41 WX_DEFINE_OBJARRAY(wxAuiNotebookPageArray)
42 WX_DEFINE_OBJARRAY(wxAuiTabContainerButtonArray)
43
44 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, wxAuiNotebookEvent);
45 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, wxAuiNotebookEvent);
46 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, wxAuiNotebookEvent);
47 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, wxAuiNotebookEvent);
48 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, wxAuiNotebookEvent);
49 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, wxAuiNotebookEvent);
50 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, wxAuiNotebookEvent);
51 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, wxAuiNotebookEvent);
52 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, wxAuiNotebookEvent);
53 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, wxAuiNotebookEvent);
54 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, wxAuiNotebookEvent);
55 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, wxAuiNotebookEvent);
56 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, wxAuiNotebookEvent);
57 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, wxAuiNotebookEvent);
58 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, wxAuiNotebookEvent);
59 wxDEFINE_EVENT(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, wxAuiNotebookEvent);
60
61 IMPLEMENT_CLASS(wxAuiNotebook, wxControl)
62 IMPLEMENT_CLASS(wxAuiTabCtrl, wxControl)
63 IMPLEMENT_DYNAMIC_CLASS(wxAuiNotebookEvent, wxBookCtrlEvent)
64
65
66
67
68
69 // these functions live in dockart.cpp -- they'll eventually
70 // be moved to a new utility cpp file
71
72 wxBitmap wxAuiBitmapFromBits(const unsigned char bits[], int w, int h,
73 const wxColour& color);
74
75 wxString wxAuiChopText(wxDC& dc, const wxString& text, int max_size);
76
77 static void DrawButtons(wxDC& dc,
78 const wxRect& _rect,
79 const wxBitmap& bmp,
80 const wxColour& bkcolour,
81 int button_state)
82 {
83 wxRect rect = _rect;
84
85 if (button_state == wxAUI_BUTTON_STATE_PRESSED)
86 {
87 rect.x++;
88 rect.y++;
89 }
90
91 if (button_state == wxAUI_BUTTON_STATE_HOVER ||
92 button_state == wxAUI_BUTTON_STATE_PRESSED)
93 {
94 dc.SetBrush(wxBrush(bkcolour.ChangeLightness(120)));
95 dc.SetPen(wxPen(bkcolour.ChangeLightness(75)));
96
97 // draw the background behind the button
98 dc.DrawRectangle(rect.x, rect.y, 15, 15);
99 }
100
101 // draw the button itself
102 dc.DrawBitmap(bmp, rect.x, rect.y, true);
103 }
104
105 static void IndentPressedBitmap(wxRect* rect, int button_state)
106 {
107 if (button_state == wxAUI_BUTTON_STATE_PRESSED)
108 {
109 rect->x++;
110 rect->y++;
111 }
112 }
113
114
115
116 // -- GUI helper classes and functions --
117
118 class wxAuiCommandCapture : public wxEvtHandler
119 {
120 public:
121
122 wxAuiCommandCapture() { m_lastId = 0; }
123 int GetCommandId() const { return m_lastId; }
124
125 bool ProcessEvent(wxEvent& evt)
126 {
127 if (evt.GetEventType() == wxEVT_COMMAND_MENU_SELECTED)
128 {
129 m_lastId = evt.GetId();
130 return true;
131 }
132
133 if (GetNextHandler())
134 return GetNextHandler()->ProcessEvent(evt);
135
136 return false;
137 }
138
139 private:
140 int m_lastId;
141 };
142
143
144 // -- bitmaps --
145
146 #if defined( __WXMAC__ )
147 static const unsigned char close_bits[]={
148 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0xFE, 0x03, 0xF8, 0x01, 0xF0, 0x19, 0xF3,
149 0xB8, 0xE3, 0xF0, 0xE1, 0xE0, 0xE0, 0xF0, 0xE1, 0xB8, 0xE3, 0x19, 0xF3,
150 0x01, 0xF0, 0x03, 0xF8, 0x0F, 0xFE, 0xFF, 0xFF };
151 #elif defined( __WXGTK__)
152 static const unsigned char close_bits[]={
153 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xfb, 0xef, 0xdb, 0xed, 0x8b, 0xe8,
154 0x1b, 0xec, 0x3b, 0xee, 0x1b, 0xec, 0x8b, 0xe8, 0xdb, 0xed, 0xfb, 0xef,
155 0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
156 #else
157 static const unsigned char close_bits[]={
158 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe7, 0xf3, 0xcf, 0xf9,
159 0x9f, 0xfc, 0x3f, 0xfe, 0x3f, 0xfe, 0x9f, 0xfc, 0xcf, 0xf9, 0xe7, 0xf3,
160 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
161 #endif
162
163 static const unsigned char left_bits[] = {
164 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0xfe, 0x3f, 0xfe,
165 0x1f, 0xfe, 0x0f, 0xfe, 0x1f, 0xfe, 0x3f, 0xfe, 0x7f, 0xfe, 0xff, 0xfe,
166 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
167
168 static const unsigned char right_bits[] = {
169 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdf, 0xff, 0x9f, 0xff, 0x1f, 0xff,
170 0x1f, 0xfe, 0x1f, 0xfc, 0x1f, 0xfe, 0x1f, 0xff, 0x9f, 0xff, 0xdf, 0xff,
171 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
172
173 static const unsigned char list_bits[] = {
174 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
175 0x0f, 0xf8, 0xff, 0xff, 0x0f, 0xf8, 0x1f, 0xfc, 0x3f, 0xfe, 0x7f, 0xff,
176 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
177
178
179
180
181
182
183 // -- wxAuiDefaultTabArt class implementation --
184
185 wxAuiDefaultTabArt::wxAuiDefaultTabArt()
186 {
187 m_normalFont = *wxNORMAL_FONT;
188 m_selectedFont = *wxNORMAL_FONT;
189 m_selectedFont.SetWeight(wxBOLD);
190 m_measuringFont = m_selectedFont;
191
192 m_fixedTabWidth = 100;
193 m_tabCtrlHeight = 0;
194
195 #if defined( __WXMAC__ ) && wxOSX_USE_COCOA_OR_CARBON
196 wxColor baseColour = wxColour( wxMacCreateCGColorFromHITheme(kThemeBrushToolbarBackground));
197 #else
198 wxColor baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
199 #endif
200
201 // the baseColour is too pale to use as our base colour,
202 // so darken it a bit --
203 if ((255-baseColour.Red()) +
204 (255-baseColour.Green()) +
205 (255-baseColour.Blue()) < 60)
206 {
207 baseColour = baseColour.ChangeLightness(92);
208 }
209
210 m_activeColour = baseColour;
211 m_baseColour = baseColour;
212 wxColor borderColour = baseColour.ChangeLightness(75);
213
214 m_borderPen = wxPen(borderColour);
215 m_baseColourPen = wxPen(m_baseColour);
216 m_baseColourBrush = wxBrush(m_baseColour);
217
218 m_activeCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
219 m_disabledCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
220
221 m_activeLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
222 m_disabledLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
223
224 m_activeRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
225 m_disabledRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
226
227 m_activeWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
228 m_disabledWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
229
230 m_flags = 0;
231 }
232
233 wxAuiDefaultTabArt::~wxAuiDefaultTabArt()
234 {
235 }
236
237 wxAuiTabArt* wxAuiDefaultTabArt::Clone()
238 {
239 return new wxAuiDefaultTabArt(*this);
240 }
241
242 void wxAuiDefaultTabArt::SetFlags(unsigned int flags)
243 {
244 m_flags = flags;
245 }
246
247 void wxAuiDefaultTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
248 size_t tab_count)
249 {
250 m_fixedTabWidth = 100;
251
252 int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
253
254 if (m_flags & wxAUI_NB_CLOSE_BUTTON)
255 tot_width -= m_activeCloseBmp.GetWidth();
256 if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
257 tot_width -= m_activeWindowListBmp.GetWidth();
258
259 if (tab_count > 0)
260 {
261 m_fixedTabWidth = tot_width/(int)tab_count;
262 }
263
264
265 if (m_fixedTabWidth < 100)
266 m_fixedTabWidth = 100;
267
268 if (m_fixedTabWidth > tot_width/2)
269 m_fixedTabWidth = tot_width/2;
270
271 if (m_fixedTabWidth > 220)
272 m_fixedTabWidth = 220;
273
274 m_tabCtrlHeight = tab_ctrl_size.y;
275 }
276
277
278 void wxAuiDefaultTabArt::DrawBackground(wxDC& dc,
279 wxWindow* WXUNUSED(wnd),
280 const wxRect& rect)
281 {
282 // draw background
283
284 wxColor top_color = m_baseColour.ChangeLightness(90);
285 wxColor bottom_color = m_baseColour.ChangeLightness(170);
286 wxRect r;
287
288 if (m_flags &wxAUI_NB_BOTTOM)
289 r = wxRect(rect.x, rect.y, rect.width+2, rect.height);
290 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
291 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
292 else //for wxAUI_NB_TOP
293 r = wxRect(rect.x, rect.y, rect.width+2, rect.height-3);
294
295 dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
296
297
298 // draw base lines
299
300 dc.SetPen(m_borderPen);
301 int y = rect.GetHeight();
302 int w = rect.GetWidth();
303
304 if (m_flags &wxAUI_NB_BOTTOM)
305 {
306 dc.SetBrush(wxBrush(bottom_color));
307 dc.DrawRectangle(-1, 0, w+2, 4);
308 }
309 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
310 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
311 else //for wxAUI_NB_TOP
312 {
313 dc.SetBrush(m_baseColourBrush);
314 dc.DrawRectangle(-1, y-4, w+2, 4);
315 }
316 }
317
318
319 // DrawTab() draws an individual tab.
320 //
321 // dc - output dc
322 // in_rect - rectangle the tab should be confined to
323 // caption - tab's caption
324 // active - whether or not the tab is active
325 // out_rect - actual output rectangle
326 // x_extent - the advance x; where the next tab should start
327
328 void wxAuiDefaultTabArt::DrawTab(wxDC& dc,
329 wxWindow* wnd,
330 const wxAuiNotebookPage& page,
331 const wxRect& in_rect,
332 int close_button_state,
333 wxRect* out_tab_rect,
334 wxRect* out_button_rect,
335 int* x_extent)
336 {
337 wxCoord normal_textx, normal_texty;
338 wxCoord selected_textx, selected_texty;
339 wxCoord texty;
340
341 // if the caption is empty, measure some temporary text
342 wxString caption = page.caption;
343 if (caption.empty())
344 caption = wxT("Xj");
345
346 dc.SetFont(m_selectedFont);
347 dc.GetTextExtent(caption, &selected_textx, &selected_texty);
348
349 dc.SetFont(m_normalFont);
350 dc.GetTextExtent(caption, &normal_textx, &normal_texty);
351
352 // figure out the size of the tab
353 wxSize tab_size = GetTabSize(dc,
354 wnd,
355 page.caption,
356 page.bitmap,
357 page.active,
358 close_button_state,
359 x_extent);
360
361 wxCoord tab_height = m_tabCtrlHeight - 3;
362 wxCoord tab_width = tab_size.x;
363 wxCoord tab_x = in_rect.x;
364 wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
365
366
367 caption = page.caption;
368
369
370 // select pen, brush and font for the tab to be drawn
371
372 if (page.active)
373 {
374 dc.SetFont(m_selectedFont);
375 texty = selected_texty;
376 }
377 else
378 {
379 dc.SetFont(m_normalFont);
380 texty = normal_texty;
381 }
382
383
384 // create points that will make the tab outline
385
386 int clip_width = tab_width;
387 if (tab_x + clip_width > in_rect.x + in_rect.width)
388 clip_width = (in_rect.x + in_rect.width) - tab_x;
389
390 /*
391 wxPoint clip_points[6];
392 clip_points[0] = wxPoint(tab_x, tab_y+tab_height-3);
393 clip_points[1] = wxPoint(tab_x, tab_y+2);
394 clip_points[2] = wxPoint(tab_x+2, tab_y);
395 clip_points[3] = wxPoint(tab_x+clip_width-1, tab_y);
396 clip_points[4] = wxPoint(tab_x+clip_width+1, tab_y+2);
397 clip_points[5] = wxPoint(tab_x+clip_width+1, tab_y+tab_height-3);
398
399 // FIXME: these ports don't provide wxRegion ctor from array of points
400 #if !defined(__WXDFB__) && !defined(__WXCOCOA__)
401 // set the clipping region for the tab --
402 wxRegion clipping_region(WXSIZEOF(clip_points), clip_points);
403 dc.SetClippingRegion(clipping_region);
404 #endif // !wxDFB && !wxCocoa
405 */
406 // since the above code above doesn't play well with WXDFB or WXCOCOA,
407 // we'll just use a rectangle for the clipping region for now --
408 dc.SetClippingRegion(tab_x, tab_y, clip_width+1, tab_height-3);
409
410
411 wxPoint border_points[6];
412 if (m_flags &wxAUI_NB_BOTTOM)
413 {
414 border_points[0] = wxPoint(tab_x, tab_y);
415 border_points[1] = wxPoint(tab_x, tab_y+tab_height-6);
416 border_points[2] = wxPoint(tab_x+2, tab_y+tab_height-4);
417 border_points[3] = wxPoint(tab_x+tab_width-2, tab_y+tab_height-4);
418 border_points[4] = wxPoint(tab_x+tab_width, tab_y+tab_height-6);
419 border_points[5] = wxPoint(tab_x+tab_width, tab_y);
420 }
421 else //if (m_flags & wxAUI_NB_TOP) {}
422 {
423 border_points[0] = wxPoint(tab_x, tab_y+tab_height-4);
424 border_points[1] = wxPoint(tab_x, tab_y+2);
425 border_points[2] = wxPoint(tab_x+2, tab_y);
426 border_points[3] = wxPoint(tab_x+tab_width-2, tab_y);
427 border_points[4] = wxPoint(tab_x+tab_width, tab_y+2);
428 border_points[5] = wxPoint(tab_x+tab_width, tab_y+tab_height-4);
429 }
430 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
431 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
432
433 int drawn_tab_yoff = border_points[1].y;
434 int drawn_tab_height = border_points[0].y - border_points[1].y;
435
436
437 if (page.active)
438 {
439 // draw active tab
440
441 // draw base background color
442 wxRect r(tab_x, tab_y, tab_width, tab_height);
443 dc.SetPen(wxPen(m_activeColour));
444 dc.SetBrush(wxBrush(m_activeColour));
445 dc.DrawRectangle(r.x+1, r.y+1, r.width-1, r.height-4);
446
447 // this white helps fill out the gradient at the top of the tab
448 dc.SetPen(*wxWHITE_PEN);
449 dc.SetBrush(*wxWHITE_BRUSH);
450 dc.DrawRectangle(r.x+2, r.y+1, r.width-3, r.height-4);
451
452 // these two points help the rounded corners appear more antialiased
453 dc.SetPen(wxPen(m_activeColour));
454 dc.DrawPoint(r.x+2, r.y+1);
455 dc.DrawPoint(r.x+r.width-2, r.y+1);
456
457 // set rectangle down a bit for gradient drawing
458 r.SetHeight(r.GetHeight()/2);
459 r.x += 2;
460 r.width -= 3;
461 r.y += r.height;
462 r.y -= 2;
463
464 // draw gradient background
465 wxColor top_color = *wxWHITE;
466 wxColor bottom_color = m_activeColour;
467 dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
468 }
469 else
470 {
471 // draw inactive tab
472
473 wxRect r(tab_x, tab_y+1, tab_width, tab_height-3);
474
475 // start the gradent up a bit and leave the inside border inset
476 // by a pixel for a 3D look. Only the top half of the inactive
477 // tab will have a slight gradient
478 r.x += 3;
479 r.y++;
480 r.width -= 4;
481 r.height /= 2;
482 r.height--;
483
484 // -- draw top gradient fill for glossy look
485 wxColor top_color = m_baseColour;
486 wxColor bottom_color = top_color.ChangeLightness(160);
487 dc.GradientFillLinear(r, bottom_color, top_color, wxNORTH);
488
489 r.y += r.height;
490 r.y--;
491
492 // -- draw bottom fill for glossy look
493 top_color = m_baseColour;
494 bottom_color = m_baseColour;
495 dc.GradientFillLinear(r, top_color, bottom_color, wxSOUTH);
496 }
497
498 // draw tab outline
499 dc.SetPen(m_borderPen);
500 dc.SetBrush(*wxTRANSPARENT_BRUSH);
501 dc.DrawPolygon(WXSIZEOF(border_points), border_points);
502
503 // there are two horizontal grey lines at the bottom of the tab control,
504 // this gets rid of the top one of those lines in the tab control
505 if (page.active)
506 {
507 if (m_flags &wxAUI_NB_BOTTOM)
508 dc.SetPen(wxPen(m_baseColour.ChangeLightness(170)));
509 // TODO: else if (m_flags &wxAUI_NB_LEFT) {}
510 // TODO: else if (m_flags &wxAUI_NB_RIGHT) {}
511 else //for wxAUI_NB_TOP
512 dc.SetPen(m_baseColourPen);
513 dc.DrawLine(border_points[0].x+1,
514 border_points[0].y,
515 border_points[5].x,
516 border_points[5].y);
517 }
518
519
520 int text_offset = tab_x + 8;
521 int close_button_width = 0;
522 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
523 {
524 close_button_width = m_activeCloseBmp.GetWidth();
525 }
526
527 int bitmap_offset = 0;
528 if (page.bitmap.IsOk())
529 {
530 bitmap_offset = tab_x + 8;
531
532 // draw bitmap
533 dc.DrawBitmap(page.bitmap,
534 bitmap_offset,
535 drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
536 true);
537
538 text_offset = bitmap_offset + page.bitmap.GetWidth();
539 text_offset += 3; // bitmap padding
540
541 }
542 else
543 {
544 text_offset = tab_x + 8;
545 }
546
547
548 wxString draw_text = wxAuiChopText(dc,
549 caption,
550 tab_width - (text_offset-tab_x) - close_button_width);
551
552 // draw tab text
553 dc.DrawText(draw_text,
554 text_offset,
555 drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1);
556
557 // draw focus rectangle
558 if (page.active && (wnd->FindFocus() == wnd))
559 {
560 wxRect focusRectText(text_offset, (drawn_tab_yoff + (drawn_tab_height)/2 - (texty/2) - 1),
561 selected_textx, selected_texty);
562
563 wxRect focusRect;
564 wxRect focusRectBitmap;
565
566 if (page.bitmap.IsOk())
567 focusRectBitmap = wxRect(bitmap_offset, drawn_tab_yoff + (drawn_tab_height/2) - (page.bitmap.GetHeight()/2),
568 page.bitmap.GetWidth(), page.bitmap.GetHeight());
569
570 if (page.bitmap.IsOk() && draw_text.IsEmpty())
571 focusRect = focusRectBitmap;
572 else if (!page.bitmap.IsOk() && !draw_text.IsEmpty())
573 focusRect = focusRectText;
574 else if (page.bitmap.IsOk() && !draw_text.IsEmpty())
575 focusRect = focusRectText.Union(focusRectBitmap);
576
577 focusRect.Inflate(2, 2);
578
579 wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
580 }
581
582 // draw close button if necessary
583 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
584 {
585 wxBitmap bmp = m_disabledCloseBmp;
586
587 if (close_button_state == wxAUI_BUTTON_STATE_HOVER ||
588 close_button_state == wxAUI_BUTTON_STATE_PRESSED)
589 {
590 bmp = m_activeCloseBmp;
591 }
592
593 int offsetY = tab_y-1;
594 if (m_flags & wxAUI_NB_BOTTOM)
595 offsetY = 1;
596
597 wxRect rect(tab_x + tab_width - close_button_width - 1,
598 offsetY + (tab_height/2) - (bmp.GetHeight()/2),
599 close_button_width,
600 tab_height);
601
602 IndentPressedBitmap(&rect, close_button_state);
603 dc.DrawBitmap(bmp, rect.x, rect.y, true);
604
605 *out_button_rect = rect;
606 }
607
608 *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
609
610 dc.DestroyClippingRegion();
611 }
612
613 int wxAuiDefaultTabArt::GetIndentSize()
614 {
615 return 5;
616 }
617
618 wxSize wxAuiDefaultTabArt::GetTabSize(wxDC& dc,
619 wxWindow* WXUNUSED(wnd),
620 const wxString& caption,
621 const wxBitmap& bitmap,
622 bool WXUNUSED(active),
623 int close_button_state,
624 int* x_extent)
625 {
626 wxCoord measured_textx, measured_texty, tmp;
627
628 dc.SetFont(m_measuringFont);
629 dc.GetTextExtent(caption, &measured_textx, &measured_texty);
630
631 dc.GetTextExtent(wxT("ABCDEFXj"), &tmp, &measured_texty);
632
633 // add padding around the text
634 wxCoord tab_width = measured_textx;
635 wxCoord tab_height = measured_texty;
636
637 // if the close button is showing, add space for it
638 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
639 tab_width += m_activeCloseBmp.GetWidth() + 3;
640
641 // if there's a bitmap, add space for it
642 if (bitmap.IsOk())
643 {
644 tab_width += bitmap.GetWidth();
645 tab_width += 3; // right side bitmap padding
646 tab_height = wxMax(tab_height, bitmap.GetHeight());
647 }
648
649 // add padding
650 tab_width += 16;
651 tab_height += 10;
652
653 if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
654 {
655 tab_width = m_fixedTabWidth;
656 }
657
658 *x_extent = tab_width;
659
660 return wxSize(tab_width, tab_height);
661 }
662
663
664 void wxAuiDefaultTabArt::DrawButton(wxDC& dc,
665 wxWindow* WXUNUSED(wnd),
666 const wxRect& in_rect,
667 int bitmap_id,
668 int button_state,
669 int orientation,
670 wxRect* out_rect)
671 {
672 wxBitmap bmp;
673 wxRect rect;
674
675 switch (bitmap_id)
676 {
677 case wxAUI_BUTTON_CLOSE:
678 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
679 bmp = m_disabledCloseBmp;
680 else
681 bmp = m_activeCloseBmp;
682 break;
683 case wxAUI_BUTTON_LEFT:
684 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
685 bmp = m_disabledLeftBmp;
686 else
687 bmp = m_activeLeftBmp;
688 break;
689 case wxAUI_BUTTON_RIGHT:
690 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
691 bmp = m_disabledRightBmp;
692 else
693 bmp = m_activeRightBmp;
694 break;
695 case wxAUI_BUTTON_WINDOWLIST:
696 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
697 bmp = m_disabledWindowListBmp;
698 else
699 bmp = m_activeWindowListBmp;
700 break;
701 }
702
703
704 if (!bmp.IsOk())
705 return;
706
707 rect = in_rect;
708
709 if (orientation == wxLEFT)
710 {
711 rect.SetX(in_rect.x);
712 rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
713 rect.SetWidth(bmp.GetWidth());
714 rect.SetHeight(bmp.GetHeight());
715 }
716 else
717 {
718 rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
719 ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
720 bmp.GetWidth(), bmp.GetHeight());
721 }
722
723 IndentPressedBitmap(&rect, button_state);
724 dc.DrawBitmap(bmp, rect.x, rect.y, true);
725
726 *out_rect = rect;
727 }
728
729 int wxAuiDefaultTabArt::ShowDropDown(wxWindow* wnd,
730 const wxAuiNotebookPageArray& pages,
731 int /*active_idx*/)
732 {
733 wxMenu menuPopup;
734
735 size_t i, count = pages.GetCount();
736 for (i = 0; i < count; ++i)
737 {
738 const wxAuiNotebookPage& page = pages.Item(i);
739 wxString caption = page.caption;
740
741 // if there is no caption, make it a space. This will prevent
742 // an assert in the menu code.
743 if (caption.IsEmpty())
744 caption = wxT(" ");
745
746 wxMenuItem* item = new wxMenuItem(NULL, 1000+i, caption);
747 if (page.bitmap.IsOk())
748 item->SetBitmap(page.bitmap);
749 menuPopup.Append(item);
750 }
751
752 // find out where to put the popup menu of window items
753 wxPoint pt = ::wxGetMousePosition();
754 pt = wnd->ScreenToClient(pt);
755
756 // find out the screen coordinate at the bottom of the tab ctrl
757 wxRect cli_rect = wnd->GetClientRect();
758 pt.y = cli_rect.y + cli_rect.height;
759
760 wxAuiCommandCapture* cc = new wxAuiCommandCapture;
761 wnd->PushEventHandler(cc);
762 wnd->PopupMenu(&menuPopup, pt);
763 int command = cc->GetCommandId();
764 wnd->PopEventHandler(true);
765
766 if (command >= 1000)
767 return command-1000;
768
769 return -1;
770 }
771
772 int wxAuiDefaultTabArt::GetBestTabCtrlSize(wxWindow* wnd,
773 const wxAuiNotebookPageArray& pages,
774 const wxSize& requiredBmp_size)
775 {
776 wxClientDC dc(wnd);
777 dc.SetFont(m_measuringFont);
778
779 // sometimes a standard bitmap size needs to be enforced, especially
780 // if some tabs have bitmaps and others don't. This is important because
781 // it prevents the tab control from resizing when tabs are added.
782 wxBitmap measureBmp;
783 if (requiredBmp_size.IsFullySpecified())
784 {
785 measureBmp.Create(requiredBmp_size.x,
786 requiredBmp_size.y);
787 }
788
789
790 int max_y = 0;
791 size_t i, page_count = pages.GetCount();
792 for (i = 0; i < page_count; ++i)
793 {
794 wxAuiNotebookPage& page = pages.Item(i);
795
796 wxBitmap bmp;
797 if (measureBmp.IsOk())
798 bmp = measureBmp;
799 else
800 bmp = page.bitmap;
801
802 // we don't use the caption text because we don't
803 // want tab heights to be different in the case
804 // of a very short piece of text on one tab and a very
805 // tall piece of text on another tab
806 int x_ext = 0;
807 wxSize s = GetTabSize(dc,
808 wnd,
809 wxT("ABCDEFGHIj"),
810 bmp,
811 true,
812 wxAUI_BUTTON_STATE_HIDDEN,
813 &x_ext);
814
815 max_y = wxMax(max_y, s.y);
816 }
817
818 return max_y+2;
819 }
820
821 void wxAuiDefaultTabArt::SetNormalFont(const wxFont& font)
822 {
823 m_normalFont = font;
824 }
825
826 void wxAuiDefaultTabArt::SetSelectedFont(const wxFont& font)
827 {
828 m_selectedFont = font;
829 }
830
831 void wxAuiDefaultTabArt::SetMeasuringFont(const wxFont& font)
832 {
833 m_measuringFont = font;
834 }
835
836 void wxAuiDefaultTabArt::SetColour(const wxColour& colour)
837 {
838 m_baseColour = colour;
839 m_borderPen = wxPen(m_baseColour.ChangeLightness(75));
840 m_baseColourPen = wxPen(m_baseColour);
841 m_baseColourBrush = wxBrush(m_baseColour);
842 }
843
844 void wxAuiDefaultTabArt::SetActiveColour(const wxColour& colour)
845 {
846 m_activeColour = colour;
847 }
848
849 // -- wxAuiSimpleTabArt class implementation --
850
851 wxAuiSimpleTabArt::wxAuiSimpleTabArt()
852 {
853 m_normalFont = *wxNORMAL_FONT;
854 m_selectedFont = *wxNORMAL_FONT;
855 m_selectedFont.SetWeight(wxBOLD);
856 m_measuringFont = m_selectedFont;
857
858 m_flags = 0;
859 m_fixedTabWidth = 100;
860
861 wxColour baseColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
862
863 wxColour backgroundColour = baseColour;
864 wxColour normaltabColour = baseColour;
865 wxColour selectedtabColour = *wxWHITE;
866
867 m_bkBrush = wxBrush(backgroundColour);
868 m_normalBkBrush = wxBrush(normaltabColour);
869 m_normalBkPen = wxPen(normaltabColour);
870 m_selectedBkBrush = wxBrush(selectedtabColour);
871 m_selectedBkPen = wxPen(selectedtabColour);
872
873 m_activeCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, *wxBLACK);
874 m_disabledCloseBmp = wxAuiBitmapFromBits(close_bits, 16, 16, wxColour(128,128,128));
875
876 m_activeLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, *wxBLACK);
877 m_disabledLeftBmp = wxAuiBitmapFromBits(left_bits, 16, 16, wxColour(128,128,128));
878
879 m_activeRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, *wxBLACK);
880 m_disabledRightBmp = wxAuiBitmapFromBits(right_bits, 16, 16, wxColour(128,128,128));
881
882 m_activeWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, *wxBLACK);
883 m_disabledWindowListBmp = wxAuiBitmapFromBits(list_bits, 16, 16, wxColour(128,128,128));
884
885 }
886
887 wxAuiSimpleTabArt::~wxAuiSimpleTabArt()
888 {
889 }
890
891 wxAuiTabArt* wxAuiSimpleTabArt::Clone()
892 {
893 return new wxAuiSimpleTabArt(*this);
894 }
895
896 void wxAuiSimpleTabArt::SetFlags(unsigned int flags)
897 {
898 m_flags = flags;
899 }
900
901 void wxAuiSimpleTabArt::SetSizingInfo(const wxSize& tab_ctrl_size,
902 size_t tab_count)
903 {
904 m_fixedTabWidth = 100;
905
906 int tot_width = (int)tab_ctrl_size.x - GetIndentSize() - 4;
907
908 if (m_flags & wxAUI_NB_CLOSE_BUTTON)
909 tot_width -= m_activeCloseBmp.GetWidth();
910 if (m_flags & wxAUI_NB_WINDOWLIST_BUTTON)
911 tot_width -= m_activeWindowListBmp.GetWidth();
912
913 if (tab_count > 0)
914 {
915 m_fixedTabWidth = tot_width/(int)tab_count;
916 }
917
918
919 if (m_fixedTabWidth < 100)
920 m_fixedTabWidth = 100;
921
922 if (m_fixedTabWidth > tot_width/2)
923 m_fixedTabWidth = tot_width/2;
924
925 if (m_fixedTabWidth > 220)
926 m_fixedTabWidth = 220;
927 }
928
929 void wxAuiSimpleTabArt::SetColour(const wxColour& colour)
930 {
931 m_bkBrush = wxBrush(colour);
932 m_normalBkBrush = wxBrush(colour);
933 m_normalBkPen = wxPen(colour);
934 }
935
936 void wxAuiSimpleTabArt::SetActiveColour(const wxColour& colour)
937 {
938 m_selectedBkBrush = wxBrush(colour);
939 m_selectedBkPen = wxPen(colour);
940 }
941
942 void wxAuiSimpleTabArt::DrawBackground(wxDC& dc,
943 wxWindow* WXUNUSED(wnd),
944 const wxRect& rect)
945 {
946 // draw background
947 dc.SetBrush(m_bkBrush);
948 dc.SetPen(*wxTRANSPARENT_PEN);
949 dc.DrawRectangle(-1, -1, rect.GetWidth()+2, rect.GetHeight()+2);
950
951 // draw base line
952 dc.SetPen(*wxGREY_PEN);
953 dc.DrawLine(0, rect.GetHeight()-1, rect.GetWidth(), rect.GetHeight()-1);
954 }
955
956
957 // DrawTab() draws an individual tab.
958 //
959 // dc - output dc
960 // in_rect - rectangle the tab should be confined to
961 // caption - tab's caption
962 // active - whether or not the tab is active
963 // out_rect - actual output rectangle
964 // x_extent - the advance x; where the next tab should start
965
966 void wxAuiSimpleTabArt::DrawTab(wxDC& dc,
967 wxWindow* wnd,
968 const wxAuiNotebookPage& page,
969 const wxRect& in_rect,
970 int close_button_state,
971 wxRect* out_tab_rect,
972 wxRect* out_button_rect,
973 int* x_extent)
974 {
975 wxCoord normal_textx, normal_texty;
976 wxCoord selected_textx, selected_texty;
977 wxCoord textx, texty;
978
979 // if the caption is empty, measure some temporary text
980 wxString caption = page.caption;
981 if (caption.empty())
982 caption = wxT("Xj");
983
984 dc.SetFont(m_selectedFont);
985 dc.GetTextExtent(caption, &selected_textx, &selected_texty);
986
987 dc.SetFont(m_normalFont);
988 dc.GetTextExtent(caption, &normal_textx, &normal_texty);
989
990 // figure out the size of the tab
991 wxSize tab_size = GetTabSize(dc,
992 wnd,
993 page.caption,
994 page.bitmap,
995 page.active,
996 close_button_state,
997 x_extent);
998
999 wxCoord tab_height = tab_size.y;
1000 wxCoord tab_width = tab_size.x;
1001 wxCoord tab_x = in_rect.x;
1002 wxCoord tab_y = in_rect.y + in_rect.height - tab_height;
1003
1004 caption = page.caption;
1005
1006 // select pen, brush and font for the tab to be drawn
1007
1008 if (page.active)
1009 {
1010 dc.SetPen(m_selectedBkPen);
1011 dc.SetBrush(m_selectedBkBrush);
1012 dc.SetFont(m_selectedFont);
1013 textx = selected_textx;
1014 texty = selected_texty;
1015 }
1016 else
1017 {
1018 dc.SetPen(m_normalBkPen);
1019 dc.SetBrush(m_normalBkBrush);
1020 dc.SetFont(m_normalFont);
1021 textx = normal_textx;
1022 texty = normal_texty;
1023 }
1024
1025
1026 // -- draw line --
1027
1028 wxPoint points[7];
1029 points[0].x = tab_x;
1030 points[0].y = tab_y + tab_height - 1;
1031 points[1].x = tab_x + tab_height - 3;
1032 points[1].y = tab_y + 2;
1033 points[2].x = tab_x + tab_height + 3;
1034 points[2].y = tab_y;
1035 points[3].x = tab_x + tab_width - 2;
1036 points[3].y = tab_y;
1037 points[4].x = tab_x + tab_width;
1038 points[4].y = tab_y + 2;
1039 points[5].x = tab_x + tab_width;
1040 points[5].y = tab_y + tab_height - 1;
1041 points[6] = points[0];
1042
1043 dc.SetClippingRegion(in_rect);
1044
1045 dc.DrawPolygon(WXSIZEOF(points) - 1, points);
1046
1047 dc.SetPen(*wxGREY_PEN);
1048
1049 //dc.DrawLines(active ? WXSIZEOF(points) - 1 : WXSIZEOF(points), points);
1050 dc.DrawLines(WXSIZEOF(points), points);
1051
1052
1053 int text_offset;
1054
1055 int close_button_width = 0;
1056 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1057 {
1058 close_button_width = m_activeCloseBmp.GetWidth();
1059 text_offset = tab_x + (tab_height/2) + ((tab_width-close_button_width)/2) - (textx/2);
1060 }
1061 else
1062 {
1063 text_offset = tab_x + (tab_height/3) + (tab_width/2) - (textx/2);
1064 }
1065
1066 // set minimum text offset
1067 if (text_offset < tab_x + tab_height)
1068 text_offset = tab_x + tab_height;
1069
1070 // chop text if necessary
1071 wxString draw_text = wxAuiChopText(dc,
1072 caption,
1073 tab_width - (text_offset-tab_x) - close_button_width);
1074
1075 // draw tab text
1076 dc.DrawText(draw_text,
1077 text_offset,
1078 (tab_y + tab_height)/2 - (texty/2) + 1);
1079
1080
1081 // draw focus rectangle
1082 if (page.active && (wnd->FindFocus() == wnd))
1083 {
1084 wxRect focusRect(text_offset, ((tab_y + tab_height)/2 - (texty/2) + 1),
1085 selected_textx, selected_texty);
1086
1087 focusRect.Inflate(2, 2);
1088
1089 wxRendererNative::Get().DrawFocusRect(wnd, dc, focusRect, 0);
1090 }
1091
1092 // draw close button if necessary
1093 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1094 {
1095 wxBitmap bmp;
1096 if (page.active)
1097 bmp = m_activeCloseBmp;
1098 else
1099 bmp = m_disabledCloseBmp;
1100
1101 wxRect rect(tab_x + tab_width - close_button_width - 1,
1102 tab_y + (tab_height/2) - (bmp.GetHeight()/2) + 1,
1103 close_button_width,
1104 tab_height - 1);
1105 DrawButtons(dc, rect, bmp, *wxWHITE, close_button_state);
1106
1107 *out_button_rect = rect;
1108 }
1109
1110
1111 *out_tab_rect = wxRect(tab_x, tab_y, tab_width, tab_height);
1112
1113 dc.DestroyClippingRegion();
1114 }
1115
1116 int wxAuiSimpleTabArt::GetIndentSize()
1117 {
1118 return 0;
1119 }
1120
1121 wxSize wxAuiSimpleTabArt::GetTabSize(wxDC& dc,
1122 wxWindow* WXUNUSED(wnd),
1123 const wxString& caption,
1124 const wxBitmap& WXUNUSED(bitmap),
1125 bool WXUNUSED(active),
1126 int close_button_state,
1127 int* x_extent)
1128 {
1129 wxCoord measured_textx, measured_texty;
1130
1131 dc.SetFont(m_measuringFont);
1132 dc.GetTextExtent(caption, &measured_textx, &measured_texty);
1133
1134 wxCoord tab_height = measured_texty + 4;
1135 wxCoord tab_width = measured_textx + tab_height + 5;
1136
1137 if (close_button_state != wxAUI_BUTTON_STATE_HIDDEN)
1138 tab_width += m_activeCloseBmp.GetWidth();
1139
1140 if (m_flags & wxAUI_NB_TAB_FIXED_WIDTH)
1141 {
1142 tab_width = m_fixedTabWidth;
1143 }
1144
1145 *x_extent = tab_width - (tab_height/2) - 1;
1146
1147 return wxSize(tab_width, tab_height);
1148 }
1149
1150
1151 void wxAuiSimpleTabArt::DrawButton(wxDC& dc,
1152 wxWindow* WXUNUSED(wnd),
1153 const wxRect& in_rect,
1154 int bitmap_id,
1155 int button_state,
1156 int orientation,
1157 wxRect* out_rect)
1158 {
1159 wxBitmap bmp;
1160 wxRect rect;
1161
1162 switch (bitmap_id)
1163 {
1164 case wxAUI_BUTTON_CLOSE:
1165 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1166 bmp = m_disabledCloseBmp;
1167 else
1168 bmp = m_activeCloseBmp;
1169 break;
1170 case wxAUI_BUTTON_LEFT:
1171 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1172 bmp = m_disabledLeftBmp;
1173 else
1174 bmp = m_activeLeftBmp;
1175 break;
1176 case wxAUI_BUTTON_RIGHT:
1177 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1178 bmp = m_disabledRightBmp;
1179 else
1180 bmp = m_activeRightBmp;
1181 break;
1182 case wxAUI_BUTTON_WINDOWLIST:
1183 if (button_state & wxAUI_BUTTON_STATE_DISABLED)
1184 bmp = m_disabledWindowListBmp;
1185 else
1186 bmp = m_activeWindowListBmp;
1187 break;
1188 }
1189
1190 if (!bmp.IsOk())
1191 return;
1192
1193 rect = in_rect;
1194
1195 if (orientation == wxLEFT)
1196 {
1197 rect.SetX(in_rect.x);
1198 rect.SetY(((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2));
1199 rect.SetWidth(bmp.GetWidth());
1200 rect.SetHeight(bmp.GetHeight());
1201 }
1202 else
1203 {
1204 rect = wxRect(in_rect.x + in_rect.width - bmp.GetWidth(),
1205 ((in_rect.y + in_rect.height)/2) - (bmp.GetHeight()/2),
1206 bmp.GetWidth(), bmp.GetHeight());
1207 }
1208
1209
1210 DrawButtons(dc, rect, bmp, *wxWHITE, button_state);
1211
1212 *out_rect = rect;
1213 }
1214
1215 int wxAuiSimpleTabArt::ShowDropDown(wxWindow* wnd,
1216 const wxAuiNotebookPageArray& pages,
1217 int active_idx)
1218 {
1219 wxMenu menuPopup;
1220
1221 size_t i, count = pages.GetCount();
1222 for (i = 0; i < count; ++i)
1223 {
1224 const wxAuiNotebookPage& page = pages.Item(i);
1225 menuPopup.AppendCheckItem(1000+i, page.caption);
1226 }
1227
1228 if (active_idx != -1)
1229 {
1230 menuPopup.Check(1000+active_idx, true);
1231 }
1232
1233 // find out where to put the popup menu of window
1234 // items. Subtract 100 for now to center the menu
1235 // a bit, until a better mechanism can be implemented
1236 wxPoint pt = ::wxGetMousePosition();
1237 pt = wnd->ScreenToClient(pt);
1238 if (pt.x < 100)
1239 pt.x = 0;
1240 else
1241 pt.x -= 100;
1242
1243 // find out the screen coordinate at the bottom of the tab ctrl
1244 wxRect cli_rect = wnd->GetClientRect();
1245 pt.y = cli_rect.y + cli_rect.height;
1246
1247 wxAuiCommandCapture* cc = new wxAuiCommandCapture;
1248 wnd->PushEventHandler(cc);
1249 wnd->PopupMenu(&menuPopup, pt);
1250 int command = cc->GetCommandId();
1251 wnd->PopEventHandler(true);
1252
1253 if (command >= 1000)
1254 return command-1000;
1255
1256 return -1;
1257 }
1258
1259 int wxAuiSimpleTabArt::GetBestTabCtrlSize(wxWindow* wnd,
1260 const wxAuiNotebookPageArray& WXUNUSED(pages),
1261 const wxSize& WXUNUSED(requiredBmp_size))
1262 {
1263 wxClientDC dc(wnd);
1264 dc.SetFont(m_measuringFont);
1265 int x_ext = 0;
1266 wxSize s = GetTabSize(dc,
1267 wnd,
1268 wxT("ABCDEFGHIj"),
1269 wxNullBitmap,
1270 true,
1271 wxAUI_BUTTON_STATE_HIDDEN,
1272 &x_ext);
1273 return s.y+3;
1274 }
1275
1276 void wxAuiSimpleTabArt::SetNormalFont(const wxFont& font)
1277 {
1278 m_normalFont = font;
1279 }
1280
1281 void wxAuiSimpleTabArt::SetSelectedFont(const wxFont& font)
1282 {
1283 m_selectedFont = font;
1284 }
1285
1286 void wxAuiSimpleTabArt::SetMeasuringFont(const wxFont& font)
1287 {
1288 m_measuringFont = font;
1289 }
1290
1291
1292
1293
1294 // -- wxAuiTabContainer class implementation --
1295
1296
1297 // wxAuiTabContainer is a class which contains information about each
1298 // tab. It also can render an entire tab control to a specified DC.
1299 // It's not a window class itself, because this code will be used by
1300 // the wxFrameMananger, where it is disadvantageous to have separate
1301 // windows for each tab control in the case of "docked tabs"
1302
1303 // A derived class, wxAuiTabCtrl, is an actual wxWindow-derived window
1304 // which can be used as a tab control in the normal sense.
1305
1306
1307 wxAuiTabContainer::wxAuiTabContainer()
1308 {
1309 m_tabOffset = 0;
1310 m_flags = 0;
1311 m_art = new wxAuiDefaultTabArt;
1312
1313 AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
1314 AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
1315 AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
1316 AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
1317 }
1318
1319 wxAuiTabContainer::~wxAuiTabContainer()
1320 {
1321 delete m_art;
1322 }
1323
1324 void wxAuiTabContainer::SetArtProvider(wxAuiTabArt* art)
1325 {
1326 delete m_art;
1327 m_art = art;
1328
1329 if (m_art)
1330 {
1331 m_art->SetFlags(m_flags);
1332 }
1333 }
1334
1335 wxAuiTabArt* wxAuiTabContainer::GetArtProvider() const
1336 {
1337 return m_art;
1338 }
1339
1340 void wxAuiTabContainer::SetFlags(unsigned int flags)
1341 {
1342 m_flags = flags;
1343
1344 // check for new close button settings
1345 RemoveButton(wxAUI_BUTTON_LEFT);
1346 RemoveButton(wxAUI_BUTTON_RIGHT);
1347 RemoveButton(wxAUI_BUTTON_WINDOWLIST);
1348 RemoveButton(wxAUI_BUTTON_CLOSE);
1349
1350
1351 if (flags & wxAUI_NB_SCROLL_BUTTONS)
1352 {
1353 AddButton(wxAUI_BUTTON_LEFT, wxLEFT);
1354 AddButton(wxAUI_BUTTON_RIGHT, wxRIGHT);
1355 }
1356
1357 if (flags & wxAUI_NB_WINDOWLIST_BUTTON)
1358 {
1359 AddButton(wxAUI_BUTTON_WINDOWLIST, wxRIGHT);
1360 }
1361
1362 if (flags & wxAUI_NB_CLOSE_BUTTON)
1363 {
1364 AddButton(wxAUI_BUTTON_CLOSE, wxRIGHT);
1365 }
1366
1367 if (m_art)
1368 {
1369 m_art->SetFlags(m_flags);
1370 }
1371 }
1372
1373 unsigned int wxAuiTabContainer::GetFlags() const
1374 {
1375 return m_flags;
1376 }
1377
1378
1379 void wxAuiTabContainer::SetNormalFont(const wxFont& font)
1380 {
1381 m_art->SetNormalFont(font);
1382 }
1383
1384 void wxAuiTabContainer::SetSelectedFont(const wxFont& font)
1385 {
1386 m_art->SetSelectedFont(font);
1387 }
1388
1389 void wxAuiTabContainer::SetMeasuringFont(const wxFont& font)
1390 {
1391 m_art->SetMeasuringFont(font);
1392 }
1393
1394 void wxAuiTabContainer::SetColour(const wxColour& colour)
1395 {
1396 m_art->SetColour(colour);
1397 }
1398
1399 void wxAuiTabContainer::SetActiveColour(const wxColour& colour)
1400 {
1401 m_art->SetActiveColour(colour);
1402 }
1403
1404 void wxAuiTabContainer::SetRect(const wxRect& rect)
1405 {
1406 m_rect = rect;
1407
1408 if (m_art)
1409 {
1410 m_art->SetSizingInfo(rect.GetSize(), m_pages.GetCount());
1411 }
1412 }
1413
1414 bool wxAuiTabContainer::AddPage(wxWindow* page,
1415 const wxAuiNotebookPage& info)
1416 {
1417 wxAuiNotebookPage page_info;
1418 page_info = info;
1419 page_info.window = page;
1420
1421 m_pages.Add(page_info);
1422
1423 // let the art provider know how many pages we have
1424 if (m_art)
1425 {
1426 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1427 }
1428
1429 return true;
1430 }
1431
1432 bool wxAuiTabContainer::InsertPage(wxWindow* page,
1433 const wxAuiNotebookPage& info,
1434 size_t idx)
1435 {
1436 wxAuiNotebookPage page_info;
1437 page_info = info;
1438 page_info.window = page;
1439
1440 if (idx >= m_pages.GetCount())
1441 m_pages.Add(page_info);
1442 else
1443 m_pages.Insert(page_info, idx);
1444
1445 // let the art provider know how many pages we have
1446 if (m_art)
1447 {
1448 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1449 }
1450
1451 return true;
1452 }
1453
1454 bool wxAuiTabContainer::MovePage(wxWindow* page,
1455 size_t new_idx)
1456 {
1457 int idx = GetIdxFromWindow(page);
1458 if (idx == -1)
1459 return false;
1460
1461 // get page entry, make a copy of it
1462 wxAuiNotebookPage p = GetPage(idx);
1463
1464 // remove old page entry
1465 RemovePage(page);
1466
1467 // insert page where it should be
1468 InsertPage(page, p, new_idx);
1469
1470 return true;
1471 }
1472
1473 bool wxAuiTabContainer::RemovePage(wxWindow* wnd)
1474 {
1475 size_t i, page_count = m_pages.GetCount();
1476 for (i = 0; i < page_count; ++i)
1477 {
1478 wxAuiNotebookPage& page = m_pages.Item(i);
1479 if (page.window == wnd)
1480 {
1481 m_pages.RemoveAt(i);
1482
1483 // let the art provider know how many pages we have
1484 if (m_art)
1485 {
1486 m_art->SetSizingInfo(m_rect.GetSize(), m_pages.GetCount());
1487 }
1488
1489 return true;
1490 }
1491 }
1492
1493 return false;
1494 }
1495
1496 bool wxAuiTabContainer::SetActivePage(wxWindow* wnd)
1497 {
1498 bool found = false;
1499
1500 size_t i, page_count = m_pages.GetCount();
1501 for (i = 0; i < page_count; ++i)
1502 {
1503 wxAuiNotebookPage& page = m_pages.Item(i);
1504 if (page.window == wnd)
1505 {
1506 page.active = true;
1507 found = true;
1508 }
1509 else
1510 {
1511 page.active = false;
1512 }
1513 }
1514
1515 return found;
1516 }
1517
1518 void wxAuiTabContainer::SetNoneActive()
1519 {
1520 size_t i, page_count = m_pages.GetCount();
1521 for (i = 0; i < page_count; ++i)
1522 {
1523 wxAuiNotebookPage& page = m_pages.Item(i);
1524 page.active = false;
1525 }
1526 }
1527
1528 bool wxAuiTabContainer::SetActivePage(size_t page)
1529 {
1530 if (page >= m_pages.GetCount())
1531 return false;
1532
1533 return SetActivePage(m_pages.Item(page).window);
1534 }
1535
1536 int wxAuiTabContainer::GetActivePage() const
1537 {
1538 size_t i, page_count = m_pages.GetCount();
1539 for (i = 0; i < page_count; ++i)
1540 {
1541 wxAuiNotebookPage& page = m_pages.Item(i);
1542 if (page.active)
1543 return i;
1544 }
1545
1546 return -1;
1547 }
1548
1549 wxWindow* wxAuiTabContainer::GetWindowFromIdx(size_t idx) const
1550 {
1551 if (idx >= m_pages.GetCount())
1552 return NULL;
1553
1554 return m_pages[idx].window;
1555 }
1556
1557 int wxAuiTabContainer::GetIdxFromWindow(wxWindow* wnd) const
1558 {
1559 const size_t page_count = m_pages.GetCount();
1560 for ( size_t i = 0; i < page_count; ++i )
1561 {
1562 wxAuiNotebookPage& page = m_pages.Item(i);
1563 if (page.window == wnd)
1564 return i;
1565 }
1566 return wxNOT_FOUND;
1567 }
1568
1569 wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx)
1570 {
1571 wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
1572
1573 return m_pages[idx];
1574 }
1575
1576 const wxAuiNotebookPage& wxAuiTabContainer::GetPage(size_t idx) const
1577 {
1578 wxASSERT_MSG(idx < m_pages.GetCount(), wxT("Invalid Page index"));
1579
1580 return m_pages[idx];
1581 }
1582
1583 wxAuiNotebookPageArray& wxAuiTabContainer::GetPages()
1584 {
1585 return m_pages;
1586 }
1587
1588 size_t wxAuiTabContainer::GetPageCount() const
1589 {
1590 return m_pages.GetCount();
1591 }
1592
1593 void wxAuiTabContainer::AddButton(int id,
1594 int location,
1595 const wxBitmap& normalBitmap,
1596 const wxBitmap& disabledBitmap)
1597 {
1598 wxAuiTabContainerButton button;
1599 button.id = id;
1600 button.bitmap = normalBitmap;
1601 button.disBitmap = disabledBitmap;
1602 button.location = location;
1603 button.curState = wxAUI_BUTTON_STATE_NORMAL;
1604
1605 m_buttons.Add(button);
1606 }
1607
1608 void wxAuiTabContainer::RemoveButton(int id)
1609 {
1610 size_t i, button_count = m_buttons.GetCount();
1611
1612 for (i = 0; i < button_count; ++i)
1613 {
1614 if (m_buttons.Item(i).id == id)
1615 {
1616 m_buttons.RemoveAt(i);
1617 return;
1618 }
1619 }
1620 }
1621
1622
1623
1624 size_t wxAuiTabContainer::GetTabOffset() const
1625 {
1626 return m_tabOffset;
1627 }
1628
1629 void wxAuiTabContainer::SetTabOffset(size_t offset)
1630 {
1631 m_tabOffset = offset;
1632 }
1633
1634
1635
1636
1637 // Render() renders the tab catalog to the specified DC
1638 // It is a virtual function and can be overridden to
1639 // provide custom drawing capabilities
1640 void wxAuiTabContainer::Render(wxDC* raw_dc, wxWindow* wnd)
1641 {
1642 if (!raw_dc || !raw_dc->IsOk())
1643 return;
1644
1645 wxMemoryDC dc;
1646
1647 // use the same layout direction as the window DC uses to ensure that the
1648 // text is rendered correctly
1649 dc.SetLayoutDirection(raw_dc->GetLayoutDirection());
1650
1651 wxBitmap bmp;
1652 size_t i;
1653 size_t page_count = m_pages.GetCount();
1654 size_t button_count = m_buttons.GetCount();
1655
1656 // create off-screen bitmap
1657 bmp.Create(m_rect.GetWidth(), m_rect.GetHeight());
1658 dc.SelectObject(bmp);
1659
1660 if (!dc.IsOk())
1661 return;
1662
1663 // find out if size of tabs is larger than can be
1664 // afforded on screen
1665 int total_width = 0;
1666 int visible_width = 0;
1667 for (i = 0; i < page_count; ++i)
1668 {
1669 wxAuiNotebookPage& page = m_pages.Item(i);
1670
1671 // determine if a close button is on this tab
1672 bool close_button = false;
1673 if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1674 ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1675 {
1676 close_button = true;
1677 }
1678
1679
1680 int x_extent = 0;
1681 wxSize size = m_art->GetTabSize(dc,
1682 wnd,
1683 page.caption,
1684 page.bitmap,
1685 page.active,
1686 close_button ?
1687 wxAUI_BUTTON_STATE_NORMAL :
1688 wxAUI_BUTTON_STATE_HIDDEN,
1689 &x_extent);
1690
1691 if (i+1 < page_count)
1692 total_width += x_extent;
1693 else
1694 total_width += size.x;
1695
1696 if (i >= m_tabOffset)
1697 {
1698 if (i+1 < page_count)
1699 visible_width += x_extent;
1700 else
1701 visible_width += size.x;
1702 }
1703 }
1704
1705 if (total_width > m_rect.GetWidth() || m_tabOffset != 0)
1706 {
1707 // show left/right buttons
1708 for (i = 0; i < button_count; ++i)
1709 {
1710 wxAuiTabContainerButton& button = m_buttons.Item(i);
1711 if (button.id == wxAUI_BUTTON_LEFT ||
1712 button.id == wxAUI_BUTTON_RIGHT)
1713 {
1714 button.curState &= ~wxAUI_BUTTON_STATE_HIDDEN;
1715 }
1716 }
1717 }
1718 else
1719 {
1720 // hide left/right buttons
1721 for (i = 0; i < button_count; ++i)
1722 {
1723 wxAuiTabContainerButton& button = m_buttons.Item(i);
1724 if (button.id == wxAUI_BUTTON_LEFT ||
1725 button.id == wxAUI_BUTTON_RIGHT)
1726 {
1727 button.curState |= wxAUI_BUTTON_STATE_HIDDEN;
1728 }
1729 }
1730 }
1731
1732 // determine whether left button should be enabled
1733 for (i = 0; i < button_count; ++i)
1734 {
1735 wxAuiTabContainerButton& button = m_buttons.Item(i);
1736 if (button.id == wxAUI_BUTTON_LEFT)
1737 {
1738 if (m_tabOffset == 0)
1739 button.curState |= wxAUI_BUTTON_STATE_DISABLED;
1740 else
1741 button.curState &= ~wxAUI_BUTTON_STATE_DISABLED;
1742 }
1743 if (button.id == wxAUI_BUTTON_RIGHT)
1744 {
1745 if (visible_width < m_rect.GetWidth() - ((int)button_count*16))
1746 button.curState |= wxAUI_BUTTON_STATE_DISABLED;
1747 else
1748 button.curState &= ~wxAUI_BUTTON_STATE_DISABLED;
1749 }
1750 }
1751
1752
1753
1754 // draw background
1755 m_art->DrawBackground(dc, wnd, m_rect);
1756
1757 // draw buttons
1758 int left_buttons_width = 0;
1759 int right_buttons_width = 0;
1760
1761 int offset = 0;
1762
1763 // draw the buttons on the right side
1764 offset = m_rect.x + m_rect.width;
1765 for (i = 0; i < button_count; ++i)
1766 {
1767 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1768
1769 if (button.location != wxRIGHT)
1770 continue;
1771 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
1772 continue;
1773
1774 wxRect button_rect = m_rect;
1775 button_rect.SetY(1);
1776 button_rect.SetWidth(offset);
1777
1778 m_art->DrawButton(dc,
1779 wnd,
1780 button_rect,
1781 button.id,
1782 button.curState,
1783 wxRIGHT,
1784 &button.rect);
1785
1786 offset -= button.rect.GetWidth();
1787 right_buttons_width += button.rect.GetWidth();
1788 }
1789
1790
1791
1792 offset = 0;
1793
1794 // draw the buttons on the left side
1795
1796 for (i = 0; i < button_count; ++i)
1797 {
1798 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1799
1800 if (button.location != wxLEFT)
1801 continue;
1802 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
1803 continue;
1804
1805 wxRect button_rect(offset, 1, 1000, m_rect.height);
1806
1807 m_art->DrawButton(dc,
1808 wnd,
1809 button_rect,
1810 button.id,
1811 button.curState,
1812 wxLEFT,
1813 &button.rect);
1814
1815 offset += button.rect.GetWidth();
1816 left_buttons_width += button.rect.GetWidth();
1817 }
1818
1819 offset = left_buttons_width;
1820
1821 if (offset == 0)
1822 offset += m_art->GetIndentSize();
1823
1824
1825 // prepare the tab-close-button array
1826 // make sure tab button entries which aren't used are marked as hidden
1827 for (i = page_count; i < m_tabCloseButtons.GetCount(); ++i)
1828 m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
1829
1830 // make sure there are enough tab button entries to accommodate all tabs
1831 while (m_tabCloseButtons.GetCount() < page_count)
1832 {
1833 wxAuiTabContainerButton tempbtn;
1834 tempbtn.id = wxAUI_BUTTON_CLOSE;
1835 tempbtn.location = wxCENTER;
1836 tempbtn.curState = wxAUI_BUTTON_STATE_HIDDEN;
1837 m_tabCloseButtons.Add(tempbtn);
1838 }
1839
1840
1841 // buttons before the tab offset must be set to hidden
1842 for (i = 0; i < m_tabOffset; ++i)
1843 {
1844 m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
1845 }
1846
1847
1848 // draw the tabs
1849
1850 size_t active = 999;
1851 int active_offset = 0;
1852 wxRect active_rect;
1853
1854 int x_extent = 0;
1855 wxRect rect = m_rect;
1856 rect.y = 0;
1857 rect.height = m_rect.height;
1858
1859 for (i = m_tabOffset; i < page_count; ++i)
1860 {
1861 wxAuiNotebookPage& page = m_pages.Item(i);
1862 wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(i);
1863
1864 // determine if a close button is on this tab
1865 if ((m_flags & wxAUI_NB_CLOSE_ON_ALL_TABS) != 0 ||
1866 ((m_flags & wxAUI_NB_CLOSE_ON_ACTIVE_TAB) != 0 && page.active))
1867 {
1868 if (tab_button.curState == wxAUI_BUTTON_STATE_HIDDEN)
1869 {
1870 tab_button.id = wxAUI_BUTTON_CLOSE;
1871 tab_button.curState = wxAUI_BUTTON_STATE_NORMAL;
1872 tab_button.location = wxCENTER;
1873 }
1874 }
1875 else
1876 {
1877 tab_button.curState = wxAUI_BUTTON_STATE_HIDDEN;
1878 }
1879
1880 rect.x = offset;
1881 rect.width = m_rect.width - right_buttons_width - offset - 2;
1882
1883 if (rect.width <= 0)
1884 break;
1885
1886 m_art->DrawTab(dc,
1887 wnd,
1888 page,
1889 rect,
1890 tab_button.curState,
1891 &page.rect,
1892 &tab_button.rect,
1893 &x_extent);
1894
1895 if (page.active)
1896 {
1897 active = i;
1898 active_offset = offset;
1899 active_rect = rect;
1900 }
1901
1902 offset += x_extent;
1903 }
1904
1905
1906 // make sure to deactivate buttons which are off the screen to the right
1907 for (++i; i < m_tabCloseButtons.GetCount(); ++i)
1908 {
1909 m_tabCloseButtons.Item(i).curState = wxAUI_BUTTON_STATE_HIDDEN;
1910 }
1911
1912
1913 // draw the active tab again so it stands in the foreground
1914 if (active >= m_tabOffset && active < m_pages.GetCount())
1915 {
1916 wxAuiNotebookPage& page = m_pages.Item(active);
1917
1918 wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(active);
1919
1920 rect.x = active_offset;
1921 m_art->DrawTab(dc,
1922 wnd,
1923 page,
1924 active_rect,
1925 tab_button.curState,
1926 &page.rect,
1927 &tab_button.rect,
1928 &x_extent);
1929 }
1930
1931
1932 raw_dc->Blit(m_rect.x, m_rect.y,
1933 m_rect.GetWidth(), m_rect.GetHeight(),
1934 &dc, 0, 0);
1935 }
1936
1937 // Is the tab visible?
1938 bool wxAuiTabContainer::IsTabVisible(int tabPage, int tabOffset, wxDC* dc, wxWindow* wnd)
1939 {
1940 if (!dc || !dc->IsOk())
1941 return false;
1942
1943 size_t i;
1944 size_t page_count = m_pages.GetCount();
1945 size_t button_count = m_buttons.GetCount();
1946
1947 // Hasn't been rendered yet; assume it's visible
1948 if (m_tabCloseButtons.GetCount() < page_count)
1949 return true;
1950
1951 // First check if both buttons are disabled - if so, there's no need to
1952 // check further for visibility.
1953 int arrowButtonVisibleCount = 0;
1954 for (i = 0; i < button_count; ++i)
1955 {
1956 wxAuiTabContainerButton& button = m_buttons.Item(i);
1957 if (button.id == wxAUI_BUTTON_LEFT ||
1958 button.id == wxAUI_BUTTON_RIGHT)
1959 {
1960 if ((button.curState & wxAUI_BUTTON_STATE_HIDDEN) == 0)
1961 arrowButtonVisibleCount ++;
1962 }
1963 }
1964
1965 // Tab must be visible
1966 if (arrowButtonVisibleCount == 0)
1967 return true;
1968
1969 // If tab is less than the given offset, it must be invisible by definition
1970 if (tabPage < tabOffset)
1971 return false;
1972
1973 // draw buttons
1974 int left_buttons_width = 0;
1975 int right_buttons_width = 0;
1976
1977 int offset = 0;
1978
1979 // calculate size of the buttons on the right side
1980 offset = m_rect.x + m_rect.width;
1981 for (i = 0; i < button_count; ++i)
1982 {
1983 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
1984
1985 if (button.location != wxRIGHT)
1986 continue;
1987 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
1988 continue;
1989
1990 offset -= button.rect.GetWidth();
1991 right_buttons_width += button.rect.GetWidth();
1992 }
1993
1994 offset = 0;
1995
1996 // calculate size of the buttons on the left side
1997 for (i = 0; i < button_count; ++i)
1998 {
1999 wxAuiTabContainerButton& button = m_buttons.Item(button_count - i - 1);
2000
2001 if (button.location != wxLEFT)
2002 continue;
2003 if (button.curState & wxAUI_BUTTON_STATE_HIDDEN)
2004 continue;
2005
2006 offset += button.rect.GetWidth();
2007 left_buttons_width += button.rect.GetWidth();
2008 }
2009
2010 offset = left_buttons_width;
2011
2012 if (offset == 0)
2013 offset += m_art->GetIndentSize();
2014
2015 wxRect active_rect;
2016
2017 wxRect rect = m_rect;
2018 rect.y = 0;
2019 rect.height = m_rect.height;
2020
2021 // See if the given page is visible at the given tab offset (effectively scroll position)
2022 for (i = tabOffset; i < page_count; ++i)
2023 {
2024 wxAuiNotebookPage& page = m_pages.Item(i);
2025 wxAuiTabContainerButton& tab_button = m_tabCloseButtons.Item(i);
2026
2027 rect.x = offset;
2028 rect.width = m_rect.width - right_buttons_width - offset - 2;
2029
2030 if (rect.width <= 0)
2031 return false; // haven't found the tab, and we've run out of space, so return false
2032
2033 int x_extent = 0;
2034 m_art->GetTabSize(*dc,
2035 wnd,
2036 page.caption,
2037 page.bitmap,
2038 page.active,
2039 tab_button.curState,
2040 &x_extent);
2041
2042 offset += x_extent;
2043
2044 if (i == (size_t) tabPage)
2045 {
2046 // If not all of the tab is visible, and supposing there's space to display it all,
2047 // we could do better so we return false.
2048 if (((m_rect.width - right_buttons_width - offset - 2) <= 0) && ((m_rect.width - right_buttons_width - left_buttons_width) > x_extent))
2049 return false;
2050 else
2051 return true;
2052 }
2053 }
2054
2055 // Shouldn't really get here, but if it does, assume the tab is visible to prevent
2056 // further looping in calling code.
2057 return true;
2058 }
2059
2060 // Make the tab visible if it wasn't already
2061 void wxAuiTabContainer::MakeTabVisible(int tabPage, wxWindow* win)
2062 {
2063 wxClientDC dc(win);
2064 if (!IsTabVisible(tabPage, GetTabOffset(), & dc, win))
2065 {
2066 int i;
2067 for (i = 0; i < (int) m_pages.GetCount(); i++)
2068 {
2069 if (IsTabVisible(tabPage, i, & dc, win))
2070 {
2071 SetTabOffset(i);
2072 win->Refresh();
2073 return;
2074 }
2075 }
2076 }
2077 }
2078
2079 // TabHitTest() tests if a tab was hit, passing the window pointer
2080 // back if that condition was fulfilled. The function returns
2081 // true if a tab was hit, otherwise false
2082 bool wxAuiTabContainer::TabHitTest(int x, int y, wxWindow** hit) const
2083 {
2084 if (!m_rect.Contains(x,y))
2085 return false;
2086
2087 wxAuiTabContainerButton* btn = NULL;
2088 if (ButtonHitTest(x, y, &btn) && !(btn->curState & wxAUI_BUTTON_STATE_DISABLED))
2089 {
2090 if (m_buttons.Index(*btn) != wxNOT_FOUND)
2091 return false;
2092 }
2093
2094 size_t i, page_count = m_pages.GetCount();
2095
2096 for (i = m_tabOffset; i < page_count; ++i)
2097 {
2098 wxAuiNotebookPage& page = m_pages.Item(i);
2099 if (page.rect.Contains(x,y))
2100 {
2101 if (hit)
2102 *hit = page.window;
2103 return true;
2104 }
2105 }
2106
2107 return false;
2108 }
2109
2110 // ButtonHitTest() tests if a button was hit. The function returns
2111 // true if a button was hit, otherwise false
2112 bool wxAuiTabContainer::ButtonHitTest(int x, int y,
2113 wxAuiTabContainerButton** hit) const
2114 {
2115 if (!m_rect.Contains(x,y))
2116 return false;
2117
2118 size_t i, button_count;
2119
2120
2121 button_count = m_buttons.GetCount();
2122 for (i = 0; i < button_count; ++i)
2123 {
2124 wxAuiTabContainerButton& button = m_buttons.Item(i);
2125 if (button.rect.Contains(x,y) &&
2126 !(button.curState & wxAUI_BUTTON_STATE_HIDDEN ))
2127 {
2128 if (hit)
2129 *hit = &button;
2130 return true;
2131 }
2132 }
2133
2134 button_count = m_tabCloseButtons.GetCount();
2135 for (i = 0; i < button_count; ++i)
2136 {
2137 wxAuiTabContainerButton& button = m_tabCloseButtons.Item(i);
2138 if (button.rect.Contains(x,y) &&
2139 !(button.curState & (wxAUI_BUTTON_STATE_HIDDEN |
2140 wxAUI_BUTTON_STATE_DISABLED)))
2141 {
2142 if (hit)
2143 *hit = &button;
2144 return true;
2145 }
2146 }
2147
2148 return false;
2149 }
2150
2151
2152
2153 // the utility function ShowWnd() is the same as show,
2154 // except it handles wxAuiMDIChildFrame windows as well,
2155 // as the Show() method on this class is "unplugged"
2156 static void ShowWnd(wxWindow* wnd, bool show)
2157 {
2158 #if wxUSE_MDI
2159 if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2160 {
2161 wxAuiMDIChildFrame* cf = (wxAuiMDIChildFrame*)wnd;
2162 cf->DoShow(show);
2163 }
2164 else
2165 #endif
2166 {
2167 wnd->Show(show);
2168 }
2169 }
2170
2171
2172 // DoShowHide() this function shows the active window, then
2173 // hides all of the other windows (in that order)
2174 void wxAuiTabContainer::DoShowHide()
2175 {
2176 wxAuiNotebookPageArray& pages = GetPages();
2177 size_t i, page_count = pages.GetCount();
2178
2179 // show new active page first
2180 for (i = 0; i < page_count; ++i)
2181 {
2182 wxAuiNotebookPage& page = pages.Item(i);
2183 if (page.active)
2184 {
2185 ShowWnd(page.window, true);
2186 break;
2187 }
2188 }
2189
2190 // hide all other pages
2191 for (i = 0; i < page_count; ++i)
2192 {
2193 wxAuiNotebookPage& page = pages.Item(i);
2194 if (!page.active)
2195 ShowWnd(page.window, false);
2196 }
2197 }
2198
2199
2200
2201
2202
2203
2204 // -- wxAuiTabCtrl class implementation --
2205
2206
2207
2208 BEGIN_EVENT_TABLE(wxAuiTabCtrl, wxControl)
2209 EVT_PAINT(wxAuiTabCtrl::OnPaint)
2210 EVT_ERASE_BACKGROUND(wxAuiTabCtrl::OnEraseBackground)
2211 EVT_SIZE(wxAuiTabCtrl::OnSize)
2212 EVT_LEFT_DOWN(wxAuiTabCtrl::OnLeftDown)
2213 EVT_LEFT_DCLICK(wxAuiTabCtrl::OnLeftDClick)
2214 EVT_LEFT_UP(wxAuiTabCtrl::OnLeftUp)
2215 EVT_MIDDLE_DOWN(wxAuiTabCtrl::OnMiddleDown)
2216 EVT_MIDDLE_UP(wxAuiTabCtrl::OnMiddleUp)
2217 EVT_RIGHT_DOWN(wxAuiTabCtrl::OnRightDown)
2218 EVT_RIGHT_UP(wxAuiTabCtrl::OnRightUp)
2219 EVT_MOTION(wxAuiTabCtrl::OnMotion)
2220 EVT_LEAVE_WINDOW(wxAuiTabCtrl::OnLeaveWindow)
2221 EVT_AUINOTEBOOK_BUTTON(wxID_ANY, wxAuiTabCtrl::OnButton)
2222 EVT_SET_FOCUS(wxAuiTabCtrl::OnSetFocus)
2223 EVT_KILL_FOCUS(wxAuiTabCtrl::OnKillFocus)
2224 EVT_CHAR(wxAuiTabCtrl::OnChar)
2225 EVT_MOUSE_CAPTURE_LOST(wxAuiTabCtrl::OnCaptureLost)
2226 END_EVENT_TABLE()
2227
2228
2229 wxAuiTabCtrl::wxAuiTabCtrl(wxWindow* parent,
2230 wxWindowID id,
2231 const wxPoint& pos,
2232 const wxSize& size,
2233 long style) : wxControl(parent, id, pos, size, style)
2234 {
2235 SetName(wxT("wxAuiTabCtrl"));
2236 m_clickPt = wxDefaultPosition;
2237 m_isDragging = false;
2238 m_hoverButton = NULL;
2239 m_pressedButton = NULL;
2240 }
2241
2242 wxAuiTabCtrl::~wxAuiTabCtrl()
2243 {
2244 }
2245
2246 void wxAuiTabCtrl::OnPaint(wxPaintEvent&)
2247 {
2248 wxPaintDC dc(this);
2249
2250 dc.SetFont(GetFont());
2251
2252 if (GetPageCount() > 0)
2253 Render(&dc, this);
2254 }
2255
2256 void wxAuiTabCtrl::OnEraseBackground(wxEraseEvent& WXUNUSED(evt))
2257 {
2258 }
2259
2260 void wxAuiTabCtrl::OnSize(wxSizeEvent& evt)
2261 {
2262 wxSize s = evt.GetSize();
2263 wxRect r(0, 0, s.GetWidth(), s.GetHeight());
2264 SetRect(r);
2265 }
2266
2267 void wxAuiTabCtrl::OnLeftDown(wxMouseEvent& evt)
2268 {
2269 CaptureMouse();
2270 m_clickPt = wxDefaultPosition;
2271 m_isDragging = false;
2272 m_clickTab = NULL;
2273 m_pressedButton = NULL;
2274
2275
2276 wxWindow* wnd;
2277 if (TabHitTest(evt.m_x, evt.m_y, &wnd))
2278 {
2279 int new_selection = GetIdxFromWindow(wnd);
2280
2281 // wxAuiNotebooks always want to receive this event
2282 // even if the tab is already active, because they may
2283 // have multiple tab controls
2284 if (new_selection != GetActivePage() ||
2285 GetParent()->IsKindOf(CLASSINFO(wxAuiNotebook)))
2286 {
2287 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2288 e.SetSelection(new_selection);
2289 e.SetOldSelection(GetActivePage());
2290 e.SetEventObject(this);
2291 GetEventHandler()->ProcessEvent(e);
2292 }
2293
2294 m_clickPt.x = evt.m_x;
2295 m_clickPt.y = evt.m_y;
2296 m_clickTab = wnd;
2297 }
2298
2299 if (m_hoverButton)
2300 {
2301 m_pressedButton = m_hoverButton;
2302 m_pressedButton->curState = wxAUI_BUTTON_STATE_PRESSED;
2303 Refresh();
2304 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
2305 Update();
2306 #endif
2307 }
2308 }
2309
2310 void wxAuiTabCtrl::OnCaptureLost(wxMouseCaptureLostEvent& WXUNUSED(event))
2311 {
2312 if (m_isDragging)
2313 {
2314 m_isDragging = false;
2315
2316 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG, m_windowId);
2317 evt.SetSelection(GetIdxFromWindow(m_clickTab));
2318 evt.SetOldSelection(evt.GetSelection());
2319 evt.SetEventObject(this);
2320 GetEventHandler()->ProcessEvent(evt);
2321 }
2322 }
2323
2324 void wxAuiTabCtrl::OnLeftUp(wxMouseEvent& evt)
2325 {
2326 if (GetCapture() == this)
2327 ReleaseMouse();
2328
2329 if (m_isDragging)
2330 {
2331 m_isDragging = false;
2332
2333 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, m_windowId);
2334 evt.SetSelection(GetIdxFromWindow(m_clickTab));
2335 evt.SetOldSelection(evt.GetSelection());
2336 evt.SetEventObject(this);
2337 GetEventHandler()->ProcessEvent(evt);
2338
2339 return;
2340 }
2341
2342 if (m_pressedButton)
2343 {
2344 // make sure we're still clicking the button
2345 wxAuiTabContainerButton* button = NULL;
2346 if (!ButtonHitTest(evt.m_x, evt.m_y, &button) ||
2347 button->curState & wxAUI_BUTTON_STATE_DISABLED)
2348 return;
2349
2350 if (button != m_pressedButton)
2351 {
2352 m_pressedButton = NULL;
2353 return;
2354 }
2355
2356 Refresh();
2357 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
2358 Update();
2359 #endif
2360
2361 if (!(m_pressedButton->curState & wxAUI_BUTTON_STATE_DISABLED))
2362 {
2363 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BUTTON, m_windowId);
2364 evt.SetSelection(GetIdxFromWindow(m_clickTab));
2365 evt.SetInt(m_pressedButton->id);
2366 evt.SetEventObject(this);
2367 GetEventHandler()->ProcessEvent(evt);
2368 }
2369
2370 m_pressedButton = NULL;
2371 }
2372
2373 m_clickPt = wxDefaultPosition;
2374 m_isDragging = false;
2375 m_clickTab = NULL;
2376 }
2377
2378 void wxAuiTabCtrl::OnMiddleUp(wxMouseEvent& evt)
2379 {
2380 wxWindow* wnd = NULL;
2381 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2382 return;
2383
2384 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
2385 e.SetEventObject(this);
2386 e.SetSelection(GetIdxFromWindow(wnd));
2387 GetEventHandler()->ProcessEvent(e);
2388 }
2389
2390 void wxAuiTabCtrl::OnMiddleDown(wxMouseEvent& evt)
2391 {
2392 wxWindow* wnd = NULL;
2393 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2394 return;
2395
2396 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
2397 e.SetEventObject(this);
2398 e.SetSelection(GetIdxFromWindow(wnd));
2399 GetEventHandler()->ProcessEvent(e);
2400 }
2401
2402 void wxAuiTabCtrl::OnRightUp(wxMouseEvent& evt)
2403 {
2404 wxWindow* wnd = NULL;
2405 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2406 return;
2407
2408 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
2409 e.SetEventObject(this);
2410 e.SetSelection(GetIdxFromWindow(wnd));
2411 GetEventHandler()->ProcessEvent(e);
2412 }
2413
2414 void wxAuiTabCtrl::OnRightDown(wxMouseEvent& evt)
2415 {
2416 wxWindow* wnd = NULL;
2417 if (!TabHitTest(evt.m_x, evt.m_y, &wnd))
2418 return;
2419
2420 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
2421 e.SetEventObject(this);
2422 e.SetSelection(GetIdxFromWindow(wnd));
2423 GetEventHandler()->ProcessEvent(e);
2424 }
2425
2426 void wxAuiTabCtrl::OnLeftDClick(wxMouseEvent& evt)
2427 {
2428 wxWindow* wnd;
2429 wxAuiTabContainerButton* button;
2430 if (!TabHitTest(evt.m_x, evt.m_y, &wnd) && !ButtonHitTest(evt.m_x, evt.m_y, &button))
2431 {
2432 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
2433 e.SetEventObject(this);
2434 GetEventHandler()->ProcessEvent(e);
2435 }
2436 }
2437
2438 void wxAuiTabCtrl::OnMotion(wxMouseEvent& evt)
2439 {
2440 wxPoint pos = evt.GetPosition();
2441
2442 // check if the mouse is hovering above a button
2443 wxAuiTabContainerButton* button;
2444 if (ButtonHitTest(pos.x, pos.y, &button) && !(button->curState & wxAUI_BUTTON_STATE_DISABLED))
2445 {
2446 if (m_hoverButton && button != m_hoverButton)
2447 {
2448 m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
2449 m_hoverButton = NULL;
2450 Refresh();
2451 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
2452 Update();
2453 #endif
2454 }
2455
2456 if (button->curState != wxAUI_BUTTON_STATE_HOVER)
2457 {
2458 button->curState = wxAUI_BUTTON_STATE_HOVER;
2459 Refresh();
2460 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
2461 Update();
2462 #endif
2463 m_hoverButton = button;
2464 return;
2465 }
2466 }
2467 else
2468 {
2469 if (m_hoverButton)
2470 {
2471 m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
2472 m_hoverButton = NULL;
2473 Refresh();
2474 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
2475 Update();
2476 #endif
2477 }
2478 }
2479
2480
2481 if (!evt.LeftIsDown() || m_clickPt == wxDefaultPosition)
2482 return;
2483
2484 if (m_isDragging)
2485 {
2486 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, m_windowId);
2487 evt.SetSelection(GetIdxFromWindow(m_clickTab));
2488 evt.SetOldSelection(evt.GetSelection());
2489 evt.SetEventObject(this);
2490 GetEventHandler()->ProcessEvent(evt);
2491 return;
2492 }
2493
2494
2495 int drag_x_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_X);
2496 int drag_y_threshold = wxSystemSettings::GetMetric(wxSYS_DRAG_Y);
2497
2498 if (abs(pos.x - m_clickPt.x) > drag_x_threshold ||
2499 abs(pos.y - m_clickPt.y) > drag_y_threshold)
2500 {
2501 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, m_windowId);
2502 evt.SetSelection(GetIdxFromWindow(m_clickTab));
2503 evt.SetOldSelection(evt.GetSelection());
2504 evt.SetEventObject(this);
2505 GetEventHandler()->ProcessEvent(evt);
2506
2507 m_isDragging = true;
2508 }
2509 }
2510
2511 void wxAuiTabCtrl::OnLeaveWindow(wxMouseEvent& WXUNUSED(event))
2512 {
2513 if (m_hoverButton)
2514 {
2515 m_hoverButton->curState = wxAUI_BUTTON_STATE_NORMAL;
2516 m_hoverButton = NULL;
2517 Refresh();
2518 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
2519 Update();
2520 #endif
2521 }
2522 }
2523
2524 void wxAuiTabCtrl::OnButton(wxAuiNotebookEvent& event)
2525 {
2526 int button = event.GetInt();
2527
2528 if (button == wxAUI_BUTTON_LEFT || button == wxAUI_BUTTON_RIGHT)
2529 {
2530 if (button == wxAUI_BUTTON_LEFT)
2531 {
2532 if (GetTabOffset() > 0)
2533 {
2534 SetTabOffset(GetTabOffset()-1);
2535 Refresh();
2536 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
2537 Update();
2538 #endif
2539 }
2540 }
2541 else
2542 {
2543 SetTabOffset(GetTabOffset()+1);
2544 Refresh();
2545 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
2546 Update();
2547 #endif
2548 }
2549 }
2550 else if (button == wxAUI_BUTTON_WINDOWLIST)
2551 {
2552 int idx = GetArtProvider()->ShowDropDown(this, m_pages, GetActivePage());
2553
2554 if (idx != -1)
2555 {
2556 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2557 e.SetSelection(idx);
2558 e.SetOldSelection(GetActivePage());
2559 e.SetEventObject(this);
2560 GetEventHandler()->ProcessEvent(e);
2561 }
2562 }
2563 else
2564 {
2565 event.Skip();
2566 }
2567 }
2568
2569 void wxAuiTabCtrl::OnSetFocus(wxFocusEvent& WXUNUSED(event))
2570 {
2571 Refresh();
2572 }
2573
2574 void wxAuiTabCtrl::OnKillFocus(wxFocusEvent& WXUNUSED(event))
2575 {
2576 Refresh();
2577 }
2578
2579 void wxAuiTabCtrl::OnChar(wxKeyEvent& event)
2580 {
2581 if (GetActivePage() == -1)
2582 {
2583 event.Skip();
2584 return;
2585 }
2586
2587 // We can't leave tab processing to the system; on Windows, tabs and keys
2588 // get eaten by the system and not processed properly if we specify both
2589 // wxTAB_TRAVERSAL and wxWANTS_CHARS. And if we specify just wxTAB_TRAVERSAL,
2590 // we don't key arrow key events.
2591
2592 int key = event.GetKeyCode();
2593
2594 if (key == WXK_NUMPAD_PAGEUP)
2595 key = WXK_PAGEUP;
2596 if (key == WXK_NUMPAD_PAGEDOWN)
2597 key = WXK_PAGEDOWN;
2598 if (key == WXK_NUMPAD_HOME)
2599 key = WXK_HOME;
2600 if (key == WXK_NUMPAD_END)
2601 key = WXK_END;
2602 if (key == WXK_NUMPAD_LEFT)
2603 key = WXK_LEFT;
2604 if (key == WXK_NUMPAD_RIGHT)
2605 key = WXK_RIGHT;
2606
2607 if (key == WXK_TAB || key == WXK_PAGEUP || key == WXK_PAGEDOWN)
2608 {
2609 bool bCtrlDown = event.ControlDown();
2610 bool bShiftDown = event.ShiftDown();
2611
2612 bool bForward = (key == WXK_TAB && !bShiftDown) || (key == WXK_PAGEDOWN);
2613 bool bWindowChange = (key == WXK_PAGEUP) || (key == WXK_PAGEDOWN) || bCtrlDown;
2614 bool bFromTab = (key == WXK_TAB);
2615
2616 wxAuiNotebook* nb = wxDynamicCast(GetParent(), wxAuiNotebook);
2617 if (!nb)
2618 {
2619 event.Skip();
2620 return;
2621 }
2622
2623 wxNavigationKeyEvent keyEvent;
2624 keyEvent.SetDirection(bForward);
2625 keyEvent.SetWindowChange(bWindowChange);
2626 keyEvent.SetFromTab(bFromTab);
2627 keyEvent.SetEventObject(nb);
2628
2629 if (!nb->GetEventHandler()->ProcessEvent(keyEvent))
2630 {
2631 // Not processed? Do an explicit tab into the page.
2632 wxWindow* win = GetWindowFromIdx(GetActivePage());
2633 if (win)
2634 win->SetFocus();
2635 }
2636 return;
2637 }
2638
2639 if (m_pages.GetCount() < 2)
2640 {
2641 event.Skip();
2642 return;
2643 }
2644
2645 int newPage = -1;
2646
2647 int forwardKey, backwardKey;
2648 if (GetLayoutDirection() == wxLayout_RightToLeft)
2649 {
2650 forwardKey = WXK_LEFT;
2651 backwardKey = WXK_RIGHT;
2652 }
2653 else
2654 {
2655 forwardKey = WXK_RIGHT;
2656 backwardKey = WXK_LEFT;
2657 }
2658
2659 if (key == forwardKey)
2660 {
2661 if (m_pages.GetCount() > 1)
2662 {
2663 if (GetActivePage() == -1)
2664 newPage = 0;
2665 else if (GetActivePage() < (int) (m_pages.GetCount() - 1))
2666 newPage = GetActivePage() + 1;
2667 }
2668 }
2669 else if (key == backwardKey)
2670 {
2671 if (m_pages.GetCount() > 1)
2672 {
2673 if (GetActivePage() == -1)
2674 newPage = (int) (m_pages.GetCount() - 1);
2675 else if (GetActivePage() > 0)
2676 newPage = GetActivePage() - 1;
2677 }
2678 }
2679 else if (key == WXK_HOME)
2680 {
2681 newPage = 0;
2682 }
2683 else if (key == WXK_END)
2684 {
2685 newPage = (int) (m_pages.GetCount() - 1);
2686 }
2687 else
2688 event.Skip();
2689
2690 if (newPage != -1)
2691 {
2692 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
2693 e.SetSelection(newPage);
2694 e.SetOldSelection(newPage);
2695 e.SetEventObject(this);
2696 this->GetEventHandler()->ProcessEvent(e);
2697 }
2698 else
2699 event.Skip();
2700 }
2701
2702 // wxTabFrame is an interesting case. It's important that all child pages
2703 // of the multi-notebook control are all actually children of that control
2704 // (and not grandchildren). wxTabFrame facilitates this. There is one
2705 // instance of wxTabFrame for each tab control inside the multi-notebook.
2706 // It's important to know that wxTabFrame is not a real window, but it merely
2707 // used to capture the dimensions/positioning of the internal tab control and
2708 // it's managed page windows
2709
2710 class wxTabFrame : public wxWindow
2711 {
2712 public:
2713
2714 wxTabFrame()
2715 {
2716 m_tabs = NULL;
2717 m_rect = wxRect(0,0,200,200);
2718 m_tabCtrlHeight = 20;
2719 }
2720
2721 ~wxTabFrame()
2722 {
2723 wxDELETE(m_tabs);
2724 }
2725
2726 void SetTabCtrlHeight(int h)
2727 {
2728 m_tabCtrlHeight = h;
2729 }
2730
2731 protected:
2732 void DoSetSize(int x, int y,
2733 int width, int height,
2734 int WXUNUSED(sizeFlags = wxSIZE_AUTO))
2735 {
2736 m_rect = wxRect(x, y, width, height);
2737 DoSizing();
2738 }
2739
2740 void DoGetClientSize(int* x, int* y) const
2741 {
2742 *x = m_rect.width;
2743 *y = m_rect.height;
2744 }
2745
2746 public:
2747 bool Show( bool WXUNUSED(show = true) ) { return false; }
2748
2749 void DoSizing()
2750 {
2751 if (!m_tabs)
2752 return;
2753
2754 if (m_tabs->IsFrozen() || m_tabs->GetParent()->IsFrozen())
2755 return;
2756
2757 m_tab_rect = wxRect(m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
2758 if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
2759 {
2760 m_tab_rect = wxRect (m_rect.x, m_rect.y + m_rect.height - m_tabCtrlHeight, m_rect.width, m_tabCtrlHeight);
2761 m_tabs->SetSize (m_rect.x, m_rect.y + m_rect.height - m_tabCtrlHeight, m_rect.width, m_tabCtrlHeight);
2762 m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tabCtrlHeight));
2763 }
2764 else //TODO: if (GetFlags() & wxAUI_NB_TOP)
2765 {
2766 m_tab_rect = wxRect (m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
2767 m_tabs->SetSize (m_rect.x, m_rect.y, m_rect.width, m_tabCtrlHeight);
2768 m_tabs->SetRect (wxRect(0, 0, m_rect.width, m_tabCtrlHeight));
2769 }
2770 // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
2771 // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
2772
2773 m_tabs->Refresh();
2774 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
2775 m_tabs->Update();
2776 #endif
2777
2778 wxAuiNotebookPageArray& pages = m_tabs->GetPages();
2779 size_t i, page_count = pages.GetCount();
2780
2781 for (i = 0; i < page_count; ++i)
2782 {
2783 int height = m_rect.height - m_tabCtrlHeight;
2784 if ( height < 0 )
2785 {
2786 // avoid passing negative height to wxWindow::SetSize(), this
2787 // results in assert failures/GTK+ warnings
2788 height = 0;
2789 }
2790
2791 wxAuiNotebookPage& page = pages.Item(i);
2792 if (m_tabs->GetFlags() & wxAUI_NB_BOTTOM)
2793 {
2794 page.window->SetSize(m_rect.x, m_rect.y, m_rect.width, height);
2795 }
2796 else //TODO: if (GetFlags() & wxAUI_NB_TOP)
2797 {
2798 page.window->SetSize(m_rect.x, m_rect.y + m_tabCtrlHeight,
2799 m_rect.width, height);
2800 }
2801 // TODO: else if (GetFlags() & wxAUI_NB_LEFT){}
2802 // TODO: else if (GetFlags() & wxAUI_NB_RIGHT){}
2803
2804 #if wxUSE_MDI
2805 if (page.window->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
2806 {
2807 wxAuiMDIChildFrame* wnd = (wxAuiMDIChildFrame*)page.window;
2808 wnd->ApplyMDIChildFrameRect();
2809 }
2810 #endif
2811 }
2812 }
2813
2814 protected:
2815 void DoGetSize(int* x, int* y) const
2816 {
2817 if (x)
2818 *x = m_rect.GetWidth();
2819 if (y)
2820 *y = m_rect.GetHeight();
2821 }
2822
2823 public:
2824 void Update()
2825 {
2826 // does nothing
2827 }
2828
2829 wxRect m_rect;
2830 wxRect m_tab_rect;
2831 wxAuiTabCtrl* m_tabs;
2832 int m_tabCtrlHeight;
2833 };
2834
2835
2836 const int wxAuiBaseTabCtrlId = 5380;
2837
2838
2839 // -- wxAuiNotebook class implementation --
2840
2841 #define EVT_AUI_RANGE(id1, id2, event, func) \
2842 wx__DECLARE_EVT2(event, id1, id2, wxAuiNotebookEventHandler(func))
2843
2844 BEGIN_EVENT_TABLE(wxAuiNotebook, wxControl)
2845 EVT_SIZE(wxAuiNotebook::OnSize)
2846 EVT_CHILD_FOCUS(wxAuiNotebook::OnChildFocusNotebook)
2847 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2848 wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
2849 wxAuiNotebook::OnTabClicked)
2850 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2851 wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG,
2852 wxAuiNotebook::OnTabBeginDrag)
2853 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2854 wxEVT_COMMAND_AUINOTEBOOK_END_DRAG,
2855 wxAuiNotebook::OnTabEndDrag)
2856 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2857 wxEVT_COMMAND_AUINOTEBOOK_CANCEL_DRAG,
2858 wxAuiNotebook::OnTabCancelDrag)
2859 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2860 wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION,
2861 wxAuiNotebook::OnTabDragMotion)
2862 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2863 wxEVT_COMMAND_AUINOTEBOOK_BUTTON,
2864 wxAuiNotebook::OnTabButton)
2865 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2866 wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN,
2867 wxAuiNotebook::OnTabMiddleDown)
2868 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2869 wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP,
2870 wxAuiNotebook::OnTabMiddleUp)
2871 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2872 wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN,
2873 wxAuiNotebook::OnTabRightDown)
2874 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2875 wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP,
2876 wxAuiNotebook::OnTabRightUp)
2877 EVT_AUI_RANGE(wxAuiBaseTabCtrlId, wxAuiBaseTabCtrlId+500,
2878 wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK,
2879 wxAuiNotebook::OnTabBgDClick)
2880 EVT_NAVIGATION_KEY(wxAuiNotebook::OnNavigationKeyNotebook)
2881 END_EVENT_TABLE()
2882
2883 void wxAuiNotebook::Init()
2884 {
2885 m_curPage = -1;
2886 m_tabIdCounter = wxAuiBaseTabCtrlId;
2887 m_dummyWnd = NULL;
2888 m_tabCtrlHeight = 20;
2889 m_requestedBmpSize = wxDefaultSize;
2890 m_requestedTabCtrlHeight = -1;
2891 }
2892
2893 bool wxAuiNotebook::Create(wxWindow* parent,
2894 wxWindowID id,
2895 const wxPoint& pos,
2896 const wxSize& size,
2897 long style)
2898 {
2899 if (!wxControl::Create(parent, id, pos, size, style))
2900 return false;
2901
2902 InitNotebook(style);
2903
2904 return true;
2905 }
2906
2907 // InitNotebook() contains common initialization
2908 // code called by all constructors
2909 void wxAuiNotebook::InitNotebook(long style)
2910 {
2911 SetName(wxT("wxAuiNotebook"));
2912 m_curPage = -1;
2913 m_tabIdCounter = wxAuiBaseTabCtrlId;
2914 m_dummyWnd = NULL;
2915 m_flags = (unsigned int)style;
2916 m_tabCtrlHeight = 20;
2917
2918 m_normalFont = *wxNORMAL_FONT;
2919 m_selectedFont = *wxNORMAL_FONT;
2920 m_selectedFont.SetWeight(wxBOLD);
2921
2922 SetArtProvider(new wxAuiDefaultTabArt);
2923
2924 m_dummyWnd = new wxWindow(this, wxID_ANY, wxPoint(0,0), wxSize(0,0));
2925 m_dummyWnd->SetSize(200, 200);
2926 m_dummyWnd->Show(false);
2927
2928 m_mgr.SetManagedWindow(this);
2929 m_mgr.SetFlags(wxAUI_MGR_DEFAULT);
2930 m_mgr.SetDockSizeConstraint(1.0, 1.0); // no dock size constraint
2931
2932 m_mgr.AddPane(m_dummyWnd,
2933 wxAuiPaneInfo().Name(wxT("dummy")).Bottom().CaptionVisible(false).Show(false));
2934
2935 m_mgr.Update();
2936 }
2937
2938 wxAuiNotebook::~wxAuiNotebook()
2939 {
2940 // Indicate we're deleting pages
2941 SendDestroyEvent();
2942
2943 while ( GetPageCount() > 0 )
2944 DeletePage(0);
2945
2946 m_mgr.UnInit();
2947 }
2948
2949 void wxAuiNotebook::SetArtProvider(wxAuiTabArt* art)
2950 {
2951 m_tabs.SetArtProvider(art);
2952
2953 // Update the height and do nothing else if it did something but otherwise
2954 // (i.e. if the new art provider uses the same height as the old one) we
2955 // need to manually set the art provider for all tabs ourselves.
2956 if ( !UpdateTabCtrlHeight() )
2957 {
2958 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
2959 const size_t pane_count = all_panes.GetCount();
2960 for (size_t i = 0; i < pane_count; ++i)
2961 {
2962 wxAuiPaneInfo& pane = all_panes.Item(i);
2963 if (pane.name == wxT("dummy"))
2964 continue;
2965 wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
2966 wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
2967 tabctrl->SetArtProvider(art->Clone());
2968 }
2969 }
2970 }
2971
2972 // SetTabCtrlHeight() is the highest-level override of the
2973 // tab height. A call to this function effectively enforces a
2974 // specified tab ctrl height, overriding all other considerations,
2975 // such as text or bitmap height. It overrides any call to
2976 // SetUniformBitmapSize(). Specifying a height of -1 reverts
2977 // any previous call and returns to the default behaviour
2978
2979 void wxAuiNotebook::SetTabCtrlHeight(int height)
2980 {
2981 m_requestedTabCtrlHeight = height;
2982
2983 // if window is already initialized, recalculate the tab height
2984 if (m_dummyWnd)
2985 {
2986 UpdateTabCtrlHeight();
2987 }
2988 }
2989
2990
2991 // SetUniformBitmapSize() ensures that all tabs will have
2992 // the same height, even if some tabs don't have bitmaps
2993 // Passing wxDefaultSize to this function will instruct
2994 // the control to use dynamic tab height-- so when a tab
2995 // with a large bitmap is added, the tab ctrl's height will
2996 // automatically increase to accommodate the bitmap
2997
2998 void wxAuiNotebook::SetUniformBitmapSize(const wxSize& size)
2999 {
3000 m_requestedBmpSize = size;
3001
3002 // if window is already initialized, recalculate the tab height
3003 if (m_dummyWnd)
3004 {
3005 UpdateTabCtrlHeight();
3006 }
3007 }
3008
3009 // UpdateTabCtrlHeight() does the actual tab resizing. It's meant
3010 // to be used internally
3011 bool wxAuiNotebook::UpdateTabCtrlHeight()
3012 {
3013 // get the tab ctrl height we will use
3014 int height = CalculateTabCtrlHeight();
3015
3016 // if the tab control height needs to change, update
3017 // all of our tab controls with the new height
3018 if (m_tabCtrlHeight == height)
3019 return false;
3020
3021 wxAuiTabArt* art = m_tabs.GetArtProvider();
3022
3023 m_tabCtrlHeight = height;
3024
3025 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3026 size_t i, pane_count = all_panes.GetCount();
3027 for (i = 0; i < pane_count; ++i)
3028 {
3029 wxAuiPaneInfo& pane = all_panes.Item(i);
3030 if (pane.name == wxT("dummy"))
3031 continue;
3032 wxTabFrame* tab_frame = (wxTabFrame*)pane.window;
3033 wxAuiTabCtrl* tabctrl = tab_frame->m_tabs;
3034 tab_frame->SetTabCtrlHeight(m_tabCtrlHeight);
3035 tabctrl->SetArtProvider(art->Clone());
3036 tab_frame->DoSizing();
3037 }
3038
3039 return true;
3040 }
3041
3042 void wxAuiNotebook::UpdateHintWindowSize()
3043 {
3044 wxSize size = CalculateNewSplitSize();
3045
3046 // the placeholder hint window should be set to this size
3047 wxAuiPaneInfo& info = m_mgr.GetPane(wxT("dummy"));
3048 if (info.IsOk())
3049 {
3050 info.MinSize(size);
3051 info.BestSize(size);
3052 m_dummyWnd->SetSize(size);
3053 }
3054 }
3055
3056
3057 // calculates the size of the new split
3058 wxSize wxAuiNotebook::CalculateNewSplitSize()
3059 {
3060 // count number of tab controls
3061 int tab_ctrl_count = 0;
3062 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3063 size_t i, pane_count = all_panes.GetCount();
3064 for (i = 0; i < pane_count; ++i)
3065 {
3066 wxAuiPaneInfo& pane = all_panes.Item(i);
3067 if (pane.name == wxT("dummy"))
3068 continue;
3069 tab_ctrl_count++;
3070 }
3071
3072 wxSize new_split_size;
3073
3074 // if there is only one tab control, the first split
3075 // should happen around the middle
3076 if (tab_ctrl_count < 2)
3077 {
3078 new_split_size = GetClientSize();
3079 new_split_size.x /= 2;
3080 new_split_size.y /= 2;
3081 }
3082 else
3083 {
3084 // this is in place of a more complicated calculation
3085 // that needs to be implemented
3086 new_split_size = wxSize(180,180);
3087 }
3088
3089 return new_split_size;
3090 }
3091
3092 int wxAuiNotebook::CalculateTabCtrlHeight()
3093 {
3094 // if a fixed tab ctrl height is specified,
3095 // just return that instead of calculating a
3096 // tab height
3097 if (m_requestedTabCtrlHeight != -1)
3098 return m_requestedTabCtrlHeight;
3099
3100 // find out new best tab height
3101 wxAuiTabArt* art = m_tabs.GetArtProvider();
3102
3103 return art->GetBestTabCtrlSize(this,
3104 m_tabs.GetPages(),
3105 m_requestedBmpSize);
3106 }
3107
3108
3109 wxAuiTabArt* wxAuiNotebook::GetArtProvider() const
3110 {
3111 return m_tabs.GetArtProvider();
3112 }
3113
3114 void wxAuiNotebook::SetWindowStyleFlag(long style)
3115 {
3116 wxControl::SetWindowStyleFlag(style);
3117
3118 m_flags = (unsigned int)style;
3119
3120 // if the control is already initialized
3121 if (m_mgr.GetManagedWindow() == (wxWindow*)this)
3122 {
3123 // let all of the tab children know about the new style
3124
3125 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3126 size_t i, pane_count = all_panes.GetCount();
3127 for (i = 0; i < pane_count; ++i)
3128 {
3129 wxAuiPaneInfo& pane = all_panes.Item(i);
3130 if (pane.name == wxT("dummy"))
3131 continue;
3132 wxTabFrame* tabframe = (wxTabFrame*)pane.window;
3133 wxAuiTabCtrl* tabctrl = tabframe->m_tabs;
3134 tabctrl->SetFlags(m_flags);
3135 tabframe->DoSizing();
3136 tabctrl->Refresh();
3137 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
3138 tabctrl->Update();
3139 #endif
3140 }
3141 }
3142 }
3143
3144
3145 bool wxAuiNotebook::AddPage(wxWindow* page,
3146 const wxString& caption,
3147 bool select,
3148 const wxBitmap& bitmap)
3149 {
3150 return InsertPage(GetPageCount(), page, caption, select, bitmap);
3151 }
3152
3153 bool wxAuiNotebook::InsertPage(size_t page_idx,
3154 wxWindow* page,
3155 const wxString& caption,
3156 bool select,
3157 const wxBitmap& bitmap)
3158 {
3159 wxASSERT_MSG(page, wxT("page pointer must be non-NULL"));
3160 if (!page)
3161 return false;
3162
3163 page->Reparent(this);
3164
3165 wxAuiNotebookPage info;
3166 info.window = page;
3167 info.caption = caption;
3168 info.bitmap = bitmap;
3169 info.active = false;
3170
3171 // if there are currently no tabs, the first added
3172 // tab must be active
3173 if (m_tabs.GetPageCount() == 0)
3174 info.active = true;
3175
3176 m_tabs.InsertPage(page, info, page_idx);
3177
3178 // if that was the first page added, even if
3179 // select is false, it must become the "current page"
3180 // (though no select events will be fired)
3181 if (!select && m_tabs.GetPageCount() == 1)
3182 select = true;
3183 //m_curPage = GetPageIndex(page);
3184
3185 wxAuiTabCtrl* active_tabctrl = GetActiveTabCtrl();
3186 if (page_idx >= active_tabctrl->GetPageCount())
3187 active_tabctrl->AddPage(page, info);
3188 else
3189 active_tabctrl->InsertPage(page, info, page_idx);
3190
3191 UpdateTabCtrlHeight();
3192 DoSizing();
3193 active_tabctrl->DoShowHide();
3194
3195 // adjust selected index
3196 if(m_curPage >= (int) page_idx)
3197 m_curPage++;
3198
3199 if (select)
3200 {
3201 SetSelectionToWindow(page);
3202 }
3203
3204 return true;
3205 }
3206
3207
3208 // DeletePage() removes a tab from the multi-notebook,
3209 // and destroys the window as well
3210 bool wxAuiNotebook::DeletePage(size_t page_idx)
3211 {
3212 if (page_idx >= m_tabs.GetPageCount())
3213 return false;
3214
3215 wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3216
3217 // hide the window in advance, as this will
3218 // prevent flicker
3219 ShowWnd(wnd, false);
3220
3221 if (!RemovePage(page_idx))
3222 return false;
3223
3224 #if wxUSE_MDI
3225 // actually destroy the window now
3226 if (wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
3227 {
3228 // delete the child frame with pending delete, as is
3229 // customary with frame windows
3230 if (!wxPendingDelete.Member(wnd))
3231 wxPendingDelete.Append(wnd);
3232 }
3233 else
3234 #endif
3235 {
3236 wnd->Destroy();
3237 }
3238
3239 return true;
3240 }
3241
3242
3243
3244 // RemovePage() removes a tab from the multi-notebook,
3245 // but does not destroy the window
3246 bool wxAuiNotebook::RemovePage(size_t page_idx)
3247 {
3248 // save active window pointer
3249 wxWindow* active_wnd = NULL;
3250 if (m_curPage >= 0)
3251 active_wnd = m_tabs.GetWindowFromIdx(m_curPage);
3252
3253 // save pointer of window being deleted
3254 wxWindow* wnd = m_tabs.GetWindowFromIdx(page_idx);
3255 wxWindow* new_active = NULL;
3256
3257 // make sure we found the page
3258 if (!wnd)
3259 return false;
3260
3261 // find out which onscreen tab ctrl owns this tab
3262 wxAuiTabCtrl* ctrl;
3263 int ctrl_idx;
3264 if (!FindTab(wnd, &ctrl, &ctrl_idx))
3265 return false;
3266
3267 bool is_curpage = (m_curPage == (int)page_idx);
3268 bool is_active_in_split = ctrl->GetPage(ctrl_idx).active;
3269
3270
3271 // remove the tab from main catalog
3272 if (!m_tabs.RemovePage(wnd))
3273 return false;
3274
3275 // remove the tab from the onscreen tab ctrl
3276 ctrl->RemovePage(wnd);
3277
3278 if (is_active_in_split)
3279 {
3280 int ctrl_new_page_count = (int)ctrl->GetPageCount();
3281
3282 if (ctrl_idx >= ctrl_new_page_count)
3283 ctrl_idx = ctrl_new_page_count-1;
3284
3285 if (ctrl_idx >= 0 && ctrl_idx < (int)ctrl->GetPageCount())
3286 {
3287 // set new page as active in the tab split
3288 ctrl->SetActivePage(ctrl_idx);
3289
3290 // if the page deleted was the current page for the
3291 // entire tab control, then record the window
3292 // pointer of the new active page for activation
3293 if (is_curpage)
3294 {
3295 new_active = ctrl->GetWindowFromIdx(ctrl_idx);
3296 }
3297 }
3298 }
3299 else
3300 {
3301 // we are not deleting the active page, so keep it the same
3302 new_active = active_wnd;
3303 }
3304
3305
3306 if (!new_active)
3307 {
3308 // we haven't yet found a new page to active,
3309 // so select the next page from the main tab
3310 // catalogue
3311
3312 if (page_idx < m_tabs.GetPageCount())
3313 {
3314 new_active = m_tabs.GetPage(page_idx).window;
3315 }
3316
3317 if (!new_active && m_tabs.GetPageCount() > 0)
3318 {
3319 new_active = m_tabs.GetPage(0).window;
3320 }
3321 }
3322
3323
3324 RemoveEmptyTabFrames();
3325
3326 m_curPage = wxNOT_FOUND;
3327
3328 // set new active pane unless we're being destroyed anyhow
3329 if (new_active && !m_isBeingDeleted)
3330 SetSelectionToWindow(new_active);
3331
3332 return true;
3333 }
3334
3335 // GetPageIndex() returns the index of the page, or -1 if the
3336 // page could not be located in the notebook
3337 int wxAuiNotebook::GetPageIndex(wxWindow* page_wnd) const
3338 {
3339 return m_tabs.GetIdxFromWindow(page_wnd);
3340 }
3341
3342
3343
3344 // SetPageText() changes the tab caption of the specified page
3345 bool wxAuiNotebook::SetPageText(size_t page_idx, const wxString& text)
3346 {
3347 if (page_idx >= m_tabs.GetPageCount())
3348 return false;
3349
3350 // update our own tab catalog
3351 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3352 page_info.caption = text;
3353
3354 // update what's on screen
3355 wxAuiTabCtrl* ctrl;
3356 int ctrl_idx;
3357 if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3358 {
3359 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3360 info.caption = text;
3361 ctrl->Refresh();
3362 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
3363 ctrl->Update();
3364 #endif
3365 }
3366
3367 return true;
3368 }
3369
3370 // returns the page caption
3371 wxString wxAuiNotebook::GetPageText(size_t page_idx) const
3372 {
3373 if (page_idx >= m_tabs.GetPageCount())
3374 return wxEmptyString;
3375
3376 // update our own tab catalog
3377 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3378 return page_info.caption;
3379 }
3380
3381 bool wxAuiNotebook::SetPageBitmap(size_t page_idx, const wxBitmap& bitmap)
3382 {
3383 if (page_idx >= m_tabs.GetPageCount())
3384 return false;
3385
3386 // update our own tab catalog
3387 wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3388 page_info.bitmap = bitmap;
3389
3390 // tab height might have changed
3391 UpdateTabCtrlHeight();
3392
3393 // update what's on screen
3394 wxAuiTabCtrl* ctrl;
3395 int ctrl_idx;
3396 if (FindTab(page_info.window, &ctrl, &ctrl_idx))
3397 {
3398 wxAuiNotebookPage& info = ctrl->GetPage(ctrl_idx);
3399 info.bitmap = bitmap;
3400 ctrl->Refresh();
3401 #ifdef TODO_REMOVE_IF_NO_PROBLEMS
3402 ctrl->Update();
3403 #endif
3404 }
3405
3406 return true;
3407 }
3408
3409 // returns the page bitmap
3410 wxBitmap wxAuiNotebook::GetPageBitmap(size_t page_idx) const
3411 {
3412 if (page_idx >= m_tabs.GetPageCount())
3413 return wxBitmap();
3414
3415 // update our own tab catalog
3416 const wxAuiNotebookPage& page_info = m_tabs.GetPage(page_idx);
3417 return page_info.bitmap;
3418 }
3419
3420 // GetSelection() returns the index of the currently active page
3421 int wxAuiNotebook::GetSelection() const
3422 {
3423 return m_curPage;
3424 }
3425
3426 // SetSelection() sets the currently active page
3427 int wxAuiNotebook::SetSelection(size_t new_page)
3428 {
3429 return DoModifySelection(new_page, true);
3430 }
3431
3432 void wxAuiNotebook::SetSelectionToWindow(wxWindow *win)
3433 {
3434 const int idx = m_tabs.GetIdxFromWindow(win);
3435 wxCHECK_RET( idx != wxNOT_FOUND, wxT("invalid notebook page") );
3436
3437
3438 // since a tab was clicked, let the parent know that we received
3439 // the focus, even if we will assign that focus immediately
3440 // to the child tab in the SetSelection call below
3441 // (the child focus event will also let wxAuiManager, if any,
3442 // know that the notebook control has been activated)
3443
3444 wxWindow* parent = GetParent();
3445 if (parent)
3446 {
3447 wxChildFocusEvent eventFocus(this);
3448 parent->GetEventHandler()->ProcessEvent(eventFocus);
3449 }
3450
3451
3452 SetSelection(idx);
3453 }
3454
3455 // GetPageCount() returns the total number of
3456 // pages managed by the multi-notebook
3457 size_t wxAuiNotebook::GetPageCount() const
3458 {
3459 return m_tabs.GetPageCount();
3460 }
3461
3462 // GetPage() returns the wxWindow pointer of the
3463 // specified page
3464 wxWindow* wxAuiNotebook::GetPage(size_t page_idx) const
3465 {
3466 wxASSERT(page_idx < m_tabs.GetPageCount());
3467
3468 return m_tabs.GetWindowFromIdx(page_idx);
3469 }
3470
3471 // DoSizing() performs all sizing operations in each tab control
3472 void wxAuiNotebook::DoSizing()
3473 {
3474 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3475 size_t i, pane_count = all_panes.GetCount();
3476 for (i = 0; i < pane_count; ++i)
3477 {
3478 if (all_panes.Item(i).name == wxT("dummy"))
3479 continue;
3480
3481 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3482 tabframe->DoSizing();
3483 }
3484 }
3485
3486 // GetActiveTabCtrl() returns the active tab control. It is
3487 // called to determine which control gets new windows being added
3488 wxAuiTabCtrl* wxAuiNotebook::GetActiveTabCtrl()
3489 {
3490 if (m_curPage >= 0 && m_curPage < (int)m_tabs.GetPageCount())
3491 {
3492 wxAuiTabCtrl* ctrl;
3493 int idx;
3494
3495 // find the tab ctrl with the current page
3496 if (FindTab(m_tabs.GetPage(m_curPage).window,
3497 &ctrl, &idx))
3498 {
3499 return ctrl;
3500 }
3501 }
3502
3503 // no current page, just find the first tab ctrl
3504 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3505 size_t i, pane_count = all_panes.GetCount();
3506 for (i = 0; i < pane_count; ++i)
3507 {
3508 if (all_panes.Item(i).name == wxT("dummy"))
3509 continue;
3510
3511 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3512 return tabframe->m_tabs;
3513 }
3514
3515 // If there is no tabframe at all, create one
3516 wxTabFrame* tabframe = new wxTabFrame;
3517 tabframe->SetTabCtrlHeight(m_tabCtrlHeight);
3518 tabframe->m_tabs = new wxAuiTabCtrl(this,
3519 m_tabIdCounter++,
3520 wxDefaultPosition,
3521 wxDefaultSize,
3522 wxNO_BORDER|wxWANTS_CHARS);
3523 tabframe->m_tabs->SetFlags(m_flags);
3524 tabframe->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3525 m_mgr.AddPane(tabframe,
3526 wxAuiPaneInfo().Center().CaptionVisible(false));
3527
3528 m_mgr.Update();
3529
3530 return tabframe->m_tabs;
3531 }
3532
3533 // FindTab() finds the tab control that currently contains the window as well
3534 // as the index of the window in the tab control. It returns true if the
3535 // window was found, otherwise false.
3536 bool wxAuiNotebook::FindTab(wxWindow* page, wxAuiTabCtrl** ctrl, int* idx)
3537 {
3538 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
3539 size_t i, pane_count = all_panes.GetCount();
3540 for (i = 0; i < pane_count; ++i)
3541 {
3542 if (all_panes.Item(i).name == wxT("dummy"))
3543 continue;
3544
3545 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
3546
3547 int page_idx = tabframe->m_tabs->GetIdxFromWindow(page);
3548 if (page_idx != -1)
3549 {
3550 *ctrl = tabframe->m_tabs;
3551 *idx = page_idx;
3552 return true;
3553 }
3554 }
3555
3556 return false;
3557 }
3558
3559 void wxAuiNotebook::Split(size_t page, int direction)
3560 {
3561 wxSize cli_size = GetClientSize();
3562
3563 // get the page's window pointer
3564 wxWindow* wnd = GetPage(page);
3565 if (!wnd)
3566 return;
3567
3568 // notebooks with 1 or less pages can't be split
3569 if (GetPageCount() < 2)
3570 return;
3571
3572 // find out which tab control the page currently belongs to
3573 wxAuiTabCtrl *src_tabs, *dest_tabs;
3574 int src_idx = -1;
3575 src_tabs = NULL;
3576 if (!FindTab(wnd, &src_tabs, &src_idx))
3577 return;
3578 if (!src_tabs || src_idx == -1)
3579 return;
3580
3581 // choose a split size
3582 wxSize split_size;
3583 if (GetPageCount() > 2)
3584 {
3585 split_size = CalculateNewSplitSize();
3586 }
3587 else
3588 {
3589 // because there are two panes, always split them
3590 // equally
3591 split_size = GetClientSize();
3592 split_size.x /= 2;
3593 split_size.y /= 2;
3594 }
3595
3596
3597 // create a new tab frame
3598 wxTabFrame* new_tabs = new wxTabFrame;
3599 new_tabs->m_rect = wxRect(wxPoint(0,0), split_size);
3600 new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);
3601 new_tabs->m_tabs = new wxAuiTabCtrl(this,
3602 m_tabIdCounter++,
3603 wxDefaultPosition,
3604 wxDefaultSize,
3605 wxNO_BORDER|wxWANTS_CHARS);
3606 new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
3607 new_tabs->m_tabs->SetFlags(m_flags);
3608 dest_tabs = new_tabs->m_tabs;
3609
3610 // create a pane info structure with the information
3611 // about where the pane should be added
3612 wxAuiPaneInfo paneInfo = wxAuiPaneInfo().Bottom().CaptionVisible(false);
3613 wxPoint mouse_pt;
3614
3615 if (direction == wxLEFT)
3616 {
3617 paneInfo.Left();
3618 mouse_pt = wxPoint(0, cli_size.y/2);
3619 }
3620 else if (direction == wxRIGHT)
3621 {
3622 paneInfo.Right();
3623 mouse_pt = wxPoint(cli_size.x, cli_size.y/2);
3624 }
3625 else if (direction == wxTOP)
3626 {
3627 paneInfo.Top();
3628 mouse_pt = wxPoint(cli_size.x/2, 0);
3629 }
3630 else if (direction == wxBOTTOM)
3631 {
3632 paneInfo.Bottom();
3633 mouse_pt = wxPoint(cli_size.x/2, cli_size.y);
3634 }
3635
3636 m_mgr.AddPane(new_tabs, paneInfo, mouse_pt);
3637 m_mgr.Update();
3638
3639 // remove the page from the source tabs
3640 wxAuiNotebookPage page_info = src_tabs->GetPage(src_idx);
3641 page_info.active = false;
3642 src_tabs->RemovePage(page_info.window);
3643 if (src_tabs->GetPageCount() > 0)
3644 {
3645 src_tabs->SetActivePage((size_t)0);
3646 src_tabs->DoShowHide();
3647 src_tabs->Refresh();
3648 }
3649
3650
3651 // add the page to the destination tabs
3652 dest_tabs->InsertPage(page_info.window, page_info, 0);
3653
3654 if (src_tabs->GetPageCount() == 0)
3655 {
3656 RemoveEmptyTabFrames();
3657 }
3658
3659 DoSizing();
3660 dest_tabs->DoShowHide();
3661 dest_tabs->Refresh();
3662
3663 // force the set selection function reset the selection
3664 m_curPage = -1;
3665
3666 // set the active page to the one we just split off
3667 SetSelectionToPage(page_info);
3668
3669 UpdateHintWindowSize();
3670 }
3671
3672
3673 void wxAuiNotebook::OnSize(wxSizeEvent& evt)
3674 {
3675 UpdateHintWindowSize();
3676
3677 evt.Skip();
3678 }
3679
3680 void wxAuiNotebook::OnTabClicked(wxAuiNotebookEvent& evt)
3681 {
3682 wxAuiTabCtrl* ctrl = (wxAuiTabCtrl*)evt.GetEventObject();
3683 wxASSERT(ctrl != NULL);
3684
3685 wxWindow* wnd = ctrl->GetWindowFromIdx(evt.GetSelection());
3686 wxASSERT(wnd != NULL);
3687
3688 SetSelectionToWindow(wnd);
3689 }
3690
3691 void wxAuiNotebook::OnTabBgDClick(wxAuiNotebookEvent& WXUNUSED(evt))
3692 {
3693 // notify owner that the tabbar background has been double-clicked
3694 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK, m_windowId);
3695 e.SetEventObject(this);
3696 GetEventHandler()->ProcessEvent(e);
3697 }
3698
3699 void wxAuiNotebook::OnTabBeginDrag(wxAuiNotebookEvent&)
3700 {
3701 m_lastDragX = 0;
3702 }
3703
3704 void wxAuiNotebook::OnTabDragMotion(wxAuiNotebookEvent& evt)
3705 {
3706 wxPoint screen_pt = ::wxGetMousePosition();
3707 wxPoint client_pt = ScreenToClient(screen_pt);
3708 wxPoint zero(0,0);
3709
3710 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3711 wxAuiTabCtrl* dest_tabs = GetTabCtrlFromPoint(client_pt);
3712
3713 if (dest_tabs == src_tabs)
3714 {
3715 if (src_tabs)
3716 {
3717 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3718 }
3719
3720 // always hide the hint for inner-tabctrl drag
3721 m_mgr.HideHint();
3722
3723 // if tab moving is not allowed, leave
3724 if (!(m_flags & wxAUI_NB_TAB_MOVE))
3725 {
3726 return;
3727 }
3728
3729 wxPoint pt = dest_tabs->ScreenToClient(screen_pt);
3730 wxWindow* dest_location_tab;
3731
3732 // this is an inner-tab drag/reposition
3733 if (dest_tabs->TabHitTest(pt.x, pt.y, &dest_location_tab))
3734 {
3735 int src_idx = evt.GetSelection();
3736 int dest_idx = dest_tabs->GetIdxFromWindow(dest_location_tab);
3737
3738 // prevent jumpy drag
3739 if ((src_idx == dest_idx) || dest_idx == -1 ||
3740 (src_idx > dest_idx && m_lastDragX <= pt.x) ||
3741 (src_idx < dest_idx && m_lastDragX >= pt.x))
3742 {
3743 m_lastDragX = pt.x;
3744 return;
3745 }
3746
3747
3748 wxWindow* src_tab = dest_tabs->GetWindowFromIdx(src_idx);
3749 dest_tabs->MovePage(src_tab, dest_idx);
3750 dest_tabs->SetActivePage((size_t)dest_idx);
3751 dest_tabs->DoShowHide();
3752 dest_tabs->Refresh();
3753 m_lastDragX = pt.x;
3754
3755 }
3756
3757 return;
3758 }
3759
3760
3761 // if external drag is allowed, check if the tab is being dragged
3762 // over a different wxAuiNotebook control
3763 if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3764 {
3765 wxWindow* tab_ctrl = ::wxFindWindowAtPoint(screen_pt);
3766
3767 // if we aren't over any window, stop here
3768 if (!tab_ctrl)
3769 return;
3770
3771 // make sure we are not over the hint window
3772 if (!tab_ctrl->IsKindOf(CLASSINFO(wxFrame)))
3773 {
3774 while (tab_ctrl)
3775 {
3776 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3777 break;
3778 tab_ctrl = tab_ctrl->GetParent();
3779 }
3780
3781 if (tab_ctrl)
3782 {
3783 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3784
3785 if (nb != this)
3786 {
3787 wxRect hint_rect = tab_ctrl->GetClientRect();
3788 tab_ctrl->ClientToScreen(&hint_rect.x, &hint_rect.y);
3789 m_mgr.ShowHint(hint_rect);
3790 return;
3791 }
3792 }
3793 }
3794 else
3795 {
3796 if (!dest_tabs)
3797 {
3798 // we are either over a hint window, or not over a tab
3799 // window, and there is no where to drag to, so exit
3800 return;
3801 }
3802 }
3803 }
3804
3805
3806 // if there are less than two panes, split can't happen, so leave
3807 if (m_tabs.GetPageCount() < 2)
3808 return;
3809
3810 // if tab moving is not allowed, leave
3811 if (!(m_flags & wxAUI_NB_TAB_SPLIT))
3812 return;
3813
3814
3815 if (src_tabs)
3816 {
3817 src_tabs->SetCursor(wxCursor(wxCURSOR_SIZING));
3818 }
3819
3820
3821 if (dest_tabs)
3822 {
3823 wxRect hint_rect = dest_tabs->GetRect();
3824 ClientToScreen(&hint_rect.x, &hint_rect.y);
3825 m_mgr.ShowHint(hint_rect);
3826 }
3827 else
3828 {
3829 m_mgr.DrawHintRect(m_dummyWnd, client_pt, zero);
3830 }
3831 }
3832
3833
3834
3835 void wxAuiNotebook::OnTabEndDrag(wxAuiNotebookEvent& evt)
3836 {
3837 m_mgr.HideHint();
3838
3839
3840 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
3841 wxCHECK_RET( src_tabs, wxT("no source object?") );
3842
3843 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
3844
3845 // get the mouse position, which will be used to determine the drop point
3846 wxPoint mouse_screen_pt = ::wxGetMousePosition();
3847 wxPoint mouse_client_pt = ScreenToClient(mouse_screen_pt);
3848
3849
3850
3851 // check for an external move
3852 if (m_flags & wxAUI_NB_TAB_EXTERNAL_MOVE)
3853 {
3854 wxWindow* tab_ctrl = ::wxFindWindowAtPoint(mouse_screen_pt);
3855
3856 while (tab_ctrl)
3857 {
3858 if (tab_ctrl->IsKindOf(CLASSINFO(wxAuiTabCtrl)))
3859 break;
3860 tab_ctrl = tab_ctrl->GetParent();
3861 }
3862
3863 if (tab_ctrl)
3864 {
3865 wxAuiNotebook* nb = (wxAuiNotebook*)tab_ctrl->GetParent();
3866
3867 if (nb != this)
3868 {
3869 // find out from the destination control
3870 // if it's ok to drop this tab here
3871 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, m_windowId);
3872 e.SetSelection(evt.GetSelection());
3873 e.SetOldSelection(evt.GetSelection());
3874 e.SetEventObject(this);
3875 e.SetDragSource(this);
3876 e.Veto(); // dropping must be explicitly approved by control owner
3877
3878 nb->GetEventHandler()->ProcessEvent(e);
3879
3880 if (!e.IsAllowed())
3881 {
3882 // no answer or negative answer
3883 m_mgr.HideHint();
3884 return;
3885 }
3886
3887 // drop was allowed
3888 int src_idx = evt.GetSelection();
3889 wxWindow* src_page = src_tabs->GetWindowFromIdx(src_idx);
3890
3891 // Check that it's not an impossible parent relationship
3892 wxWindow* p = nb;
3893 while (p && !p->IsTopLevel())
3894 {
3895 if (p == src_page)
3896 {
3897 return;
3898 }
3899 p = p->GetParent();
3900 }
3901
3902 // get main index of the page
3903 int main_idx = m_tabs.GetIdxFromWindow(src_page);
3904 wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no source page?") );
3905
3906
3907 // make a copy of the page info
3908 wxAuiNotebookPage page_info = m_tabs.GetPage(main_idx);
3909
3910 // remove the page from the source notebook
3911 RemovePage(main_idx);
3912
3913 // reparent the page
3914 src_page->Reparent(nb);
3915
3916
3917 // found out the insert idx
3918 wxAuiTabCtrl* dest_tabs = (wxAuiTabCtrl*)tab_ctrl;
3919 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3920
3921 wxWindow* target = NULL;
3922 int insert_idx = -1;
3923 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3924 if (target)
3925 {
3926 insert_idx = dest_tabs->GetIdxFromWindow(target);
3927 }
3928
3929
3930 // add the page to the new notebook
3931 if (insert_idx == -1)
3932 insert_idx = dest_tabs->GetPageCount();
3933 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
3934 nb->m_tabs.AddPage(page_info.window, page_info);
3935
3936 nb->DoSizing();
3937 dest_tabs->DoShowHide();
3938 dest_tabs->Refresh();
3939
3940 // set the selection in the destination tab control
3941 nb->SetSelectionToPage(page_info);
3942
3943 // notify owner that the tab has been dragged
3944 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
3945 e2.SetSelection(evt.GetSelection());
3946 e2.SetOldSelection(evt.GetSelection());
3947 e2.SetEventObject(this);
3948 GetEventHandler()->ProcessEvent(e2);
3949
3950 return;
3951 }
3952 }
3953 }
3954
3955
3956
3957
3958 // only perform a tab split if it's allowed
3959 wxAuiTabCtrl* dest_tabs = NULL;
3960
3961 if ((m_flags & wxAUI_NB_TAB_SPLIT) && m_tabs.GetPageCount() >= 2)
3962 {
3963 // If the pointer is in an existing tab frame, do a tab insert
3964 wxWindow* hit_wnd = ::wxFindWindowAtPoint(mouse_screen_pt);
3965 wxTabFrame* tab_frame = (wxTabFrame*)GetTabFrameFromTabCtrl(hit_wnd);
3966 int insert_idx = -1;
3967 if (tab_frame)
3968 {
3969 dest_tabs = tab_frame->m_tabs;
3970
3971 if (dest_tabs == src_tabs)
3972 return;
3973
3974
3975 wxPoint pt = dest_tabs->ScreenToClient(mouse_screen_pt);
3976 wxWindow* target = NULL;
3977 dest_tabs->TabHitTest(pt.x, pt.y, &target);
3978 if (target)
3979 {
3980 insert_idx = dest_tabs->GetIdxFromWindow(target);
3981 }
3982 }
3983 else
3984 {
3985 wxPoint zero(0,0);
3986 wxRect rect = m_mgr.CalculateHintRect(m_dummyWnd,
3987 mouse_client_pt,
3988 zero);
3989 if (rect.IsEmpty())
3990 {
3991 // there is no suitable drop location here, exit out
3992 return;
3993 }
3994
3995 // If there is no tabframe at all, create one
3996 wxTabFrame* new_tabs = new wxTabFrame;
3997 new_tabs->m_rect = wxRect(wxPoint(0,0), CalculateNewSplitSize());
3998 new_tabs->SetTabCtrlHeight(m_tabCtrlHeight);
3999 new_tabs->m_tabs = new wxAuiTabCtrl(this,
4000 m_tabIdCounter++,
4001 wxDefaultPosition,
4002 wxDefaultSize,
4003 wxNO_BORDER|wxWANTS_CHARS);
4004 new_tabs->m_tabs->SetArtProvider(m_tabs.GetArtProvider()->Clone());
4005 new_tabs->m_tabs->SetFlags(m_flags);
4006
4007 m_mgr.AddPane(new_tabs,
4008 wxAuiPaneInfo().Bottom().CaptionVisible(false),
4009 mouse_client_pt);
4010 m_mgr.Update();
4011 dest_tabs = new_tabs->m_tabs;
4012 }
4013
4014
4015
4016 // remove the page from the source tabs
4017 wxAuiNotebookPage page_info = src_tabs->GetPage(evt.GetSelection());
4018 page_info.active = false;
4019 src_tabs->RemovePage(page_info.window);
4020 if (src_tabs->GetPageCount() > 0)
4021 {
4022 src_tabs->SetActivePage((size_t)0);
4023 src_tabs->DoShowHide();
4024 src_tabs->Refresh();
4025 }
4026
4027
4028
4029 // add the page to the destination tabs
4030 if (insert_idx == -1)
4031 insert_idx = dest_tabs->GetPageCount();
4032 dest_tabs->InsertPage(page_info.window, page_info, insert_idx);
4033
4034 if (src_tabs->GetPageCount() == 0)
4035 {
4036 RemoveEmptyTabFrames();
4037 }
4038
4039 DoSizing();
4040 dest_tabs->DoShowHide();
4041 dest_tabs->Refresh();
4042
4043 // force the set selection function reset the selection
4044 m_curPage = -1;
4045
4046 // set the active page to the one we just split off
4047 SetSelectionToPage(page_info);
4048
4049 UpdateHintWindowSize();
4050 }
4051
4052 // notify owner that the tab has been dragged
4053 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE, m_windowId);
4054 e.SetSelection(evt.GetSelection());
4055 e.SetOldSelection(evt.GetSelection());
4056 e.SetEventObject(this);
4057 GetEventHandler()->ProcessEvent(e);
4058 }
4059
4060
4061
4062 void wxAuiNotebook::OnTabCancelDrag(wxAuiNotebookEvent& command_evt)
4063 {
4064 wxAuiNotebookEvent& evt = (wxAuiNotebookEvent&)command_evt;
4065
4066 m_mgr.HideHint();
4067
4068 wxAuiTabCtrl* src_tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4069 wxCHECK_RET( src_tabs, wxT("no source object?") );
4070
4071 src_tabs->SetCursor(wxCursor(wxCURSOR_ARROW));
4072 }
4073
4074 wxAuiTabCtrl* wxAuiNotebook::GetTabCtrlFromPoint(const wxPoint& pt)
4075 {
4076 // if we've just removed the last tab from the source
4077 // tab set, the remove the tab control completely
4078 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4079 size_t i, pane_count = all_panes.GetCount();
4080 for (i = 0; i < pane_count; ++i)
4081 {
4082 if (all_panes.Item(i).name == wxT("dummy"))
4083 continue;
4084
4085 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
4086 if (tabframe->m_tab_rect.Contains(pt))
4087 return tabframe->m_tabs;
4088 }
4089
4090 return NULL;
4091 }
4092
4093 wxWindow* wxAuiNotebook::GetTabFrameFromTabCtrl(wxWindow* tab_ctrl)
4094 {
4095 // if we've just removed the last tab from the source
4096 // tab set, the remove the tab control completely
4097 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4098 size_t i, pane_count = all_panes.GetCount();
4099 for (i = 0; i < pane_count; ++i)
4100 {
4101 if (all_panes.Item(i).name == wxT("dummy"))
4102 continue;
4103
4104 wxTabFrame* tabframe = (wxTabFrame*)all_panes.Item(i).window;
4105 if (tabframe->m_tabs == tab_ctrl)
4106 {
4107 return tabframe;
4108 }
4109 }
4110
4111 return NULL;
4112 }
4113
4114 void wxAuiNotebook::RemoveEmptyTabFrames()
4115 {
4116 // if we've just removed the last tab from the source
4117 // tab set, the remove the tab control completely
4118 wxAuiPaneInfoArray all_panes = m_mgr.GetAllPanes();
4119 size_t i, pane_count = all_panes.GetCount();
4120 for (i = 0; i < pane_count; ++i)
4121 {
4122 if (all_panes.Item(i).name == wxT("dummy"))
4123 continue;
4124
4125 wxTabFrame* tab_frame = (wxTabFrame*)all_panes.Item(i).window;
4126 if (tab_frame->m_tabs->GetPageCount() == 0)
4127 {
4128 m_mgr.DetachPane(tab_frame);
4129
4130 // use pending delete because sometimes during
4131 // window closing, refreshs are pending
4132 if (!wxPendingDelete.Member(tab_frame->m_tabs))
4133 wxPendingDelete.Append(tab_frame->m_tabs);
4134
4135 tab_frame->m_tabs = NULL;
4136
4137 delete tab_frame;
4138 }
4139 }
4140
4141
4142 // check to see if there is still a center pane;
4143 // if there isn't, make a frame the center pane
4144 wxAuiPaneInfoArray panes = m_mgr.GetAllPanes();
4145 pane_count = panes.GetCount();
4146 wxWindow* first_good = NULL;
4147 bool center_found = false;
4148 for (i = 0; i < pane_count; ++i)
4149 {
4150 if (panes.Item(i).name == wxT("dummy"))
4151 continue;
4152 if (panes.Item(i).dock_direction == wxAUI_DOCK_CENTRE)
4153 center_found = true;
4154 if (!first_good)
4155 first_good = panes.Item(i).window;
4156 }
4157
4158 if (!center_found && first_good)
4159 {
4160 m_mgr.GetPane(first_good).Centre();
4161 }
4162
4163 if (!m_isBeingDeleted)
4164 m_mgr.Update();
4165 }
4166
4167 void wxAuiNotebook::OnChildFocusNotebook(wxChildFocusEvent& evt)
4168 {
4169 evt.Skip();
4170
4171 // if we're dragging a tab, don't change the current selection.
4172 // This code prevents a bug that used to happen when the hint window
4173 // was hidden. In the bug, the focus would return to the notebook
4174 // child, which would then enter this handler and call
4175 // SetSelection, which is not desired turn tab dragging.
4176
4177 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4178 size_t i, pane_count = all_panes.GetCount();
4179 for (i = 0; i < pane_count; ++i)
4180 {
4181 wxAuiPaneInfo& pane = all_panes.Item(i);
4182 if (pane.name == wxT("dummy"))
4183 continue;
4184 wxTabFrame* tabframe = (wxTabFrame*)pane.window;
4185 if (tabframe->m_tabs->IsDragging())
4186 return;
4187 }
4188
4189
4190 // change the tab selection to the child
4191 // which was focused
4192 int idx = m_tabs.GetIdxFromWindow(evt.GetWindow());
4193 if (idx != -1 && idx != m_curPage)
4194 {
4195 SetSelection(idx);
4196 }
4197 }
4198
4199 void wxAuiNotebook::OnNavigationKeyNotebook(wxNavigationKeyEvent& event)
4200 {
4201 if ( event.IsWindowChange() ) {
4202 // change pages
4203 // FIXME: the problem with this is that if we have a split notebook,
4204 // we selection may go all over the place.
4205 AdvanceSelection(event.GetDirection());
4206 }
4207 else {
4208 // we get this event in 3 cases
4209 //
4210 // a) one of our pages might have generated it because the user TABbed
4211 // out from it in which case we should propagate the event upwards and
4212 // our parent will take care of setting the focus to prev/next sibling
4213 //
4214 // or
4215 //
4216 // b) the parent panel wants to give the focus to us so that we
4217 // forward it to our selected page. We can't deal with this in
4218 // OnSetFocus() because we don't know which direction the focus came
4219 // from in this case and so can't choose between setting the focus to
4220 // first or last panel child
4221 //
4222 // or
4223 //
4224 // c) we ourselves (see MSWTranslateMessage) generated the event
4225 //
4226 wxWindow * const parent = GetParent();
4227
4228 // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
4229 const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
4230 const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
4231
4232 if ( isFromParent || isFromSelf )
4233 {
4234 // no, it doesn't come from child, case (b) or (c): forward to a
4235 // page but only if direction is backwards (TAB) or from ourselves,
4236 if ( GetSelection() != wxNOT_FOUND &&
4237 (!event.GetDirection() || isFromSelf) )
4238 {
4239 // so that the page knows that the event comes from it's parent
4240 // and is being propagated downwards
4241 event.SetEventObject(this);
4242
4243 wxWindow *page = GetPage(GetSelection());
4244 if ( !page->GetEventHandler()->ProcessEvent(event) )
4245 {
4246 page->SetFocus();
4247 }
4248 //else: page manages focus inside it itself
4249 }
4250 else // otherwise set the focus to the notebook itself
4251 {
4252 SetFocus();
4253 }
4254 }
4255 else
4256 {
4257 // it comes from our child, case (a), pass to the parent, but only
4258 // if the direction is forwards. Otherwise set the focus to the
4259 // notebook itself. The notebook is always the 'first' control of a
4260 // page.
4261 if ( !event.GetDirection() )
4262 {
4263 SetFocus();
4264 }
4265 else if ( parent )
4266 {
4267 event.SetCurrentFocus(this);
4268 parent->GetEventHandler()->ProcessEvent(event);
4269 }
4270 }
4271 }
4272 }
4273
4274 void wxAuiNotebook::OnTabButton(wxAuiNotebookEvent& evt)
4275 {
4276 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4277
4278 int button_id = evt.GetInt();
4279
4280 if (button_id == wxAUI_BUTTON_CLOSE)
4281 {
4282 int selection = evt.GetSelection();
4283
4284 if (selection == -1)
4285 {
4286 // if the close button is to the right, use the active
4287 // page selection to determine which page to close
4288 selection = tabs->GetActivePage();
4289 }
4290
4291 if (selection != -1)
4292 {
4293 wxWindow* close_wnd = tabs->GetWindowFromIdx(selection);
4294
4295 // ask owner if it's ok to close the tab
4296 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, m_windowId);
4297 e.SetSelection(m_tabs.GetIdxFromWindow(close_wnd));
4298 const int idx = m_tabs.GetIdxFromWindow(close_wnd);
4299 e.SetSelection(idx);
4300 e.SetOldSelection(evt.GetSelection());
4301 e.SetEventObject(this);
4302 GetEventHandler()->ProcessEvent(e);
4303 if (!e.IsAllowed())
4304 return;
4305
4306
4307 #if wxUSE_MDI
4308 if (close_wnd->IsKindOf(CLASSINFO(wxAuiMDIChildFrame)))
4309 {
4310 close_wnd->Close();
4311 }
4312 else
4313 #endif
4314 {
4315 int main_idx = m_tabs.GetIdxFromWindow(close_wnd);
4316 wxCHECK_RET( main_idx != wxNOT_FOUND, wxT("no page to delete?") );
4317
4318 DeletePage(main_idx);
4319 }
4320
4321 // notify owner that the tab has been closed
4322 wxAuiNotebookEvent e2(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED, m_windowId);
4323 e2.SetSelection(idx);
4324 e2.SetEventObject(this);
4325 GetEventHandler()->ProcessEvent(e2);
4326 }
4327 }
4328 }
4329
4330
4331 void wxAuiNotebook::OnTabMiddleDown(wxAuiNotebookEvent& evt)
4332 {
4333 // patch event through to owner
4334 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4335 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4336
4337 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN, m_windowId);
4338 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4339 e.SetEventObject(this);
4340 GetEventHandler()->ProcessEvent(e);
4341 }
4342
4343 void wxAuiNotebook::OnTabMiddleUp(wxAuiNotebookEvent& evt)
4344 {
4345 // if the wxAUI_NB_MIDDLE_CLICK_CLOSE is specified, middle
4346 // click should act like a tab close action. However, first
4347 // give the owner an opportunity to handle the middle up event
4348 // for custom action
4349
4350 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4351 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4352
4353 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP, m_windowId);
4354 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4355 e.SetEventObject(this);
4356 if (GetEventHandler()->ProcessEvent(e))
4357 return;
4358 if (!e.IsAllowed())
4359 return;
4360
4361 // check if we are supposed to close on middle-up
4362 if ((m_flags & wxAUI_NB_MIDDLE_CLICK_CLOSE) == 0)
4363 return;
4364
4365 // simulate the user pressing the close button on the tab
4366 evt.SetInt(wxAUI_BUTTON_CLOSE);
4367 OnTabButton(evt);
4368 }
4369
4370 void wxAuiNotebook::OnTabRightDown(wxAuiNotebookEvent& evt)
4371 {
4372 // patch event through to owner
4373 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4374 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4375
4376 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN, m_windowId);
4377 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4378 e.SetEventObject(this);
4379 GetEventHandler()->ProcessEvent(e);
4380 }
4381
4382 void wxAuiNotebook::OnTabRightUp(wxAuiNotebookEvent& evt)
4383 {
4384 // patch event through to owner
4385 wxAuiTabCtrl* tabs = (wxAuiTabCtrl*)evt.GetEventObject();
4386 wxWindow* wnd = tabs->GetWindowFromIdx(evt.GetSelection());
4387
4388 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP, m_windowId);
4389 e.SetSelection(m_tabs.GetIdxFromWindow(wnd));
4390 e.SetEventObject(this);
4391 GetEventHandler()->ProcessEvent(e);
4392 }
4393
4394 // Sets the normal font
4395 void wxAuiNotebook::SetNormalFont(const wxFont& font)
4396 {
4397 m_normalFont = font;
4398 GetArtProvider()->SetNormalFont(font);
4399 }
4400
4401 // Sets the selected tab font
4402 void wxAuiNotebook::SetSelectedFont(const wxFont& font)
4403 {
4404 m_selectedFont = font;
4405 GetArtProvider()->SetSelectedFont(font);
4406 }
4407
4408 // Sets the measuring font
4409 void wxAuiNotebook::SetMeasuringFont(const wxFont& font)
4410 {
4411 GetArtProvider()->SetMeasuringFont(font);
4412 }
4413
4414 // Sets the tab font
4415 bool wxAuiNotebook::SetFont(const wxFont& font)
4416 {
4417 wxControl::SetFont(font);
4418
4419 wxFont normalFont(font);
4420 wxFont selectedFont(normalFont);
4421 selectedFont.SetWeight(wxBOLD);
4422
4423 SetNormalFont(normalFont);
4424 SetSelectedFont(selectedFont);
4425 SetMeasuringFont(selectedFont);
4426
4427 return true;
4428 }
4429
4430 // Gets the tab control height
4431 int wxAuiNotebook::GetTabCtrlHeight() const
4432 {
4433 return m_tabCtrlHeight;
4434 }
4435
4436 // Gets the height of the notebook for a given page height
4437 int wxAuiNotebook::GetHeightForPageHeight(int pageHeight)
4438 {
4439 UpdateTabCtrlHeight();
4440
4441 int tabCtrlHeight = GetTabCtrlHeight();
4442 int decorHeight = 2;
4443 return tabCtrlHeight + pageHeight + decorHeight;
4444 }
4445
4446 // Advances the selection, generation page selection events
4447 void wxAuiNotebook::AdvanceSelection(bool forward)
4448 {
4449 if (GetPageCount() <= 1)
4450 return;
4451
4452 int currentSelection = GetSelection();
4453
4454 if (forward)
4455 {
4456 if (currentSelection == (int) (GetPageCount() - 1))
4457 return;
4458 else if (currentSelection == -1)
4459 currentSelection = 0;
4460 else
4461 currentSelection ++;
4462 }
4463 else
4464 {
4465 if (currentSelection <= 0)
4466 return;
4467 else
4468 currentSelection --;
4469 }
4470
4471 SetSelection(currentSelection);
4472 }
4473
4474 // Shows the window menu
4475 bool wxAuiNotebook::ShowWindowMenu()
4476 {
4477 wxAuiTabCtrl* tabCtrl = GetActiveTabCtrl();
4478
4479 int idx = tabCtrl->GetArtProvider()->ShowDropDown(tabCtrl, tabCtrl->GetPages(), tabCtrl->GetActivePage());
4480
4481 if (idx != -1)
4482 {
4483 wxAuiNotebookEvent e(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, tabCtrl->GetId());
4484 e.SetSelection(idx);
4485 e.SetOldSelection(tabCtrl->GetActivePage());
4486 e.SetEventObject(tabCtrl);
4487 GetEventHandler()->ProcessEvent(e);
4488
4489 return true;
4490 }
4491 else
4492 return false;
4493 }
4494
4495 void wxAuiNotebook::Thaw()
4496 {
4497 DoSizing();
4498
4499 wxControl::Thaw();
4500 }
4501
4502 void wxAuiNotebook::SetPageSize (const wxSize& WXUNUSED(size))
4503 {
4504 wxFAIL_MSG("Not implemented for wxAuiNotebook");
4505 }
4506
4507 int wxAuiNotebook::HitTest (const wxPoint& WXUNUSED(pt), long* WXUNUSED(flags)) const
4508 {
4509 wxFAIL_MSG("Not implemented for wxAuiNotebook");
4510 return wxNOT_FOUND;
4511 }
4512
4513 int wxAuiNotebook::GetPageImage(size_t WXUNUSED(n)) const
4514 {
4515 wxFAIL_MSG("Not implemented for wxAuiNotebook");
4516 return -1;
4517 }
4518
4519 bool wxAuiNotebook::SetPageImage(size_t n, int imageId)
4520 {
4521 return SetPageBitmap(n, GetImageList()->GetBitmap(imageId));
4522 }
4523
4524 wxWindow* wxAuiNotebook::GetCurrentPage () const
4525 {
4526 return GetPage(GetSelection());
4527 }
4528
4529 int wxAuiNotebook::ChangeSelection(size_t n)
4530 {
4531 return DoModifySelection(n, false);
4532 }
4533
4534 bool wxAuiNotebook::AddPage(wxWindow *page, const wxString &text, bool select,
4535 int imageId)
4536 {
4537 if(HasImageList())
4538 {
4539 return AddPage(page, text, select, GetImageList()->GetBitmap(imageId));
4540 }
4541 else
4542 {
4543 return AddPage(page, text, select, wxNullBitmap);
4544 }
4545 }
4546
4547 bool wxAuiNotebook::DeleteAllPages()
4548 {
4549 size_t count = GetPageCount();
4550 for(size_t i = 0; i < count; i++)
4551 {
4552 DeletePage(0);
4553 }
4554 return true;
4555 }
4556
4557 bool wxAuiNotebook::InsertPage(size_t index, wxWindow *page,
4558 const wxString &text, bool select,
4559 int imageId)
4560 {
4561 if(HasImageList())
4562 {
4563 return InsertPage(index, page, text, select,
4564 GetImageList()->GetBitmap(imageId));
4565 }
4566 else
4567 {
4568 return InsertPage(index, page, text, select, wxNullBitmap);
4569 }
4570 }
4571
4572 int wxAuiNotebook::DoModifySelection(size_t n, bool events)
4573 {
4574 wxWindow* wnd = m_tabs.GetWindowFromIdx(n);
4575 if (!wnd)
4576 return m_curPage;
4577
4578 // don't change the page unless necessary;
4579 // however, clicking again on a tab should give it the focus.
4580 if ((int)n == m_curPage)
4581 {
4582 wxAuiTabCtrl* ctrl;
4583 int ctrl_idx;
4584 if (FindTab(wnd, &ctrl, &ctrl_idx))
4585 {
4586 if (FindFocus() != ctrl)
4587 ctrl->SetFocus();
4588 }
4589 return m_curPage;
4590 }
4591
4592 bool vetoed = false;
4593
4594 wxAuiNotebookEvent evt(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING, m_windowId);
4595
4596 if(events)
4597 {
4598 evt.SetSelection(n);
4599 evt.SetOldSelection(m_curPage);
4600 evt.SetEventObject(this);
4601 GetEventHandler()->ProcessEvent(evt);
4602 vetoed = !evt.IsAllowed();
4603 }
4604
4605 if (!vetoed)
4606 {
4607 int old_curpage = m_curPage;
4608 m_curPage = n;
4609
4610 // program allows the page change
4611 if(events)
4612 {
4613 evt.SetEventType(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED);
4614 (void)GetEventHandler()->ProcessEvent(evt);
4615 }
4616
4617
4618 wxAuiTabCtrl* ctrl;
4619 int ctrl_idx;
4620 if (FindTab(wnd, &ctrl, &ctrl_idx))
4621 {
4622 m_tabs.SetActivePage(wnd);
4623
4624 ctrl->SetActivePage(ctrl_idx);
4625 DoSizing();
4626 ctrl->DoShowHide();
4627
4628 ctrl->MakeTabVisible(ctrl_idx, ctrl);
4629
4630 // set fonts
4631 wxAuiPaneInfoArray& all_panes = m_mgr.GetAllPanes();
4632 size_t i, pane_count = all_panes.GetCount();
4633 for (i = 0; i < pane_count; ++i)
4634 {
4635 wxAuiPaneInfo& pane = all_panes.Item(i);
4636 if (pane.name == wxT("dummy"))
4637 continue;
4638 wxAuiTabCtrl* tabctrl = ((wxTabFrame*)pane.window)->m_tabs;
4639 if (tabctrl != ctrl)
4640 tabctrl->SetSelectedFont(m_normalFont);
4641 else
4642 tabctrl->SetSelectedFont(m_selectedFont);
4643 tabctrl->Refresh();
4644 }
4645
4646 // Set the focus to the page if we're not currently focused on the tab.
4647 // This is Firefox-like behaviour.
4648 if (wnd->IsShownOnScreen() && FindFocus() != ctrl)
4649 wnd->SetFocus();
4650
4651 return old_curpage;
4652 }
4653 }
4654
4655 return m_curPage;
4656 }
4657
4658
4659 #endif // wxUSE_AUI
wxWidgets (Impactor)