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