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