]> git.saurik.com Git - wxWidgets.git/blob - src/univ/notebook.cpp
Use wxMarkupParser in wxStaticText for dealing with markup.
[wxWidgets.git] / src / univ / notebook.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/univ/notebook.cpp
3 // Purpose: wxNotebook implementation
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 01.02.01
7 // RCS-ID: $Id$
8 // Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #include "wx/wxprec.h"
21
22 #ifdef __BORLANDC__
23 #pragma hdrstop
24 #endif
25
26 #if wxUSE_NOTEBOOK
27
28 #include "wx/notebook.h"
29
30 #ifndef WX_PRECOMP
31 #include "wx/dcmemory.h"
32 #endif
33
34 #include "wx/imaglist.h"
35 #include "wx/spinbutt.h"
36
37 #include "wx/univ/renderer.h"
38
39 // ----------------------------------------------------------------------------
40 // wxStdNotebookInputHandler: translates SPACE and ENTER keys and the left mouse
41 // click into button press/release actions
42 // ----------------------------------------------------------------------------
43
44 class WXDLLEXPORT wxStdNotebookInputHandler : public wxStdInputHandler
45 {
46 public:
47 wxStdNotebookInputHandler(wxInputHandler *inphand);
48
49 virtual bool HandleKey(wxInputConsumer *consumer,
50 const wxKeyEvent& event,
51 bool pressed);
52 virtual bool HandleMouse(wxInputConsumer *consumer,
53 const wxMouseEvent& event);
54 virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event);
55 virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
56 virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
57
58 protected:
59 void HandleFocusChange(wxInputConsumer *consumer);
60 };
61
62 // ----------------------------------------------------------------------------
63 // macros
64 // ----------------------------------------------------------------------------
65
66 #if 0
67 // due to unsigned type nPage is always >= 0
68 #define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((size_t(nPage)) < GetPageCount()))
69 #else
70 #define IS_VALID_PAGE(nPage) (((size_t)nPage) < GetPageCount())
71 #endif
72
73 // ----------------------------------------------------------------------------
74 // private classes
75 // ----------------------------------------------------------------------------
76
77 class wxNotebookSpinBtn : public wxSpinButton
78 {
79 public:
80 wxNotebookSpinBtn(wxNotebook *nb)
81 : wxSpinButton(nb, wxID_ANY,
82 wxDefaultPosition, wxDefaultSize,
83 nb->IsVertical() ? wxSP_VERTICAL : wxSP_HORIZONTAL)
84 {
85 m_nb = nb;
86 }
87
88 protected:
89 void OnSpin(wxSpinEvent& event)
90 {
91 m_nb->PerformAction(wxACTION_NOTEBOOK_GOTO, event.GetPosition());
92 }
93
94 private:
95 wxNotebook *m_nb;
96
97 DECLARE_EVENT_TABLE()
98 };
99
100 BEGIN_EVENT_TABLE(wxNotebookSpinBtn, wxSpinButton)
101 EVT_SPIN(wxID_ANY, wxNotebookSpinBtn::OnSpin)
102 END_EVENT_TABLE()
103
104 // ============================================================================
105 // implementation
106 // ============================================================================
107
108 // ----------------------------------------------------------------------------
109 // wxNotebook creation
110 // ----------------------------------------------------------------------------
111
112 void wxNotebook::Init()
113 {
114 m_heightTab =
115 m_widthMax = 0;
116
117 m_firstVisible =
118 m_lastVisible =
119 m_lastFullyVisible = 0;
120
121 m_offset = 0;
122
123 m_spinbtn = NULL;
124 }
125
126 bool wxNotebook::Create(wxWindow *parent,
127 wxWindowID id,
128 const wxPoint& pos,
129 const wxSize& size,
130 long style,
131 const wxString& name)
132 {
133 if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT )
134 style |= wxBK_TOP;
135
136 if ( !wxControl::Create(parent, id, pos, size, style,
137 wxDefaultValidator, name) )
138 return false;
139
140 m_sizePad = GetRenderer()->GetTabPadding();
141
142 SetInitialSize(size);
143
144 CreateInputHandler(wxINP_HANDLER_NOTEBOOK);
145
146 return true;
147 }
148
149 // ----------------------------------------------------------------------------
150 // wxNotebook page titles and images
151 // ----------------------------------------------------------------------------
152
153 wxString wxNotebook::GetPageText(size_t nPage) const
154 {
155 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxEmptyString, wxT("invalid notebook page") );
156
157 return m_titles[nPage];
158 }
159
160 bool wxNotebook::SetPageText(size_t nPage, const wxString& strText)
161 {
162 wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("invalid notebook page") );
163
164 if ( strText != m_titles[nPage] )
165 {
166 m_accels[nPage] = FindAccelIndex(strText, &m_titles[nPage]);
167
168 if ( FixedSizeTabs() )
169 {
170 // it's enough to just reresh this one
171 RefreshTab(nPage);
172 }
173 else // var width tabs
174 {
175 // we need to resize the tab to fit the new string
176 ResizeTab(nPage);
177 }
178 }
179
180 return true;
181 }
182
183 int wxNotebook::GetPageImage(size_t nPage) const
184 {
185 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("invalid notebook page") );
186
187 return m_images[nPage];
188 }
189
190 bool wxNotebook::SetPageImage(size_t nPage, int nImage)
191 {
192 wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("invalid notebook page") );
193
194 wxCHECK_MSG( m_imageList && nImage < m_imageList->GetImageCount(), false,
195 wxT("invalid image index in SetPageImage()") );
196
197 if ( nImage != m_images[nPage] )
198 {
199 // if the item didn't have an icon before or, on the contrary, did have
200 // it but has lost it now, its size will change - but if the icon just
201 // changes, it won't
202 bool tabSizeChanges = nImage == -1 || m_images[nPage] == -1;
203 m_images[nPage] = nImage;
204
205 if ( tabSizeChanges )
206 RefreshAllTabs();
207 else
208 RefreshTab(nPage);
209 }
210
211 return true;
212 }
213
214 wxNotebook::~wxNotebook()
215 {
216 }
217
218 // ----------------------------------------------------------------------------
219 // wxNotebook page switching
220 // ----------------------------------------------------------------------------
221
222 int wxNotebook::DoSetSelection(size_t nPage, int flags)
223 {
224 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("invalid notebook page") );
225
226 if ( (int)nPage == m_selection )
227 {
228 // don't do anything if there is nothing to do
229 return m_selection;
230 }
231
232 if ( flags & SetSelection_SendEvent )
233 {
234 if ( !SendPageChangingEvent(nPage) )
235 {
236 // program doesn't allow the page change
237 return m_selection;
238 }
239 }
240
241 // we need to change m_selection first, before calling RefreshTab() below as
242 // otherwise the previously selected tab wouldn't be redrawn properly under
243 // wxGTK which calls Refresh() immediately and not during the next event
244 // loop iteration as wxMSW does and as it should
245 int selOld = m_selection;
246
247 m_selection = nPage;
248
249 if ( selOld != wxNOT_FOUND )
250 {
251 RefreshTab(selOld, true /* this tab was selected */);
252
253 m_pages[selOld]->Hide();
254 }
255
256 if ( m_selection != wxNOT_FOUND ) // this is impossible - but test nevertheless
257 {
258 if ( HasSpinBtn() )
259 {
260 // keep it in sync
261 m_spinbtn->SetValue(m_selection);
262 }
263
264 if ( nPage < m_firstVisible )
265 {
266 // selection is to the left of visible part of tabs
267 ScrollTo(nPage);
268 }
269 else if ( nPage > m_lastFullyVisible )
270 {
271 // selection is to the right of visible part of tabs
272 ScrollLastTo(nPage);
273 }
274 else // we already see this tab
275 {
276 // no need to scroll
277 RefreshTab(nPage);
278 }
279
280 m_pages[nPage]->SetSize(GetPageRect());
281 m_pages[nPage]->Show();
282 }
283
284 if ( flags & SetSelection_SendEvent )
285 {
286 // event handling
287 SendPageChangedEvent(selOld);
288 }
289
290 return selOld;
291 }
292
293 // ----------------------------------------------------------------------------
294 // wxNotebook pages adding/deleting
295 // ----------------------------------------------------------------------------
296
297 bool wxNotebook::InsertPage(size_t nPage,
298 wxNotebookPage *pPage,
299 const wxString& strText,
300 bool bSelect,
301 int imageId)
302 {
303 size_t nPages = GetPageCount();
304 wxCHECK_MSG( nPage == nPages || IS_VALID_PAGE(nPage), false,
305 wxT("invalid notebook page in InsertPage()") );
306
307 // modify the data
308 m_pages.Insert(pPage, nPage);
309
310 wxString label;
311 m_accels.Insert(FindAccelIndex(strText, &label), nPage);
312 m_titles.Insert(label, nPage);
313
314 m_images.Insert(imageId, nPage);
315
316 // cache the tab geometry here
317 wxSize sizeTab = CalcTabSize(nPage);
318
319 if ( sizeTab.y > m_heightTab )
320 m_heightTab = sizeTab.y;
321
322 if ( FixedSizeTabs() && sizeTab.x > m_widthMax )
323 m_widthMax = sizeTab.x;
324
325 m_widths.Insert(sizeTab.x, nPage);
326
327 // spin button may appear if we didn't have it before - but even if we did,
328 // its range should change, so update it unconditionally
329 UpdateSpinBtn();
330
331 // if the tab has just appeared, we have to relayout everything, otherwise
332 // it's enough to just redraw the tabs
333 if ( nPages == 0 )
334 {
335 // always select the first tab to have at least some selection
336 bSelect = true;
337
338 Relayout();
339 Refresh();
340 }
341 else // not the first tab
342 {
343 RefreshAllTabs();
344 }
345
346 if ( bSelect )
347 {
348 SetSelection(nPage);
349 }
350 else // pages added to the notebook are initially hidden
351 {
352 pPage->Hide();
353 }
354
355 return true;
356 }
357
358 bool wxNotebook::DeleteAllPages()
359 {
360 if ( !wxNotebookBase::DeleteAllPages() )
361 return false;
362
363 // clear the other arrays as well
364 m_titles.Clear();
365 m_images.Clear();
366 m_accels.Clear();
367 m_widths.Clear();
368
369 // spin button is not needed any more
370 UpdateSpinBtn();
371
372 Relayout();
373
374 return true;
375 }
376
377 wxNotebookPage *wxNotebook::DoRemovePage(size_t nPage)
378 {
379 wxCHECK_MSG( IS_VALID_PAGE(nPage), NULL, wxT("invalid notebook page") );
380
381 wxNotebookPage *page = m_pages[nPage];
382 m_pages.RemoveAt(nPage);
383 m_titles.RemoveAt(nPage);
384 m_accels.RemoveAt(nPage);
385 m_widths.RemoveAt(nPage);
386 m_images.RemoveAt(nPage);
387
388 // the spin button might not be needed any more
389 // 2002-08-12 'if' commented out by JACS on behalf
390 // of Hans Van Leemputten <Hansvl@softhome.net> who
391 // points out that UpdateSpinBtn should always be called,
392 // to ensure m_lastVisible is up to date.
393 // if ( HasSpinBtn() )
394 {
395 UpdateSpinBtn();
396 }
397
398 size_t count = GetPageCount();
399 if ( count )
400 {
401 wxASSERT_MSG( m_selection != wxNOT_FOUND, "should have selection" );
402
403 if ( (size_t)m_selection == nPage )
404 {
405 // avoid sending event to this page which doesn't exist in the
406 // notebook any more
407 m_selection = wxNOT_FOUND;
408
409 SetSelection(nPage == count ? nPage - 1 : nPage);
410 }
411 else if ( (size_t)m_selection > nPage )
412 {
413 // no need to change selection, just adjust the index
414 m_selection--;
415 }
416 }
417 else // no more tabs left
418 {
419 m_selection = wxNOT_FOUND;
420 }
421
422 // have to refresh everything
423 Relayout();
424
425 return page;
426 }
427
428 // ----------------------------------------------------------------------------
429 // wxNotebook drawing
430 // ----------------------------------------------------------------------------
431
432 void wxNotebook::RefreshCurrent()
433 {
434 if ( m_selection != wxNOT_FOUND )
435 {
436 RefreshTab(m_selection);
437 }
438 }
439
440 void wxNotebook::RefreshTab(int page, bool forceSelected)
441 {
442 wxCHECK_RET( IS_VALID_PAGE(page), wxT("invalid notebook page") );
443
444 wxRect rect = GetTabRect(page);
445 if ( forceSelected || (page == m_selection) )
446 {
447 const wxSize indent = GetRenderer()->GetTabIndent();
448 rect.Inflate(indent.x, indent.y);
449 }
450
451 RefreshRect(rect);
452 }
453
454 void wxNotebook::RefreshAllTabs()
455 {
456 wxRect rect = GetAllTabsRect();
457 if ( rect.width || rect.height )
458 {
459 RefreshRect(rect);
460 }
461 //else: we don't have tabs at all
462 }
463
464 void wxNotebook::DoDrawTab(wxDC& dc, const wxRect& rect, size_t n)
465 {
466 wxBitmap bmp;
467 if ( HasImage(n) )
468 {
469 int image = m_images[n];
470
471 // Not needed now that wxGenericImageList is being
472 // used for wxUniversal under MSW
473 #if 0 // def __WXMSW__ // FIXME
474 int w, h;
475 m_imageList->GetSize(n, w, h);
476 bmp.Create(w, h);
477 wxMemoryDC dc;
478 dc.SelectObject(bmp);
479 dc.SetBackground(wxBrush(GetBackgroundColour(), wxSOLID));
480 m_imageList->Draw(image, dc, 0, 0, wxIMAGELIST_DRAW_NORMAL, true);
481 dc.SelectObject(wxNullBitmap);
482 #else
483 bmp = m_imageList->GetBitmap(image);
484 #endif
485 }
486
487 int flags = 0;
488 if ( (int)n == m_selection )
489 {
490 flags |= wxCONTROL_SELECTED;
491
492 if ( IsFocused() )
493 flags |= wxCONTROL_FOCUSED;
494 }
495
496 GetRenderer()->DrawTab
497 (
498 dc,
499 rect,
500 GetTabOrientation(),
501 m_titles[n],
502 bmp,
503 flags,
504 m_accels[n]
505 );
506 }
507
508 void wxNotebook::DoDraw(wxControlRenderer *renderer)
509 {
510 //wxRect rectUpdate = GetUpdateClientRect(); -- unused
511
512 wxDC& dc = renderer->GetDC();
513 dc.SetFont(GetFont());
514 dc.SetTextForeground(GetForegroundColour());
515
516 // redraw the border - it's simpler to always do it instead of checking
517 // whether this needs to be done
518 GetRenderer()->DrawBorder(dc, wxBORDER_RAISED, GetPagePart());
519
520 // avoid overwriting the spin button
521 if ( HasSpinBtn() )
522 {
523 wxRect rectTabs = GetAllTabsRect();
524 wxSize sizeSpinBtn = m_spinbtn->GetSize();
525
526 if ( IsVertical() )
527 {
528 rectTabs.height -= sizeSpinBtn.y;
529
530 // Allow for erasing the line under selected tab
531 rectTabs.width += 2;
532 }
533 else
534 {
535 rectTabs.width -= sizeSpinBtn.x;
536
537 // Allow for erasing the line under selected tab
538 rectTabs.height += 2;
539 }
540
541 dc.SetClippingRegion(rectTabs);
542 }
543
544 wxRect rect = GetTabsPart();
545 bool isVertical = IsVertical();
546
547 wxRect rectSel;
548 for ( size_t n = m_firstVisible; n < m_lastVisible; n++ )
549 {
550 GetTabSize(n, &rect.width, &rect.height);
551
552 if ( (int)n == m_selection )
553 {
554 // don't redraw it now as this tab has to be drawn over the other
555 // ones as it takes more place and spills over to them
556 rectSel = rect;
557 }
558 else // not selected tab
559 {
560 // unfortunately we can't do this because the selected tab hangs
561 // over its neighbours and so we might need to refresh more tabs -
562 // of course, we could still avoid rereshing some of them with more
563 // complicated checks, but it doesn't seem too bad to refresh all
564 // of them, I still don't see flicker, so leaving as is for now
565
566 //if ( rectUpdate.Intersects(rect) )
567 {
568 DoDrawTab(dc, rect, n);
569 }
570 //else: doesn't need to be refreshed
571 }
572
573 // move the rect to the next tab
574 if ( isVertical )
575 rect.y += rect.height;
576 else
577 rect.x += rect.width;
578 }
579
580 // now redraw the selected tab
581 if ( rectSel.width )
582 {
583 DoDrawTab(dc, rectSel, m_selection);
584 }
585
586 dc.DestroyClippingRegion();
587 }
588
589 // ----------------------------------------------------------------------------
590 // wxNotebook geometry
591 // ----------------------------------------------------------------------------
592
593 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
594 {
595 if ( flags )
596 *flags = wxBK_HITTEST_NOWHERE;
597
598 // first check that it is in this window at all
599 if ( !GetClientRect().Contains(pt) )
600 {
601 return -1;
602 }
603
604 wxRect rectTabs = GetAllTabsRect();
605
606 switch ( GetTabOrientation() )
607 {
608 default:
609 wxFAIL_MSG(wxT("unknown tab orientation"));
610 // fall through
611
612 case wxTOP:
613 if ( pt.y > rectTabs.GetBottom() )
614 return -1;
615 break;
616
617 case wxBOTTOM:
618 if ( pt.y < rectTabs.y )
619 return -1;
620 break;
621
622 case wxLEFT:
623 if ( pt.x > rectTabs.GetRight() )
624 return -1;
625 break;
626
627 case wxRIGHT:
628 if ( pt.x < rectTabs.x )
629 return -1;
630 break;
631 }
632
633 for ( size_t n = m_firstVisible; n < m_lastVisible; n++ )
634 {
635 GetTabSize(n, &rectTabs.width, &rectTabs.height);
636
637 if ( rectTabs.Contains(pt) )
638 {
639 if ( flags )
640 {
641 // TODO: be more precise
642 *flags = wxBK_HITTEST_ONITEM;
643 }
644
645 return n;
646 }
647
648 // move the rectTabs to the next tab
649 if ( IsVertical() )
650 rectTabs.y += rectTabs.height;
651 else
652 rectTabs.x += rectTabs.width;
653 }
654
655 return -1;
656 }
657
658 bool wxNotebook::IsVertical() const
659 {
660 wxDirection dir = GetTabOrientation();
661
662 return dir == wxLEFT || dir == wxRIGHT;
663 }
664
665 wxDirection wxNotebook::GetTabOrientation() const
666 {
667 long style = GetWindowStyle();
668 if ( style & wxBK_BOTTOM )
669 return wxBOTTOM;
670 else if ( style & wxBK_RIGHT )
671 return wxRIGHT;
672 else if ( style & wxBK_LEFT )
673 return wxLEFT;
674
675 // wxBK_TOP == 0 so we don't have to test for it
676 return wxTOP;
677 }
678
679 wxRect wxNotebook::GetTabRect(int page) const
680 {
681 wxRect rect;
682 wxCHECK_MSG( IS_VALID_PAGE(page), rect, wxT("invalid notebook page") );
683
684 // calc the size of this tab and of the preceding ones
685 wxCoord widthThis, widthBefore;
686 if ( FixedSizeTabs() )
687 {
688 widthThis = m_widthMax;
689 widthBefore = page*m_widthMax;
690 }
691 else
692 {
693 widthBefore = 0;
694 for ( int n = 0; n < page; n++ )
695 {
696 widthBefore += m_widths[n];
697 }
698
699 widthThis = m_widths[page];
700 }
701
702 rect = GetTabsPart();
703 if ( IsVertical() )
704 {
705 rect.y += widthBefore - m_offset;
706 rect.height = widthThis;
707 }
708 else // horz
709 {
710 rect.x += widthBefore - m_offset;
711 rect.width = widthThis;
712 }
713
714 return rect;
715 }
716
717 wxRect wxNotebook::GetAllTabsRect() const
718 {
719 wxRect rect;
720
721 if ( GetPageCount() )
722 {
723 const wxSize indent = GetRenderer()->GetTabIndent();
724 wxSize size = GetClientSize();
725
726 if ( IsVertical() )
727 {
728 rect.width = m_heightTab + indent.x;
729 rect.x = GetTabOrientation() == wxLEFT ? 0 : size.x - rect.width;
730 rect.y = 0;
731 rect.height = size.y;
732 }
733 else // horz
734 {
735 rect.x = 0;
736 rect.width = size.x;
737 rect.height = m_heightTab + indent.y;
738 rect.y = GetTabOrientation() == wxTOP ? 0 : size.y - rect.height;
739 }
740 }
741 //else: no pages
742
743 return rect;
744 }
745
746 wxRect wxNotebook::GetTabsPart() const
747 {
748 wxRect rect = GetAllTabsRect();
749
750 wxDirection dir = GetTabOrientation();
751
752 const wxSize indent = GetRenderer()->GetTabIndent();
753 if ( IsVertical() )
754 {
755 rect.y += indent.x;
756 if ( dir == wxLEFT )
757 {
758 rect.x += indent.y;
759 rect.width -= indent.y;
760 }
761 else // wxRIGHT
762 {
763 rect.width -= indent.y;
764 }
765 }
766 else // horz
767 {
768 rect.x += indent.x;
769 if ( dir == wxTOP )
770 {
771 rect.y += indent.y;
772 rect.height -= indent.y;
773 }
774 else // wxBOTTOM
775 {
776 rect.height -= indent.y;
777 }
778 }
779
780 return rect;
781 }
782
783 void wxNotebook::GetTabSize(int page, wxCoord *w, wxCoord *h) const
784 {
785 wxCHECK_RET( w && h, wxT("NULL pointer in GetTabSize") );
786
787 if ( IsVertical() )
788 {
789 // width and height have inverted meaning
790 wxCoord *tmp = w;
791 w = h;
792 h = tmp;
793 }
794
795 // height is always fixed
796 *h = m_heightTab;
797
798 // width may also be fixed and be the same for all tabs
799 *w = GetTabWidth(page);
800 }
801
802 void wxNotebook::SetTabSize(const wxSize& sz)
803 {
804 wxCHECK_RET( FixedSizeTabs(), wxT("SetTabSize() ignored") );
805
806 if ( IsVertical() )
807 {
808 m_heightTab = sz.x;
809 m_widthMax = sz.y;
810 }
811 else // horz
812 {
813 m_widthMax = sz.x;
814 m_heightTab = sz.y;
815 }
816 }
817
818 wxSize wxNotebook::CalcTabSize(int page) const
819 {
820 // NB: don't use m_widthMax, m_heightTab or m_widths here because this
821 // method is called to calculate them
822
823 wxSize size;
824
825 wxCHECK_MSG( IS_VALID_PAGE(page), size, wxT("invalid notebook page") );
826
827 GetTextExtent(m_titles[page], &size.x, &size.y);
828
829 if ( HasImage(page) )
830 {
831 wxSize sizeImage;
832 m_imageList->GetSize(m_images[page], sizeImage.x, sizeImage.y);
833
834 size.x += sizeImage.x + 5; // FIXME: hard coded margin
835
836 if ( sizeImage.y > size.y )
837 size.y = sizeImage.y;
838 }
839
840 size.x += 2*m_sizePad.x;
841 size.y += 2*m_sizePad.y;
842
843 return size;
844 }
845
846 void wxNotebook::ResizeTab(int page)
847 {
848 wxSize sizeTab = CalcTabSize(page);
849
850 // we only need full relayout if the page size changes
851 bool needsRelayout = false;
852
853 if ( IsVertical() )
854 {
855 // swap coordinates
856 wxCoord tmp = sizeTab.x;
857 sizeTab.x = sizeTab.y;
858 sizeTab.y = tmp;
859 }
860
861 if ( sizeTab.y > m_heightTab )
862 {
863 needsRelayout = true;
864
865 m_heightTab = sizeTab.y;
866 }
867
868 m_widths[page] = sizeTab.x;
869
870 if ( sizeTab.x > m_widthMax )
871 m_widthMax = sizeTab.x;
872
873 // the total of the tabs has changed too
874 UpdateSpinBtn();
875
876 if ( needsRelayout )
877 Relayout();
878 else
879 RefreshAllTabs();
880 }
881
882 void wxNotebook::SetPadding(const wxSize& padding)
883 {
884 if ( padding != m_sizePad )
885 {
886 m_sizePad = padding;
887
888 Relayout();
889 }
890 }
891
892 void wxNotebook::Relayout()
893 {
894 if ( GetPageCount() )
895 {
896 RefreshAllTabs();
897
898 UpdateSpinBtn();
899
900 if ( m_selection != wxNOT_FOUND )
901 {
902 // resize the currently shown page
903 wxRect rectPage = GetPageRect();
904
905 m_pages[m_selection]->SetSize(rectPage);
906
907 // also scroll it into view if needed (note that m_lastVisible
908 // was updated by the call to UpdateSpinBtn() above, this is why it
909 // is needed here)
910 if ( HasSpinBtn() )
911 {
912 const size_t selection = m_selection;
913 if ( selection < m_firstVisible )
914 {
915 // selection is to the left of visible part of tabs
916 ScrollTo(selection);
917 }
918 else if ( selection > m_lastFullyVisible )
919 {
920 // selection is to the right of visible part of tabs
921 ScrollLastTo(selection);
922 }
923 }
924 }
925 }
926 else // we have no pages
927 {
928 // just refresh everything
929 Refresh();
930 }
931 }
932
933 wxRect wxNotebook::GetPagePart() const
934 {
935 wxRect rectPage = GetClientRect();
936
937 if ( GetPageCount() )
938 {
939 wxRect rectTabs = GetAllTabsRect();
940 wxDirection dir = GetTabOrientation();
941 if ( IsVertical() )
942 {
943 rectPage.width -= rectTabs.width;
944 if ( dir == wxLEFT )
945 rectPage.x += rectTabs.width;
946 }
947 else // horz
948 {
949 rectPage.height -= rectTabs.height;
950 if ( dir == wxTOP )
951 rectPage.y += rectTabs.height;
952 }
953 }
954 //else: no pages at all
955
956 return rectPage;
957 }
958
959 wxRect wxNotebook::GetPageRect() const
960 {
961 wxRect rect = GetPagePart();
962
963 // leave space for the border
964 wxRect rectBorder = GetRenderer()->GetBorderDimensions(wxBORDER_RAISED);
965
966 // FIXME: hardcoded +2!
967 rect.Inflate(-(rectBorder.x + rectBorder.width + 2),
968 -(rectBorder.y + rectBorder.height + 2));
969
970 return rect;
971 }
972
973 wxSize wxNotebook::GetSizeForPage(const wxSize& size) const
974 {
975 wxSize sizeNb = size;
976 wxRect rect = GetAllTabsRect();
977 if ( IsVertical() )
978 sizeNb.x += rect.width;
979 else
980 sizeNb.y += rect.height;
981
982 return sizeNb;
983 }
984
985 void wxNotebook::SetPageSize(const wxSize& size)
986 {
987 SetClientSize(GetSizeForPage(size));
988 }
989
990 wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
991 {
992 return AdjustSize(GetSizeForPage(sizePage));
993 }
994
995 // ----------------------------------------------------------------------------
996 // wxNotebook spin button
997 // ----------------------------------------------------------------------------
998
999 bool wxNotebook::HasSpinBtn() const
1000 {
1001 return m_spinbtn && m_spinbtn->IsShown();
1002 }
1003
1004 void wxNotebook::CalcLastVisibleTab()
1005 {
1006 bool isVertical = IsVertical();
1007
1008 wxCoord width = GetClientSize().x;
1009
1010 wxRect rect = GetTabsPart();
1011
1012 size_t count = GetPageCount();
1013
1014 wxCoord widthLast = 0;
1015 size_t n;
1016 for ( n = m_firstVisible; n < count; n++ )
1017 {
1018 GetTabSize(n, &rect.width, &rect.height);
1019 if ( rect.GetRight() > width )
1020 {
1021 break;
1022 }
1023
1024 // remember it to use below
1025 widthLast = rect.GetRight();
1026
1027 // move the rect to the next tab
1028 if ( isVertical )
1029 rect.y += rect.height;
1030 else
1031 rect.x += rect.width;
1032 }
1033
1034 if ( n == m_firstVisible )
1035 {
1036 // even the first tab isn't fully visible - but still pretend it is as
1037 // we have to show something
1038 m_lastFullyVisible = m_firstVisible;
1039 }
1040 else // more than one tab visible
1041 {
1042 m_lastFullyVisible = n - 1;
1043
1044 // but is it really fully visible? it shouldn't overlap with the spin
1045 // button if it is present (again, even if the first button does
1046 // overlap with it, we pretend that it doesn't as there is not much
1047 // else we can do)
1048 if ( (m_lastFullyVisible > m_firstVisible) && HasSpinBtn() )
1049 {
1050 // adjust width to be the width before the spin button
1051 wxSize sizeSpinBtn = m_spinbtn->GetSize();
1052 if ( IsVertical() )
1053 width -= sizeSpinBtn.y;
1054 else
1055 width -= sizeSpinBtn.x;
1056
1057 if ( widthLast > width )
1058 {
1059 // the last button overlaps with spin button, so take he
1060 // previous one
1061 m_lastFullyVisible--;
1062 }
1063 }
1064 }
1065
1066 if ( n == count )
1067 {
1068 // everything is visible
1069 m_lastVisible = n;
1070 }
1071 else
1072 {
1073 // this tab is still (partially) visible, so m_lastVisible is the
1074 // next tab (remember, this is "exclusive" last)
1075 m_lastVisible = n + 1;
1076
1077 }
1078 }
1079
1080 void wxNotebook::UpdateSpinBtn()
1081 {
1082 // first decide if we need a spin button
1083 bool allTabsShown;
1084
1085 size_t count = (size_t)GetPageCount();
1086 if ( count == 0 )
1087 {
1088 // this case is special, get rid of it immediately: everything is
1089 // visible and we don't need any spin buttons
1090 allTabsShown = true;
1091
1092 // have to reset them manually as we don't call CalcLastVisibleTab()
1093 m_firstVisible =
1094 m_lastVisible =
1095 m_lastFullyVisible = 0;
1096 }
1097 else
1098 {
1099 CalcLastVisibleTab();
1100
1101 // if all tabs after the first visible one are shown, it doesn't yet
1102 // mean that all tabs are shown - so we go backwards until we arrive to
1103 // the beginning (then all tabs are indeed shown) or find a tab such
1104 // that not all tabs after it are shown
1105 while ( (m_lastFullyVisible == count - 1) && (m_firstVisible > 0) )
1106 {
1107 // this is equivalent to ScrollTo(m_firstVisible - 1) but more
1108 // efficient
1109 m_offset -= GetTabWidth(m_firstVisible--);
1110
1111 // reclaculate after m_firstVisible change
1112 CalcLastVisibleTab();
1113 }
1114
1115 allTabsShown = m_lastFullyVisible == count - 1;
1116 }
1117
1118 if ( !allTabsShown )
1119 {
1120 if ( !m_spinbtn )
1121 {
1122 // create it once only
1123 m_spinbtn = new wxNotebookSpinBtn(this);
1124
1125 // set the correct value to keep it in sync
1126 m_spinbtn->SetValue(m_selection);
1127 }
1128
1129 // position it correctly
1130 PositionSpinBtn();
1131
1132 // and show it
1133 m_spinbtn->Show();
1134
1135 // also set/update the range
1136 m_spinbtn->SetRange(0, count - 1);
1137
1138 // update m_lastFullyVisible once again as it might have changed
1139 // because the spin button appeared
1140 //
1141 // FIXME: might do it more efficiently
1142 CalcLastVisibleTab();
1143 }
1144 else // all tabs are visible, we don't need spin button
1145 {
1146 if ( m_spinbtn && m_spinbtn -> IsShown() )
1147 {
1148 m_spinbtn->Hide();
1149 }
1150 }
1151 }
1152
1153 void wxNotebook::PositionSpinBtn()
1154 {
1155 if ( !m_spinbtn )
1156 return;
1157
1158 wxCoord wBtn, hBtn;
1159 m_spinbtn->GetSize(&wBtn, &hBtn);
1160
1161 wxRect rectTabs = GetAllTabsRect();
1162
1163 wxCoord x, y;
1164 switch ( GetTabOrientation() )
1165 {
1166 default:
1167 wxFAIL_MSG(wxT("unknown tab orientation"));
1168 // fall through
1169
1170 case wxTOP:
1171 x = rectTabs.GetRight() - wBtn;
1172 y = rectTabs.GetBottom() - hBtn;
1173 break;
1174
1175 case wxBOTTOM:
1176 x = rectTabs.GetRight() - wBtn;
1177 y = rectTabs.GetTop();
1178 break;
1179
1180 case wxLEFT:
1181 x = rectTabs.GetRight() - wBtn;
1182 y = rectTabs.GetBottom() - hBtn;
1183 break;
1184
1185 case wxRIGHT:
1186 x = rectTabs.GetLeft();
1187 y = rectTabs.GetBottom() - hBtn;
1188 break;
1189 }
1190
1191 m_spinbtn->Move(x, y);
1192 }
1193
1194 // ----------------------------------------------------------------------------
1195 // wxNotebook scrolling
1196 // ----------------------------------------------------------------------------
1197
1198 void wxNotebook::ScrollTo(size_t page)
1199 {
1200 wxCHECK_RET( IS_VALID_PAGE(page), wxT("invalid notebook page") );
1201
1202 // set the first visible tab and offset (easy)
1203 m_firstVisible = page;
1204 m_offset = 0;
1205 for ( size_t n = 0; n < m_firstVisible; n++ )
1206 {
1207 m_offset += GetTabWidth(n);
1208 }
1209
1210 // find the last visible tab too
1211 CalcLastVisibleTab();
1212
1213 RefreshAllTabs();
1214 }
1215
1216 void wxNotebook::ScrollLastTo(size_t page)
1217 {
1218 wxCHECK_RET( IS_VALID_PAGE(page), wxT("invalid notebook page") );
1219
1220 // go backwards until we find the first tab which can be made visible
1221 // without hiding the given one
1222 wxSize size = GetClientSize();
1223 wxCoord widthAll = IsVertical() ? size.y : size.x,
1224 widthTabs = GetTabWidth(page);
1225
1226 // the total width is less than the width of the window if we have the spin
1227 // button
1228 if ( HasSpinBtn() )
1229 {
1230 wxSize sizeSpinBtn = m_spinbtn->GetSize();
1231 if ( IsVertical() )
1232 widthAll -= sizeSpinBtn.y;
1233 else
1234 widthAll -= sizeSpinBtn.x;
1235 }
1236
1237 m_firstVisible = page;
1238 while ( (m_firstVisible > 0) && (widthTabs <= widthAll) )
1239 {
1240 widthTabs += GetTabWidth(--m_firstVisible);
1241 }
1242
1243 if ( widthTabs > widthAll )
1244 {
1245 // take one step back (that it is forward) if we can
1246 if ( m_firstVisible < (size_t)GetPageCount() - 1 )
1247 m_firstVisible++;
1248 }
1249
1250 // go to it
1251 ScrollTo(m_firstVisible);
1252
1253 // consitency check: the page we were asked to show should be shown
1254 wxASSERT_MSG( (size_t)page < m_lastVisible, wxT("bug in ScrollLastTo") );
1255 }
1256
1257 // ----------------------------------------------------------------------------
1258 // wxNotebook sizing/moving
1259 // ----------------------------------------------------------------------------
1260
1261 wxSize wxNotebook::DoGetBestClientSize() const
1262 {
1263 // calculate the max page size
1264 wxSize size;
1265
1266 size_t count = GetPageCount();
1267 if ( count )
1268 {
1269 for ( size_t n = 0; n < count; n++ )
1270 {
1271 wxSize sizePage = m_pages[n]->GetSize();
1272
1273 if ( size.x < sizePage.x )
1274 size.x = sizePage.x;
1275 if ( size.y < sizePage.y )
1276 size.y = sizePage.y;
1277 }
1278 }
1279 else // no pages
1280 {
1281 // use some arbitrary default size
1282 size.x =
1283 size.y = 100;
1284 }
1285
1286 return GetSizeForPage(size);
1287 }
1288
1289 void wxNotebook::DoMoveWindow(int x, int y, int width, int height)
1290 {
1291 wxControl::DoMoveWindow(x, y, width, height);
1292
1293 // move the spin ctrl too (NOP if it doesn't exist)
1294 PositionSpinBtn();
1295 }
1296
1297 void wxNotebook::DoSetSize(int x, int y,
1298 int width, int height,
1299 int sizeFlags)
1300 {
1301 wxSize old_client_size = GetClientSize();
1302
1303 wxControl::DoSetSize(x, y, width, height, sizeFlags);
1304
1305 wxSize new_client_size = GetClientSize();
1306
1307 if (old_client_size != new_client_size)
1308 Relayout();
1309 }
1310
1311 // ----------------------------------------------------------------------------
1312 // wxNotebook input processing
1313 // ----------------------------------------------------------------------------
1314
1315 bool wxNotebook::PerformAction(const wxControlAction& action,
1316 long numArg,
1317 const wxString& strArg)
1318 {
1319 if ( action == wxACTION_NOTEBOOK_NEXT )
1320 SetSelection(GetNextPage(true));
1321 else if ( action == wxACTION_NOTEBOOK_PREV )
1322 SetSelection(GetNextPage(false));
1323 else if ( action == wxACTION_NOTEBOOK_GOTO )
1324 SetSelection((int)numArg);
1325 else
1326 return wxControl::PerformAction(action, numArg, strArg);
1327
1328 return true;
1329 }
1330
1331 /* static */
1332 wxInputHandler *wxNotebook::GetStdInputHandler(wxInputHandler *handlerDef)
1333 {
1334 static wxStdNotebookInputHandler s_handler(handlerDef);
1335
1336 return &s_handler;
1337 }
1338
1339 // ----------------------------------------------------------------------------
1340 // wxStdNotebookInputHandler
1341 // ----------------------------------------------------------------------------
1342
1343 wxStdNotebookInputHandler::wxStdNotebookInputHandler(wxInputHandler *inphand)
1344 : wxStdInputHandler(inphand)
1345 {
1346 }
1347
1348 bool wxStdNotebookInputHandler::HandleKey(wxInputConsumer *consumer,
1349 const wxKeyEvent& event,
1350 bool pressed)
1351 {
1352 // ignore the key releases
1353 if ( pressed )
1354 {
1355 wxNotebook *notebook = wxStaticCast(consumer->GetInputWindow(), wxNotebook);
1356
1357 int page = 0;
1358 wxControlAction action;
1359 switch ( event.GetKeyCode() )
1360 {
1361 case WXK_UP:
1362 if ( notebook->IsVertical() )
1363 action = wxACTION_NOTEBOOK_PREV;
1364 break;
1365
1366 case WXK_LEFT:
1367 if ( !notebook->IsVertical() )
1368 action = wxACTION_NOTEBOOK_PREV;
1369 break;
1370
1371 case WXK_DOWN:
1372 if ( notebook->IsVertical() )
1373 action = wxACTION_NOTEBOOK_NEXT;
1374 break;
1375
1376 case WXK_RIGHT:
1377 if ( !notebook->IsVertical() )
1378 action = wxACTION_NOTEBOOK_NEXT;
1379 break;
1380
1381 case WXK_HOME:
1382 action = wxACTION_NOTEBOOK_GOTO;
1383 // page = 0; -- already has this value
1384 break;
1385
1386 case WXK_END:
1387 action = wxACTION_NOTEBOOK_GOTO;
1388 page = notebook->GetPageCount() - 1;
1389 break;
1390 }
1391
1392 if ( !action.IsEmpty() )
1393 {
1394 return consumer->PerformAction(action, page);
1395 }
1396 }
1397
1398 return wxStdInputHandler::HandleKey(consumer, event, pressed);
1399 }
1400
1401 bool wxStdNotebookInputHandler::HandleMouse(wxInputConsumer *consumer,
1402 const wxMouseEvent& event)
1403 {
1404 if ( event.ButtonDown(1) )
1405 {
1406 wxNotebook *notebook = wxStaticCast(consumer->GetInputWindow(), wxNotebook);
1407 int page = notebook->HitTest(event.GetPosition());
1408 if ( page != -1 )
1409 {
1410 consumer->PerformAction(wxACTION_NOTEBOOK_GOTO, page);
1411
1412 return false;
1413 }
1414 }
1415
1416 return wxStdInputHandler::HandleMouse(consumer, event);
1417 }
1418
1419 bool wxStdNotebookInputHandler::HandleMouseMove(wxInputConsumer *consumer,
1420 const wxMouseEvent& event)
1421 {
1422 return wxStdInputHandler::HandleMouseMove(consumer, event);
1423 }
1424
1425 bool
1426 wxStdNotebookInputHandler::HandleFocus(wxInputConsumer *consumer,
1427 const wxFocusEvent& WXUNUSED(event))
1428 {
1429 HandleFocusChange(consumer);
1430
1431 return false;
1432 }
1433
1434 bool wxStdNotebookInputHandler::HandleActivation(wxInputConsumer *consumer,
1435 bool WXUNUSED(activated))
1436 {
1437 // we react to the focus change in the same way as to the [de]activation
1438 HandleFocusChange(consumer);
1439
1440 return false;
1441 }
1442
1443 void wxStdNotebookInputHandler::HandleFocusChange(wxInputConsumer *consumer)
1444 {
1445 wxNotebook *notebook = wxStaticCast(consumer->GetInputWindow(), wxNotebook);
1446 notebook->RefreshCurrent();
1447 }
1448
1449 #endif // wxUSE_NOTEBOOK