src/generic/notebook.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        notebook.cpp
// Purpose:     implementation of wxNotebook
// Author:      Julian Smart
// Modified by:
// Created:     17/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "notebook.h"
#endif

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

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#include  "wx/string.h"
#include  "wx/log.h"
#include  "wx/settings.h"
#include  "wx/generic/imaglist.h"
#include  "wx/notebook.h"
#include  "wx/dcclient.h"
#include  "wx/generic/tabg.h"

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

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

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

DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)

BEGIN_EVENT_TABLE(wxNotebook, wxControl)
    EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
    EVT_SIZE(wxNotebook::OnSize)
    EVT_PAINT(wxNotebook::OnPaint)
    EVT_MOUSE_EVENTS(wxNotebook::OnMouseEvent)
    EVT_SET_FOCUS(wxNotebook::OnSetFocus)
    EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
END_EVENT_TABLE()

IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)

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

// ============================================================================
// Private class
// ============================================================================

// This reuses wxTabView to draw the tabs.
class WXDLLEXPORT wxNotebookTabView: public wxTabView
{
DECLARE_DYNAMIC_CLASS(wxNotebookTabView)
public:
  wxNotebookTabView(wxNotebook* notebook, long style = wxTAB_STYLE_DRAW_BOX | wxTAB_STYLE_COLOUR_INTERIOR);
  ~wxNotebookTabView(void);

  // Called when a tab is activated
  virtual void OnTabActivate(int activateId, int deactivateId);
  // Allows vetoing
  virtual bool OnTabPreActivate(int activateId, int deactivateId);

protected:
   wxNotebook*      m_notebook;
};

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

// common part of all ctors
void wxNotebook::Init()
{
    m_tabView = (wxNotebookTabView*) 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);

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

    // It's like a normal window...
    if (!wxWindow::Create(parent, id, pos, size, style|wxNO_BORDER, name))
        return FALSE;

    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));

    SetTabView(new wxNotebookTabView(this));

    return TRUE;
}

// dtor
wxNotebook::~wxNotebook()
{
    delete m_tabView;
}

// ----------------------------------------------------------------------------
// wxNotebook accessors
// ----------------------------------------------------------------------------
int wxNotebook::GetRowCount() const
{
    // TODO
    return 0;
}

int wxNotebook::SetSelection(int nPage)
{
    if (nPage == -1)
      return 0;

    wxASSERT( IS_VALID_PAGE(nPage) );

#if defined (__WIN16__)
    m_tabView->SetTabSelection(nPage);
#else
    wxNotebookPage* pPage = GetPage(nPage);

    m_tabView->SetTabSelection((int) (long) pPage);
#endif
    // TODO
    return 0;
}

#if 0
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);
}
#endif

bool wxNotebook::SetPageText(int nPage, const wxString& strText)
{
    wxASSERT( IS_VALID_PAGE(nPage) );
#if defined (__WIN16__)
	m_tabView->SetTabText(nPage, strText);
    Refresh();
    return TRUE;
#else
    wxNotebookPage* page = GetPage(nPage);
    if (page)
    {
        m_tabView->SetTabText((int) (long) page, strText);
        Refresh();
        return TRUE;
    }
#endif
    return FALSE;
}

wxString wxNotebook::GetPageText(int nPage) const
{
    wxASSERT( IS_VALID_PAGE(nPage) );

#if defined (__WIN16__)
    return m_tabView->GetTabText(nPage);
#else
    wxNotebookPage* page = ((wxNotebook*)this)->GetPage(nPage);
    if (page)
        return m_tabView->GetTabText((int) (long) page);
    else
        return wxEmptyString;
#endif
}

int wxNotebook::GetPageImage(int nPage) const
{
    wxASSERT( IS_VALID_PAGE(nPage) );

    // TODO
    return 0;
}

bool wxNotebook::SetPageImage(int nPage, int nImage)
{
    wxASSERT( IS_VALID_PAGE(nPage) );

    // TODO
    return FALSE;
}

// set the size (the same for all pages)
void wxNotebook::SetPageSize(const wxSize& size)
{
    // TODO
}

// set the padding between tabs (in pixels)
void wxNotebook::SetPadding(const wxSize& padding)
{
    // TODO
}

// set the size of the tabs for wxNB_FIXEDWIDTH controls
void wxNotebook::SetTabSize(const wxSize& sz)
{
    // TODO
}

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

// remove one page from the notebook and delete it
bool wxNotebook::DeletePage(int nPage)
{
    wxCHECK( IS_VALID_PAGE(nPage), FALSE );

    if (m_nSelection != -1)
    {
        m_pages[m_nSelection]->Show(FALSE);
        m_pages[m_nSelection]->Lower();
    }

    wxNotebookPage* pPage = GetPage(nPage);
#if defined (__WIN16__)
    m_tabView->RemoveTab(nPage);
#else
    m_tabView->RemoveTab((int) (long) pPage);
#endif

    m_pages.Remove(pPage);
    delete pPage;

    if (m_pages.GetCount() == 0)
    {
      m_nSelection = -1;
      m_tabView->SetTabSelection(-1, FALSE);
    }
    else if (m_nSelection > -1)
    {
      m_nSelection = -1;
#if defined (__WIN16__)
      m_tabView->SetTabSelection(0, FALSE);
#else
      m_tabView->SetTabSelection((int) (long) GetPage(0), FALSE);
#endif
      if (m_nSelection != 0)
        ChangePage(-1, 0);
    }

    RefreshLayout(FALSE);

    return TRUE;
}

bool wxNotebook::DeletePage(wxNotebookPage* page)
{
    int pagePos = FindPagePosition(page);
    if (pagePos > -1)
        return DeletePage(pagePos);
    else
        return FALSE;
}

// remove one page from the notebook
bool wxNotebook::RemovePage(int nPage)
{
    wxCHECK( IS_VALID_PAGE(nPage), FALSE );

    m_pages[nPage]->Show(FALSE);
    //    m_pages[nPage]->Lower();

    wxNotebookPage* pPage = GetPage(nPage);
#if defined (__WIN16__)
    m_tabView->RemoveTab(nPage);
#else
    m_tabView->RemoveTab((int) (long) pPage);
#endif

    m_pages.Remove(pPage);

    if (m_pages.GetCount() == 0)
    {
      m_nSelection = -1;
      m_tabView->SetTabSelection(-1, TRUE);
    }
    else if (m_nSelection > -1)
    {
      // Only change the selection if the page we
      // deleted was the selection.
      if (nPage == m_nSelection)
      {
         m_nSelection = -1;
         // Select the first tab. Generates a ChangePage.
         m_tabView->SetTabSelection((int) (long) GetPage(0), TRUE);
      }
      else
      {
	// We must adjust which tab we think is selected.
        // If greater than the page we deleted, it must be moved down
        // a notch.
        if (m_nSelection > nPage)
          m_nSelection -- ;
      }
    }

    RefreshLayout(FALSE);

    return TRUE;
}

bool wxNotebook::RemovePage(wxNotebookPage* page)
{
    int pagePos = FindPagePosition(page);
    if (pagePos > -1)
        return RemovePage(pagePos);
    else
        return FALSE;
}

// Find the position of the wxNotebookPage, -1 if not found.
int wxNotebook::FindPagePosition(wxNotebookPage* page) const
{
    int nPageCount = GetPageCount();
    int nPage;
    for ( nPage = 0; nPage < nPageCount; nPage++ )
        if (m_pages[nPage] == page)
            return nPage;
    return -1;
}

// remove all pages
bool wxNotebook::DeleteAllPages()
{
    m_tabView->ClearTabs(TRUE);

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

    m_pages.Clear();

    return TRUE;
}

// 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 );

// For 16 bit integers (tabs limited to 32768)
#if defined (__WIN16__)
    m_tabView->AddTab(nPage, strText);
#else
    m_tabView->AddTab((int) (long) pPage, strText);
#endif
    if (!bSelect)
      pPage->Show(FALSE);

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

    if (bSelect)
    {
        // This will cause ChangePage to be called, via OnSelPage
#if defined (__WIN16__)
        m_tabView->SetTabSelection(nPage, TRUE);
#else
        m_tabView->SetTabSelection((int) (long) pPage, TRUE);
#endif
    }

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

    RefreshLayout(FALSE);

    return TRUE;
}

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

// @@@ OnSize() is used for setting the font when it's called for the first
//     time because doing it in ::Create() doesn't work (for unknown reasons)
void wxNotebook::OnSize(wxSizeEvent& event)
{
    static bool s_bFirstTime = TRUE;
    if ( s_bFirstTime ) {
        // TODO: any first-time-size processing.
        s_bFirstTime = FALSE;
    }

    RefreshLayout();

    // Processing continues to next OnSize
    event.Skip();
}

// This was supposed to cure the non-display of the notebook
// until the user resizes the window.
// What's going on?
void wxNotebook::OnInternalIdle()
{
    wxWindow::OnInternalIdle();

#if 0
    static bool s_bFirstTime = TRUE;
    if ( s_bFirstTime ) {
      /*
      wxSize sz(GetSize());
      sz.x ++;
      SetSize(sz);
      sz.x --;
      SetSize(sz);
      */

      /*
      wxSize sz(GetSize());
      wxSizeEvent sizeEvent(sz, GetId());
      sizeEvent.SetEventObject(this);
      GetEventHandler()->ProcessEvent(sizeEvent);
      Refresh();
      */
      s_bFirstTime = FALSE;
    }
#endif
}

// Implementation: calculate the layout of the view rect
// and resize the children if required
bool wxNotebook::RefreshLayout(bool force)
{
    if (m_tabView)
    {
        wxRect oldRect = m_tabView->GetViewRect();

        int cw, ch;
        GetClientSize(& cw, & ch);

        int tabHeight = m_tabView->GetTotalTabHeight();
        wxRect rect;
        rect.x = 4;
        rect.y = tabHeight + 4;
        rect.width = cw - 8;
        rect.height = ch - 4 - rect.y ;

        m_tabView->SetViewRect(rect);

        m_tabView->LayoutTabs();

        // Need to do it a 2nd time to get the tab height with
        // the new view width, since changing the view width changes the
        // tab layout.
        tabHeight = m_tabView->GetTotalTabHeight();
        rect.x = 4;
        rect.y = tabHeight + 4;
        rect.width = cw - 8;
        rect.height = ch - 4 - rect.y ;

        m_tabView->SetViewRect(rect);

        m_tabView->LayoutTabs();

        if (!force && (rect == oldRect))
          return FALSE;

        // fit the notebook page to the tab control's display area

        unsigned int nCount = m_pages.Count();
        for ( unsigned int nPage = 0; nPage < nCount; nPage++ ) {
            wxNotebookPage *pPage = m_pages[nPage];
            wxRect clientRect = GetAvailableClientSize();
            if (pPage->IsShown())
            {
                pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height);
                if ( pPage->GetAutoLayout() )
                   pPage->Layout();
            }
        }
        Refresh();
    }
    return TRUE;
}

void wxNotebook::OnSelChange(wxNotebookEvent& event)
{
    // is it our tab control?
    if ( event.GetEventObject() == this )
    {
        if (event.GetSelection() != m_nSelection)
          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_pages[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()->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& WXUNUSED(event))
{
    wxFAIL_MSG("wxNotebook::Command not implemented");
}

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

// hide the currently active panel and show the new one
void wxNotebook::ChangePage(int nOldSel, int nSel)
{
  //  cout << "ChangePage: " << nOldSel << ", " << nSel << "\n";
    wxASSERT( nOldSel != nSel ); // impossible

    if ( nOldSel != -1 ) {
        m_pages[nOldSel]->Show(FALSE);
        m_pages[nOldSel]->Lower();
    }

    wxNotebookPage *pPage = m_pages[nSel];

    wxRect clientRect = GetAvailableClientSize();
    pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height);

    Refresh();

    pPage->Show(TRUE);
    pPage->Raise();
    pPage->SetFocus();

    m_nSelection = nSel;
}

void wxNotebook::OnMouseEvent(wxMouseEvent& event)
{
  if (m_tabView)
    m_tabView->OnEvent(event);
}

void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event) )
{
    wxPaintDC dc(this);
    if (m_tabView)
        m_tabView->Draw(dc);
}

wxRect wxNotebook::GetAvailableClientSize()
{
    int cw, ch;
    GetClientSize(& cw, & ch);

    int tabHeight = m_tabView->GetTotalTabHeight();

    // TODO: these margins should be configurable.
    wxRect rect;
    rect.x = 6;
    rect.y = tabHeight + 6;
    rect.width = cw - 12;
    rect.height = ch - 4 - rect.y ;

    return rect;
}

/*
 * wxNotebookTabView
 */

IMPLEMENT_CLASS(wxNotebookTabView, wxTabView)

wxNotebookTabView::wxNotebookTabView(wxNotebook *notebook, long style): wxTabView(style)
{
  m_notebook = notebook;

  m_notebook->SetTabView(this);

  SetWindow(m_notebook);
}

wxNotebookTabView::~wxNotebookTabView(void)
{
}

// Called when a tab is activated
void wxNotebookTabView::OnTabActivate(int activateId, int deactivateId)
{
  if (!m_notebook)
    return;

  wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_notebook->GetId());

#if defined (__WIN16__)
  int activatePos = activateId;
  int deactivatePos = deactivateId;
#else
  // Translate from wxTabView's ids (which aren't position-dependent)
  // to wxNotebook's (which are).
  wxNotebookPage* pActive = (wxNotebookPage*) activateId;
  wxNotebookPage* pDeactive = (wxNotebookPage*) deactivateId;

  int activatePos = m_notebook->FindPagePosition(pActive);
  int deactivatePos = m_notebook->FindPagePosition(pDeactive);

#endif
  event.SetEventObject(m_notebook);
  event.SetSelection(activatePos);
  event.SetOldSelection(deactivatePos);
  m_notebook->GetEventHandler()->ProcessEvent(event);
}

// Allows Vetoing
bool wxNotebookTabView::OnTabPreActivate(int activateId, int deactivateId)
{
  bool retval = TRUE;

  if (m_notebook)
  {
    wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_notebook->GetId());

#if defined (__WIN16__)
    int activatePos = activateId;
    int deactivatePos = deactivateId;
#else
    // Translate from wxTabView's ids (which aren't position-dependent)
    // to wxNotebook's (which are).
    wxNotebookPage* pActive = (wxNotebookPage*) activateId;
    wxNotebookPage* pDeactive = (wxNotebookPage*) deactivateId;

    int activatePos = m_notebook->FindPagePosition(pActive);
    int deactivatePos = m_notebook->FindPagePosition(pDeactive);

#endif
    event.SetEventObject(m_notebook);
    event.SetSelection(activatePos);
    event.SetOldSelection(deactivatePos);
    if (m_notebook->GetEventHandler()->ProcessEvent(event))
    {
      retval = event.IsAllowed();
    }
  }
  return retval;
}
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: notebook.cpp
	3	// Purpose: implementation of wxNotebook
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 17/09/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19	#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
	20	#pragma implementation "notebook.h"
	21	#endif
	22
	23	// For compilers that support precompilation, includes "wx.h".
	24	#include "wx/wxprec.h"
	25
	26	#ifdef __BORLANDC__
	27	#pragma hdrstop
	28	#endif
	29
	30	#include "wx/string.h"
	31	#include "wx/log.h"
	32	#include "wx/settings.h"
	33	#include "wx/generic/imaglist.h"
	34	#include "wx/notebook.h"
	35	#include "wx/dcclient.h"
	36	#include "wx/generic/tabg.h"
	37
	38	// ----------------------------------------------------------------------------
	39	// macros
	40	// ----------------------------------------------------------------------------
	41
	42	// check that the page index is valid
	43	#define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount()))
	44
	45	// ----------------------------------------------------------------------------
	46	// event table
	47	// ----------------------------------------------------------------------------
	48
	49	DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
	50	DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
	51
	52	BEGIN_EVENT_TABLE(wxNotebook, wxControl)
	53	EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
	54	EVT_SIZE(wxNotebook::OnSize)
	55	EVT_PAINT(wxNotebook::OnPaint)
	56	EVT_MOUSE_EVENTS(wxNotebook::OnMouseEvent)
	57	EVT_SET_FOCUS(wxNotebook::OnSetFocus)
	58	EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
	59	END_EVENT_TABLE()
	60
	61	IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
	62	IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
	63
	64	// ============================================================================
	65	// implementation
	66	// ============================================================================
	67
	68	// ============================================================================
	69	// Private class
	70	// ============================================================================
	71
	72	// This reuses wxTabView to draw the tabs.
	73	class WXDLLEXPORT wxNotebookTabView: public wxTabView
	74	{
	75	DECLARE_DYNAMIC_CLASS(wxNotebookTabView)
	76	public:
	77	wxNotebookTabView(wxNotebook* notebook, long style = wxTAB_STYLE_DRAW_BOX \| wxTAB_STYLE_COLOUR_INTERIOR);
	78	~wxNotebookTabView(void);
	79
	80	// Called when a tab is activated
	81	virtual void OnTabActivate(int activateId, int deactivateId);
	82	// Allows vetoing
	83	virtual bool OnTabPreActivate(int activateId, int deactivateId);
	84
	85	protected:
	86	wxNotebook* m_notebook;
	87	};
	88
	89	// ----------------------------------------------------------------------------
	90	// wxNotebook construction
	91	// ----------------------------------------------------------------------------
	92
	93	// common part of all ctors
	94	void wxNotebook::Init()
	95	{
	96	m_tabView = (wxNotebookTabView*) NULL;
	97	m_nSelection = -1;
	98	}
	99
	100	// default for dynamic class
	101	wxNotebook::wxNotebook()
	102	{
	103	Init();
	104	}
	105
	106	// the same arguments as for wxControl
	107	wxNotebook::wxNotebook(wxWindow *parent,
	108	wxWindowID id,
	109	const wxPoint& pos,
	110	const wxSize& size,
	111	long style,
	112	const wxString& name)
	113	{
	114	Init();
	115
	116	Create(parent, id, pos, size, style, name);
	117	}
	118
	119	// Create() function
	120	bool wxNotebook::Create(wxWindow *parent,
	121	wxWindowID id,
	122	const wxPoint& pos,
	123	const wxSize& size,
	124	long style,
	125	const wxString& name)
	126	{
	127	// base init
	128	SetName(name);
	129
	130	m_windowId = id == -1 ? NewControlId() : id;
	131
	132	// It's like a normal window...
	133	if (!wxWindow::Create(parent, id, pos, size, style\|wxNO_BORDER, name))
	134	return FALSE;
	135
	136	SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
	137
	138	SetTabView(new wxNotebookTabView(this));
	139
	140	return TRUE;
	141	}
	142
	143	// dtor
	144	wxNotebook::~wxNotebook()
	145	{
	146	delete m_tabView;
	147	}
	148
	149	// ----------------------------------------------------------------------------
	150	// wxNotebook accessors
	151	// ----------------------------------------------------------------------------
	152	int wxNotebook::GetRowCount() const
	153	{
	154	// TODO
	155	return 0;
	156	}
	157
	158	int wxNotebook::SetSelection(int nPage)
	159	{
	160	if (nPage == -1)
	161	return 0;
	162
	163	wxASSERT( IS_VALID_PAGE(nPage) );
	164
	165	#if defined (__WIN16__)
	166	m_tabView->SetTabSelection(nPage);
	167	#else
	168	wxNotebookPage* pPage = GetPage(nPage);
	169
	170	m_tabView->SetTabSelection((int) (long) pPage);
	171	#endif
	172	// TODO
	173	return 0;
	174	}
	175
	176	#if 0
	177	void wxNotebook::AdvanceSelection(bool bForward)
	178	{
	179	int nSel = GetSelection();
	180	int nMax = GetPageCount() - 1;
	181	if ( bForward )
	182	SetSelection(nSel == nMax ? 0 : nSel + 1);
	183	else
	184	SetSelection(nSel == 0 ? nMax : nSel - 1);
	185	}
	186	#endif
	187
	188	bool wxNotebook::SetPageText(int nPage, const wxString& strText)
	189	{
	190	wxASSERT( IS_VALID_PAGE(nPage) );
	191	#if defined (__WIN16__)
	192	m_tabView->SetTabText(nPage, strText);
	193	Refresh();
	194	return TRUE;
	195	#else
	196	wxNotebookPage* page = GetPage(nPage);
	197	if (page)
	198	{
	199	m_tabView->SetTabText((int) (long) page, strText);
	200	Refresh();
	201	return TRUE;
	202	}
	203	#endif
	204	return FALSE;
	205	}
	206
	207	wxString wxNotebook::GetPageText(int nPage) const
	208	{
	209	wxASSERT( IS_VALID_PAGE(nPage) );
	210
	211	#if defined (__WIN16__)
	212	return m_tabView->GetTabText(nPage);
	213	#else
	214	wxNotebookPage* page = ((wxNotebook*)this)->GetPage(nPage);
	215	if (page)
	216	return m_tabView->GetTabText((int) (long) page);
	217	else
	218	return wxEmptyString;
	219	#endif
	220	}
	221
	222	int wxNotebook::GetPageImage(int nPage) const
	223	{
	224	wxASSERT( IS_VALID_PAGE(nPage) );
	225
	226	// TODO
	227	return 0;
	228	}
	229
	230	bool wxNotebook::SetPageImage(int nPage, int nImage)
	231	{
	232	wxASSERT( IS_VALID_PAGE(nPage) );
	233
	234	// TODO
	235	return FALSE;
	236	}
	237
	238	// set the size (the same for all pages)
	239	void wxNotebook::SetPageSize(const wxSize& size)
	240	{
	241	// TODO
	242	}
	243
	244	// set the padding between tabs (in pixels)
	245	void wxNotebook::SetPadding(const wxSize& padding)
	246	{
	247	// TODO
	248	}
	249
	250	// set the size of the tabs for wxNB_FIXEDWIDTH controls
	251	void wxNotebook::SetTabSize(const wxSize& sz)
	252	{
	253	// TODO
	254	}
	255
	256	// ----------------------------------------------------------------------------
	257	// wxNotebook operations
	258	// ----------------------------------------------------------------------------
	259
	260	// remove one page from the notebook and delete it
	261	bool wxNotebook::DeletePage(int nPage)
	262	{
	263	wxCHECK( IS_VALID_PAGE(nPage), FALSE );
	264
	265	if (m_nSelection != -1)
	266	{
	267	m_pages[m_nSelection]->Show(FALSE);
	268	m_pages[m_nSelection]->Lower();
	269	}
	270
	271	wxNotebookPage* pPage = GetPage(nPage);
	272	#if defined (__WIN16__)
	273	m_tabView->RemoveTab(nPage);
	274	#else
	275	m_tabView->RemoveTab((int) (long) pPage);
	276	#endif
	277
	278	m_pages.Remove(pPage);
	279	delete pPage;
	280
	281	if (m_pages.GetCount() == 0)
	282	{
	283	m_nSelection = -1;
	284	m_tabView->SetTabSelection(-1, FALSE);
	285	}
	286	else if (m_nSelection > -1)
	287	{
	288	m_nSelection = -1;
	289	#if defined (__WIN16__)
	290	m_tabView->SetTabSelection(0, FALSE);
	291	#else
	292	m_tabView->SetTabSelection((int) (long) GetPage(0), FALSE);
	293	#endif
	294	if (m_nSelection != 0)
	295	ChangePage(-1, 0);
	296	}
	297
	298	RefreshLayout(FALSE);
	299
	300	return TRUE;
	301	}
	302
	303	bool wxNotebook::DeletePage(wxNotebookPage* page)
	304	{
	305	int pagePos = FindPagePosition(page);
	306	if (pagePos > -1)
	307	return DeletePage(pagePos);
	308	else
	309	return FALSE;
	310	}
	311
	312	// remove one page from the notebook
	313	bool wxNotebook::RemovePage(int nPage)
	314	{
	315	wxCHECK( IS_VALID_PAGE(nPage), FALSE );
	316
	317	m_pages[nPage]->Show(FALSE);
	318	// m_pages[nPage]->Lower();
	319
	320	wxNotebookPage* pPage = GetPage(nPage);
	321	#if defined (__WIN16__)
	322	m_tabView->RemoveTab(nPage);
	323	#else
	324	m_tabView->RemoveTab((int) (long) pPage);
	325	#endif
	326
	327	m_pages.Remove(pPage);
	328
	329	if (m_pages.GetCount() == 0)
	330	{
	331	m_nSelection = -1;
	332	m_tabView->SetTabSelection(-1, TRUE);
	333	}
	334	else if (m_nSelection > -1)
	335	{
	336	// Only change the selection if the page we
	337	// deleted was the selection.
	338	if (nPage == m_nSelection)
	339	{
	340	m_nSelection = -1;
	341	// Select the first tab. Generates a ChangePage.
	342	m_tabView->SetTabSelection((int) (long) GetPage(0), TRUE);
	343	}
	344	else
	345	{
	346	// We must adjust which tab we think is selected.
	347	// If greater than the page we deleted, it must be moved down
	348	// a notch.
	349	if (m_nSelection > nPage)
	350	m_nSelection -- ;
	351	}
	352	}
	353
	354	RefreshLayout(FALSE);
	355
	356	return TRUE;
	357	}
	358
	359	bool wxNotebook::RemovePage(wxNotebookPage* page)
	360	{
	361	int pagePos = FindPagePosition(page);
	362	if (pagePos > -1)
	363	return RemovePage(pagePos);
	364	else
	365	return FALSE;
	366	}
	367
	368	// Find the position of the wxNotebookPage, -1 if not found.
	369	int wxNotebook::FindPagePosition(wxNotebookPage* page) const
	370	{
	371	int nPageCount = GetPageCount();
	372	int nPage;
	373	for ( nPage = 0; nPage < nPageCount; nPage++ )
	374	if (m_pages[nPage] == page)
	375	return nPage;
	376	return -1;
	377	}
	378
	379	// remove all pages
	380	bool wxNotebook::DeleteAllPages()
	381	{
	382	m_tabView->ClearTabs(TRUE);
	383
	384	int nPageCount = GetPageCount();
	385	int nPage;
	386	for ( nPage = 0; nPage < nPageCount; nPage++ )
	387	delete m_pages[nPage];
	388
	389	m_pages.Clear();
	390
	391	return TRUE;
	392	}
	393
	394	// same as AddPage() but does it at given position
	395	bool wxNotebook::InsertPage(int nPage,
	396	wxNotebookPage *pPage,
	397	const wxString& strText,
	398	bool bSelect,
	399	int imageId)
	400	{
	401	wxASSERT( pPage != NULL );
	402	wxCHECK( IS_VALID_PAGE(nPage) \|\| nPage == GetPageCount(), FALSE );
	403
	404	// For 16 bit integers (tabs limited to 32768)
	405	#if defined (__WIN16__)
	406	m_tabView->AddTab(nPage, strText);
	407	#else
	408	m_tabView->AddTab((int) (long) pPage, strText);
	409	#endif
	410	if (!bSelect)
	411	pPage->Show(FALSE);
	412
	413	// save the pointer to the page
	414	m_pages.Insert(pPage, nPage);
	415
	416	if (bSelect)
	417	{
	418	// This will cause ChangePage to be called, via OnSelPage
	419	#if defined (__WIN16__)
	420	m_tabView->SetTabSelection(nPage, TRUE);
	421	#else
	422	m_tabView->SetTabSelection((int) (long) pPage, TRUE);
	423	#endif
	424	}
	425
	426	// some page must be selected: either this one or the first one if there is
	427	// still no selection
	428	if ( m_nSelection == -1 )
	429	ChangePage(-1, 0);
	430
	431	RefreshLayout(FALSE);
	432
	433	return TRUE;
	434	}
	435
	436	// ----------------------------------------------------------------------------
	437	// wxNotebook callbacks
	438	// ----------------------------------------------------------------------------
	439
	440	// @@@ OnSize() is used for setting the font when it's called for the first
	441	// time because doing it in ::Create() doesn't work (for unknown reasons)
	442	void wxNotebook::OnSize(wxSizeEvent& event)
	443	{
	444	static bool s_bFirstTime = TRUE;
	445	if ( s_bFirstTime ) {
	446	// TODO: any first-time-size processing.
	447	s_bFirstTime = FALSE;
	448	}
	449
	450	RefreshLayout();
	451
	452	// Processing continues to next OnSize
	453	event.Skip();
	454	}
	455
	456	// This was supposed to cure the non-display of the notebook
	457	// until the user resizes the window.
	458	// What's going on?
	459	void wxNotebook::OnInternalIdle()
	460	{
	461	wxWindow::OnInternalIdle();
	462
	463	#if 0
	464	static bool s_bFirstTime = TRUE;
	465	if ( s_bFirstTime ) {
	466	/*
	467	wxSize sz(GetSize());
	468	sz.x ++;
	469	SetSize(sz);
	470	sz.x --;
	471	SetSize(sz);
	472	*/
	473
	474	/*
	475	wxSize sz(GetSize());
	476	wxSizeEvent sizeEvent(sz, GetId());
	477	sizeEvent.SetEventObject(this);
	478	GetEventHandler()->ProcessEvent(sizeEvent);
	479	Refresh();
	480	*/
	481	s_bFirstTime = FALSE;
	482	}
	483	#endif
	484	}
	485
	486	// Implementation: calculate the layout of the view rect
	487	// and resize the children if required
	488	bool wxNotebook::RefreshLayout(bool force)
	489	{
	490	if (m_tabView)
	491	{
	492	wxRect oldRect = m_tabView->GetViewRect();
	493
	494	int cw, ch;
	495	GetClientSize(& cw, & ch);
	496
	497	int tabHeight = m_tabView->GetTotalTabHeight();
	498	wxRect rect;
	499	rect.x = 4;
	500	rect.y = tabHeight + 4;
	501	rect.width = cw - 8;
	502	rect.height = ch - 4 - rect.y ;
	503
	504	m_tabView->SetViewRect(rect);
	505
	506	m_tabView->LayoutTabs();
	507
	508	// Need to do it a 2nd time to get the tab height with
	509	// the new view width, since changing the view width changes the
	510	// tab layout.
	511	tabHeight = m_tabView->GetTotalTabHeight();
	512	rect.x = 4;
	513	rect.y = tabHeight + 4;
	514	rect.width = cw - 8;
	515	rect.height = ch - 4 - rect.y ;
	516
	517	m_tabView->SetViewRect(rect);
	518
	519	m_tabView->LayoutTabs();
	520
	521	if (!force && (rect == oldRect))
	522	return FALSE;
	523
	524	// fit the notebook page to the tab control's display area
	525
	526	unsigned int nCount = m_pages.Count();
	527	for ( unsigned int nPage = 0; nPage < nCount; nPage++ ) {
	528	wxNotebookPage *pPage = m_pages[nPage];
	529	wxRect clientRect = GetAvailableClientSize();
	530	if (pPage->IsShown())
	531	{
	532	pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height);
	533	if ( pPage->GetAutoLayout() )
	534	pPage->Layout();
	535	}
	536	}
	537	Refresh();
	538	}
	539	return TRUE;
	540	}
	541
	542	void wxNotebook::OnSelChange(wxNotebookEvent& event)
	543	{
	544	// is it our tab control?
	545	if ( event.GetEventObject() == this )
	546	{
	547	if (event.GetSelection() != m_nSelection)
	548	ChangePage(event.GetOldSelection(), event.GetSelection());
	549	}
	550
	551	// we want to give others a chance to process this message as well
	552	event.Skip();
	553	}
	554
	555	void wxNotebook::OnSetFocus(wxFocusEvent& event)
	556	{
	557	// set focus to the currently selected page if any
	558	if ( m_nSelection != -1 )
	559	m_pages[m_nSelection]->SetFocus();
	560
	561	event.Skip();
	562	}
	563
	564	void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
	565	{
	566	if ( event.IsWindowChange() ) {
	567	// change pages
	568	AdvanceSelection(event.GetDirection());
	569	}
	570	else {
	571	// pass to the parent
	572	if ( GetParent() ) {
	573	event.SetCurrentFocus(this);
	574	GetParent()->ProcessEvent(event);
	575	}
	576	}
	577	}
	578
	579	// ----------------------------------------------------------------------------
	580	// wxNotebook base class virtuals
	581	// ----------------------------------------------------------------------------
	582
	583	// override these 2 functions to do nothing: everything is done in OnSize
	584
	585	void wxNotebook::SetConstraintSizes(bool /* recurse */)
	586	{
	587	// don't set the sizes of the pages - their correct size is not yet known
	588	wxControl::SetConstraintSizes(FALSE);
	589	}
	590
	591	bool wxNotebook::DoPhase(int /* nPhase */)
	592	{
	593	return TRUE;
	594	}
	595
	596	void wxNotebook::Command(wxCommandEvent& WXUNUSED(event))
	597	{
	598	wxFAIL_MSG("wxNotebook::Command not implemented");
	599	}
	600
	601	// ----------------------------------------------------------------------------
	602	// wxNotebook helper functions
	603	// ----------------------------------------------------------------------------
	604
	605	// hide the currently active panel and show the new one
	606	void wxNotebook::ChangePage(int nOldSel, int nSel)
	607	{
	608	// cout << "ChangePage: " << nOldSel << ", " << nSel << "\n";
	609	wxASSERT( nOldSel != nSel ); // impossible
	610
	611	if ( nOldSel != -1 ) {
	612	m_pages[nOldSel]->Show(FALSE);
	613	m_pages[nOldSel]->Lower();
	614	}
	615
	616	wxNotebookPage *pPage = m_pages[nSel];
	617
	618	wxRect clientRect = GetAvailableClientSize();
	619	pPage->SetSize(clientRect.x, clientRect.y, clientRect.width, clientRect.height);
	620
	621	Refresh();
	622
	623	pPage->Show(TRUE);
	624	pPage->Raise();
	625	pPage->SetFocus();
	626
	627	m_nSelection = nSel;
	628	}
	629
	630	void wxNotebook::OnMouseEvent(wxMouseEvent& event)
	631	{
	632	if (m_tabView)
	633	m_tabView->OnEvent(event);
	634	}
	635
	636	void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event) )
	637	{
	638	wxPaintDC dc(this);
	639	if (m_tabView)
	640	m_tabView->Draw(dc);
	641	}
	642
	643	wxRect wxNotebook::GetAvailableClientSize()
	644	{
	645	int cw, ch;
	646	GetClientSize(& cw, & ch);
	647
	648	int tabHeight = m_tabView->GetTotalTabHeight();
	649
	650	// TODO: these margins should be configurable.
	651	wxRect rect;
	652	rect.x = 6;
	653	rect.y = tabHeight + 6;
	654	rect.width = cw - 12;
	655	rect.height = ch - 4 - rect.y ;
	656
	657	return rect;
	658	}
	659
	660	/*
	661	* wxNotebookTabView
	662	*/
	663
	664	IMPLEMENT_CLASS(wxNotebookTabView, wxTabView)
	665
	666	wxNotebookTabView::wxNotebookTabView(wxNotebook *notebook, long style): wxTabView(style)
	667	{
	668	m_notebook = notebook;
	669
	670	m_notebook->SetTabView(this);
	671
	672	SetWindow(m_notebook);
	673	}
	674
	675	wxNotebookTabView::~wxNotebookTabView(void)
	676	{
	677	}
	678
	679	// Called when a tab is activated
	680	void wxNotebookTabView::OnTabActivate(int activateId, int deactivateId)
	681	{
	682	if (!m_notebook)
	683	return;
	684
	685	wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_notebook->GetId());
	686
	687	#if defined (__WIN16__)
	688	int activatePos = activateId;
	689	int deactivatePos = deactivateId;
	690	#else
	691	// Translate from wxTabView's ids (which aren't position-dependent)
	692	// to wxNotebook's (which are).
	693	wxNotebookPage* pActive = (wxNotebookPage*) activateId;
	694	wxNotebookPage* pDeactive = (wxNotebookPage*) deactivateId;
	695
	696	int activatePos = m_notebook->FindPagePosition(pActive);
	697	int deactivatePos = m_notebook->FindPagePosition(pDeactive);
	698
	699	#endif
	700	event.SetEventObject(m_notebook);
	701	event.SetSelection(activatePos);
	702	event.SetOldSelection(deactivatePos);
	703	m_notebook->GetEventHandler()->ProcessEvent(event);
	704	}
	705
	706	// Allows Vetoing
	707	bool wxNotebookTabView::OnTabPreActivate(int activateId, int deactivateId)
	708	{
	709	bool retval = TRUE;
	710
	711	if (m_notebook)
	712	{
	713	wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_notebook->GetId());
	714
	715	#if defined (__WIN16__)
	716	int activatePos = activateId;
	717	int deactivatePos = deactivateId;
	718	#else
	719	// Translate from wxTabView's ids (which aren't position-dependent)
	720	// to wxNotebook's (which are).
	721	wxNotebookPage* pActive = (wxNotebookPage*) activateId;
	722	wxNotebookPage* pDeactive = (wxNotebookPage*) deactivateId;
	723
	724	int activatePos = m_notebook->FindPagePosition(pActive);
	725	int deactivatePos = m_notebook->FindPagePosition(pDeactive);
	726
	727	#endif
	728	event.SetEventObject(m_notebook);
	729	event.SetSelection(activatePos);
	730	event.SetOldSelection(deactivatePos);
	731	if (m_notebook->GetEventHandler()->ProcessEvent(event))
	732	{
	733	retval = event.IsAllowed();
	734	}
	735	}
	736	return retval;
	737	}
	738