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     TabCtrl_DeleteItem(GetHwnd(), nPage);
 692
 693     if ( m_pages.IsEmpty() )
 694     {
 695         // no selection any more, the notebook becamse empty
 696         m_nSelection = wxNOT_FOUND;
 697     }
 698     else // notebook still not empty
 699     {
 700         int selNew = TabCtrl_GetCurSel(GetHwnd());
 701         if ( selNew != wxNOT_FOUND )
 702         {
 703             // No selection change, just refresh the current selection.
 704             // Because it could be that the slection index changed
 705             // we need to update it.
 706             // Note: this does not mean the selection it self changed.
 707             m_nSelection = selNew;
 708             m_pages[m_nSelection]->Refresh();
 709         }
 710         else if (int(nPage) == m_nSelection)
 711         {
 712             // The selection was deleted.
 713
 714             // Determine new selection.
 715             if (m_nSelection == int(GetPageCount()))
 716                 selNew = m_nSelection - 1;
 717             else
 718                 selNew = m_nSelection;
 719
 720             // m_nSelection must be always valid so reset it before calling
 721             // SetSelection()
 722             m_nSelection = wxNOT_FOUND;
 723             SetSelection(selNew);
 724         }
 725         else
 726         {
 727             wxFAIL; // Windows did not behave ok.
 728         }
 729     }
 730
 731     return pageRemoved;
 732 }
 733
 734 // remove all pages
 735 bool wxNotebook::DeleteAllPages()
 736 {
 737     size_t nPageCount = GetPageCount();
 738     size_t nPage;
 739     for ( nPage = 0; nPage < nPageCount; nPage++ )
 740         delete m_pages[nPage];
 741
 742     m_pages.Clear();
 743
 744     TabCtrl_DeleteAllItems(GetHwnd());
 745
 746     m_nSelection = wxNOT_FOUND;
 747
 748     InvalidateBestSize();
 749     return true;
 750 }
 751
 752 // same as AddPage() but does it at given position
 753 bool wxNotebook::InsertPage(size_t nPage,
 754                             wxNotebookPage *pPage,
 755                             const wxString& strText,
 756                             bool bSelect,
 757                             int imageId)
 758 {
 759     wxCHECK_MSG( pPage != NULL, false, wxT("NULL page in wxNotebook::InsertPage") );
 760     wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false,
 761                  wxT("invalid index in wxNotebook::InsertPage") );
 762
 763     wxASSERT_MSG( pPage->GetParent() == this,
 764                     wxT("notebook pages must have notebook as parent") );
 765
 766     // add a new tab to the control
 767     // ----------------------------
 768
 769     // init all fields to 0
 770     TC_ITEM tcItem;
 771     wxZeroMemory(tcItem);
 772
 773     // set the image, if any
 774     if ( imageId != -1 )
 775     {
 776         tcItem.mask |= TCIF_IMAGE;
 777         tcItem.iImage  = imageId;
 778     }
 779
 780     // and the text
 781     if ( !strText.empty() )
 782     {
 783         tcItem.mask |= TCIF_TEXT;
 784         tcItem.pszText = (wxChar *)strText.wx_str(); // const_cast
 785     }
 786
 787     // hide the page: unless it is selected, it shouldn't be shown (and if it
 788     // is selected it will be shown later)
 789     HWND hwnd = GetWinHwnd(pPage);
 790     SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);
 791
 792     // this updates internal flag too -- otherwise it would get out of sync
 793     // with the real state
 794     pPage->Show(false);
 795
 796
 797     // fit the notebook page to the tab control's display area: this should be
 798     // done before adding it to the notebook or TabCtrl_InsertItem() will
 799     // change the notebooks size itself!
 800     AdjustPageSize(pPage);
 801
 802     // finally do insert it
 803     if ( TabCtrl_InsertItem(GetHwnd(), nPage, &tcItem) == -1 )
 804     {
 805         wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str());
 806
 807         return false;
 808     }
 809
 810     // need to update the bg brush when the first page is added
 811     // so the first panel gets the correct themed background
 812     if ( m_pages.empty() )
 813     {
 814 #if wxUSE_UXTHEME
 815         UpdateBgBrush();
 816 #endif // wxUSE_UXTHEME
 817     }
 818
 819     // succeeded: save the pointer to the page
 820     m_pages.Insert(pPage, nPage);
 821
 822     // also ensure that the notebook background is used for its pages by making
 823     // them transparent: this ensures that MSWGetBgBrush() queries the notebook
 824     // for the background brush to be used for erasing them
 825     if ( wxPanel *panel = wxDynamicCast(pPage, wxPanel) )
 826     {
 827         panel->MSWSetTransparentBackground();
 828     }
 829
 830     // we may need to adjust the size again if the notebook size changed:
 831     // normally this only happens for the first page we add (the tabs which
 832     // hadn't been there before are now shown) but for a multiline notebook it
 833     // can happen for any page at all as a new row could have been started
 834     if ( m_pages.GetCount() == 1 || HasFlag(wxNB_MULTILINE) )
 835     {
 836         AdjustPageSize(pPage);
 837     }
 838
 839     // now deal with the selection
 840     // ---------------------------
 841
 842     // if the inserted page is before the selected one, we must update the
 843     // index of the selected page
 844     if ( int(nPage) <= m_nSelection )
 845     {
 846         // one extra page added
 847         m_nSelection++;
 848     }
 849
 850     // some page should be selected: either this one or the first one if there
 851     // is still no selection
 852     int selNew = wxNOT_FOUND;
 853     if ( bSelect )
 854         selNew = nPage;
 855     else if ( m_nSelection == wxNOT_FOUND )
 856         selNew = 0;
 857
 858     if ( selNew != wxNOT_FOUND )
 859         SetSelection(selNew);
 860
 861     InvalidateBestSize();
 862
 863     return true;
 864 }
 865
 866 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
 867 {
 868     TC_HITTESTINFO hitTestInfo;
 869     hitTestInfo.pt.x = pt.x;
 870     hitTestInfo.pt.y = pt.y;
 871     int item = TabCtrl_HitTest(GetHwnd(), &hitTestInfo);
 872
 873     if ( flags )
 874     {
 875         *flags = 0;
 876
 877         if ((hitTestInfo.flags & TCHT_NOWHERE) == TCHT_NOWHERE)
 878             *flags |= wxBK_HITTEST_NOWHERE;
 879         if ((hitTestInfo.flags & TCHT_ONITEM) == TCHT_ONITEM)
 880             *flags |= wxBK_HITTEST_ONITEM;
 881         if ((hitTestInfo.flags & TCHT_ONITEMICON) == TCHT_ONITEMICON)
 882             *flags |= wxBK_HITTEST_ONICON;
 883         if ((hitTestInfo.flags & TCHT_ONITEMLABEL) == TCHT_ONITEMLABEL)
 884             *flags |= wxBK_HITTEST_ONLABEL;
 885         if ( item == wxNOT_FOUND && GetPageSize().Contains(pt) )
 886             *flags |= wxBK_HITTEST_ONPAGE;
 887     }
 888
 889     return item;
 890 }
 891
 892 // ----------------------------------------------------------------------------
 893 // flicker-less notebook redraw
 894 // ----------------------------------------------------------------------------
 895
 896 #if USE_NOTEBOOK_ANTIFLICKER
 897
 898 // wnd proc for the spin button
 899 LRESULT APIENTRY _EXPORT wxNotebookSpinBtnWndProc(HWND hwnd,
 900                                                   UINT message,
 901                                                   WPARAM wParam,
 902                                                   LPARAM lParam)
 903 {
 904     if ( message == WM_ERASEBKGND )
 905         return 0;
 906
 907     return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebookSpinBtn,
 908                             hwnd, message, wParam, lParam);
 909 }
 910
 911 LRESULT APIENTRY _EXPORT wxNotebookWndProc(HWND hwnd,
 912                                            UINT message,
 913                                            WPARAM wParam,
 914                                            LPARAM lParam)
 915 {
 916     return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebook,
 917                             hwnd, message, wParam, lParam);
 918 }
 919
 920 void wxNotebook::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
 921 {
 922     // do nothing here
 923 }
 924
 925 void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event))
 926 {
 927     wxPaintDC dc(this);
 928     wxMemoryDC memdc;
 929     RECT rc;
 930     ::GetClientRect(GetHwnd(), &rc);
 931     wxBitmap bmp(rc.right, rc.bottom);
 932     memdc.SelectObject(bmp);
 933
 934     const wxLayoutDirection dir = dc.GetLayoutDirection();
 935     memdc.SetLayoutDirection(dir);
 936
 937     // if there is no special brush just use the solid background colour
 938 #if wxUSE_UXTHEME
 939     HBRUSH hbr = (HBRUSH)m_hbrBackground;
 940 #else
 941     HBRUSH hbr = 0;
 942 #endif
 943     wxBrush brush;
 944     if ( !hbr )
 945     {
 946         brush = wxBrush(GetBackgroundColour());
 947         hbr = GetHbrushOf(brush);
 948     }
 949
 950     wxMSWDCImpl *impl = (wxMSWDCImpl*) memdc.GetImpl();
 951
 952     ::FillRect(GetHdcOf(*impl), &rc, hbr);
 953
 954     MSWDefWindowProc(WM_PAINT, (WPARAM)(impl->GetHDC()), 0);
 955
 956     // For some reason in RTL mode, source offset has to be -1, otherwise the
 957     // right border (physical) remains unpainted.
 958     const wxCoord ofs = dir == wxLayout_RightToLeft ? -1 : 0;
 959     dc.Blit(ofs, 0, rc.right, rc.bottom, &memdc, ofs, 0);
 960 }
 961
 962 #endif // USE_NOTEBOOK_ANTIFLICKER
 963
 964 // ----------------------------------------------------------------------------
 965 // wxNotebook callbacks
 966 // ----------------------------------------------------------------------------
 967
 968 void wxNotebook::OnSize(wxSizeEvent& event)
 969 {
 970     if ( GetPageCount() == 0 )
 971     {
 972         // Prevents droppings on resize, but does cause some flicker
 973         // when there are no pages.
 974         Refresh();
 975         event.Skip();
 976         return;
 977     }
 978 #ifndef __WXWINCE__
 979     else
 980     {
 981         // Without this, we can sometimes get droppings at the edges
 982         // of a notebook, for example a notebook in a splitter window.
 983         // This needs to be reconciled with the RefreshRect calls
 984         // at the end of this function, which weren't enough to prevent
 985         // the droppings.
 986
 987         wxSize sz = GetClientSize();
 988
 989         // Refresh right side
 990         wxRect rect(sz.x-4, 0, 4, sz.y);
 991         RefreshRect(rect);
 992
 993         // Refresh bottom side
 994         rect = wxRect(0, sz.y-4, sz.x, 4);
 995         RefreshRect(rect);
 996
 997         // Refresh left side
 998         rect = wxRect(0, 0, 4, sz.y);
 999         RefreshRect(rect);
1000     }
1001 #endif // !__WXWINCE__
1002
1003     // fit all the notebook pages to the tab control's display area
1004
1005     RECT rc;
1006     rc.left = rc.top = 0;
1007     GetSize((int *)&rc.right, (int *)&rc.bottom);
1008
1009     // save the total size, we'll use it below
1010     int widthNbook = rc.right - rc.left,
1011         heightNbook = rc.bottom - rc.top;
1012
1013     // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
1014     // returns completely false values for multiline tab controls after the tabs
1015     // are added but before getting the first WM_SIZE (off by ~50 pixels, see
1016     //
1017     // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
1018     //
1019     // and the only work around I could find was this ugly hack... without it
1020     // simply toggling the "multiline" checkbox in the notebook sample resulted
1021     // in a noticeable page displacement
1022     if ( HasFlag(wxNB_MULTILINE) )
1023     {
1024         // avoid an infinite recursion: we get another notification too!
1025         static bool s_isInOnSize = false;
1026
1027         if ( !s_isInOnSize )
1028         {
1029             s_isInOnSize = true;
1030             SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED,
1031                     MAKELPARAM(rc.right, rc.bottom));
1032             s_isInOnSize = false;
1033         }
1034
1035         // The best size depends on the number of rows of tabs, which can
1036         // change when the notepad is resized.
1037         InvalidateBestSize();
1038     }
1039
1040 #if wxUSE_UXTHEME
1041     // background bitmap size has changed, update the brush using it too
1042     UpdateBgBrush();
1043 #endif // wxUSE_UXTHEME
1044
1045     TabCtrl_AdjustRect(GetHwnd(), false, &rc);
1046
1047     int width = rc.right - rc.left,
1048         height = rc.bottom - rc.top;
1049     size_t nCount = m_pages.Count();
1050     for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
1051         wxNotebookPage *pPage = m_pages[nPage];
1052         pPage->SetSize(rc.left, rc.top, width, height);
1053     }
1054
1055
1056     // unless we had already repainted everything, we now need to refresh
1057     if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
1058     {
1059         // invalidate areas not covered by pages
1060         RefreshRect(wxRect(0, 0, widthNbook, rc.top), false);
1061         RefreshRect(wxRect(0, rc.top, rc.left, height), false);
1062         RefreshRect(wxRect(0, rc.bottom, widthNbook, heightNbook - rc.bottom),
1063                     false);
1064         RefreshRect(wxRect(rc.right, rc.top, widthNbook - rc.right, height),
1065                     false);
1066     }
1067
1068 #if USE_NOTEBOOK_ANTIFLICKER
1069     // subclass the spin control used by the notebook to scroll pages to
1070     // prevent it from flickering on resize
1071     if ( !m_hasSubclassedUpdown )
1072     {
1073         // iterate over all child windows to find spin button
1074         for ( HWND child = ::GetWindow(GetHwnd(), GW_CHILD);
1075               child;
1076               child = ::GetWindow(child, GW_HWNDNEXT) )
1077         {
1078             wxWindow *childWindow = wxFindWinFromHandle((WXHWND)child);
1079
1080             // see if it exists, if no wxWindow found then assume it's the spin
1081             // btn
1082             if ( !childWindow )
1083             {
1084                 // subclass the spin button to override WM_ERASEBKGND
1085                 if ( !gs_wndprocNotebookSpinBtn )
1086                     gs_wndprocNotebookSpinBtn = (WXFARPROC)wxGetWindowProc(child);
1087
1088                 wxSetWindowProc(child, wxNotebookSpinBtnWndProc);
1089                 m_hasSubclassedUpdown = true;
1090                 break;
1091             }
1092         }
1093     }
1094 #endif // USE_NOTEBOOK_ANTIFLICKER
1095
1096     event.Skip();
1097 }
1098
1099 void wxNotebook::OnSelChange(wxBookCtrlEvent& event)
1100 {
1101     // is it our tab control?
1102     if ( event.GetEventObject() == this )
1103     {
1104         UpdateSelection(event.GetSelection());
1105     }
1106
1107     // we want to give others a chance to process this message as well
1108     event.Skip();
1109 }
1110
1111 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
1112 {
1113     if ( event.IsWindowChange() ) {
1114         // change pages
1115         AdvanceSelection(event.GetDirection());
1116     }
1117     else {
1118         // we get this event in 3 cases
1119         //
1120         // a) one of our pages might have generated it because the user TABbed
1121         // out from it in which case we should propagate the event upwards and
1122         // our parent will take care of setting the focus to prev/next sibling
1123         //
1124         // or
1125         //
1126         // b) the parent panel wants to give the focus to us so that we
1127         // forward it to our selected page. We can't deal with this in
1128         // OnSetFocus() because we don't know which direction the focus came
1129         // from in this case and so can't choose between setting the focus to
1130         // first or last panel child
1131         //
1132         // or
1133         //
1134         // c) we ourselves (see MSWTranslateMessage) generated the event
1135         //
1136         wxWindow * const parent = GetParent();
1137
1138         // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
1139         const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
1140         const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
1141         const bool isForward = event.GetDirection();
1142
1143         if ( isFromSelf && !isForward )
1144         {
1145             // focus is currently on notebook tab and should leave
1146             // it backwards (Shift-TAB)
1147             event.SetCurrentFocus(this);
1148             parent->HandleWindowEvent(event);
1149         }
1150         else if ( isFromParent || isFromSelf )
1151         {
1152             // no, it doesn't come from child, case (b) or (c): forward to a
1153             // page but only if entering notebook page (i.e. direction is
1154             // backwards (Shift-TAB) comething from out-of-notebook, or
1155             // direction is forward (TAB) from ourselves),
1156             if ( m_nSelection != wxNOT_FOUND &&
1157                     (!event.GetDirection() || isFromSelf) )
1158             {
1159                 // so that the page knows that the event comes from it's parent
1160                 // and is being propagated downwards
1161                 event.SetEventObject(this);
1162
1163                 wxWindow *page = m_pages[m_nSelection];
1164                 if ( !page->HandleWindowEvent(event) )
1165                 {
1166                     page->SetFocus();
1167                 }
1168                 //else: page manages focus inside it itself
1169             }
1170             else // otherwise set the focus to the notebook itself
1171             {
1172                 SetFocus();
1173             }
1174         }
1175         else
1176         {
1177             // it comes from our child, case (a), pass to the parent, but only
1178             // if the direction is forwards. Otherwise set the focus to the
1179             // notebook itself. The notebook is always the 'first' control of a
1180             // page.
1181             if ( !isForward )
1182             {
1183                 SetFocus();
1184             }
1185             else if ( parent )
1186             {
1187                 event.SetCurrentFocus(this);
1188                 parent->HandleWindowEvent(event);
1189             }
1190         }
1191     }
1192 }
1193
1194 #if wxUSE_UXTHEME
1195
1196 bool wxNotebook::DoDrawBackground(WXHDC hDC, wxWindow *child)
1197 {
1198     wxUxThemeHandle theme(child ? child : this, L"TAB");
1199     if ( !theme )
1200         return false;
1201
1202     // get the notebook client rect (we're not interested in drawing tabs
1203     // themselves)
1204     wxRect r = GetPageSize();
1205     if ( r.IsEmpty() )
1206         return false;
1207
1208     RECT rc;
1209     wxCopyRectToRECT(r, rc);
1210
1211     // map rect to the coords of the window we're drawing in
1212     if ( child )
1213         ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1214
1215     // we have the content area (page size), but we need to draw all of the
1216     // background for it to be aligned correctly
1217     wxUxThemeEngine::Get()->GetThemeBackgroundExtent
1218                             (
1219                                 theme,
1220                                 (HDC) hDC,
1221                                 9 /* TABP_PANE */,
1222                                 0,
1223                                 &rc,
1224                                 &rc
1225                             );
1226     wxUxThemeEngine::Get()->DrawThemeBackground
1227                             (
1228                                 theme,
1229                                 (HDC) hDC,
1230                                 9 /* TABP_PANE */,
1231                                 0,
1232                                 &rc,
1233                                 NULL
1234                             );
1235
1236     return true;
1237 }
1238
1239 WXHBRUSH wxNotebook::QueryBgBitmap()
1240 {
1241     wxRect r = GetPageSize();
1242     if ( r.IsEmpty() )
1243         return 0;
1244
1245     WindowHDC hDC(GetHwnd());
1246     MemoryHDC hDCMem(hDC);
1247     CompatibleBitmap hBmp(hDC, r.x + r.width, r.y + r.height);
1248
1249     SelectInHDC selectBmp(hDCMem, hBmp);
1250
1251     if ( !DoDrawBackground((WXHDC)(HDC)hDCMem) )
1252         return 0;
1253
1254     return (WXHBRUSH)::CreatePatternBrush(hBmp);
1255 }
1256
1257 void wxNotebook::UpdateBgBrush()
1258 {
1259     if ( m_hbrBackground )
1260         ::DeleteObject((HBRUSH)m_hbrBackground);
1261
1262     if ( !m_hasBgCol && wxUxThemeEngine::GetIfActive() )
1263     {
1264         m_hbrBackground = QueryBgBitmap();
1265     }
1266     else // no themes or we've got user-defined solid colour
1267     {
1268         m_hbrBackground = NULL;
1269     }
1270 }
1271
1272 WXHBRUSH wxNotebook::MSWGetBgBrushForChild(WXHDC hDC, wxWindow *child)
1273 {
1274     if ( m_hbrBackground )
1275     {
1276         // before drawing with the background brush, we need to position it
1277         // correctly
1278         RECT rc;
1279         ::GetWindowRect(GetHwndOf(child), &rc);
1280
1281         ::MapWindowPoints(NULL, GetHwnd(), (POINT *)&rc, 1);
1282
1283         if ( !::SetBrushOrgEx((HDC)hDC, -rc.left, -rc.top, NULL) )
1284         {
1285             wxLogLastError(wxT("SetBrushOrgEx(notebook bg brush)"));
1286         }
1287
1288         return m_hbrBackground;
1289     }
1290
1291     return wxNotebookBase::MSWGetBgBrushForChild(hDC, child);
1292 }
1293
1294 bool wxNotebook::MSWPrintChild(WXHDC hDC, wxWindow *child)
1295 {
1296     // solid background colour overrides themed background drawing
1297     if ( !UseBgCol() && DoDrawBackground(hDC, child) )
1298         return true;
1299
1300     // If we're using a solid colour (for example if we've switched off
1301     // theming for this notebook), paint it
1302     if (UseBgCol())
1303     {
1304         wxRect r = GetPageSize();
1305         if ( r.IsEmpty() )
1306             return false;
1307
1308         RECT rc;
1309         wxCopyRectToRECT(r, rc);
1310
1311         // map rect to the coords of the window we're drawing in
1312         if ( child )
1313             ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1314
1315         wxBrush brush(GetBackgroundColour());
1316         HBRUSH hbr = GetHbrushOf(brush);
1317
1318         ::FillRect((HDC) hDC, &rc, hbr);
1319
1320         return true;
1321     }
1322
1323     return wxNotebookBase::MSWPrintChild(hDC, child);
1324 }
1325
1326 #endif // wxUSE_UXTHEME
1327
1328 // Windows only: attempts to get colour for UX theme page background
1329 wxColour wxNotebook::GetThemeBackgroundColour() const
1330 {
1331 #if wxUSE_UXTHEME
1332     if (wxUxThemeEngine::Get())
1333     {
1334         wxUxThemeHandle hTheme((wxNotebook*) this, L"TAB");
1335         if (hTheme)
1336         {
1337             // This is total guesswork.
1338             // See PlatformSDK\Include\Tmschema.h for values.
1339             // JACS: can also use 9 (TABP_PANE)
1340             COLORREF themeColor;
1341             bool success = (S_OK == wxUxThemeEngine::Get()->GetThemeColor(
1342                                         hTheme,
1343                                         10 /* TABP_BODY */,
1344                                         1 /* NORMAL */,
1345                                         3821 /* FILLCOLORHINT */,
1346                                         &themeColor));
1347             if (!success)
1348                 return GetBackgroundColour();
1349
1350             /*
1351             [DS] Workaround for WindowBlinds:
1352             Some themes return a near black theme color using FILLCOLORHINT,
1353             this makes notebook pages have an ugly black background and makes
1354             text (usually black) unreadable. Retry again with FILLCOLOR.
1355
1356             This workaround potentially breaks appearance of some themes,
1357             but in practice it already fixes some themes.
1358             */
1359             if (themeColor == 1)
1360             {
1361                 wxUxThemeEngine::Get()->GetThemeColor(
1362                                             hTheme,
1363                                             10 /* TABP_BODY */,
1364                                             1 /* NORMAL */,
1365                                             3802 /* FILLCOLOR */,
1366                                             &themeColor);
1367             }
1368
1369             wxColour colour = wxRGBToColour(themeColor);
1370
1371             // Under Vista, the tab background colour is reported incorrectly.
1372             // So for the default theme at least, hard-code the colour to something
1373             // that will blend in.
1374
1375             static int s_AeroStatus = -1;
1376             if (s_AeroStatus == -1)
1377             {
1378                 WCHAR szwThemeFile[1024];
1379                 WCHAR szwThemeColor[256];
1380                 if (S_OK == wxUxThemeEngine::Get()->GetCurrentThemeName(szwThemeFile, 1024, szwThemeColor, 256, NULL, 0))
1381                 {
1382                     wxString themeFile(szwThemeFile), themeColor(szwThemeColor);
1383                     if (themeFile.Find(wxT("Aero")) != -1 && themeColor == wxT("NormalColor"))
1384                         s_AeroStatus = 1;
1385                     else
1386                         s_AeroStatus = 0;
1387                 }
1388                 else
1389                     s_AeroStatus = 0;
1390             }
1391
1392             if (s_AeroStatus == 1)
1393                 colour = wxColour(255, 255, 255);
1394
1395             return colour;
1396         }
1397     }
1398 #endif // wxUSE_UXTHEME
1399
1400     return GetBackgroundColour();
1401 }
1402
1403 // ----------------------------------------------------------------------------
1404 // wxNotebook base class virtuals
1405 // ----------------------------------------------------------------------------
1406
1407 #if wxUSE_CONSTRAINTS
1408
1409 // override these 2 functions to do nothing: everything is done in OnSize
1410
1411 void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse))
1412 {
1413   // don't set the sizes of the pages - their correct size is not yet known
1414   wxControl::SetConstraintSizes(false);
1415 }
1416
1417 bool wxNotebook::DoPhase(int WXUNUSED(nPhase))
1418 {
1419   return true;
1420 }
1421
1422 #endif // wxUSE_CONSTRAINTS
1423
1424 // ----------------------------------------------------------------------------
1425 // wxNotebook Windows message handlers
1426 // ----------------------------------------------------------------------------
1427
1428 bool wxNotebook::MSWOnScroll(int orientation, WXWORD nSBCode,
1429                              WXWORD pos, WXHWND control)
1430 {
1431     // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the
1432     // up-down control
1433     if ( control )
1434         return false;
1435
1436     return wxNotebookBase::MSWOnScroll(orientation, nSBCode, pos, control);
1437 }
1438
1439 bool wxNotebook::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM* result)
1440 {
1441   wxBookCtrlEvent event(wxEVT_NULL, m_windowId);
1442
1443   NMHDR* hdr = (NMHDR *)lParam;
1444   switch ( hdr->code ) {
1445     case TCN_SELCHANGE:
1446       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
1447       break;
1448
1449     case TCN_SELCHANGING:
1450       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING);
1451       break;
1452
1453     default:
1454       return wxControl::MSWOnNotify(idCtrl, lParam, result);
1455   }
1456
1457   event.SetSelection(TabCtrl_GetCurSel(GetHwnd()));
1458   event.SetOldSelection(m_nSelection);
1459   event.SetEventObject(this);
1460   event.SetInt(idCtrl);
1461
1462   bool processed = HandleWindowEvent(event);
1463   *result = !event.IsAllowed();
1464   return processed;
1465 }
1466
1467 #endif // wxUSE_NOTEBOOK