]> git.saurik.com Git - wxWidgets.git/blob - src/msw/notebook.cpp
Fixes and XCode 2.3 update
[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/string.h"
25 #include "wx/dc.h"
26 #include "wx/log.h"
27 #include "wx/event.h"
28 #include "wx/app.h"
29 #include "wx/dcclient.h"
30 #include "wx/dcmemory.h"
31 #include "wx/control.h"
32 #endif // WX_PRECOMP
33
34 #include "wx/imaglist.h"
35 #include "wx/sysopt.h"
36
37 #include "wx/msw/private.h"
38
39 #include <windowsx.h>
40 #include "wx/msw/winundef.h"
41
42 // include <commctrl.h> "properly"
43 #include "wx/msw/wrapcctl.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 #if !wxUSE_UXTHEME
279 // ComCtl32 notebook tabs simply don't work unless they're on top if we have uxtheme, we can
280 // work around it later (after control creation), but if we don't have uxtheme, we have to clear
281 // those styles
282 const int verComCtl32 = wxApp::GetComCtl32Version();
283 if ( verComCtl32 == 600 )
284 {
285 style &= ~(wxBK_BOTTOM | wxBK_LEFT | wxBK_RIGHT);
286 }
287 #endif //wxUSE_UXTHEME
288
289 LPCTSTR className = WC_TABCONTROL;
290
291 #if USE_NOTEBOOK_ANTIFLICKER
292 // SysTabCtl32 class has natively CS_HREDRAW and CS_VREDRAW enabled and it
293 // causes horrible flicker when resizing notebook, so get rid of it by
294 // using a class without these styles (but otherwise identical to it)
295 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
296 {
297 static ClassRegistrar s_clsNotebook;
298 if ( !s_clsNotebook.IsInitialized() )
299 {
300 // get a copy of standard class and modify it
301 WNDCLASS wc;
302
303 if ( ::GetClassInfo(NULL, WC_TABCONTROL, &wc) )
304 {
305 gs_wndprocNotebook =
306 wx_reinterpret_cast(WXFARPROC, wc.lpfnWndProc);
307 wc.lpszClassName = wxT("_wx_SysTabCtl32");
308 wc.style &= ~(CS_HREDRAW | CS_VREDRAW);
309 wc.hInstance = wxGetInstance();
310 wc.lpfnWndProc = wxNotebookWndProc;
311 s_clsNotebook.Register(wc);
312 }
313 else
314 {
315 wxLogLastError(_T("GetClassInfoEx(SysTabCtl32)"));
316 }
317 }
318
319 // use our custom class if available but fall back to the standard
320 // notebook if we failed to register it
321 if ( s_clsNotebook.IsRegistered() )
322 {
323 // it's ok to use c_str() here as the static s_clsNotebook object
324 // has sufficiently long lifetime
325 className = s_clsNotebook.GetName().c_str();
326 }
327 }
328 #endif // USE_NOTEBOOK_ANTIFLICKER
329
330 if ( !CreateControl(parent, id, pos, size, style | wxTAB_TRAVERSAL,
331 wxDefaultValidator, name) )
332 return false;
333
334 if ( !MSWCreateControl(className, wxEmptyString, pos, size) )
335 return false;
336
337 #if wxUSE_UXTHEME
338 if ( HasFlag(wxNB_NOPAGETHEME) ||
339 wxSystemOptions::IsFalse(wxT("msw.notebook.themed-background")) )
340 {
341 SetBackgroundColour(GetThemeBackgroundColour());
342 }
343 else // use themed background by default
344 {
345 // create backing store
346 UpdateBgBrush();
347 }
348
349 // comctl32.dll 6.0 doesn't support non-top tabs with visual styles (the
350 // control is simply not rendered correctly), so we disable themes
351 // if possible, otherwise we simply clear the styles.
352 // It's probably not possible to have UXTHEME without ComCtl32 6 or better, but lets
353 // check it anyway.
354 const int verComCtl32 = wxApp::GetComCtl32Version();
355 if ( verComCtl32 == 600 )
356 {
357 // check if we use themes at all -- if we don't, we're still okay
358 if ( wxUxThemeEngine::GetIfActive() && (style & (wxBK_BOTTOM|wxBK_LEFT|wxBK_RIGHT)))
359 {
360 wxUxThemeEngine::GetIfActive()->SetWindowTheme((HWND)this->GetHandle(), L"", L"");
361 SetBackgroundColour(GetThemeBackgroundColour()); //correct the background color for the new non-themed control
362 }
363 }
364 #endif // wxUSE_UXTHEME
365
366 // Undocumented hack to get flat notebook style
367 // In fact, we should probably only do this in some
368 // curcumstances, i.e. if we know we will have a border
369 // at the bottom (the tab control doesn't draw it itself)
370 #if defined(__POCKETPC__) || defined(__SMARTPHONE__)
371 if (HasFlag(wxNB_FLAT))
372 {
373 SendMessage(GetHwnd(), CCM_SETVERSION, COMCTL32_VERSION, 0);
374 if (!m_hasBgCol)
375 SetBackgroundColour(*wxWHITE);
376 }
377 #endif
378 return true;
379 }
380
381 WXDWORD wxNotebook::MSWGetStyle(long style, WXDWORD *exstyle) const
382 {
383 WXDWORD tabStyle = wxControl::MSWGetStyle(style, exstyle);
384
385 tabStyle |= WS_TABSTOP | TCS_TABS;
386
387 if ( style & wxNB_MULTILINE )
388 tabStyle |= TCS_MULTILINE;
389 if ( style & wxNB_FIXEDWIDTH )
390 tabStyle |= TCS_FIXEDWIDTH;
391
392 if ( style & wxBK_BOTTOM )
393 tabStyle |= TCS_RIGHT;
394 else if ( style & wxBK_LEFT )
395 tabStyle |= TCS_VERTICAL;
396 else if ( style & wxBK_RIGHT )
397 tabStyle |= TCS_VERTICAL | TCS_RIGHT;
398
399 // ex style
400 if ( exstyle )
401 {
402 // note that we never want to have the default WS_EX_CLIENTEDGE style
403 // as it looks too ugly for the notebooks
404 *exstyle = 0;
405 }
406
407 return tabStyle;
408 }
409
410 wxNotebook::~wxNotebook()
411 {
412 #if wxUSE_UXTHEME
413 if ( m_hbrBackground )
414 ::DeleteObject((HBRUSH)m_hbrBackground);
415 #endif // wxUSE_UXTHEME
416 }
417
418 // ----------------------------------------------------------------------------
419 // wxNotebook accessors
420 // ----------------------------------------------------------------------------
421
422 size_t wxNotebook::GetPageCount() const
423 {
424 // consistency check
425 wxASSERT( (int)m_pages.Count() == TabCtrl_GetItemCount(GetHwnd()) );
426
427 return m_pages.Count();
428 }
429
430 int wxNotebook::GetRowCount() const
431 {
432 return TabCtrl_GetRowCount(GetHwnd());
433 }
434
435 int wxNotebook::SetSelection(size_t nPage)
436 {
437 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("notebook page out of range") );
438
439 if ( int(nPage) != m_nSelection )
440 {
441 wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId);
442 event.SetSelection(nPage);
443 event.SetOldSelection(m_nSelection);
444 event.SetEventObject(this);
445 if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
446 {
447 // program allows the page change
448 event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
449 (void)GetEventHandler()->ProcessEvent(event);
450
451 TabCtrl_SetCurSel(GetHwnd(), nPage);
452 }
453 }
454
455 return m_nSelection;
456 }
457
458 bool wxNotebook::SetPageText(size_t nPage, const wxString& strText)
459 {
460 wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
461
462 TC_ITEM tcItem;
463 tcItem.mask = TCIF_TEXT;
464 tcItem.pszText = (wxChar *)strText.c_str();
465
466 if ( !HasFlag(wxNB_MULTILINE) )
467 return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
468
469 // multiline - we need to set new page size if a line is added or removed
470 int rows = GetRowCount();
471 bool ret = TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
472
473 if ( ret && rows != GetRowCount() )
474 {
475 const wxRect r = GetPageSize();
476 const size_t count = m_pages.Count();
477 for ( size_t page = 0; page < count; page++ )
478 m_pages[page]->SetSize(r);
479 }
480
481 return ret;
482 }
483
484 wxString wxNotebook::GetPageText(size_t nPage) const
485 {
486 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxEmptyString, wxT("notebook page out of range") );
487
488 wxChar buf[256];
489 TC_ITEM tcItem;
490 tcItem.mask = TCIF_TEXT;
491 tcItem.pszText = buf;
492 tcItem.cchTextMax = WXSIZEOF(buf);
493
494 wxString str;
495 if ( TabCtrl_GetItem(GetHwnd(), nPage, &tcItem) )
496 str = tcItem.pszText;
497
498 return str;
499 }
500
501 int wxNotebook::GetPageImage(size_t nPage) const
502 {
503 wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("notebook page out of range") );
504
505 TC_ITEM tcItem;
506 tcItem.mask = TCIF_IMAGE;
507
508 return TabCtrl_GetItem(GetHwnd(), nPage, &tcItem) ? tcItem.iImage : wxNOT_FOUND;
509 }
510
511 bool wxNotebook::SetPageImage(size_t nPage, int nImage)
512 {
513 wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
514
515 TC_ITEM tcItem;
516 tcItem.mask = TCIF_IMAGE;
517 tcItem.iImage = nImage;
518
519 return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
520 }
521
522 void wxNotebook::SetImageList(wxImageList* imageList)
523 {
524 wxNotebookBase::SetImageList(imageList);
525
526 if ( imageList )
527 {
528 (void) TabCtrl_SetImageList(GetHwnd(), (HIMAGELIST)imageList->GetHIMAGELIST());
529 }
530 }
531
532 // ----------------------------------------------------------------------------
533 // wxNotebook size settings
534 // ----------------------------------------------------------------------------
535
536 wxRect wxNotebook::GetPageSize() const
537 {
538 wxRect r;
539
540 RECT rc;
541 ::GetClientRect(GetHwnd(), &rc);
542
543 // This check is to work around a bug in TabCtrl_AdjustRect which will
544 // cause a crash on win2k or on XP with themes disabled if either
545 // wxNB_MULTILINE is used or tabs are placed on a side, if the rectangle
546 // is too small.
547 //
548 // The value of 20 is chosen arbitrarily but seems to work
549 if ( rc.right > 20 && rc.bottom > 20 )
550 {
551 TabCtrl_AdjustRect(GetHwnd(), false, &rc);
552
553 wxCopyRECTToRect(rc, r);
554 }
555
556 return r;
557 }
558
559 void wxNotebook::SetPageSize(const wxSize& size)
560 {
561 // transform the page size into the notebook size
562 RECT rc;
563 rc.left =
564 rc.top = 0;
565 rc.right = size.x;
566 rc.bottom = size.y;
567
568 TabCtrl_AdjustRect(GetHwnd(), true, &rc);
569
570 // and now set it
571 SetSize(rc.right - rc.left, rc.bottom - rc.top);
572 }
573
574 void wxNotebook::SetPadding(const wxSize& padding)
575 {
576 TabCtrl_SetPadding(GetHwnd(), padding.x, padding.y);
577 }
578
579 // Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH
580 // style.
581 void wxNotebook::SetTabSize(const wxSize& sz)
582 {
583 ::SendMessage(GetHwnd(), TCM_SETITEMSIZE, 0, MAKELPARAM(sz.x, sz.y));
584 }
585
586 wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
587 {
588 wxSize sizeTotal = sizePage;
589
590 // We need to make getting tab size part of the wxWidgets API.
591 wxSize tabSize;
592 if (GetPageCount() > 0)
593 {
594 RECT rect;
595 TabCtrl_GetItemRect((HWND) GetHWND(), 0, & rect);
596 tabSize.x = rect.right - rect.left;
597 tabSize.y = rect.bottom - rect.top;
598 }
599 if ( HasFlag(wxBK_LEFT) || HasFlag(wxBK_RIGHT) )
600 {
601 sizeTotal.x += tabSize.x + 7;
602 sizeTotal.y += 7;
603 }
604 else
605 {
606 sizeTotal.x += 7;
607 sizeTotal.y += tabSize.y + 7;
608 }
609
610 return sizeTotal;
611 }
612
613 void wxNotebook::AdjustPageSize(wxNotebookPage *page)
614 {
615 wxCHECK_RET( page, _T("NULL page in wxNotebook::AdjustPageSize") );
616
617 const wxRect r = GetPageSize();
618 if ( !r.IsEmpty() )
619 {
620 page->SetSize(r);
621 }
622 }
623
624 // ----------------------------------------------------------------------------
625 // wxNotebook operations
626 // ----------------------------------------------------------------------------
627
628 // remove one page from the notebook, without deleting
629 wxNotebookPage *wxNotebook::DoRemovePage(size_t nPage)
630 {
631 wxNotebookPage *pageRemoved = wxNotebookBase::DoRemovePage(nPage);
632 if ( !pageRemoved )
633 return NULL;
634
635 TabCtrl_DeleteItem(GetHwnd(), nPage);
636
637 if ( m_pages.IsEmpty() )
638 {
639 // no selection any more, the notebook becamse empty
640 m_nSelection = -1;
641 }
642 else // notebook still not empty
643 {
644 int selNew = TabCtrl_GetCurSel(GetHwnd());
645 if (selNew != -1)
646 {
647 // No selection change, just refresh the current selection.
648 // Because it could be that the slection index changed
649 // we need to update it.
650 // Note: this does not mean the selection it self changed.
651 m_nSelection = selNew;
652 m_pages[m_nSelection]->Refresh();
653 }
654 else if (int(nPage) == m_nSelection)
655 {
656 // The selection was deleted.
657
658 // Determine new selection.
659 if (m_nSelection == int(GetPageCount()))
660 selNew = m_nSelection - 1;
661 else
662 selNew = m_nSelection;
663
664 // m_nSelection must be always valid so reset it before calling
665 // SetSelection()
666 m_nSelection = -1;
667 SetSelection(selNew);
668 }
669 else
670 {
671 wxFAIL; // Windows did not behave ok.
672 }
673 }
674
675 return pageRemoved;
676 }
677
678 // remove all pages
679 bool wxNotebook::DeleteAllPages()
680 {
681 size_t nPageCount = GetPageCount();
682 size_t nPage;
683 for ( nPage = 0; nPage < nPageCount; nPage++ )
684 delete m_pages[nPage];
685
686 m_pages.Clear();
687
688 TabCtrl_DeleteAllItems(GetHwnd());
689
690 m_nSelection = -1;
691
692 InvalidateBestSize();
693 return true;
694 }
695
696 // same as AddPage() but does it at given position
697 bool wxNotebook::InsertPage(size_t nPage,
698 wxNotebookPage *pPage,
699 const wxString& strText,
700 bool bSelect,
701 int imageId)
702 {
703 wxCHECK_MSG( pPage != NULL, false, _T("NULL page in wxNotebook::InsertPage") );
704 wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false,
705 _T("invalid index in wxNotebook::InsertPage") );
706
707 wxASSERT_MSG( pPage->GetParent() == this,
708 _T("notebook pages must have notebook as parent") );
709
710 // add a new tab to the control
711 // ----------------------------
712
713 // init all fields to 0
714 TC_ITEM tcItem;
715 wxZeroMemory(tcItem);
716
717 // set the image, if any
718 if ( imageId != -1 )
719 {
720 tcItem.mask |= TCIF_IMAGE;
721 tcItem.iImage = imageId;
722 }
723
724 // and the text
725 if ( !strText.empty() )
726 {
727 tcItem.mask |= TCIF_TEXT;
728 tcItem.pszText = (wxChar *)strText.c_str(); // const_cast
729 }
730
731 // hide the page: unless it is selected, it shouldn't be shown (and if it
732 // is selected it will be shown later)
733 HWND hwnd = GetWinHwnd(pPage);
734 SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);
735
736 // this updates internal flag too -- otherwise it would get out of sync
737 // with the real state
738 pPage->Show(false);
739
740
741 // fit the notebook page to the tab control's display area: this should be
742 // done before adding it to the notebook or TabCtrl_InsertItem() will
743 // change the notebooks size itself!
744 AdjustPageSize(pPage);
745
746 // finally do insert it
747 if ( TabCtrl_InsertItem(GetHwnd(), nPage, &tcItem) == -1 )
748 {
749 wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str());
750
751 return false;
752 }
753
754 // succeeded: save the pointer to the page
755 m_pages.Insert(pPage, nPage);
756
757 // we may need to adjust the size again if the notebook size changed:
758 // normally this only happens for the first page we add (the tabs which
759 // hadn't been there before are now shown) but for a multiline notebook it
760 // can happen for any page at all as a new row could have been started
761 if ( m_pages.GetCount() == 1 || HasFlag(wxNB_MULTILINE) )
762 {
763 AdjustPageSize(pPage);
764 }
765
766 // now deal with the selection
767 // ---------------------------
768
769 // if the inserted page is before the selected one, we must update the
770 // index of the selected page
771 if ( int(nPage) <= m_nSelection )
772 {
773 // one extra page added
774 m_nSelection++;
775 }
776
777 // some page should be selected: either this one or the first one if there
778 // is still no selection
779 int selNew = -1;
780 if ( bSelect )
781 selNew = nPage;
782 else if ( m_nSelection == -1 )
783 selNew = 0;
784
785 if ( selNew != -1 )
786 SetSelection(selNew);
787
788 InvalidateBestSize();
789
790 return true;
791 }
792
793 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
794 {
795 TC_HITTESTINFO hitTestInfo;
796 hitTestInfo.pt.x = pt.x;
797 hitTestInfo.pt.y = pt.y;
798 int item = TabCtrl_HitTest(GetHwnd(), &hitTestInfo);
799
800 if ( flags )
801 {
802 *flags = 0;
803
804 if ((hitTestInfo.flags & TCHT_NOWHERE) == TCHT_NOWHERE)
805 *flags |= wxNB_HITTEST_NOWHERE;
806 if ((hitTestInfo.flags & TCHT_ONITEM) == TCHT_ONITEM)
807 *flags |= wxNB_HITTEST_ONITEM;
808 if ((hitTestInfo.flags & TCHT_ONITEMICON) == TCHT_ONITEMICON)
809 *flags |= wxNB_HITTEST_ONICON;
810 if ((hitTestInfo.flags & TCHT_ONITEMLABEL) == TCHT_ONITEMLABEL)
811 *flags |= wxNB_HITTEST_ONLABEL;
812 }
813
814 return item;
815 }
816
817 // ----------------------------------------------------------------------------
818 // flicker-less notebook redraw
819 // ----------------------------------------------------------------------------
820
821 #if USE_NOTEBOOK_ANTIFLICKER
822
823 // wnd proc for the spin button
824 LRESULT APIENTRY _EXPORT wxNotebookSpinBtnWndProc(HWND hwnd,
825 UINT message,
826 WPARAM wParam,
827 LPARAM lParam)
828 {
829 if ( message == WM_ERASEBKGND )
830 return 0;
831
832 return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebookSpinBtn,
833 hwnd, message, wParam, lParam);
834 }
835
836 LRESULT APIENTRY _EXPORT wxNotebookWndProc(HWND hwnd,
837 UINT message,
838 WPARAM wParam,
839 LPARAM lParam)
840 {
841 return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebook,
842 hwnd, message, wParam, lParam);
843 }
844
845 void wxNotebook::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
846 {
847 // do nothing here
848 }
849
850 void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event))
851 {
852 wxPaintDC dc(this);
853 wxMemoryDC memdc;
854 RECT rc;
855 ::GetClientRect(GetHwnd(), &rc);
856 wxBitmap bmp(rc.right, rc.bottom);
857 memdc.SelectObject(bmp);
858
859 // if there is no special brush just use the solid background colour
860 #if wxUSE_UXTHEME
861 HBRUSH hbr = (HBRUSH)m_hbrBackground;
862 #else
863 HBRUSH hbr = 0;
864 #endif
865 wxBrush brush;
866 if ( !hbr )
867 {
868 brush = wxBrush(GetBackgroundColour());
869 hbr = GetHbrushOf(brush);
870 }
871
872 ::FillRect(GetHdcOf(memdc), &rc, hbr);
873
874 MSWDefWindowProc(WM_PAINT, (WPARAM)memdc.GetHDC(), 0);
875
876 dc.Blit(0, 0, rc.right, rc.bottom, &memdc, 0, 0);
877 }
878
879 #endif // USE_NOTEBOOK_ANTIFLICKER
880
881 // ----------------------------------------------------------------------------
882 // wxNotebook callbacks
883 // ----------------------------------------------------------------------------
884
885 void wxNotebook::OnSize(wxSizeEvent& event)
886 {
887 if ( GetPageCount() == 0 )
888 {
889 // Prevents droppings on resize, but does cause some flicker
890 // when there are no pages.
891 Refresh();
892 event.Skip();
893 return;
894 }
895 #ifndef __WXWINCE__
896 else
897 {
898 // Without this, we can sometimes get droppings at the edges
899 // of a notebook, for example a notebook in a splitter window.
900 // This needs to be reconciled with the RefreshRect calls
901 // at the end of this function, which weren't enough to prevent
902 // the droppings.
903
904 wxSize sz = GetClientSize();
905
906 // Refresh right side
907 wxRect rect(sz.x-4, 0, 4, sz.y);
908 RefreshRect(rect);
909
910 // Refresh bottom side
911 rect = wxRect(0, sz.y-4, sz.x, 4);
912 RefreshRect(rect);
913
914 // Refresh left side
915 rect = wxRect(0, 0, 4, sz.y);
916 RefreshRect(rect);
917 }
918 #endif // !__WXWINCE__
919
920 // fit all the notebook pages to the tab control's display area
921
922 RECT rc;
923 rc.left = rc.top = 0;
924 GetSize((int *)&rc.right, (int *)&rc.bottom);
925
926 // save the total size, we'll use it below
927 int widthNbook = rc.right - rc.left,
928 heightNbook = rc.bottom - rc.top;
929
930 // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
931 // returns completely false values for multiline tab controls after the tabs
932 // are added but before getting the first WM_SIZE (off by ~50 pixels, see
933 //
934 // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
935 //
936 // and the only work around I could find was this ugly hack... without it
937 // simply toggling the "multiline" checkbox in the notebook sample resulted
938 // in a noticeable page displacement
939 if ( HasFlag(wxNB_MULTILINE) )
940 {
941 // avoid an infinite recursion: we get another notification too!
942 static bool s_isInOnSize = false;
943
944 if ( !s_isInOnSize )
945 {
946 s_isInOnSize = true;
947 SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED,
948 MAKELPARAM(rc.right, rc.bottom));
949 s_isInOnSize = false;
950 }
951 }
952
953 #if wxUSE_UXTHEME
954 // background bitmap size has changed, update the brush using it too
955 UpdateBgBrush();
956 #endif // wxUSE_UXTHEME
957
958 TabCtrl_AdjustRect(GetHwnd(), false, &rc);
959
960 int width = rc.right - rc.left,
961 height = rc.bottom - rc.top;
962 size_t nCount = m_pages.Count();
963 for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
964 wxNotebookPage *pPage = m_pages[nPage];
965 pPage->SetSize(rc.left, rc.top, width, height);
966 }
967
968
969 // unless we had already repainted everything, we now need to refresh
970 if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
971 {
972 // invalidate areas not covered by pages
973 RefreshRect(wxRect(0, 0, widthNbook, rc.top), false);
974 RefreshRect(wxRect(0, rc.top, rc.left, height), false);
975 RefreshRect(wxRect(0, rc.bottom, widthNbook, heightNbook - rc.bottom),
976 false);
977 RefreshRect(wxRect(rc.right, rc.top, widthNbook - rc.right, height),
978 false);
979 }
980
981 #if USE_NOTEBOOK_ANTIFLICKER
982 // subclass the spin control used by the notebook to scroll pages to
983 // prevent it from flickering on resize
984 if ( !m_hasSubclassedUpdown )
985 {
986 // iterate over all child windows to find spin button
987 for ( HWND child = ::GetWindow(GetHwnd(), GW_CHILD);
988 child;
989 child = ::GetWindow(child, GW_HWNDNEXT) )
990 {
991 wxWindow *childWindow = wxFindWinFromHandle((WXHWND)child);
992
993 // see if it exists, if no wxWindow found then assume it's the spin
994 // btn
995 if ( !childWindow )
996 {
997 // subclass the spin button to override WM_ERASEBKGND
998 if ( !gs_wndprocNotebookSpinBtn )
999 gs_wndprocNotebookSpinBtn = (WXFARPROC)wxGetWindowProc(child);
1000
1001 wxSetWindowProc(child, wxNotebookSpinBtnWndProc);
1002 m_hasSubclassedUpdown = true;
1003 break;
1004 }
1005 }
1006 }
1007 #endif // USE_NOTEBOOK_ANTIFLICKER
1008
1009 event.Skip();
1010 }
1011
1012 void wxNotebook::OnSelChange(wxNotebookEvent& event)
1013 {
1014 // is it our tab control?
1015 if ( event.GetEventObject() == this )
1016 {
1017 int sel = event.GetOldSelection();
1018 if ( sel != -1 )
1019 m_pages[sel]->Show(false);
1020
1021 sel = event.GetSelection();
1022 if ( sel != -1 )
1023 {
1024 wxNotebookPage *pPage = m_pages[sel];
1025 pPage->Show(true);
1026 }
1027
1028 // Changing the page should give the focus to it but, as per bug report
1029 // http://sf.net/tracker/index.php?func=detail&aid=1150659&group_id=9863&atid=109863,
1030 // we should not set the focus to it directly since it erroneously
1031 // selects radio buttons and breaks keyboard handling for a notebook's
1032 // scroll buttons. So give focus to the notebook and not the page.
1033
1034 // but don't do this is the notebook is hidden
1035 if ( ::IsWindowVisible(GetHwnd()) )
1036 SetFocus();
1037
1038 m_nSelection = sel;
1039 }
1040
1041 // we want to give others a chance to process this message as well
1042 event.Skip();
1043 }
1044
1045 bool wxNotebook::MSWTranslateMessage(WXMSG *wxmsg)
1046 {
1047 const MSG * const msg = (MSG *)wxmsg;
1048
1049 // intercept TAB, CTRL+TAB and CTRL+SHIFT+TAB for processing by wxNotebook.
1050 // TAB will be passed to the currently selected page, CTRL+TAB and
1051 // CTRL+SHIFT+TAB will be processed by the notebook itself. do not
1052 // intercept SHIFT+TAB. This goes to the parent of the notebook which will
1053 // process it.
1054 if ( msg->message == WM_KEYDOWN && msg->wParam == VK_TAB &&
1055 msg->hwnd == GetHwnd() &&
1056 (wxIsCtrlDown() || !wxIsShiftDown()) )
1057 {
1058 return MSWProcessMessage(wxmsg);
1059 }
1060
1061 return false;
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