src/msw/notebook.cpp

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