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, wxControl)
 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, wxControl,"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, wxControl)
 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     ::FillRect(GetHdcOf(memdc), &rc, hbr);
 949
 950     MSWDefWindowProc(WM_PAINT, (WPARAM)memdc.GetHDC(), 0);
 951
 952     // For some reason in RTL mode, source offset has to be -1, otherwise the
 953     // right border (physical) remains unpainted.
 954     const wxCoord ofs = dir == wxLayout_RightToLeft ? -1 : 0;
 955     dc.Blit(ofs, 0, rc.right, rc.bottom, &memdc, ofs, 0);
 956 }
 957
 958 #endif // USE_NOTEBOOK_ANTIFLICKER
 959
 960 // ----------------------------------------------------------------------------
 961 // wxNotebook callbacks
 962 // ----------------------------------------------------------------------------
 963
 964 void wxNotebook::OnSize(wxSizeEvent& event)
 965 {
 966     if ( GetPageCount() == 0 )
 967     {
 968         // Prevents droppings on resize, but does cause some flicker
 969         // when there are no pages.
 970         Refresh();
 971         event.Skip();
 972         return;
 973     }
 974 #ifndef __WXWINCE__
 975     else
 976     {
 977         // Without this, we can sometimes get droppings at the edges
 978         // of a notebook, for example a notebook in a splitter window.
 979         // This needs to be reconciled with the RefreshRect calls
 980         // at the end of this function, which weren't enough to prevent
 981         // the droppings.
 982
 983         wxSize sz = GetClientSize();
 984
 985         // Refresh right side
 986         wxRect rect(sz.x-4, 0, 4, sz.y);
 987         RefreshRect(rect);
 988
 989         // Refresh bottom side
 990         rect = wxRect(0, sz.y-4, sz.x, 4);
 991         RefreshRect(rect);
 992
 993         // Refresh left side
 994         rect = wxRect(0, 0, 4, sz.y);
 995         RefreshRect(rect);
 996     }
 997 #endif // !__WXWINCE__
 998
 999     // fit all the notebook pages to the tab control's display area
1000
1001     RECT rc;
1002     rc.left = rc.top = 0;
1003     GetSize((int *)&rc.right, (int *)&rc.bottom);
1004
1005     // save the total size, we'll use it below
1006     int widthNbook = rc.right - rc.left,
1007         heightNbook = rc.bottom - rc.top;
1008
1009     // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
1010     // returns completely false values for multiline tab controls after the tabs
1011     // are added but before getting the first WM_SIZE (off by ~50 pixels, see
1012     //
1013     // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
1014     //
1015     // and the only work around I could find was this ugly hack... without it
1016     // simply toggling the "multiline" checkbox in the notebook sample resulted
1017     // in a noticeable page displacement
1018     if ( HasFlag(wxNB_MULTILINE) )
1019     {
1020         // avoid an infinite recursion: we get another notification too!
1021         static bool s_isInOnSize = false;
1022
1023         if ( !s_isInOnSize )
1024         {
1025             s_isInOnSize = true;
1026             SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED,
1027                     MAKELPARAM(rc.right, rc.bottom));
1028             s_isInOnSize = false;
1029         }
1030     }
1031
1032 #if wxUSE_UXTHEME
1033     // background bitmap size has changed, update the brush using it too
1034     UpdateBgBrush();
1035 #endif // wxUSE_UXTHEME
1036
1037     TabCtrl_AdjustRect(GetHwnd(), false, &rc);
1038
1039     int width = rc.right - rc.left,
1040         height = rc.bottom - rc.top;
1041     size_t nCount = m_pages.Count();
1042     for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
1043         wxNotebookPage *pPage = m_pages[nPage];
1044         pPage->SetSize(rc.left, rc.top, width, height);
1045     }
1046
1047
1048     // unless we had already repainted everything, we now need to refresh
1049     if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) )
1050     {
1051         // invalidate areas not covered by pages
1052         RefreshRect(wxRect(0, 0, widthNbook, rc.top), false);
1053         RefreshRect(wxRect(0, rc.top, rc.left, height), false);
1054         RefreshRect(wxRect(0, rc.bottom, widthNbook, heightNbook - rc.bottom),
1055                     false);
1056         RefreshRect(wxRect(rc.right, rc.top, widthNbook - rc.right, height),
1057                     false);
1058     }
1059
1060 #if USE_NOTEBOOK_ANTIFLICKER
1061     // subclass the spin control used by the notebook to scroll pages to
1062     // prevent it from flickering on resize
1063     if ( !m_hasSubclassedUpdown )
1064     {
1065         // iterate over all child windows to find spin button
1066         for ( HWND child = ::GetWindow(GetHwnd(), GW_CHILD);
1067               child;
1068               child = ::GetWindow(child, GW_HWNDNEXT) )
1069         {
1070             wxWindow *childWindow = wxFindWinFromHandle((WXHWND)child);
1071
1072             // see if it exists, if no wxWindow found then assume it's the spin
1073             // btn
1074             if ( !childWindow )
1075             {
1076                 // subclass the spin button to override WM_ERASEBKGND
1077                 if ( !gs_wndprocNotebookSpinBtn )
1078                     gs_wndprocNotebookSpinBtn = (WXFARPROC)wxGetWindowProc(child);
1079
1080                 wxSetWindowProc(child, wxNotebookSpinBtnWndProc);
1081                 m_hasSubclassedUpdown = true;
1082                 break;
1083             }
1084         }
1085     }
1086 #endif // USE_NOTEBOOK_ANTIFLICKER
1087
1088     event.Skip();
1089 }
1090
1091 void wxNotebook::OnSelChange(wxNotebookEvent& event)
1092 {
1093     // is it our tab control?
1094     if ( event.GetEventObject() == this )
1095     {
1096         UpdateSelection(event.GetSelection());
1097     }
1098
1099     // we want to give others a chance to process this message as well
1100     event.Skip();
1101 }
1102
1103 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
1104 {
1105     if ( event.IsWindowChange() ) {
1106         // change pages
1107         AdvanceSelection(event.GetDirection());
1108     }
1109     else {
1110         // we get this event in 3 cases
1111         //
1112         // a) one of our pages might have generated it because the user TABbed
1113         // out from it in which case we should propagate the event upwards and
1114         // our parent will take care of setting the focus to prev/next sibling
1115         //
1116         // or
1117         //
1118         // b) the parent panel wants to give the focus to us so that we
1119         // forward it to our selected page. We can't deal with this in
1120         // OnSetFocus() because we don't know which direction the focus came
1121         // from in this case and so can't choose between setting the focus to
1122         // first or last panel child
1123         //
1124         // or
1125         //
1126         // c) we ourselves (see MSWTranslateMessage) generated the event
1127         //
1128         wxWindow * const parent = GetParent();
1129
1130         // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE
1131         const bool isFromParent = event.GetEventObject() == (wxObject*) parent;
1132         const bool isFromSelf = event.GetEventObject() == (wxObject*) this;
1133
1134         if ( isFromParent || isFromSelf )
1135         {
1136             // no, it doesn't come from child, case (b) or (c): forward to a
1137             // page but only if direction is backwards (TAB) or from ourselves,
1138             if ( m_nSelection != wxNOT_FOUND &&
1139                     (!event.GetDirection() || isFromSelf) )
1140             {
1141                 // so that the page knows that the event comes from it's parent
1142                 // and is being propagated downwards
1143                 event.SetEventObject(this);
1144
1145                 wxWindow *page = m_pages[m_nSelection];
1146                 if ( !page->GetEventHandler()->ProcessEvent(event) )
1147                 {
1148                     page->SetFocus();
1149                 }
1150                 //else: page manages focus inside it itself
1151             }
1152             else // otherwise set the focus to the notebook itself
1153             {
1154                 SetFocus();
1155             }
1156         }
1157         else
1158         {
1159             // it comes from our child, case (a), pass to the parent, but only
1160             // if the direction is forwards. Otherwise set the focus to the
1161             // notebook itself. The notebook is always the 'first' control of a
1162             // page.
1163             if ( !event.GetDirection() )
1164             {
1165                 SetFocus();
1166             }
1167             else if ( parent )
1168             {
1169                 event.SetCurrentFocus(this);
1170                 parent->GetEventHandler()->ProcessEvent(event);
1171             }
1172         }
1173     }
1174 }
1175
1176 #if wxUSE_UXTHEME
1177
1178 bool wxNotebook::DoDrawBackground(WXHDC hDC, wxWindow *child)
1179 {
1180     wxUxThemeHandle theme(child ? child : this, L"TAB");
1181     if ( !theme )
1182         return false;
1183
1184     // get the notebook client rect (we're not interested in drawing tabs
1185     // themselves)
1186     wxRect r = GetPageSize();
1187     if ( r.IsEmpty() )
1188         return false;
1189
1190     RECT rc;
1191     wxCopyRectToRECT(r, rc);
1192
1193     // map rect to the coords of the window we're drawing in
1194     if ( child )
1195         ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1196
1197     // we have the content area (page size), but we need to draw all of the
1198     // background for it to be aligned correctly
1199     wxUxThemeEngine::Get()->GetThemeBackgroundExtent
1200                             (
1201                                 theme,
1202                                 (HDC) hDC,
1203                                 9 /* TABP_PANE */,
1204                                 0,
1205                                 &rc,
1206                                 &rc
1207                             );
1208     wxUxThemeEngine::Get()->DrawThemeBackground
1209                             (
1210                                 theme,
1211                                 (HDC) hDC,
1212                                 9 /* TABP_PANE */,
1213                                 0,
1214                                 &rc,
1215                                 NULL
1216                             );
1217
1218     return true;
1219 }
1220
1221 WXHBRUSH wxNotebook::QueryBgBitmap()
1222 {
1223     wxRect r = GetPageSize();
1224     if ( r.IsEmpty() )
1225         return 0;
1226
1227     WindowHDC hDC(GetHwnd());
1228     MemoryHDC hDCMem(hDC);
1229     CompatibleBitmap hBmp(hDC, r.x + r.width, r.y + r.height);
1230
1231     SelectInHDC selectBmp(hDCMem, hBmp);
1232
1233     if ( !DoDrawBackground((WXHDC)(HDC)hDCMem) )
1234         return 0;
1235
1236     return (WXHBRUSH)::CreatePatternBrush(hBmp);
1237 }
1238
1239 void wxNotebook::UpdateBgBrush()
1240 {
1241     if ( m_hbrBackground )
1242         ::DeleteObject((HBRUSH)m_hbrBackground);
1243
1244     if ( !m_hasBgCol && wxUxThemeEngine::GetIfActive() )
1245     {
1246         m_hbrBackground = QueryBgBitmap();
1247     }
1248     else // no themes or we've got user-defined solid colour
1249     {
1250         m_hbrBackground = NULL;
1251     }
1252 }
1253
1254 WXHBRUSH wxNotebook::MSWGetBgBrushForChild(WXHDC hDC, WXHWND hWnd)
1255 {
1256     if ( m_hbrBackground )
1257     {
1258         // before drawing with the background brush, we need to position it
1259         // correctly
1260         RECT rc;
1261         ::GetWindowRect((HWND)hWnd, &rc);
1262
1263         ::MapWindowPoints(NULL, GetHwnd(), (POINT *)&rc, 1);
1264
1265         if ( !::SetBrushOrgEx((HDC)hDC, -rc.left, -rc.top, NULL) )
1266         {
1267             wxLogLastError(_T("SetBrushOrgEx(notebook bg brush)"));
1268         }
1269
1270         return m_hbrBackground;
1271     }
1272
1273     return wxNotebookBase::MSWGetBgBrushForChild(hDC, hWnd);
1274 }
1275
1276 bool wxNotebook::MSWPrintChild(WXHDC hDC, wxWindow *child)
1277 {
1278     // solid background colour overrides themed background drawing
1279     if ( !UseBgCol() && DoDrawBackground(hDC, child) )
1280         return true;
1281
1282     // If we're using a solid colour (for example if we've switched off
1283     // theming for this notebook), paint it
1284     if (UseBgCol())
1285     {
1286         wxRect r = GetPageSize();
1287         if ( r.IsEmpty() )
1288             return false;
1289
1290         RECT rc;
1291         wxCopyRectToRECT(r, rc);
1292
1293         // map rect to the coords of the window we're drawing in
1294         if ( child )
1295             ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2);
1296
1297         wxBrush brush(GetBackgroundColour());
1298         HBRUSH hbr = GetHbrushOf(brush);
1299
1300         ::FillRect((HDC) hDC, &rc, hbr);
1301
1302         return true;
1303     }
1304
1305     return wxNotebookBase::MSWPrintChild(hDC, child);
1306 }
1307
1308 #endif // wxUSE_UXTHEME
1309
1310 // Windows only: attempts to get colour for UX theme page background
1311 wxColour wxNotebook::GetThemeBackgroundColour() const
1312 {
1313 #if wxUSE_UXTHEME
1314     if (wxUxThemeEngine::Get())
1315     {
1316         wxUxThemeHandle hTheme((wxNotebook*) this, L"TAB");
1317         if (hTheme)
1318         {
1319             // This is total guesswork.
1320             // See PlatformSDK\Include\Tmschema.h for values.
1321             // JACS: can also use 9 (TABP_PANE)
1322             COLORREF themeColor;
1323             bool success = (S_OK == wxUxThemeEngine::Get()->GetThemeColor(
1324                                         hTheme,
1325                                         10 /* TABP_BODY */,
1326                                         1 /* NORMAL */,
1327                                         3821 /* FILLCOLORHINT */,
1328                                         &themeColor));
1329             if (!success)
1330                 return GetBackgroundColour();
1331
1332             /*
1333             [DS] Workaround for WindowBlinds:
1334             Some themes return a near black theme color using FILLCOLORHINT,
1335             this makes notebook pages have an ugly black background and makes
1336             text (usually black) unreadable. Retry again with FILLCOLOR.
1337
1338             This workaround potentially breaks appearance of some themes,
1339             but in practice it already fixes some themes.
1340             */
1341             if (themeColor == 1)
1342             {
1343                 wxUxThemeEngine::Get()->GetThemeColor(
1344                                             hTheme,
1345                                             10 /* TABP_BODY */,
1346                                             1 /* NORMAL */,
1347                                             3802 /* FILLCOLOR */,
1348                                             &themeColor);
1349             }
1350
1351             wxColour colour = wxRGBToColour(themeColor);
1352
1353             // Under Vista, the tab background colour is reported incorrectly.
1354             // So for the default theme at least, hard-code the colour to something
1355             // that will blend in.
1356
1357             static int s_AeroStatus = -1;
1358             if (s_AeroStatus == -1)
1359             {
1360                 WCHAR szwThemeFile[1024];
1361                 WCHAR szwThemeColor[256];
1362                 if (S_OK == wxUxThemeEngine::Get()->GetCurrentThemeName(szwThemeFile, 1024, szwThemeColor, 256, NULL, 0))
1363                 {
1364                     wxString themeFile(szwThemeFile), themeColor(szwThemeColor);
1365                     if (themeFile.Find(wxT("Aero")) != -1 && themeColor == wxT("NormalColor"))
1366                         s_AeroStatus = 1;
1367                     else
1368                         s_AeroStatus = 0;
1369                 }
1370                 else
1371                     s_AeroStatus = 0;
1372             }
1373
1374             if (s_AeroStatus == 1)
1375                 colour = wxColour(255, 255, 255);
1376
1377             return colour;
1378         }
1379     }
1380 #endif // wxUSE_UXTHEME
1381
1382     return GetBackgroundColour();
1383 }
1384
1385 // ----------------------------------------------------------------------------
1386 // wxNotebook base class virtuals
1387 // ----------------------------------------------------------------------------
1388
1389 #if wxUSE_CONSTRAINTS
1390
1391 // override these 2 functions to do nothing: everything is done in OnSize
1392
1393 void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse))
1394 {
1395   // don't set the sizes of the pages - their correct size is not yet known
1396   wxControl::SetConstraintSizes(false);
1397 }
1398
1399 bool wxNotebook::DoPhase(int WXUNUSED(nPhase))
1400 {
1401   return true;
1402 }
1403
1404 #endif // wxUSE_CONSTRAINTS
1405
1406 // ----------------------------------------------------------------------------
1407 // wxNotebook Windows message handlers
1408 // ----------------------------------------------------------------------------
1409
1410 bool wxNotebook::MSWOnScroll(int orientation, WXWORD nSBCode,
1411                              WXWORD pos, WXHWND control)
1412 {
1413     // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the
1414     // up-down control
1415     if ( control )
1416         return false;
1417
1418     return wxNotebookBase::MSWOnScroll(orientation, nSBCode, pos, control);
1419 }
1420
1421 bool wxNotebook::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM* result)
1422 {
1423   wxNotebookEvent event(wxEVT_NULL, m_windowId);
1424
1425   NMHDR* hdr = (NMHDR *)lParam;
1426   switch ( hdr->code ) {
1427     case TCN_SELCHANGE:
1428       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
1429       break;
1430
1431     case TCN_SELCHANGING:
1432       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING);
1433       break;
1434
1435     default:
1436       return wxControl::MSWOnNotify(idCtrl, lParam, result);
1437   }
1438
1439   event.SetSelection(TabCtrl_GetCurSel(GetHwnd()));
1440   event.SetOldSelection(m_nSelection);
1441   event.SetEventObject(this);
1442   event.SetInt(idCtrl);
1443
1444   bool processed = GetEventHandler()->ProcessEvent(event);
1445   *result = !event.IsAllowed();
1446   return processed;
1447 }
1448
1449 #endif // wxUSE_NOTEBOOK