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