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