src/msw/notebook.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13 #pragma implementation "notebook.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20     #pragma hdrstop
  21 #endif
  22
  23 #if wxUSE_NOTEBOOK
  24
  25 // wxWidgets
  26 #ifndef WX_PRECOMP
  27   #include  "wx/string.h"
  28 #endif  // WX_PRECOMP
  29
  30 #include  "wx/log.h"
  31 #include  "wx/imaglist.h"
  32 #include  "wx/event.h"
  33 #include  "wx/control.h"
  34 #include  "wx/notebook.h"
  35 #include  "wx/app.h"
  36
  37 #include  "wx/msw/private.h"
  38
  39 // Windows standard headers
  40 #ifndef   __WIN95__
  41   #error  "wxNotebook is only supported Windows 95 and above"
  42 #endif    //Win95
  43
  44 #include  <windowsx.h>  // for SetWindowFont
  45
  46 #ifdef __GNUWIN32_OLD__
  47     #include "wx/msw/gnuwin32/extra.h"
  48 #endif
  49
  50 #if defined(__WIN95__) && !(defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__))
  51     #include <commctrl.h>
  52 #endif
  53
  54 #include "wx/msw/winundef.h"
  55
  56 #if wxUSE_UXTHEME
  57 #include "wx/msw/uxtheme.h"
  58
  59 #include "wx/radiobut.h"
  60 #include "wx/radiobox.h"
  61 #include "wx/checkbox.h"
  62 #include "wx/bmpbuttn.h"
  63 #include "wx/statline.h"
  64 #include "wx/statbox.h"
  65 #include "wx/stattext.h"
  66 #include "wx/slider.h"
  67 #include "wx/scrolwin.h"
  68 #include "wx/panel.h"
  69 #endif
  70
  71 // ----------------------------------------------------------------------------
  72 // macros
  73 // ----------------------------------------------------------------------------
  74
  75 // check that the page index is valid
  76 #define IS_VALID_PAGE(nPage) ((nPage) < GetPageCount())
  77
  78 // hide the ugly cast
  79 #define m_hwnd    (HWND)GetHWND()
  80
  81 // ----------------------------------------------------------------------------
  82 // constants
  83 // ----------------------------------------------------------------------------
  84
  85 // This is a work-around for missing defines in gcc-2.95 headers
  86 #ifndef TCS_RIGHT
  87     #define TCS_RIGHT       0x0002
  88 #endif
  89
  90 #ifndef TCS_VERTICAL
  91     #define TCS_VERTICAL    0x0080
  92 #endif
  93
  94 #ifndef TCS_BOTTOM
  95     #define TCS_BOTTOM      TCS_RIGHT
  96 #endif
  97
  98 // ----------------------------------------------------------------------------
  99 // event table
 100 // ----------------------------------------------------------------------------
 101
 102 #include <wx/listimpl.cpp>
 103
 104 WX_DEFINE_LIST( wxNotebookPageInfoList ) ;
 105
 106 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
 107 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
 108
 109 BEGIN_EVENT_TABLE(wxNotebook, wxControl)
 110     EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
 111
 112     EVT_SIZE(wxNotebook::OnSize)
 113
 114     EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
 115 END_EVENT_TABLE()
 116
 117 #if wxUSE_EXTENDED_RTTI
 118 WX_DEFINE_FLAGS( wxNotebookStyle )
 119
 120 wxBEGIN_FLAGS( wxNotebookStyle )
 121     // new style border flags, we put them first to
 122     // use them for streaming out
 123     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
 124     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
 125     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
 126     wxFLAGS_MEMBER(wxBORDER_RAISED)
 127     wxFLAGS_MEMBER(wxBORDER_STATIC)
 128     wxFLAGS_MEMBER(wxBORDER_NONE)
 129
 130     // old style border flags
 131     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
 132     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
 133     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
 134     wxFLAGS_MEMBER(wxRAISED_BORDER)
 135     wxFLAGS_MEMBER(wxSTATIC_BORDER)
 136     wxFLAGS_MEMBER(wxBORDER)
 137
 138     // standard window styles
 139     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
 140     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
 141     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
 142     wxFLAGS_MEMBER(wxWANTS_CHARS)
 143     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
 144     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
 145     wxFLAGS_MEMBER(wxVSCROLL)
 146     wxFLAGS_MEMBER(wxHSCROLL)
 147
 148     wxFLAGS_MEMBER(wxNB_FIXEDWIDTH)
 149     wxFLAGS_MEMBER(wxNB_LEFT)
 150     wxFLAGS_MEMBER(wxNB_RIGHT)
 151     wxFLAGS_MEMBER(wxNB_BOTTOM)
 152
 153 wxEND_FLAGS( wxNotebookStyle )
 154
 155 IMPLEMENT_DYNAMIC_CLASS_XTI(wxNotebook, wxControl,"wx/notebook.h")
 156 IMPLEMENT_DYNAMIC_CLASS_XTI(wxNotebookPageInfo, wxObject , "wx/notebook.h" )
 157
 158 wxCOLLECTION_TYPE_INFO( wxNotebookPageInfo * , wxNotebookPageInfoList ) ;
 159
 160 template<> void wxCollectionToVariantArray( wxNotebookPageInfoList const &theList, wxxVariantArray &value)
 161 {
 162     wxListCollectionToVariantArray<wxNotebookPageInfoList::compatibility_iterator>( theList , value ) ;
 163 }
 164
 165 wxBEGIN_PROPERTIES_TABLE(wxNotebook)
 166     wxEVENT_PROPERTY( PageChanging , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING , wxNotebookEvent )
 167     wxEVENT_PROPERTY( PageChanged , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED , wxNotebookEvent )
 168
 169     wxPROPERTY_COLLECTION( PageInfos , wxNotebookPageInfoList , wxNotebookPageInfo* , AddPageInfo , GetPageInfos , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 170     wxPROPERTY_FLAGS( WindowStyle , wxNotebookStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 171 wxEND_PROPERTIES_TABLE()
 172
 173 wxBEGIN_HANDLERS_TABLE(wxNotebook)
 174 wxEND_HANDLERS_TABLE()
 175
 176 wxCONSTRUCTOR_5( wxNotebook , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle)
 177
 178
 179 wxBEGIN_PROPERTIES_TABLE(wxNotebookPageInfo)
 180     wxREADONLY_PROPERTY( Page , wxNotebookPage* , GetPage , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 181     wxREADONLY_PROPERTY( Text , wxString , GetText , wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 182     wxREADONLY_PROPERTY( Selected , bool , GetSelected , false, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
 183     wxREADONLY_PROPERTY( ImageId , int , GetImageId , -1 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 184 wxEND_PROPERTIES_TABLE()
 185
 186 wxBEGIN_HANDLERS_TABLE(wxNotebookPageInfo)
 187 wxEND_HANDLERS_TABLE()
 188
 189 wxCONSTRUCTOR_4( wxNotebookPageInfo , wxNotebookPage* , Page , wxString , Text , bool , Selected , int , ImageId )
 190
 191 #else
 192 IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
 193 IMPLEMENT_DYNAMIC_CLASS(wxNotebookPageInfo, wxObject )
 194 #endif
 195 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent)
 196
 197 // ============================================================================
 198 // implementation
 199 // ============================================================================
 200
 201 // ----------------------------------------------------------------------------
 202 // wxNotebook construction
 203 // ----------------------------------------------------------------------------
 204
 205 const wxNotebookPageInfoList& wxNotebook::GetPageInfos() const
 206 {
 207     wxNotebookPageInfoList* list = const_cast< wxNotebookPageInfoList* >( &m_pageInfos ) ;
 208     WX_CLEAR_LIST( wxNotebookPageInfoList , *list ) ;
 209     for( size_t i = 0 ; i < GetPageCount() ; ++i )
 210     {
 211         wxNotebookPageInfo *info = new wxNotebookPageInfo() ;
 212         info->Create( const_cast<wxNotebook*>(this)->GetPage(i) , GetPageText(i) , GetSelection() == int(i) , GetPageImage(i) ) ;
 213         list->Append( info ) ;
 214     }
 215     return m_pageInfos ;
 216 }
 217
 218 // common part of all ctors
 219 void wxNotebook::Init()
 220 {
 221   m_imageList = NULL;
 222   m_nSelection = -1;
 223 }
 224
 225 // default for dynamic class
 226 wxNotebook::wxNotebook()
 227 {
 228   Init();
 229 }
 230
 231 // the same arguments as for wxControl
 232 wxNotebook::wxNotebook(wxWindow *parent,
 233                        wxWindowID id,
 234                        const wxPoint& pos,
 235                        const wxSize& size,
 236                        long style,
 237                        const wxString& name)
 238 {
 239   Init();
 240
 241   Create(parent, id, pos, size, style, name);
 242 }
 243
 244 // Create() function
 245 bool wxNotebook::Create(wxWindow *parent,
 246                         wxWindowID id,
 247                         const wxPoint& pos,
 248                         const wxSize& size,
 249                         long style,
 250                         const wxString& name)
 251 {
 252     // Does ComCtl32 support non-top tabs?
 253     int verComCtl32 = wxApp::GetComCtl32Version();
 254     if ( verComCtl32 < 470 || verComCtl32 >= 600 )
 255     {
 256         if (style & wxNB_BOTTOM)
 257             style &= ~wxNB_BOTTOM;
 258
 259         if (style & wxNB_LEFT)
 260             style &= ~wxNB_LEFT;
 261
 262         if (style & wxNB_RIGHT)
 263             style &= ~wxNB_RIGHT;
 264     }
 265
 266     if ( !CreateControl(parent, id, pos, size, style | wxTAB_TRAVERSAL,
 267                         wxDefaultValidator, name) )
 268         return false;
 269
 270     if ( !MSWCreateControl(WC_TABCONTROL, wxEmptyString, pos, size) )
 271         return false;
 272
 273     SetBackgroundColour(wxColour(::GetSysColor(COLOR_BTNFACE)));
 274
 275     return true;
 276 }
 277
 278 WXDWORD wxNotebook::MSWGetStyle(long style, WXDWORD *exstyle) const
 279 {
 280     WXDWORD tabStyle = wxControl::MSWGetStyle(style, exstyle);
 281
 282     tabStyle |= WS_TABSTOP | TCS_TABS;
 283
 284     if ( style & wxNB_MULTILINE )
 285         tabStyle |= TCS_MULTILINE;
 286     if ( style & wxNB_FIXEDWIDTH )
 287         tabStyle |= TCS_FIXEDWIDTH;
 288
 289     if ( style & wxNB_BOTTOM )
 290         tabStyle |= TCS_RIGHT;
 291     else if ( style & wxNB_LEFT )
 292         tabStyle |= TCS_VERTICAL;
 293     else if ( style & wxNB_RIGHT )
 294         tabStyle |= TCS_VERTICAL | TCS_RIGHT;
 295
 296     // ex style
 297     if ( exstyle )
 298     {
 299         // note that we never want to have the default WS_EX_CLIENTEDGE style
 300         // as it looks too ugly for the notebooks
 301         *exstyle = 0;
 302     }
 303
 304     return tabStyle;
 305 }
 306
 307 // ----------------------------------------------------------------------------
 308 // wxNotebook accessors
 309 // ----------------------------------------------------------------------------
 310
 311 size_t wxNotebook::GetPageCount() const
 312 {
 313   // consistency check
 314   wxASSERT( (int)m_pages.Count() == TabCtrl_GetItemCount(m_hwnd) );
 315
 316   return m_pages.Count();
 317 }
 318
 319 int wxNotebook::GetRowCount() const
 320 {
 321   return TabCtrl_GetRowCount(m_hwnd);
 322 }
 323
 324 int wxNotebook::SetSelection(size_t nPage)
 325 {
 326   wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, wxT("notebook page out of range") );
 327
 328   if ( int(nPage) != m_nSelection )
 329   {
 330     wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId);
 331     event.SetSelection(nPage);
 332     event.SetOldSelection(m_nSelection);
 333     event.SetEventObject(this);
 334     if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
 335     {
 336       // program allows the page change
 337       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
 338       (void)GetEventHandler()->ProcessEvent(event);
 339
 340       TabCtrl_SetCurSel(m_hwnd, nPage);
 341     }
 342   }
 343
 344   return m_nSelection;
 345 }
 346
 347 bool wxNotebook::SetPageText(size_t nPage, const wxString& strText)
 348 {
 349   wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
 350
 351   TC_ITEM tcItem;
 352   tcItem.mask = TCIF_TEXT;
 353   tcItem.pszText = (wxChar *)strText.c_str();
 354
 355   return TabCtrl_SetItem(m_hwnd, nPage, &tcItem) != 0;
 356 }
 357
 358 wxString wxNotebook::GetPageText(size_t nPage) const
 359 {
 360   wxCHECK_MSG( IS_VALID_PAGE(nPage), wxEmptyString, wxT("notebook page out of range") );
 361
 362   wxChar buf[256];
 363   TC_ITEM tcItem;
 364   tcItem.mask = TCIF_TEXT;
 365   tcItem.pszText = buf;
 366   tcItem.cchTextMax = WXSIZEOF(buf);
 367
 368   wxString str;
 369   if ( TabCtrl_GetItem(m_hwnd, nPage, &tcItem) )
 370     str = tcItem.pszText;
 371
 372   return str;
 373 }
 374
 375 int wxNotebook::GetPageImage(size_t nPage) const
 376 {
 377   wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, wxT("notebook page out of range") );
 378
 379   TC_ITEM tcItem;
 380   tcItem.mask = TCIF_IMAGE;
 381
 382   return TabCtrl_GetItem(m_hwnd, nPage, &tcItem) ? tcItem.iImage : -1;
 383 }
 384
 385 bool wxNotebook::SetPageImage(size_t nPage, int nImage)
 386 {
 387   wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") );
 388
 389   TC_ITEM tcItem;
 390   tcItem.mask = TCIF_IMAGE;
 391   tcItem.iImage = nImage;
 392
 393   return TabCtrl_SetItem(m_hwnd, nPage, &tcItem) != 0;
 394 }
 395
 396 void wxNotebook::SetImageList(wxImageList* imageList)
 397 {
 398   wxNotebookBase::SetImageList(imageList);
 399
 400   if ( imageList )
 401   {
 402     TabCtrl_SetImageList(m_hwnd, (HIMAGELIST)imageList->GetHIMAGELIST());
 403   }
 404 }
 405
 406 // ----------------------------------------------------------------------------
 407 // wxNotebook size settings
 408 // ----------------------------------------------------------------------------
 409
 410 void wxNotebook::SetPageSize(const wxSize& size)
 411 {
 412     // transform the page size into the notebook size
 413     RECT rc;
 414     rc.left =
 415     rc.top = 0;
 416     rc.right = size.x;
 417     rc.bottom = size.y;
 418
 419     TabCtrl_AdjustRect(GetHwnd(), true, &rc);
 420
 421     // and now set it
 422     SetSize(rc.right - rc.left, rc.bottom - rc.top);
 423 }
 424
 425 void wxNotebook::SetPadding(const wxSize& padding)
 426 {
 427     TabCtrl_SetPadding(GetHwnd(), padding.x, padding.y);
 428 }
 429
 430 // Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH
 431 // style.
 432 void wxNotebook::SetTabSize(const wxSize& sz)
 433 {
 434     ::SendMessage(GetHwnd(), TCM_SETITEMSIZE, 0, MAKELPARAM(sz.x, sz.y));
 435 }
 436
 437 wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
 438 {
 439     wxSize sizeTotal = sizePage;
 440
 441     // We need to make getting tab size part of the wxWidgets API.
 442     wxSize tabSize(0, 0);
 443     if (GetPageCount() > 0)
 444     {
 445         RECT rect;
 446         TabCtrl_GetItemRect((HWND) GetHWND(), 0, & rect);
 447         tabSize.x = rect.right - rect.left;
 448         tabSize.y = rect.bottom - rect.top;
 449     }
 450     if ( HasFlag(wxNB_LEFT) || HasFlag(wxNB_RIGHT) )
 451     {
 452         sizeTotal.x += tabSize.x + 7;
 453         sizeTotal.y += 7;
 454     }
 455     else
 456     {
 457         sizeTotal.x += 7;
 458         sizeTotal.y += tabSize.y + 7;
 459     }
 460
 461     return sizeTotal;
 462 }
 463
 464 void wxNotebook::AdjustPageSize(wxNotebookPage *page)
 465 {
 466     wxCHECK_RET( page, _T("NULL page in wxNotebook::AdjustPageSize") );
 467
 468     RECT rc;
 469     rc.left =
 470     rc.top = 0;
 471
 472     // get the page size from the notebook size
 473     GetSize((int *)&rc.right, (int *)&rc.bottom);
 474
 475     // This check is to work around a bug in TabCtrl_AdjustRect which will
 476     // cause a crash on win2k, or on XP with themes disabled, if the
 477     // wxNB_MULTILINE style is used and the rectangle is very small, (such as
 478     // when the notebook is first created.)  The value of 20 is just
 479     // arbitrarily chosen, if there is a better way to determine this value
 480     // then please do so.  --RD
 481     if (rc.right > 20 && rc.bottom > 20)
 482     {
 483         TabCtrl_AdjustRect(m_hwnd, false, &rc);
 484         page->SetSize(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
 485     }
 486 }
 487
 488 // ----------------------------------------------------------------------------
 489 // wxNotebook operations
 490 // ----------------------------------------------------------------------------
 491
 492 // remove one page from the notebook, without deleting
 493 wxNotebookPage *wxNotebook::DoRemovePage(size_t nPage)
 494 {
 495     wxNotebookPage *pageRemoved = wxNotebookBase::DoRemovePage(nPage);
 496     if ( !pageRemoved )
 497         return NULL;
 498
 499     TabCtrl_DeleteItem(m_hwnd, nPage);
 500
 501     if ( m_pages.IsEmpty() )
 502     {
 503         // no selection any more, the notebook becamse empty
 504         m_nSelection = -1;
 505     }
 506     else // notebook still not empty
 507     {
 508         int selNew = TabCtrl_GetCurSel(m_hwnd);
 509         if (selNew != -1)
 510         {
 511             // No selection change, just refresh the current selection.
 512             // Because it could be that the slection index changed
 513             // we need to update it.
 514             // Note: this does not mean the selection it self changed.
 515             m_nSelection = selNew;
 516             m_pages[m_nSelection]->Refresh();
 517         }
 518         else if (int(nPage) == m_nSelection)
 519         {
 520             // The selection was deleted.
 521
 522             // Determine new selection.
 523             if (m_nSelection == int(GetPageCount()))
 524                 selNew = m_nSelection - 1;
 525             else
 526                 selNew = m_nSelection;
 527
 528             // m_nSelection must be always valid so reset it before calling
 529             // SetSelection()
 530             m_nSelection = -1;
 531             SetSelection(selNew);
 532         }
 533         else
 534         {
 535             wxFAIL; // Windows did not behave ok.
 536         }
 537     }
 538
 539     return pageRemoved;
 540 }
 541
 542 // remove all pages
 543 bool wxNotebook::DeleteAllPages()
 544 {
 545   size_t nPageCount = GetPageCount();
 546   size_t nPage;
 547   for ( nPage = 0; nPage < nPageCount; nPage++ )
 548     delete m_pages[nPage];
 549
 550   m_pages.Clear();
 551
 552   TabCtrl_DeleteAllItems(m_hwnd);
 553
 554   m_nSelection = -1;
 555
 556   return true;
 557 }
 558
 559 // same as AddPage() but does it at given position
 560 bool wxNotebook::InsertPage(size_t nPage,
 561                             wxNotebookPage *pPage,
 562                             const wxString& strText,
 563                             bool bSelect,
 564                             int imageId)
 565 {
 566     wxCHECK_MSG( pPage != NULL, false, _T("NULL page in wxNotebook::InsertPage") );
 567     wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false,
 568                  _T("invalid index in wxNotebook::InsertPage") );
 569
 570     wxASSERT_MSG( pPage->GetParent() == this,
 571                     _T("notebook pages must have notebook as parent") );
 572
 573 #if wxUSE_UXTHEME && wxUSE_UXTHEME_AUTO
 574     static bool g_TestedForTheme = false;
 575     static bool g_UseTheme = false;
 576     if (!g_TestedForTheme)
 577     {
 578         int commCtrlVersion = wxTheApp->GetComCtl32Version() ;
 579
 580         g_UseTheme = (commCtrlVersion >= 600);
 581         g_TestedForTheme = true;
 582     }
 583
 584     // Automatically apply the theme background,
 585     // changing the colour of the panel to match the
 586     // tab page colour. This won't work well with all
 587     // themes but it's a start.
 588     if (g_UseTheme && wxUxThemeEngine::Get() && pPage->IsKindOf(CLASSINFO(wxPanel)))
 589     {
 590         ApplyThemeBackground(pPage, GetThemeBackgroundColour());
 591     }
 592 #endif
 593
 594     // add a new tab to the control
 595     // ----------------------------
 596
 597     // init all fields to 0
 598     TC_ITEM tcItem;
 599     wxZeroMemory(tcItem);
 600
 601     // set the image, if any
 602     if ( imageId != -1 )
 603     {
 604         tcItem.mask |= TCIF_IMAGE;
 605         tcItem.iImage  = imageId;
 606     }
 607
 608     // and the text
 609     if ( !strText.IsEmpty() )
 610     {
 611         tcItem.mask |= TCIF_TEXT;
 612         tcItem.pszText = (wxChar *)strText.c_str(); // const_cast
 613     }
 614
 615     // fit the notebook page to the tab control's display area: this should be
 616     // done before adding it to the notebook or TabCtrl_InsertItem() will
 617     // change the notebooks size itself!
 618     AdjustPageSize(pPage);
 619
 620     // finally do insert it
 621     if ( TabCtrl_InsertItem(m_hwnd, nPage, &tcItem) == -1 )
 622     {
 623         wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str());
 624
 625         return false;
 626     }
 627
 628     // succeeded: save the pointer to the page
 629     m_pages.Insert(pPage, nPage);
 630
 631     // we may need to adjust the size again if the notebook size changed:
 632     // normally this only happens for the first page we add (the tabs which
 633     // hadn't been there before are now shown) but for a multiline notebook it
 634     // can happen for any page at all as a new row could have been started
 635     if ( m_pages.GetCount() == 1 || HasFlag(wxNB_MULTILINE) )
 636     {
 637         AdjustPageSize(pPage);
 638     }
 639
 640     // hide the page: unless it is selected, it shouldn't be shown (and if it
 641     // is selected it will be shown later)
 642     HWND hwnd = GetWinHwnd(pPage);
 643     SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);
 644
 645     // this updates internal flag too -- otherwise it would get out of sync
 646     // with the real state
 647     pPage->Show(false);
 648
 649
 650     // now deal with the selection
 651     // ---------------------------
 652
 653     // if the inserted page is before the selected one, we must update the
 654     // index of the selected page
 655     if ( int(nPage) <= m_nSelection )
 656     {
 657         // one extra page added
 658         m_nSelection++;
 659     }
 660
 661     // some page should be selected: either this one or the first one if there
 662     // is still no selection
 663     int selNew = -1;
 664     if ( bSelect )
 665         selNew = nPage;
 666     else if ( m_nSelection == -1 )
 667         selNew = 0;
 668
 669     if ( selNew != -1 )
 670         SetSelection(selNew);
 671
 672     return true;
 673 }
 674
 675 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
 676 {
 677     TC_HITTESTINFO hitTestInfo;
 678     hitTestInfo.pt.x = pt.x;
 679     hitTestInfo.pt.y = pt.y;
 680     int item = TabCtrl_HitTest(GetHwnd(), &hitTestInfo);
 681
 682     if ( flags )
 683     {
 684         *flags = 0;
 685
 686         if ((hitTestInfo.flags & TCHT_NOWHERE) == TCHT_NOWHERE)
 687             *flags |= wxNB_HITTEST_NOWHERE;
 688         if ((hitTestInfo.flags & TCHT_ONITEM) == TCHT_ONITEM)
 689             *flags |= wxNB_HITTEST_ONITEM;
 690         if ((hitTestInfo.flags & TCHT_ONITEMICON) == TCHT_ONITEMICON)
 691             *flags |= wxNB_HITTEST_ONICON;
 692         if ((hitTestInfo.flags & TCHT_ONITEMLABEL) == TCHT_ONITEMLABEL)
 693             *flags |= wxNB_HITTEST_ONLABEL;
 694     }
 695
 696     return item;
 697 }
 698
 699
 700 // ----------------------------------------------------------------------------
 701 // wxNotebook callbacks
 702 // ----------------------------------------------------------------------------
 703
 704 void wxNotebook::OnSize(wxSizeEvent& event)
 705 {
 706   // fit the notebook page to the tab control's display area
 707   RECT rc;
 708   rc.left = rc.top = 0;
 709   GetSize((int *)&rc.right, (int *)&rc.bottom);
 710
 711   // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
 712   // returns completely false values for multiline tab controls after the tabs
 713   // are added but before getting the first WM_SIZE (off by ~50 pixels, see
 714   //
 715   // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
 716   //
 717   // and the only work around I could find was this ugly hack... without it
 718   // simply toggling the "multiline" checkbox in the notebook sample resulted
 719   // in a noticeable page displacement
 720   if ( HasFlag(wxNB_MULTILINE) )
 721   {
 722       // avoid an infinite recursion: we get another notification too!
 723       static bool s_isInOnSize = false;
 724
 725       if ( !s_isInOnSize )
 726       {
 727           s_isInOnSize = true;
 728           SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED,
 729                       MAKELPARAM(rc.right, rc.bottom));
 730           s_isInOnSize = false;
 731       }
 732   }
 733
 734   TabCtrl_AdjustRect(m_hwnd, false, &rc);
 735
 736   int width = rc.right - rc.left,
 737       height = rc.bottom - rc.top;
 738   size_t nCount = m_pages.Count();
 739   for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
 740     wxNotebookPage *pPage = m_pages[nPage];
 741     pPage->SetSize(rc.left, rc.top, width, height);
 742   }
 743
 744   event.Skip();
 745 }
 746
 747 void wxNotebook::OnSelChange(wxNotebookEvent& event)
 748 {
 749   // is it our tab control?
 750   if ( event.GetEventObject() == this )
 751   {
 752       int sel = event.GetOldSelection();
 753       if ( sel != -1 )
 754         m_pages[sel]->Show(false);
 755
 756       sel = event.GetSelection();
 757       if ( sel != -1 )
 758       {
 759         wxNotebookPage *pPage = m_pages[sel];
 760         pPage->Show(true);
 761         pPage->SetFocus();
 762
 763         // If the newly focused window is not a child of the new page,
 764         // SetFocus was not successful and the notebook itself should be
 765         // focused
 766         wxWindow *currentFocus = FindFocus();
 767         wxWindow *startFocus = currentFocus;
 768         while ( currentFocus && currentFocus != pPage && currentFocus != this )
 769             currentFocus = currentFocus->GetParent();
 770
 771         if ( startFocus == pPage || currentFocus != pPage )
 772             SetFocus();
 773
 774       }
 775       else // no pages in the notebook, give the focus to itself
 776       {
 777           SetFocus();
 778       }
 779
 780       m_nSelection = sel;
 781   }
 782
 783   // we want to give others a chance to process this message as well
 784   event.Skip();
 785 }
 786
 787 bool wxNotebook::MSWTranslateMessage(WXMSG *wxmsg)
 788 {
 789     const MSG * const msg = (MSG *)wxmsg;
 790
 791     // intercept TAB, CTRL+TAB and CTRL+SHIFT+TAB for processing by wxNotebook.
 792     // TAB will be passed to the currently selected page, CTRL+TAB and
 793     // CTRL+SHIFT+TAB will be processed by the notebook itself. do not
 794     // intercept SHIFT+TAB. This goes to the parent of the notebook which will
 795     // process it.
 796     if ( msg->message == WM_KEYDOWN && msg->wParam == VK_TAB &&
 797             msg->hwnd == m_hwnd &&
 798                 (wxIsCtrlDown() || !wxIsShiftDown()) )
 799     {
 800         return MSWProcessMessage(wxmsg);
 801     }
 802
 803     return false;
 804 }
 805
 806 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
 807 {
 808     if ( event.IsWindowChange() ) {
 809         // change pages
 810         AdvanceSelection(event.GetDirection());
 811     }
 812     else {
 813         // we get this event in 3 cases
 814         //
 815         // a) one of our pages might have generated it because the user TABbed
 816         // out from it in which case we should propagate the event upwards and
 817         // our parent will take care of setting the focus to prev/next sibling
 818         //
 819         // or
 820         //
 821         // b) the parent panel wants to give the focus to us so that we
 822         // forward it to our selected page. We can't deal with this in
 823         // OnSetFocus() because we don't know which direction the focus came
 824         // from in this case and so can't choose between setting the focus to
 825         // first or last panel child
 826         //
 827         // or
 828         //
 829         // c) we ourselves (see MSWTranslateMessage) generated the event
 830         //
 831         wxWindow * const parent = GetParent();
 832
 833         const bool isFromParent = event.GetEventObject() == parent;
 834         const bool isFromSelf = event.GetEventObject() == this;
 835
 836         if ( isFromParent || isFromSelf )
 837         {
 838             // no, it doesn't come from child, case (b) or (c): forward to a
 839             // page but only if direction is backwards (TAB) or from ourselves,
 840             if ( m_nSelection != -1 &&
 841                     (!event.GetDirection() || isFromSelf) )
 842             {
 843                 // so that the page knows that the event comes from it's parent
 844                 // and is being propagated downwards
 845                 event.SetEventObject(this);
 846
 847                 wxWindow *page = m_pages[m_nSelection];
 848                 if ( !page->GetEventHandler()->ProcessEvent(event) )
 849                 {
 850                     page->SetFocus();
 851                 }
 852                 //else: page manages focus inside it itself
 853             }
 854             else // otherwise set the focus to the notebook itself
 855             {
 856                 SetFocus();
 857             }
 858         }
 859         else
 860         {
 861             // it comes from our child, case (a), pass to the parent, but only
 862             // if the direction is forwards. Otherwise set the focus to the
 863             // notebook itself. The notebook is always the 'first' control of a
 864             // page.
 865             if ( !event.GetDirection() )
 866             {
 867                 SetFocus();
 868             }
 869             else if ( parent )
 870             {
 871                 event.SetCurrentFocus(this);
 872                 parent->GetEventHandler()->ProcessEvent(event);
 873             }
 874         }
 875     }
 876 }
 877
 878 // ----------------------------------------------------------------------------
 879 // wxNotebook base class virtuals
 880 // ----------------------------------------------------------------------------
 881
 882 #if wxUSE_CONSTRAINTS
 883
 884 // override these 2 functions to do nothing: everything is done in OnSize
 885
 886 void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse))
 887 {
 888   // don't set the sizes of the pages - their correct size is not yet known
 889   wxControl::SetConstraintSizes(false);
 890 }
 891
 892 bool wxNotebook::DoPhase(int WXUNUSED(nPhase))
 893 {
 894   return true;
 895 }
 896
 897 #endif // wxUSE_CONSTRAINTS
 898
 899 // ----------------------------------------------------------------------------
 900 // wxNotebook Windows message handlers
 901 // ----------------------------------------------------------------------------
 902
 903 bool wxNotebook::MSWOnScroll(int orientation, WXWORD nSBCode,
 904                              WXWORD pos, WXHWND control)
 905 {
 906     // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the
 907     // up-down control
 908     if ( control )
 909         return false;
 910
 911     return wxNotebookBase::MSWOnScroll(orientation, nSBCode, pos, control);
 912 }
 913
 914 bool wxNotebook::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM* result)
 915 {
 916   wxNotebookEvent event(wxEVT_NULL, m_windowId);
 917
 918   NMHDR* hdr = (NMHDR *)lParam;
 919   switch ( hdr->code ) {
 920     case TCN_SELCHANGE:
 921       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
 922       break;
 923
 924     case TCN_SELCHANGING:
 925       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING);
 926       break;
 927
 928     default:
 929       return wxControl::MSWOnNotify(idCtrl, lParam, result);
 930   }
 931
 932   event.SetSelection(TabCtrl_GetCurSel(m_hwnd));
 933   event.SetOldSelection(m_nSelection);
 934   event.SetEventObject(this);
 935   event.SetInt(idCtrl);
 936
 937   bool processed = GetEventHandler()->ProcessEvent(event);
 938   *result = !event.IsAllowed();
 939   return processed;
 940 }
 941
 942 // Windows only: attempts to get colour for UX theme page background
 943 wxColour wxNotebook::GetThemeBackgroundColour()
 944 {
 945 #if wxUSE_UXTHEME
 946     if (wxUxThemeEngine::Get())
 947     {
 948         wxUxThemeHandle hTheme(this, L"TAB");
 949         if (hTheme)
 950         {
 951             // This is total guesswork.
 952             // See PlatformSDK\Include\Tmschema.h for values
 953             COLORREF themeColor;
 954             wxUxThemeEngine::Get()->GetThemeColor(
 955                                         hTheme,
 956                                         10 /* TABP_BODY */,
 957                                         1 /* NORMAL */,
 958                                         3821 /* FILLCOLORHINT */,
 959                                         &themeColor);
 960
 961             /*
 962             [DS] Workaround for WindowBlinds:
 963             Some themes return a near black theme color using FILLCOLORHINT,
 964             this makes notebook pages have an ugly black background and makes
 965             text (usually black) unreadable. Retry again with FILLCOLOR.
 966
 967             This workaround potentially breaks appearance of some themes,
 968             but in practice it already fixes some themes.
 969             */
 970             if (themeColor == 1)
 971             {
 972                 wxUxThemeEngine::Get()->GetThemeColor(
 973                                             hTheme,
 974                                             10 /* TABP_BODY */,
 975                                             1 /* NORMAL */,
 976                                             3802 /* FILLCOLOR */,
 977                                             &themeColor);
 978             }
 979
 980             wxColour colour(GetRValue(themeColor), GetGValue(themeColor), GetBValue(themeColor));
 981             return colour;
 982         }
 983     }
 984 #endif // wxUSE_UXTHEME
 985
 986     return GetBackgroundColour();
 987 }
 988
 989 // Windows only: attempts to apply the UX theme page background to this page
 990 #if wxUSE_UXTHEME
 991 void wxNotebook::ApplyThemeBackground(wxWindow* window, const wxColour& colour)
 992 #else
 993 void wxNotebook::ApplyThemeBackground(wxWindow*, const wxColour&)
 994 #endif
 995 {
 996 #if wxUSE_UXTHEME
 997
 998     window->ApplyParentThemeBackground(colour);
 999
1000     for ( wxWindowList::compatibility_iterator node = window->GetChildren().GetFirst(); node; node = node->GetNext() )
1001     {
1002         wxWindow *child = node->GetData();
1003         ApplyThemeBackground(child, colour);
1004     }
1005 #endif
1006 }
1007
1008 #if wxUSE_UXTHEME
1009 WXLRESULT wxNotebook::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1010 {
1011     static bool g_TestedForTheme = false;
1012     static bool g_supportsThemes = false;
1013     switch ( nMsg )
1014     {
1015         case WM_ERASEBKGND:
1016         {
1017             if (!g_TestedForTheme)
1018             {
1019                 int commCtrlVersion = wxTheApp->GetComCtl32Version() ;
1020
1021                 g_supportsThemes = (commCtrlVersion >= 600);
1022                 g_TestedForTheme = true;
1023             }
1024
1025             // If currently an XP theme is active, it seems we can get away
1026             // with not drawing a background, which reduces flicker.
1027             if (g_supportsThemes)
1028             {
1029                 wxUxThemeEngine *p = wxUxThemeEngine::Get();
1030                 if (p && p->IsThemeActive() )
1031                 {
1032                     return true;
1033                 }
1034             }
1035         }
1036     }
1037
1038     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
1039 }
1040 #endif // #if wxUSE_UXTHEME
1041
1042 #endif // wxUSE_NOTEBOOK