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


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