src/mac/notebmac.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        notebook.cpp
// Purpose:     implementation of wxNotebook
// Author:      Stefan Csomor
// Modified by:
// Created:     1998-01-01
// RCS-ID:      $Id$
// Copyright:   (c) Stefan Csomor
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

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

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

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

// check that the page index is valid
#define IS_VALID_PAGE(nPage) ((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_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)

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

// The Appearance Manager docs show using tab controls in either edge to edge
// mode, or inset.  I think edge to edge conforms better to the other ports,
// and inset mode is better accomplished with space around the wxNotebook rather
// than within it.    --Robin

// CS : had to switch off tight spacing due to 10.3 problems
#define wxMAC_EDGE_TO_EDGE 0

static inline int wxMacTabMargin(long nbStyle, long side)
{
    static int tabMargin = -1;
    static int otherMargin = -1;

    if ( tabMargin == -1)
    {
        if ( UMAHasAquaLayout() )
        {
            tabMargin = 26;    // From Appearance Manager docs for small tab control dimensions
#if wxMAC_EDGE_TO_EDGE
            otherMargin = 0;
#else
            otherMargin = 20;
#endif
        }
        else
        {
            tabMargin = 30;
#if wxMAC_EDGE_TO_EDGE
            otherMargin = 0;
#else
            otherMargin = 16;
#endif
        }
    }

    // If the style matches the side asked for then return the tab margin,
    // but we have to special case wxNB_TOP since it is zero...
    if ( side == wxNB_TOP)
    {
        if ( nbStyle != 0 && nbStyle & (wxNB_LEFT|wxNB_RIGHT|wxNB_BOTTOM))
        {
            return otherMargin;
        }
        else
        {
            return tabMargin;
        }
    }
    else if ( nbStyle & side)
        return tabMargin;
    else
        return otherMargin;
}

static inline int wxMacTabLeftMargin(long style)
{
    return wxMacTabMargin(style, wxNB_LEFT);
}

static inline int wxMacTabTopMargin(long style)
{
    return wxMacTabMargin(style, wxNB_TOP);
}

static inline int wxMacTabRightMargin(long style)
{
    return wxMacTabMargin(style, wxNB_RIGHT);
}

static inline int wxMacTabBottomMargin(long style)
{
    return wxMacTabMargin(style, wxNB_BOTTOM);
}

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

// common part of all ctors
void wxNotebook::Init()
{
    if ( UMAHasAquaLayout() )
    {
        // Should these depend on wxMAC_EDGE_TO_EDGE too?
        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)
{
    if ( !wxNotebookBase::Create(parent, id, pos, size, style, name) )
        return false;

    Rect bounds ;
    Str255 title ;

    MacPreControlCreate( parent , id ,  wxEmptyString , 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()
{
}

wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
{
    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(size_t nPage)
{
    wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, wxT("notebook page out of range") );

    if ( int(nPage) != m_nSelection )
    {
        wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId);
        event.SetSelection(nPage);
        event.SetOldSelection(m_nSelection);
        event.SetEventObject(this);
        if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
        {
            // program allows the page change
            event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
            (void)GetEventHandler()->ProcessEvent(event);

            ChangePage(m_nSelection, nPage);
        }
    }

    return m_nSelection;
}

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

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

    return true;
}

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

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

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

    return m_images[nPage];
}

bool wxNotebook::SetPageImage(size_t 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(size_t nPage)
{
    wxCHECK( IS_VALID_PAGE(nPage), NULL );
    wxNotebookPage* page = m_pages[nPage] ;
    m_pages.RemoveAt(nPage);

    MacSetupTabs();

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

// remove all pages
bool wxNotebook::DeleteAllPages()
{
    WX_CLEAR_ARRAY(m_pages) ;
    MacSetupTabs();
    m_nSelection = -1 ;
    return TRUE;
}


// same as AddPage() but does it at given position
bool wxNotebook::InsertPage(size_t nPage,
                            wxNotebookPage *pPage,
                            const wxString& strText,
                            bool bSelect,
                            int imageId)
{
    if ( !wxNotebookBase::InsertPage(nPage, pPage, strText, bSelect, imageId) )
        return false;

    wxASSERT_MSG( pPage->GetParent() == this,
                    _T("notebook pages must have notebook as parent") );

    // don't show pages by default (we'll need to adjust their size first)
    pPage->Show( false ) ;

    pPage->SetLabel(strText);

    m_images.Insert(imageId, nPage);

    MacSetupTabs();

    int h, w;
    GetSize(&w, &h);
    pPage->SetSize(wxMacTabLeftMargin(GetWindowStyle()) + m_macHorizontalBorder,
                   wxMacTabTopMargin(GetWindowStyle()) + m_macVerticalBorder,
                   w - wxMacTabLeftMargin(GetWindowStyle()) - wxMacTabRightMargin(GetWindowStyle()) - 2*m_macHorizontalBorder,
                   h - wxMacTabTopMargin(GetWindowStyle()) - wxMacTabBottomMargin(GetWindowStyle()) - 2*m_macVerticalBorder);
    if ( pPage->GetAutoLayout() ) {
        pPage->Layout();
    }


    // now deal with the selection
    // ---------------------------

    // if the inserted page is before the selected one, we must update the
    // index of the selected page

    if ( int(nPage) <= m_nSelection )
    {
        m_nSelection++;
        // while this still is the same page showing, we need to update the tabs
        SetControl32BitValue( (ControlHandle) m_macControl , m_nSelection + 1 ) ;
    }

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

    if ( selNew != -1 )
        SetSelection(selNew);

    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;

    const size_t countPages = GetPageCount();
    for(size_t ii = 0; ii < countPages; ii++)
    {
        page = m_pages[ii];
        info.version = 0;
        info.iconSuiteID = 0;
        wxMacStringToPascal( page->GetLabel() , info.name ) ;

        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
            const wxBitmap* bmap = GetImageList()->GetBitmap( GetPageImage(ii ) ) ;
            if ( bmap )
            {
                wxBitmap scaledBitmap ;
                if ( bmap->GetWidth() != 16 || bmap->GetHeight() != 16 )
                {
                    scaledBitmap = wxBitmap( bmap->ConvertToImage().Scale(16,16) ) ;
                    bmap = &scaledBitmap ;
                }
                ControlButtonContentInfo info ;
                wxMacCreateBitmapButton( &info , *bmap , kControlContentPictHandle) ;
                IconFamilyHandle iconFamily = (IconFamilyHandle) NewHandle(0) ;
                OSErr err = SetIconFamilyData( iconFamily, 'PICT' , (Handle) info.u.picture ) ;
                wxASSERT_MSG( err == noErr , wxT("Error when adding bitmap") ) ;
                IconRef iconRef ;
                err = RegisterIconRefFromIconFamily( 'WXNG' , (OSType) 1 , iconFamily, &iconRef ) ;
                wxASSERT_MSG( err == noErr , wxT("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 , wxT("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(wxMacTabLeftMargin(GetWindowStyle()) + m_macHorizontalBorder,
                       wxMacTabTopMargin(GetWindowStyle()) + m_macVerticalBorder,
                       w - wxMacTabLeftMargin(GetWindowStyle()) - wxMacTabRightMargin(GetWindowStyle()) - 2*m_macHorizontalBorder,
                       h - wxMacTabTopMargin(GetWindowStyle()) - wxMacTabBottomMargin(GetWindowStyle()) - 2*m_macVerticalBorder);
        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 {
        // we get this event in 2 cases
        //
        // a) one of our pages might have generated it because the user TABbed
        // out from it in which case we should propagate the event upwards and
        // our parent will take care of setting the focus to prev/next sibling
        //
        // or
        //
        // b) the parent panel wants to give the focus to us so that we
        // forward it to our selected page. We can't deal with this in
        // OnSetFocus() because we don't know which direction the focus came
        // from in this case and so can't choose between setting the focus to
        // first or last panel child
        wxWindow *parent = GetParent();
        // the cast is here to fic a GCC ICE
        if ( ((wxWindow*)event.GetEventObject()) == parent )
        {
            // no, it doesn't come from child, case (b): forward to a page
            if ( m_nSelection != -1 )
            {
                // so that the page knows that the event comes from it's parent
                // and is being propagated downwards
                event.SetEventObject(this);

                wxWindow *page = m_pages[m_nSelection];
                if ( !page->GetEventHandler()->ProcessEvent(event) )
                {
                    page->SetFocus();
                }
                //else: page manages focus inside it itself
            }
            else
            {
                // we have no pages - still have to give focus to _something_
                SetFocus();
            }
        }
        else
        {
            // it comes from our child, case (a), pass to the parent
            if ( parent ) {
                event.SetCurrentFocus(this);
                parent->GetEventHandler()->ProcessEvent(event);
            }
        }
    }
}

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

#if wxUSE_CONSTRAINTS

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

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

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

#endif // wxUSE_CONSTRAINTS

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

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

// hide the currently active panel and show the new one
void wxNotebook::ChangePage(int nOldSel, int nSel)
{
    if ( nOldSel != -1 )
    {
        m_pages[nOldSel]->Show(FALSE);
    }

    if ( nSel != -1 )
    {
        wxNotebookPage *pPage = m_pages[nSel];
        pPage->Show(TRUE);
        pPage->SetFocus();
    }

    m_nSelection = nSel;
    SetControl32BitValue( (ControlHandle) m_macControl , m_nSelection + 1 ) ;
}


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

                    GetEventHandler()->ProcessEvent(event);
                }
            }
        }
    }
}


void wxNotebook::MacHandleControlClick( WXWidget control , wxInt16 controlpart , bool WXUNUSED( mouseStillDown ) )
{
#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: Stefan Csomor
	5	// Modified by:
	6	// Created: 1998-01-01
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Stefan Csomor
	9	// Licence: wxWindows licence
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "notebook.h"
	14	#endif
	15
	16	// ============================================================================
	17	// declarations
	18	// ============================================================================
	19
	20	// ----------------------------------------------------------------------------
	21	// headers
	22	// ----------------------------------------------------------------------------
	23	#include "wx/app.h"
	24	#include "wx/string.h"
	25	#include "wx/log.h"
	26	#include "wx/imaglist.h"
	27	#include "wx/image.h"
	28	#include "wx/notebook.h"
	29	#include "wx/mac/uma.h"
	30	// ----------------------------------------------------------------------------
	31	// macros
	32	// ----------------------------------------------------------------------------
	33
	34	// check that the page index is valid
	35	#define IS_VALID_PAGE(nPage) ((nPage) < GetPageCount())
	36
	37
	38	// ----------------------------------------------------------------------------
	39	// event table
	40	// ----------------------------------------------------------------------------
	41
	42	DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED)
	43	DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING)
	44
	45	BEGIN_EVENT_TABLE(wxNotebook, wxControl)
	46	EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
	47	EVT_MOUSE_EVENTS(wxNotebook::OnMouse)
	48
	49	EVT_SIZE(wxNotebook::OnSize)
	50	EVT_SET_FOCUS(wxNotebook::OnSetFocus)
	51	EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey)
	52	END_EVENT_TABLE()
	53
	54	IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl)
	55	IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)
	56
	57	// ============================================================================
	58	// implementation
	59	// ============================================================================
	60
	61	// The Appearance Manager docs show using tab controls in either edge to edge
	62	// mode, or inset. I think edge to edge conforms better to the other ports,
	63	// and inset mode is better accomplished with space around the wxNotebook rather
	64	// than within it. --Robin
	65
	66	// CS : had to switch off tight spacing due to 10.3 problems
	67	#define wxMAC_EDGE_TO_EDGE 0
	68
	69	static inline int wxMacTabMargin(long nbStyle, long side)
	70	{
	71	static int tabMargin = -1;
	72	static int otherMargin = -1;
	73
	74	if ( tabMargin == -1)
	75	{
	76	if ( UMAHasAquaLayout() )
	77	{
	78	tabMargin = 26; // From Appearance Manager docs for small tab control dimensions
	79	#if wxMAC_EDGE_TO_EDGE
	80	otherMargin = 0;
	81	#else
	82	otherMargin = 20;
	83	#endif
	84	}
	85	else
	86	{
	87	tabMargin = 30;
	88	#if wxMAC_EDGE_TO_EDGE
	89	otherMargin = 0;
	90	#else
	91	otherMargin = 16;
	92	#endif
	93	}
	94	}
	95
	96	// If the style matches the side asked for then return the tab margin,
	97	// but we have to special case wxNB_TOP since it is zero...
	98	if ( side == wxNB_TOP)
	99	{
	100	if ( nbStyle != 0 && nbStyle & (wxNB_LEFT\|wxNB_RIGHT\|wxNB_BOTTOM))
	101	{
	102	return otherMargin;
	103	}
	104	else
	105	{
	106	return tabMargin;
	107	}
	108	}
	109	else if ( nbStyle & side)
	110	return tabMargin;
	111	else
	112	return otherMargin;
	113	}
	114
	115	static inline int wxMacTabLeftMargin(long style)
	116	{
	117	return wxMacTabMargin(style, wxNB_LEFT);
	118	}
	119
	120	static inline int wxMacTabTopMargin(long style)
	121	{
	122	return wxMacTabMargin(style, wxNB_TOP);
	123	}
	124
	125	static inline int wxMacTabRightMargin(long style)
	126	{
	127	return wxMacTabMargin(style, wxNB_RIGHT);
	128	}
	129
	130	static inline int wxMacTabBottomMargin(long style)
	131	{
	132	return wxMacTabMargin(style, wxNB_BOTTOM);
	133	}
	134
	135	// ----------------------------------------------------------------------------
	136	// wxNotebook construction
	137	// ----------------------------------------------------------------------------
	138
	139	// common part of all ctors
	140	void wxNotebook::Init()
	141	{
	142	if ( UMAHasAquaLayout() )
	143	{
	144	// Should these depend on wxMAC_EDGE_TO_EDGE too?
	145	m_macHorizontalBorder = 7;
	146	m_macVerticalBorder = 8;
	147	}
	148
	149	m_nSelection = -1;
	150	}
	151
	152	// default for dynamic class
	153	wxNotebook::wxNotebook()
	154	{
	155	Init();
	156	}
	157
	158	// the same arguments as for wxControl
	159	wxNotebook::wxNotebook(wxWindow *parent,
	160	wxWindowID id,
	161	const wxPoint& pos,
	162	const wxSize& size,
	163	long style,
	164	const wxString& name)
	165	{
	166	Init();
	167
	168	Create(parent, id, pos, size, style, name);
	169	}
	170
	171	// Create() function
	172	bool wxNotebook::Create(wxWindow *parent,
	173	wxWindowID id,
	174	const wxPoint& pos,
	175	const wxSize& size,
	176	long style,
	177	const wxString& name)
	178	{
	179	if ( !wxNotebookBase::Create(parent, id, pos, size, style, name) )
	180	return false;
	181
	182	Rect bounds ;
	183	Str255 title ;
	184
	185	MacPreControlCreate( parent , id , wxEmptyString , pos , size ,style, wxDefaultValidator , name , &bounds , title ) ;
	186
	187	int tabstyle = kControlTabSmallNorthProc ;
	188	if ( HasFlag(wxNB_LEFT) )
	189	tabstyle = kControlTabSmallWestProc ;
	190	else if ( HasFlag( wxNB_RIGHT ) )
	191	tabstyle = kControlTabSmallEastProc ;
	192	else if ( HasFlag( wxNB_BOTTOM ) )
	193	tabstyle = kControlTabSmallSouthProc ;
	194
	195
	196	m_macControl = ::NewControl( MAC_WXHWND(parent->MacGetRootWindow()) , &bounds , title , false , 0 , 0 , 1,
	197	tabstyle , (long) this ) ;
	198
	199	MacPostControlCreate() ;
	200	return TRUE ;
	201	}
	202
	203	// dtor
	204	wxNotebook::~wxNotebook()
	205	{
	206	}
	207
	208	wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const
	209	{
	210	wxSize sizeTotal = sizePage;
	211
	212	int major,minor;
	213	wxGetOsVersion( &major, &minor );
	214
	215	// Mac has large notebook borders. Aqua even more so.
	216
	217	if ( HasFlag(wxNB_LEFT) \|\| HasFlag(wxNB_RIGHT) )
	218	{
	219	sizeTotal.x += 90;
	220
	221	if (major >= 10)
	222	sizeTotal.y += 28;
	223	else
	224	sizeTotal.y += 20;
	225	}
	226	else
	227	{
	228	if (major >= 10)
	229	{
	230	sizeTotal.x += 34;
	231	sizeTotal.y += 46;
	232	}
	233	else
	234	{
	235	sizeTotal.x += 22;
	236	sizeTotal.y += 44;
	237	}
	238	}
	239
	240	return sizeTotal;
	241	}
	242
	243	// ----------------------------------------------------------------------------
	244	// wxNotebook accessors
	245	// ----------------------------------------------------------------------------
	246
	247	void wxNotebook::SetPadding(const wxSize& padding)
	248	{
	249	wxFAIL_MSG( wxT("wxNotebook::SetPadding not implemented") );
	250	}
	251
	252	void wxNotebook::SetTabSize(const wxSize& sz)
	253	{
	254	wxFAIL_MSG( wxT("wxNotebook::SetTabSize not implemented") );
	255	}
	256
	257	void wxNotebook::SetPageSize(const wxSize& size)
	258	{
	259	wxFAIL_MSG( wxT("wxNotebook::SetPageSize not implemented") );
	260	}
	261
	262	int wxNotebook::SetSelection(size_t nPage)
	263	{
	264	wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, wxT("notebook page out of range") );
	265
	266	if ( int(nPage) != m_nSelection )
	267	{
	268	wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId);
	269	event.SetSelection(nPage);
	270	event.SetOldSelection(m_nSelection);
	271	event.SetEventObject(this);
	272	if ( !GetEventHandler()->ProcessEvent(event) \|\| event.IsAllowed() )
	273	{
	274	// program allows the page change
	275	event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED);
	276	(void)GetEventHandler()->ProcessEvent(event);
	277
	278	ChangePage(m_nSelection, nPage);
	279	}
	280	}
	281
	282	return m_nSelection;
	283	}
	284
	285	bool wxNotebook::SetPageText(size_t nPage, const wxString& strText)
	286	{
	287	wxASSERT( IS_VALID_PAGE(nPage) );
	288
	289	wxNotebookPage *page = m_pages[nPage];
	290	page->SetLabel(strText);
	291	MacSetupTabs();
	292
	293	return true;
	294	}
	295
	296	wxString wxNotebook::GetPageText(size_t nPage) const
	297	{
	298	wxASSERT( IS_VALID_PAGE(nPage) );
	299
	300	wxNotebookPage *page = m_pages[nPage];
	301	return page->GetLabel();
	302	}
	303
	304	int wxNotebook::GetPageImage(size_t nPage) const
	305	{
	306	wxCHECK_MSG( IS_VALID_PAGE(nPage), -1, _T("invalid notebook page") );
	307
	308	return m_images[nPage];
	309	}
	310
	311	bool wxNotebook::SetPageImage(size_t nPage, int nImage)
	312	{
	313	wxCHECK_MSG( IS_VALID_PAGE(nPage), FALSE, _T("invalid notebook page") );
	314
	315	wxCHECK_MSG( m_imageList && nImage < m_imageList->GetImageCount(), FALSE,
	316	_T("invalid image index in SetPageImage()") );
	317
	318	if ( nImage != m_images[nPage] )
	319	{
	320	// if the item didn't have an icon before or, on the contrary, did have
	321	// it but has lost it now, its size will change - but if the icon just
	322	// changes, it won't
	323	m_images[nPage] = nImage;
	324
	325	MacSetupTabs() ;
	326	}
	327
	328	return TRUE;
	329	}
	330
	331	// ----------------------------------------------------------------------------
	332	// wxNotebook operations
	333	// ----------------------------------------------------------------------------
	334
	335	// remove one page from the notebook, without deleting the window
	336	wxNotebookPage* wxNotebook::DoRemovePage(size_t nPage)
	337	{
	338	wxCHECK( IS_VALID_PAGE(nPage), NULL );
	339	wxNotebookPage* page = m_pages[nPage] ;
	340	m_pages.RemoveAt(nPage);
	341
	342	MacSetupTabs();
	343
	344	if(m_nSelection >= (int)GetPageCount()) {
	345	m_nSelection = GetPageCount() - 1;
	346	}
	347	if(m_nSelection >= 0) {
	348	m_pages[m_nSelection]->Show(true);
	349	}
	350	return page;
	351	}
	352
	353	// remove all pages
	354	bool wxNotebook::DeleteAllPages()
	355	{
	356	WX_CLEAR_ARRAY(m_pages) ;
	357	MacSetupTabs();
	358	m_nSelection = -1 ;
	359	return TRUE;
	360	}
	361
	362
	363	// same as AddPage() but does it at given position
	364	bool wxNotebook::InsertPage(size_t nPage,
	365	wxNotebookPage *pPage,
	366	const wxString& strText,
	367	bool bSelect,
	368	int imageId)
	369	{
	370	if ( !wxNotebookBase::InsertPage(nPage, pPage, strText, bSelect, imageId) )
	371	return false;
	372
	373	wxASSERT_MSG( pPage->GetParent() == this,
	374	_T("notebook pages must have notebook as parent") );
	375
	376	// don't show pages by default (we'll need to adjust their size first)
	377	pPage->Show( false ) ;
	378
	379	pPage->SetLabel(strText);
	380
	381	m_images.Insert(imageId, nPage);
	382
	383	MacSetupTabs();
	384
	385	int h, w;
	386	GetSize(&w, &h);
	387	pPage->SetSize(wxMacTabLeftMargin(GetWindowStyle()) + m_macHorizontalBorder,
	388	wxMacTabTopMargin(GetWindowStyle()) + m_macVerticalBorder,
	389	w - wxMacTabLeftMargin(GetWindowStyle()) - wxMacTabRightMargin(GetWindowStyle()) - 2*m_macHorizontalBorder,
	390	h - wxMacTabTopMargin(GetWindowStyle()) - wxMacTabBottomMargin(GetWindowStyle()) - 2*m_macVerticalBorder);
	391	if ( pPage->GetAutoLayout() ) {
	392	pPage->Layout();
	393	}
	394
	395
	396	// now deal with the selection
	397	// ---------------------------
	398
	399	// if the inserted page is before the selected one, we must update the
	400	// index of the selected page
	401
	402	if ( int(nPage) <= m_nSelection )
	403	{
	404	m_nSelection++;
	405	// while this still is the same page showing, we need to update the tabs
	406	SetControl32BitValue( (ControlHandle) m_macControl , m_nSelection + 1 ) ;
	407	}
	408
	409	// some page should be selected: either this one or the first one if there
	410	// is still no selection
	411	int selNew = -1;
	412	if ( bSelect )
	413	selNew = nPage;
	414	else if ( m_nSelection == -1 )
	415	selNew = 0;
	416
	417	if ( selNew != -1 )
	418	SetSelection(selNew);
	419
	420	return true;
	421	}
	422
	423	/* Added by Mark Newsam
	424	* When a page is added or deleted to the notebook this function updates
	425	* information held in the m_macControl so that it matches the order
	426	* the user would expect.
	427	*/
	428	void wxNotebook::MacSetupTabs()
	429	{
	430	SetControl32BitMaximum( (ControlHandle) m_macControl , GetPageCount() ) ;
	431
	432	wxNotebookPage *page;
	433	ControlTabInfoRec info;
	434
	435	const size_t countPages = GetPageCount();
	436	for(size_t ii = 0; ii < countPages; ii++)
	437	{
	438	page = m_pages[ii];
	439	info.version = 0;
	440	info.iconSuiteID = 0;
	441	wxMacStringToPascal( page->GetLabel() , info.name ) ;
	442
	443	SetControlData( (ControlHandle) m_macControl, ii+1, kControlTabInfoTag,
	444	sizeof( ControlTabInfoRec) , (char*) &info ) ;
	445	SetTabEnabled( (ControlHandle) m_macControl , ii+1 , true ) ;
	446	#if TARGET_CARBON
	447	if ( GetImageList() && GetPageImage(ii) >= 0 && UMAGetSystemVersion() >= 0x1020 )
	448	{
	449	// tab controls only support very specific types of images, therefore we are doing an odyssee
	450	// accross the icon worlds (even Apple DTS did not find a shorter path)
	451	// in order not to pollute the icon registry we put every icon into (OSType) 1 and immediately
	452	// afterwards Unregister it (IconRef is ref counted, so it will stay on the tab even if we
	453	// unregister it) in case this will ever lead to having the same icon everywhere add some kind
	454	// of static counter
	455	const wxBitmap* bmap = GetImageList()->GetBitmap( GetPageImage(ii ) ) ;
	456	if ( bmap )
	457	{
	458	wxBitmap scaledBitmap ;
	459	if ( bmap->GetWidth() != 16 \|\| bmap->GetHeight() != 16 )
	460	{
	461	scaledBitmap = wxBitmap( bmap->ConvertToImage().Scale(16,16) ) ;
	462	bmap = &scaledBitmap ;
	463	}
	464	ControlButtonContentInfo info ;
	465	wxMacCreateBitmapButton( &info , *bmap , kControlContentPictHandle) ;
	466	IconFamilyHandle iconFamily = (IconFamilyHandle) NewHandle(0) ;
	467	OSErr err = SetIconFamilyData( iconFamily, 'PICT' , (Handle) info.u.picture ) ;
	468	wxASSERT_MSG( err == noErr , wxT("Error when adding bitmap") ) ;
	469	IconRef iconRef ;
	470	err = RegisterIconRefFromIconFamily( 'WXNG' , (OSType) 1 , iconFamily, &iconRef ) ;
	471	wxASSERT_MSG( err == noErr , wxT("Error when adding bitmap") ) ;
	472	info.contentType = kControlContentIconRef ;
	473	info.u.iconRef = iconRef ;
	474	SetControlData( (ControlHandle) m_macControl, ii+1,kControlTabImageContentTag,
	475	sizeof( info ), (Ptr)&info );
	476	wxASSERT_MSG( err == noErr , wxT("Error when setting icon on tab") ) ;
	477	UnregisterIconRef( 'WXNG' , (OSType) 1 ) ;
	478	ReleaseIconRef( iconRef ) ;
	479	DisposeHandle( (Handle) iconFamily ) ;
	480	}
	481	}
	482	#endif
	483	}
	484	Rect bounds;
	485	GetControlBounds((ControlHandle)m_macControl, &bounds);
	486	InvalWindowRect((WindowRef)MacGetRootWindow(), &bounds);
	487	}
	488
	489	// ----------------------------------------------------------------------------
	490	// wxNotebook callbacks
	491	// ----------------------------------------------------------------------------
	492
	493	// @@@ OnSize() is used for setting the font when it's called for the first
	494	// time because doing it in ::Create() doesn't work (for unknown reasons)
	495	void wxNotebook::OnSize(wxSizeEvent& event)
	496	{
	497	// emulate page change (it's esp. important to do it first time because
	498	// otherwise our page would stay invisible)
	499	/*
	500	int nSel = m_nSelection;
	501	m_nSelection = -1;
	502	SetSelection(nSel);
	503	*/
	504
	505	// fit the notebook page to the tab control's display area
	506	int w, h;
	507	GetSize(&w, &h);
	508
	509	unsigned int nCount = m_pages.Count();
	510	for ( unsigned int nPage = 0; nPage < nCount; nPage++ ) {
	511	wxNotebookPage *pPage = m_pages[nPage];
	512	pPage->SetSize(wxMacTabLeftMargin(GetWindowStyle()) + m_macHorizontalBorder,
	513	wxMacTabTopMargin(GetWindowStyle()) + m_macVerticalBorder,
	514	w - wxMacTabLeftMargin(GetWindowStyle()) - wxMacTabRightMargin(GetWindowStyle()) - 2*m_macHorizontalBorder,
	515	h - wxMacTabTopMargin(GetWindowStyle()) - wxMacTabBottomMargin(GetWindowStyle()) - 2*m_macVerticalBorder);
	516	if ( pPage->GetAutoLayout() ) {
	517	pPage->Layout();
	518	}
	519	}
	520
	521	// Processing continues to next OnSize
	522	event.Skip();
	523	}
	524
	525	void wxNotebook::OnSelChange(wxNotebookEvent& event)
	526	{
	527	// is it our tab control?
	528	if ( event.GetEventObject() == this )
	529	ChangePage(event.GetOldSelection(), event.GetSelection());
	530
	531	// we want to give others a chance to process this message as well
	532	event.Skip();
	533	}
	534
	535	void wxNotebook::OnSetFocus(wxFocusEvent& event)
	536	{
	537	// set focus to the currently selected page if any
	538	if ( m_nSelection != -1 )
	539	m_pages[m_nSelection]->SetFocus();
	540
	541	event.Skip();
	542	}
	543
	544	void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
	545	{
	546	if ( event.IsWindowChange() ) {
	547	// change pages
	548	AdvanceSelection(event.GetDirection());
	549	}
	550	else {
	551	// we get this event in 2 cases
	552	//
	553	// a) one of our pages might have generated it because the user TABbed
	554	// out from it in which case we should propagate the event upwards and
	555	// our parent will take care of setting the focus to prev/next sibling
	556	//
	557	// or
	558	//
	559	// b) the parent panel wants to give the focus to us so that we
	560	// forward it to our selected page. We can't deal with this in
	561	// OnSetFocus() because we don't know which direction the focus came
	562	// from in this case and so can't choose between setting the focus to
	563	// first or last panel child
	564	wxWindow *parent = GetParent();
	565	// the cast is here to fic a GCC ICE
	566	if ( ((wxWindow*)event.GetEventObject()) == parent )
	567	{
	568	// no, it doesn't come from child, case (b): forward to a page
	569	if ( m_nSelection != -1 )
	570	{
	571	// so that the page knows that the event comes from it's parent
	572	// and is being propagated downwards
	573	event.SetEventObject(this);
	574
	575	wxWindow *page = m_pages[m_nSelection];
	576	if ( !page->GetEventHandler()->ProcessEvent(event) )
	577	{
	578	page->SetFocus();
	579	}
	580	//else: page manages focus inside it itself
	581	}
	582	else
	583	{
	584	// we have no pages - still have to give focus to _something_
	585	SetFocus();
	586	}
	587	}
	588	else
	589	{
	590	// it comes from our child, case (a), pass to the parent
	591	if ( parent ) {
	592	event.SetCurrentFocus(this);
	593	parent->GetEventHandler()->ProcessEvent(event);
	594	}
	595	}
	596	}
	597	}
	598
	599	// ----------------------------------------------------------------------------
	600	// wxNotebook base class virtuals
	601	// ----------------------------------------------------------------------------
	602
	603	#if wxUSE_CONSTRAINTS
	604
	605	// override these 2 functions to do nothing: everything is done in OnSize
	606
	607	void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse))
	608	{
	609	// don't set the sizes of the pages - their correct size is not yet known
	610	wxControl::SetConstraintSizes(FALSE);
	611	}
	612
	613	bool wxNotebook::DoPhase(int WXUNUSED(nPhase))
	614	{
	615	return TRUE;
	616	}
	617
	618	#endif // wxUSE_CONSTRAINTS
	619
	620	void wxNotebook::Command(wxCommandEvent& event)
	621	{
	622	wxFAIL_MSG(wxT("wxNotebook::Command not implemented"));
	623	}
	624
	625	// ----------------------------------------------------------------------------
	626	// wxNotebook helper functions
	627	// ----------------------------------------------------------------------------
	628
	629	// hide the currently active panel and show the new one
	630	void wxNotebook::ChangePage(int nOldSel, int nSel)
	631	{
	632	if ( nOldSel != -1 )
	633	{
	634	m_pages[nOldSel]->Show(FALSE);
	635	}
	636
	637	if ( nSel != -1 )
	638	{
	639	wxNotebookPage *pPage = m_pages[nSel];
	640	pPage->Show(TRUE);
	641	pPage->SetFocus();
	642	}
	643
	644	m_nSelection = nSel;
	645	SetControl32BitValue( (ControlHandle) m_macControl , m_nSelection + 1 ) ;
	646	}
	647
	648
	649	void wxNotebook::OnMouse( wxMouseEvent &event )
	650	{
	651	if ( (ControlHandle) m_macControl == NULL )
	652	{
	653	event.Skip() ;
	654	return ;
	655	}
	656
	657	if (event.GetEventType() == wxEVT_LEFT_DOWN \|\| event.GetEventType() == wxEVT_LEFT_DCLICK )
	658	{
	659	int x = event.m_x ;
	660	int y = event.m_y ;
	661
	662	MacClientToRootWindow( &x , &y ) ;
	663
	664	ControlHandle control ;
	665	Point localwhere ;
	666	SInt16 controlpart ;
	667
	668	localwhere.h = x ;
	669	localwhere.v = y ;
	670
	671	short modifiers = 0;
	672
	673	if ( !event.m_leftDown && !event.m_rightDown )
	674	modifiers \|= btnState ;
	675
	676	if ( event.m_shiftDown )
	677	modifiers \|= shiftKey ;
	678
	679	if ( event.m_controlDown )
	680	modifiers \|= controlKey ;
	681
	682	if ( event.m_altDown )
	683	modifiers \|= optionKey ;
	684
	685	if ( event.m_metaDown )
	686	modifiers \|= cmdKey ;
	687
	688	control = (ControlHandle) m_macControl ;
	689	if ( control && ::IsControlActive( control ) )
	690	{
	691	{
	692	wxNotebookEvent changing(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId,
	693	::GetControl32BitValue(control) - 1, m_nSelection);
	694	changing.SetEventObject(this);
	695	GetEventHandler()->ProcessEvent(changing);
	696
	697	if(changing.IsAllowed())
	698	{
	699	controlpart = ::HandleControlClick(control, localwhere, modifiers,
	700	(ControlActionUPP) -1);
	701	wxTheApp->s_lastMouseDown = 0 ;
	702
	703	wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_windowId,
	704	::GetControl32BitValue(control) - 1, m_nSelection);
	705	event.SetEventObject(this);
	706
	707	GetEventHandler()->ProcessEvent(event);
	708	}
	709	}
	710	}
	711	}
	712	}
	713
	714
	715	void wxNotebook::MacHandleControlClick( WXWidget control , wxInt16 controlpart , bool WXUNUSED( mouseStillDown ) )
	716	{
	717	#if 0
	718	wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, m_windowId , ::GetControl32BitValue((ControlHandle)m_macControl) - 1, m_nSelection);
	719	event.SetEventObject(this);
	720
	721	ProcessEvent(event);
	722	#endif
	723	}
	724