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