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