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"
30 #include "wx/dcmemory.h"
31 #include "wx/control.h"
34 #include "wx/imaglist.h"
35 #include "wx/sysopt.h"
37 #include "wx/msw/private.h"
40 #include "wx/msw/winundef.h"
42 // include <commctrl.h> "properly"
43 #include "wx/msw/wrapcctl.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
)
271 if ( (style
& wxBK_ALIGN_MASK
) == wxBK_DEFAULT
)
273 #if defined(__POCKETPC__)
274 style
|= wxBK_BOTTOM
| wxNB_FLAT
;
281 // Not sure why, but without this style, there is no border
282 // around the notebook tabs.
283 if (style
& wxNB_FLAT
)
284 style
|= wxBORDER_SUNKEN
;
288 // ComCtl32 notebook tabs simply don't work unless they're on top if we have uxtheme, we can
289 // work around it later (after control creation), but if we don't have uxtheme, we have to clear
291 const int verComCtl32
= wxApp::GetComCtl32Version();
292 if ( verComCtl32
== 600 )
294 style
&= ~(wxBK_BOTTOM
| wxBK_LEFT
| wxBK_RIGHT
);
296 #endif //wxUSE_UXTHEME
298 LPCTSTR className
= WC_TABCONTROL
;
300 #if USE_NOTEBOOK_ANTIFLICKER
301 // SysTabCtl32 class has natively CS_HREDRAW and CS_VREDRAW enabled and it
302 // causes horrible flicker when resizing notebook, so get rid of it by
303 // using a class without these styles (but otherwise identical to it)
304 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
306 static ClassRegistrar s_clsNotebook
;
307 if ( !s_clsNotebook
.IsInitialized() )
309 // get a copy of standard class and modify it
312 if ( ::GetClassInfo(NULL
, WC_TABCONTROL
, &wc
) )
315 wx_reinterpret_cast(WXFARPROC
, wc
.lpfnWndProc
);
316 wc
.lpszClassName
= wxT("_wx_SysTabCtl32");
317 wc
.style
&= ~(CS_HREDRAW
| CS_VREDRAW
);
318 wc
.hInstance
= wxGetInstance();
319 wc
.lpfnWndProc
= wxNotebookWndProc
;
320 s_clsNotebook
.Register(wc
);
324 wxLogLastError(_T("GetClassInfoEx(SysTabCtl32)"));
328 // use our custom class if available but fall back to the standard
329 // notebook if we failed to register it
330 if ( s_clsNotebook
.IsRegistered() )
332 // it's ok to use c_str() here as the static s_clsNotebook object
333 // has sufficiently long lifetime
334 className
= s_clsNotebook
.GetName().c_str();
337 #endif // USE_NOTEBOOK_ANTIFLICKER
339 if ( !CreateControl(parent
, id
, pos
, size
, style
| wxTAB_TRAVERSAL
,
340 wxDefaultValidator
, name
) )
343 if ( !MSWCreateControl(className
, wxEmptyString
, pos
, size
) )
347 if ( HasFlag(wxNB_NOPAGETHEME
) ||
348 wxSystemOptions::IsFalse(wxT("msw.notebook.themed-background")) )
350 SetBackgroundColour(GetThemeBackgroundColour());
352 else // use themed background by default
354 // create backing store
358 // comctl32.dll 6.0 doesn't support non-top tabs with visual styles (the
359 // control is simply not rendered correctly), so we disable themes
360 // if possible, otherwise we simply clear the styles.
361 // It's probably not possible to have UXTHEME without ComCtl32 6 or better, but lets
363 const int verComCtl32
= wxApp::GetComCtl32Version();
364 if ( verComCtl32
== 600 )
366 // check if we use themes at all -- if we don't, we're still okay
367 if ( wxUxThemeEngine::GetIfActive() && (style
& (wxBK_BOTTOM
|wxBK_LEFT
|wxBK_RIGHT
)))
369 wxUxThemeEngine::GetIfActive()->SetWindowTheme((HWND
)this->GetHandle(), L
"", L
"");
370 SetBackgroundColour(GetThemeBackgroundColour()); //correct the background color for the new non-themed control
373 #endif // wxUSE_UXTHEME
375 // Undocumented hack to get flat notebook style
376 // In fact, we should probably only do this in some
377 // curcumstances, i.e. if we know we will have a border
378 // at the bottom (the tab control doesn't draw it itself)
379 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
380 if (HasFlag(wxNB_FLAT
))
382 SendMessage(GetHwnd(), CCM_SETVERSION
, COMCTL32_VERSION
, 0);
384 SetBackgroundColour(*wxWHITE
);
390 WXDWORD
wxNotebook::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
392 WXDWORD tabStyle
= wxControl::MSWGetStyle(style
, exstyle
);
394 tabStyle
|= WS_TABSTOP
| TCS_TABS
;
396 if ( style
& wxNB_MULTILINE
)
397 tabStyle
|= TCS_MULTILINE
;
398 if ( style
& wxNB_FIXEDWIDTH
)
399 tabStyle
|= TCS_FIXEDWIDTH
;
401 if ( style
& wxBK_BOTTOM
)
402 tabStyle
|= TCS_RIGHT
;
403 else if ( style
& wxBK_LEFT
)
404 tabStyle
|= TCS_VERTICAL
;
405 else if ( style
& wxBK_RIGHT
)
406 tabStyle
|= TCS_VERTICAL
| TCS_RIGHT
;
411 // note that we never want to have the default WS_EX_CLIENTEDGE style
412 // as it looks too ugly for the notebooks
419 wxNotebook::~wxNotebook()
422 if ( m_hbrBackground
)
423 ::DeleteObject((HBRUSH
)m_hbrBackground
);
424 #endif // wxUSE_UXTHEME
427 // ----------------------------------------------------------------------------
428 // wxNotebook accessors
429 // ----------------------------------------------------------------------------
431 size_t wxNotebook::GetPageCount() const
434 wxASSERT( (int)m_pages
.Count() == TabCtrl_GetItemCount(GetHwnd()) );
436 return m_pages
.Count();
439 int wxNotebook::GetRowCount() const
441 return TabCtrl_GetRowCount(GetHwnd());
444 int wxNotebook::SetSelection(size_t nPage
)
446 wxCHECK_MSG( IS_VALID_PAGE(nPage
), wxNOT_FOUND
, wxT("notebook page out of range") );
448 if ( int(nPage
) != m_nSelection
)
450 wxNotebookEvent
event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
, m_windowId
);
451 event
.SetSelection(nPage
);
452 event
.SetOldSelection(m_nSelection
);
453 event
.SetEventObject(this);
454 if ( !GetEventHandler()->ProcessEvent(event
) || event
.IsAllowed() )
456 // program allows the page change
457 event
.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
);
458 (void)GetEventHandler()->ProcessEvent(event
);
460 TabCtrl_SetCurSel(GetHwnd(), nPage
);
467 bool wxNotebook::SetPageText(size_t nPage
, const wxString
& strText
)
469 wxCHECK_MSG( IS_VALID_PAGE(nPage
), false, wxT("notebook page out of range") );
472 tcItem
.mask
= TCIF_TEXT
;
473 tcItem
.pszText
= (wxChar
*)strText
.c_str();
475 if ( !HasFlag(wxNB_MULTILINE
) )
476 return TabCtrl_SetItem(GetHwnd(), nPage
, &tcItem
) != 0;
478 // multiline - we need to set new page size if a line is added or removed
479 int rows
= GetRowCount();
480 bool ret
= TabCtrl_SetItem(GetHwnd(), nPage
, &tcItem
) != 0;
482 if ( ret
&& rows
!= GetRowCount() )
484 const wxRect r
= GetPageSize();
485 const size_t count
= m_pages
.Count();
486 for ( size_t page
= 0; page
< count
; page
++ )
487 m_pages
[page
]->SetSize(r
);
493 wxString
wxNotebook::GetPageText(size_t nPage
) const
495 wxCHECK_MSG( IS_VALID_PAGE(nPage
), wxEmptyString
, wxT("notebook page out of range") );
499 tcItem
.mask
= TCIF_TEXT
;
500 tcItem
.pszText
= buf
;
501 tcItem
.cchTextMax
= WXSIZEOF(buf
);
504 if ( TabCtrl_GetItem(GetHwnd(), nPage
, &tcItem
) )
505 str
= tcItem
.pszText
;
510 int wxNotebook::GetPageImage(size_t nPage
) const
512 wxCHECK_MSG( IS_VALID_PAGE(nPage
), wxNOT_FOUND
, wxT("notebook page out of range") );
515 tcItem
.mask
= TCIF_IMAGE
;
517 return TabCtrl_GetItem(GetHwnd(), nPage
, &tcItem
) ? tcItem
.iImage
: wxNOT_FOUND
;
520 bool wxNotebook::SetPageImage(size_t nPage
, int nImage
)
522 wxCHECK_MSG( IS_VALID_PAGE(nPage
), false, wxT("notebook page out of range") );
525 tcItem
.mask
= TCIF_IMAGE
;
526 tcItem
.iImage
= nImage
;
528 return TabCtrl_SetItem(GetHwnd(), nPage
, &tcItem
) != 0;
531 void wxNotebook::SetImageList(wxImageList
* imageList
)
533 wxNotebookBase::SetImageList(imageList
);
537 (void) TabCtrl_SetImageList(GetHwnd(), (HIMAGELIST
)imageList
->GetHIMAGELIST());
541 // ----------------------------------------------------------------------------
542 // wxNotebook size settings
543 // ----------------------------------------------------------------------------
545 wxRect
wxNotebook::GetPageSize() const
550 ::GetClientRect(GetHwnd(), &rc
);
552 // This check is to work around a bug in TabCtrl_AdjustRect which will
553 // cause a crash on win2k or on XP with themes disabled if either
554 // wxNB_MULTILINE is used or tabs are placed on a side, if the rectangle
557 // The value of 20 is chosen arbitrarily but seems to work
558 if ( rc
.right
> 20 && rc
.bottom
> 20 )
560 TabCtrl_AdjustRect(GetHwnd(), false, &rc
);
562 wxCopyRECTToRect(rc
, r
);
568 void wxNotebook::SetPageSize(const wxSize
& size
)
570 // transform the page size into the notebook size
577 TabCtrl_AdjustRect(GetHwnd(), true, &rc
);
580 SetSize(rc
.right
- rc
.left
, rc
.bottom
- rc
.top
);
583 void wxNotebook::SetPadding(const wxSize
& padding
)
585 TabCtrl_SetPadding(GetHwnd(), padding
.x
, padding
.y
);
588 // Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH
590 void wxNotebook::SetTabSize(const wxSize
& sz
)
592 ::SendMessage(GetHwnd(), TCM_SETITEMSIZE
, 0, MAKELPARAM(sz
.x
, sz
.y
));
595 wxSize
wxNotebook::CalcSizeFromPage(const wxSize
& sizePage
) const
597 wxSize sizeTotal
= sizePage
;
599 // We need to make getting tab size part of the wxWidgets API.
601 if (GetPageCount() > 0)
604 TabCtrl_GetItemRect((HWND
) GetHWND(), 0, & rect
);
605 tabSize
.x
= rect
.right
- rect
.left
;
606 tabSize
.y
= rect
.bottom
- rect
.top
;
608 if ( HasFlag(wxBK_LEFT
) || HasFlag(wxBK_RIGHT
) )
610 sizeTotal
.x
+= tabSize
.x
+ 7;
616 sizeTotal
.y
+= tabSize
.y
+ 7;
622 void wxNotebook::AdjustPageSize(wxNotebookPage
*page
)
624 wxCHECK_RET( page
, _T("NULL page in wxNotebook::AdjustPageSize") );
626 const wxRect r
= GetPageSize();
633 // ----------------------------------------------------------------------------
634 // wxNotebook operations
635 // ----------------------------------------------------------------------------
637 // remove one page from the notebook, without deleting
638 wxNotebookPage
*wxNotebook::DoRemovePage(size_t nPage
)
640 wxNotebookPage
*pageRemoved
= wxNotebookBase::DoRemovePage(nPage
);
644 TabCtrl_DeleteItem(GetHwnd(), nPage
);
646 if ( m_pages
.IsEmpty() )
648 // no selection any more, the notebook becamse empty
651 else // notebook still not empty
653 int selNew
= TabCtrl_GetCurSel(GetHwnd());
656 // No selection change, just refresh the current selection.
657 // Because it could be that the slection index changed
658 // we need to update it.
659 // Note: this does not mean the selection it self changed.
660 m_nSelection
= selNew
;
661 m_pages
[m_nSelection
]->Refresh();
663 else if (int(nPage
) == m_nSelection
)
665 // The selection was deleted.
667 // Determine new selection.
668 if (m_nSelection
== int(GetPageCount()))
669 selNew
= m_nSelection
- 1;
671 selNew
= m_nSelection
;
673 // m_nSelection must be always valid so reset it before calling
676 SetSelection(selNew
);
680 wxFAIL
; // Windows did not behave ok.
688 bool wxNotebook::DeleteAllPages()
690 size_t nPageCount
= GetPageCount();
692 for ( nPage
= 0; nPage
< nPageCount
; nPage
++ )
693 delete m_pages
[nPage
];
697 TabCtrl_DeleteAllItems(GetHwnd());
701 InvalidateBestSize();
705 // same as AddPage() but does it at given position
706 bool wxNotebook::InsertPage(size_t nPage
,
707 wxNotebookPage
*pPage
,
708 const wxString
& strText
,
712 wxCHECK_MSG( pPage
!= NULL
, false, _T("NULL page in wxNotebook::InsertPage") );
713 wxCHECK_MSG( IS_VALID_PAGE(nPage
) || nPage
== GetPageCount(), false,
714 _T("invalid index in wxNotebook::InsertPage") );
716 wxASSERT_MSG( pPage
->GetParent() == this,
717 _T("notebook pages must have notebook as parent") );
719 // add a new tab to the control
720 // ----------------------------
722 // init all fields to 0
724 wxZeroMemory(tcItem
);
726 // set the image, if any
729 tcItem
.mask
|= TCIF_IMAGE
;
730 tcItem
.iImage
= imageId
;
734 if ( !strText
.empty() )
736 tcItem
.mask
|= TCIF_TEXT
;
737 tcItem
.pszText
= (wxChar
*)strText
.c_str(); // const_cast
740 // hide the page: unless it is selected, it shouldn't be shown (and if it
741 // is selected it will be shown later)
742 HWND hwnd
= GetWinHwnd(pPage
);
743 SetWindowLong(hwnd
, GWL_STYLE
, GetWindowLong(hwnd
, GWL_STYLE
) & ~WS_VISIBLE
);
745 // this updates internal flag too -- otherwise it would get out of sync
746 // with the real state
750 // fit the notebook page to the tab control's display area: this should be
751 // done before adding it to the notebook or TabCtrl_InsertItem() will
752 // change the notebooks size itself!
753 AdjustPageSize(pPage
);
755 // finally do insert it
756 if ( TabCtrl_InsertItem(GetHwnd(), nPage
, &tcItem
) == -1 )
758 wxLogError(wxT("Can't create the notebook page '%s'."), strText
.c_str());
763 // succeeded: save the pointer to the page
764 m_pages
.Insert(pPage
, nPage
);
766 // we may need to adjust the size again if the notebook size changed:
767 // normally this only happens for the first page we add (the tabs which
768 // hadn't been there before are now shown) but for a multiline notebook it
769 // can happen for any page at all as a new row could have been started
770 if ( m_pages
.GetCount() == 1 || HasFlag(wxNB_MULTILINE
) )
772 AdjustPageSize(pPage
);
775 // now deal with the selection
776 // ---------------------------
778 // if the inserted page is before the selected one, we must update the
779 // index of the selected page
780 if ( int(nPage
) <= m_nSelection
)
782 // one extra page added
786 // some page should be selected: either this one or the first one if there
787 // is still no selection
791 else if ( m_nSelection
== -1 )
795 SetSelection(selNew
);
797 InvalidateBestSize();
802 int wxNotebook::HitTest(const wxPoint
& pt
, long *flags
) const
804 TC_HITTESTINFO hitTestInfo
;
805 hitTestInfo
.pt
.x
= pt
.x
;
806 hitTestInfo
.pt
.y
= pt
.y
;
807 int item
= TabCtrl_HitTest(GetHwnd(), &hitTestInfo
);
813 if ((hitTestInfo
.flags
& TCHT_NOWHERE
) == TCHT_NOWHERE
)
814 *flags
|= wxNB_HITTEST_NOWHERE
;
815 if ((hitTestInfo
.flags
& TCHT_ONITEM
) == TCHT_ONITEM
)
816 *flags
|= wxNB_HITTEST_ONITEM
;
817 if ((hitTestInfo
.flags
& TCHT_ONITEMICON
) == TCHT_ONITEMICON
)
818 *flags
|= wxNB_HITTEST_ONICON
;
819 if ((hitTestInfo
.flags
& TCHT_ONITEMLABEL
) == TCHT_ONITEMLABEL
)
820 *flags
|= wxNB_HITTEST_ONLABEL
;
826 // ----------------------------------------------------------------------------
827 // flicker-less notebook redraw
828 // ----------------------------------------------------------------------------
830 #if USE_NOTEBOOK_ANTIFLICKER
832 // wnd proc for the spin button
833 LRESULT APIENTRY _EXPORT
wxNotebookSpinBtnWndProc(HWND hwnd
,
838 if ( message
== WM_ERASEBKGND
)
841 return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebookSpinBtn
,
842 hwnd
, message
, wParam
, lParam
);
845 LRESULT APIENTRY _EXPORT
wxNotebookWndProc(HWND hwnd
,
850 return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebook
,
851 hwnd
, message
, wParam
, lParam
);
854 void wxNotebook::OnEraseBackground(wxEraseEvent
& WXUNUSED(event
))
859 void wxNotebook::OnPaint(wxPaintEvent
& WXUNUSED(event
))
864 ::GetClientRect(GetHwnd(), &rc
);
865 wxBitmap
bmp(rc
.right
, rc
.bottom
);
866 memdc
.SelectObject(bmp
);
868 // if there is no special brush just use the solid background colour
870 HBRUSH hbr
= (HBRUSH
)m_hbrBackground
;
877 brush
= wxBrush(GetBackgroundColour());
878 hbr
= GetHbrushOf(brush
);
881 ::FillRect(GetHdcOf(memdc
), &rc
, hbr
);
883 MSWDefWindowProc(WM_PAINT
, (WPARAM
)memdc
.GetHDC(), 0);
885 dc
.Blit(0, 0, rc
.right
, rc
.bottom
, &memdc
, 0, 0);
888 #endif // USE_NOTEBOOK_ANTIFLICKER
890 // ----------------------------------------------------------------------------
891 // wxNotebook callbacks
892 // ----------------------------------------------------------------------------
894 void wxNotebook::OnSize(wxSizeEvent
& event
)
896 if ( GetPageCount() == 0 )
898 // Prevents droppings on resize, but does cause some flicker
899 // when there are no pages.
907 // Without this, we can sometimes get droppings at the edges
908 // of a notebook, for example a notebook in a splitter window.
909 // This needs to be reconciled with the RefreshRect calls
910 // at the end of this function, which weren't enough to prevent
913 wxSize sz
= GetClientSize();
915 // Refresh right side
916 wxRect
rect(sz
.x
-4, 0, 4, sz
.y
);
919 // Refresh bottom side
920 rect
= wxRect(0, sz
.y
-4, sz
.x
, 4);
924 rect
= wxRect(0, 0, 4, sz
.y
);
927 #endif // !__WXWINCE__
929 // fit all the notebook pages to the tab control's display area
932 rc
.left
= rc
.top
= 0;
933 GetSize((int *)&rc
.right
, (int *)&rc
.bottom
);
935 // save the total size, we'll use it below
936 int widthNbook
= rc
.right
- rc
.left
,
937 heightNbook
= rc
.bottom
- rc
.top
;
939 // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
940 // returns completely false values for multiline tab controls after the tabs
941 // are added but before getting the first WM_SIZE (off by ~50 pixels, see
943 // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
945 // and the only work around I could find was this ugly hack... without it
946 // simply toggling the "multiline" checkbox in the notebook sample resulted
947 // in a noticeable page displacement
948 if ( HasFlag(wxNB_MULTILINE
) )
950 // avoid an infinite recursion: we get another notification too!
951 static bool s_isInOnSize
= false;
956 SendMessage(GetHwnd(), WM_SIZE
, SIZE_RESTORED
,
957 MAKELPARAM(rc
.right
, rc
.bottom
));
958 s_isInOnSize
= false;
963 // background bitmap size has changed, update the brush using it too
965 #endif // wxUSE_UXTHEME
967 TabCtrl_AdjustRect(GetHwnd(), false, &rc
);
969 int width
= rc
.right
- rc
.left
,
970 height
= rc
.bottom
- rc
.top
;
971 size_t nCount
= m_pages
.Count();
972 for ( size_t nPage
= 0; nPage
< nCount
; nPage
++ ) {
973 wxNotebookPage
*pPage
= m_pages
[nPage
];
974 pPage
->SetSize(rc
.left
, rc
.top
, width
, height
);
978 // unless we had already repainted everything, we now need to refresh
979 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE
) )
981 // invalidate areas not covered by pages
982 RefreshRect(wxRect(0, 0, widthNbook
, rc
.top
), false);
983 RefreshRect(wxRect(0, rc
.top
, rc
.left
, height
), false);
984 RefreshRect(wxRect(0, rc
.bottom
, widthNbook
, heightNbook
- rc
.bottom
),
986 RefreshRect(wxRect(rc
.right
, rc
.top
, widthNbook
- rc
.right
, height
),
990 #if USE_NOTEBOOK_ANTIFLICKER
991 // subclass the spin control used by the notebook to scroll pages to
992 // prevent it from flickering on resize
993 if ( !m_hasSubclassedUpdown
)
995 // iterate over all child windows to find spin button
996 for ( HWND child
= ::GetWindow(GetHwnd(), GW_CHILD
);
998 child
= ::GetWindow(child
, GW_HWNDNEXT
) )
1000 wxWindow
*childWindow
= wxFindWinFromHandle((WXHWND
)child
);
1002 // see if it exists, if no wxWindow found then assume it's the spin
1006 // subclass the spin button to override WM_ERASEBKGND
1007 if ( !gs_wndprocNotebookSpinBtn
)
1008 gs_wndprocNotebookSpinBtn
= (WXFARPROC
)wxGetWindowProc(child
);
1010 wxSetWindowProc(child
, wxNotebookSpinBtnWndProc
);
1011 m_hasSubclassedUpdown
= true;
1016 #endif // USE_NOTEBOOK_ANTIFLICKER
1021 void wxNotebook::OnSelChange(wxNotebookEvent
& event
)
1023 // is it our tab control?
1024 if ( event
.GetEventObject() == this )
1026 int sel
= event
.GetOldSelection();
1028 m_pages
[sel
]->Show(false);
1030 sel
= event
.GetSelection();
1033 wxNotebookPage
*pPage
= m_pages
[sel
];
1037 // Changing the page should give the focus to it but, as per bug report
1038 // http://sf.net/tracker/index.php?func=detail&aid=1150659&group_id=9863&atid=109863,
1039 // we should not set the focus to it directly since it erroneously
1040 // selects radio buttons and breaks keyboard handling for a notebook's
1041 // scroll buttons. So give focus to the notebook and not the page.
1043 // but don't do this is the notebook is hidden
1044 if ( ::IsWindowVisible(GetHwnd()) )
1050 // we want to give others a chance to process this message as well
1054 bool wxNotebook::MSWTranslateMessage(WXMSG
*wxmsg
)
1056 const MSG
* const msg
= (MSG
*)wxmsg
;
1058 // intercept TAB, CTRL+TAB and CTRL+SHIFT+TAB for processing by wxNotebook.
1059 // TAB will be passed to the currently selected page, CTRL+TAB and
1060 // CTRL+SHIFT+TAB will be processed by the notebook itself. do not
1061 // intercept SHIFT+TAB. This goes to the parent of the notebook which will
1063 if ( msg
->message
== WM_KEYDOWN
&& msg
->wParam
== VK_TAB
&&
1064 msg
->hwnd
== GetHwnd() &&
1065 (wxIsCtrlDown() || !wxIsShiftDown()) )
1067 return MSWProcessMessage(wxmsg
);
1073 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent
& event
)
1075 if ( event
.IsWindowChange() ) {
1077 AdvanceSelection(event
.GetDirection());
1080 // we get this event in 3 cases
1082 // a) one of our pages might have generated it because the user TABbed
1083 // out from it in which case we should propagate the event upwards and
1084 // our parent will take care of setting the focus to prev/next sibling
1088 // b) the parent panel wants to give the focus to us so that we
1089 // forward it to our selected page. We can't deal with this in
1090 // OnSetFocus() because we don't know which direction the focus came
1091 // from in this case and so can't choose between setting the focus to
1092 // first or last panel child
1096 // c) we ourselves (see MSWTranslateMessage) generated the event
1098 wxWindow
* const parent
= GetParent();
1100 // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
1101 const bool isFromParent
= event
.GetEventObject() == (wxObject
*) parent
;
1102 const bool isFromSelf
= event
.GetEventObject() == (wxObject
*) this;
1104 if ( isFromParent
|| isFromSelf
)
1106 // no, it doesn't come from child, case (b) or (c): forward to a
1107 // page but only if direction is backwards (TAB) or from ourselves,
1108 if ( m_nSelection
!= -1 &&
1109 (!event
.GetDirection() || isFromSelf
) )
1111 // so that the page knows that the event comes from it's parent
1112 // and is being propagated downwards
1113 event
.SetEventObject(this);
1115 wxWindow
*page
= m_pages
[m_nSelection
];
1116 if ( !page
->GetEventHandler()->ProcessEvent(event
) )
1120 //else: page manages focus inside it itself
1122 else // otherwise set the focus to the notebook itself
1129 // it comes from our child, case (a), pass to the parent, but only
1130 // if the direction is forwards. Otherwise set the focus to the
1131 // notebook itself. The notebook is always the 'first' control of a
1133 if ( !event
.GetDirection() )
1139 event
.SetCurrentFocus(this);
1140 parent
->GetEventHandler()->ProcessEvent(event
);
1148 bool wxNotebook::DoDrawBackground(WXHDC hDC
, wxWindow
*child
)
1150 wxUxThemeHandle
theme(child
? child
: this, L
"TAB");
1154 // get the notebook client rect (we're not interested in drawing tabs
1156 wxRect r
= GetPageSize();
1161 wxCopyRectToRECT(r
, rc
);
1163 // map rect to the coords of the window we're drawing in
1165 ::MapWindowPoints(GetHwnd(), GetHwndOf(child
), (POINT
*)&rc
, 2);
1167 // we have the content area (page size), but we need to draw all of the
1168 // background for it to be aligned correctly
1169 wxUxThemeEngine::Get()->GetThemeBackgroundExtent
1178 wxUxThemeEngine::Get()->DrawThemeBackground
1191 WXHBRUSH
wxNotebook::QueryBgBitmap()
1193 wxRect r
= GetPageSize();
1197 WindowHDC
hDC(GetHwnd());
1198 MemoryHDC
hDCMem(hDC
);
1199 CompatibleBitmap
hBmp(hDC
, r
.x
+ r
.width
, r
.y
+ r
.height
);
1201 SelectInHDC
selectBmp(hDCMem
, hBmp
);
1203 if ( !DoDrawBackground((WXHDC
)(HDC
)hDCMem
) )
1206 return (WXHBRUSH
)::CreatePatternBrush(hBmp
);
1209 void wxNotebook::UpdateBgBrush()
1211 if ( m_hbrBackground
)
1212 ::DeleteObject((HBRUSH
)m_hbrBackground
);
1214 if ( !m_hasBgCol
&& wxUxThemeEngine::GetIfActive() )
1216 m_hbrBackground
= QueryBgBitmap();
1218 else // no themes or we've got user-defined solid colour
1220 m_hbrBackground
= NULL
;
1224 WXHBRUSH
wxNotebook::MSWGetBgBrushForChild(WXHDC hDC
, WXHWND hWnd
)
1226 if ( m_hbrBackground
)
1228 // before drawing with the background brush, we need to position it
1231 ::GetWindowRect((HWND
)hWnd
, &rc
);
1233 ::MapWindowPoints(NULL
, GetHwnd(), (POINT
*)&rc
, 1);
1235 if ( !::SetBrushOrgEx((HDC
)hDC
, -rc
.left
, -rc
.top
, NULL
) )
1237 wxLogLastError(_T("SetBrushOrgEx(notebook bg brush)"));
1240 return m_hbrBackground
;
1243 return wxNotebookBase::MSWGetBgBrushForChild(hDC
, hWnd
);
1246 bool wxNotebook::MSWPrintChild(WXHDC hDC
, wxWindow
*child
)
1248 // solid background colour overrides themed background drawing
1249 if ( !UseBgCol() && DoDrawBackground(hDC
, child
) )
1252 // If we're using a solid colour (for example if we've switched off
1253 // theming for this notebook), paint it
1256 wxRect r
= GetPageSize();
1261 wxCopyRectToRECT(r
, rc
);
1263 // map rect to the coords of the window we're drawing in
1265 ::MapWindowPoints(GetHwnd(), GetHwndOf(child
), (POINT
*)&rc
, 2);
1267 wxBrush
brush(GetBackgroundColour());
1268 HBRUSH hbr
= GetHbrushOf(brush
);
1270 ::FillRect((HDC
) hDC
, &rc
, hbr
);
1275 return wxNotebookBase::MSWPrintChild(hDC
, child
);
1278 #endif // wxUSE_UXTHEME
1280 // Windows only: attempts to get colour for UX theme page background
1281 wxColour
wxNotebook::GetThemeBackgroundColour() const
1284 if (wxUxThemeEngine::Get())
1286 wxUxThemeHandle
hTheme((wxNotebook
*) this, L
"TAB");
1289 // This is total guesswork.
1290 // See PlatformSDK\Include\Tmschema.h for values
1291 COLORREF themeColor
;
1292 wxUxThemeEngine::Get()->GetThemeColor(
1296 3821 /* FILLCOLORHINT */,
1300 [DS] Workaround for WindowBlinds:
1301 Some themes return a near black theme color using FILLCOLORHINT,
1302 this makes notebook pages have an ugly black background and makes
1303 text (usually black) unreadable. Retry again with FILLCOLOR.
1305 This workaround potentially breaks appearance of some themes,
1306 but in practice it already fixes some themes.
1308 if (themeColor
== 1)
1310 wxUxThemeEngine::Get()->GetThemeColor(
1314 3802 /* FILLCOLOR */,
1318 return wxRGBToColour(themeColor
);
1321 #endif // wxUSE_UXTHEME
1323 return GetBackgroundColour();
1326 // ----------------------------------------------------------------------------
1327 // wxNotebook base class virtuals
1328 // ----------------------------------------------------------------------------
1330 #if wxUSE_CONSTRAINTS
1332 // override these 2 functions to do nothing: everything is done in OnSize
1334 void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse
))
1336 // don't set the sizes of the pages - their correct size is not yet known
1337 wxControl::SetConstraintSizes(false);
1340 bool wxNotebook::DoPhase(int WXUNUSED(nPhase
))
1345 #endif // wxUSE_CONSTRAINTS
1347 // ----------------------------------------------------------------------------
1348 // wxNotebook Windows message handlers
1349 // ----------------------------------------------------------------------------
1351 bool wxNotebook::MSWOnScroll(int orientation
, WXWORD nSBCode
,
1352 WXWORD pos
, WXHWND control
)
1354 // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the
1359 return wxNotebookBase::MSWOnScroll(orientation
, nSBCode
, pos
, control
);
1362 bool wxNotebook::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
* result
)
1364 wxNotebookEvent
event(wxEVT_NULL
, m_windowId
);
1366 NMHDR
* hdr
= (NMHDR
*)lParam
;
1367 switch ( hdr
->code
) {
1369 event
.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
);
1372 case TCN_SELCHANGING
:
1373 event
.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
);
1377 return wxControl::MSWOnNotify(idCtrl
, lParam
, result
);
1380 event
.SetSelection(TabCtrl_GetCurSel(GetHwnd()));
1381 event
.SetOldSelection(m_nSelection
);
1382 event
.SetEventObject(this);
1383 event
.SetInt(idCtrl
);
1385 bool processed
= GetEventHandler()->ProcessEvent(event
);
1386 *result
= !event
.IsAllowed();
1390 #endif // wxUSE_NOTEBOOK