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


cd19ed2b0d0e419e9282cab664a5899257498d8a
[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 ( int(nPage) != m_nSelection )
447 {
448 wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId);
449 event.SetSelection(nPage);
450 event.SetOldSelection(m_nSelection);
451 event.SetEventObject(this);
452 if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
453 {
454 // program allows the page change
455 event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
456 (void)GetEventHandler()->ProcessEvent(event);
457
458 TabCtrl_SetCurSel(GetHwnd(), nPage);
459 }
460 }
461
462 return m_nSelection;
463 }
464
465 bool wxNotebook::SetPageText(size_t nPage, const wxString& strText)
466 {
467 wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
468
469 TC_ITEM tcItem;
470 tcItem.mask = TCIF_TEXT;
471 tcItem.pszText = (wxChar *)strText.c_str();
472
473 if ( !HasFlag(wxNB_MULTILINE) )
474 return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
475
476 // multiline - we need to set new page size if a line is added or removed
477 int rows = GetRowCount();
478 bool ret = TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
479
480 if ( ret && rows != GetRowCount() )
481 {
482 const wxRect r = GetPageSize();
483 const size_t count = m_pages.Count();
484 for ( size_t page = 0; page < count; page++ )
485 m_pages[page]->SetSize(r);
486 }
487
488 return ret;
489 }
490
491 wxString wxNotebook::GetPageText(size_t nPage) const
492 {
493 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxEmptyString, wxT("notebook page out of range") );
494
495 wxChar buf[256];
496 TC_ITEM tcItem;
497 tcItem.mask = TCIF_TEXT;
498 tcItem.pszText = buf;
499 tcItem.cchTextMax = WXSIZEOF(buf);
500
501 wxString str;
502 if ( TabCtrl_GetItem(GetHwnd(), nPage, &tcItem) )
503 str = tcItem.pszText;
504
505 return str;
506 }
507
508 int wxNotebook::GetPageImage(size_t nPage) const
509 {
510 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("notebook page out of range") );
511
512 TC_ITEM tcItem;
513 tcItem.mask = TCIF_IMAGE;
514
515 return TabCtrl_GetItem(GetHwnd(), nPage, &tcItem) ? tcItem.iImage : wxNOT_FOUND;
516 }
517
518 bool wxNotebook::SetPageImage(size_t nPage, int nImage)
519 {
520 wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
521
522 TC_ITEM tcItem;
523 tcItem.mask = TCIF_IMAGE;
524 tcItem.iImage = nImage;
525
526 return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
527 }
528
529 void wxNotebook::SetImageList(wxImageList* imageList)
530 {
531 wxNotebookBase::SetImageList(imageList);
532
533 if ( imageList )
534 {
535 (void) TabCtrl_SetImageList(GetHwnd(), (HIMAGELIST)imageList->GetHIMAGELIST());
536 }
537 }
538
539 // ----------------------------------------------------------------------------
540 // wxNotebook size settings
541 // ----------------------------------------------------------------------------
542
543 wxRect wxNotebook::GetPageSize() const
544 {
545 wxRect r;
546
547 RECT rc;
548 ::GetClientRect(GetHwnd(), &rc);
549
550 // This check is to work around a bug in TabCtrl_AdjustRect which will
551 // cause a crash on win2k or on XP with themes disabled if either
552 // wxNB_MULTILINE is used or tabs are placed on a side, if the rectangle
553 // is too small.
554 //
555 // The value of 20 is chosen arbitrarily but seems to work
556 if ( rc.right > 20 && rc.bottom > 20 )
557 {
558 TabCtrl_AdjustRect(GetHwnd(), false, &rc);
559
560 wxCopyRECTToRect(rc, r);
561 }
562
563 return r;
564 }
565
566 void wxNotebook::SetPageSize(const wxSize& size)
567 {
568 // transform the page size into the notebook size
569 RECT rc;
570 rc.left =
571 rc.top = 0;
572 rc.right = size.x;
573 rc.bottom = size.y;
574
575 TabCtrl_AdjustRect(GetHwnd(), true, &rc);
576
577 // and now set it
578 SetSize(rc.right - rc.left, rc.bottom - rc.top);
579 }
580
581 void wxNotebook::SetPadding(const wxSize& padding)
582 {
583 TabCtrl_SetPadding(GetHwnd(), padding.x, padding.y);
584 }
585
586 // Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH
587 // style.
588 void wxNotebook::SetTabSize(const wxSize& sz)
589 {
590 ::SendMessage(GetHwnd(), TCM_SETITEMSIZE, 0, MAKELPARAM(sz.x, sz.y));
591 }
592
593 wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
594 {
595 // we can't use TabCtrl_AdjustRect here because it only works for wxNB_TOP
596 wxSize sizeTotal = sizePage;
597
598 wxSize tabSize;
599 if ( GetPageCount() > 0 )
600 {
601 RECT rect;
602 TabCtrl_GetItemRect(GetHwnd(), 0, &rect);
603 tabSize.x = rect.right - rect.left;
604 tabSize.y = rect.bottom - rect.top;
605 }
606
607 // add an extra margin in both directions
608 const int MARGIN = 8;
609 if ( IsVertical() )
610 {
611 sizeTotal.x += MARGIN;
612 sizeTotal.y += tabSize.y + MARGIN;
613 }
614 else // horizontal layout
615 {
616 sizeTotal.x += tabSize.x + MARGIN;
617 sizeTotal.y += MARGIN;
618 }
619
620 return sizeTotal;
621 }
622
623 void wxNotebook::AdjustPageSize(wxNotebookPage *page)
624 {
625 wxCHECK_RET( page, _T("NULL page in wxNotebook::AdjustPageSize") );
626
627 const wxRect r = GetPageSize();
628 if ( !r.IsEmpty() )
629 {
630 page->SetSize(r);
631 }
632 }
633
634 // ----------------------------------------------------------------------------
635 // wxNotebook operations
636 // ----------------------------------------------------------------------------
637
638 // remove one page from the notebook, without deleting
639 wxNotebookPage *wxNotebook::DoRemovePage(size_t nPage)
640 {
641 wxNotebookPage *pageRemoved = wxNotebookBase::DoRemovePage(nPage);
642 if ( !pageRemoved )
643 return NULL;
644
645 TabCtrl_DeleteItem(GetHwnd(), nPage);
646
647 if ( m_pages.IsEmpty() )
648 {
649 // no selection any more, the notebook becamse empty
650 m_nSelection = -1;
651 }
652 else // notebook still not empty
653 {
654 int selNew = TabCtrl_GetCurSel(GetHwnd());
655 if (selNew != -1)
656 {
657 // No selection change, just refresh the current selection.
658 // Because it could be that the slection index changed
659 // we need to update it.
660 // Note: this does not mean the selection it self changed.
661 m_nSelection = selNew;
662 m_pages[m_nSelection]->Refresh();
663 }
664 else if (int(nPage) == m_nSelection)
665 {
666 // The selection was deleted.
667
668 // Determine new selection.
669 if (m_nSelection == int(GetPageCount()))
670 selNew = m_nSelection - 1;
671 else
672 selNew = m_nSelection;
673
674 // m_nSelection must be always valid so reset it before calling
675 // SetSelection()
676 m_nSelection = -1;
677 SetSelection(selNew);
678 }
679 else
680 {
681 wxFAIL; // Windows did not behave ok.
682 }
683 }
684
685 return pageRemoved;
686 }
687
688 // remove all pages
689 bool wxNotebook::DeleteAllPages()
690 {
691 size_t nPageCount = GetPageCount();
692 size_t nPage;
693 for ( nPage = 0; nPage < nPageCount; nPage++ )
694 delete m_pages[nPage];
695
696 m_pages.Clear();
697
698 TabCtrl_DeleteAllItems(GetHwnd());
699
700 m_nSelection = -1;
701
702 InvalidateBestSize();
703 return true;
704 }
705
706 // same as AddPage() but does it at given position
707 bool wxNotebook::InsertPage(size_t nPage,
708 wxNotebookPage *pPage,
709 const wxString& strText,
710 bool bSelect,
711 int imageId)
712 {
713 wxCHECK_MSG( pPage != NULL, false, _T("NULL page in wxNotebook::InsertPage") );
714 wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false,
715 _T("invalid index in wxNotebook::InsertPage") );
716
717 wxASSERT_MSG( pPage->GetParent() == this,
718 _T("notebook pages must have notebook as parent") );
719
720 // add a new tab to the control
721 // ----------------------------
722
723 // init all fields to 0
724 TC_ITEM tcItem;
725 wxZeroMemory(tcItem);
726
727 // set the image, if any
728 if ( imageId != -1 )
729 {
730 tcItem.mask |= TCIF_IMAGE;
731 tcItem.iImage = imageId;
732 }
733
734 // and the text
735 if ( !strText.empty() )
736 {
737 tcItem.mask |= TCIF_TEXT;
738 tcItem.pszText = (wxChar *)strText.c_str(); // const_cast
739 }
740
741 // hide the page: unless it is selected, it shouldn't be shown (and if it
742 // is selected it will be shown later)
743 HWND hwnd = GetWinHwnd(pPage);
744 SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);
745
746 // this updates internal flag too -- otherwise it would get out of sync
747 // with the real state
748 pPage->Show(false);
749
750
751 // fit the notebook page to the tab control's display area: this should be
752 // done before adding it to the notebook or TabCtrl_InsertItem() will
753 // change the notebooks size itself!
754 AdjustPageSize(pPage);
755
756 // finally do insert it
757 if ( TabCtrl_InsertItem(GetHwnd(), nPage, &tcItem) == -1 )
758 {
759 wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str());
760
761 return false;
762 }
763
764 // need to update the bg brush when the first page is added
765 // so the first panel gets the correct themed background
766 if ( m_pages.empty() )
767 {
768 UpdateBgBrush();
769 }
770
771 // succeeded: save the pointer to the page
772 m_pages.Insert(pPage, nPage);
773
774 // we may need to adjust the size again if the notebook size changed:
775 // normally this only happens for the first page we add (the tabs which
776 // hadn't been there before are now shown) but for a multiline notebook it
777 // can happen for any page at all as a new row could have been started
778 if ( m_pages.GetCount() == 1 || HasFlag(wxNB_MULTILINE) )
779 {
780 AdjustPageSize(pPage);
781 }
782
783 // now deal with the selection
784 // ---------------------------
785
786 // if the inserted page is before the selected one, we must update the
787 // index of the selected page
788 if ( int(nPage) <= m_nSelection )
789 {
790 // one extra page added
791 m_nSelection++;
792 }
793
794 // some page should be selected: either this one or the first one if there
795 // is still no selection
796 int selNew = -1;
797 if ( bSelect )
798 selNew = nPage;
799 else if ( m_nSelection == -1 )
800 selNew = 0;
801
802 if ( selNew != -1 )
803 SetSelection(selNew);
804
805 InvalidateBestSize();
806
807 return true;
808 }
809
810 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
811 {
812 TC_HITTESTINFO hitTestInfo;
813 hitTestInfo.pt.x = pt.x;
814 hitTestInfo.pt.y = pt.y;
815 int item = TabCtrl_HitTest(GetHwnd(), &hitTestInfo);
816
817 if ( flags )
818 {
819 *flags = 0;
820
821 if ((hitTestInfo.flags & TCHT_NOWHERE) == TCHT_NOWHERE)
822 *flags |= wxBK_HITTEST_NOWHERE;
823 if ((hitTestInfo.flags & TCHT_ONITEM) == TCHT_ONITEM)
824 *flags |= wxBK_HITTEST_ONITEM;
825 if ((hitTestInfo.flags & TCHT_ONITEMICON) == TCHT_ONITEMICON)
826 *flags |= wxBK_HITTEST_ONICON;
827 if ((hitTestInfo.flags & TCHT_ONITEMLABEL) == TCHT_ONITEMLABEL)
828 *flags |= wxBK_HITTEST_ONLABEL;
829 if ( item == wxNOT_FOUND && GetPageSize().Contains(pt) )
830 *flags |= wxBK_HITTEST_ONPAGE;
831 }
832
833 return item;
834 }
835
836 // ----------------------------------------------------------------------------
837 // flicker-less notebook redraw
838 // ----------------------------------------------------------------------------
839
840 #if USE_NOTEBOOK_ANTIFLICKER
841
842 // wnd proc for the spin button
843 LRESULT APIENTRY _EXPORT wxNotebookSpinBtnWndProc(HWND hwnd,
844 UINT message,
845 WPARAM wParam,
846 LPARAM lParam)
847 {
848 if ( message == WM_ERASEBKGND )
849 return 0;
850
851 return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebookSpinBtn,
852 hwnd, message, wParam, lParam);
853 }
854
855 LRESULT APIENTRY _EXPORT wxNotebookWndProc(HWND hwnd,
856 UINT message,
857 WPARAM wParam,
858 LPARAM lParam)
859 {
860 return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebook,
861 hwnd, message, wParam, lParam);
862 }
863
864 void wxNotebook::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
865 {
866 // do nothing here
867 }
868
869 void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event))
870 {
871 wxPaintDC dc(this);
872 wxMemoryDC memdc;
873 RECT rc;
874 ::GetClientRect(GetHwnd(), &rc);
875 wxBitmap bmp(rc.right, rc.bottom);
876 memdc.SelectObject(bmp);
877
878 // if there is no special brush just use the solid background colour
879 #if wxUSE_UXTHEME
880 HBRUSH hbr = (HBRUSH)m_hbrBackground;
881 #else
882 HBRUSH hbr = 0;
883 #endif
884 wxBrush brush;
885 if ( !hbr )
886 {
887 brush = wxBrush(GetBackgroundColour());
888 hbr = GetHbrushOf(brush);
889 }
890
891 ::FillRect(GetHdcOf(memdc), &rc, hbr);
892
893 MSWDefWindowProc(WM_PAINT, (WPARAM)memdc.GetHDC(), 0);
894
895 dc.Blit(0, 0, rc.right, rc.bottom, &memdc, 0, 0);
896 }
897
898 #endif // USE_NOTEBOOK_ANTIFLICKER
899
900 // ----------------------------------------------------------------------------
901 // wxNotebook callbacks
902 // ----------------------------------------------------------------------------
903
904 void wxNotebook::OnSize(wxSizeEvent& event)
905 {
906 if ( GetPageCount() == 0 )
907 {
908 // Prevents droppings on resize, but does cause some flicker
909 // when there are no pages.
910 Refresh();
911 event.Skip();
912 return;
913 }
914 #ifndef __WXWINCE__
915 else
916 {
917 // Without this, we can sometimes get droppings at the edges
918 // of a notebook, for example a notebook in a splitter window.
919 // This needs to be reconciled with the RefreshRect calls
920 // at the end of this function, which weren't enough to prevent
921 // the droppings.
922
923 wxSize sz = GetClientSize();
924
925 // Refresh right side
926 wxRect rect(sz.x-4, 0, 4, sz.y);
927 RefreshRect(rect);
928
929 // Refresh bottom side
930 rect = wxRect(0, sz.y-4, sz.x, 4);
931 RefreshRect(rect);
932
933 // Refresh left side
934 rect = wxRect(0, 0, 4, sz.y);
935 RefreshRect(rect);
936 }
937 #endif // !__WXWINCE__
938
939 // fit all the notebook pages to the tab control's display area
940
941 RECT rc;
942 rc.left = rc.top = 0;
943 GetSize((int *)&rc.right, (int *)&rc.bottom);
944
945 // save the total size, we'll use it below
946 int widthNbook = rc.right - rc.left,
947 heightNbook = rc.bottom - rc.top;
948
949 // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
950 // returns completely false values for multiline tab controls after the tabs
951 // are added but before getting the first WM_SIZE (off by ~50 pixels, see
952 //
953 // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
954 //
955 // and the only work around I could find was this ugly hack... without it
956 // simply toggling the "multiline" checkbox in the notebook sample resulted
957 // in a noticeable page displacement
958 if ( HasFlag(wxNB_MULTILINE) )
959 {
960 // avoid an infinite recursion: we get another notification too!
961 static bool s_isInOnSize = false;
962
963 if ( !s_isInOnSize )
964 {
965 s_isInOnSize = true;
966 SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED,
967 MAKELPARAM(rc.right, rc.bottom));
968 s_isInOnSize = false;
969 }
970 }
971
972 #if wxUSE_UXTHEME
973 // background bitmap size has changed, update the brush using it too
974 UpdateBgBrush();
975 #endif // wxUSE_UXTHEME
976
977 TabCtrl_AdjustRect(GetHwnd(), false, &rc);
978
979 int width = rc.right - rc.left,
980 height = rc.bottom - rc.top;
981 size_t nCount = m_pages.Count();
982 for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
983 wxNotebookPage *pPage = m_pages[nPage];
984 pPage->SetSize(rc.left, rc.top, width, height);
985 }
986
987
988 // unless we had already repainted everything, we now need to refresh
989 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
990 {
991 // invalidate areas not covered by pages
992 RefreshRect(wxRect(0, 0, widthNbook, rc.top), false);
993 RefreshRect(wxRect(0, rc.top, rc.left, height), false);
994 RefreshRect(wxRect(0, rc.bottom, widthNbook, heightNbook - rc.bottom),
995 false);
996 RefreshRect(wxRect(rc.right, rc.top, widthNbook - rc.right, height),
997 false);
998 }
999
1000 #if USE_NOTEBOOK_ANTIFLICKER
1001 // subclass the spin control used by the notebook to scroll pages to
1002 // prevent it from flickering on resize
1003 if ( !m_hasSubclassedUpdown )
1004 {
1005 // iterate over all child windows to find spin button
1006 for ( HWND child = ::GetWindow(GetHwnd(), GW_CHILD);
1007 child;
1008 child = ::GetWindow(child, GW_HWNDNEXT) )
1009 {
1010 wxWindow *childWindow = wxFindWinFromHandle((WXHWND)child);
1011
1012 // see if it exists, if no wxWindow found then assume it's the spin
1013 // btn
1014 if ( !childWindow )
1015 {
1016 // subclass the spin button to override WM_ERASEBKGND
1017 if ( !gs_wndprocNotebookSpinBtn )
1018 gs_wndprocNotebookSpinBtn = (WXFARPROC)wxGetWindowProc(child);
1019
1020 wxSetWindowProc(child, wxNotebookSpinBtnWndProc);
1021 m_hasSubclassedUpdown = true;
1022 break;
1023 }
1024 }
1025 }
1026 #endif // USE_NOTEBOOK_ANTIFLICKER
1027
1028 event.Skip();
1029 }
1030
1031 void wxNotebook::OnSelChange(wxNotebookEvent& event)
1032 {
1033 // is it our tab control?
1034 if ( event.GetEventObject() == this )
1035 {
1036 int sel = event.GetOldSelection();
1037 if ( sel != -1 )
1038 m_pages[sel]->Show(false);
1039
1040 sel = event.GetSelection();
1041 if ( sel != -1 )
1042 {
1043 wxNotebookPage *pPage = m_pages[sel];
1044 pPage->Show(true);
1045 }
1046
1047 // Changing the page should give the focus to it but, as per bug report
1048 // http://sf.net/tracker/index.php?func=detail&aid=1150659&group_id=9863&atid=109863,
1049 // we should not set the focus to it directly since it erroneously
1050 // selects radio buttons and breaks keyboard handling for a notebook's
1051 // scroll buttons. So give focus to the notebook and not the page.
1052
1053 // but don't do this is the notebook is hidden
1054 if ( ::IsWindowVisible(GetHwnd()) )
1055 SetFocus();
1056
1057 m_nSelection = sel;
1058 }
1059
1060 // we want to give others a chance to process this message as well
1061 event.Skip();
1062 }
1063
1064 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
1065 {
1066 if ( event.IsWindowChange() ) {
1067 // change pages
1068 AdvanceSelection(event.GetDirection());
1069 }
1070 else {
1071 // we get this event in 3 cases
1072 //
1073 // a) one of our pages might have generated it because the user TABbed
1074 // out from it in which case we should propagate the event upwards and
1075 // our parent will take care of setting the focus to prev/next sibling
1076 //
1077 // or
1078 //
1079 // b) the parent panel wants to give the focus to us so that we
1080 // forward it to our selected page. We can't deal with this in
1081 // OnSetFocus() because we don't know which direction the focus came
1082 // from in this case and so can't choose between setting the focus to
1083 // first or last panel child
1084 //
1085 // or
1086 //
1087 // c) we ourselves (see MSWTranslateMessage) generated the event
1088 //
1089 wxWindow * const parent = GetParent();
1090
1091 // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
1092 const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
1093 const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
1094
1095 if ( isFromParent || isFromSelf )
1096 {
1097 // no, it doesn't come from child, case (b) or (c): forward to a
1098 // page but only if direction is backwards (TAB) or from ourselves,
1099 if ( m_nSelection != -1 &&
1100 (!event.GetDirection() || isFromSelf) )
1101 {
1102 // so that the page knows that the event comes from it's parent
1103 // and is being propagated downwards
1104 event.SetEventObject(this);
1105
1106 wxWindow *page = m_pages[m_nSelection];
1107 if ( !page->GetEventHandler()->ProcessEvent(event) )
1108 {
1109 page->SetFocus();
1110 }
1111 //else: page manages focus inside it itself
1112 }
1113 else // otherwise set the focus to the notebook itself
1114 {
1115 SetFocus();
1116 }
1117 }
1118 else
1119 {
1120 // it comes from our child, case (a), pass to the parent, but only
1121 // if the direction is forwards. Otherwise set the focus to the
1122 // notebook itself. The notebook is always the 'first' control of a
1123 // page.
1124 if ( !event.GetDirection() )
1125 {
1126 SetFocus();
1127 }
1128 else if ( parent )
1129 {
1130 event.SetCurrentFocus(this);
1131 parent->GetEventHandler()->ProcessEvent(event);
1132 }
1133 }
1134 }
1135 }
1136
1137 #if wxUSE_UXTHEME
1138
1139 bool wxNotebook::DoDrawBackground(WXHDC hDC, wxWindow *child)
1140 {
1141 wxUxThemeHandle theme(child ? child : this, L"TAB");
1142 if ( !theme )
1143 return false;
1144
1145 // get the notebook client rect (we're not interested in drawing tabs
1146 // themselves)
1147 wxRect r = GetPageSize();
1148 if ( r.IsEmpty() )
1149 return false;
1150
1151 RECT rc;
1152 wxCopyRectToRECT(r, rc);
1153
1154 // map rect to the coords of the window we're drawing in
1155 if ( child )
1156 ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1157
1158 // we have the content area (page size), but we need to draw all of the
1159 // background for it to be aligned correctly
1160 wxUxThemeEngine::Get()->GetThemeBackgroundExtent
1161 (
1162 theme,
1163 (HDC) hDC,
1164 9 /* TABP_PANE */,
1165 0,
1166 &rc,
1167 &rc
1168 );
1169 wxUxThemeEngine::Get()->DrawThemeBackground
1170 (
1171 theme,
1172 (HDC) hDC,
1173 9 /* TABP_PANE */,
1174 0,
1175 &rc,
1176 NULL
1177 );
1178
1179 return true;
1180 }
1181
1182 WXHBRUSH wxNotebook::QueryBgBitmap()
1183 {
1184 wxRect r = GetPageSize();
1185 if ( r.IsEmpty() )
1186 return 0;
1187
1188 WindowHDC hDC(GetHwnd());
1189 MemoryHDC hDCMem(hDC);
1190 CompatibleBitmap hBmp(hDC, r.x + r.width, r.y + r.height);
1191
1192 SelectInHDC selectBmp(hDCMem, hBmp);
1193
1194 if ( !DoDrawBackground((WXHDC)(HDC)hDCMem) )
1195 return 0;
1196
1197 return (WXHBRUSH)::CreatePatternBrush(hBmp);
1198 }
1199
1200 void wxNotebook::UpdateBgBrush()
1201 {
1202 if ( m_hbrBackground )
1203 ::DeleteObject((HBRUSH)m_hbrBackground);
1204
1205 if ( !m_hasBgCol && wxUxThemeEngine::GetIfActive() )
1206 {
1207 m_hbrBackground = QueryBgBitmap();
1208 }
1209 else // no themes or we've got user-defined solid colour
1210 {
1211 m_hbrBackground = NULL;
1212 }
1213 }
1214
1215 WXHBRUSH wxNotebook::MSWGetBgBrushForChild(WXHDC hDC, WXHWND hWnd)
1216 {
1217 if ( m_hbrBackground )
1218 {
1219 // before drawing with the background brush, we need to position it
1220 // correctly
1221 RECT rc;
1222 ::GetWindowRect((HWND)hWnd, &rc);
1223
1224 ::MapWindowPoints(NULL, GetHwnd(), (POINT *)&rc, 1);
1225
1226 if ( !::SetBrushOrgEx((HDC)hDC, -rc.left, -rc.top, NULL) )
1227 {
1228 wxLogLastError(_T("SetBrushOrgEx(notebook bg brush)"));
1229 }
1230
1231 return m_hbrBackground;
1232 }
1233
1234 return wxNotebookBase::MSWGetBgBrushForChild(hDC, hWnd);
1235 }
1236
1237 bool wxNotebook::MSWPrintChild(WXHDC hDC, wxWindow *child)
1238 {
1239 // solid background colour overrides themed background drawing
1240 if ( !UseBgCol() && DoDrawBackground(hDC, child) )
1241 return true;
1242
1243 // If we're using a solid colour (for example if we've switched off
1244 // theming for this notebook), paint it
1245 if (UseBgCol())
1246 {
1247 wxRect r = GetPageSize();
1248 if ( r.IsEmpty() )
1249 return false;
1250
1251 RECT rc;
1252 wxCopyRectToRECT(r, rc);
1253
1254 // map rect to the coords of the window we're drawing in
1255 if ( child )
1256 ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1257
1258 wxBrush brush(GetBackgroundColour());
1259 HBRUSH hbr = GetHbrushOf(brush);
1260
1261 ::FillRect((HDC) hDC, &rc, hbr);
1262
1263 return true;
1264 }
1265
1266 return wxNotebookBase::MSWPrintChild(hDC, child);
1267 }
1268
1269 #endif // wxUSE_UXTHEME
1270
1271 // Windows only: attempts to get colour for UX theme page background
1272 wxColour wxNotebook::GetThemeBackgroundColour() const
1273 {
1274 #if wxUSE_UXTHEME
1275 if (wxUxThemeEngine::Get())
1276 {
1277 wxUxThemeHandle hTheme((wxNotebook*) this, L"TAB");
1278 if (hTheme)
1279 {
1280 // This is total guesswork.
1281 // See PlatformSDK\Include\Tmschema.h for values
1282 COLORREF themeColor;
1283 wxUxThemeEngine::Get()->GetThemeColor(
1284 hTheme,
1285 10 /* TABP_BODY */,
1286 1 /* NORMAL */,
1287 3821 /* FILLCOLORHINT */,
1288 &themeColor);
1289
1290 /*
1291 [DS] Workaround for WindowBlinds:
1292 Some themes return a near black theme color using FILLCOLORHINT,
1293 this makes notebook pages have an ugly black background and makes
1294 text (usually black) unreadable. Retry again with FILLCOLOR.
1295
1296 This workaround potentially breaks appearance of some themes,
1297 but in practice it already fixes some themes.
1298 */
1299 if (themeColor == 1)
1300 {
1301 wxUxThemeEngine::Get()->GetThemeColor(
1302 hTheme,
1303 10 /* TABP_BODY */,
1304 1 /* NORMAL */,
1305 3802 /* FILLCOLOR */,
1306 &themeColor);
1307 }
1308
1309 return wxRGBToColour(themeColor);
1310 }
1311 }
1312 #endif // wxUSE_UXTHEME
1313
1314 return GetBackgroundColour();
1315 }
1316
1317 // ----------------------------------------------------------------------------
1318 // wxNotebook base class virtuals
1319 // ----------------------------------------------------------------------------
1320
1321 #if wxUSE_CONSTRAINTS
1322
1323 // override these 2 functions to do nothing: everything is done in OnSize
1324
1325 void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse))
1326 {
1327 // don't set the sizes of the pages - their correct size is not yet known
1328 wxControl::SetConstraintSizes(false);
1329 }
1330
1331 bool wxNotebook::DoPhase(int WXUNUSED(nPhase))
1332 {
1333 return true;
1334 }
1335
1336 #endif // wxUSE_CONSTRAINTS
1337
1338 // ----------------------------------------------------------------------------
1339 // wxNotebook Windows message handlers
1340 // ----------------------------------------------------------------------------
1341
1342 bool wxNotebook::MSWOnScroll(int orientation, WXWORD nSBCode,
1343 WXWORD pos, WXHWND control)
1344 {
1345 // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the
1346 // up-down control
1347 if ( control )
1348 return false;
1349
1350 return wxNotebookBase::MSWOnScroll(orientation, nSBCode, pos, control);
1351 }
1352
1353 bool wxNotebook::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM* result)
1354 {
1355 wxNotebookEvent event(wxEVT_NULL, m_windowId);
1356
1357 NMHDR* hdr = (NMHDR *)lParam;
1358 switch ( hdr->code ) {
1359 case TCN_SELCHANGE:
1360 event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
1361 break;
1362
1363 case TCN_SELCHANGING:
1364 event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING);
1365 break;
1366
1367 default:
1368 return wxControl::MSWOnNotify(idCtrl, lParam, result);
1369 }
1370
1371 event.SetSelection(TabCtrl_GetCurSel(GetHwnd()));
1372 event.SetOldSelection(m_nSelection);
1373 event.SetEventObject(this);
1374 event.SetInt(idCtrl);
1375
1376 bool processed = GetEventHandler()->ProcessEvent(event);
1377 *result = !event.IsAllowed();
1378 return processed;
1379 }
1380
1381 #endif // wxUSE_NOTEBOOK
wxWidgets (Impactor)