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