]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/generic/notebook.cpp | |
3 | // Purpose: generic implementation of wxNotebook | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 17/09/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart | |
9 | // Licence: wxWindows licence | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // ============================================================================ | |
13 | // declarations | |
14 | // ============================================================================ | |
15 | ||
16 | // ---------------------------------------------------------------------------- | |
17 | // headers | |
18 | // ---------------------------------------------------------------------------- | |
19 | ||
20 | // For compilers that support precompilation, includes "wx.h". | |
21 | #include "wx/wxprec.h" | |
22 | ||
23 | #ifdef __BORLANDC__ | |
24 | #pragma hdrstop | |
25 | #endif | |
26 | ||
27 | #if wxUSE_NOTEBOOK | |
28 | ||
29 | #include "wx/notebook.h" | |
30 | ||
31 | #ifndef WX_PRECOMP | |
32 | #include "wx/string.h" | |
33 | #include "wx/log.h" | |
34 | #include "wx/dcclient.h" | |
35 | #include "wx/settings.h" | |
36 | #endif | |
37 | ||
38 | #include "wx/generic/imaglist.h" | |
39 | #include "wx/generic/tabg.h" | |
40 | ||
41 | // ---------------------------------------------------------------------------- | |
42 | // macros | |
43 | // ---------------------------------------------------------------------------- | |
44 | ||
45 | // check that the page index is valid | |
46 | #define IS_VALID_PAGE(nPage) ((nPage) < GetPageCount()) | |
47 | ||
48 | // ---------------------------------------------------------------------------- | |
49 | // event table | |
50 | // ---------------------------------------------------------------------------- | |
51 | ||
52 | DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED) | |
53 | DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING) | |
54 | ||
55 | BEGIN_EVENT_TABLE(wxNotebook, wxControl) | |
56 | EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY, wxNotebook::OnSelChange) | |
57 | EVT_SIZE(wxNotebook::OnSize) | |
58 | EVT_PAINT(wxNotebook::OnPaint) | |
59 | EVT_MOUSE_EVENTS(wxNotebook::OnMouseEvent) | |
60 | EVT_SET_FOCUS(wxNotebook::OnSetFocus) | |
61 | EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey) | |
62 | END_EVENT_TABLE() | |
63 | ||
64 | IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl) | |
65 | IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent) | |
66 | ||
67 | // ============================================================================ | |
68 | // implementation | |
69 | // ============================================================================ | |
70 | ||
71 | // ============================================================================ | |
72 | // Private class | |
73 | // ============================================================================ | |
74 | ||
75 | WX_DECLARE_HASH_MAP(int, wxNotebookPage*, wxIntegerHash, wxIntegerEqual, | |
76 | wxIntToNotebookPageHashMap); | |
77 | ||
78 | WX_DECLARE_HASH_MAP(wxNotebookPage*, int, wxPointerHash, wxPointerEqual, | |
79 | wxNotebookPageToIntHashMap); | |
80 | ||
81 | // This reuses wxTabView to draw the tabs. | |
82 | class WXDLLEXPORT wxNotebookTabView: public wxTabView | |
83 | { | |
84 | DECLARE_DYNAMIC_CLASS(wxNotebookTabView) | |
85 | public: | |
86 | wxNotebookTabView(wxNotebook* notebook, long style = wxTAB_STYLE_DRAW_BOX | wxTAB_STYLE_COLOUR_INTERIOR); | |
87 | ~wxNotebookTabView(void); | |
88 | ||
89 | // Called when a tab is activated | |
90 | virtual void OnTabActivate(int activateId, int deactivateId); | |
91 | // Allows vetoing | |
92 | virtual bool OnTabPreActivate(int activateId, int deactivateId); | |
93 | ||
94 | // map integer ids used by wxTabView to wxNotebookPage pointers | |
95 | int GetId(wxNotebookPage *page); | |
96 | wxNotebookPage *GetPage(int id) { return m_idToPage[id]; } | |
97 | ||
98 | protected: | |
99 | wxNotebook* m_notebook; | |
100 | ||
101 | private: | |
102 | wxIntToNotebookPageHashMap m_idToPage; | |
103 | wxNotebookPageToIntHashMap m_pageToId; | |
104 | int m_nextid; | |
105 | }; | |
106 | ||
107 | static int GetPageId(wxTabView *tabview, wxNotebookPage *page) | |
108 | { | |
109 | return wx_static_cast(wxNotebookTabView*, tabview)->GetId(page); | |
110 | } | |
111 | ||
112 | // ---------------------------------------------------------------------------- | |
113 | // wxNotebook construction | |
114 | // ---------------------------------------------------------------------------- | |
115 | ||
116 | // common part of all ctors | |
117 | void wxNotebook::Init() | |
118 | { | |
119 | m_tabView = (wxNotebookTabView*) NULL; | |
120 | m_nSelection = -1; | |
121 | } | |
122 | ||
123 | // default for dynamic class | |
124 | wxNotebook::wxNotebook() | |
125 | { | |
126 | Init(); | |
127 | } | |
128 | ||
129 | // the same arguments as for wxControl | |
130 | wxNotebook::wxNotebook(wxWindow *parent, | |
131 | wxWindowID id, | |
132 | const wxPoint& pos, | |
133 | const wxSize& size, | |
134 | long style, | |
135 | const wxString& name) | |
136 | { | |
137 | Init(); | |
138 | ||
139 | Create(parent, id, pos, size, style, name); | |
140 | } | |
141 | ||
142 | // Create() function | |
143 | bool wxNotebook::Create(wxWindow *parent, | |
144 | wxWindowID id, | |
145 | const wxPoint& pos, | |
146 | const wxSize& size, | |
147 | long style, | |
148 | const wxString& name) | |
149 | { | |
150 | // base init | |
151 | SetName(name); | |
152 | ||
153 | if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT ) | |
154 | style |= wxBK_TOP; | |
155 | ||
156 | m_windowId = id == wxID_ANY ? NewControlId() : id; | |
157 | ||
158 | if (!wxControl::Create(parent, id, pos, size, style|wxNO_BORDER, wxDefaultValidator, name)) | |
159 | return false; | |
160 | ||
161 | SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE)); | |
162 | ||
163 | SetTabView(new wxNotebookTabView(this)); | |
164 | ||
165 | return true; | |
166 | } | |
167 | ||
168 | // dtor | |
169 | wxNotebook::~wxNotebook() | |
170 | { | |
171 | delete m_tabView; | |
172 | } | |
173 | ||
174 | // ---------------------------------------------------------------------------- | |
175 | // wxNotebook accessors | |
176 | // ---------------------------------------------------------------------------- | |
177 | int wxNotebook::GetRowCount() const | |
178 | { | |
179 | // TODO | |
180 | return 0; | |
181 | } | |
182 | ||
183 | int wxNotebook::SetSelection(size_t nPage) | |
184 | { | |
185 | wxASSERT( IS_VALID_PAGE(nPage) ); | |
186 | ||
187 | wxNotebookPage* pPage = GetPage(nPage); | |
188 | ||
189 | m_tabView->SetTabSelection(GetPageId(m_tabView, pPage)); | |
190 | ||
191 | // TODO | |
192 | return 0; | |
193 | } | |
194 | ||
195 | #if 0 | |
196 | void wxNotebook::AdvanceSelection(bool bForward) | |
197 | { | |
198 | int nSel = GetSelection(); | |
199 | int nMax = GetPageCount() - 1; | |
200 | if ( bForward ) | |
201 | SetSelection(nSel == nMax ? 0 : nSel + 1); | |
202 | else | |
203 | SetSelection(nSel == 0 ? nMax : nSel - 1); | |
204 | } | |
205 | #endif | |
206 | ||
207 | bool wxNotebook::SetPageText(size_t nPage, const wxString& strText) | |
208 | { | |
209 | wxASSERT( IS_VALID_PAGE(nPage) ); | |
210 | ||
211 | wxNotebookPage* page = GetPage(nPage); | |
212 | if (page) | |
213 | { | |
214 | m_tabView->SetTabText(GetPageId(m_tabView, page), strText); | |
215 | Refresh(); | |
216 | return true; | |
217 | } | |
218 | ||
219 | return false; | |
220 | } | |
221 | ||
222 | wxString wxNotebook::GetPageText(size_t nPage) const | |
223 | { | |
224 | wxASSERT( IS_VALID_PAGE(nPage) ); | |
225 | ||
226 | wxNotebookPage* page = ((wxNotebook*)this)->GetPage(nPage); | |
227 | if (page) | |
228 | return m_tabView->GetTabText(GetPageId(m_tabView, page)); | |
229 | else | |
230 | return wxEmptyString; | |
231 | } | |
232 | ||
233 | int wxNotebook::GetPageImage(size_t WXUNUSED_UNLESS_DEBUG(nPage)) const | |
234 | { | |
235 | wxASSERT( IS_VALID_PAGE(nPage) ); | |
236 | ||
237 | // TODO | |
238 | return 0; | |
239 | } | |
240 | ||
241 | bool wxNotebook::SetPageImage(size_t WXUNUSED_UNLESS_DEBUG(nPage), | |
242 | int WXUNUSED(nImage)) | |
243 | { | |
244 | wxASSERT( IS_VALID_PAGE(nPage) ); | |
245 | ||
246 | // TODO | |
247 | return false; | |
248 | } | |
249 | ||
250 | // set the size (the same for all pages) | |
251 | void wxNotebook::SetPageSize(const wxSize& WXUNUSED(size)) | |
252 | { | |
253 | // TODO | |
254 | } | |
255 | ||
256 | // set the padding between tabs (in pixels) | |
257 | void wxNotebook::SetPadding(const wxSize& WXUNUSED(padding)) | |
258 | { | |
259 | // TODO | |
260 | } | |
261 | ||
262 | // set the size of the tabs for wxNB_FIXEDWIDTH controls | |
263 | void wxNotebook::SetTabSize(const wxSize& WXUNUSED(sz)) | |
264 | { | |
265 | // TODO | |
266 | } | |
267 | ||
268 | // ---------------------------------------------------------------------------- | |
269 | // wxNotebook operations | |
270 | // ---------------------------------------------------------------------------- | |
271 | ||
272 | // remove one page from the notebook and delete it | |
273 | bool wxNotebook::DeletePage(size_t nPage) | |
274 | { | |
275 | wxCHECK( IS_VALID_PAGE(nPage), false ); | |
276 | ||
277 | if (m_nSelection != -1) | |
278 | { | |
279 | m_pages[m_nSelection]->Show(false); | |
280 | m_pages[m_nSelection]->Lower(); | |
281 | } | |
282 | ||
283 | wxNotebookPage* pPage = GetPage(nPage); | |
284 | ||
285 | m_tabView->RemoveTab(GetPageId(m_tabView, pPage)); | |
286 | ||
287 | m_pages.Remove(pPage); | |
288 | delete pPage; | |
289 | ||
290 | if (m_pages.GetCount() == 0) | |
291 | { | |
292 | m_nSelection = -1; | |
293 | m_tabView->SetTabSelection(-1, false); | |
294 | } | |
295 | else if (m_nSelection > -1) | |
296 | { | |
297 | m_nSelection = -1; | |
298 | ||
299 | m_tabView->SetTabSelection(GetPageId(m_tabView, GetPage(0)), false); | |
300 | ||
301 | if (m_nSelection != 0) | |
302 | ChangePage(-1, 0); | |
303 | } | |
304 | ||
305 | RefreshLayout(false); | |
306 | ||
307 | return true; | |
308 | } | |
309 | ||
310 | bool wxNotebook::DeletePage(wxNotebookPage* page) | |
311 | { | |
312 | int pagePos = FindPagePosition(page); | |
313 | if (pagePos > -1) | |
314 | return DeletePage(pagePos); | |
315 | else | |
316 | return false; | |
317 | } | |
318 | ||
319 | bool wxNotebook::RemovePage(size_t nPage) | |
320 | { | |
321 | return DoRemovePage(nPage) != NULL; | |
322 | } | |
323 | ||
324 | // remove one page from the notebook | |
325 | wxWindow* wxNotebook::DoRemovePage(size_t nPage) | |
326 | { | |
327 | wxCHECK( IS_VALID_PAGE(nPage), NULL ); | |
328 | ||
329 | m_pages[nPage]->Show(false); | |
330 | // m_pages[nPage]->Lower(); | |
331 | ||
332 | wxNotebookPage* pPage = GetPage(nPage); | |
333 | ||
334 | m_tabView->RemoveTab(GetPageId(m_tabView, pPage)); | |
335 | ||
336 | m_pages.Remove(pPage); | |
337 | ||
338 | if (m_pages.GetCount() == 0) | |
339 | { | |
340 | m_nSelection = -1; | |
341 | m_tabView->SetTabSelection(-1, true); | |
342 | } | |
343 | else if (m_nSelection > -1) | |
344 | { | |
345 | // Only change the selection if the page we | |
346 | // deleted was the selection. | |
347 | if (nPage == (size_t)m_nSelection) | |
348 | { | |
349 | m_nSelection = -1; | |
350 | // Select the first tab. Generates a ChangePage. | |
351 | m_tabView->SetTabSelection(0, true); | |
352 | } | |
353 | else | |
354 | { | |
355 | // We must adjust which tab we think is selected. | |
356 | // If greater than the page we deleted, it must be moved down | |
357 | // a notch. | |
358 | if (size_t(m_nSelection) > nPage) | |
359 | m_nSelection -- ; | |
360 | } | |
361 | } | |
362 | ||
363 | RefreshLayout(false); | |
364 | ||
365 | return pPage; | |
366 | } | |
367 | ||
368 | bool wxNotebook::RemovePage(wxNotebookPage* page) | |
369 | { | |
370 | int pagePos = FindPagePosition(page); | |
371 | if (pagePos > -1) | |
372 | return RemovePage(pagePos); | |
373 | else | |
374 | return false; | |
375 | } | |
376 | ||
377 | // Find the position of the wxNotebookPage, -1 if not found. | |
378 | int wxNotebook::FindPagePosition(wxNotebookPage* page) const | |
379 | { | |
380 | size_t nPageCount = GetPageCount(); | |
381 | size_t nPage; | |
382 | for ( nPage = 0; nPage < nPageCount; nPage++ ) | |
383 | if (m_pages[nPage] == page) | |
384 | return nPage; | |
385 | return -1; | |
386 | } | |
387 | ||
388 | // remove all pages | |
389 | bool wxNotebook::DeleteAllPages() | |
390 | { | |
391 | m_tabView->ClearTabs(true); | |
392 | ||
393 | size_t nPageCount = GetPageCount(); | |
394 | size_t nPage; | |
395 | for ( nPage = 0; nPage < nPageCount; nPage++ ) | |
396 | delete m_pages[nPage]; | |
397 | ||
398 | m_pages.Clear(); | |
399 | ||
400 | return true; | |
401 | } | |
402 | ||
403 | // same as AddPage() but does it at given position | |
404 | bool wxNotebook::InsertPage(size_t nPage, | |
405 | wxNotebookPage *pPage, | |
406 | const wxString& strText, | |
407 | bool bSelect, | |
408 | int WXUNUSED(imageId)) | |
409 | { | |
410 | wxASSERT( pPage != NULL ); | |
411 | wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false ); | |
412 | ||
413 | m_tabView->AddTab(GetPageId(m_tabView, pPage), strText); | |
414 | ||
415 | if (!bSelect) | |
416 | pPage->Show(false); | |
417 | ||
418 | // save the pointer to the page | |
419 | m_pages.Insert(pPage, nPage); | |
420 | ||
421 | if (bSelect) | |
422 | { | |
423 | // This will cause ChangePage to be called, via OnSelPage | |
424 | ||
425 | m_tabView->SetTabSelection(GetPageId(m_tabView, pPage), true); | |
426 | } | |
427 | ||
428 | // some page must be selected: either this one or the first one if there is | |
429 | // still no selection | |
430 | if ( m_nSelection == -1 ) | |
431 | ChangePage(-1, 0); | |
432 | ||
433 | RefreshLayout(false); | |
434 | ||
435 | return true; | |
436 | } | |
437 | ||
438 | // ---------------------------------------------------------------------------- | |
439 | // wxNotebook callbacks | |
440 | // ---------------------------------------------------------------------------- | |
441 | ||
442 | // @@@ OnSize() is used for setting the font when it's called for the first | |
443 | // time because doing it in ::Create() doesn't work (for unknown reasons) | |
444 | void wxNotebook::OnSize(wxSizeEvent& event) | |
445 | { | |
446 | static bool s_bFirstTime = true; | |
447 | if ( s_bFirstTime ) { | |
448 | // TODO: any first-time-size processing. | |
449 | s_bFirstTime = false; | |
450 | } | |
451 | ||
452 | RefreshLayout(); | |
453 | ||
454 | // Processing continues to next OnSize | |
455 | event.Skip(); | |
456 | } | |
457 | ||
458 | // This was supposed to cure the non-display of the notebook | |
459 | // until the user resizes the window. | |
460 | // What's going on? | |
461 | void wxNotebook::OnInternalIdle() | |
462 | { | |
463 | wxWindow::OnInternalIdle(); | |
464 | ||
465 | #if 0 | |
466 | static bool s_bFirstTime = true; | |
467 | if ( s_bFirstTime ) { | |
468 | /* | |
469 | wxSize sz(GetSize()); | |
470 | sz.x ++; | |
471 | SetSize(sz); | |
472 | sz.x --; | |
473 | SetSize(sz); | |
474 | */ | |
475 | ||
476 | /* | |
477 | wxSize sz(GetSize()); | |
478 | wxSizeEvent sizeEvent(sz, GetId()); | |
479 | sizeEvent.SetEventObject(this); | |
480 | GetEventHandler()->ProcessEvent(sizeEvent); | |
481 | Refresh(); | |
482 | */ | |
483 | s_bFirstTime = false; | |
484 | } | |
485 | #endif | |
486 | } | |
487 | ||
488 | // Implementation: calculate the layout of the view rect | |
489 | // and resize the children if required | |
490 | bool wxNotebook::RefreshLayout(bool force) | |
491 | { | |
492 | if (m_tabView) | |
493 | { | |
494 | wxRect oldRect = m_tabView->GetViewRect(); | |
495 | ||
496 | int cw, ch; | |
497 | GetClientSize(& cw, & ch); | |
498 | ||
499 | int tabHeight = m_tabView->GetTotalTabHeight(); | |
500 | wxRect rect; | |
501 | rect.x = 4; | |
502 | rect.y = tabHeight + 4; | |
503 | rect.width = cw - 8; | |
504 | rect.height = ch - 4 - rect.y ; | |
505 | ||
506 | m_tabView->SetViewRect(rect); | |
507 | ||
508 | m_tabView->LayoutTabs(); | |
509 | ||
510 | // Need to do it a 2nd time to get the tab height with | |
511 | // the new view width, since changing the view width changes the | |
512 | // tab layout. | |
513 | tabHeight = m_tabView->GetTotalTabHeight(); | |
514 | rect.x = 4; | |
515 | rect.y = tabHeight + 4; | |
516 | rect.width = cw - 8; | |
517 | rect.height = ch - 4 - rect.y ; | |
518 | ||
519 | m_tabView->SetViewRect(rect); | |
520 | ||
521 | m_tabView->LayoutTabs(); | |
522 | ||
523 | if (!force && (rect == oldRect)) | |
524 | return false; | |
525 | ||
526 | // fit the notebook page to the tab control's display area | |
527 | ||
528 | size_t nCount = m_pages.Count(); | |
529 | for ( size_t nPage = 0; nPage < nCount; nPage++ ) { | |
530 | wxNotebookPage *pPage = m_pages[nPage]; | |
531 | wxRect clientRect = GetAvailableClientSize(); | |
532 | if (pPage->IsShown()) | |
533 | { | |
534 | pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height); | |
535 | if ( pPage->GetAutoLayout() ) | |
536 | pPage->Layout(); | |
537 | } | |
538 | } | |
539 | Refresh(); | |
540 | } | |
541 | return true; | |
542 | } | |
543 | ||
544 | void wxNotebook::OnSelChange(wxNotebookEvent& event) | |
545 | { | |
546 | // is it our tab control? | |
547 | if ( event.GetEventObject() == this ) | |
548 | { | |
549 | if (event.GetSelection() != m_nSelection) | |
550 | ChangePage(event.GetOldSelection(), event.GetSelection()); | |
551 | } | |
552 | ||
553 | // we want to give others a chance to process this message as well | |
554 | event.Skip(); | |
555 | } | |
556 | ||
557 | void wxNotebook::OnSetFocus(wxFocusEvent& event) | |
558 | { | |
559 | // set focus to the currently selected page if any | |
560 | if ( m_nSelection != -1 ) | |
561 | m_pages[m_nSelection]->SetFocus(); | |
562 | ||
563 | event.Skip(); | |
564 | } | |
565 | ||
566 | void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event) | |
567 | { | |
568 | if ( event.IsWindowChange() ) { | |
569 | // change pages | |
570 | AdvanceSelection(event.GetDirection()); | |
571 | } | |
572 | else { | |
573 | // pass to the parent | |
574 | if ( GetParent() ) { | |
575 | event.SetCurrentFocus(this); | |
576 | GetParent()->ProcessEvent(event); | |
577 | } | |
578 | } | |
579 | } | |
580 | ||
581 | // ---------------------------------------------------------------------------- | |
582 | // wxNotebook base class virtuals | |
583 | // ---------------------------------------------------------------------------- | |
584 | ||
585 | // override these 2 functions to do nothing: everything is done in OnSize | |
586 | ||
587 | void wxNotebook::SetConstraintSizes(bool /* recurse */) | |
588 | { | |
589 | // don't set the sizes of the pages - their correct size is not yet known | |
590 | wxControl::SetConstraintSizes(false); | |
591 | } | |
592 | ||
593 | bool wxNotebook::DoPhase(int /* nPhase */) | |
594 | { | |
595 | return true; | |
596 | } | |
597 | ||
598 | void wxNotebook::Command(wxCommandEvent& WXUNUSED(event)) | |
599 | { | |
600 | wxFAIL_MSG(wxT("wxNotebook::Command not implemented")); | |
601 | } | |
602 | ||
603 | // ---------------------------------------------------------------------------- | |
604 | // wxNotebook helper functions | |
605 | // ---------------------------------------------------------------------------- | |
606 | ||
607 | // hide the currently active panel and show the new one | |
608 | void wxNotebook::ChangePage(int nOldSel, int nSel) | |
609 | { | |
610 | // cout << "ChangePage: " << nOldSel << ", " << nSel << "\n"; | |
611 | wxASSERT( nOldSel != nSel ); // impossible | |
612 | ||
613 | if ( nOldSel != -1 ) { | |
614 | m_pages[nOldSel]->Show(false); | |
615 | m_pages[nOldSel]->Lower(); | |
616 | } | |
617 | ||
618 | wxNotebookPage *pPage = m_pages[nSel]; | |
619 | ||
620 | wxRect clientRect = GetAvailableClientSize(); | |
621 | pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height); | |
622 | ||
623 | Refresh(); | |
624 | ||
625 | pPage->Show(true); | |
626 | pPage->Raise(); | |
627 | pPage->SetFocus(); | |
628 | ||
629 | m_nSelection = nSel; | |
630 | } | |
631 | ||
632 | void wxNotebook::OnMouseEvent(wxMouseEvent& event) | |
633 | { | |
634 | if (m_tabView) | |
635 | m_tabView->OnEvent(event); | |
636 | } | |
637 | ||
638 | void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event) ) | |
639 | { | |
640 | wxPaintDC dc(this); | |
641 | if (m_tabView) | |
642 | m_tabView->Draw(dc); | |
643 | } | |
644 | ||
645 | wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const | |
646 | { | |
647 | // MBN: since the total tab height is really a function of the | |
648 | // width, this should really call | |
649 | // GetTotalTabHeightPretendingWidthIs(), but the current | |
650 | // implementation will suffice, provided the wxNotebook has been | |
651 | // created with a sensible initial width. | |
652 | return wxSize( sizePage.x + 12, | |
653 | sizePage.y + m_tabView->GetTotalTabHeight() + 6 + 4 ); | |
654 | } | |
655 | ||
656 | wxRect wxNotebook::GetAvailableClientSize() | |
657 | { | |
658 | int cw, ch; | |
659 | GetClientSize(& cw, & ch); | |
660 | ||
661 | int tabHeight = m_tabView->GetTotalTabHeight(); | |
662 | ||
663 | // TODO: these margins should be configurable. | |
664 | wxRect rect; | |
665 | rect.x = 6; | |
666 | rect.y = tabHeight + 6; | |
667 | rect.width = cw - 12; | |
668 | rect.height = ch - 4 - rect.y ; | |
669 | ||
670 | return rect; | |
671 | } | |
672 | ||
673 | /* | |
674 | * wxNotebookTabView | |
675 | */ | |
676 | ||
677 | IMPLEMENT_CLASS(wxNotebookTabView, wxTabView) | |
678 | ||
679 | wxNotebookTabView::wxNotebookTabView(wxNotebook *notebook, long style) | |
680 | : wxTabView(style), m_nextid(1) | |
681 | { | |
682 | m_notebook = notebook; | |
683 | ||
684 | m_notebook->SetTabView(this); | |
685 | ||
686 | SetWindow(m_notebook); | |
687 | } | |
688 | ||
689 | wxNotebookTabView::~wxNotebookTabView(void) | |
690 | { | |
691 | } | |
692 | ||
693 | int wxNotebookTabView::GetId(wxNotebookPage *page) | |
694 | { | |
695 | int& id = m_pageToId[page]; | |
696 | ||
697 | if (!id) | |
698 | { | |
699 | id = m_nextid++; | |
700 | m_idToPage[id] = page; | |
701 | } | |
702 | ||
703 | return id; | |
704 | } | |
705 | ||
706 | // Called when a tab is activated | |
707 | void wxNotebookTabView::OnTabActivate(int activateId, int deactivateId) | |
708 | { | |
709 | if (!m_notebook) | |
710 | return; | |
711 | ||
712 | wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_notebook->GetId()); | |
713 | ||
714 | // Translate from wxTabView's ids (which aren't position-dependent) | |
715 | // to wxNotebook's (which are). | |
716 | wxNotebookPage* pActive = GetPage(activateId); | |
717 | wxNotebookPage* pDeactive = GetPage(deactivateId); | |
718 | ||
719 | int activatePos = m_notebook->FindPagePosition(pActive); | |
720 | int deactivatePos = m_notebook->FindPagePosition(pDeactive); | |
721 | ||
722 | event.SetEventObject(m_notebook); | |
723 | event.SetSelection(activatePos); | |
724 | event.SetOldSelection(deactivatePos); | |
725 | m_notebook->GetEventHandler()->ProcessEvent(event); | |
726 | } | |
727 | ||
728 | // Allows Vetoing | |
729 | bool wxNotebookTabView::OnTabPreActivate(int activateId, int deactivateId) | |
730 | { | |
731 | bool retval = true; | |
732 | ||
733 | if (m_notebook) | |
734 | { | |
735 | wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_notebook->GetId()); | |
736 | ||
737 | // Translate from wxTabView's ids (which aren't position-dependent) | |
738 | // to wxNotebook's (which are). | |
739 | wxNotebookPage* pActive = GetPage(activateId); | |
740 | wxNotebookPage* pDeactive = GetPage(deactivateId); | |
741 | ||
742 | int activatePos = m_notebook->FindPagePosition(pActive); | |
743 | int deactivatePos = m_notebook->FindPagePosition(pDeactive); | |
744 | ||
745 | event.SetEventObject(m_notebook); | |
746 | event.SetSelection(activatePos); | |
747 | event.SetOldSelection(deactivatePos); | |
748 | if (m_notebook->GetEventHandler()->ProcessEvent(event)) | |
749 | { | |
750 | retval = event.IsAllowed(); | |
751 | } | |
752 | } | |
753 | return retval; | |
754 | } | |
755 | ||
756 | #endif // wxUSE_NOTEBOOK |