src/msw/notebook.cpp

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