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