1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/notebook.cpp
3 // Purpose: implementation of wxNotebook
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
21 #include "wx/notebook.h"
24 #include "wx/string.h"
29 #include "wx/dcclient.h"
32 #include "wx/imaglist.h"
33 #include "wx/control.h"
34 #include "wx/sysopt.h"
35 #include "wx/dcmemory.h"
37 #include "wx/msw/private.h"
43 #include "wx/msw/winundef.h"
46 #include "wx/msw/uxtheme.h"
49 // ----------------------------------------------------------------------------
51 // ----------------------------------------------------------------------------
53 // check that the page index is valid
54 #define IS_VALID_PAGE(nPage) ((nPage) < GetPageCount())
56 // you can set USE_NOTEBOOK_ANTIFLICKER to 0 for desktop Windows versions too
57 // to disable code whih results in flicker-less notebook redrawing at the
58 // expense of some extra GDI resource consumption
60 // notebooks are never resized under CE anyhow
61 #define USE_NOTEBOOK_ANTIFLICKER 0
63 #define USE_NOTEBOOK_ANTIFLICKER 1
66 // ----------------------------------------------------------------------------
68 // ----------------------------------------------------------------------------
70 // This is a work-around for missing defines in gcc-2.95 headers
72 #define TCS_RIGHT 0x0002
76 #define TCS_VERTICAL 0x0080
80 #define TCS_BOTTOM TCS_RIGHT
83 // ----------------------------------------------------------------------------
85 // ----------------------------------------------------------------------------
87 #if USE_NOTEBOOK_ANTIFLICKER
89 // the pointer to standard spin button wnd proc
90 static WXFARPROC gs_wndprocNotebookSpinBtn
= (WXFARPROC
)NULL
;
92 // the pointer to standard tab control wnd proc
93 static WXFARPROC gs_wndprocNotebook
= (WXFARPROC
)NULL
;
95 LRESULT APIENTRY _EXPORT
wxNotebookWndProc(HWND hwnd
,
100 #endif // USE_NOTEBOOK_ANTIFLICKER
102 // ----------------------------------------------------------------------------
104 // ----------------------------------------------------------------------------
106 #include "wx/listimpl.cpp"
108 WX_DEFINE_LIST( wxNotebookPageInfoList
)
110 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
)
111 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
)
113 BEGIN_EVENT_TABLE(wxNotebook
, wxControl
)
114 EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY
, wxNotebook::OnSelChange
)
115 EVT_SIZE(wxNotebook::OnSize
)
116 EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey
)
118 #if USE_NOTEBOOK_ANTIFLICKER
119 EVT_ERASE_BACKGROUND(wxNotebook::OnEraseBackground
)
120 EVT_PAINT(wxNotebook::OnPaint
)
121 #endif // USE_NOTEBOOK_ANTIFLICKER
124 #if wxUSE_EXTENDED_RTTI
125 WX_DEFINE_FLAGS( wxNotebookStyle
)
127 wxBEGIN_FLAGS( wxNotebookStyle
)
128 // new style border flags, we put them first to
129 // use them for streaming out
130 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
131 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
132 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
133 wxFLAGS_MEMBER(wxBORDER_RAISED
)
134 wxFLAGS_MEMBER(wxBORDER_STATIC
)
135 wxFLAGS_MEMBER(wxBORDER_NONE
)
137 // old style border flags
138 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
139 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
140 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
141 wxFLAGS_MEMBER(wxRAISED_BORDER
)
142 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
143 wxFLAGS_MEMBER(wxBORDER
)
145 // standard window styles
146 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
147 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
148 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
149 wxFLAGS_MEMBER(wxWANTS_CHARS
)
150 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
151 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
152 wxFLAGS_MEMBER(wxVSCROLL
)
153 wxFLAGS_MEMBER(wxHSCROLL
)
155 wxFLAGS_MEMBER(wxNB_FIXEDWIDTH
)
156 wxFLAGS_MEMBER(wxBK_DEFAULT
)
157 wxFLAGS_MEMBER(wxBK_TOP
)
158 wxFLAGS_MEMBER(wxBK_LEFT
)
159 wxFLAGS_MEMBER(wxBK_RIGHT
)
160 wxFLAGS_MEMBER(wxBK_BOTTOM
)
161 wxFLAGS_MEMBER(wxNB_NOPAGETHEME
)
162 wxFLAGS_MEMBER(wxNB_FLAT
)
164 wxEND_FLAGS( wxNotebookStyle
)
166 IMPLEMENT_DYNAMIC_CLASS_XTI(wxNotebook
, wxControl
,"wx/notebook.h")
167 IMPLEMENT_DYNAMIC_CLASS_XTI(wxNotebookPageInfo
, wxObject
, "wx/notebook.h" )
169 wxCOLLECTION_TYPE_INFO( wxNotebookPageInfo
* , wxNotebookPageInfoList
) ;
171 template<> void wxCollectionToVariantArray( wxNotebookPageInfoList
const &theList
, wxxVariantArray
&value
)
173 wxListCollectionToVariantArray
<wxNotebookPageInfoList::compatibility_iterator
>( theList
, value
) ;
176 wxBEGIN_PROPERTIES_TABLE(wxNotebook
)
177 wxEVENT_PROPERTY( PageChanging
, wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
, wxNotebookEvent
)
178 wxEVENT_PROPERTY( PageChanged
, wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
, wxNotebookEvent
)
180 wxPROPERTY_COLLECTION( PageInfos
, wxNotebookPageInfoList
, wxNotebookPageInfo
* , AddPageInfo
, GetPageInfos
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
181 wxPROPERTY_FLAGS( WindowStyle
, wxNotebookStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
182 wxEND_PROPERTIES_TABLE()
184 wxBEGIN_HANDLERS_TABLE(wxNotebook
)
185 wxEND_HANDLERS_TABLE()
187 wxCONSTRUCTOR_5( wxNotebook
, wxWindow
* , Parent
, wxWindowID
, Id
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
190 wxBEGIN_PROPERTIES_TABLE(wxNotebookPageInfo
)
191 wxREADONLY_PROPERTY( Page
, wxNotebookPage
* , GetPage
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
192 wxREADONLY_PROPERTY( Text
, wxString
, GetText
, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
193 wxREADONLY_PROPERTY( Selected
, bool , GetSelected
, false, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
194 wxREADONLY_PROPERTY( ImageId
, int , GetImageId
, -1 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
195 wxEND_PROPERTIES_TABLE()
197 wxBEGIN_HANDLERS_TABLE(wxNotebookPageInfo
)
198 wxEND_HANDLERS_TABLE()
200 wxCONSTRUCTOR_4( wxNotebookPageInfo
, wxNotebookPage
* , Page
, wxString
, Text
, bool , Selected
, int , ImageId
)
203 IMPLEMENT_DYNAMIC_CLASS(wxNotebook
, wxControl
)
204 IMPLEMENT_DYNAMIC_CLASS(wxNotebookPageInfo
, wxObject
)
206 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent
, wxNotifyEvent
)
208 // ============================================================================
210 // ============================================================================
212 // ----------------------------------------------------------------------------
213 // wxNotebook construction
214 // ----------------------------------------------------------------------------
216 const wxNotebookPageInfoList
& wxNotebook::GetPageInfos() const
218 wxNotebookPageInfoList
* list
= const_cast< wxNotebookPageInfoList
* >( &m_pageInfos
) ;
219 WX_CLEAR_LIST( wxNotebookPageInfoList
, *list
) ;
220 for( size_t i
= 0 ; i
< GetPageCount() ; ++i
)
222 wxNotebookPageInfo
*info
= new wxNotebookPageInfo() ;
223 info
->Create( const_cast<wxNotebook
*>(this)->GetPage(i
) , GetPageText(i
) , GetSelection() == int(i
) , GetPageImage(i
) ) ;
224 list
->Append( info
) ;
229 // common part of all ctors
230 void wxNotebook::Init()
236 m_hbrBackground
= NULL
;
237 #endif // wxUSE_UXTHEME
239 #if USE_NOTEBOOK_ANTIFLICKER
240 m_hasSubclassedUpdown
= false;
241 #endif // USE_NOTEBOOK_ANTIFLICKER
244 // default for dynamic class
245 wxNotebook::wxNotebook()
250 // the same arguments as for wxControl
251 wxNotebook::wxNotebook(wxWindow
*parent
,
256 const wxString
& name
)
260 Create(parent
, id
, pos
, size
, style
, name
);
264 bool wxNotebook::Create(wxWindow
*parent
,
269 const wxString
& name
)
272 // Not sure why, but without this style, there is no border
273 // around the notebook tabs.
274 if (style
& wxNB_FLAT
)
275 style
|= wxBORDER_SUNKEN
;
279 // ComCtl32 notebook tabs simply don't work unless they're on top if we have uxtheme, we can
280 // work around it later (after control creation), but if we don't have uxtheme, we have to clear
282 const int verComCtl32
= wxApp::GetComCtl32Version();
283 if ( verComCtl32
== 600 )
285 style
&= ~(wxBK_BOTTOM
| wxBK_LEFT
| wxBK_RIGHT
);
287 #endif //wxUSE_UXTHEME
289 LPCTSTR className
= WC_TABCONTROL
;
291 #if USE_NOTEBOOK_ANTIFLICKER
292 // SysTabCtl32 class has natively CS_HREDRAW and CS_VREDRAW enabled and it
293 // causes horrible flicker when resizing notebook, so get rid of it by
294 // using a class without these styles (but otherwise identical to it)
295 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
297 static ClassRegistrar s_clsNotebook
;
298 if ( !s_clsNotebook
.IsInitialized() )
300 // get a copy of standard class and modify it
303 if ( ::GetClassInfo(NULL
, WC_TABCONTROL
, &wc
) )
306 wx_reinterpret_cast(WXFARPROC
, wc
.lpfnWndProc
);
307 wc
.lpszClassName
= wxT("_wx_SysTabCtl32");
308 wc
.style
&= ~(CS_HREDRAW
| CS_VREDRAW
);
309 wc
.hInstance
= wxGetInstance();
310 wc
.lpfnWndProc
= wxNotebookWndProc
;
311 s_clsNotebook
.Register(wc
);
315 wxLogLastError(_T("GetClassInfoEx(SysTabCtl32)"));
319 // use our custom class if available but fall back to the standard
320 // notebook if we failed to register it
321 if ( s_clsNotebook
.IsRegistered() )
323 // it's ok to use c_str() here as the static s_clsNotebook object
324 // has sufficiently long lifetime
325 className
= s_clsNotebook
.GetName().c_str();
328 #endif // USE_NOTEBOOK_ANTIFLICKER
330 if ( !CreateControl(parent
, id
, pos
, size
, style
| wxTAB_TRAVERSAL
,
331 wxDefaultValidator
, name
) )
334 if ( !MSWCreateControl(className
, wxEmptyString
, pos
, size
) )
338 if ( HasFlag(wxNB_NOPAGETHEME
) ||
339 wxSystemOptions::IsFalse(wxT("msw.notebook.themed-background")) )
341 SetBackgroundColour(GetThemeBackgroundColour());
343 else // use themed background by default
345 // create backing store
349 // comctl32.dll 6.0 doesn't support non-top tabs with visual styles (the
350 // control is simply not rendered correctly), so we disable themes
351 // if possible, otherwise we simply clear the styles.
352 // It's probably not possible to have UXTHEME without ComCtl32 6 or better, but lets
354 const int verComCtl32
= wxApp::GetComCtl32Version();
355 if ( verComCtl32
== 600 )
357 // check if we use themes at all -- if we don't, we're still okay
358 if ( wxUxThemeEngine::GetIfActive() && (style
& (wxBK_BOTTOM
|wxBK_LEFT
|wxBK_RIGHT
)))
360 wxUxThemeEngine::GetIfActive()->SetWindowTheme((HWND
)this->GetHandle(), L
"", L
"");
361 SetBackgroundColour(GetThemeBackgroundColour()); //correct the background color for the new non-themed control
364 #endif // wxUSE_UXTHEME
366 // Undocumented hack to get flat notebook style
367 // In fact, we should probably only do this in some
368 // curcumstances, i.e. if we know we will have a border
369 // at the bottom (the tab control doesn't draw it itself)
370 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
371 if (HasFlag(wxNB_FLAT
))
373 SendMessage(GetHwnd(), CCM_SETVERSION
, COMCTL32_VERSION
, 0);
375 SetBackgroundColour(*wxWHITE
);
381 WXDWORD
wxNotebook::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
383 WXDWORD tabStyle
= wxControl::MSWGetStyle(style
, exstyle
);
385 tabStyle
|= WS_TABSTOP
| TCS_TABS
;
387 if ( style
& wxNB_MULTILINE
)
388 tabStyle
|= TCS_MULTILINE
;
389 if ( style
& wxNB_FIXEDWIDTH
)
390 tabStyle
|= TCS_FIXEDWIDTH
;
392 if ( style
& wxBK_BOTTOM
)
393 tabStyle
|= TCS_RIGHT
;
394 else if ( style
& wxBK_LEFT
)
395 tabStyle
|= TCS_VERTICAL
;
396 else if ( style
& wxBK_RIGHT
)
397 tabStyle
|= TCS_VERTICAL
| TCS_RIGHT
;
402 // note that we never want to have the default WS_EX_CLIENTEDGE style
403 // as it looks too ugly for the notebooks
410 wxNotebook::~wxNotebook()
413 if ( m_hbrBackground
)
414 ::DeleteObject((HBRUSH
)m_hbrBackground
);
415 #endif // wxUSE_UXTHEME
418 // ----------------------------------------------------------------------------
419 // wxNotebook accessors
420 // ----------------------------------------------------------------------------
422 size_t wxNotebook::GetPageCount() const
425 wxASSERT( (int)m_pages
.Count() == TabCtrl_GetItemCount(GetHwnd()) );
427 return m_pages
.Count();
430 int wxNotebook::GetRowCount() const
432 return TabCtrl_GetRowCount(GetHwnd());
435 int wxNotebook::SetSelection(size_t nPage
)
437 wxCHECK_MSG( IS_VALID_PAGE(nPage
), wxNOT_FOUND
, wxT("notebook page out of range") );
439 if ( int(nPage
) != m_nSelection
)
441 wxNotebookEvent
event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
, m_windowId
);
442 event
.SetSelection(nPage
);
443 event
.SetOldSelection(m_nSelection
);
444 event
.SetEventObject(this);
445 if ( !GetEventHandler()->ProcessEvent(event
) || event
.IsAllowed() )
447 // program allows the page change
448 event
.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
);
449 (void)GetEventHandler()->ProcessEvent(event
);
451 TabCtrl_SetCurSel(GetHwnd(), nPage
);
458 bool wxNotebook::SetPageText(size_t nPage
, const wxString
& strText
)
460 wxCHECK_MSG( IS_VALID_PAGE(nPage
), false, wxT("notebook page out of range") );
463 tcItem
.mask
= TCIF_TEXT
;
464 tcItem
.pszText
= (wxChar
*)strText
.c_str();
466 if ( !HasFlag(wxNB_MULTILINE
) )
467 return TabCtrl_SetItem(GetHwnd(), nPage
, &tcItem
) != 0;
469 // multiline - we need to set new page size if a line is added or removed
470 int rows
= GetRowCount();
471 bool ret
= TabCtrl_SetItem(GetHwnd(), nPage
, &tcItem
) != 0;
473 if ( ret
&& rows
!= GetRowCount() )
475 const wxRect r
= GetPageSize();
476 const size_t count
= m_pages
.Count();
477 for ( size_t page
= 0; page
< count
; page
++ )
478 m_pages
[page
]->SetSize(r
);
484 wxString
wxNotebook::GetPageText(size_t nPage
) const
486 wxCHECK_MSG( IS_VALID_PAGE(nPage
), wxEmptyString
, wxT("notebook page out of range") );
490 tcItem
.mask
= TCIF_TEXT
;
491 tcItem
.pszText
= buf
;
492 tcItem
.cchTextMax
= WXSIZEOF(buf
);
495 if ( TabCtrl_GetItem(GetHwnd(), nPage
, &tcItem
) )
496 str
= tcItem
.pszText
;
501 int wxNotebook::GetPageImage(size_t nPage
) const
503 wxCHECK_MSG( IS_VALID_PAGE(nPage
), wxNOT_FOUND
, wxT("notebook page out of range") );
506 tcItem
.mask
= TCIF_IMAGE
;
508 return TabCtrl_GetItem(GetHwnd(), nPage
, &tcItem
) ? tcItem
.iImage
: wxNOT_FOUND
;
511 bool wxNotebook::SetPageImage(size_t nPage
, int nImage
)
513 wxCHECK_MSG( IS_VALID_PAGE(nPage
), false, wxT("notebook page out of range") );
516 tcItem
.mask
= TCIF_IMAGE
;
517 tcItem
.iImage
= nImage
;
519 return TabCtrl_SetItem(GetHwnd(), nPage
, &tcItem
) != 0;
522 void wxNotebook::SetImageList(wxImageList
* imageList
)
524 wxNotebookBase::SetImageList(imageList
);
528 (void) TabCtrl_SetImageList(GetHwnd(), (HIMAGELIST
)imageList
->GetHIMAGELIST());
532 // ----------------------------------------------------------------------------
533 // wxNotebook size settings
534 // ----------------------------------------------------------------------------
536 wxRect
wxNotebook::GetPageSize() const
541 ::GetClientRect(GetHwnd(), &rc
);
543 // This check is to work around a bug in TabCtrl_AdjustRect which will
544 // cause a crash on win2k or on XP with themes disabled if either
545 // wxNB_MULTILINE is used or tabs are placed on a side, if the rectangle
548 // The value of 20 is chosen arbitrarily but seems to work
549 if ( rc
.right
> 20 && rc
.bottom
> 20 )
551 TabCtrl_AdjustRect(GetHwnd(), false, &rc
);
553 wxCopyRECTToRect(rc
, r
);
559 void wxNotebook::SetPageSize(const wxSize
& size
)
561 // transform the page size into the notebook size
568 TabCtrl_AdjustRect(GetHwnd(), true, &rc
);
571 SetSize(rc
.right
- rc
.left
, rc
.bottom
- rc
.top
);
574 void wxNotebook::SetPadding(const wxSize
& padding
)
576 TabCtrl_SetPadding(GetHwnd(), padding
.x
, padding
.y
);
579 // Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH
581 void wxNotebook::SetTabSize(const wxSize
& sz
)
583 ::SendMessage(GetHwnd(), TCM_SETITEMSIZE
, 0, MAKELPARAM(sz
.x
, sz
.y
));
586 wxSize
wxNotebook::CalcSizeFromPage(const wxSize
& sizePage
) const
588 wxSize sizeTotal
= sizePage
;
590 // We need to make getting tab size part of the wxWidgets API.
592 if (GetPageCount() > 0)
595 TabCtrl_GetItemRect((HWND
) GetHWND(), 0, & rect
);
596 tabSize
.x
= rect
.right
- rect
.left
;
597 tabSize
.y
= rect
.bottom
- rect
.top
;
599 if ( HasFlag(wxBK_LEFT
) || HasFlag(wxBK_RIGHT
) )
601 sizeTotal
.x
+= tabSize
.x
+ 7;
607 sizeTotal
.y
+= tabSize
.y
+ 7;
613 void wxNotebook::AdjustPageSize(wxNotebookPage
*page
)
615 wxCHECK_RET( page
, _T("NULL page in wxNotebook::AdjustPageSize") );
617 const wxRect r
= GetPageSize();
624 // ----------------------------------------------------------------------------
625 // wxNotebook operations
626 // ----------------------------------------------------------------------------
628 // remove one page from the notebook, without deleting
629 wxNotebookPage
*wxNotebook::DoRemovePage(size_t nPage
)
631 wxNotebookPage
*pageRemoved
= wxNotebookBase::DoRemovePage(nPage
);
635 TabCtrl_DeleteItem(GetHwnd(), nPage
);
637 if ( m_pages
.IsEmpty() )
639 // no selection any more, the notebook becamse empty
642 else // notebook still not empty
644 int selNew
= TabCtrl_GetCurSel(GetHwnd());
647 // No selection change, just refresh the current selection.
648 // Because it could be that the slection index changed
649 // we need to update it.
650 // Note: this does not mean the selection it self changed.
651 m_nSelection
= selNew
;
652 m_pages
[m_nSelection
]->Refresh();
654 else if (int(nPage
) == m_nSelection
)
656 // The selection was deleted.
658 // Determine new selection.
659 if (m_nSelection
== int(GetPageCount()))
660 selNew
= m_nSelection
- 1;
662 selNew
= m_nSelection
;
664 // m_nSelection must be always valid so reset it before calling
667 SetSelection(selNew
);
671 wxFAIL
; // Windows did not behave ok.
679 bool wxNotebook::DeleteAllPages()
681 size_t nPageCount
= GetPageCount();
683 for ( nPage
= 0; nPage
< nPageCount
; nPage
++ )
684 delete m_pages
[nPage
];
688 TabCtrl_DeleteAllItems(GetHwnd());
692 InvalidateBestSize();
696 // same as AddPage() but does it at given position
697 bool wxNotebook::InsertPage(size_t nPage
,
698 wxNotebookPage
*pPage
,
699 const wxString
& strText
,
703 wxCHECK_MSG( pPage
!= NULL
, false, _T("NULL page in wxNotebook::InsertPage") );
704 wxCHECK_MSG( IS_VALID_PAGE(nPage
) || nPage
== GetPageCount(), false,
705 _T("invalid index in wxNotebook::InsertPage") );
707 wxASSERT_MSG( pPage
->GetParent() == this,
708 _T("notebook pages must have notebook as parent") );
710 // add a new tab to the control
711 // ----------------------------
713 // init all fields to 0
715 wxZeroMemory(tcItem
);
717 // set the image, if any
720 tcItem
.mask
|= TCIF_IMAGE
;
721 tcItem
.iImage
= imageId
;
725 if ( !strText
.empty() )
727 tcItem
.mask
|= TCIF_TEXT
;
728 tcItem
.pszText
= (wxChar
*)strText
.c_str(); // const_cast
731 // hide the page: unless it is selected, it shouldn't be shown (and if it
732 // is selected it will be shown later)
733 HWND hwnd
= GetWinHwnd(pPage
);
734 SetWindowLong(hwnd
, GWL_STYLE
, GetWindowLong(hwnd
, GWL_STYLE
) & ~WS_VISIBLE
);
736 // this updates internal flag too -- otherwise it would get out of sync
737 // with the real state
741 // fit the notebook page to the tab control's display area: this should be
742 // done before adding it to the notebook or TabCtrl_InsertItem() will
743 // change the notebooks size itself!
744 AdjustPageSize(pPage
);
746 // finally do insert it
747 if ( TabCtrl_InsertItem(GetHwnd(), nPage
, &tcItem
) == -1 )
749 wxLogError(wxT("Can't create the notebook page '%s'."), strText
.c_str());
754 // succeeded: save the pointer to the page
755 m_pages
.Insert(pPage
, nPage
);
757 // we may need to adjust the size again if the notebook size changed:
758 // normally this only happens for the first page we add (the tabs which
759 // hadn't been there before are now shown) but for a multiline notebook it
760 // can happen for any page at all as a new row could have been started
761 if ( m_pages
.GetCount() == 1 || HasFlag(wxNB_MULTILINE
) )
763 AdjustPageSize(pPage
);
766 // now deal with the selection
767 // ---------------------------
769 // if the inserted page is before the selected one, we must update the
770 // index of the selected page
771 if ( int(nPage
) <= m_nSelection
)
773 // one extra page added
777 // some page should be selected: either this one or the first one if there
778 // is still no selection
782 else if ( m_nSelection
== -1 )
786 SetSelection(selNew
);
788 InvalidateBestSize();
793 int wxNotebook::HitTest(const wxPoint
& pt
, long *flags
) const
795 TC_HITTESTINFO hitTestInfo
;
796 hitTestInfo
.pt
.x
= pt
.x
;
797 hitTestInfo
.pt
.y
= pt
.y
;
798 int item
= TabCtrl_HitTest(GetHwnd(), &hitTestInfo
);
804 if ((hitTestInfo
.flags
& TCHT_NOWHERE
) == TCHT_NOWHERE
)
805 *flags
|= wxNB_HITTEST_NOWHERE
;
806 if ((hitTestInfo
.flags
& TCHT_ONITEM
) == TCHT_ONITEM
)
807 *flags
|= wxNB_HITTEST_ONITEM
;
808 if ((hitTestInfo
.flags
& TCHT_ONITEMICON
) == TCHT_ONITEMICON
)
809 *flags
|= wxNB_HITTEST_ONICON
;
810 if ((hitTestInfo
.flags
& TCHT_ONITEMLABEL
) == TCHT_ONITEMLABEL
)
811 *flags
|= wxNB_HITTEST_ONLABEL
;
817 // ----------------------------------------------------------------------------
818 // flicker-less notebook redraw
819 // ----------------------------------------------------------------------------
821 #if USE_NOTEBOOK_ANTIFLICKER
823 // wnd proc for the spin button
824 LRESULT APIENTRY _EXPORT
wxNotebookSpinBtnWndProc(HWND hwnd
,
829 if ( message
== WM_ERASEBKGND
)
832 return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebookSpinBtn
,
833 hwnd
, message
, wParam
, lParam
);
836 LRESULT APIENTRY _EXPORT
wxNotebookWndProc(HWND hwnd
,
841 return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebook
,
842 hwnd
, message
, wParam
, lParam
);
845 void wxNotebook::OnEraseBackground(wxEraseEvent
& WXUNUSED(event
))
850 void wxNotebook::OnPaint(wxPaintEvent
& WXUNUSED(event
))
855 ::GetClientRect(GetHwnd(), &rc
);
856 wxBitmap
bmp(rc
.right
, rc
.bottom
);
857 memdc
.SelectObject(bmp
);
859 // if there is no special brush just use the solid background colour
861 HBRUSH hbr
= (HBRUSH
)m_hbrBackground
;
868 brush
= wxBrush(GetBackgroundColour());
869 hbr
= GetHbrushOf(brush
);
872 ::FillRect(GetHdcOf(memdc
), &rc
, hbr
);
874 MSWDefWindowProc(WM_PAINT
, (WPARAM
)memdc
.GetHDC(), 0);
876 dc
.Blit(0, 0, rc
.right
, rc
.bottom
, &memdc
, 0, 0);
879 #endif // USE_NOTEBOOK_ANTIFLICKER
881 // ----------------------------------------------------------------------------
882 // wxNotebook callbacks
883 // ----------------------------------------------------------------------------
885 void wxNotebook::OnSize(wxSizeEvent
& event
)
887 if ( GetPageCount() == 0 )
889 // Prevents droppings on resize, but does cause some flicker
890 // when there are no pages.
898 // Without this, we can sometimes get droppings at the edges
899 // of a notebook, for example a notebook in a splitter window.
900 // This needs to be reconciled with the RefreshRect calls
901 // at the end of this function, which weren't enough to prevent
904 wxSize sz
= GetClientSize();
906 // Refresh right side
907 wxRect
rect(sz
.x
-4, 0, 4, sz
.y
);
910 // Refresh bottom side
911 rect
= wxRect(0, sz
.y
-4, sz
.x
, 4);
915 rect
= wxRect(0, 0, 4, sz
.y
);
918 #endif // !__WXWINCE__
920 // fit all the notebook pages to the tab control's display area
923 rc
.left
= rc
.top
= 0;
924 GetSize((int *)&rc
.right
, (int *)&rc
.bottom
);
926 // save the total size, we'll use it below
927 int widthNbook
= rc
.right
- rc
.left
,
928 heightNbook
= rc
.bottom
- rc
.top
;
930 // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
931 // returns completely false values for multiline tab controls after the tabs
932 // are added but before getting the first WM_SIZE (off by ~50 pixels, see
934 // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
936 // and the only work around I could find was this ugly hack... without it
937 // simply toggling the "multiline" checkbox in the notebook sample resulted
938 // in a noticeable page displacement
939 if ( HasFlag(wxNB_MULTILINE
) )
941 // avoid an infinite recursion: we get another notification too!
942 static bool s_isInOnSize
= false;
947 SendMessage(GetHwnd(), WM_SIZE
, SIZE_RESTORED
,
948 MAKELPARAM(rc
.right
, rc
.bottom
));
949 s_isInOnSize
= false;
954 // background bitmap size has changed, update the brush using it too
956 #endif // wxUSE_UXTHEME
958 TabCtrl_AdjustRect(GetHwnd(), false, &rc
);
960 int width
= rc
.right
- rc
.left
,
961 height
= rc
.bottom
- rc
.top
;
962 size_t nCount
= m_pages
.Count();
963 for ( size_t nPage
= 0; nPage
< nCount
; nPage
++ ) {
964 wxNotebookPage
*pPage
= m_pages
[nPage
];
965 pPage
->SetSize(rc
.left
, rc
.top
, width
, height
);
969 // unless we had already repainted everything, we now need to refresh
970 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
972 // invalidate areas not covered by pages
973 RefreshRect(wxRect(0, 0, widthNbook
, rc
.top
), false);
974 RefreshRect(wxRect(0, rc
.top
, rc
.left
, height
), false);
975 RefreshRect(wxRect(0, rc
.bottom
, widthNbook
, heightNbook
- rc
.bottom
),
977 RefreshRect(wxRect(rc
.right
, rc
.top
, widthNbook
- rc
.right
, height
),
981 #if USE_NOTEBOOK_ANTIFLICKER
982 // subclass the spin control used by the notebook to scroll pages to
983 // prevent it from flickering on resize
984 if ( !m_hasSubclassedUpdown
)
986 // iterate over all child windows to find spin button
987 for ( HWND child
= ::GetWindow(GetHwnd(), GW_CHILD
);
989 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
991 wxWindow
*childWindow
= wxFindWinFromHandle((WXHWND
)child
);
993 // see if it exists, if no wxWindow found then assume it's the spin
997 // subclass the spin button to override WM_ERASEBKGND
998 if ( !gs_wndprocNotebookSpinBtn
)
999 gs_wndprocNotebookSpinBtn
= (WXFARPROC
)wxGetWindowProc(child
);
1001 wxSetWindowProc(child
, wxNotebookSpinBtnWndProc
);
1002 m_hasSubclassedUpdown
= true;
1007 #endif // USE_NOTEBOOK_ANTIFLICKER
1012 void wxNotebook::OnSelChange(wxNotebookEvent
& event
)
1014 // is it our tab control?
1015 if ( event
.GetEventObject() == this )
1017 int sel
= event
.GetOldSelection();
1019 m_pages
[sel
]->Show(false);
1021 sel
= event
.GetSelection();
1024 wxNotebookPage
*pPage
= m_pages
[sel
];
1028 // Changing the page should give the focus to it but, as per bug report
1029 // http://sf.net/tracker/index.php?func=detail&aid=1150659&group_id=9863&atid=109863,
1030 // we should not set the focus to it directly since it erroneously
1031 // selects radio buttons and breaks keyboard handling for a notebook's
1032 // scroll buttons. So give focus to the notebook and not the page.
1034 // but don't do this is the notebook is hidden
1035 if ( ::IsWindowVisible(GetHwnd()) )
1041 // we want to give others a chance to process this message as well
1045 bool wxNotebook::MSWTranslateMessage(WXMSG
*wxmsg
)
1047 const MSG
* const msg
= (MSG
*)wxmsg
;
1049 // intercept TAB, CTRL+TAB and CTRL+SHIFT+TAB for processing by wxNotebook.
1050 // TAB will be passed to the currently selected page, CTRL+TAB and
1051 // CTRL+SHIFT+TAB will be processed by the notebook itself. do not
1052 // intercept SHIFT+TAB. This goes to the parent of the notebook which will
1054 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_TAB
&&
1055 msg
->hwnd
== GetHwnd() &&
1056 (wxIsCtrlDown() || !wxIsShiftDown()) )
1058 return MSWProcessMessage(wxmsg
);
1064 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent
& event
)
1066 if ( event
.IsWindowChange() ) {
1068 AdvanceSelection(event
.GetDirection());
1071 // we get this event in 3 cases
1073 // a) one of our pages might have generated it because the user TABbed
1074 // out from it in which case we should propagate the event upwards and
1075 // our parent will take care of setting the focus to prev/next sibling
1079 // b) the parent panel wants to give the focus to us so that we
1080 // forward it to our selected page. We can't deal with this in
1081 // OnSetFocus() because we don't know which direction the focus came
1082 // from in this case and so can't choose between setting the focus to
1083 // first or last panel child
1087 // c) we ourselves (see MSWTranslateMessage) generated the event
1089 wxWindow
* const parent
= GetParent();
1091 // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
1092 const bool isFromParent
= event
.GetEventObject() == (wxObject
*) parent
;
1093 const bool isFromSelf
= event
.GetEventObject() == (wxObject
*) this;
1095 if ( isFromParent
|| isFromSelf
)
1097 // no, it doesn't come from child, case (b) or (c): forward to a
1098 // page but only if direction is backwards (TAB) or from ourselves,
1099 if ( m_nSelection
!= -1 &&
1100 (!event
.GetDirection() || isFromSelf
) )
1102 // so that the page knows that the event comes from it's parent
1103 // and is being propagated downwards
1104 event
.SetEventObject(this);
1106 wxWindow
*page
= m_pages
[m_nSelection
];
1107 if ( !page
->GetEventHandler()->ProcessEvent(event
) )
1111 //else: page manages focus inside it itself
1113 else // otherwise set the focus to the notebook itself
1120 // it comes from our child, case (a), pass to the parent, but only
1121 // if the direction is forwards. Otherwise set the focus to the
1122 // notebook itself. The notebook is always the 'first' control of a
1124 if ( !event
.GetDirection() )
1130 event
.SetCurrentFocus(this);
1131 parent
->GetEventHandler()->ProcessEvent(event
);
1139 bool wxNotebook::DoDrawBackground(WXHDC hDC
, wxWindow
*child
)
1141 wxUxThemeHandle
theme(child
? child
: this, L
"TAB");
1145 // get the notebook client rect (we're not interested in drawing tabs
1147 wxRect r
= GetPageSize();
1152 wxCopyRectToRECT(r
, rc
);
1154 // map rect to the coords of the window we're drawing in
1156 ::MapWindowPoints(GetHwnd(), GetHwndOf(child
), (POINT
*)&rc
, 2);
1158 // we have the content area (page size), but we need to draw all of the
1159 // background for it to be aligned correctly
1160 wxUxThemeEngine::Get()->GetThemeBackgroundExtent
1169 wxUxThemeEngine::Get()->DrawThemeBackground
1182 WXHBRUSH
wxNotebook::QueryBgBitmap()
1184 wxRect r
= GetPageSize();
1188 WindowHDC
hDC(GetHwnd());
1189 MemoryHDC
hDCMem(hDC
);
1190 CompatibleBitmap
hBmp(hDC
, r
.x
+ r
.width
, r
.y
+ r
.height
);
1192 SelectInHDC
selectBmp(hDCMem
, hBmp
);
1194 if ( !DoDrawBackground((WXHDC
)(HDC
)hDCMem
) )
1197 return (WXHBRUSH
)::CreatePatternBrush(hBmp
);
1200 void wxNotebook::UpdateBgBrush()
1202 if ( m_hbrBackground
)
1203 ::DeleteObject((HBRUSH
)m_hbrBackground
);
1205 if ( !m_hasBgCol
&& wxUxThemeEngine::GetIfActive() )
1207 m_hbrBackground
= QueryBgBitmap();
1209 else // no themes or we've got user-defined solid colour
1211 m_hbrBackground
= NULL
;
1215 WXHBRUSH
wxNotebook::MSWGetBgBrushForChild(WXHDC hDC
, WXHWND hWnd
)
1217 if ( m_hbrBackground
)
1219 // before drawing with the background brush, we need to position it
1222 ::GetWindowRect((HWND
)hWnd
, &rc
);
1224 ::MapWindowPoints(NULL
, GetHwnd(), (POINT
*)&rc
, 1);
1226 if ( !::SetBrushOrgEx((HDC
)hDC
, -rc
.left
, -rc
.top
, NULL
) )
1228 wxLogLastError(_T("SetBrushOrgEx(notebook bg brush)"));
1231 return m_hbrBackground
;
1234 return wxNotebookBase::MSWGetBgBrushForChild(hDC
, hWnd
);
1237 bool wxNotebook::MSWPrintChild(WXHDC hDC
, wxWindow
*child
)
1239 // solid background colour overrides themed background drawing
1240 if ( !UseBgCol() && DoDrawBackground(hDC
, child
) )
1243 // If we're using a solid colour (for example if we've switched off
1244 // theming for this notebook), paint it
1247 wxRect r
= GetPageSize();
1252 wxCopyRectToRECT(r
, rc
);
1254 // map rect to the coords of the window we're drawing in
1256 ::MapWindowPoints(GetHwnd(), GetHwndOf(child
), (POINT
*)&rc
, 2);
1258 wxBrush
brush(GetBackgroundColour());
1259 HBRUSH hbr
= GetHbrushOf(brush
);
1261 ::FillRect((HDC
) hDC
, &rc
, hbr
);
1266 return wxNotebookBase::MSWPrintChild(hDC
, child
);
1269 #endif // wxUSE_UXTHEME
1271 // Windows only: attempts to get colour for UX theme page background
1272 wxColour
wxNotebook::GetThemeBackgroundColour() const
1275 if (wxUxThemeEngine::Get())
1277 wxUxThemeHandle
hTheme((wxNotebook
*) this, L
"TAB");
1280 // This is total guesswork.
1281 // See PlatformSDK\Include\Tmschema.h for values
1282 COLORREF themeColor
;
1283 wxUxThemeEngine::Get()->GetThemeColor(
1287 3821 /* FILLCOLORHINT */,
1291 [DS] Workaround for WindowBlinds:
1292 Some themes return a near black theme color using FILLCOLORHINT,
1293 this makes notebook pages have an ugly black background and makes
1294 text (usually black) unreadable. Retry again with FILLCOLOR.
1296 This workaround potentially breaks appearance of some themes,
1297 but in practice it already fixes some themes.
1299 if (themeColor
== 1)
1301 wxUxThemeEngine::Get()->GetThemeColor(
1305 3802 /* FILLCOLOR */,
1309 return wxRGBToColour(themeColor
);
1312 #endif // wxUSE_UXTHEME
1314 return GetBackgroundColour();
1317 // ----------------------------------------------------------------------------
1318 // wxNotebook base class virtuals
1319 // ----------------------------------------------------------------------------
1321 #if wxUSE_CONSTRAINTS
1323 // override these 2 functions to do nothing: everything is done in OnSize
1325 void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse
))
1327 // don't set the sizes of the pages - their correct size is not yet known
1328 wxControl::SetConstraintSizes(false);
1331 bool wxNotebook::DoPhase(int WXUNUSED(nPhase
))
1336 #endif // wxUSE_CONSTRAINTS
1338 // ----------------------------------------------------------------------------
1339 // wxNotebook Windows message handlers
1340 // ----------------------------------------------------------------------------
1342 bool wxNotebook::MSWOnScroll(int orientation
, WXWORD nSBCode
,
1343 WXWORD pos
, WXHWND control
)
1345 // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the
1350 return wxNotebookBase::MSWOnScroll(orientation
, nSBCode
, pos
, control
);
1353 bool wxNotebook::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
* result
)
1355 wxNotebookEvent
event(wxEVT_NULL
, m_windowId
);
1357 NMHDR
* hdr
= (NMHDR
*)lParam
;
1358 switch ( hdr
->code
) {
1360 event
.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
);
1363 case TCN_SELCHANGING
:
1364 event
.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
);
1368 return wxControl::MSWOnNotify(idCtrl
, lParam
, result
);
1371 event
.SetSelection(TabCtrl_GetCurSel(GetHwnd()));
1372 event
.SetOldSelection(m_nSelection
);
1373 event
.SetEventObject(this);
1374 event
.SetInt(idCtrl
);
1376 bool processed
= GetEventHandler()->ProcessEvent(event
);
1377 *result
= !event
.IsAllowed();
1381 #endif // wxUSE_NOTEBOOK