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 = -1;
 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(size_t newsel)
 461 {
 462     if ( m_nSelection != -1 )
 463         m_pages[m_nSelection]->Show(false);
 464
 465     if ( newsel != -1 )
 466     {
 467         wxNotebookPage *pPage = m_pages[newsel];
 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 = newsel;
 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 ( int(nPage) != 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 : wxNOT_FOUND;
 549 }
 550
 551 bool wxNotebook::SetPageImage(size_t nPage, int nImage)
 552 {
 553     wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
 554
 555     TC_ITEM tcItem;
 556     tcItem.mask = TCIF_IMAGE;
 557     tcItem.iImage = nImage;
 558
 559     return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0;
 560 }
 561
 562 void wxNotebook::SetImageList(wxImageList* imageList)
 563 {
 564     wxNotebookBase::SetImageList(imageList);
 565
 566     if ( imageList )
 567     {
 568         (void) TabCtrl_SetImageList(GetHwnd(), (HIMAGELIST)imageList->GetHIMAGELIST());
 569     }
 570 }
 571
 572 // ----------------------------------------------------------------------------
 573 // wxNotebook size settings
 574 // ----------------------------------------------------------------------------
 575
 576 wxRect wxNotebook::GetPageSize() const
 577 {
 578     wxRect r;
 579
 580     RECT rc;
 581     ::GetClientRect(GetHwnd(), &rc);
 582
 583     // This check is to work around a bug in TabCtrl_AdjustRect which will
 584     // cause a crash on win2k or on XP with themes disabled if either
 585     // wxNB_MULTILINE is used or tabs are placed on a side, if the rectangle
 586     // is too small.
 587     //
 588     // The value of 20 is chosen arbitrarily but seems to work
 589     if ( rc.right > 20 && rc.bottom > 20 )
 590     {
 591         TabCtrl_AdjustRect(GetHwnd(), false, &rc);
 592
 593         wxCopyRECTToRect(rc, r);
 594     }
 595
 596     return r;
 597 }
 598
 599 void wxNotebook::SetPageSize(const wxSize& size)
 600 {
 601     // transform the page size into the notebook size
 602     RECT rc;
 603     rc.left =
 604     rc.top = 0;
 605     rc.right = size.x;
 606     rc.bottom = size.y;
 607
 608     TabCtrl_AdjustRect(GetHwnd(), true, &rc);
 609
 610     // and now set it
 611     SetSize(rc.right - rc.left, rc.bottom - rc.top);
 612 }
 613
 614 void wxNotebook::SetPadding(const wxSize& padding)
 615 {
 616     TabCtrl_SetPadding(GetHwnd(), padding.x, padding.y);
 617 }
 618
 619 // Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH
 620 // style.
 621 void wxNotebook::SetTabSize(const wxSize& sz)
 622 {
 623     ::SendMessage(GetHwnd(), TCM_SETITEMSIZE, 0, MAKELPARAM(sz.x, sz.y));
 624 }
 625
 626 wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
 627 {
 628     // we can't use TabCtrl_AdjustRect here because it only works for wxNB_TOP
 629     wxSize sizeTotal = sizePage;
 630
 631     wxSize tabSize;
 632     if ( GetPageCount() > 0 )
 633     {
 634         RECT rect;
 635         TabCtrl_GetItemRect(GetHwnd(), 0, &rect);
 636         tabSize.x = rect.right - rect.left;
 637         tabSize.y = rect.bottom - rect.top;
 638     }
 639
 640     // add an extra margin in both directions
 641     const int MARGIN = 8;
 642     if ( IsVertical() )
 643     {
 644         sizeTotal.x += MARGIN;
 645         sizeTotal.y += tabSize.y + MARGIN;
 646     }
 647     else // horizontal layout
 648     {
 649         sizeTotal.x += tabSize.x + MARGIN;
 650         sizeTotal.y += MARGIN;
 651     }
 652
 653     return sizeTotal;
 654 }
 655
 656 void wxNotebook::AdjustPageSize(wxNotebookPage *page)
 657 {
 658     wxCHECK_RET( page, _T("NULL page in wxNotebook::AdjustPageSize") );
 659
 660     const wxRect r = GetPageSize();
 661     if ( !r.IsEmpty() )
 662     {
 663         page->SetSize(r);
 664     }
 665 }
 666
 667 // ----------------------------------------------------------------------------
 668 // wxNotebook operations
 669 // ----------------------------------------------------------------------------
 670
 671 // remove one page from the notebook, without deleting
 672 wxNotebookPage *wxNotebook::DoRemovePage(size_t nPage)
 673 {
 674     wxNotebookPage *pageRemoved = wxNotebookBase::DoRemovePage(nPage);
 675     if ( !pageRemoved )
 676         return NULL;
 677
 678     TabCtrl_DeleteItem(GetHwnd(), nPage);
 679
 680     if ( m_pages.IsEmpty() )
 681     {
 682         // no selection any more, the notebook becamse empty
 683         m_nSelection = -1;
 684     }
 685     else // notebook still not empty
 686     {
 687         int selNew = TabCtrl_GetCurSel(GetHwnd());
 688         if (selNew != -1)
 689         {
 690             // No selection change, just refresh the current selection.
 691             // Because it could be that the slection index changed
 692             // we need to update it.
 693             // Note: this does not mean the selection it self changed.
 694             m_nSelection = selNew;
 695             m_pages[m_nSelection]->Refresh();
 696         }
 697         else if (int(nPage) == m_nSelection)
 698         {
 699             // The selection was deleted.
 700
 701             // Determine new selection.
 702             if (m_nSelection == int(GetPageCount()))
 703                 selNew = m_nSelection - 1;
 704             else
 705                 selNew = m_nSelection;
 706
 707             // m_nSelection must be always valid so reset it before calling
 708             // SetSelection()
 709             m_nSelection = -1;
 710             SetSelection(selNew);
 711         }
 712         else
 713         {
 714             wxFAIL; // Windows did not behave ok.
 715         }
 716     }
 717
 718     return pageRemoved;
 719 }
 720
 721 // remove all pages
 722 bool wxNotebook::DeleteAllPages()
 723 {
 724     size_t nPageCount = GetPageCount();
 725     size_t nPage;
 726     for ( nPage = 0; nPage < nPageCount; nPage++ )
 727         delete m_pages[nPage];
 728
 729     m_pages.Clear();
 730
 731     TabCtrl_DeleteAllItems(GetHwnd());
 732
 733     m_nSelection = -1;
 734
 735     InvalidateBestSize();
 736     return true;
 737 }
 738
 739 // same as AddPage() but does it at given position
 740 bool wxNotebook::InsertPage(size_t nPage,
 741                             wxNotebookPage *pPage,
 742                             const wxString& strText,
 743                             bool bSelect,
 744                             int imageId)
 745 {
 746     wxCHECK_MSG( pPage != NULL, false, _T("NULL page in wxNotebook::InsertPage") );
 747     wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false,
 748                  _T("invalid index in wxNotebook::InsertPage") );
 749
 750     wxASSERT_MSG( pPage->GetParent() == this,
 751                     _T("notebook pages must have notebook as parent") );
 752
 753     // add a new tab to the control
 754     // ----------------------------
 755
 756     // init all fields to 0
 757     TC_ITEM tcItem;
 758     wxZeroMemory(tcItem);
 759
 760     // set the image, if any
 761     if ( imageId != -1 )
 762     {
 763         tcItem.mask |= TCIF_IMAGE;
 764         tcItem.iImage  = imageId;
 765     }
 766
 767     // and the text
 768     if ( !strText.empty() )
 769     {
 770         tcItem.mask |= TCIF_TEXT;
 771         tcItem.pszText = (wxChar *)strText.c_str(); // const_cast
 772     }
 773
 774     // hide the page: unless it is selected, it shouldn't be shown (and if it
 775     // is selected it will be shown later)
 776     HWND hwnd = GetWinHwnd(pPage);
 777     SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);
 778
 779     // this updates internal flag too -- otherwise it would get out of sync
 780     // with the real state
 781     pPage->Show(false);
 782
 783
 784     // fit the notebook page to the tab control's display area: this should be
 785     // done before adding it to the notebook or TabCtrl_InsertItem() will
 786     // change the notebooks size itself!
 787     AdjustPageSize(pPage);
 788
 789     // finally do insert it
 790     if ( TabCtrl_InsertItem(GetHwnd(), nPage, &tcItem) == -1 )
 791     {
 792         wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str());
 793
 794         return false;
 795     }
 796
 797     // need to update the bg brush when the first page is added
 798     // so the first panel gets the correct themed background
 799     if ( m_pages.empty() )
 800     {
 801         UpdateBgBrush();
 802     }
 803
 804     // succeeded: save the pointer to the page
 805     m_pages.Insert(pPage, nPage);
 806
 807     // we may need to adjust the size again if the notebook size changed:
 808     // normally this only happens for the first page we add (the tabs which
 809     // hadn't been there before are now shown) but for a multiline notebook it
 810     // can happen for any page at all as a new row could have been started
 811     if ( m_pages.GetCount() == 1 || HasFlag(wxNB_MULTILINE) )
 812     {
 813         AdjustPageSize(pPage);
 814     }
 815
 816     // now deal with the selection
 817     // ---------------------------
 818
 819     // if the inserted page is before the selected one, we must update the
 820     // index of the selected page
 821     if ( int(nPage) <= m_nSelection )
 822     {
 823         // one extra page added
 824         m_nSelection++;
 825     }
 826
 827     // some page should be selected: either this one or the first one if there
 828     // is still no selection
 829     int selNew = -1;
 830     if ( bSelect )
 831         selNew = nPage;
 832     else if ( m_nSelection == -1 )
 833         selNew = 0;
 834
 835     if ( selNew != -1 )
 836         SetSelection(selNew);
 837
 838     InvalidateBestSize();
 839
 840     return true;
 841 }
 842
 843 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
 844 {
 845     TC_HITTESTINFO hitTestInfo;
 846     hitTestInfo.pt.x = pt.x;
 847     hitTestInfo.pt.y = pt.y;
 848     int item = TabCtrl_HitTest(GetHwnd(), &hitTestInfo);
 849
 850     if ( flags )
 851     {
 852         *flags = 0;
 853
 854         if ((hitTestInfo.flags & TCHT_NOWHERE) == TCHT_NOWHERE)
 855             *flags |= wxBK_HITTEST_NOWHERE;
 856         if ((hitTestInfo.flags & TCHT_ONITEM) == TCHT_ONITEM)
 857             *flags |= wxBK_HITTEST_ONITEM;
 858         if ((hitTestInfo.flags & TCHT_ONITEMICON) == TCHT_ONITEMICON)
 859             *flags |= wxBK_HITTEST_ONICON;
 860         if ((hitTestInfo.flags & TCHT_ONITEMLABEL) == TCHT_ONITEMLABEL)
 861             *flags |= wxBK_HITTEST_ONLABEL;
 862         if ( item == wxNOT_FOUND && GetPageSize().Contains(pt) )
 863             *flags |= wxBK_HITTEST_ONPAGE;
 864     }
 865
 866     return item;
 867 }
 868
 869 // ----------------------------------------------------------------------------
 870 // flicker-less notebook redraw
 871 // ----------------------------------------------------------------------------
 872
 873 #if USE_NOTEBOOK_ANTIFLICKER
 874
 875 // wnd proc for the spin button
 876 LRESULT APIENTRY _EXPORT wxNotebookSpinBtnWndProc(HWND hwnd,
 877                                                   UINT message,
 878                                                   WPARAM wParam,
 879                                                   LPARAM lParam)
 880 {
 881     if ( message == WM_ERASEBKGND )
 882         return 0;
 883
 884     return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebookSpinBtn,
 885                             hwnd, message, wParam, lParam);
 886 }
 887
 888 LRESULT APIENTRY _EXPORT wxNotebookWndProc(HWND hwnd,
 889                                            UINT message,
 890                                            WPARAM wParam,
 891                                            LPARAM lParam)
 892 {
 893     return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebook,
 894                             hwnd, message, wParam, lParam);
 895 }
 896
 897 void wxNotebook::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
 898 {
 899     // do nothing here
 900 }
 901
 902 void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event))
 903 {
 904     wxPaintDC dc(this);
 905     wxMemoryDC memdc;
 906     RECT rc;
 907     ::GetClientRect(GetHwnd(), &rc);
 908     wxBitmap bmp(rc.right, rc.bottom);
 909     memdc.SelectObject(bmp);
 910
 911     // if there is no special brush just use the solid background colour
 912 #if wxUSE_UXTHEME
 913     HBRUSH hbr = (HBRUSH)m_hbrBackground;
 914 #else
 915     HBRUSH hbr = 0;
 916 #endif
 917     wxBrush brush;
 918     if ( !hbr )
 919     {
 920         brush = wxBrush(GetBackgroundColour());
 921         hbr = GetHbrushOf(brush);
 922     }
 923
 924     ::FillRect(GetHdcOf(memdc), &rc, hbr);
 925
 926     MSWDefWindowProc(WM_PAINT, (WPARAM)memdc.GetHDC(), 0);
 927
 928     dc.Blit(0, 0, rc.right, rc.bottom, &memdc, 0, 0);
 929 }
 930
 931 #endif // USE_NOTEBOOK_ANTIFLICKER
 932
 933 // ----------------------------------------------------------------------------
 934 // wxNotebook callbacks
 935 // ----------------------------------------------------------------------------
 936
 937 void wxNotebook::OnSize(wxSizeEvent& event)
 938 {
 939     if ( GetPageCount() == 0 )
 940     {
 941         // Prevents droppings on resize, but does cause some flicker
 942         // when there are no pages.
 943         Refresh();
 944         event.Skip();
 945         return;
 946     }
 947 #ifndef __WXWINCE__
 948     else
 949     {
 950         // Without this, we can sometimes get droppings at the edges
 951         // of a notebook, for example a notebook in a splitter window.
 952         // This needs to be reconciled with the RefreshRect calls
 953         // at the end of this function, which weren't enough to prevent
 954         // the droppings.
 955
 956         wxSize sz = GetClientSize();
 957
 958         // Refresh right side
 959         wxRect rect(sz.x-4, 0, 4, sz.y);
 960         RefreshRect(rect);
 961
 962         // Refresh bottom side
 963         rect = wxRect(0, sz.y-4, sz.x, 4);
 964         RefreshRect(rect);
 965
 966         // Refresh left side
 967         rect = wxRect(0, 0, 4, sz.y);
 968         RefreshRect(rect);
 969     }
 970 #endif // !__WXWINCE__
 971
 972     // fit all the notebook pages to the tab control's display area
 973
 974     RECT rc;
 975     rc.left = rc.top = 0;
 976     GetSize((int *)&rc.right, (int *)&rc.bottom);
 977
 978     // save the total size, we'll use it below
 979     int widthNbook = rc.right - rc.left,
 980         heightNbook = rc.bottom - rc.top;
 981
 982     // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
 983     // returns completely false values for multiline tab controls after the tabs
 984     // are added but before getting the first WM_SIZE (off by ~50 pixels, see
 985     //
 986     // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
 987     //
 988     // and the only work around I could find was this ugly hack... without it
 989     // simply toggling the "multiline" checkbox in the notebook sample resulted
 990     // in a noticeable page displacement
 991     if ( HasFlag(wxNB_MULTILINE) )
 992     {
 993         // avoid an infinite recursion: we get another notification too!
 994         static bool s_isInOnSize = false;
 995
 996         if ( !s_isInOnSize )
 997         {
 998             s_isInOnSize = true;
 999             SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED,
1000                     MAKELPARAM(rc.right, rc.bottom));
1001             s_isInOnSize = false;
1002         }
1003     }
1004
1005 #if wxUSE_UXTHEME
1006     // background bitmap size has changed, update the brush using it too
1007     UpdateBgBrush();
1008 #endif // wxUSE_UXTHEME
1009
1010     TabCtrl_AdjustRect(GetHwnd(), false, &rc);
1011
1012     int width = rc.right - rc.left,
1013         height = rc.bottom - rc.top;
1014     size_t nCount = m_pages.Count();
1015     for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
1016         wxNotebookPage *pPage = m_pages[nPage];
1017         pPage->SetSize(rc.left, rc.top, width, height);
1018     }
1019
1020
1021     // unless we had already repainted everything, we now need to refresh
1022     if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
1023     {
1024         // invalidate areas not covered by pages
1025         RefreshRect(wxRect(0, 0, widthNbook, rc.top), false);
1026         RefreshRect(wxRect(0, rc.top, rc.left, height), false);
1027         RefreshRect(wxRect(0, rc.bottom, widthNbook, heightNbook - rc.bottom),
1028                     false);
1029         RefreshRect(wxRect(rc.right, rc.top, widthNbook - rc.right, height),
1030                     false);
1031     }
1032
1033 #if USE_NOTEBOOK_ANTIFLICKER
1034     // subclass the spin control used by the notebook to scroll pages to
1035     // prevent it from flickering on resize
1036     if ( !m_hasSubclassedUpdown )
1037     {
1038         // iterate over all child windows to find spin button
1039         for ( HWND child = ::GetWindow(GetHwnd(), GW_CHILD);
1040               child;
1041               child = ::GetWindow(child, GW_HWNDNEXT) )
1042         {
1043             wxWindow *childWindow = wxFindWinFromHandle((WXHWND)child);
1044
1045             // see if it exists, if no wxWindow found then assume it's the spin
1046             // btn
1047             if ( !childWindow )
1048             {
1049                 // subclass the spin button to override WM_ERASEBKGND
1050                 if ( !gs_wndprocNotebookSpinBtn )
1051                     gs_wndprocNotebookSpinBtn = (WXFARPROC)wxGetWindowProc(child);
1052
1053                 wxSetWindowProc(child, wxNotebookSpinBtnWndProc);
1054                 m_hasSubclassedUpdown = true;
1055                 break;
1056             }
1057         }
1058     }
1059 #endif // USE_NOTEBOOK_ANTIFLICKER
1060
1061     event.Skip();
1062 }
1063
1064 void wxNotebook::OnSelChange(wxNotebookEvent& event)
1065 {
1066     // is it our tab control?
1067     if ( event.GetEventObject() == this )
1068     {
1069         UpdateSelection(event.GetSelection());
1070     }
1071
1072     // we want to give others a chance to process this message as well
1073     event.Skip();
1074 }
1075
1076 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
1077 {
1078     if ( event.IsWindowChange() ) {
1079         // change pages
1080         AdvanceSelection(event.GetDirection());
1081     }
1082     else {
1083         // we get this event in 3 cases
1084         //
1085         // a) one of our pages might have generated it because the user TABbed
1086         // out from it in which case we should propagate the event upwards and
1087         // our parent will take care of setting the focus to prev/next sibling
1088         //
1089         // or
1090         //
1091         // b) the parent panel wants to give the focus to us so that we
1092         // forward it to our selected page. We can't deal with this in
1093         // OnSetFocus() because we don't know which direction the focus came
1094         // from in this case and so can't choose between setting the focus to
1095         // first or last panel child
1096         //
1097         // or
1098         //
1099         // c) we ourselves (see MSWTranslateMessage) generated the event
1100         //
1101         wxWindow * const parent = GetParent();
1102
1103         // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
1104         const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
1105         const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
1106
1107         if ( isFromParent || isFromSelf )
1108         {
1109             // no, it doesn't come from child, case (b) or (c): forward to a
1110             // page but only if direction is backwards (TAB) or from ourselves,
1111             if ( m_nSelection != -1 &&
1112                     (!event.GetDirection() || isFromSelf) )
1113             {
1114                 // so that the page knows that the event comes from it's parent
1115                 // and is being propagated downwards
1116                 event.SetEventObject(this);
1117
1118                 wxWindow *page = m_pages[m_nSelection];
1119                 if ( !page->GetEventHandler()->ProcessEvent(event) )
1120                 {
1121                     page->SetFocus();
1122                 }
1123                 //else: page manages focus inside it itself
1124             }
1125             else // otherwise set the focus to the notebook itself
1126             {
1127                 SetFocus();
1128             }
1129         }
1130         else
1131         {
1132             // it comes from our child, case (a), pass to the parent, but only
1133             // if the direction is forwards. Otherwise set the focus to the
1134             // notebook itself. The notebook is always the 'first' control of a
1135             // page.
1136             if ( !event.GetDirection() )
1137             {
1138                 SetFocus();
1139             }
1140             else if ( parent )
1141             {
1142                 event.SetCurrentFocus(this);
1143                 parent->GetEventHandler()->ProcessEvent(event);
1144             }
1145         }
1146     }
1147 }
1148
1149 #if wxUSE_UXTHEME
1150
1151 bool wxNotebook::DoDrawBackground(WXHDC hDC, wxWindow *child)
1152 {
1153     wxUxThemeHandle theme(child ? child : this, L"TAB");
1154     if ( !theme )
1155         return false;
1156
1157     // get the notebook client rect (we're not interested in drawing tabs
1158     // themselves)
1159     wxRect r = GetPageSize();
1160     if ( r.IsEmpty() )
1161         return false;
1162
1163     RECT rc;
1164     wxCopyRectToRECT(r, rc);
1165
1166     // map rect to the coords of the window we're drawing in
1167     if ( child )
1168         ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1169
1170     // we have the content area (page size), but we need to draw all of the
1171     // background for it to be aligned correctly
1172     wxUxThemeEngine::Get()->GetThemeBackgroundExtent
1173                             (
1174                                 theme,
1175                                 (HDC) hDC,
1176                                 9 /* TABP_PANE */,
1177                                 0,
1178                                 &rc,
1179                                 &rc
1180                             );
1181     wxUxThemeEngine::Get()->DrawThemeBackground
1182                             (
1183                                 theme,
1184                                 (HDC) hDC,
1185                                 9 /* TABP_PANE */,
1186                                 0,
1187                                 &rc,
1188                                 NULL
1189                             );
1190
1191     return true;
1192 }
1193
1194 WXHBRUSH wxNotebook::QueryBgBitmap()
1195 {
1196     wxRect r = GetPageSize();
1197     if ( r.IsEmpty() )
1198         return 0;
1199
1200     WindowHDC hDC(GetHwnd());
1201     MemoryHDC hDCMem(hDC);
1202     CompatibleBitmap hBmp(hDC, r.x + r.width, r.y + r.height);
1203
1204     SelectInHDC selectBmp(hDCMem, hBmp);
1205
1206     if ( !DoDrawBackground((WXHDC)(HDC)hDCMem) )
1207         return 0;
1208
1209     return (WXHBRUSH)::CreatePatternBrush(hBmp);
1210 }
1211
1212 void wxNotebook::UpdateBgBrush()
1213 {
1214     if ( m_hbrBackground )
1215         ::DeleteObject((HBRUSH)m_hbrBackground);
1216
1217     if ( !m_hasBgCol && wxUxThemeEngine::GetIfActive() )
1218     {
1219         m_hbrBackground = QueryBgBitmap();
1220     }
1221     else // no themes or we've got user-defined solid colour
1222     {
1223         m_hbrBackground = NULL;
1224     }
1225 }
1226
1227 WXHBRUSH wxNotebook::MSWGetBgBrushForChild(WXHDC hDC, WXHWND hWnd)
1228 {
1229     if ( m_hbrBackground )
1230     {
1231         // before drawing with the background brush, we need to position it
1232         // correctly
1233         RECT rc;
1234         ::GetWindowRect((HWND)hWnd, &rc);
1235
1236         ::MapWindowPoints(NULL, GetHwnd(), (POINT *)&rc, 1);
1237
1238         if ( !::SetBrushOrgEx((HDC)hDC, -rc.left, -rc.top, NULL) )
1239         {
1240             wxLogLastError(_T("SetBrushOrgEx(notebook bg brush)"));
1241         }
1242
1243         return m_hbrBackground;
1244     }
1245
1246     return wxNotebookBase::MSWGetBgBrushForChild(hDC, hWnd);
1247 }
1248
1249 bool wxNotebook::MSWPrintChild(WXHDC hDC, wxWindow *child)
1250 {
1251     // solid background colour overrides themed background drawing
1252     if ( !UseBgCol() && DoDrawBackground(hDC, child) )
1253         return true;
1254
1255     // If we're using a solid colour (for example if we've switched off
1256     // theming for this notebook), paint it
1257     if (UseBgCol())
1258     {
1259         wxRect r = GetPageSize();
1260         if ( r.IsEmpty() )
1261             return false;
1262
1263         RECT rc;
1264         wxCopyRectToRECT(r, rc);
1265
1266         // map rect to the coords of the window we're drawing in
1267         if ( child )
1268             ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1269
1270         wxBrush brush(GetBackgroundColour());
1271         HBRUSH hbr = GetHbrushOf(brush);
1272
1273         ::FillRect((HDC) hDC, &rc, hbr);
1274
1275         return true;
1276     }
1277
1278     return wxNotebookBase::MSWPrintChild(hDC, child);
1279 }
1280
1281 #endif // wxUSE_UXTHEME
1282
1283 // Windows only: attempts to get colour for UX theme page background
1284 wxColour wxNotebook::GetThemeBackgroundColour() const
1285 {
1286 #if wxUSE_UXTHEME
1287     if (wxUxThemeEngine::Get())
1288     {
1289         wxUxThemeHandle hTheme((wxNotebook*) this, L"TAB");
1290         if (hTheme)
1291         {
1292             // This is total guesswork.
1293             // See PlatformSDK\Include\Tmschema.h for values
1294             COLORREF themeColor;
1295             wxUxThemeEngine::Get()->GetThemeColor(
1296                                         hTheme,
1297                                         10 /* TABP_BODY */,
1298                                         1 /* NORMAL */,
1299                                         3821 /* FILLCOLORHINT */,
1300                                         &themeColor);
1301
1302             /*
1303             [DS] Workaround for WindowBlinds:
1304             Some themes return a near black theme color using FILLCOLORHINT,
1305             this makes notebook pages have an ugly black background and makes
1306             text (usually black) unreadable. Retry again with FILLCOLOR.
1307
1308             This workaround potentially breaks appearance of some themes,
1309             but in practice it already fixes some themes.
1310             */
1311             if (themeColor == 1)
1312             {
1313                 wxUxThemeEngine::Get()->GetThemeColor(
1314                                             hTheme,
1315                                             10 /* TABP_BODY */,
1316                                             1 /* NORMAL */,
1317                                             3802 /* FILLCOLOR */,
1318                                             &themeColor);
1319             }
1320
1321             return wxRGBToColour(themeColor);
1322         }
1323     }
1324 #endif // wxUSE_UXTHEME
1325
1326     return GetBackgroundColour();
1327 }
1328
1329 // ----------------------------------------------------------------------------
1330 // wxNotebook base class virtuals
1331 // ----------------------------------------------------------------------------
1332
1333 #if wxUSE_CONSTRAINTS
1334
1335 // override these 2 functions to do nothing: everything is done in OnSize
1336
1337 void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse))
1338 {
1339   // don't set the sizes of the pages - their correct size is not yet known
1340   wxControl::SetConstraintSizes(false);
1341 }
1342
1343 bool wxNotebook::DoPhase(int WXUNUSED(nPhase))
1344 {
1345   return true;
1346 }
1347
1348 #endif // wxUSE_CONSTRAINTS
1349
1350 // ----------------------------------------------------------------------------
1351 // wxNotebook Windows message handlers
1352 // ----------------------------------------------------------------------------
1353
1354 bool wxNotebook::MSWOnScroll(int orientation, WXWORD nSBCode,
1355                              WXWORD pos, WXHWND control)
1356 {
1357     // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the
1358     // up-down control
1359     if ( control )
1360         return false;
1361
1362     return wxNotebookBase::MSWOnScroll(orientation, nSBCode, pos, control);
1363 }
1364
1365 bool wxNotebook::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM* result)
1366 {
1367   wxNotebookEvent event(wxEVT_NULL, m_windowId);
1368
1369   NMHDR* hdr = (NMHDR *)lParam;
1370   switch ( hdr->code ) {
1371     case TCN_SELCHANGE:
1372       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
1373       break;
1374
1375     case TCN_SELCHANGING:
1376       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING);
1377       break;
1378
1379     default:
1380       return wxControl::MSWOnNotify(idCtrl, lParam, result);
1381   }
1382
1383   event.SetSelection(TabCtrl_GetCurSel(GetHwnd()));
1384   event.SetOldSelection(m_nSelection);
1385   event.SetEventObject(this);
1386   event.SetInt(idCtrl);
1387
1388   bool processed = GetEventHandler()->ProcessEvent(event);
1389   *result = !event.IsAllowed();
1390   return processed;
1391 }
1392
1393 #endif // wxUSE_NOTEBOOK