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