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


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