src/msw/notebook.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        msw/notebook.cpp
// Purpose:     implementation of wxNotebook
// Author:      Vadim Zeitlin
// Modified by:
// Created:     11.06.98
// RCS-ID:      $Id$
// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows license
///////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "notebook.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

// wxWindows
#ifndef WX_PRECOMP
  #include  <wx/string.h>
#endif  // WX_PRECOMP

#include  <wx/log.h>
#include  <wx/imaglist.h>
#include  <wx/event.h>
#include  <wx/control.h>
#include  <wx/notebook.h>

#include  <wx/msw/private.h>

// Windows standard headers
#ifndef   __WIN95__
  #error  "wxNotebook is only supported Windows 95 and above"
#endif    //Win95

#include  <windowsx.h>  // for SetWindowFont

#ifndef __TWIN32__
#ifdef __GNUWIN32__
  #include "wx/msw/gnuwin32/extra.h"
#endif
#endif

#if !defined(__GNUWIN32__) || defined(__TWIN32__)
  #include <commctrl.h>
#endif

// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------

// check that the page index is valid
#define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount()))

// hide the ugly cast
#define m_hwnd    (HWND)GetHWND()

// ----------------------------------------------------------------------------
// event table
// ----------------------------------------------------------------------------

#if !USE_SHARED_LIBRARIES
  BEGIN_EVENT_TABLE(wxNotebook, wxControl)
    EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)

    EVT_SIZE(wxNotebook::OnSize)
    EVT_ERASE_BACKGROUND(wxNotebook::OnEraseBackground)
    EVT_SET_FOCUS(wxNotebook::OnSetFocus)
    EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
  END_EVENT_TABLE()

  IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
  IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent)
#endif

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxNotebook construction
// ----------------------------------------------------------------------------

// common part of all ctors
void wxNotebook::Init()
{
  m_pImageList = NULL;
  m_nSelection = -1;
}

// default for dynamic class
wxNotebook::wxNotebook()
{
  Init();
}

// the same arguments as for wxControl
wxNotebook::wxNotebook(wxWindow *parent,
                       wxWindowID id,
                       const wxPoint& pos,
                       const wxSize& size,
                       long style,
                       const wxString& name)
{
  Init();

  Create(parent, id, pos, size, style, name);
}

// Create() function
bool wxNotebook::Create(wxWindow *parent,
                        wxWindowID id,
                        const wxPoint& pos,
                        const wxSize& size,
                        long style,
                        const wxString& name)
{
  // base init
  SetName(name);
  SetParent(parent);

  m_windowId = id == -1 ? NewControlId() : id;

  // colors and font
  m_backgroundColour = wxColour(GetSysColor(COLOR_BTNFACE));
  m_foregroundColour = *wxBLACK ;

  // style
  m_windowStyle = style | wxTAB_TRAVERSAL;

  long tabStyle = WS_CHILD | WS_VISIBLE | WS_TABSTOP | TCS_TABS;
  if ( m_windowStyle & wxTC_MULTILINE )
    tabStyle |= TCS_MULTILINE;
  if ( m_windowStyle & wxBORDER )
    tabStyle &= WS_BORDER;

  // create the tab control.
  m_hWnd = (WXHWND)CreateWindowEx
    (
      0,                                      // extended style
      WC_TABCONTROL,                          // class name for the tab control
      "",                                     // no caption
      tabStyle,                               // style
      pos.x, pos.y, size.x, size.y,           // size and position
      (HWND)parent->GetHWND(),                // parent window
      (HMENU)m_windowId,                      // child id
      wxGetInstance(),                        // current instance
      NULL                                    // no class data
    );

  if ( m_hWnd == 0 ) {
    wxLogSysError("Can't create the notebook control");
    return FALSE;
  }

  // Not all compilers recognise SetWindowFont
//  SetWindowFont((HWND)m_hwnd, ::GetStockObject(DEFAULT_GUI_FONT), FALSE);
  ::SendMessage((HWND) m_hwnd, WM_SETFONT,
                  (WPARAM)::GetStockObject(DEFAULT_GUI_FONT),TRUE);


  if ( parent != NULL )
    parent->AddChild(this);

  SubclassWin(m_hWnd);

  return TRUE;
}

// dtor
wxNotebook::~wxNotebook()
{
}

// ----------------------------------------------------------------------------
// wxNotebook accessors
// ----------------------------------------------------------------------------
int wxNotebook::GetPageCount() const
{
  // consistency check
  wxASSERT( (int)m_aPages.Count() == TabCtrl_GetItemCount(m_hwnd) );

  return m_aPages.Count();
}

int wxNotebook::GetRowCount() const
{
  return TabCtrl_GetRowCount(m_hwnd);
}

int wxNotebook::SetSelection(int nPage)
{
  wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, "notebook page out of range" );

  ChangePage(m_nSelection, nPage);

  return TabCtrl_SetCurSel(m_hwnd, nPage);
}

void wxNotebook::AdvanceSelection(bool bForward)
{
  int nSel = GetSelection();
  int nMax = GetPageCount() - 1;
  if ( bForward )
    SetSelection(nSel == nMax ? 0 : nSel + 1);
  else
    SetSelection(nSel == 0 ? nMax : nSel - 1);
}

bool wxNotebook::SetPageText(int nPage, const wxString& strText)
{
  wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, "notebook page out of range" );

  TC_ITEM tcItem;
  tcItem.mask = TCIF_TEXT;
  tcItem.pszText = (char *)strText.c_str();

  return TabCtrl_SetItem(m_hwnd, nPage, &tcItem) != 0;
}

wxString wxNotebook::GetPageText(int nPage) const
{
  wxCHECK_MSG( IS_VALID_PAGE(nPage), "", "notebook page out of range" );

  char buf[256];
  TC_ITEM tcItem;
  tcItem.mask = TCIF_TEXT;
  tcItem.pszText = buf;
  tcItem.cchTextMax = WXSIZEOF(buf);

  wxString str;
  if ( TabCtrl_GetItem(m_hwnd, nPage, &tcItem) )
    str = tcItem.pszText;

  return str;
}

int wxNotebook::GetPageImage(int nPage) const
{
  wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, "notebook page out of range" );

  TC_ITEM tcItem;
  tcItem.mask = TCIF_IMAGE;

  return TabCtrl_GetItem(m_hwnd, nPage, &tcItem) ? tcItem.iImage : -1;
}

bool wxNotebook::SetPageImage(int nPage, int nImage)
{
  wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, "notebook page out of range" );

  TC_ITEM tcItem;
  tcItem.mask = TCIF_IMAGE;
  tcItem.iImage = nImage;

  return TabCtrl_SetItem(m_hwnd, nPage, &tcItem) != 0;
}

void wxNotebook::SetImageList(wxImageList* imageList)
{
  m_pImageList = imageList;
  TabCtrl_SetImageList(m_hwnd, (HIMAGELIST)imageList->GetHIMAGELIST());
}

// ----------------------------------------------------------------------------
// wxNotebook operations
// ----------------------------------------------------------------------------

// remove one page from the notebook
bool wxNotebook::DeletePage(int nPage)
{
  wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, "notebook page out of range" );

  TabCtrl_DeleteItem(m_hwnd, nPage);

  delete m_aPages[nPage];
  m_aPages.Remove(nPage);

  return TRUE;
}

// remove one page from the notebook, without deleting
bool wxNotebook::RemovePage(int nPage)
{
  wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, "notebook page out of range" );

  TabCtrl_DeleteItem(m_hwnd, nPage);

  m_aPages.Remove(nPage);

  return TRUE;
}

// remove all pages
bool wxNotebook::DeleteAllPages()
{
  TabCtrl_DeleteAllItems(m_hwnd);

  int nPageCount = GetPageCount();
  int nPage;
  for ( nPage = 0; nPage < nPageCount; nPage++ )
    delete m_aPages[nPage];

  m_aPages.Clear();

  return TRUE;
}

// add a page to the notebook
bool wxNotebook::AddPage(wxNotebookPage *pPage,
                         const wxString& strText,
                         bool bSelect,
                         int imageId)
{
  return InsertPage(GetPageCount(), pPage, strText, bSelect, imageId);
}

// same as AddPage() but does it at given position
bool wxNotebook::InsertPage(int nPage,
                            wxNotebookPage *pPage,
                            const wxString& strText,
                            bool bSelect,
                            int imageId)
{
  wxASSERT( pPage != NULL );
  wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), FALSE );

  // add the tab to the control
  TC_ITEM tcItem;
  tcItem.mask    = TCIF_TEXT | TCIF_IMAGE;
  tcItem.pszText = (char *)strText.c_str();
  tcItem.iImage  = imageId;

  if ( TabCtrl_InsertItem(m_hwnd, nPage, &tcItem) == -1 ) {
    wxLogError("Can't create the notebook page '%s'.", strText.c_str());
    return FALSE;
  }

  // save the pointer to the page
  m_aPages.Insert(pPage, nPage);

  // some page must be selected: either this one or the first one if there is
  // still no selection
  if ( bSelect )
    m_nSelection = nPage;
  else if ( m_nSelection == -1 )
    m_nSelection = 0;

  // don't show pages by default (we'll need to adjust their size first)
  HWND hwnd = (HWND)pPage->GetHWND();
  SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);

  return TRUE;
}

// ----------------------------------------------------------------------------
// wxNotebook callbacks
// ----------------------------------------------------------------------------

void wxNotebook::OnSize(wxSizeEvent& event)
{
  // make sure the current page is shown and has focus (it's useful because all
  // pages are created invisible initially)
  if ( m_nSelection != -1 ) {
    wxNotebookPage *pPage = m_aPages[m_nSelection];
    pPage->Show(TRUE);
    pPage->SetFocus();
  }

  // fit the notebook page to the tab control's display area
  RECT rc;
  rc.left = rc.top = 0;
  GetSize((int *)&rc.right, (int *)&rc.bottom);

  TabCtrl_AdjustRect(m_hwnd, FALSE, &rc);
  size_t nCount = m_aPages.Count();
  for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
    wxNotebookPage *pPage = m_aPages[nPage];
    pPage->SetSize(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
    if ( pPage->GetAutoLayout() )
      pPage->Layout();
  }

  event.Skip();
}

void wxNotebook::OnSelChange(wxNotebookEvent& event)
{
  // is it our tab control?
  if ( event.GetEventObject() == this )
    ChangePage(event.GetOldSelection(), event.GetSelection());

  // we want to give others a chance to process this message as well
  event.Skip();
}

void wxNotebook::OnSetFocus(wxFocusEvent& event)
{
  // set focus to the currently selected page if any
  if ( m_nSelection != -1 )
    m_aPages[m_nSelection]->SetFocus();

  event.Skip();
}

void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
{
  if ( event.IsWindowChange() ) {
    // change pages
    AdvanceSelection(event.GetDirection());
  }
  else {
    // pass to the parent
    if ( GetParent() ) {
      event.SetCurrentFocus(this);
      GetParent()->GetEventHandler()->ProcessEvent(event);
    }
  }
}

// ----------------------------------------------------------------------------
// wxNotebook base class virtuals
// ----------------------------------------------------------------------------

// override these 2 functions to do nothing: everything is done in OnSize

void wxNotebook::SetConstraintSizes(bool /* recurse */)
{
  // don't set the sizes of the pages - their correct size is not yet known
  wxControl::SetConstraintSizes(FALSE);
}

bool wxNotebook::DoPhase(int /* nPhase */)
{
  return TRUE;
}

void wxNotebook::Command(wxCommandEvent& event)
{
  wxFAIL_MSG("wxNotebook::Command not implemented");
}

bool wxNotebook::MSWNotify(WXWPARAM wParam, WXLPARAM lParam, WXLPARAM* result)
{
  wxNotebookEvent event(wxEVT_NULL, m_windowId);

  NMHDR* hdr = (NMHDR *)lParam;
  switch ( hdr->code ) {
    case TCN_SELCHANGE:
      event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
      break;

    case TCN_SELCHANGING:
      event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING);
      break;

    default:
      return wxControl::MSWNotify(wParam, lParam, result);
  }

  event.SetSelection(TabCtrl_GetCurSel(m_hwnd));
  event.SetOldSelection(m_nSelection);
  event.SetEventObject(this);
  event.SetInt(LOWORD(wParam)); // ctrl id

  bool processed = GetEventHandler()->ProcessEvent(event);
  *result = !event.IsAllowed();
  return processed;
}

// ----------------------------------------------------------------------------
// wxNotebook helper functions
// ----------------------------------------------------------------------------

// hide the currently active panel and show the new one
void wxNotebook::ChangePage(int nOldSel, int nSel)
{
  // MT-FIXME should use a real semaphore
  static bool s_bInsideChangePage = FALSE;

  // when we call ProcessEvent(), our own OnSelChange() is called which calls
  // this function - break the infinite loop
  if ( s_bInsideChangePage )
    return;

  // it's not an error (the message may be generated by the tab control itself)
  // and it may happen - just do nothing
  if ( nSel == nOldSel )
    return;

  s_bInsideChangePage = TRUE;

  wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId);
  event.SetSelection(nSel);
  event.SetOldSelection(nOldSel);
  event.SetEventObject(this);
  if ( ProcessEvent(event) && !event.IsAllowed() )
  {
    // program doesn't allow the page change
    s_bInsideChangePage = FALSE;
    return;
  }

  if ( nOldSel != -1 )
    m_aPages[nOldSel]->Show(FALSE);

  wxNotebookPage *pPage = m_aPages[nSel];
  pPage->Show(TRUE);
  pPage->SetFocus();

  event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
  ProcessEvent(event);

  m_nSelection = nSel;
  s_bInsideChangePage = FALSE;
}

void wxNotebook::OnEraseBackground(wxEraseEvent& event)
{
    Default();
}
Commit	Line	Data
	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 license
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	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	// wxWindows
	24	#ifndef WX_PRECOMP
	25	#include <wx/string.h>
	26	#endif // WX_PRECOMP
	27
	28	#include <wx/log.h>
	29	#include <wx/imaglist.h>
	30	#include <wx/event.h>
	31	#include <wx/control.h>
	32	#include <wx/notebook.h>
	33
	34	#include <wx/msw/private.h>
	35
	36	// Windows standard headers
	37	#ifndef __WIN95__
	38	#error "wxNotebook is only supported Windows 95 and above"
	39	#endif //Win95
	40
	41	#include <windowsx.h> // for SetWindowFont
	42
	43	#ifndef __TWIN32__
	44	#ifdef __GNUWIN32__
	45	#include "wx/msw/gnuwin32/extra.h"
	46	#endif
	47	#endif
	48
	49	#if !defined(__GNUWIN32__) \|\| defined(__TWIN32__)
	50	#include <commctrl.h>
	51	#endif
	52
	53	// ----------------------------------------------------------------------------
	54	// macros
	55	// ----------------------------------------------------------------------------
	56
	57	// check that the page index is valid
	58	#define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount()))
	59
	60	// hide the ugly cast
	61	#define m_hwnd (HWND)GetHWND()
	62
	63	// ----------------------------------------------------------------------------
	64	// event table
	65	// ----------------------------------------------------------------------------
	66
	67	#if !USE_SHARED_LIBRARIES
	68	BEGIN_EVENT_TABLE(wxNotebook, wxControl)
	69	EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
	70
	71	EVT_SIZE(wxNotebook::OnSize)
	72	EVT_ERASE_BACKGROUND(wxNotebook::OnEraseBackground)
	73	EVT_SET_FOCUS(wxNotebook::OnSetFocus)
	74	EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
	75	END_EVENT_TABLE()
	76
	77	IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
	78	IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent)
	79	#endif
	80
	81	// ============================================================================
	82	// implementation
	83	// ============================================================================
	84
	85	// ----------------------------------------------------------------------------
	86	// wxNotebook construction
	87	// ----------------------------------------------------------------------------
	88
	89	// common part of all ctors
	90	void wxNotebook::Init()
	91	{
	92	m_pImageList = NULL;
	93	m_nSelection = -1;
	94	}
	95
	96	// default for dynamic class
	97	wxNotebook::wxNotebook()
	98	{
	99	Init();
	100	}
	101
	102	// the same arguments as for wxControl
	103	wxNotebook::wxNotebook(wxWindow *parent,
	104	wxWindowID id,
	105	const wxPoint& pos,
	106	const wxSize& size,
	107	long style,
	108	const wxString& name)
	109	{
	110	Init();
	111
	112	Create(parent, id, pos, size, style, name);
	113	}
	114
	115	// Create() function
	116	bool wxNotebook::Create(wxWindow *parent,
	117	wxWindowID id,
	118	const wxPoint& pos,
	119	const wxSize& size,
	120	long style,
	121	const wxString& name)
	122	{
	123	// base init
	124	SetName(name);
	125	SetParent(parent);
	126
	127	m_windowId = id == -1 ? NewControlId() : id;
	128
	129	// colors and font
	130	m_backgroundColour = wxColour(GetSysColor(COLOR_BTNFACE));
	131	m_foregroundColour = *wxBLACK ;
	132
	133	// style
	134	m_windowStyle = style \| wxTAB_TRAVERSAL;
	135
	136	long tabStyle = WS_CHILD \| WS_VISIBLE \| WS_TABSTOP \| TCS_TABS;
	137	if ( m_windowStyle & wxTC_MULTILINE )
	138	tabStyle \|= TCS_MULTILINE;
	139	if ( m_windowStyle & wxBORDER )
	140	tabStyle &= WS_BORDER;
	141
	142	// create the tab control.
	143	m_hWnd = (WXHWND)CreateWindowEx
	144	(
	145	0, // extended style
	146	WC_TABCONTROL, // class name for the tab control
	147	"", // no caption
	148	tabStyle, // style
	149	pos.x, pos.y, size.x, size.y, // size and position
	150	(HWND)parent->GetHWND(), // parent window
	151	(HMENU)m_windowId, // child id
	152	wxGetInstance(), // current instance
	153	NULL // no class data
	154	);
	155
	156	if ( m_hWnd == 0 ) {
	157	wxLogSysError("Can't create the notebook control");
	158	return FALSE;
	159	}
	160
	161	// Not all compilers recognise SetWindowFont
	162	// SetWindowFont((HWND)m_hwnd, ::GetStockObject(DEFAULT_GUI_FONT), FALSE);
	163	::SendMessage((HWND) m_hwnd, WM_SETFONT,
	164	(WPARAM)::GetStockObject(DEFAULT_GUI_FONT),TRUE);
	165
	166
	167	if ( parent != NULL )
	168	parent->AddChild(this);
	169
	170	SubclassWin(m_hWnd);
	171
	172	return TRUE;
	173	}
	174
	175	// dtor
	176	wxNotebook::~wxNotebook()
	177	{
	178	}
	179
	180	// ----------------------------------------------------------------------------
	181	// wxNotebook accessors
	182	// ----------------------------------------------------------------------------
	183	int wxNotebook::GetPageCount() const
	184	{
	185	// consistency check
	186	wxASSERT( (int)m_aPages.Count() == TabCtrl_GetItemCount(m_hwnd) );
	187
	188	return m_aPages.Count();
	189	}
	190
	191	int wxNotebook::GetRowCount() const
	192	{
	193	return TabCtrl_GetRowCount(m_hwnd);
	194	}
	195
	196	int wxNotebook::SetSelection(int nPage)
	197	{
	198	wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, "notebook page out of range" );
	199
	200	ChangePage(m_nSelection, nPage);
	201
	202	return TabCtrl_SetCurSel(m_hwnd, nPage);
	203	}
	204
	205	void wxNotebook::AdvanceSelection(bool bForward)
	206	{
	207	int nSel = GetSelection();
	208	int nMax = GetPageCount() - 1;
	209	if ( bForward )
	210	SetSelection(nSel == nMax ? 0 : nSel + 1);
	211	else
	212	SetSelection(nSel == 0 ? nMax : nSel - 1);
	213	}
	214
	215	bool wxNotebook::SetPageText(int nPage, const wxString& strText)
	216	{
	217	wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, "notebook page out of range" );
	218
	219	TC_ITEM tcItem;
	220	tcItem.mask = TCIF_TEXT;
	221	tcItem.pszText = (char *)strText.c_str();
	222
	223	return TabCtrl_SetItem(m_hwnd, nPage, &tcItem) != 0;
	224	}
	225
	226	wxString wxNotebook::GetPageText(int nPage) const
	227	{
	228	wxCHECK_MSG( IS_VALID_PAGE(nPage), "", "notebook page out of range" );
	229
	230	char buf[256];
	231	TC_ITEM tcItem;
	232	tcItem.mask = TCIF_TEXT;
	233	tcItem.pszText = buf;
	234	tcItem.cchTextMax = WXSIZEOF(buf);
	235
	236	wxString str;
	237	if ( TabCtrl_GetItem(m_hwnd, nPage, &tcItem) )
	238	str = tcItem.pszText;
	239
	240	return str;
	241	}
	242
	243	int wxNotebook::GetPageImage(int nPage) const
	244	{
	245	wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, "notebook page out of range" );
	246
	247	TC_ITEM tcItem;
	248	tcItem.mask = TCIF_IMAGE;
	249
	250	return TabCtrl_GetItem(m_hwnd, nPage, &tcItem) ? tcItem.iImage : -1;
	251	}
	252
	253	bool wxNotebook::SetPageImage(int nPage, int nImage)
	254	{
	255	wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, "notebook page out of range" );
	256
	257	TC_ITEM tcItem;
	258	tcItem.mask = TCIF_IMAGE;
	259	tcItem.iImage = nImage;
	260
	261	return TabCtrl_SetItem(m_hwnd, nPage, &tcItem) != 0;
	262	}
	263
	264	void wxNotebook::SetImageList(wxImageList* imageList)
	265	{
	266	m_pImageList = imageList;
	267	TabCtrl_SetImageList(m_hwnd, (HIMAGELIST)imageList->GetHIMAGELIST());
	268	}
	269
	270	// ----------------------------------------------------------------------------
	271	// wxNotebook operations
	272	// ----------------------------------------------------------------------------
	273
	274	// remove one page from the notebook
	275	bool wxNotebook::DeletePage(int nPage)
	276	{
	277	wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, "notebook page out of range" );
	278
	279	TabCtrl_DeleteItem(m_hwnd, nPage);
	280
	281	delete m_aPages[nPage];
	282	m_aPages.Remove(nPage);
	283
	284	return TRUE;
	285	}
	286
	287	// remove one page from the notebook, without deleting
	288	bool wxNotebook::RemovePage(int nPage)
	289	{
	290	wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, "notebook page out of range" );
	291
	292	TabCtrl_DeleteItem(m_hwnd, nPage);
	293
	294	m_aPages.Remove(nPage);
	295
	296	return TRUE;
	297	}
	298
	299	// remove all pages
	300	bool wxNotebook::DeleteAllPages()
	301	{
	302	TabCtrl_DeleteAllItems(m_hwnd);
	303
	304	int nPageCount = GetPageCount();
	305	int nPage;
	306	for ( nPage = 0; nPage < nPageCount; nPage++ )
	307	delete m_aPages[nPage];
	308
	309	m_aPages.Clear();
	310
	311	return TRUE;
	312	}
	313
	314	// add a page to the notebook
	315	bool wxNotebook::AddPage(wxNotebookPage *pPage,
	316	const wxString& strText,
	317	bool bSelect,
	318	int imageId)
	319	{
	320	return InsertPage(GetPageCount(), pPage, strText, bSelect, imageId);
	321	}
	322
	323	// same as AddPage() but does it at given position
	324	bool wxNotebook::InsertPage(int nPage,
	325	wxNotebookPage *pPage,
	326	const wxString& strText,
	327	bool bSelect,
	328	int imageId)
	329	{
	330	wxASSERT( pPage != NULL );
	331	wxCHECK( IS_VALID_PAGE(nPage) \|\| nPage == GetPageCount(), FALSE );
	332
	333	// add the tab to the control
	334	TC_ITEM tcItem;
	335	tcItem.mask = TCIF_TEXT \| TCIF_IMAGE;
	336	tcItem.pszText = (char *)strText.c_str();
	337	tcItem.iImage = imageId;
	338
	339	if ( TabCtrl_InsertItem(m_hwnd, nPage, &tcItem) == -1 ) {
	340	wxLogError("Can't create the notebook page '%s'.", strText.c_str());
	341	return FALSE;
	342	}
	343
	344	// save the pointer to the page
	345	m_aPages.Insert(pPage, nPage);
	346
	347	// some page must be selected: either this one or the first one if there is
	348	// still no selection
	349	if ( bSelect )
	350	m_nSelection = nPage;
	351	else if ( m_nSelection == -1 )
	352	m_nSelection = 0;
	353
	354	// don't show pages by default (we'll need to adjust their size first)
	355	HWND hwnd = (HWND)pPage->GetHWND();
	356	SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE);
	357
	358	return TRUE;
	359	}
	360
	361	// ----------------------------------------------------------------------------
	362	// wxNotebook callbacks
	363	// ----------------------------------------------------------------------------
	364
	365	void wxNotebook::OnSize(wxSizeEvent& event)
	366	{
	367	// make sure the current page is shown and has focus (it's useful because all
	368	// pages are created invisible initially)
	369	if ( m_nSelection != -1 ) {
	370	wxNotebookPage *pPage = m_aPages[m_nSelection];
	371	pPage->Show(TRUE);
	372	pPage->SetFocus();
	373	}
	374
	375	// fit the notebook page to the tab control's display area
	376	RECT rc;
	377	rc.left = rc.top = 0;
	378	GetSize((int )&rc.right, (int )&rc.bottom);
	379
	380	TabCtrl_AdjustRect(m_hwnd, FALSE, &rc);
	381	size_t nCount = m_aPages.Count();
	382	for ( size_t nPage = 0; nPage < nCount; nPage++ ) {
	383	wxNotebookPage *pPage = m_aPages[nPage];
	384	pPage->SetSize(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
	385	if ( pPage->GetAutoLayout() )
	386	pPage->Layout();
	387	}
	388
	389	event.Skip();
	390	}
	391
	392	void wxNotebook::OnSelChange(wxNotebookEvent& event)
	393	{
	394	// is it our tab control?
	395	if ( event.GetEventObject() == this )
	396	ChangePage(event.GetOldSelection(), event.GetSelection());
	397
	398	// we want to give others a chance to process this message as well
	399	event.Skip();
	400	}
	401
	402	void wxNotebook::OnSetFocus(wxFocusEvent& event)
	403	{
	404	// set focus to the currently selected page if any
	405	if ( m_nSelection != -1 )
	406	m_aPages[m_nSelection]->SetFocus();
	407
	408	event.Skip();
	409	}
	410
	411	void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
	412	{
	413	if ( event.IsWindowChange() ) {
	414	// change pages
	415	AdvanceSelection(event.GetDirection());
	416	}
	417	else {
	418	// pass to the parent
	419	if ( GetParent() ) {
	420	event.SetCurrentFocus(this);
	421	GetParent()->GetEventHandler()->ProcessEvent(event);
	422	}
	423	}
	424	}
	425
	426	// ----------------------------------------------------------------------------
	427	// wxNotebook base class virtuals
	428	// ----------------------------------------------------------------------------
	429
	430	// override these 2 functions to do nothing: everything is done in OnSize
	431
	432	void wxNotebook::SetConstraintSizes(bool /* recurse */)
	433	{
	434	// don't set the sizes of the pages - their correct size is not yet known
	435	wxControl::SetConstraintSizes(FALSE);
	436	}
	437
	438	bool wxNotebook::DoPhase(int /* nPhase */)
	439	{
	440	return TRUE;
	441	}
	442
	443	void wxNotebook::Command(wxCommandEvent& event)
	444	{
	445	wxFAIL_MSG("wxNotebook::Command not implemented");
	446	}
	447
	448	bool wxNotebook::MSWNotify(WXWPARAM wParam, WXLPARAM lParam, WXLPARAM* result)
	449	{
	450	wxNotebookEvent event(wxEVT_NULL, m_windowId);
	451
	452	NMHDR* hdr = (NMHDR *)lParam;
	453	switch ( hdr->code ) {
	454	case TCN_SELCHANGE:
	455	event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
	456	break;
	457
	458	case TCN_SELCHANGING:
	459	event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING);
	460	break;
	461
	462	default:
	463	return wxControl::MSWNotify(wParam, lParam, result);
	464	}
	465
	466	event.SetSelection(TabCtrl_GetCurSel(m_hwnd));
	467	event.SetOldSelection(m_nSelection);
	468	event.SetEventObject(this);
	469	event.SetInt(LOWORD(wParam)); // ctrl id
	470
	471	bool processed = GetEventHandler()->ProcessEvent(event);
	472	*result = !event.IsAllowed();
	473	return processed;
	474	}
	475
	476	// ----------------------------------------------------------------------------
	477	// wxNotebook helper functions
	478	// ----------------------------------------------------------------------------
	479
	480	// hide the currently active panel and show the new one
	481	void wxNotebook::ChangePage(int nOldSel, int nSel)
	482	{
	483	// MT-FIXME should use a real semaphore
	484	static bool s_bInsideChangePage = FALSE;
	485
	486	// when we call ProcessEvent(), our own OnSelChange() is called which calls
	487	// this function - break the infinite loop
	488	if ( s_bInsideChangePage )
	489	return;
	490
	491	// it's not an error (the message may be generated by the tab control itself)
	492	// and it may happen - just do nothing
	493	if ( nSel == nOldSel )
	494	return;
	495
	496	s_bInsideChangePage = TRUE;
	497
	498	wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId);
	499	event.SetSelection(nSel);
	500	event.SetOldSelection(nOldSel);
	501	event.SetEventObject(this);
	502	if ( ProcessEvent(event) && !event.IsAllowed() )
	503	{
	504	// program doesn't allow the page change
	505	s_bInsideChangePage = FALSE;
	506	return;
	507	}
	508
	509	if ( nOldSel != -1 )
	510	m_aPages[nOldSel]->Show(FALSE);
	511
	512	wxNotebookPage *pPage = m_aPages[nSel];
	513	pPage->Show(TRUE);
	514	pPage->SetFocus();
	515
	516	event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
	517	ProcessEvent(event);
	518
	519	m_nSelection = nSel;
	520	s_bInsideChangePage = FALSE;
	521	}
	522
	523	void wxNotebook::OnEraseBackground(wxEraseEvent& event)
	524	{
	525	Default();
	526	}
	527