]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/generic/notebook.cpp
added missing wx/dcclient.h header for PCH-less compilation, removed several other...
[wxWidgets.git] / src / generic / notebook.cpp
... / ...
CommitLineData
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/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
52BEGIN_EVENT_TABLE(wxNotebook, wxBookCtrlBase)
53 EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY, wxNotebook::OnSelChange)
54 EVT_SIZE(wxNotebook::OnSize)
55 EVT_PAINT(wxNotebook::OnPaint)
56 EVT_MOUSE_EVENTS(wxNotebook::OnMouseEvent)
57 EVT_SET_FOCUS(wxNotebook::OnSetFocus)
58 EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
59END_EVENT_TABLE()
60
61IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxBookCtrlBase)
62
63// ============================================================================
64// implementation
65// ============================================================================
66
67// ============================================================================
68// Private class
69// ============================================================================
70
71WX_DECLARE_HASH_MAP(int, wxNotebookPage*, wxIntegerHash, wxIntegerEqual,
72 wxIntToNotebookPageHashMap);
73
74WX_DECLARE_HASH_MAP(wxNotebookPage*, int, wxPointerHash, wxPointerEqual,
75 wxNotebookPageToIntHashMap);
76
77// This reuses wxTabView to draw the tabs.
78class WXDLLEXPORT wxNotebookTabView: public wxTabView
79{
80DECLARE_DYNAMIC_CLASS(wxNotebookTabView)
81public:
82 wxNotebookTabView(wxNotebook* notebook, long style = wxTAB_STYLE_DRAW_BOX | wxTAB_STYLE_COLOUR_INTERIOR);
83 virtual ~wxNotebookTabView(void);
84
85 // Called when a tab is activated
86 virtual void OnTabActivate(int activateId, int deactivateId);
87 // Allows vetoing
88 virtual bool OnTabPreActivate(int activateId, int deactivateId);
89
90 // map integer ids used by wxTabView to wxNotebookPage pointers
91 int GetId(wxNotebookPage *page);
92 wxNotebookPage *GetPage(int id) { return m_idToPage[id]; }
93
94protected:
95 wxNotebook* m_notebook;
96
97private:
98 wxIntToNotebookPageHashMap m_idToPage;
99 wxNotebookPageToIntHashMap m_pageToId;
100 int m_nextid;
101};
102
103static int GetPageId(wxTabView *tabview, wxNotebookPage *page)
104{
105 return wx_static_cast(wxNotebookTabView*, tabview)->GetId(page);
106}
107
108// ----------------------------------------------------------------------------
109// wxNotebook construction
110// ----------------------------------------------------------------------------
111
112// common part of all ctors
113void wxNotebook::Init()
114{
115 m_tabView = (wxNotebookTabView*) NULL;
116 m_nSelection = -1;
117}
118
119// default for dynamic class
120wxNotebook::wxNotebook()
121{
122 Init();
123}
124
125// the same arguments as for wxControl
126wxNotebook::wxNotebook(wxWindow *parent,
127 wxWindowID id,
128 const wxPoint& pos,
129 const wxSize& size,
130 long style,
131 const wxString& name)
132{
133 Init();
134
135 Create(parent, id, pos, size, style, name);
136}
137
138// Create() function
139bool wxNotebook::Create(wxWindow *parent,
140 wxWindowID id,
141 const wxPoint& pos,
142 const wxSize& size,
143 long style,
144 const wxString& name)
145{
146 // base init
147 SetName(name);
148
149 if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT )
150 style |= wxBK_TOP;
151
152 m_windowId = id == wxID_ANY ? NewControlId() : id;
153
154 if (!wxControl::Create(parent, id, pos, size, style|wxNO_BORDER, wxDefaultValidator, name))
155 return false;
156
157 SetTabView(new wxNotebookTabView(this));
158
159 return true;
160}
161
162// dtor
163wxNotebook::~wxNotebook()
164{
165 delete m_tabView;
166}
167
168// ----------------------------------------------------------------------------
169// wxNotebook accessors
170// ----------------------------------------------------------------------------
171int wxNotebook::GetRowCount() const
172{
173 // TODO
174 return 0;
175}
176
177int wxNotebook::SetSelection(size_t nPage)
178{
179 wxASSERT( IS_VALID_PAGE(nPage) );
180
181 wxNotebookPage* pPage = GetPage(nPage);
182
183 m_tabView->SetTabSelection(GetPageId(m_tabView, pPage));
184
185 // TODO
186 return 0;
187}
188
189int wxNotebook::ChangeSelection(size_t nPage)
190{
191 // FIXME: currently it does generate events too
192 return SetSelection(nPage);
193}
194
195#if 0
196void 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
207bool 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
222wxString 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
233int wxNotebook::GetPageImage(size_t WXUNUSED_UNLESS_DEBUG(nPage)) const
234{
235 wxASSERT( IS_VALID_PAGE(nPage) );
236
237 // TODO
238 return 0;
239}
240
241bool 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)
251void wxNotebook::SetPageSize(const wxSize& WXUNUSED(size))
252{
253 // TODO
254}
255
256// set the padding between tabs (in pixels)
257void wxNotebook::SetPadding(const wxSize& WXUNUSED(padding))
258{
259 // TODO
260}
261
262// set the size of the tabs for wxNB_FIXEDWIDTH controls
263void 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
273bool 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
310bool 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
319bool wxNotebook::RemovePage(size_t nPage)
320{
321 return DoRemovePage(nPage) != NULL;
322}
323
324// remove one page from the notebook
325wxWindow* 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
368bool 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.
378int 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
389bool 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
404bool 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)
444void 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?
461void 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
490bool 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
544void wxNotebook::OnSelChange(wxBookCtrlEvent& 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
557void 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
566void 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
587void 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
593bool wxNotebook::DoPhase(int /* nPhase */)
594{
595 return true;
596}
597
598void 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
608void 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
632void wxNotebook::OnMouseEvent(wxMouseEvent& event)
633{
634 if (m_tabView)
635 m_tabView->OnEvent(event);
636}
637
638void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event) )
639{
640 wxPaintDC dc(this);
641 if (m_tabView)
642 m_tabView->Draw(dc);
643}
644
645wxSize 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
656wxRect 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
677IMPLEMENT_CLASS(wxNotebookTabView, wxTabView)
678
679wxNotebookTabView::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
689wxNotebookTabView::~wxNotebookTabView(void)
690{
691}
692
693int 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
707void wxNotebookTabView::OnTabActivate(int activateId, int deactivateId)
708{
709 if (!m_notebook)
710 return;
711
712 wxBookCtrlEvent 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
729bool wxNotebookTabView::OnTabPreActivate(int activateId, int deactivateId)
730{
731 bool retval = true;
732
733 if (m_notebook)
734 {
735 wxBookCtrlEvent 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