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