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