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   #include  "wx/dc.h"
  29 #endif  // WX_PRECOMP
  30
  31 #include  "wx/log.h"
  32 #include  "wx/imaglist.h"
  33 #include  "wx/event.h"
  34 #include  "wx/control.h"
  35 #include  "wx/notebook.h"
  36 #include  "wx/app.h"
  37
  38 #include  "wx/msw/private.h"
  39
  40 // Windows standard headers
  41 #ifndef   __WIN95__
  42   #error  "wxNotebook is only supported Windows 95 and above"
  43 #endif    //Win95
  44
  45 #include  <windowsx.h>  // for SetWindowFont
  46
  47 #ifdef __GNUWIN32_OLD__
  48     #include "wx/msw/gnuwin32/extra.h"
  49 #endif
  50
  51 #if defined(__WIN95__) && !(defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__))
  52     #include <commctrl.h>
  53 #endif
  54
  55 #include "wx/msw/winundef.h"
  56
  57 #if wxUSE_UXTHEME
  58     #include "wx/msw/uxtheme.h"
  59 #endif
  60
  61 // ----------------------------------------------------------------------------
  62 // macros
  63 // ----------------------------------------------------------------------------
  64
  65 // check that the page index is valid
  66 #define IS_VALID_PAGE(nPage) ((nPage) < GetPageCount())
  67
  68 // hide the ugly cast
  69 #define m_hwnd    (HWND)GetHWND()
  70
  71 // ----------------------------------------------------------------------------
  72 // constants
  73 // ----------------------------------------------------------------------------
  74
  75 // This is a work-around for missing defines in gcc-2.95 headers
  76 #ifndef TCS_RIGHT
  77     #define TCS_RIGHT       0x0002
  78 #endif
  79
  80 #ifndef TCS_VERTICAL
  81     #define TCS_VERTICAL    0x0080
  82 #endif
  83
  84 #ifndef TCS_BOTTOM
  85     #define TCS_BOTTOM      TCS_RIGHT
  86 #endif
  87
  88 // ----------------------------------------------------------------------------
  89 // event table
  90 // ----------------------------------------------------------------------------
  91
  92 #include <wx/listimpl.cpp>
  93
  94 WX_DEFINE_LIST( wxNotebookPageInfoList ) ;
  95
  96 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
  97 DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
  98
  99 BEGIN_EVENT_TABLE(wxNotebook, wxControl)
 100     EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
 101
 102     EVT_SIZE(wxNotebook::OnSize)
 103
 104     EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
 105 END_EVENT_TABLE()
 106
 107 #if wxUSE_EXTENDED_RTTI
 108 WX_DEFINE_FLAGS( wxNotebookStyle )
 109
 110 wxBEGIN_FLAGS( wxNotebookStyle )
 111     // new style border flags, we put them first to
 112     // use them for streaming out
 113     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
 114     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
 115     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
 116     wxFLAGS_MEMBER(wxBORDER_RAISED)
 117     wxFLAGS_MEMBER(wxBORDER_STATIC)
 118     wxFLAGS_MEMBER(wxBORDER_NONE)
 119
 120     // old style border flags
 121     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
 122     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
 123     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
 124     wxFLAGS_MEMBER(wxRAISED_BORDER)
 125     wxFLAGS_MEMBER(wxSTATIC_BORDER)
 126     wxFLAGS_MEMBER(wxBORDER)
 127
 128     // standard window styles
 129     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
 130     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
 131     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
 132     wxFLAGS_MEMBER(wxWANTS_CHARS)
 133     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
 134     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
 135     wxFLAGS_MEMBER(wxVSCROLL)
 136     wxFLAGS_MEMBER(wxHSCROLL)
 137
 138     wxFLAGS_MEMBER(wxNB_FIXEDWIDTH)
 139     wxFLAGS_MEMBER(wxNB_LEFT)
 140     wxFLAGS_MEMBER(wxNB_RIGHT)
 141     wxFLAGS_MEMBER(wxNB_BOTTOM)
 142
 143 wxEND_FLAGS( wxNotebookStyle )
 144
 145 IMPLEMENT_DYNAMIC_CLASS_XTI(wxNotebook, wxControl,"wx/notebook.h")
 146 IMPLEMENT_DYNAMIC_CLASS_XTI(wxNotebookPageInfo, wxObject , "wx/notebook.h" )
 147
 148 wxCOLLECTION_TYPE_INFO( wxNotebookPageInfo * , wxNotebookPageInfoList ) ;
 149
 150 template<> void wxCollectionToVariantArray( wxNotebookPageInfoList const &theList, wxxVariantArray &value)
 151 {
 152     wxListCollectionToVariantArray<wxNotebookPageInfoList::compatibility_iterator>( theList , value ) ;
 153 }
 154
 155 wxBEGIN_PROPERTIES_TABLE(wxNotebook)
 156     wxEVENT_PROPERTY( PageChanging , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING , wxNotebookEvent )
 157     wxEVENT_PROPERTY( PageChanged , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED , wxNotebookEvent )
 158
 159     wxPROPERTY_COLLECTION( PageInfos , wxNotebookPageInfoList , wxNotebookPageInfo* , AddPageInfo , GetPageInfos , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 160     wxPROPERTY_FLAGS( WindowStyle , wxNotebookStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 161 wxEND_PROPERTIES_TABLE()
 162
 163 wxBEGIN_HANDLERS_TABLE(wxNotebook)
 164 wxEND_HANDLERS_TABLE()
 165
 166 wxCONSTRUCTOR_5( wxNotebook , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle)
 167
 168
 169 wxBEGIN_PROPERTIES_TABLE(wxNotebookPageInfo)
 170     wxREADONLY_PROPERTY( Page , wxNotebookPage* , GetPage , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 171     wxREADONLY_PROPERTY( Text , wxString , GetText , wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 172     wxREADONLY_PROPERTY( Selected , bool , GetSelected , false, 0 /*flags*/ , wxT("Helpstring") , wxT("group") )
 173     wxREADONLY_PROPERTY( ImageId , int , GetImageId , -1 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
 174 wxEND_PROPERTIES_TABLE()
 175
 176 wxBEGIN_HANDLERS_TABLE(wxNotebookPageInfo)
 177 wxEND_HANDLERS_TABLE()
 178
 179 wxCONSTRUCTOR_4( wxNotebookPageInfo , wxNotebookPage* , Page , wxString , Text , bool , Selected , int , ImageId )
 180
 181 #else
 182 IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
 183 IMPLEMENT_DYNAMIC_CLASS(wxNotebookPageInfo, wxObject )
 184 #endif
 185 IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent)
 186
 187 // ============================================================================
 188 // implementation
 189 // ============================================================================
 190
 191 // ----------------------------------------------------------------------------
 192 // wxNotebook construction
 193 // ----------------------------------------------------------------------------
 194
 195 const wxNotebookPageInfoList& wxNotebook::GetPageInfos() const
 196 {
 197     wxNotebookPageInfoList* list = const_cast< wxNotebookPageInfoList* >( &m_pageInfos ) ;
 198     WX_CLEAR_LIST( wxNotebookPageInfoList , *list ) ;
 199     for( size_t i = 0 ; i < GetPageCount() ; ++i )
 200     {
 201         wxNotebookPageInfo *info = new wxNotebookPageInfo() ;
 202         info->Create( const_cast<wxNotebook*>(this)->GetPage(i) , GetPageText(i) , GetSelection() == int(i) , GetPageImage(i) ) ;
 203         list->Append( info ) ;
 204     }
 205     return m_pageInfos ;
 206 }
 207
 208 // common part of all ctors
 209 void wxNotebook::Init()
 210 {
 211   m_imageList = NULL;
 212   m_nSelection = -1;
 213
 214 #if wxUSE_UXTHEME
 215   m_hbrBackground = NULL;
 216 #endif // wxUSE_UXTHEME
 217 }
 218
 219 // default for dynamic class
 220 wxNotebook::wxNotebook()
 221 {
 222   Init();
 223 }
 224
 225 // the same arguments as for wxControl
 226 wxNotebook::wxNotebook(wxWindow *parent,
 227                        wxWindowID id,
 228                        const wxPoint& pos,
 229                        const wxSize& size,
 230                        long style,
 231                        const wxString& name)
 232 {
 233   Init();
 234
 235   Create(parent, id, pos, size, style, name);
 236 }
 237
 238 // Create() function
 239 bool wxNotebook::Create(wxWindow *parent,
 240                         wxWindowID id,
 241                         const wxPoint& pos,
 242                         const wxSize& size,
 243                         long style,
 244                         const wxString& name)
 245 {
 246     // Does ComCtl32 support non-top tabs?
 247     int verComCtl32 = wxApp::GetComCtl32Version();
 248     if ( verComCtl32 < 470 || verComCtl32 >= 600 )
 249     {
 250         if (style & wxNB_BOTTOM)
 251             style &= ~wxNB_BOTTOM;
 252
 253         if (style & wxNB_LEFT)
 254             style &= ~wxNB_LEFT;
 255
 256         if (style & wxNB_RIGHT)
 257             style &= ~wxNB_RIGHT;
 258     }
 259
 260     if ( !CreateControl(parent, id, pos, size, style | wxTAB_TRAVERSAL,
 261                         wxDefaultValidator, name) )
 262         return false;
 263
 264     if ( !MSWCreateControl(WC_TABCONTROL, wxEmptyString, pos, size) )
 265         return false;
 266
 267     return true;
 268 }
 269
 270 WXDWORD wxNotebook::MSWGetStyle(long style, WXDWORD *exstyle) const
 271 {
 272     WXDWORD tabStyle = wxControl::MSWGetStyle(style, exstyle);
 273
 274     tabStyle |= WS_TABSTOP | TCS_TABS;
 275
 276     if ( style & wxNB_MULTILINE )
 277         tabStyle |= TCS_MULTILINE;
 278     if ( style & wxNB_FIXEDWIDTH )
 279         tabStyle |= TCS_FIXEDWIDTH;
 280
 281     if ( style & wxNB_BOTTOM )
 282         tabStyle |= TCS_RIGHT;
 283     else if ( style & wxNB_LEFT )
 284         tabStyle |= TCS_VERTICAL;
 285     else if ( style & wxNB_RIGHT )
 286         tabStyle |= TCS_VERTICAL | TCS_RIGHT;
 287
 288     // ex style
 289     if ( exstyle )
 290     {
 291         // note that we never want to have the default WS_EX_CLIENTEDGE style
 292         // as it looks too ugly for the notebooks
 293         *exstyle = 0;
 294     }
 295
 296     return tabStyle;
 297 }
 298
 299 wxNotebook::~wxNotebook()
 300 {
 301 #if wxUSE_UXTHEME
 302     if ( m_hbrBackground )
 303         ::DeleteObject((HBRUSH)m_hbrBackground);
 304 #endif // wxUSE_UXTHEME
 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), wxNOT_FOUND, 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   InvalidateBestSize();
 557   return true;
 558 }
 559
 560 // same as AddPage() but does it at given position
 561 bool wxNotebook::InsertPage(size_t nPage,
 562                             wxNotebookPage *pPage,
 563                             const wxString& strText,
 564                             bool bSelect,
 565                             int imageId)
 566 {
 567     wxCHECK_MSG( pPage != NULL, false, _T("NULL page in wxNotebook::InsertPage") );
 568     wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false,
 569                  _T("invalid index in wxNotebook::InsertPage") );
 570
 571     wxASSERT_MSG( pPage->GetParent() == this,
 572                     _T("notebook pages must have notebook as parent") );
 573
 574     // add a new tab to the control
 575     // ----------------------------
 576
 577     // init all fields to 0
 578     TC_ITEM tcItem;
 579     wxZeroMemory(tcItem);
 580
 581     // set the image, if any
 582     if ( imageId != -1 )
 583     {
 584         tcItem.mask |= TCIF_IMAGE;
 585         tcItem.iImage  = imageId;
 586     }
 587
 588     // and the text
 589     if ( !strText.IsEmpty() )
 590     {
 591         tcItem.mask |= TCIF_TEXT;
 592         tcItem.pszText = (wxChar *)strText.c_str(); // const_cast
 593     }
 594
 595     // hide the page: unless it is selected, it shouldn't be shown (and if it
 596     // is selected it will be shown later)
 597     HWND hwnd = GetWinHwnd(pPage);
 598     SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);
 599
 600     // this updates internal flag too -- otherwise it would get out of sync
 601     // with the real state
 602     pPage->Show(false);
 603
 604
 605     // fit the notebook page to the tab control's display area: this should be
 606     // done before adding it to the notebook or TabCtrl_InsertItem() will
 607     // change the notebooks size itself!
 608     AdjustPageSize(pPage);
 609
 610     // finally do insert it
 611     if ( TabCtrl_InsertItem(m_hwnd, nPage, &tcItem) == -1 )
 612     {
 613         wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str());
 614
 615         return false;
 616     }
 617
 618     // succeeded: save the pointer to the page
 619     m_pages.Insert(pPage, nPage);
 620
 621     // we may need to adjust the size again if the notebook size changed:
 622     // normally this only happens for the first page we add (the tabs which
 623     // hadn't been there before are now shown) but for a multiline notebook it
 624     // can happen for any page at all as a new row could have been started
 625     if ( m_pages.GetCount() == 1 || HasFlag(wxNB_MULTILINE) )
 626     {
 627         AdjustPageSize(pPage);
 628     }
 629
 630     // now deal with the selection
 631     // ---------------------------
 632
 633     // if the inserted page is before the selected one, we must update the
 634     // index of the selected page
 635     if ( int(nPage) <= m_nSelection )
 636     {
 637         // one extra page added
 638         m_nSelection++;
 639     }
 640
 641     // some page should be selected: either this one or the first one if there
 642     // is still no selection
 643     int selNew = -1;
 644     if ( bSelect )
 645         selNew = nPage;
 646     else if ( m_nSelection == -1 )
 647         selNew = 0;
 648
 649     if ( selNew != -1 )
 650         SetSelection(selNew);
 651
 652     InvalidateBestSize();
 653     return true;
 654 }
 655
 656 int wxNotebook::HitTest(const wxPoint& pt, long *flags) const
 657 {
 658     TC_HITTESTINFO hitTestInfo;
 659     hitTestInfo.pt.x = pt.x;
 660     hitTestInfo.pt.y = pt.y;
 661     int item = TabCtrl_HitTest(GetHwnd(), &hitTestInfo);
 662
 663     if ( flags )
 664     {
 665         *flags = 0;
 666
 667         if ((hitTestInfo.flags & TCHT_NOWHERE) == TCHT_NOWHERE)
 668             *flags |= wxNB_HITTEST_NOWHERE;
 669         if ((hitTestInfo.flags & TCHT_ONITEM) == TCHT_ONITEM)
 670             *flags |= wxNB_HITTEST_ONITEM;
 671         if ((hitTestInfo.flags & TCHT_ONITEMICON) == TCHT_ONITEMICON)
 672             *flags |= wxNB_HITTEST_ONICON;
 673         if ((hitTestInfo.flags & TCHT_ONITEMLABEL) == TCHT_ONITEMLABEL)
 674             *flags |= wxNB_HITTEST_ONLABEL;
 675     }
 676
 677     return item;
 678 }
 679
 680
 681 // ----------------------------------------------------------------------------
 682 // wxNotebook callbacks
 683 // ----------------------------------------------------------------------------
 684
 685 void wxNotebook::OnSize(wxSizeEvent& event)
 686 {
 687   // fit the notebook page to the tab control's display area
 688   RECT rc;
 689   rc.left = rc.top = 0;
 690   GetSize((int *)&rc.right, (int *)&rc.bottom);
 691
 692   // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it
 693   // returns completely false values for multiline tab controls after the tabs
 694   // are added but before getting the first WM_SIZE (off by ~50 pixels, see
 695   //
 696   // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863
 697   //
 698   // and the only work around I could find was this ugly hack... without it
 699   // simply toggling the "multiline" checkbox in the notebook sample resulted
 700   // in a noticeable page displacement
 701   if ( HasFlag(wxNB_MULTILINE) )
 702   {
 703       // avoid an infinite recursion: we get another notification too!
 704       static bool s_isInOnSize = false;
 705
 706       if ( !s_isInOnSize )
 707       {
 708           s_isInOnSize = true;
 709           SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED,
 710                       MAKELPARAM(rc.right, rc.bottom));
 711           s_isInOnSize = false;
 712       }
 713   }
 714
 715   TabCtrl_AdjustRect(m_hwnd, false, &rc);
 716
 717   int width = rc.right - rc.left,
 718       height = rc.bottom - rc.top;
 719   size_t nCount = m_pages.Count();
 720   for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
 721     wxNotebookPage *pPage = m_pages[nPage];
 722     pPage->SetSize(rc.left, rc.top, width, height);
 723   }
 724
 725 #if wxUSE_UXTHEME
 726   UpdateBgBrush();
 727 #endif // wxUSE_UXTHEME
 728
 729   event.Skip();
 730 }
 731
 732 void wxNotebook::OnSelChange(wxNotebookEvent& event)
 733 {
 734   // is it our tab control?
 735   if ( event.GetEventObject() == this )
 736   {
 737       int sel = event.GetOldSelection();
 738       if ( sel != -1 )
 739         m_pages[sel]->Show(false);
 740
 741       sel = event.GetSelection();
 742       if ( sel != -1 )
 743       {
 744         wxNotebookPage *pPage = m_pages[sel];
 745         pPage->Show(true);
 746         pPage->SetFocus();
 747
 748         // If the newly focused window is not a child of the new page,
 749         // SetFocus was not successful and the notebook itself should be
 750         // focused
 751         wxWindow *currentFocus = FindFocus();
 752         wxWindow *startFocus = currentFocus;
 753         while ( currentFocus && currentFocus != pPage && currentFocus != this )
 754             currentFocus = currentFocus->GetParent();
 755
 756         if ( startFocus == pPage || currentFocus != pPage )
 757             SetFocus();
 758
 759       }
 760       else // no pages in the notebook, give the focus to itself
 761       {
 762           SetFocus();
 763       }
 764
 765       m_nSelection = sel;
 766   }
 767
 768   // we want to give others a chance to process this message as well
 769   event.Skip();
 770 }
 771
 772 bool wxNotebook::MSWTranslateMessage(WXMSG *wxmsg)
 773 {
 774     const MSG * const msg = (MSG *)wxmsg;
 775
 776     // intercept TAB, CTRL+TAB and CTRL+SHIFT+TAB for processing by wxNotebook.
 777     // TAB will be passed to the currently selected page, CTRL+TAB and
 778     // CTRL+SHIFT+TAB will be processed by the notebook itself. do not
 779     // intercept SHIFT+TAB. This goes to the parent of the notebook which will
 780     // process it.
 781     if ( msg->message == WM_KEYDOWN && msg->wParam == VK_TAB &&
 782             msg->hwnd == m_hwnd &&
 783                 (wxIsCtrlDown() || !wxIsShiftDown()) )
 784     {
 785         return MSWProcessMessage(wxmsg);
 786     }
 787
 788     return false;
 789 }
 790
 791 void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
 792 {
 793     if ( event.IsWindowChange() ) {
 794         // change pages
 795         AdvanceSelection(event.GetDirection());
 796     }
 797     else {
 798         // we get this event in 3 cases
 799         //
 800         // a) one of our pages might have generated it because the user TABbed
 801         // out from it in which case we should propagate the event upwards and
 802         // our parent will take care of setting the focus to prev/next sibling
 803         //
 804         // or
 805         //
 806         // b) the parent panel wants to give the focus to us so that we
 807         // forward it to our selected page. We can't deal with this in
 808         // OnSetFocus() because we don't know which direction the focus came
 809         // from in this case and so can't choose between setting the focus to
 810         // first or last panel child
 811         //
 812         // or
 813         //
 814         // c) we ourselves (see MSWTranslateMessage) generated the event
 815         //
 816         wxWindow * const parent = GetParent();
 817
 818         const bool isFromParent = event.GetEventObject() == parent;
 819         const bool isFromSelf = event.GetEventObject() == this;
 820
 821         if ( isFromParent || isFromSelf )
 822         {
 823             // no, it doesn't come from child, case (b) or (c): forward to a
 824             // page but only if direction is backwards (TAB) or from ourselves,
 825             if ( m_nSelection != -1 &&
 826                     (!event.GetDirection() || isFromSelf) )
 827             {
 828                 // so that the page knows that the event comes from it's parent
 829                 // and is being propagated downwards
 830                 event.SetEventObject(this);
 831
 832                 wxWindow *page = m_pages[m_nSelection];
 833                 if ( !page->GetEventHandler()->ProcessEvent(event) )
 834                 {
 835                     page->SetFocus();
 836                 }
 837                 //else: page manages focus inside it itself
 838             }
 839             else // otherwise set the focus to the notebook itself
 840             {
 841                 SetFocus();
 842             }
 843         }
 844         else
 845         {
 846             // it comes from our child, case (a), pass to the parent, but only
 847             // if the direction is forwards. Otherwise set the focus to the
 848             // notebook itself. The notebook is always the 'first' control of a
 849             // page.
 850             if ( !event.GetDirection() )
 851             {
 852                 SetFocus();
 853             }
 854             else if ( parent )
 855             {
 856                 event.SetCurrentFocus(this);
 857                 parent->GetEventHandler()->ProcessEvent(event);
 858             }
 859         }
 860     }
 861 }
 862
 863 #if wxUSE_UXTHEME
 864
 865 void wxNotebook::UpdateBgBrush()
 866 {
 867     if ( m_hbrBackground )
 868         ::DeleteObject((HBRUSH)m_hbrBackground);
 869
 870     if ( wxUxThemeEngine::GetIfActive() )
 871     {
 872         RECT rc;
 873         GetWindowRect(GetHwnd(), &rc);
 874
 875         WindowHDC hDC(GetHwnd());
 876         MemoryHDC hDCMem(hDC);
 877         CompatibleBitmap hBmp(hDC, rc.right - rc.left, rc.bottom - rc.top);
 878
 879         SelectInHDC selectBmp(hDCMem, hBmp);
 880
 881         SendMessage(GetHwnd(), WM_PRINTCLIENT, (WPARAM)(HDC)hDCMem,
 882                     PRF_ERASEBKGND | PRF_CLIENT | PRF_NONCLIENT);
 883
 884         m_hbrBackground = (WXHBRUSH)::CreatePatternBrush(hBmp);
 885     }
 886     else // no themes
 887     {
 888         m_hbrBackground = NULL;
 889     }
 890 }
 891
 892 WXHBRUSH wxNotebook::GetThemeBackgroundBrush(WXHDC hDC, wxWindow *win) const
 893 {
 894     if ( m_hbrBackground )
 895     {
 896         // before drawing with the background brush, we need to position it
 897         // correctly
 898         RECT rc;
 899         ::GetWindowRect(GetHwndOf(win), &rc);
 900
 901         ::MapWindowPoints(NULL, GetHwnd(), (POINT *)&rc, 1);
 902
 903         if ( !::SetBrushOrgEx((HDC)hDC, -rc.left, -rc.top, NULL) )
 904         {
 905             wxLogLastError(_T("SetBrushOrgEx(notebook bg brush)"));
 906         }
 907     }
 908
 909     return m_hbrBackground;
 910 }
 911
 912 void wxNotebook::DoEraseBackground(wxEraseEvent& event)
 913 {
 914     DoEraseBackground((wxWindow *)event.GetEventObject(),
 915                       (WXHDC)GetHdcOf(*event.GetDC()));
 916 }
 917
 918 void wxNotebook::DoEraseBackground(wxWindow *win, WXHDC hDC)
 919 {
 920     // we can either draw the background ourselves or let DrawThemeBackground()
 921     // do it, but as we already have the correct brush, let's do it ourselves
 922     // (note that we use the same code in wxControl::MSWControlColor(), so if
 923     // it breaks, it should at least break in consistent way)
 924     WXHBRUSH hbr = GetThemeBackgroundBrush(hDC, win);
 925     if ( hbr )
 926     {
 927         RECT rectClient;
 928         ::GetClientRect(GetHwndOf(win), &rectClient);
 929         ::FillRect((HDC)hDC, &rectClient, (HBRUSH)hbr);
 930     }
 931 }
 932
 933 #endif // wxUSE_UXTHEME
 934
 935 // ----------------------------------------------------------------------------
 936 // wxNotebook base class virtuals
 937 // ----------------------------------------------------------------------------
 938
 939 #if wxUSE_CONSTRAINTS
 940
 941 // override these 2 functions to do nothing: everything is done in OnSize
 942
 943 void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse))
 944 {
 945   // don't set the sizes of the pages - their correct size is not yet known
 946   wxControl::SetConstraintSizes(false);
 947 }
 948
 949 bool wxNotebook::DoPhase(int WXUNUSED(nPhase))
 950 {
 951   return true;
 952 }
 953
 954 #endif // wxUSE_CONSTRAINTS
 955
 956 // ----------------------------------------------------------------------------
 957 // wxNotebook Windows message handlers
 958 // ----------------------------------------------------------------------------
 959
 960 bool wxNotebook::MSWOnScroll(int orientation, WXWORD nSBCode,
 961                              WXWORD pos, WXHWND control)
 962 {
 963     // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the
 964     // up-down control
 965     if ( control )
 966         return false;
 967
 968     return wxNotebookBase::MSWOnScroll(orientation, nSBCode, pos, control);
 969 }
 970
 971 bool wxNotebook::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM* result)
 972 {
 973   wxNotebookEvent event(wxEVT_NULL, m_windowId);
 974
 975   NMHDR* hdr = (NMHDR *)lParam;
 976   switch ( hdr->code ) {
 977     case TCN_SELCHANGE:
 978       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
 979       break;
 980
 981     case TCN_SELCHANGING:
 982       event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING);
 983       break;
 984
 985     default:
 986       return wxControl::MSWOnNotify(idCtrl, lParam, result);
 987   }
 988
 989   event.SetSelection(TabCtrl_GetCurSel(m_hwnd));
 990   event.SetOldSelection(m_nSelection);
 991   event.SetEventObject(this);
 992   event.SetInt(idCtrl);
 993
 994   bool processed = GetEventHandler()->ProcessEvent(event);
 995   *result = !event.IsAllowed();
 996   return processed;
 997 }
 998
 999 #endif // wxUSE_NOTEBOOK