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     const wxLayoutDirection dir = dc.GetLayoutDirection();
 915     memdc.SetLayoutDirection(dir);
 916
 917     // if there is no special brush just use the solid background colour
 918 #if wxUSE_UXTHEME
 919     HBRUSH hbr = (HBRUSH)m_hbrBackground;
 920 #else
 921     HBRUSH hbr = 0;
 922 #endif
 923     wxBrush brush;
 924     if ( !hbr )
 925     {
 926         brush = wxBrush(GetBackgroundColour());
 927         hbr = GetHbrushOf(brush);
 928     }
 929
 930     ::FillRect(GetHdcOf(memdc), &rc, hbr);
 931
 932     MSWDefWindowProc(WM_PAINT, (WPARAM)memdc.GetHDC(), 0);
 933
 934     // For some reason in RTL mode, source offset has to be -1, otherwise the
 935     // right border (physical) remains unpainted.
 936     const wxCoord ofs = dir == wxLayout_RightToLeft ? -1 : 0;
 937     dc.Blit(ofs, 0, rc.right, rc.bottom, &memdc, ofs, 0);
 938 }
 939
 940 #endif // USE_NOTEBOOK_ANTIFLICKER
 941
 942 // ----------------------------------------------------------------------------
 943 // wxNotebook callbacks
 944 // ----------------------------------------------------------------------------
 945
 946 void wxNotebook::OnSize(wxSizeEvent& event)
 947 {
 948     if ( GetPageCount() == 0 )
 949     {
 950         // Prevents droppings on resize, but does cause some flicker
 951         // when there are no pages.
 952         Refresh();
 953         event.Skip();
 954         return;
 955     }
 956 #ifndef __WXWINCE__
 957     else
 958     {
 959         // Without this, we can sometimes get droppings at the edges
 960         // of a notebook, for example a notebook in a splitter window.
 961         // This needs to be reconciled with the RefreshRect calls
 962         // at the end of this function, which weren't enough to prevent
 963         // the droppings.
 964
 965         wxSize sz = GetClientSize();
 966
 967         // Refresh right side
 968         wxRect rect(sz.x-4, 0, 4, sz.y);
 969         RefreshRect(rect);
 970
 971         // Refresh bottom side
 972         rect = wxRect(0, sz.y-4, sz.x, 4);
 973         RefreshRect(rect);
 974
 975         // Refresh left side
 976         rect = wxRect(0, 0, 4, sz.y);
 977         RefreshRect(rect);
 978     }
 979 #endif // !__WXWINCE__
 980
 981     // fit all the notebook pages to the tab control's display area
 982
 983     RECT rc;
 984     rc.left = rc.top = 0;
 985     GetSize((int *)&rc.right, (int *)&rc.bottom);
 986
 987     // save the total size, we'll use it below
 988     int widthNbook = rc.right - rc.left,
 989         heightNbook = rc.bottom - rc.top;
 990
 991     // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
 992     // returns completely false values for multiline tab controls after the tabs
 993     // are added but before getting the first WM_SIZE (off by ~50 pixels, see
 994     //
 995     // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
 996     //
 997     // and the only work around I could find was this ugly hack... without it
 998     // simply toggling the "multiline" checkbox in the notebook sample resulted
 999     // in a noticeable page displacement
1000     if ( HasFlag(wxNB_MULTILINE) )
1001     {
1002         // avoid an infinite recursion: we get another notification too!
1003         static bool s_isInOnSize = false;
1004
1005         if ( !s_isInOnSize )
1006         {
1007             s_isInOnSize = true;
1008             SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED,
1009                     MAKELPARAM(rc.right, rc.bottom));
1010             s_isInOnSize = false;
1011         }
1012     }
1013
1014 #if wxUSE_UXTHEME
1015     // background bitmap size has changed, update the brush using it too
1016     UpdateBgBrush();
1017 #endif // wxUSE_UXTHEME
1018
1019     TabCtrl_AdjustRect(GetHwnd(), false, &rc);
1020
1021     int width = rc.right - rc.left,
1022         height = rc.bottom - rc.top;
1023     size_t nCount = m_pages.Count();
1024     for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
1025         wxNotebookPage *pPage = m_pages[nPage];
1026         pPage->SetSize(rc.left, rc.top, width, height);
1027     }
1028
1029
1030     // unless we had already repainted everything, we now need to refresh
1031     if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
1032     {
1033         // invalidate areas not covered by pages
1034         RefreshRect(wxRect(0, 0, widthNbook, rc.top), false);
1035         RefreshRect(wxRect(0, rc.top, rc.left, height), false);
1036         RefreshRect(wxRect(0, rc.bottom, widthNbook, heightNbook - rc.bottom),
1037                     false);
1038         RefreshRect(wxRect(rc.right, rc.top, widthNbook - rc.right, height),
1039                     false);
1040     }
1041
1042 #if USE_NOTEBOOK_ANTIFLICKER
1043     // subclass the spin control used by the notebook to scroll pages to
1044     // prevent it from flickering on resize
1045     if ( !m_hasSubclassedUpdown )
1046     {
1047         // iterate over all child windows to find spin button
1048         for ( HWND child = ::GetWindow(GetHwnd(), GW_CHILD);
1049               child;
1050               child = ::GetWindow(child, GW_HWNDNEXT) )
1051         {
1052             wxWindow *childWindow = wxFindWinFromHandle((WXHWND)child);
1053
1054             // see if it exists, if no wxWindow found then assume it's the spin
1055             // btn
1056             if ( !childWindow )
1057             {
1058                 // subclass the spin button to override WM_ERASEBKGND
1059                 if ( !gs_wndprocNotebookSpinBtn )
1060                     gs_wndprocNotebookSpinBtn = (WXFARPROC)wxGetWindowProc(child);
1061
1062                 wxSetWindowProc(child, wxNotebookSpinBtnWndProc);
1063                 m_hasSubclassedUpdown = true;
1064                 break;
1065             }
1066         }
1067     }
1068 #endif // USE_NOTEBOOK_ANTIFLICKER
1069
1070     event.Skip();
1071 }
1072
1073 void wxNotebook::OnSelChange(wxNotebookEvent& event)
1074 {
1075     // is it our tab control?
1076     if ( event.GetEventObject() == this )
1077     {
1078         UpdateSelection(event.GetSelection());
1079     }
1080
1081     // we want to give others a chance to process this message as well
1082     event.Skip();
1083 }
1084
1085 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
1086 {
1087     if ( event.IsWindowChange() ) {
1088         // change pages
1089         AdvanceSelection(event.GetDirection());
1090     }
1091     else {
1092         // we get this event in 3 cases
1093         //
1094         // a) one of our pages might have generated it because the user TABbed
1095         // out from it in which case we should propagate the event upwards and
1096         // our parent will take care of setting the focus to prev/next sibling
1097         //
1098         // or
1099         //
1100         // b) the parent panel wants to give the focus to us so that we
1101         // forward it to our selected page. We can't deal with this in
1102         // OnSetFocus() because we don't know which direction the focus came
1103         // from in this case and so can't choose between setting the focus to
1104         // first or last panel child
1105         //
1106         // or
1107         //
1108         // c) we ourselves (see MSWTranslateMessage) generated the event
1109         //
1110         wxWindow * const parent = GetParent();
1111
1112         // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
1113         const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
1114         const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
1115
1116         if ( isFromParent || isFromSelf )
1117         {
1118             // no, it doesn't come from child, case (b) or (c): forward to a
1119             // page but only if direction is backwards (TAB) or from ourselves,
1120             if ( m_nSelection != wxNOT_FOUND &&
1121                     (!event.GetDirection() || isFromSelf) )
1122             {
1123                 // so that the page knows that the event comes from it's parent
1124                 // and is being propagated downwards
1125                 event.SetEventObject(this);
1126
1127                 wxWindow *page = m_pages[m_nSelection];
1128                 if ( !page->GetEventHandler()->ProcessEvent(event) )
1129                 {
1130                     page->SetFocus();
1131                 }
1132                 //else: page manages focus inside it itself
1133             }
1134             else // otherwise set the focus to the notebook itself
1135             {
1136                 SetFocus();
1137             }
1138         }
1139         else
1140         {
1141             // it comes from our child, case (a), pass to the parent, but only
1142             // if the direction is forwards. Otherwise set the focus to the
1143             // notebook itself. The notebook is always the 'first' control of a
1144             // page.
1145             if ( !event.GetDirection() )
1146             {
1147                 SetFocus();
1148             }
1149             else if ( parent )
1150             {
1151                 event.SetCurrentFocus(this);
1152                 parent->GetEventHandler()->ProcessEvent(event);
1153             }
1154         }
1155     }
1156 }
1157
1158 #if wxUSE_UXTHEME
1159
1160 bool wxNotebook::DoDrawBackground(WXHDC hDC, wxWindow *child)
1161 {
1162     wxUxThemeHandle theme(child ? child : this, L"TAB");
1163     if ( !theme )
1164         return false;
1165
1166     // get the notebook client rect (we're not interested in drawing tabs
1167     // themselves)
1168     wxRect r = GetPageSize();
1169     if ( r.IsEmpty() )
1170         return false;
1171
1172     RECT rc;
1173     wxCopyRectToRECT(r, rc);
1174
1175     // map rect to the coords of the window we're drawing in
1176     if ( child )
1177         ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1178
1179     // we have the content area (page size), but we need to draw all of the
1180     // background for it to be aligned correctly
1181     wxUxThemeEngine::Get()->GetThemeBackgroundExtent
1182                             (
1183                                 theme,
1184                                 (HDC) hDC,
1185                                 9 /* TABP_PANE */,
1186                                 0,
1187                                 &rc,
1188                                 &rc
1189                             );
1190     wxUxThemeEngine::Get()->DrawThemeBackground
1191                             (
1192                                 theme,
1193                                 (HDC) hDC,
1194                                 9 /* TABP_PANE */,
1195                                 0,
1196                                 &rc,
1197                                 NULL
1198                             );
1199
1200     return true;
1201 }
1202
1203 WXHBRUSH wxNotebook::QueryBgBitmap()
1204 {
1205     wxRect r = GetPageSize();
1206     if ( r.IsEmpty() )
1207         return 0;
1208
1209     WindowHDC hDC(GetHwnd());
1210     MemoryHDC hDCMem(hDC);
1211     CompatibleBitmap hBmp(hDC, r.x + r.width, r.y + r.height);
1212
1213     SelectInHDC selectBmp(hDCMem, hBmp);
1214
1215     if ( !DoDrawBackground((WXHDC)(HDC)hDCMem) )
1216         return 0;
1217
1218     return (WXHBRUSH)::CreatePatternBrush(hBmp);
1219 }
1220
1221 void wxNotebook::UpdateBgBrush()
1222 {
1223     if ( m_hbrBackground )
1224         ::DeleteObject((HBRUSH)m_hbrBackground);
1225
1226     if ( !m_hasBgCol && wxUxThemeEngine::GetIfActive() )
1227     {
1228         m_hbrBackground = QueryBgBitmap();
1229     }
1230     else // no themes or we've got user-defined solid colour
1231     {
1232         m_hbrBackground = NULL;
1233     }
1234 }
1235
1236 WXHBRUSH wxNotebook::MSWGetBgBrushForChild(WXHDC hDC, WXHWND hWnd)
1237 {
1238     if ( m_hbrBackground )
1239     {
1240         // before drawing with the background brush, we need to position it
1241         // correctly
1242         RECT rc;
1243         ::GetWindowRect((HWND)hWnd, &rc);
1244
1245         ::MapWindowPoints(NULL, GetHwnd(), (POINT *)&rc, 1);
1246
1247         if ( !::SetBrushOrgEx((HDC)hDC, -rc.left, -rc.top, NULL) )
1248         {
1249             wxLogLastError(_T("SetBrushOrgEx(notebook bg brush)"));
1250         }
1251
1252         return m_hbrBackground;
1253     }
1254
1255     return wxNotebookBase::MSWGetBgBrushForChild(hDC, hWnd);
1256 }
1257
1258 bool wxNotebook::MSWPrintChild(WXHDC hDC, wxWindow *child)
1259 {
1260     // solid background colour overrides themed background drawing
1261     if ( !UseBgCol() && DoDrawBackground(hDC, child) )
1262         return true;
1263
1264     // If we're using a solid colour (for example if we've switched off
1265     // theming for this notebook), paint it
1266     if (UseBgCol())
1267     {
1268         wxRect r = GetPageSize();
1269         if ( r.IsEmpty() )
1270             return false;
1271
1272         RECT rc;
1273         wxCopyRectToRECT(r, rc);
1274
1275         // map rect to the coords of the window we're drawing in
1276         if ( child )
1277             ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1278
1279         wxBrush brush(GetBackgroundColour());
1280         HBRUSH hbr = GetHbrushOf(brush);
1281
1282         ::FillRect((HDC) hDC, &rc, hbr);
1283
1284         return true;
1285     }
1286
1287     return wxNotebookBase::MSWPrintChild(hDC, child);
1288 }
1289
1290 #endif // wxUSE_UXTHEME
1291
1292 // Windows only: attempts to get colour for UX theme page background
1293 wxColour wxNotebook::GetThemeBackgroundColour() const
1294 {
1295 #if wxUSE_UXTHEME
1296     if (wxUxThemeEngine::Get())
1297     {
1298         wxUxThemeHandle hTheme((wxNotebook*) this, L"TAB");
1299         if (hTheme)
1300         {
1301             // This is total guesswork.
1302             // See PlatformSDK\Include\Tmschema.h for values
1303             COLORREF themeColor;
1304             wxUxThemeEngine::Get()->GetThemeColor(
1305                                         hTheme,
1306                                         10 /* TABP_BODY */,
1307                                         1 /* NORMAL */,
1308                                         3821 /* FILLCOLORHINT */,
1309                                         &themeColor);
1310
1311             /*
1312             [DS] Workaround for WindowBlinds:
1313             Some themes return a near black theme color using FILLCOLORHINT,
1314             this makes notebook pages have an ugly black background and makes
1315             text (usually black) unreadable. Retry again with FILLCOLOR.
1316
1317             This workaround potentially breaks appearance of some themes,
1318             but in practice it already fixes some themes.
1319             */
1320             if (themeColor == 1)
1321             {
1322                 wxUxThemeEngine::Get()->GetThemeColor(
1323                                             hTheme,
1324                                             10 /* TABP_BODY */,
1325                                             1 /* NORMAL */,
1326                                             3802 /* FILLCOLOR */,
1327                                             &themeColor);
1328             }
1329
1330             return wxRGBToColour(themeColor);
1331         }
1332     }
1333 #endif // wxUSE_UXTHEME
1334
1335     return GetBackgroundColour();
1336 }
1337
1338 // ----------------------------------------------------------------------------
1339 // wxNotebook base class virtuals
1340 // ----------------------------------------------------------------------------
1341
1342 #if wxUSE_CONSTRAINTS
1343
1344 // override these 2 functions to do nothing: everything is done in OnSize
1345
1346 void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse))
1347 {
1348   // don't set the sizes of the pages - their correct size is not yet known
1349   wxControl::SetConstraintSizes(false);
1350 }
1351
1352 bool wxNotebook::DoPhase(int WXUNUSED(nPhase))
1353 {
1354   return true;
1355 }
1356
1357 #endif // wxUSE_CONSTRAINTS
1358
1359 // ----------------------------------------------------------------------------
1360 // wxNotebook Windows message handlers
1361 // ----------------------------------------------------------------------------
1362
1363 bool wxNotebook::MSWOnScroll(int orientation, WXWORD nSBCode,
1364                              WXWORD pos, WXHWND control)
1365 {
1366     // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the
1367     // up-down control
1368     if ( control )
1369         return false;
1370
1371     return wxNotebookBase::MSWOnScroll(orientation, nSBCode, pos, control);
1372 }
1373
1374 bool wxNotebook::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM* result)
1375 {
1376   wxNotebookEvent event(wxEVT_NULL, m_windowId);
1377
1378   NMHDR* hdr = (NMHDR *)lParam;
1379   switch ( hdr->code ) {
1380     case TCN_SELCHANGE:
1381       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
1382       break;
1383
1384     case TCN_SELCHANGING:
1385       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING);
1386       break;
1387
1388     default:
1389       return wxControl::MSWOnNotify(idCtrl, lParam, result);
1390   }
1391
1392   event.SetSelection(TabCtrl_GetCurSel(GetHwnd()));
1393   event.SetOldSelection(m_nSelection);
1394   event.SetEventObject(this);
1395   event.SetInt(idCtrl);
1396
1397   bool processed = GetEventHandler()->ProcessEvent(event);
1398   *result = !event.IsAllowed();
1399   return processed;
1400 }
1401
1402 #endif // wxUSE_NOTEBOOK