src/msw/notebook.cpp

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