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