src/msw/notebook.cpp

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