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


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