]> git.saurik.com Git - wxWidgets.git/blob - src/msw/notebook.cpp
projects / wxWidgets.git / blob
? search:


7bab57b95907308aeb4c0298f076d3c592b6a571
[wxWidgets.git] / src / msw / notebook.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/notebook.cpp
3 // Purpose: implementation of wxNotebook
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 11.06.98
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx.h".
13 #include "wx/wxprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #if wxUSE_NOTEBOOK
20
21 #include "wx/notebook.h"
22
23 #ifndef WX_PRECOMP
24 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
25 #include "wx/string.h"
26 #include "wx/dc.h"
27 #include "wx/log.h"
28 #include "wx/event.h"
29 #include "wx/app.h"
30 #include "wx/dcclient.h"
31 #include "wx/dcmemory.h"
32 #include "wx/control.h"
33 #endif // WX_PRECOMP
34
35 #include "wx/imaglist.h"
36 #include "wx/sysopt.h"
37
38 #include "wx/msw/private.h"
39
40 #include <windowsx.h>
41 #include "wx/msw/winundef.h"
42
43 #if wxUSE_UXTHEME
44 #include "wx/msw/uxtheme.h"
45 #endif
46
47 // ----------------------------------------------------------------------------
48 // macros
49 // ----------------------------------------------------------------------------
50
51 // check that the page index is valid
52 #define IS_VALID_PAGE(nPage) ((nPage) < GetPageCount())
53
54 // you can set USE_NOTEBOOK_ANTIFLICKER to 0 for desktop Windows versions too
55 // to disable code whih results in flicker-less notebook redrawing at the
56 // expense of some extra GDI resource consumption
57 #ifdef __WXWINCE__
58 // notebooks are never resized under CE anyhow
59 #define USE_NOTEBOOK_ANTIFLICKER 0
60 #else
61 #define USE_NOTEBOOK_ANTIFLICKER 1
62 #endif
63
64 // ----------------------------------------------------------------------------
65 // constants
66 // ----------------------------------------------------------------------------
67
68 // This is a work-around for missing defines in gcc-2.95 headers
69 #ifndef TCS_RIGHT
70 #define TCS_RIGHT 0x0002
71 #endif
72
73 #ifndef TCS_VERTICAL
74 #define TCS_VERTICAL 0x0080
75 #endif
76
77 #ifndef TCS_BOTTOM
78 #define TCS_BOTTOM TCS_RIGHT
79 #endif
80
81 // ----------------------------------------------------------------------------
82 // global variables
83 // ----------------------------------------------------------------------------
84
85 #if USE_NOTEBOOK_ANTIFLICKER
86
87 // the pointer to standard spin button wnd proc
88 static WXFARPROC gs_wndprocNotebookSpinBtn = (WXFARPROC)NULL;
89
90 // the pointer to standard tab control wnd proc
91 static WXFARPROC gs_wndprocNotebook = (WXFARPROC)NULL;
92
93 LRESULT APIENTRY _EXPORT wxNotebookWndProc(HWND hwnd,
94 UINT message,
95 WPARAM wParam,
96 LPARAM lParam);
97
98 #endif // USE_NOTEBOOK_ANTIFLICKER
99
100 // ----------------------------------------------------------------------------
101 // event table
102 // ----------------------------------------------------------------------------
103
104 #include "wx/listimpl.cpp"
105
106 WX_DEFINE_LIST( wxNotebookPageInfoList )
107
108 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
109 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
110
111 BEGIN_EVENT_TABLE(wxNotebook, wxControl)
112 EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY, wxNotebook::OnSelChange)
113 EVT_SIZE(wxNotebook::OnSize)
114 EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
115
116 #if USE_NOTEBOOK_ANTIFLICKER
117 EVT_ERASE_BACKGROUND(wxNotebook::OnEraseBackground)
118 EVT_PAINT(wxNotebook::OnPaint)
119 #endif // USE_NOTEBOOK_ANTIFLICKER
120 END_EVENT_TABLE()
121
122 #if wxUSE_EXTENDED_RTTI
123 WX_DEFINE_FLAGS( wxNotebookStyle )
124
125 wxBEGIN_FLAGS( wxNotebookStyle )
126 // new style border flags, we put them first to
127 // use them for streaming out
128 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
129 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
130 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
131 wxFLAGS_MEMBER(wxBORDER_RAISED)
132 wxFLAGS_MEMBER(wxBORDER_STATIC)
133 wxFLAGS_MEMBER(wxBORDER_NONE)
134
135 // old style border flags
136 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
137 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
138 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
139 wxFLAGS_MEMBER(wxRAISED_BORDER)
140 wxFLAGS_MEMBER(wxSTATIC_BORDER)
141 wxFLAGS_MEMBER(wxBORDER)
142
143 // standard window styles
144 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
145 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
146 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
147 wxFLAGS_MEMBER(wxWANTS_CHARS)
148 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
149 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
150 wxFLAGS_MEMBER(wxVSCROLL)
151 wxFLAGS_MEMBER(wxHSCROLL)
152
153 wxFLAGS_MEMBER(wxNB_FIXEDWIDTH)
154 wxFLAGS_MEMBER(wxBK_DEFAULT)
155 wxFLAGS_MEMBER(wxBK_TOP)
156 wxFLAGS_MEMBER(wxBK_LEFT)
157 wxFLAGS_MEMBER(wxBK_RIGHT)
158 wxFLAGS_MEMBER(wxBK_BOTTOM)
159 wxFLAGS_MEMBER(wxNB_NOPAGETHEME)
160 wxFLAGS_MEMBER(wxNB_FLAT)
161
162 wxEND_FLAGS( wxNotebookStyle )
163
164 IMPLEMENT_DYNAMIC_CLASS_XTI(wxNotebook, wxControl,"wx/notebook.h")
165 IMPLEMENT_DYNAMIC_CLASS_XTI(wxNotebookPageInfo, wxObject , "wx/notebook.h" )
166
167 wxCOLLECTION_TYPE_INFO( wxNotebookPageInfo * , wxNotebookPageInfoList ) ;
168
169 template<> void wxCollectionToVariantArray( wxNotebookPageInfoList const &theList, wxxVariantArray &value)
170 {
171 wxListCollectionToVariantArray<wxNotebookPageInfoList::compatibility_iterator>( theList , value ) ;
172 }
173
174 wxBEGIN_PROPERTIES_TABLE(wxNotebook)
175 wxEVENT_PROPERTY( PageChanging , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING , wxNotebookEvent )
176 wxEVENT_PROPERTY( PageChanged , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED , wxNotebookEvent )
177
178 wxPROPERTY_COLLECTION( PageInfos , wxNotebookPageInfoList , wxNotebookPageInfo* , AddPageInfo , GetPageInfos , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
179 wxPROPERTY_FLAGS( WindowStyle , wxNotebookStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
180 wxEND_PROPERTIES_TABLE()
181
182 wxBEGIN_HANDLERS_TABLE(wxNotebook)
183 wxEND_HANDLERS_TABLE()
184
185 wxCONSTRUCTOR_5( wxNotebook , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle)
186
187
188 wxBEGIN_PROPERTIES_TABLE(wxNotebookPageInfo)
189 wxREADONLY_PROPERTY( Page , wxNotebookPage* , GetPage , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
190 wxREADONLY_PROPERTY( Text , wxString , GetText , wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
191 wxREADONLY_PROPERTY( Selected , bool , GetSelected , false, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
192 wxREADONLY_PROPERTY( ImageId , int , GetImageId , -1 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
193 wxEND_PROPERTIES_TABLE()
194
195 wxBEGIN_HANDLERS_TABLE(wxNotebookPageInfo)
196 wxEND_HANDLERS_TABLE()
197
198 wxCONSTRUCTOR_4( wxNotebookPageInfo , wxNotebookPage* , Page , wxString , Text , bool , Selected , int , ImageId )
199
200 #else
201 IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
202 IMPLEMENT_DYNAMIC_CLASS(wxNotebookPageInfo, wxObject )
203 #endif
204 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent)
205
206 // ============================================================================
207 // implementation
208 // ============================================================================
209
210 // ----------------------------------------------------------------------------
211 // wxNotebook construction
212 // ----------------------------------------------------------------------------
213
214 const wxNotebookPageInfoList& wxNotebook::GetPageInfos() const
215 {
216 wxNotebookPageInfoList* list = const_cast< wxNotebookPageInfoList* >( &m_pageInfos ) ;
217 WX_CLEAR_LIST( wxNotebookPageInfoList , *list ) ;
218 for( size_t i = 0 ; i < GetPageCount() ; ++i )
219 {
220 wxNotebookPageInfo *info = new wxNotebookPageInfo() ;
221 info->Create( const_cast<wxNotebook*>(this)->GetPage(i) , GetPageText(i) , GetSelection() == int(i) , GetPageImage(i) ) ;
222 list->Append( info ) ;
223 }
224 return m_pageInfos ;
225 }
226
227 // common part of all ctors
228 void wxNotebook::Init()
229 {
230 m_imageList = NULL;
231 m_nSelection = -1;
232
233 #if wxUSE_UXTHEME
234 m_hbrBackground = NULL;
235 #endif // wxUSE_UXTHEME
236
237 #if USE_NOTEBOOK_ANTIFLICKER
238 m_hasSubclassedUpdown = false;
239 #endif // USE_NOTEBOOK_ANTIFLICKER
240 }
241
242 // default for dynamic class
243 wxNotebook::wxNotebook()
244 {
245 Init();
246 }
247
248 // the same arguments as for wxControl
249 wxNotebook::wxNotebook(wxWindow *parent,
250 wxWindowID id,
251 const wxPoint& pos,
252 const wxSize& size,
253 long style,
254 const wxString& name)
255 {
256 Init();
257
258 Create(parent, id, pos, size, style, name);
259 }
260
261 // Create() function
262 bool wxNotebook::Create(wxWindow *parent,
263 wxWindowID id,
264 const wxPoint& pos,
265 const wxSize& size,
266 long style,
267 const wxString& name)
268 {
269 if ( (style & wxBK_ALIGN_MASK) == wxBK_DEFAULT )
270 {
271 #if defined(__POCKETPC__)
272 style |= wxBK_BOTTOM | wxNB_FLAT;
273 #else
274 style |= wxBK_TOP;
275 #endif
276 }
277
278 #ifdef __WXWINCE__
279 // Not sure why, but without this style, there is no border
280 // around the notebook tabs.
281 if (style & wxNB_FLAT)
282 style |= wxBORDER_SUNKEN;
283 #endif
284
285 #if !wxUSE_UXTHEME
286 // ComCtl32 notebook tabs simply don't work unless they're on top if we have uxtheme, we can
287 // work around it later (after control creation), but if we don't have uxtheme, we have to clear
288 // those styles
289 const int verComCtl32 = wxApp::GetComCtl32Version();
290 if ( verComCtl32 == 600 )
291 {
292 style &= ~(wxBK_BOTTOM | wxBK_LEFT | wxBK_RIGHT);
293 }
294 #endif //wxUSE_UXTHEME
295
296 LPCTSTR className = WC_TABCONTROL;
297
298 #if USE_NOTEBOOK_ANTIFLICKER
299 // SysTabCtl32 class has natively CS_HREDRAW and CS_VREDRAW enabled and it
300 // causes horrible flicker when resizing notebook, so get rid of it by
301 // using a class without these styles (but otherwise identical to it)
302 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
303 {
304 static ClassRegistrar s_clsNotebook;
305 if ( !s_clsNotebook.IsInitialized() )
306 {
307 // get a copy of standard class and modify it
308 WNDCLASS wc;
309
310 if ( ::GetClassInfo(NULL, WC_TABCONTROL, &wc) )
311 {
312 gs_wndprocNotebook =
313 wx_reinterpret_cast(WXFARPROC, wc.lpfnWndProc);
314 wc.lpszClassName = wxT("_wx_SysTabCtl32");
315 wc.style &= ~(CS_HREDRAW | CS_VREDRAW);
316 wc.hInstance = wxGetInstance();
317 wc.lpfnWndProc = wxNotebookWndProc;
318 s_clsNotebook.Register(wc);
319 }
320 else
321 {
322 wxLogLastError(_T("GetClassInfoEx(SysTabCtl32)"));
323 }
324 }
325
326 // use our custom class if available but fall back to the standard
327 // notebook if we failed to register it
328 if ( s_clsNotebook.IsRegistered() )
329 {
330 // it's ok to use c_str() here as the static s_clsNotebook object
331 // has sufficiently long lifetime
332 className = s_clsNotebook.GetName().c_str();
333 }
334 }
335 #endif // USE_NOTEBOOK_ANTIFLICKER
336
337 if ( !CreateControl(parent, id, pos, size, style | wxTAB_TRAVERSAL,
338 wxDefaultValidator, name) )
339 return false;
340
341 if ( !MSWCreateControl(className, wxEmptyString, pos, size) )
342 return false;
343
344 #if wxUSE_UXTHEME
345 if ( HasFlag(wxNB_NOPAGETHEME) ||
346 wxSystemOptions::IsFalse(wxT("msw.notebook.themed-background")) )
347 {
348 SetBackgroundColour(GetThemeBackgroundColour());
349 }
350 else // use themed background by default
351 {
352 // create backing store
353 UpdateBgBrush();
354 }
355
356 // comctl32.dll 6.0 doesn't support non-top tabs with visual styles (the
357 // control is simply not rendered correctly), so we disable themes
358 // if possible, otherwise we simply clear the styles.
359 // It's probably not possible to have UXTHEME without ComCtl32 6 or better, but lets
360 // check it anyway.
361 const int verComCtl32 = wxApp::GetComCtl32Version();
362 if ( verComCtl32 == 600 )
363 {
364 // check if we use themes at all -- if we don't, we're still okay
365 if ( wxUxThemeEngine::GetIfActive() && (style & (wxBK_BOTTOM|wxBK_LEFT|wxBK_RIGHT)))
366 {
367 wxUxThemeEngine::GetIfActive()->SetWindowTheme((HWND)this->GetHandle(), L"", L"");
368 SetBackgroundColour(GetThemeBackgroundColour()); //correct the background color for the new non-themed control
369 }
370 }
371 #endif // wxUSE_UXTHEME
372
373 // Undocumented hack to get flat notebook style
374 // In fact, we should probably only do this in some
375 // curcumstances, i.e. if we know we will have a border
376 // at the bottom (the tab control doesn't draw it itself)
377 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
378 if (HasFlag(wxNB_FLAT))
379 {
380 SendMessage(GetHwnd(), CCM_SETVERSION, COMCTL32_VERSION, 0);
381 if (!m_hasBgCol)
382 SetBackgroundColour(*wxWHITE);
383 }
384 #endif
385 return true;
386 }
387
388 WXDWORD wxNotebook::MSWGetStyle(long style, WXDWORD *exstyle) const
389 {
390 WXDWORD tabStyle = wxControl::MSWGetStyle(style, exstyle);
391
392 tabStyle |= WS_TABSTOP | TCS_TABS;
393
394 if ( style & wxNB_MULTILINE )
395 tabStyle |= TCS_MULTILINE;
396 if ( style & wxNB_FIXEDWIDTH )
397 tabStyle |= TCS_FIXEDWIDTH;
398
399 if ( style & wxBK_BOTTOM )
400 tabStyle |= TCS_RIGHT;
401 else if ( style & wxBK_LEFT )
402 tabStyle |= TCS_VERTICAL;
403 else if ( style & wxBK_RIGHT )
404 tabStyle |= TCS_VERTICAL | TCS_RIGHT;
405
406 // ex style
407 if ( exstyle )
408 {
409 // note that we never want to have the default WS_EX_CLIENTEDGE style
410 // as it looks too ugly for the notebooks
411 *exstyle = 0;
412 }
413
414 return tabStyle;
415 }
416
417 wxNotebook::~wxNotebook()
418 {
419 #if wxUSE_UXTHEME
420 if ( m_hbrBackground )
421 ::DeleteObject((HBRUSH)m_hbrBackground);
422 #endif // wxUSE_UXTHEME
423 }
424
425 // ----------------------------------------------------------------------------
426 // wxNotebook accessors
427 // ----------------------------------------------------------------------------
428
429 size_t wxNotebook::GetPageCount() const
430 {
431 // consistency check
432 wxASSERT( (int)m_pages.Count() == TabCtrl_GetItemCount(GetHwnd()) );
433
434 return m_pages.Count();
435 }
436
437 int wxNotebook::GetRowCount() const
438 {
439 return TabCtrl_GetRowCount(GetHwnd());
440 }
441
442 int wxNotebook::SetSelection(size_t nPage)
443 {
444 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("notebook page out of range") );
445
446 if ( m_nSelection == wxNOT_FOUND || nPage != (size_t)m_nSelection )
447 {
448 if ( SendPageChangingEvent(nPage) )
449 {
450 // program allows the page change
451 SendPageChangedEvent(m_nSelection, nPage);
452
453 TabCtrl_SetCurSel(GetHwnd(), nPage);
454 }
455 }
456
457 return m_nSelection;
458 }
459
460 void wxNotebook::UpdateSelection(size_t newsel)
461 {
462 if ( m_nSelection != -1 )
463 m_pages[m_nSelection]->Show(false);
464
465 if ( newsel != -1 )
466 {
467 wxNotebookPage *pPage = m_pages[newsel];
468 pPage->Show(true);
469 }
470
471 // Changing the page should give the focus to it but, as per bug report
472 // http://sf.net/tracker/index.php?func=detail&aid=1150659&group_id=9863&atid=109863,
473 // we should not set the focus to it directly since it erroneously
474 // selects radio buttons and breaks keyboard handling for a notebook's
475 // scroll buttons. So give focus to the notebook and not the page.
476
477 // but don't do this is the notebook is hidden
478 if ( ::IsWindowVisible(GetHwnd()) )
479 SetFocus();
480
481 m_nSelection = newsel;
482 }
483
484 int wxNotebook::ChangeSelection(size_t nPage)
485 {
486 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("notebook page out of range") );
487
488 if ( int(nPage) != m_nSelection )
489 {
490 TabCtrl_SetCurSel(GetHwnd(), nPage);
491
492 UpdateSelection(nPage);
493 }
494
495 return m_nSelection;
496 }
497
498 bool wxNotebook::SetPageText(size_t nPage, const wxString& strText)
499 {
500 wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
501
502 TC_ITEM tcItem;
503 tcItem.mask = TCIF_TEXT;
504 tcItem.pszText = (wxChar *)strText.c_str();
505
506 if ( !HasFlag(wxNB_MULTILINE) )
507 return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
508
509 // multiline - we need to set new page size if a line is added or removed
510 int rows = GetRowCount();
511 bool ret = TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
512
513 if ( ret && rows != GetRowCount() )
514 {
515 const wxRect r = GetPageSize();
516 const size_t count = m_pages.Count();
517 for ( size_t page = 0; page < count; page++ )
518 m_pages[page]->SetSize(r);
519 }
520
521 return ret;
522 }
523
524 wxString wxNotebook::GetPageText(size_t nPage) const
525 {
526 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxEmptyString, wxT("notebook page out of range") );
527
528 wxChar buf[256];
529 TC_ITEM tcItem;
530 tcItem.mask = TCIF_TEXT;
531 tcItem.pszText = buf;
532 tcItem.cchTextMax = WXSIZEOF(buf);
533
534 wxString str;
535 if ( TabCtrl_GetItem(GetHwnd(), nPage, &tcItem) )
536 str = tcItem.pszText;
537
538 return str;
539 }
540
541 int wxNotebook::GetPageImage(size_t nPage) const
542 {
543 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("notebook page out of range") );
544
545 TC_ITEM tcItem;
546 tcItem.mask = TCIF_IMAGE;
547
548 return TabCtrl_GetItem(GetHwnd(), nPage, &tcItem) ? tcItem.iImage : wxNOT_FOUND;
549 }
550
551 bool wxNotebook::SetPageImage(size_t nPage, int nImage)
552 {
553 wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
554
555 TC_ITEM tcItem;
556 tcItem.mask = TCIF_IMAGE;
557 tcItem.iImage = nImage;
558
559 return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
560 }
561
562 void wxNotebook::SetImageList(wxImageList* imageList)
563 {
564 wxNotebookBase::SetImageList(imageList);
565
566 if ( imageList )
567 {
568 (void) TabCtrl_SetImageList(GetHwnd(), (HIMAGELIST)imageList->GetHIMAGELIST());
569 }
570 }
571
572 // ----------------------------------------------------------------------------
573 // wxNotebook size settings
574 // ----------------------------------------------------------------------------
575
576 wxRect wxNotebook::GetPageSize() const
577 {
578 wxRect r;
579
580 RECT rc;
581 ::GetClientRect(GetHwnd(), &rc);
582
583 // This check is to work around a bug in TabCtrl_AdjustRect which will
584 // cause a crash on win2k or on XP with themes disabled if either
585 // wxNB_MULTILINE is used or tabs are placed on a side, if the rectangle
586 // is too small.
587 //
588 // The value of 20 is chosen arbitrarily but seems to work
589 if ( rc.right > 20 && rc.bottom > 20 )
590 {
591 TabCtrl_AdjustRect(GetHwnd(), false, &rc);
592
593 wxCopyRECTToRect(rc, r);
594 }
595
596 return r;
597 }
598
599 void wxNotebook::SetPageSize(const wxSize& size)
600 {
601 // transform the page size into the notebook size
602 RECT rc;
603 rc.left =
604 rc.top = 0;
605 rc.right = size.x;
606 rc.bottom = size.y;
607
608 TabCtrl_AdjustRect(GetHwnd(), true, &rc);
609
610 // and now set it
611 SetSize(rc.right - rc.left, rc.bottom - rc.top);
612 }
613
614 void wxNotebook::SetPadding(const wxSize& padding)
615 {
616 TabCtrl_SetPadding(GetHwnd(), padding.x, padding.y);
617 }
618
619 // Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH
620 // style.
621 void wxNotebook::SetTabSize(const wxSize& sz)
622 {
623 ::SendMessage(GetHwnd(), TCM_SETITEMSIZE, 0, MAKELPARAM(sz.x, sz.y));
624 }
625
626 wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
627 {
628 // we can't use TabCtrl_AdjustRect here because it only works for wxNB_TOP
629 wxSize sizeTotal = sizePage;
630
631 wxSize tabSize;
632 if ( GetPageCount() > 0 )
633 {
634 RECT rect;
635 TabCtrl_GetItemRect(GetHwnd(), 0, &rect);
636 tabSize.x = rect.right - rect.left;
637 tabSize.y = rect.bottom - rect.top;
638 }
639
640 // add an extra margin in both directions
641 const int MARGIN = 8;
642 if ( IsVertical() )
643 {
644 sizeTotal.x += MARGIN;
645 sizeTotal.y += tabSize.y + MARGIN;
646 }
647 else // horizontal layout
648 {
649 sizeTotal.x += tabSize.x + MARGIN;
650 sizeTotal.y += MARGIN;
651 }
652
653 return sizeTotal;
654 }
655
656 void wxNotebook::AdjustPageSize(wxNotebookPage *page)
657 {
658 wxCHECK_RET( page, _T("NULL page in wxNotebook::AdjustPageSize") );
659
660 const wxRect r = GetPageSize();
661 if ( !r.IsEmpty() )
662 {
663 page->SetSize(r);
664 }
665 }
666
667 // ----------------------------------------------------------------------------
668 // wxNotebook operations
669 // ----------------------------------------------------------------------------
670
671 // remove one page from the notebook, without deleting
672 wxNotebookPage *wxNotebook::DoRemovePage(size_t nPage)
673 {
674 wxNotebookPage *pageRemoved = wxNotebookBase::DoRemovePage(nPage);
675 if ( !pageRemoved )
676 return NULL;
677
678 TabCtrl_DeleteItem(GetHwnd(), nPage);
679
680 if ( m_pages.IsEmpty() )
681 {
682 // no selection any more, the notebook becamse empty
683 m_nSelection = -1;
684 }
685 else // notebook still not empty
686 {
687 int selNew = TabCtrl_GetCurSel(GetHwnd());
688 if (selNew != -1)
689 {
690 // No selection change, just refresh the current selection.
691 // Because it could be that the slection index changed
692 // we need to update it.
693 // Note: this does not mean the selection it self changed.
694 m_nSelection = selNew;
695 m_pages[m_nSelection]->Refresh();
696 }
697 else if (int(nPage) == m_nSelection)
698 {
699 // The selection was deleted.
700
701 // Determine new selection.
702 if (m_nSelection == int(GetPageCount()))
703 selNew = m_nSelection - 1;
704 else
705 selNew = m_nSelection;
706
707 // m_nSelection must be always valid so reset it before calling
708 // SetSelection()
709 m_nSelection = -1;
710 SetSelection(selNew);
711 }
712 else
713 {
714 wxFAIL; // Windows did not behave ok.
715 }
716 }
717
718 return pageRemoved;
719 }
720
721 // remove all pages
722 bool wxNotebook::DeleteAllPages()
723 {
724 size_t nPageCount = GetPageCount();
725 size_t nPage;
726 for ( nPage = 0; nPage < nPageCount; nPage++ )
727 delete m_pages[nPage];
728
729 m_pages.Clear();
730
731 TabCtrl_DeleteAllItems(GetHwnd());
732
733 m_nSelection = -1;
734
735 InvalidateBestSize();
736 return true;
737 }
738
739 // same as AddPage() but does it at given position
740 bool wxNotebook::InsertPage(size_t nPage,
741 wxNotebookPage *pPage,
742 const wxString& strText,
743 bool bSelect,
744 int imageId)
745 {
746 wxCHECK_MSG( pPage != NULL, false, _T("NULL page in wxNotebook::InsertPage") );
747 wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false,
748 _T("invalid index in wxNotebook::InsertPage") );
749
750 wxASSERT_MSG( pPage->GetParent() == this,
751 _T("notebook pages must have notebook as parent") );
752
753 // add a new tab to the control
754 // ----------------------------
755
756 // init all fields to 0
757 TC_ITEM tcItem;
758 wxZeroMemory(tcItem);
759
760 // set the image, if any
761 if ( imageId != -1 )
762 {
763 tcItem.mask |= TCIF_IMAGE;
764 tcItem.iImage = imageId;
765 }
766
767 // and the text
768 if ( !strText.empty() )
769 {
770 tcItem.mask |= TCIF_TEXT;
771 tcItem.pszText = (wxChar *)strText.c_str(); // const_cast
772 }
773
774 // hide the page: unless it is selected, it shouldn't be shown (and if it
775 // is selected it will be shown later)
776 HWND hwnd = GetWinHwnd(pPage);
777 SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);
778
779 // this updates internal flag too -- otherwise it would get out of sync
780 // with the real state
781 pPage->Show(false);
782
783
784 // fit the notebook page to the tab control's display area: this should be
785 // done before adding it to the notebook or TabCtrl_InsertItem() will
786 // change the notebooks size itself!
787 AdjustPageSize(pPage);
788
789 // finally do insert it
790 if ( TabCtrl_InsertItem(GetHwnd(), nPage, &tcItem) == -1 )
791 {
792 wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str());
793
794 return false;
795 }
796
797 // need to update the bg brush when the first page is added
798 // so the first panel gets the correct themed background
799 if ( m_pages.empty() )
800 {
801 UpdateBgBrush();
802 }
803
804 // succeeded: save the pointer to the page
805 m_pages.Insert(pPage, nPage);
806
807 // we may need to adjust the size again if the notebook size changed:
808 // normally this only happens for the first page we add (the tabs which
809 // hadn't been there before are now shown) but for a multiline notebook it
810 // can happen for any page at all as a new row could have been started
811 if ( m_pages.GetCount() == 1 || HasFlag(wxNB_MULTILINE) )
812 {
813 AdjustPageSize(pPage);
814 }
815
816 // now deal with the selection
817 // ---------------------------
818
819 // if the inserted page is before the selected one, we must update the
820 // index of the selected page
821 if ( int(nPage) <= m_nSelection )
822 {
823 // one extra page added
824 m_nSelection++;
825 }
826
827 // some page should be selected: either this one or the first one if there
828 // is still no selection
829 int selNew = -1;
830 if ( bSelect )
831 selNew = nPage;
832 else if ( m_nSelection == -1 )
833 selNew = 0;
834
835 if ( selNew != -1 )
836 SetSelection(selNew);
837
838 InvalidateBestSize();
839
840 return true;
841 }
842
843 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
844 {
845 TC_HITTESTINFO hitTestInfo;
846 hitTestInfo.pt.x = pt.x;
847 hitTestInfo.pt.y = pt.y;
848 int item = TabCtrl_HitTest(GetHwnd(), &hitTestInfo);
849
850 if ( flags )
851 {
852 *flags = 0;
853
854 if ((hitTestInfo.flags & TCHT_NOWHERE) == TCHT_NOWHERE)
855 *flags |= wxBK_HITTEST_NOWHERE;
856 if ((hitTestInfo.flags & TCHT_ONITEM) == TCHT_ONITEM)
857 *flags |= wxBK_HITTEST_ONITEM;
858 if ((hitTestInfo.flags & TCHT_ONITEMICON) == TCHT_ONITEMICON)
859 *flags |= wxBK_HITTEST_ONICON;
860 if ((hitTestInfo.flags & TCHT_ONITEMLABEL) == TCHT_ONITEMLABEL)
861 *flags |= wxBK_HITTEST_ONLABEL;
862 if ( item == wxNOT_FOUND && GetPageSize().Contains(pt) )
863 *flags |= wxBK_HITTEST_ONPAGE;
864 }
865
866 return item;
867 }
868
869 // ----------------------------------------------------------------------------
870 // flicker-less notebook redraw
871 // ----------------------------------------------------------------------------
872
873 #if USE_NOTEBOOK_ANTIFLICKER
874
875 // wnd proc for the spin button
876 LRESULT APIENTRY _EXPORT wxNotebookSpinBtnWndProc(HWND hwnd,
877 UINT message,
878 WPARAM wParam,
879 LPARAM lParam)
880 {
881 if ( message == WM_ERASEBKGND )
882 return 0;
883
884 return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebookSpinBtn,
885 hwnd, message, wParam, lParam);
886 }
887
888 LRESULT APIENTRY _EXPORT wxNotebookWndProc(HWND hwnd,
889 UINT message,
890 WPARAM wParam,
891 LPARAM lParam)
892 {
893 return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebook,
894 hwnd, message, wParam, lParam);
895 }
896
897 void wxNotebook::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
898 {
899 // do nothing here
900 }
901
902 void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event))
903 {
904 wxPaintDC dc(this);
905 wxMemoryDC memdc;
906 RECT rc;
907 ::GetClientRect(GetHwnd(), &rc);
908 wxBitmap bmp(rc.right, rc.bottom);
909 memdc.SelectObject(bmp);
910
911 // if there is no special brush just use the solid background colour
912 #if wxUSE_UXTHEME
913 HBRUSH hbr = (HBRUSH)m_hbrBackground;
914 #else
915 HBRUSH hbr = 0;
916 #endif
917 wxBrush brush;
918 if ( !hbr )
919 {
920 brush = wxBrush(GetBackgroundColour());
921 hbr = GetHbrushOf(brush);
922 }
923
924 ::FillRect(GetHdcOf(memdc), &rc, hbr);
925
926 MSWDefWindowProc(WM_PAINT, (WPARAM)memdc.GetHDC(), 0);
927
928 dc.Blit(0, 0, rc.right, rc.bottom, &memdc, 0, 0);
929 }
930
931 #endif // USE_NOTEBOOK_ANTIFLICKER
932
933 // ----------------------------------------------------------------------------
934 // wxNotebook callbacks
935 // ----------------------------------------------------------------------------
936
937 void wxNotebook::OnSize(wxSizeEvent& event)
938 {
939 if ( GetPageCount() == 0 )
940 {
941 // Prevents droppings on resize, but does cause some flicker
942 // when there are no pages.
943 Refresh();
944 event.Skip();
945 return;
946 }
947 #ifndef __WXWINCE__
948 else
949 {
950 // Without this, we can sometimes get droppings at the edges
951 // of a notebook, for example a notebook in a splitter window.
952 // This needs to be reconciled with the RefreshRect calls
953 // at the end of this function, which weren't enough to prevent
954 // the droppings.
955
956 wxSize sz = GetClientSize();
957
958 // Refresh right side
959 wxRect rect(sz.x-4, 0, 4, sz.y);
960 RefreshRect(rect);
961
962 // Refresh bottom side
963 rect = wxRect(0, sz.y-4, sz.x, 4);
964 RefreshRect(rect);
965
966 // Refresh left side
967 rect = wxRect(0, 0, 4, sz.y);
968 RefreshRect(rect);
969 }
970 #endif // !__WXWINCE__
971
972 // fit all the notebook pages to the tab control's display area
973
974 RECT rc;
975 rc.left = rc.top = 0;
976 GetSize((int *)&rc.right, (int *)&rc.bottom);
977
978 // save the total size, we'll use it below
979 int widthNbook = rc.right - rc.left,
980 heightNbook = rc.bottom - rc.top;
981
982 // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
983 // returns completely false values for multiline tab controls after the tabs
984 // are added but before getting the first WM_SIZE (off by ~50 pixels, see
985 //
986 // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
987 //
988 // and the only work around I could find was this ugly hack... without it
989 // simply toggling the "multiline" checkbox in the notebook sample resulted
990 // in a noticeable page displacement
991 if ( HasFlag(wxNB_MULTILINE) )
992 {
993 // avoid an infinite recursion: we get another notification too!
994 static bool s_isInOnSize = false;
995
996 if ( !s_isInOnSize )
997 {
998 s_isInOnSize = true;
999 SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED,
1000 MAKELPARAM(rc.right, rc.bottom));
1001 s_isInOnSize = false;
1002 }
1003 }
1004
1005 #if wxUSE_UXTHEME
1006 // background bitmap size has changed, update the brush using it too
1007 UpdateBgBrush();
1008 #endif // wxUSE_UXTHEME
1009
1010 TabCtrl_AdjustRect(GetHwnd(), false, &rc);
1011
1012 int width = rc.right - rc.left,
1013 height = rc.bottom - rc.top;
1014 size_t nCount = m_pages.Count();
1015 for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
1016 wxNotebookPage *pPage = m_pages[nPage];
1017 pPage->SetSize(rc.left, rc.top, width, height);
1018 }
1019
1020
1021 // unless we had already repainted everything, we now need to refresh
1022 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
1023 {
1024 // invalidate areas not covered by pages
1025 RefreshRect(wxRect(0, 0, widthNbook, rc.top), false);
1026 RefreshRect(wxRect(0, rc.top, rc.left, height), false);
1027 RefreshRect(wxRect(0, rc.bottom, widthNbook, heightNbook - rc.bottom),
1028 false);
1029 RefreshRect(wxRect(rc.right, rc.top, widthNbook - rc.right, height),
1030 false);
1031 }
1032
1033 #if USE_NOTEBOOK_ANTIFLICKER
1034 // subclass the spin control used by the notebook to scroll pages to
1035 // prevent it from flickering on resize
1036 if ( !m_hasSubclassedUpdown )
1037 {
1038 // iterate over all child windows to find spin button
1039 for ( HWND child = ::GetWindow(GetHwnd(), GW_CHILD);
1040 child;
1041 child = ::GetWindow(child, GW_HWNDNEXT) )
1042 {
1043 wxWindow *childWindow = wxFindWinFromHandle((WXHWND)child);
1044
1045 // see if it exists, if no wxWindow found then assume it's the spin
1046 // btn
1047 if ( !childWindow )
1048 {
1049 // subclass the spin button to override WM_ERASEBKGND
1050 if ( !gs_wndprocNotebookSpinBtn )
1051 gs_wndprocNotebookSpinBtn = (WXFARPROC)wxGetWindowProc(child);
1052
1053 wxSetWindowProc(child, wxNotebookSpinBtnWndProc);
1054 m_hasSubclassedUpdown = true;
1055 break;
1056 }
1057 }
1058 }
1059 #endif // USE_NOTEBOOK_ANTIFLICKER
1060
1061 event.Skip();
1062 }
1063
1064 void wxNotebook::OnSelChange(wxNotebookEvent& event)
1065 {
1066 // is it our tab control?
1067 if ( event.GetEventObject() == this )
1068 {
1069 UpdateSelection(event.GetSelection());
1070 }
1071
1072 // we want to give others a chance to process this message as well
1073 event.Skip();
1074 }
1075
1076 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
1077 {
1078 if ( event.IsWindowChange() ) {
1079 // change pages
1080 AdvanceSelection(event.GetDirection());
1081 }
1082 else {
1083 // we get this event in 3 cases
1084 //
1085 // a) one of our pages might have generated it because the user TABbed
1086 // out from it in which case we should propagate the event upwards and
1087 // our parent will take care of setting the focus to prev/next sibling
1088 //
1089 // or
1090 //
1091 // b) the parent panel wants to give the focus to us so that we
1092 // forward it to our selected page. We can't deal with this in
1093 // OnSetFocus() because we don't know which direction the focus came
1094 // from in this case and so can't choose between setting the focus to
1095 // first or last panel child
1096 //
1097 // or
1098 //
1099 // c) we ourselves (see MSWTranslateMessage) generated the event
1100 //
1101 wxWindow * const parent = GetParent();
1102
1103 // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
1104 const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
1105 const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
1106
1107 if ( isFromParent || isFromSelf )
1108 {
1109 // no, it doesn't come from child, case (b) or (c): forward to a
1110 // page but only if direction is backwards (TAB) or from ourselves,
1111 if ( m_nSelection != -1 &&
1112 (!event.GetDirection() || isFromSelf) )
1113 {
1114 // so that the page knows that the event comes from it's parent
1115 // and is being propagated downwards
1116 event.SetEventObject(this);
1117
1118 wxWindow *page = m_pages[m_nSelection];
1119 if ( !page->GetEventHandler()->ProcessEvent(event) )
1120 {
1121 page->SetFocus();
1122 }
1123 //else: page manages focus inside it itself
1124 }
1125 else // otherwise set the focus to the notebook itself
1126 {
1127 SetFocus();
1128 }
1129 }
1130 else
1131 {
1132 // it comes from our child, case (a), pass to the parent, but only
1133 // if the direction is forwards. Otherwise set the focus to the
1134 // notebook itself. The notebook is always the 'first' control of a
1135 // page.
1136 if ( !event.GetDirection() )
1137 {
1138 SetFocus();
1139 }
1140 else if ( parent )
1141 {
1142 event.SetCurrentFocus(this);
1143 parent->GetEventHandler()->ProcessEvent(event);
1144 }
1145 }
1146 }
1147 }
1148
1149 #if wxUSE_UXTHEME
1150
1151 bool wxNotebook::DoDrawBackground(WXHDC hDC, wxWindow *child)
1152 {
1153 wxUxThemeHandle theme(child ? child : this, L"TAB");
1154 if ( !theme )
1155 return false;
1156
1157 // get the notebook client rect (we're not interested in drawing tabs
1158 // themselves)
1159 wxRect r = GetPageSize();
1160 if ( r.IsEmpty() )
1161 return false;
1162
1163 RECT rc;
1164 wxCopyRectToRECT(r, rc);
1165
1166 // map rect to the coords of the window we're drawing in
1167 if ( child )
1168 ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1169
1170 // we have the content area (page size), but we need to draw all of the
1171 // background for it to be aligned correctly
1172 wxUxThemeEngine::Get()->GetThemeBackgroundExtent
1173 (
1174 theme,
1175 (HDC) hDC,
1176 9 /* TABP_PANE */,
1177 0,
1178 &rc,
1179 &rc
1180 );
1181 wxUxThemeEngine::Get()->DrawThemeBackground
1182 (
1183 theme,
1184 (HDC) hDC,
1185 9 /* TABP_PANE */,
1186 0,
1187 &rc,
1188 NULL
1189 );
1190
1191 return true;
1192 }
1193
1194 WXHBRUSH wxNotebook::QueryBgBitmap()
1195 {
1196 wxRect r = GetPageSize();
1197 if ( r.IsEmpty() )
1198 return 0;
1199
1200 WindowHDC hDC(GetHwnd());
1201 MemoryHDC hDCMem(hDC);
1202 CompatibleBitmap hBmp(hDC, r.x + r.width, r.y + r.height);
1203
1204 SelectInHDC selectBmp(hDCMem, hBmp);
1205
1206 if ( !DoDrawBackground((WXHDC)(HDC)hDCMem) )
1207 return 0;
1208
1209 return (WXHBRUSH)::CreatePatternBrush(hBmp);
1210 }
1211
1212 void wxNotebook::UpdateBgBrush()
1213 {
1214 if ( m_hbrBackground )
1215 ::DeleteObject((HBRUSH)m_hbrBackground);
1216
1217 if ( !m_hasBgCol && wxUxThemeEngine::GetIfActive() )
1218 {
1219 m_hbrBackground = QueryBgBitmap();
1220 }
1221 else // no themes or we've got user-defined solid colour
1222 {
1223 m_hbrBackground = NULL;
1224 }
1225 }
1226
1227 WXHBRUSH wxNotebook::MSWGetBgBrushForChild(WXHDC hDC, WXHWND hWnd)
1228 {
1229 if ( m_hbrBackground )
1230 {
1231 // before drawing with the background brush, we need to position it
1232 // correctly
1233 RECT rc;
1234 ::GetWindowRect((HWND)hWnd, &rc);
1235
1236 ::MapWindowPoints(NULL, GetHwnd(), (POINT *)&rc, 1);
1237
1238 if ( !::SetBrushOrgEx((HDC)hDC, -rc.left, -rc.top, NULL) )
1239 {
1240 wxLogLastError(_T("SetBrushOrgEx(notebook bg brush)"));
1241 }
1242
1243 return m_hbrBackground;
1244 }
1245
1246 return wxNotebookBase::MSWGetBgBrushForChild(hDC, hWnd);
1247 }
1248
1249 bool wxNotebook::MSWPrintChild(WXHDC hDC, wxWindow *child)
1250 {
1251 // solid background colour overrides themed background drawing
1252 if ( !UseBgCol() && DoDrawBackground(hDC, child) )
1253 return true;
1254
1255 // If we're using a solid colour (for example if we've switched off
1256 // theming for this notebook), paint it
1257 if (UseBgCol())
1258 {
1259 wxRect r = GetPageSize();
1260 if ( r.IsEmpty() )
1261 return false;
1262
1263 RECT rc;
1264 wxCopyRectToRECT(r, rc);
1265
1266 // map rect to the coords of the window we're drawing in
1267 if ( child )
1268 ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1269
1270 wxBrush brush(GetBackgroundColour());
1271 HBRUSH hbr = GetHbrushOf(brush);
1272
1273 ::FillRect((HDC) hDC, &rc, hbr);
1274
1275 return true;
1276 }
1277
1278 return wxNotebookBase::MSWPrintChild(hDC, child);
1279 }
1280
1281 #endif // wxUSE_UXTHEME
1282
1283 // Windows only: attempts to get colour for UX theme page background
1284 wxColour wxNotebook::GetThemeBackgroundColour() const
1285 {
1286 #if wxUSE_UXTHEME
1287 if (wxUxThemeEngine::Get())
1288 {
1289 wxUxThemeHandle hTheme((wxNotebook*) this, L"TAB");
1290 if (hTheme)
1291 {
1292 // This is total guesswork.
1293 // See PlatformSDK\Include\Tmschema.h for values
1294 COLORREF themeColor;
1295 wxUxThemeEngine::Get()->GetThemeColor(
1296 hTheme,
1297 10 /* TABP_BODY */,
1298 1 /* NORMAL */,
1299 3821 /* FILLCOLORHINT */,
1300 &themeColor);
1301
1302 /*
1303 [DS] Workaround for WindowBlinds:
1304 Some themes return a near black theme color using FILLCOLORHINT,
1305 this makes notebook pages have an ugly black background and makes
1306 text (usually black) unreadable. Retry again with FILLCOLOR.
1307
1308 This workaround potentially breaks appearance of some themes,
1309 but in practice it already fixes some themes.
1310 */
1311 if (themeColor == 1)
1312 {
1313 wxUxThemeEngine::Get()->GetThemeColor(
1314 hTheme,
1315 10 /* TABP_BODY */,
1316 1 /* NORMAL */,
1317 3802 /* FILLCOLOR */,
1318 &themeColor);
1319 }
1320
1321 return wxRGBToColour(themeColor);
1322 }
1323 }
1324 #endif // wxUSE_UXTHEME
1325
1326 return GetBackgroundColour();
1327 }
1328
1329 // ----------------------------------------------------------------------------
1330 // wxNotebook base class virtuals
1331 // ----------------------------------------------------------------------------
1332
1333 #if wxUSE_CONSTRAINTS
1334
1335 // override these 2 functions to do nothing: everything is done in OnSize
1336
1337 void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse))
1338 {
1339 // don't set the sizes of the pages - their correct size is not yet known
1340 wxControl::SetConstraintSizes(false);
1341 }
1342
1343 bool wxNotebook::DoPhase(int WXUNUSED(nPhase))
1344 {
1345 return true;
1346 }
1347
1348 #endif // wxUSE_CONSTRAINTS
1349
1350 // ----------------------------------------------------------------------------
1351 // wxNotebook Windows message handlers
1352 // ----------------------------------------------------------------------------
1353
1354 bool wxNotebook::MSWOnScroll(int orientation, WXWORD nSBCode,
1355 WXWORD pos, WXHWND control)
1356 {
1357 // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the
1358 // up-down control
1359 if ( control )
1360 return false;
1361
1362 return wxNotebookBase::MSWOnScroll(orientation, nSBCode, pos, control);
1363 }
1364
1365 bool wxNotebook::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM* result)
1366 {
1367 wxNotebookEvent event(wxEVT_NULL, m_windowId);
1368
1369 NMHDR* hdr = (NMHDR *)lParam;
1370 switch ( hdr->code ) {
1371 case TCN_SELCHANGE:
1372 event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
1373 break;
1374
1375 case TCN_SELCHANGING:
1376 event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING);
1377 break;
1378
1379 default:
1380 return wxControl::MSWOnNotify(idCtrl, lParam, result);
1381 }
1382
1383 event.SetSelection(TabCtrl_GetCurSel(GetHwnd()));
1384 event.SetOldSelection(m_nSelection);
1385 event.SetEventObject(this);
1386 event.SetInt(idCtrl);
1387
1388 bool processed = GetEventHandler()->ProcessEvent(event);
1389 *result = !event.IsAllowed();
1390 return processed;
1391 }
1392
1393 #endif // wxUSE_NOTEBOOK
wxWidgets (Impactor)