src/msw/notebook.cpp

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