src/mac/notebmac.cpp

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

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

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
  #pragma implementation "notebook.h"
#endif

#include "wx/app.h"
#include "wx/string.h"
#include "wx/log.h"
#include "wx/imaglist.h"
#include "wx/notebook.h"
#include "wx/mac/uma.h"
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------

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

static bool constantsSet = false ;

 short kwxMacTabLeftMargin = 0 ;
 short kwxMacTabTopMargin = 0 ;
 short kwxMacTabRightMargin = 0 ;
 short kwxMacTabBottomMargin = 0 ;

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

#if !USE_SHARED_LIBRARIES
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_MOUSE_EVENTS(wxNotebook::OnMouse)

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

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

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

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

// common part of all ctors
void wxNotebook::Init()
{
    if ( !constantsSet )
    {
        if ( UMAHasAquaLayout() )
        {
      // I got these values for Mac OS X from the Appearance mgr docs. (Mark Newsam)
            kwxMacTabLeftMargin = 20 ;
            kwxMacTabTopMargin = 38 ;
            kwxMacTabRightMargin = 20 ;
            kwxMacTabBottomMargin = 12 ;
        }
        else
        {
            kwxMacTabLeftMargin = 16 ;
            kwxMacTabTopMargin = 30 ;
            kwxMacTabRightMargin = 16 ;
            kwxMacTabBottomMargin = 16 ;
        }
        constantsSet = true ;
    }
    if ( UMAHasAquaLayout() )
    {
        m_macHorizontalBorder = 7;
        m_macVerticalBorder = 8;
    }

    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)
{
	Rect bounds ;
	Str255 title ;

	MacPreControlCreate( parent , id ,  "" , pos , size ,style, wxDefaultValidator , name , &bounds , title ) ;

	int tabstyle = kControlTabSmallNorthProc ;
	if ( HasFlag(wxNB_LEFT) )
		tabstyle = kControlTabSmallWestProc ;
	else if ( HasFlag( wxNB_RIGHT ) )
		tabstyle = kControlTabSmallEastProc ;
	else if ( HasFlag( wxNB_BOTTOM ) )
		tabstyle = kControlTabSmallSouthProc ;


	m_macControl = ::NewControl( MAC_WXHWND(parent->MacGetRootWindow()) , &bounds , title , false , 0 , 0 , 1,
	  	tabstyle , (long) this ) ;

	MacPostControlCreate() ;
	return TRUE ;
}

// dtor
wxNotebook::~wxNotebook()
{
	m_macControl = NULL ;
}

wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage)
{
    wxSize sizeTotal = sizePage;

    int major,minor;
    wxGetOsVersion( &major, &minor );

    // Mac has large notebook borders. Aqua even more so.

    if ( HasFlag(wxNB_LEFT) || HasFlag(wxNB_RIGHT) )
    {
        sizeTotal.x += 90;

        if (major >= 10)
            sizeTotal.y += 28;
        else
            sizeTotal.y += 20;
    }
    else
    {
        if (major >= 10)
        {
            sizeTotal.x += 34;
            sizeTotal.y += 46;
        }
        else
        {
            sizeTotal.x += 22;
            sizeTotal.y += 44;
        }
    }

    return sizeTotal;
}

// ----------------------------------------------------------------------------
// wxNotebook accessors
// ----------------------------------------------------------------------------

void wxNotebook::SetPadding(const wxSize& padding)
{
   wxFAIL_MSG( wxT("wxNotebook::SetPadding not implemented") );
}

void wxNotebook::SetTabSize(const wxSize& sz)
{
    wxFAIL_MSG( wxT("wxNotebook::SetTabSize not implemented") );
}

void wxNotebook::SetPageSize(const wxSize& size)
{
    wxFAIL_MSG( wxT("wxNotebook::SetPageSize not implemented") );
}

int wxNotebook::SetSelection(int nPage)
{
  if( !IS_VALID_PAGE(nPage) )
    return m_nSelection ;

    ChangePage(m_nSelection, nPage);
	SetControl32BitValue( (ControlHandle) m_macControl , m_nSelection + 1 ) ;

    Refresh();
    return m_nSelection;
}

bool wxNotebook::SetPageText(int nPage, const wxString& strText)
{
    wxASSERT( IS_VALID_PAGE(nPage) );

    wxNotebookPage *page = m_pages[nPage];
    page->SetLabel(strText);
    MacSetupTabs();

    return true;
}

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

    wxNotebookPage *page = m_pages[nPage];
    return page->GetLabel();
}

int wxNotebook::GetPageImage(int nPage) const
{
    wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, _T("invalid notebook page") );

    return m_images[nPage];
}

bool wxNotebook::SetPageImage(int nPage, int nImage)
{
    wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, _T("invalid notebook page") );

    wxCHECK_MSG( m_imageList && nImage < m_imageList->GetImageCount(), FALSE,
                 _T("invalid image index in SetPageImage()") );

    if ( nImage != m_images[nPage] )
    {
        // if the item didn't have an icon before or, on the contrary, did have
        // it but has lost it now, its size will change - but if the icon just
        // changes, it won't
        m_images[nPage] = nImage;

		MacSetupTabs() ;
    }

    return TRUE;
}

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

// remove one page from the notebook, without deleting the window
wxNotebookPage* wxNotebook::DoRemovePage(int nPage)
{
    wxCHECK( IS_VALID_PAGE(nPage), NULL );
    wxNotebookPage* page = m_pages[nPage] ;
    m_pages.RemoveAt(nPage);

    MacSetupTabs();

    if(m_nSelection >= GetPageCount()) {
        m_nSelection = GetPageCount() - 1;
    }
    if(m_nSelection >= 0) {
        m_pages[m_nSelection]->Show(true);
    }
    return page;
}

// remove all pages
bool wxNotebook::DeleteAllPages()
{
    // TODO: delete native widget pages

    WX_CLEAR_ARRAY(m_pages) ;
    MacSetupTabs();

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

    pPage->SetLabel(strText);

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

    m_images.Insert(imageId, nPage);

    MacSetupTabs();

    if ( bSelect ) {
        m_nSelection = nPage;
    }
    else if ( m_nSelection == -1 ) {
        m_nSelection = 0;
    }
    else if (m_nSelection >= nPage) {
        m_nSelection++;
    }
    // don't show pages by default (we'll need to adjust their size first)
    pPage->Show( false ) ;

    int h, w;
    GetSize(&w, &h);
    pPage->SetSize(kwxMacTabLeftMargin, kwxMacTabTopMargin,
                   w - kwxMacTabLeftMargin - kwxMacTabRightMargin,
                   h - kwxMacTabTopMargin - kwxMacTabBottomMargin );
    if ( pPage->GetAutoLayout() ) {
        pPage->Layout();
    }

    return true;
}

/* Added by Mark Newsam
 * When a page is added or deleted to the notebook this function updates
 * information held in the m_macControl so that it matches the order
 * the user would expect.
 */
void wxNotebook::MacSetupTabs()
{
    SetControl32BitMaximum( (ControlHandle) m_macControl , GetPageCount() ) ;

    wxNotebookPage *page;
    ControlTabInfoRec info;

    for(int ii = 0; ii < GetPageCount(); ii++)
    {
        page = m_pages[ii];
        info.version = 0;
        info.iconSuiteID = 0;
#if TARGET_CARBON
		c2pstrcpy( (StringPtr) info.name , page->GetLabel() ) ;
#else
		strcpy( (char *) info.name , page->GetLabel() ) ;
		c2pstr( (char *) info.name ) ;
#endif
        SetControlData( (ControlHandle) m_macControl, ii+1, kControlTabInfoTag,
                        sizeof( ControlTabInfoRec) , (char*) &info ) ;
        SetTabEnabled( (ControlHandle) m_macControl , ii+1 , true ) ;

#if TARGET_CARBON
        if ( GetImageList() && GetPageImage(ii) >= 0 && UMAGetSystemVersion() >= 0x1020 )
        {
        	// tab controls only support very specific types of images, therefore we are doing an odyssee
        	// accross the icon worlds (even Apple DTS did not find a shorter path)
        	// in order not to pollute the icon registry we put every icon into (OSType) 1 and immediately
        	// afterwards Unregister it (IconRef is ref counted, so it will stay on the tab even if we
        	// unregister it) in case this will ever lead to having the same icon everywhere add some kind
        	// of static counter
        	ControlButtonContentInfo info ;
        	wxMacCreateBitmapButton( &info , *GetImageList()->GetBitmap( GetPageImage(ii ) ) , kControlContentPictHandle) ;
        	IconFamilyHandle iconFamily = (IconFamilyHandle) NewHandle(0) ;
        	OSErr err = SetIconFamilyData( iconFamily, 'PICT' , (Handle) info.u.picture ) ;
            wxASSERT_MSG( err == noErr , "Error when adding bitmap" ) ;
         	IconRef iconRef ;
         	err = RegisterIconRefFromIconFamily( 'WXNG' , (OSType) 1 , iconFamily, &iconRef ) ;
            wxASSERT_MSG( err == noErr , "Error when adding bitmap" ) ;
         	info.contentType = kControlContentIconRef ;
         	info.u.iconRef = iconRef ;
        	SetControlData( (ControlHandle) m_macControl, ii+1,kControlTabImageContentTag,
                        sizeof( info ), (Ptr)&info );
            wxASSERT_MSG( err == noErr , "Error when setting icon on tab" ) ;
           	UnregisterIconRef( 'WXNG' , (OSType) 1 ) ;
            ReleaseIconRef( iconRef ) ;
            DisposeHandle( (Handle) iconFamily ) ;
        }
#endif
    }
    Rect bounds;
    GetControlBounds((ControlHandle)m_macControl, &bounds);
    InvalWindowRect((WindowRef)MacGetRootWindow(), &bounds);
}

// ----------------------------------------------------------------------------
// 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)
{
    // emulate page change (it's esp. important to do it first time because
    // otherwise our page would stay invisible)
    int nSel = m_nSelection;
    m_nSelection = -1;
    SetSelection(nSel);

    // fit the notebook page to the tab control's display area
    int w, h;
    GetSize(&w, &h);

    unsigned int nCount = m_pages.Count();
    for ( unsigned int nPage = 0; nPage < nCount; nPage++ ) {
        wxNotebookPage *pPage = m_pages[nPage];
        pPage->SetSize(kwxMacTabLeftMargin, kwxMacTabTopMargin,
                       w - kwxMacTabLeftMargin - kwxMacTabRightMargin,
                       h - kwxMacTabTopMargin - kwxMacTabBottomMargin );
        if ( pPage->GetAutoLayout() ) {
            pPage->Layout();
        }
    }

    // Processing continues to next OnSize
    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_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& 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)
{
    // 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 )
    {
        wxNotebookPage *pPage = m_pages[nSel];
        pPage->Show(FALSE);
        pPage->Show(TRUE);
        pPage->SetFocus();
        return;
    }

    // Hide previous page
    if ( nOldSel != -1 ) {
        m_pages[nOldSel]->Show(FALSE);
    }

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

    m_nSelection = nSel;
}


void  wxNotebook::OnMouse( wxMouseEvent &event )
{
   if ( (ControlHandle) m_macControl == NULL )
   {
      event.Skip() ;
      return ;
   }

   if (event.GetEventType() == wxEVT_LEFT_DOWN || event.GetEventType() == wxEVT_LEFT_DCLICK )
   {
      int x = event.m_x ;
      int y = event.m_y ;

      MacClientToRootWindow( &x , &y ) ;

      ControlHandle   control ;
      Point       localwhere ;
      SInt16      controlpart ;

      localwhere.h = x ;
      localwhere.v = y ;

      short modifiers = 0;

      if ( !event.m_leftDown && !event.m_rightDown )
	    modifiers  |= btnState ;

      if ( event.m_shiftDown )
	    modifiers |= shiftKey ;

      if ( event.m_controlDown )
	    modifiers |= controlKey ;

      if ( event.m_altDown )
	    modifiers |= optionKey ;

      if ( event.m_metaDown )
	    modifiers |= cmdKey ;

      control = (ControlHandle) m_macControl ;
      if ( control && ::IsControlActive( control ) )
      {
	    {
            wxNotebookEvent changing(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId,
 				     ::GetControl32BitValue(control) - 1, m_nSelection);
 	        changing.SetEventObject(this);
 	        ProcessEvent(changing);

 	        if(changing.IsAllowed())
 	        {
     	       controlpart = ::HandleControlClick(control, localwhere, modifiers,
     						  (ControlActionUPP) -1);
     	       wxTheApp->s_lastMouseDown = 0 ;

     	       wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_windowId,
     				     ::GetControl32BitValue(control) - 1, m_nSelection);
     	       event.SetEventObject(this);

    	       ProcessEvent(event);
 	        }
 	    }
       }
   }
}


void wxNotebook::MacHandleControlClick( WXWidget control , wxInt16 controlpart )
{
#if 0
  wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_windowId , ::GetControl32BitValue((ControlHandle)m_macControl) - 1, m_nSelection);
  event.SetEventObject(this);

  ProcessEvent(event);
#endif
}
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: notebook.cpp
	3	// Purpose: implementation of wxNotebook
	4	// Author: AUTHOR
	5	// Modified by:
	6	// Created: ??/??/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) AUTHOR
	9	// Licence: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19	#ifdef __GNUG__
	20	#pragma implementation "notebook.h"
	21	#endif
	22
	23	#include "wx/app.h"
	24	#include "wx/string.h"
	25	#include "wx/log.h"
	26	#include "wx/imaglist.h"
	27	#include "wx/notebook.h"
	28	#include "wx/mac/uma.h"
	29	// ----------------------------------------------------------------------------
	30	// macros
	31	// ----------------------------------------------------------------------------
	32
	33	// check that the page index is valid
	34	#define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount()))
	35
	36	static bool constantsSet = false ;
	37
	38	short kwxMacTabLeftMargin = 0 ;
	39	short kwxMacTabTopMargin = 0 ;
	40	short kwxMacTabRightMargin = 0 ;
	41	short kwxMacTabBottomMargin = 0 ;
	42
	43	// ----------------------------------------------------------------------------
	44	// event table
	45	// ----------------------------------------------------------------------------
	46
	47	#if !USE_SHARED_LIBRARIES
	48	DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
	49	DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
	50
	51	BEGIN_EVENT_TABLE(wxNotebook, wxControl)
	52	EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
	53	EVT_MOUSE_EVENTS(wxNotebook::OnMouse)
	54
	55	EVT_SIZE(wxNotebook::OnSize)
	56	EVT_SET_FOCUS(wxNotebook::OnSetFocus)
	57	EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
	58	END_EVENT_TABLE()
	59
	60	IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
	61	IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
	62	#endif
	63
	64	// ============================================================================
	65	// implementation
	66	// ============================================================================
	67
	68	// ----------------------------------------------------------------------------
	69	// wxNotebook construction
	70	// ----------------------------------------------------------------------------
	71
	72	// common part of all ctors
	73	void wxNotebook::Init()
	74	{
	75	if ( !constantsSet )
	76	{
	77	if ( UMAHasAquaLayout() )
	78	{
	79	// I got these values for Mac OS X from the Appearance mgr docs. (Mark Newsam)
	80	kwxMacTabLeftMargin = 20 ;
	81	kwxMacTabTopMargin = 38 ;
	82	kwxMacTabRightMargin = 20 ;
	83	kwxMacTabBottomMargin = 12 ;
	84	}
	85	else
	86	{
	87	kwxMacTabLeftMargin = 16 ;
	88	kwxMacTabTopMargin = 30 ;
	89	kwxMacTabRightMargin = 16 ;
	90	kwxMacTabBottomMargin = 16 ;
	91	}
	92	constantsSet = true ;
	93	}
	94	if ( UMAHasAquaLayout() )
	95	{
	96	m_macHorizontalBorder = 7;
	97	m_macVerticalBorder = 8;
	98	}
	99
	100	m_nSelection = -1;
	101	}
	102
	103	// default for dynamic class
	104	wxNotebook::wxNotebook()
	105	{
	106	Init();
	107	}
	108
	109	// the same arguments as for wxControl
	110	wxNotebook::wxNotebook(wxWindow *parent,
	111	wxWindowID id,
	112	const wxPoint& pos,
	113	const wxSize& size,
	114	long style,
	115	const wxString& name)
	116	{
	117	Init();
	118
	119	Create(parent, id, pos, size, style, name);
	120	}
	121
	122	// Create() function
	123	bool wxNotebook::Create(wxWindow *parent,
	124	wxWindowID id,
	125	const wxPoint& pos,
	126	const wxSize& size,
	127	long style,
	128	const wxString& name)
	129	{
	130	Rect bounds ;
	131	Str255 title ;
	132
	133	MacPreControlCreate( parent , id , "" , pos , size ,style, wxDefaultValidator , name , &bounds , title ) ;
	134
	135	int tabstyle = kControlTabSmallNorthProc ;
	136	if ( HasFlag(wxNB_LEFT) )
	137	tabstyle = kControlTabSmallWestProc ;
	138	else if ( HasFlag( wxNB_RIGHT ) )
	139	tabstyle = kControlTabSmallEastProc ;
	140	else if ( HasFlag( wxNB_BOTTOM ) )
	141	tabstyle = kControlTabSmallSouthProc ;
	142
	143
	144	m_macControl = ::NewControl( MAC_WXHWND(parent->MacGetRootWindow()) , &bounds , title , false , 0 , 0 , 1,
	145	tabstyle , (long) this ) ;
	146
	147	MacPostControlCreate() ;
	148	return TRUE ;
	149	}
	150
	151	// dtor
	152	wxNotebook::~wxNotebook()
	153	{
	154	m_macControl = NULL ;
	155	}
	156
	157	wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage)
	158	{
	159	wxSize sizeTotal = sizePage;
	160
	161	int major,minor;
	162	wxGetOsVersion( &major, &minor );
	163
	164	// Mac has large notebook borders. Aqua even more so.
	165
	166	if ( HasFlag(wxNB_LEFT) \|\| HasFlag(wxNB_RIGHT) )
	167	{
	168	sizeTotal.x += 90;
	169
	170	if (major >= 10)
	171	sizeTotal.y += 28;
	172	else
	173	sizeTotal.y += 20;
	174	}
	175	else
	176	{
	177	if (major >= 10)
	178	{
	179	sizeTotal.x += 34;
	180	sizeTotal.y += 46;
	181	}
	182	else
	183	{
	184	sizeTotal.x += 22;
	185	sizeTotal.y += 44;
	186	}
	187	}
	188
	189	return sizeTotal;
	190	}
	191
	192	// ----------------------------------------------------------------------------
	193	// wxNotebook accessors
	194	// ----------------------------------------------------------------------------
	195
	196	void wxNotebook::SetPadding(const wxSize& padding)
	197	{
	198	wxFAIL_MSG( wxT("wxNotebook::SetPadding not implemented") );
	199	}
	200
	201	void wxNotebook::SetTabSize(const wxSize& sz)
	202	{
	203	wxFAIL_MSG( wxT("wxNotebook::SetTabSize not implemented") );
	204	}
	205
	206	void wxNotebook::SetPageSize(const wxSize& size)
	207	{
	208	wxFAIL_MSG( wxT("wxNotebook::SetPageSize not implemented") );
	209	}
	210
	211	int wxNotebook::SetSelection(int nPage)
	212	{
	213	if( !IS_VALID_PAGE(nPage) )
	214	return m_nSelection ;
	215
	216	ChangePage(m_nSelection, nPage);
	217	SetControl32BitValue( (ControlHandle) m_macControl , m_nSelection + 1 ) ;
	218
	219	Refresh();
	220	return m_nSelection;
	221	}
	222
	223	bool wxNotebook::SetPageText(int nPage, const wxString& strText)
	224	{
	225	wxASSERT( IS_VALID_PAGE(nPage) );
	226
	227	wxNotebookPage *page = m_pages[nPage];
	228	page->SetLabel(strText);
	229	MacSetupTabs();
	230
	231	return true;
	232	}
	233
	234	wxString wxNotebook::GetPageText(int nPage) const
	235	{
	236	wxASSERT( IS_VALID_PAGE(nPage) );
	237
	238	wxNotebookPage *page = m_pages[nPage];
	239	return page->GetLabel();
	240	}
	241
	242	int wxNotebook::GetPageImage(int nPage) const
	243	{
	244	wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, _T("invalid notebook page") );
	245
	246	return m_images[nPage];
	247	}
	248
	249	bool wxNotebook::SetPageImage(int nPage, int nImage)
	250	{
	251	wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, _T("invalid notebook page") );
	252
	253	wxCHECK_MSG( m_imageList && nImage < m_imageList->GetImageCount(), FALSE,
	254	_T("invalid image index in SetPageImage()") );
	255
	256	if ( nImage != m_images[nPage] )
	257	{
	258	// if the item didn't have an icon before or, on the contrary, did have
	259	// it but has lost it now, its size will change - but if the icon just
	260	// changes, it won't
	261	m_images[nPage] = nImage;
	262
	263	MacSetupTabs() ;
	264	}
	265
	266	return TRUE;
	267	}
	268
	269	// ----------------------------------------------------------------------------
	270	// wxNotebook operations
	271	// ----------------------------------------------------------------------------
	272
	273	// remove one page from the notebook, without deleting the window
	274	wxNotebookPage* wxNotebook::DoRemovePage(int nPage)
	275	{
	276	wxCHECK( IS_VALID_PAGE(nPage), NULL );
	277	wxNotebookPage* page = m_pages[nPage] ;
	278	m_pages.RemoveAt(nPage);
	279
	280	MacSetupTabs();
	281
	282	if(m_nSelection >= GetPageCount()) {
	283	m_nSelection = GetPageCount() - 1;
	284	}
	285	if(m_nSelection >= 0) {
	286	m_pages[m_nSelection]->Show(true);
	287	}
	288	return page;
	289	}
	290
	291	// remove all pages
	292	bool wxNotebook::DeleteAllPages()
	293	{
	294	// TODO: delete native widget pages
	295
	296	WX_CLEAR_ARRAY(m_pages) ;
	297	MacSetupTabs();
	298
	299	return TRUE;
	300	}
	301
	302
	303	// same as AddPage() but does it at given position
	304	bool wxNotebook::InsertPage(int nPage,
	305	wxNotebookPage *pPage,
	306	const wxString& strText,
	307	bool bSelect,
	308	int imageId)
	309	{
	310	wxASSERT( pPage != NULL );
	311	wxCHECK( IS_VALID_PAGE(nPage) \|\| nPage == GetPageCount(), FALSE );
	312
	313	pPage->SetLabel(strText);
	314
	315	// save the pointer to the page
	316	m_pages.Insert(pPage, nPage);
	317
	318	m_images.Insert(imageId, nPage);
	319
	320	MacSetupTabs();
	321
	322	if ( bSelect ) {
	323	m_nSelection = nPage;
	324	}
	325	else if ( m_nSelection == -1 ) {
	326	m_nSelection = 0;
	327	}
	328	else if (m_nSelection >= nPage) {
	329	m_nSelection++;
	330	}
	331	// don't show pages by default (we'll need to adjust their size first)
	332	pPage->Show( false ) ;
	333
	334	int h, w;
	335	GetSize(&w, &h);
	336	pPage->SetSize(kwxMacTabLeftMargin, kwxMacTabTopMargin,
	337	w - kwxMacTabLeftMargin - kwxMacTabRightMargin,
	338	h - kwxMacTabTopMargin - kwxMacTabBottomMargin );
	339	if ( pPage->GetAutoLayout() ) {
	340	pPage->Layout();
	341	}
	342
	343	return true;
	344	}
	345
	346	/* Added by Mark Newsam
	347	* When a page is added or deleted to the notebook this function updates
	348	* information held in the m_macControl so that it matches the order
	349	* the user would expect.
	350	*/
	351	void wxNotebook::MacSetupTabs()
	352	{
	353	SetControl32BitMaximum( (ControlHandle) m_macControl , GetPageCount() ) ;
	354
	355	wxNotebookPage *page;
	356	ControlTabInfoRec info;
	357
	358	for(int ii = 0; ii < GetPageCount(); ii++)
	359	{
	360	page = m_pages[ii];
	361	info.version = 0;
	362	info.iconSuiteID = 0;
	363	#if TARGET_CARBON
	364	c2pstrcpy( (StringPtr) info.name , page->GetLabel() ) ;
	365	#else
	366	strcpy( (char *) info.name , page->GetLabel() ) ;
	367	c2pstr( (char *) info.name ) ;
	368	#endif
	369	SetControlData( (ControlHandle) m_macControl, ii+1, kControlTabInfoTag,
	370	sizeof( ControlTabInfoRec) , (char*) &info ) ;
	371	SetTabEnabled( (ControlHandle) m_macControl , ii+1 , true ) ;
	372
	373	#if TARGET_CARBON
	374	if ( GetImageList() && GetPageImage(ii) >= 0 && UMAGetSystemVersion() >= 0x1020 )
	375	{
	376	// tab controls only support very specific types of images, therefore we are doing an odyssee
	377	// accross the icon worlds (even Apple DTS did not find a shorter path)
	378	// in order not to pollute the icon registry we put every icon into (OSType) 1 and immediately
	379	// afterwards Unregister it (IconRef is ref counted, so it will stay on the tab even if we
	380	// unregister it) in case this will ever lead to having the same icon everywhere add some kind
	381	// of static counter
	382	ControlButtonContentInfo info ;
	383	wxMacCreateBitmapButton( &info , *GetImageList()->GetBitmap( GetPageImage(ii ) ) , kControlContentPictHandle) ;
	384	IconFamilyHandle iconFamily = (IconFamilyHandle) NewHandle(0) ;
	385	OSErr err = SetIconFamilyData( iconFamily, 'PICT' , (Handle) info.u.picture ) ;
	386	wxASSERT_MSG( err == noErr , "Error when adding bitmap" ) ;
	387	IconRef iconRef ;
	388	err = RegisterIconRefFromIconFamily( 'WXNG' , (OSType) 1 , iconFamily, &iconRef ) ;
	389	wxASSERT_MSG( err == noErr , "Error when adding bitmap" ) ;
	390	info.contentType = kControlContentIconRef ;
	391	info.u.iconRef = iconRef ;
	392	SetControlData( (ControlHandle) m_macControl, ii+1,kControlTabImageContentTag,
	393	sizeof( info ), (Ptr)&info );
	394	wxASSERT_MSG( err == noErr , "Error when setting icon on tab" ) ;
	395	UnregisterIconRef( 'WXNG' , (OSType) 1 ) ;
	396	ReleaseIconRef( iconRef ) ;
	397	DisposeHandle( (Handle) iconFamily ) ;
	398	}
	399	#endif
	400	}
	401	Rect bounds;
	402	GetControlBounds((ControlHandle)m_macControl, &bounds);
	403	InvalWindowRect((WindowRef)MacGetRootWindow(), &bounds);
	404	}
	405
	406	// ----------------------------------------------------------------------------
	407	// wxNotebook callbacks
	408	// ----------------------------------------------------------------------------
	409
	410	// @@@ OnSize() is used for setting the font when it's called for the first
	411	// time because doing it in ::Create() doesn't work (for unknown reasons)
	412	void wxNotebook::OnSize(wxSizeEvent& event)
	413	{
	414	// emulate page change (it's esp. important to do it first time because
	415	// otherwise our page would stay invisible)
	416	int nSel = m_nSelection;
	417	m_nSelection = -1;
	418	SetSelection(nSel);
	419
	420	// fit the notebook page to the tab control's display area
	421	int w, h;
	422	GetSize(&w, &h);
	423
	424	unsigned int nCount = m_pages.Count();
	425	for ( unsigned int nPage = 0; nPage < nCount; nPage++ ) {
	426	wxNotebookPage *pPage = m_pages[nPage];
	427	pPage->SetSize(kwxMacTabLeftMargin, kwxMacTabTopMargin,
	428	w - kwxMacTabLeftMargin - kwxMacTabRightMargin,
	429	h - kwxMacTabTopMargin - kwxMacTabBottomMargin );
	430	if ( pPage->GetAutoLayout() ) {
	431	pPage->Layout();
	432	}
	433	}
	434
	435	// Processing continues to next OnSize
	436	event.Skip();
	437	}
	438
	439	void wxNotebook::OnSelChange(wxNotebookEvent& event)
	440	{
	441	// is it our tab control?
	442	if ( event.GetEventObject() == this )
	443	ChangePage(event.GetOldSelection(), event.GetSelection());
	444
	445	// we want to give others a chance to process this message as well
	446	event.Skip();
	447	}
	448
	449	void wxNotebook::OnSetFocus(wxFocusEvent& event)
	450	{
	451	// set focus to the currently selected page if any
	452	if ( m_nSelection != -1 )
	453	m_pages[m_nSelection]->SetFocus();
	454
	455	event.Skip();
	456	}
	457
	458	void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
	459	{
	460	if ( event.IsWindowChange() ) {
	461	// change pages
	462	AdvanceSelection(event.GetDirection());
	463	}
	464	else {
	465	// pass to the parent
	466	if ( GetParent() ) {
	467	event.SetCurrentFocus(this);
	468	GetParent()->ProcessEvent(event);
	469	}
	470	}
	471	}
	472
	473	// ----------------------------------------------------------------------------
	474	// wxNotebook base class virtuals
	475	// ----------------------------------------------------------------------------
	476
	477	// override these 2 functions to do nothing: everything is done in OnSize
	478
	479	void wxNotebook::SetConstraintSizes(bool /* recurse */)
	480	{
	481	// don't set the sizes of the pages - their correct size is not yet known
	482	wxControl::SetConstraintSizes(FALSE);
	483	}
	484
	485	bool wxNotebook::DoPhase(int /* nPhase */)
	486	{
	487	return TRUE;
	488	}
	489
	490	void wxNotebook::Command(wxCommandEvent& event)
	491	{
	492	wxFAIL_MSG("wxNotebook::Command not implemented");
	493	}
	494
	495	// ----------------------------------------------------------------------------
	496	// wxNotebook helper functions
	497	// ----------------------------------------------------------------------------
	498
	499	// hide the currently active panel and show the new one
	500	void wxNotebook::ChangePage(int nOldSel, int nSel)
	501	{
	502	// it's not an error (the message may be generated by the tab control itself)
	503	// and it may happen - just do nothing
	504	if ( nSel == nOldSel )
	505	{
	506	wxNotebookPage *pPage = m_pages[nSel];
	507	pPage->Show(FALSE);
	508	pPage->Show(TRUE);
	509	pPage->SetFocus();
	510	return;
	511	}
	512
	513	// Hide previous page
	514	if ( nOldSel != -1 ) {
	515	m_pages[nOldSel]->Show(FALSE);
	516	}
	517
	518	wxNotebookPage *pPage = m_pages[nSel];
	519	pPage->Show(TRUE);
	520	pPage->SetFocus();
	521
	522	m_nSelection = nSel;
	523	}
	524
	525
	526	void wxNotebook::OnMouse( wxMouseEvent &event )
	527	{
	528	if ( (ControlHandle) m_macControl == NULL )
	529	{
	530	event.Skip() ;
	531	return ;
	532	}
	533
	534	if (event.GetEventType() == wxEVT_LEFT_DOWN \|\| event.GetEventType() == wxEVT_LEFT_DCLICK )
	535	{
	536	int x = event.m_x ;
	537	int y = event.m_y ;
	538
	539	MacClientToRootWindow( &x , &y ) ;
	540
	541	ControlHandle control ;
	542	Point localwhere ;
	543	SInt16 controlpart ;
	544
	545	localwhere.h = x ;
	546	localwhere.v = y ;
	547
	548	short modifiers = 0;
	549
	550	if ( !event.m_leftDown && !event.m_rightDown )
	551	modifiers \|= btnState ;
	552
	553	if ( event.m_shiftDown )
	554	modifiers \|= shiftKey ;
	555
	556	if ( event.m_controlDown )
	557	modifiers \|= controlKey ;
	558
	559	if ( event.m_altDown )
	560	modifiers \|= optionKey ;
	561
	562	if ( event.m_metaDown )
	563	modifiers \|= cmdKey ;
	564
	565	control = (ControlHandle) m_macControl ;
	566	if ( control && ::IsControlActive( control ) )
	567	{
	568	{
	569	wxNotebookEvent changing(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId,
	570	::GetControl32BitValue(control) - 1, m_nSelection);
	571	changing.SetEventObject(this);
	572	ProcessEvent(changing);
	573
	574	if(changing.IsAllowed())
	575	{
	576	controlpart = ::HandleControlClick(control, localwhere, modifiers,
	577	(ControlActionUPP) -1);
	578	wxTheApp->s_lastMouseDown = 0 ;
	579
	580	wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_windowId,
	581	::GetControl32BitValue(control) - 1, m_nSelection);
	582	event.SetEventObject(this);
	583
	584	ProcessEvent(event);
	585	}
	586	}
	587	}
	588	}
	589	}
	590
	591
	592	void wxNotebook::MacHandleControlClick( WXWidget control , wxInt16 controlpart )
	593	{
	594	#if 0
	595	wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_windowId , ::GetControl32BitValue((ControlHandle)m_macControl) - 1, m_nSelection);
	596	event.SetEventObject(this);
	597
	598	ProcessEvent(event);
	599	#endif
	600	}
	601