src/mac/carbon/control.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        control.cpp
// Purpose:     wxControl class
// Author:      Stefan Csomor
// Modified by:
// Created:     1998-01-01
// RCS-ID:      $Id$
// Copyright:   (c) Stefan Csomor
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#include "wx/defs.h"

#include "wx/control.h"
#include "wx/panel.h"
#include "wx/app.h"
#include "wx/dc.h"
#include "wx/dcclient.h"
#include "wx/notebook.h"
#include "wx/tabctrl.h"
#include "wx/radiobox.h"
#include "wx/spinbutt.h"
#include "wx/scrolbar.h"
#include "wx/button.h"
#include "wx/dialog.h"
#include "wx/statbox.h"
#include "wx/sizer.h"
#include "wx/stattext.h"

#if !USE_SHARED_LIBRARY
IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow)

BEGIN_EVENT_TABLE(wxControl, wxWindow)
    EVT_MOUSE_EVENTS( wxControl::OnMouseEvent )
    EVT_PAINT( wxControl::OnPaint )
END_EVENT_TABLE()
#endif

#include "wx/mac/uma.h"
#include "wx/mac/private.h"

// Item members


#if PRAGMA_STRUCT_ALIGN
    #pragma options align=mac68k
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
    #pragma pack(2)
#endif

typedef struct {
 unsigned short instruction;
 void (*function)();
} cdefRec, *cdefPtr, **cdefHandle;

#if PRAGMA_STRUCT_ALIGN
    #pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
    #pragma pack()
#endif

ControlActionUPP wxMacLiveScrollbarActionUPP = NULL ;
wxControl *wxFindControlFromMacControl(ControlHandle inControl ) ;

pascal void wxMacLiveScrollbarActionProc( ControlHandle control , ControlPartCode partCode ) ;
pascal void wxMacLiveScrollbarActionProc( ControlHandle control , ControlPartCode partCode )
{
    if ( partCode != 0)
    {
        wxControl*  wx = (wxControl*) GetControlReference( control ) ;
        if ( wx )
        {
            wx->MacHandleControlClick( control , partCode , true /* stillDown */ ) ;
        }
    }
}

ControlColorUPP wxMacSetupControlBackgroundUPP = NULL ;
ControlDefUPP wxMacControlActionUPP = NULL ;

pascal SInt32  wxMacControlDefinition(SInt16 varCode, ControlRef theControl, ControlDefProcMessage message, SInt32 param)
{

    wxControl*  wx = (wxControl*) wxFindControlFromMacControl( theControl ) ;
    if ( wx != NULL && wx->IsKindOf( CLASSINFO( wxControl ) ) )
    {
        if( message == drawCntl )
        {
            wxMacWindowClipper clip( wx ) ;
            return InvokeControlDefUPP( varCode , theControl , message , param , (ControlDefUPP) wx->MacGetControlAction() ) ;
        }
        else
            return InvokeControlDefUPP( varCode , theControl , message , param , (ControlDefUPP) wx->MacGetControlAction() ) ;
    }
    return  NULL ;
}

pascal OSStatus wxMacSetupControlBackground( ControlRef iControl , SInt16 iMessage , SInt16 iDepth , Boolean iIsColor )
{
    OSStatus status = noErr ;
    switch( iMessage )
    {
        case kControlMsgSetUpBackground :
            {
                wxControl*  wx = (wxControl*) GetControlReference( iControl ) ;
                if ( wx != NULL && wx->IsKindOf( CLASSINFO( wxControl ) ) )
                {
                    wxDC::MacSetupBackgroundForCurrentPort( wx->MacGetBackgroundBrush() ) ;
#if TARGET_CARBON
                    // under classic this would lead to partial redraws
                    RgnHandle clip = NewRgn() ;
                    int x = 0 , y = 0;

                    wx->MacWindowToRootWindow( &x,&y ) ;
                    CopyRgn( (RgnHandle) wx->MacGetVisibleRegion(false).GetWXHRGN() , clip ) ;
                    OffsetRgn( clip , x , y ) ;
                    SetClip( clip ) ;
                    DisposeRgn( clip ) ;
#endif
                }
                else
                {
                    status = paramErr ;
                }
            }
            break ;
        default :
            status = paramErr ;
            break ;
    }
    return status ;
}

wxControl::wxControl()
{
    m_macControl = NULL ;
    m_macControlAction = NULL ;
    m_macHorizontalBorder = 0 ; // additional pixels around the real control
    m_macVerticalBorder = 0 ;
    m_backgroundColour = *wxWHITE;
    m_foregroundColour = *wxBLACK;

    if ( wxMacLiveScrollbarActionUPP == NULL )
    {
#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
        wxMacLiveScrollbarActionUPP = NewControlActionUPP( wxMacLiveScrollbarActionProc );
#else
        wxMacLiveScrollbarActionUPP = NewControlActionProc( wxMacLiveScrollbarActionProc ) ;
#endif
    }
}

bool wxControl::Create(wxWindow *parent, wxWindowID id,
                       const wxPoint& pos,
                       const wxSize& size, long style,
                       const wxValidator& validator,
                       const wxString& name)
{
    m_macControl = NULL ;
    m_macHorizontalBorder = 0 ; // additional pixels around the real control
    m_macVerticalBorder = 0 ;

    bool rval = wxWindow::Create(parent, id, pos, size, style, name);
    if ( parent )
    {
        m_backgroundColour = parent->GetBackgroundColour() ;
        m_foregroundColour = parent->GetForegroundColour() ;
    }
    if (rval) {
#if wxUSE_VALIDATORS
        SetValidator(validator);
#endif
    }
    return rval;
}

wxControl::~wxControl()
{
    m_isBeingDeleted = TRUE;
    wxRemoveMacControlAssociation( this ) ;
    // If we delete an item, we should initialize the parent panel,
    // because it could now be invalid.
    wxWindow *parent = GetParent() ;
    if ( parent )
    {
        if (parent->GetDefaultItem() == (wxButton*) this)
            parent->SetDefaultItem(NULL);
    }
    if ( (ControlHandle) m_macControl )
    {
        ::DisposeControl( (ControlHandle) m_macControl ) ;
        m_macControl = NULL ;
    }
}

void wxControl::SetLabel(const wxString& title)
{
    m_label = wxStripMenuCodes(title) ;

    if ( m_macControl )
    {
		UMASetControlTitle( (ControlHandle) m_macControl , m_label , m_font.GetEncoding() ) ;
    }
    Refresh() ;
}

wxSize wxControl::DoGetBestSize() const
{
    if ( (ControlHandle) m_macControl == NULL )
        return wxWindow::DoGetBestSize() ;

    Rect    bestsize = { 0 , 0 , 0 , 0 } ;
    short   baselineoffset ;
    int bestWidth, bestHeight ;
    ::GetBestControlRect( (ControlHandle) m_macControl , &bestsize , &baselineoffset ) ;

    if ( EmptyRect( &bestsize ) )
    {
        baselineoffset = 0;
        bestsize.left = bestsize.top = 0 ;
        bestsize.right = 16 ;
        bestsize.bottom = 16 ;
        if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
        {
            bestsize.bottom = 16 ;
        }
        else if ( IsKindOf( CLASSINFO( wxSpinButton ) ) )
        {
            bestsize.bottom = 24 ;
        }
    }

    bestWidth = bestsize.right - bestsize.left ;

    bestWidth += 2 * m_macHorizontalBorder ;

    bestHeight = bestsize.bottom - bestsize.top ;
    if ( bestHeight < 10 )
        bestHeight = 13 ;

    bestHeight += 2 * m_macVerticalBorder;


    return wxSize(bestWidth, bestHeight);
}

bool wxControl::ProcessCommand (wxCommandEvent & event)
{
    // Tries:
    // 1) OnCommand, starting at this window and working up parent hierarchy
    // 2) OnCommand then calls ProcessEvent to search the event tables.
    return GetEventHandler()->ProcessEvent(event);
}

// ------------------------
wxList *wxWinMacControlList = NULL;
wxControl *wxFindControlFromMacControl(ControlHandle inControl )
{
    wxNode *node = wxWinMacControlList->Find((long)inControl);
    if (!node)
        return NULL;
    return (wxControl *)node->GetData();
}

void wxAssociateControlWithMacControl(ControlHandle inControl, wxControl *control)
{
    // adding NULL WindowRef is (first) surely a result of an error and
    // (secondly) breaks menu command processing
    wxCHECK_RET( inControl != (ControlHandle) NULL, wxT("attempt to add a NULL WindowRef to window list") );

    if ( !wxWinMacControlList->Find((long)inControl) )
        wxWinMacControlList->Append((long)inControl, control);
}

void wxRemoveMacControlAssociation(wxControl *control)
{
    if ( wxWinMacControlList )
        wxWinMacControlList->DeleteObject(control);
}

void wxControl::MacPreControlCreate( wxWindow *parent, wxWindowID id, wxString label ,
             const wxPoint& pos,
             const wxSize& size, long style,
             const wxValidator& validator,
             const wxString& name , WXRECTPTR outBounds , unsigned char* maclabel )
{
    m_label = label ;

    // These sizes will be adjusted in MacPostControlCreate
    m_width = size.x ;
    m_height = size.y ;
    m_x = pos.x ;
    m_y = pos.y ;

    ((Rect*)outBounds)->top = -10;
    ((Rect*)outBounds)->left = -10;
    ((Rect*)outBounds)->bottom = 0;
    ((Rect*)outBounds)->right = 0;

    wxMacStringToPascal( wxStripMenuCodes(label) , maclabel ) ;
}

void wxControl::MacPostControlCreate()
{
    wxASSERT_MSG( (ControlHandle) m_macControl != NULL , wxT("No valid mac control") ) ;

    if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
    {
        // no font
    }
    else if ( !UMAHasAquaLayout() && (IsKindOf( CLASSINFO( wxStaticBox ) ) || IsKindOf( CLASSINFO( wxRadioBox ) ) || IsKindOf( CLASSINFO( wxButton ) ) ) )
    {
        ControlFontStyleRec     controlstyle ;
        controlstyle.flags = kControlUseFontMask ;
        controlstyle.font = kControlFontSmallBoldSystemFont ;

        ::SetControlFontStyle( (ControlHandle) m_macControl , &controlstyle ) ;
    }
    else
    {
        ControlFontStyleRec     controlstyle ;
        controlstyle.flags = kControlUseFontMask ;

        if (IsKindOf( CLASSINFO( wxButton ) ) )
            controlstyle.font = kControlFontBigSystemFont ; // eventually kControlFontBigSystemFont ;
        else
            controlstyle.font = kControlFontSmallSystemFont ;

        ::SetControlFontStyle( (ControlHandle) m_macControl , &controlstyle ) ;
    }
    ControlHandle container = (ControlHandle) GetParent()->MacGetContainerForEmbedding() ;
    wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ;
    ::EmbedControl( (ControlHandle) m_macControl , container ) ;
    m_macControlIsShown  = MacIsReallyShown() ;

    wxAssociateControlWithMacControl( (ControlHandle) m_macControl , this ) ;
    if ( wxMacSetupControlBackgroundUPP == NULL )
    {
        wxMacSetupControlBackgroundUPP = NewControlColorUPP( wxMacSetupControlBackground ) ;
    }
    if ( wxMacControlActionUPP == NULL )
    {
        wxMacControlActionUPP = NewControlDefUPP( wxMacControlDefinition ) ;
    }
    // The following block of code is responsible for crashes when switching
    // back to windows, which can be seen in the dialogs sample.
    // It is disabled until a proper solution can be found.
#if 0
#if TARGET_CARBON
/*
    only working under classic carbon
    m_macControlAction = *(**(ControlHandle)m_macControl).contrlDefProc ;
    (**(ControlHandle)m_macControl).contrlDefProc = (Handle) &wxMacControlActionUPP ;
*/
#else
    m_macControlAction = *(**(ControlHandle)m_macControl).contrlDefProc ;

    cdefHandle cdef ;
    cdef = (cdefHandle) NewHandle( sizeof(cdefRec) ) ;
    if (  (**(ControlHandle)m_macControl).contrlDefProc != NULL )
    {
        (**cdef).instruction = 0x4EF9;  /* JMP instruction */
        (**cdef).function = (void(*)()) wxMacControlActionUPP;
        (**(ControlHandle)m_macControl).contrlDefProc = (Handle) cdef ;
    }
#endif
#endif
    SetControlColorProc( (ControlHandle) m_macControl , wxMacSetupControlBackgroundUPP ) ;

    // Adjust the controls size and position
    wxPoint pos(m_x, m_y);
    wxSize best_size( DoGetBestSize() );
    wxSize new_size( m_width, m_height );

    m_x = m_y = m_width = m_height = -1;  // Forces SetSize to move/size the control

    if (new_size.x == -1) {
        new_size.x = best_size.x;
    }
    if (new_size.y == -1) {
        new_size.y = best_size.y;
    }

    SetSize(pos.x, pos.y, new_size.x, new_size.y);

#if wxUSE_UNICODE
    UMASetControlTitle( (ControlHandle) m_macControl , wxStripMenuCodes(m_label) , m_font.GetEncoding() ) ;
#endif

    if ( m_macControlIsShown )
        UMAShowControl( (ControlHandle) m_macControl ) ;

    SetCursor( *wxSTANDARD_CURSOR ) ;

    Refresh() ;
}

void wxControl::MacAdjustControlRect()
{
    wxASSERT_MSG( (ControlHandle) m_macControl != NULL , wxT("No valid mac control") ) ;
    if ( m_width == -1 || m_height == -1 )
    {
        Rect    bestsize = { 0 , 0 , 0 , 0 } ;
        short   baselineoffset ;

        ::GetBestControlRect( (ControlHandle) m_macControl , &bestsize , &baselineoffset ) ;

        if ( EmptyRect( &bestsize ) )
        {
            baselineoffset = 0;
            bestsize.left = bestsize.top = 0 ;
            bestsize.right = 16 ;
            bestsize.bottom = 16 ;
            if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
            {
                bestsize.bottom = 16 ;
            }
            else if ( IsKindOf( CLASSINFO( wxSpinButton ) ) )
            {
                bestsize.bottom = 24 ;
            }
        }

        if ( m_width == -1 )
        {
            if ( IsKindOf( CLASSINFO( wxButton ) ) )
            {
                m_width = m_label.Length() * 10 + 12 ;
                if ( m_width < 70 )
                  m_width = 70 ;
            }
            else if ( IsKindOf( CLASSINFO( wxStaticText ) ) )
            {
                m_width = m_label.Length() * 8 ;
            }
            else
                m_width = bestsize.right - bestsize.left ;

            m_width += 2 * m_macHorizontalBorder + MacGetLeftBorderSize() + MacGetRightBorderSize() ;
        }
        if ( m_height == -1 )
        {
            m_height = bestsize.bottom - bestsize.top ;
            if ( m_height < 10 )
                m_height = 13 ;

            m_height += 2 * m_macVerticalBorder + MacGetTopBorderSize() + MacGetBottomBorderSize() ;
        }
         MacUpdateDimensions() ;
    }
}

WXWidget wxControl::MacGetContainerForEmbedding()
{
    if ( m_macControl )
        return m_macControl ;

    return wxWindow::MacGetContainerForEmbedding() ;
}

void wxControl::MacUpdateDimensions()
{
    // actually in the current systems this should never be possible, but later reparenting
    // may become a reality

    if ( (ControlHandle) m_macControl == NULL )
        return ;

    if ( GetParent() == NULL )
        return ;

    WindowRef rootwindow = (WindowRef) MacGetRootWindow() ;
    if ( rootwindow == NULL )
        return ;

    Rect oldBounds ;
    GetControlBounds( (ControlHandle) m_macControl , &oldBounds ) ;

    int new_x = m_x + MacGetLeftBorderSize() + m_macHorizontalBorder ;
    int new_y = m_y + MacGetTopBorderSize() + m_macVerticalBorder ;
    int new_width = m_width - MacGetLeftBorderSize() - MacGetRightBorderSize() - 2 * m_macHorizontalBorder ;
    int new_height = m_height - MacGetTopBorderSize() - MacGetBottomBorderSize() - 2 * m_macVerticalBorder ;

    GetParent()->MacWindowToRootWindow( & new_x , & new_y ) ;
    bool doMove = new_x != oldBounds.left || new_y != oldBounds.top ;
    bool doResize =  ( oldBounds.right - oldBounds.left ) != new_width || (oldBounds.bottom - oldBounds.top ) != new_height ;
    if ( doMove || doResize )
    {
        InvalWindowRect( rootwindow, &oldBounds ) ;
        if ( doMove )
        {
            UMAMoveControl( (ControlHandle) m_macControl , new_x , new_y ) ;
        }
        if ( doResize )
        {
            UMASizeControl( (ControlHandle) m_macControl , new_width , new_height ) ;
        }
    }
}

void wxControl::MacSuperChangedPosition()
{
     MacUpdateDimensions() ;
    wxWindow::MacSuperChangedPosition() ;
}

void wxControl::MacSuperEnabled( bool enabled )
{
    Refresh(FALSE) ;
    wxWindow::MacSuperEnabled( enabled ) ;
}

void wxControl::MacSuperShown( bool show )
{
    if ( (ControlHandle) m_macControl )
    {
        if ( !show )
        {
            if ( m_macControlIsShown )
            {
                ::UMAHideControl( (ControlHandle) m_macControl ) ;
                m_macControlIsShown = false ;
            }
        }
        else
        {
            if ( MacIsReallyShown() && !m_macControlIsShown )
            {
                ::UMAShowControl( (ControlHandle) m_macControl ) ;
                m_macControlIsShown = true ;
            }
        }
    }

    wxWindow::MacSuperShown( show ) ;
}

void  wxControl::DoSetSize(int x, int y,
            int width, int height,
            int sizeFlags )
{
    wxWindow::DoSetSize( x , y ,width , height ,sizeFlags ) ;
#if 0
    {
        Rect meta , control ;
        GetControlBounds( (ControlHandle) m_macControl , &control ) ;
        RgnHandle rgn = NewRgn() ;
        GetControlRegion( (ControlHandle) m_macControl , kControlStructureMetaPart , rgn ) ;
        GetRegionBounds( rgn , &meta ) ;
        if ( !EmptyRect( &meta ) )
        {
            wxASSERT( meta.left >= control.left - m_macHorizontalBorder ) ;
            wxASSERT( meta.right <= control.right + m_macHorizontalBorder ) ;
            wxASSERT( meta.top >= control.top - m_macVerticalBorder ) ;
            wxASSERT( meta.bottom <= control.bottom + m_macVerticalBorder ) ;
        }
        DisposeRgn( rgn ) ;
    }
#endif
    return ;
}

bool  wxControl::Show(bool show)
{
    if ( !wxWindow::Show( show ) )
        return FALSE ;

    if ( (ControlHandle) m_macControl )
    {
        if ( !show )
        {
            if ( m_macControlIsShown )
            {
                ::UMAHideControl( (ControlHandle) m_macControl ) ;
                m_macControlIsShown = false ;
            }
        }
        else
        {
            if ( MacIsReallyShown() && !m_macControlIsShown )
            {
                ::UMAShowControl( (ControlHandle) m_macControl ) ;
                m_macControlIsShown = true ;
            }
        }
    }
    return TRUE ;
}

bool  wxControl::Enable(bool enable)
{
    if ( !wxWindow::Enable(enable) )
        return FALSE;

    if ( (ControlHandle) m_macControl )
    {
        if ( enable )
            UMAActivateControl( (ControlHandle) m_macControl ) ;
        else
            UMADeactivateControl( (ControlHandle) m_macControl ) ;
    }
    return TRUE ;
}

void wxControl::Refresh(bool eraseBack, const wxRect *rect)
{
    wxWindow::Refresh( eraseBack , rect ) ;
}

void wxControl::MacRedrawControl()
{
    if ( (ControlHandle) m_macControl && MacGetRootWindow() && m_macControlIsShown )
    {
        wxClientDC dc(this) ;
        wxMacPortSetter helper(&dc) ;
        wxMacWindowClipper clipper(this) ;
        wxDC::MacSetupBackgroundForCurrentPort( MacGetBackgroundBrush() ) ;
        UMADrawControl( (ControlHandle) m_macControl ) ;
    }
}

void wxControl::OnPaint(wxPaintEvent& event)
{
    if ( (ControlHandle) m_macControl )
    {
        wxPaintDC dc(this) ;
        wxMacPortSetter helper(&dc) ;
        wxMacWindowClipper clipper(this) ;
        wxDC::MacSetupBackgroundForCurrentPort( MacGetBackgroundBrush() ) ;
        UMADrawControl( (ControlHandle) m_macControl ) ;
    }
    else
    {
      event.Skip() ;
    }
}
void wxControl::OnEraseBackground(wxEraseEvent& event)
{
    wxWindow::OnEraseBackground( event ) ;
}

void  wxControl::OnKeyDown( wxKeyEvent &event )
{
    if ( (ControlHandle) m_macControl == NULL )
        return ;

#if TARGET_CARBON

    char charCode ;
    UInt32 keyCode ;
    UInt32 modifiers ;

    GetEventParameter( (EventRef) wxTheApp->MacGetCurrentEvent(), kEventParamKeyMacCharCodes, typeChar, NULL,sizeof(char), NULL,&charCode );
    GetEventParameter( (EventRef) wxTheApp->MacGetCurrentEvent(), kEventParamKeyCode, typeUInt32, NULL,  sizeof(UInt32), NULL, &keyCode );
       GetEventParameter((EventRef) wxTheApp->MacGetCurrentEvent(), kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);

    ::HandleControlKey( (ControlHandle) m_macControl , keyCode , charCode , modifiers ) ;

#else
    EventRecord *ev = (EventRecord*) wxTheApp->MacGetCurrentEvent() ;
    short keycode ;
    short keychar ;
    keychar = short(ev->message & charCodeMask);
    keycode = short(ev->message & keyCodeMask) >> 8 ;

    ::HandleControlKey( (ControlHandle) m_macControl , keycode , keychar , ev->modifiers ) ;
#endif
}

void  wxControl::OnMouseEvent( 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 ) )
            {
                {
                    controlpart = ::HandleControlClick( control , localwhere , modifiers , (ControlActionUPP) -1 ) ;
                    wxTheApp->s_lastMouseDown = 0 ;
                    if ( control && controlpart != kControlNoPart )
                    {
                        MacHandleControlClick( control , controlpart , false /* mouse not down anymore */ ) ;
                    }
                }
            }
        }
    }
    else
    {
    	event.Skip() ;
    }
}

bool wxControl::MacCanFocus() const
{
    if ( (ControlHandle) m_macControl == NULL )
        return true ;
    else
        return false ;
}

void wxControl::MacHandleControlClick( WXWidget control , wxInt16 controlpart , bool WXUNUSED( mouseStillDown ) )
{
    wxASSERT_MSG( (ControlHandle) m_macControl != NULL , wxT("No valid mac control") ) ;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: control.cpp
	3	// Purpose: wxControl class
	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 "control.h"
	14	#endif
	15
	16	#include "wx/defs.h"
	17
	18	#include "wx/control.h"
	19	#include "wx/panel.h"
	20	#include "wx/app.h"
	21	#include "wx/dc.h"
	22	#include "wx/dcclient.h"
	23	#include "wx/notebook.h"
	24	#include "wx/tabctrl.h"
	25	#include "wx/radiobox.h"
	26	#include "wx/spinbutt.h"
	27	#include "wx/scrolbar.h"
	28	#include "wx/button.h"
	29	#include "wx/dialog.h"
	30	#include "wx/statbox.h"
	31	#include "wx/sizer.h"
	32	#include "wx/stattext.h"
	33
	34	#if !USE_SHARED_LIBRARY
	35	IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow)
	36
	37	BEGIN_EVENT_TABLE(wxControl, wxWindow)
	38	EVT_MOUSE_EVENTS( wxControl::OnMouseEvent )
	39	EVT_PAINT( wxControl::OnPaint )
	40	END_EVENT_TABLE()
	41	#endif
	42
	43	#include "wx/mac/uma.h"
	44	#include "wx/mac/private.h"
	45
	46	// Item members
	47
	48
	49	#if PRAGMA_STRUCT_ALIGN
	50	#pragma options align=mac68k
	51	#elif PRAGMA_STRUCT_PACKPUSH
	52	#pragma pack(push, 2)
	53	#elif PRAGMA_STRUCT_PACK
	54	#pragma pack(2)
	55	#endif
	56
	57	typedef struct {
	58	unsigned short instruction;
	59	void (*function)();
	60	} cdefRec, cdefPtr, *cdefHandle;
	61
	62	#if PRAGMA_STRUCT_ALIGN
	63	#pragma options align=reset
	64	#elif PRAGMA_STRUCT_PACKPUSH
	65	#pragma pack(pop)
	66	#elif PRAGMA_STRUCT_PACK
	67	#pragma pack()
	68	#endif
	69
	70	ControlActionUPP wxMacLiveScrollbarActionUPP = NULL ;
	71	wxControl *wxFindControlFromMacControl(ControlHandle inControl ) ;
	72
	73	pascal void wxMacLiveScrollbarActionProc( ControlHandle control , ControlPartCode partCode ) ;
	74	pascal void wxMacLiveScrollbarActionProc( ControlHandle control , ControlPartCode partCode )
	75	{
	76	if ( partCode != 0)
	77	{
	78	wxControl* wx = (wxControl*) GetControlReference( control ) ;
	79	if ( wx )
	80	{
	81	wx->MacHandleControlClick( control , partCode , true /* stillDown */ ) ;
	82	}
	83	}
	84	}
	85
	86	ControlColorUPP wxMacSetupControlBackgroundUPP = NULL ;
	87	ControlDefUPP wxMacControlActionUPP = NULL ;
	88
	89	pascal SInt32 wxMacControlDefinition(SInt16 varCode, ControlRef theControl, ControlDefProcMessage message, SInt32 param)
	90	{
	91
	92	wxControl* wx = (wxControl*) wxFindControlFromMacControl( theControl ) ;
	93	if ( wx != NULL && wx->IsKindOf( CLASSINFO( wxControl ) ) )
	94	{
	95	if( message == drawCntl )
	96	{
	97	wxMacWindowClipper clip( wx ) ;
	98	return InvokeControlDefUPP( varCode , theControl , message , param , (ControlDefUPP) wx->MacGetControlAction() ) ;
	99	}
	100	else
	101	return InvokeControlDefUPP( varCode , theControl , message , param , (ControlDefUPP) wx->MacGetControlAction() ) ;
	102	}
	103	return NULL ;
	104	}
	105
	106	pascal OSStatus wxMacSetupControlBackground( ControlRef iControl , SInt16 iMessage , SInt16 iDepth , Boolean iIsColor )
	107	{
	108	OSStatus status = noErr ;
	109	switch( iMessage )
	110	{
	111	case kControlMsgSetUpBackground :
	112	{
	113	wxControl* wx = (wxControl*) GetControlReference( iControl ) ;
	114	if ( wx != NULL && wx->IsKindOf( CLASSINFO( wxControl ) ) )
	115	{
	116	wxDC::MacSetupBackgroundForCurrentPort( wx->MacGetBackgroundBrush() ) ;
	117	#if TARGET_CARBON
	118	// under classic this would lead to partial redraws
	119	RgnHandle clip = NewRgn() ;
	120	int x = 0 , y = 0;
	121
	122	wx->MacWindowToRootWindow( &x,&y ) ;
	123	CopyRgn( (RgnHandle) wx->MacGetVisibleRegion(false).GetWXHRGN() , clip ) ;
	124	OffsetRgn( clip , x , y ) ;
	125	SetClip( clip ) ;
	126	DisposeRgn( clip ) ;
	127	#endif
	128	}
	129	else
	130	{
	131	status = paramErr ;
	132	}
	133	}
	134	break ;
	135	default :
	136	status = paramErr ;
	137	break ;
	138	}
	139	return status ;
	140	}
	141
	142	wxControl::wxControl()
	143	{
	144	m_macControl = NULL ;
	145	m_macControlAction = NULL ;
	146	m_macHorizontalBorder = 0 ; // additional pixels around the real control
	147	m_macVerticalBorder = 0 ;
	148	m_backgroundColour = *wxWHITE;
	149	m_foregroundColour = *wxBLACK;
	150
	151	if ( wxMacLiveScrollbarActionUPP == NULL )
	152	{
	153	#if defined(UNIVERSAL_INTERFACES_VERSION) && (UNIVERSAL_INTERFACES_VERSION >= 0x0340)
	154	wxMacLiveScrollbarActionUPP = NewControlActionUPP( wxMacLiveScrollbarActionProc );
	155	#else
	156	wxMacLiveScrollbarActionUPP = NewControlActionProc( wxMacLiveScrollbarActionProc ) ;
	157	#endif
	158	}
	159	}
	160
	161	bool wxControl::Create(wxWindow *parent, wxWindowID id,
	162	const wxPoint& pos,
	163	const wxSize& size, long style,
	164	const wxValidator& validator,
	165	const wxString& name)
	166	{
	167	m_macControl = NULL ;
	168	m_macHorizontalBorder = 0 ; // additional pixels around the real control
	169	m_macVerticalBorder = 0 ;
	170
	171	bool rval = wxWindow::Create(parent, id, pos, size, style, name);
	172	if ( parent )
	173	{
	174	m_backgroundColour = parent->GetBackgroundColour() ;
	175	m_foregroundColour = parent->GetForegroundColour() ;
	176	}
	177	if (rval) {
	178	#if wxUSE_VALIDATORS
	179	SetValidator(validator);
	180	#endif
	181	}
	182	return rval;
	183	}
	184
	185	wxControl::~wxControl()
	186	{
	187	m_isBeingDeleted = TRUE;
	188	wxRemoveMacControlAssociation( this ) ;
	189	// If we delete an item, we should initialize the parent panel,
	190	// because it could now be invalid.
	191	wxWindow *parent = GetParent() ;
	192	if ( parent )
	193	{
	194	if (parent->GetDefaultItem() == (wxButton*) this)
	195	parent->SetDefaultItem(NULL);
	196	}
	197	if ( (ControlHandle) m_macControl )
	198	{
	199	::DisposeControl( (ControlHandle) m_macControl ) ;
	200	m_macControl = NULL ;
	201	}
	202	}
	203
	204	void wxControl::SetLabel(const wxString& title)
	205	{
	206	m_label = wxStripMenuCodes(title) ;
	207
	208	if ( m_macControl )
	209	{
	210	UMASetControlTitle( (ControlHandle) m_macControl , m_label , m_font.GetEncoding() ) ;
	211	}
	212	Refresh() ;
	213	}
	214
	215	wxSize wxControl::DoGetBestSize() const
	216	{
	217	if ( (ControlHandle) m_macControl == NULL )
	218	return wxWindow::DoGetBestSize() ;
	219
	220	Rect bestsize = { 0 , 0 , 0 , 0 } ;
	221	short baselineoffset ;
	222	int bestWidth, bestHeight ;
	223	::GetBestControlRect( (ControlHandle) m_macControl , &bestsize , &baselineoffset ) ;
	224
	225	if ( EmptyRect( &bestsize ) )
	226	{
	227	baselineoffset = 0;
	228	bestsize.left = bestsize.top = 0 ;
	229	bestsize.right = 16 ;
	230	bestsize.bottom = 16 ;
	231	if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
	232	{
	233	bestsize.bottom = 16 ;
	234	}
	235	else if ( IsKindOf( CLASSINFO( wxSpinButton ) ) )
	236	{
	237	bestsize.bottom = 24 ;
	238	}
	239	}
	240
	241	bestWidth = bestsize.right - bestsize.left ;
	242
	243	bestWidth += 2 * m_macHorizontalBorder ;
	244
	245	bestHeight = bestsize.bottom - bestsize.top ;
	246	if ( bestHeight < 10 )
	247	bestHeight = 13 ;
	248
	249	bestHeight += 2 * m_macVerticalBorder;
	250
	251
	252	return wxSize(bestWidth, bestHeight);
	253	}
	254
	255	bool wxControl::ProcessCommand (wxCommandEvent & event)
	256	{
	257	// Tries:
	258	// 1) OnCommand, starting at this window and working up parent hierarchy
	259	// 2) OnCommand then calls ProcessEvent to search the event tables.
	260	return GetEventHandler()->ProcessEvent(event);
	261	}
	262
	263	// ------------------------
	264	wxList *wxWinMacControlList = NULL;
	265	wxControl *wxFindControlFromMacControl(ControlHandle inControl )
	266	{
	267	wxNode *node = wxWinMacControlList->Find((long)inControl);
	268	if (!node)
	269	return NULL;
	270	return (wxControl *)node->GetData();
	271	}
	272
	273	void wxAssociateControlWithMacControl(ControlHandle inControl, wxControl *control)
	274	{
	275	// adding NULL WindowRef is (first) surely a result of an error and
	276	// (secondly) breaks menu command processing
	277	wxCHECK_RET( inControl != (ControlHandle) NULL, wxT("attempt to add a NULL WindowRef to window list") );
	278
	279	if ( !wxWinMacControlList->Find((long)inControl) )
	280	wxWinMacControlList->Append((long)inControl, control);
	281	}
	282
	283	void wxRemoveMacControlAssociation(wxControl *control)
	284	{
	285	if ( wxWinMacControlList )
	286	wxWinMacControlList->DeleteObject(control);
	287	}
	288
	289	void wxControl::MacPreControlCreate( wxWindow *parent, wxWindowID id, wxString label ,
	290	const wxPoint& pos,
	291	const wxSize& size, long style,
	292	const wxValidator& validator,
	293	const wxString& name , WXRECTPTR outBounds , unsigned char* maclabel )
	294	{
	295	m_label = label ;
	296
	297	// These sizes will be adjusted in MacPostControlCreate
	298	m_width = size.x ;
	299	m_height = size.y ;
	300	m_x = pos.x ;
	301	m_y = pos.y ;
	302
	303	((Rect*)outBounds)->top = -10;
	304	((Rect*)outBounds)->left = -10;
	305	((Rect*)outBounds)->bottom = 0;
	306	((Rect*)outBounds)->right = 0;
	307
	308	wxMacStringToPascal( wxStripMenuCodes(label) , maclabel ) ;
	309	}
	310
	311	void wxControl::MacPostControlCreate()
	312	{
	313	wxASSERT_MSG( (ControlHandle) m_macControl != NULL , wxT("No valid mac control") ) ;
	314
	315	if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
	316	{
	317	// no font
	318	}
	319	else if ( !UMAHasAquaLayout() && (IsKindOf( CLASSINFO( wxStaticBox ) ) \|\| IsKindOf( CLASSINFO( wxRadioBox ) ) \|\| IsKindOf( CLASSINFO( wxButton ) ) ) )
	320	{
	321	ControlFontStyleRec controlstyle ;
	322	controlstyle.flags = kControlUseFontMask ;
	323	controlstyle.font = kControlFontSmallBoldSystemFont ;
	324
	325	::SetControlFontStyle( (ControlHandle) m_macControl , &controlstyle ) ;
	326	}
	327	else
	328	{
	329	ControlFontStyleRec controlstyle ;
	330	controlstyle.flags = kControlUseFontMask ;
	331
	332	if (IsKindOf( CLASSINFO( wxButton ) ) )
	333	controlstyle.font = kControlFontBigSystemFont ; // eventually kControlFontBigSystemFont ;
	334	else
	335	controlstyle.font = kControlFontSmallSystemFont ;
	336
	337	::SetControlFontStyle( (ControlHandle) m_macControl , &controlstyle ) ;
	338	}
	339	ControlHandle container = (ControlHandle) GetParent()->MacGetContainerForEmbedding() ;
	340	wxASSERT_MSG( container != NULL , wxT("No valid mac container control") ) ;
	341	::EmbedControl( (ControlHandle) m_macControl , container ) ;
	342	m_macControlIsShown = MacIsReallyShown() ;
	343
	344	wxAssociateControlWithMacControl( (ControlHandle) m_macControl , this ) ;
	345	if ( wxMacSetupControlBackgroundUPP == NULL )
	346	{
	347	wxMacSetupControlBackgroundUPP = NewControlColorUPP( wxMacSetupControlBackground ) ;
	348	}
	349	if ( wxMacControlActionUPP == NULL )
	350	{
	351	wxMacControlActionUPP = NewControlDefUPP( wxMacControlDefinition ) ;
	352	}
	353	// The following block of code is responsible for crashes when switching
	354	// back to windows, which can be seen in the dialogs sample.
	355	// It is disabled until a proper solution can be found.
	356	#if 0
	357	#if TARGET_CARBON
	358	/*
	359	only working under classic carbon
	360	m_macControlAction = (*(ControlHandle)m_macControl).contrlDefProc ;
	361	(**(ControlHandle)m_macControl).contrlDefProc = (Handle) &wxMacControlActionUPP ;
	362	*/
	363	#else
	364	m_macControlAction = (*(ControlHandle)m_macControl).contrlDefProc ;
	365
	366	cdefHandle cdef ;
	367	cdef = (cdefHandle) NewHandle( sizeof(cdefRec) ) ;
	368	if ( (**(ControlHandle)m_macControl).contrlDefProc != NULL )
	369	{
	370	(*cdef).instruction = 0x4EF9; / JMP instruction */
	371	(*cdef).function = (void()()) wxMacControlActionUPP;
	372	(**(ControlHandle)m_macControl).contrlDefProc = (Handle) cdef ;
	373	}
	374	#endif
	375	#endif
	376	SetControlColorProc( (ControlHandle) m_macControl , wxMacSetupControlBackgroundUPP ) ;
	377
	378	// Adjust the controls size and position
	379	wxPoint pos(m_x, m_y);
	380	wxSize best_size( DoGetBestSize() );
	381	wxSize new_size( m_width, m_height );
	382
	383	m_x = m_y = m_width = m_height = -1; // Forces SetSize to move/size the control
	384
	385	if (new_size.x == -1) {
	386	new_size.x = best_size.x;
	387	}
	388	if (new_size.y == -1) {
	389	new_size.y = best_size.y;
	390	}
	391
	392	SetSize(pos.x, pos.y, new_size.x, new_size.y);
	393
	394	#if wxUSE_UNICODE
	395	UMASetControlTitle( (ControlHandle) m_macControl , wxStripMenuCodes(m_label) , m_font.GetEncoding() ) ;
	396	#endif
	397
	398	if ( m_macControlIsShown )
	399	UMAShowControl( (ControlHandle) m_macControl ) ;
	400
	401	SetCursor( *wxSTANDARD_CURSOR ) ;
	402
	403	Refresh() ;
	404	}
	405
	406	void wxControl::MacAdjustControlRect()
	407	{
	408	wxASSERT_MSG( (ControlHandle) m_macControl != NULL , wxT("No valid mac control") ) ;
	409	if ( m_width == -1 \|\| m_height == -1 )
	410	{
	411	Rect bestsize = { 0 , 0 , 0 , 0 } ;
	412	short baselineoffset ;
	413
	414	::GetBestControlRect( (ControlHandle) m_macControl , &bestsize , &baselineoffset ) ;
	415
	416	if ( EmptyRect( &bestsize ) )
	417	{
	418	baselineoffset = 0;
	419	bestsize.left = bestsize.top = 0 ;
	420	bestsize.right = 16 ;
	421	bestsize.bottom = 16 ;
	422	if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
	423	{
	424	bestsize.bottom = 16 ;
	425	}
	426	else if ( IsKindOf( CLASSINFO( wxSpinButton ) ) )
	427	{
	428	bestsize.bottom = 24 ;
	429	}
	430	}
	431
	432	if ( m_width == -1 )
	433	{
	434	if ( IsKindOf( CLASSINFO( wxButton ) ) )
	435	{
	436	m_width = m_label.Length() * 10 + 12 ;
	437	if ( m_width < 70 )
	438	m_width = 70 ;
	439	}
	440	else if ( IsKindOf( CLASSINFO( wxStaticText ) ) )
	441	{
	442	m_width = m_label.Length() * 8 ;
	443	}
	444	else
	445	m_width = bestsize.right - bestsize.left ;
	446
	447	m_width += 2 * m_macHorizontalBorder + MacGetLeftBorderSize() + MacGetRightBorderSize() ;
	448	}
	449	if ( m_height == -1 )
	450	{
	451	m_height = bestsize.bottom - bestsize.top ;
	452	if ( m_height < 10 )
	453	m_height = 13 ;
	454
	455	m_height += 2 * m_macVerticalBorder + MacGetTopBorderSize() + MacGetBottomBorderSize() ;
	456	}
	457	MacUpdateDimensions() ;
	458	}
	459	}
	460
	461	WXWidget wxControl::MacGetContainerForEmbedding()
	462	{
	463	if ( m_macControl )
	464	return m_macControl ;
	465
	466	return wxWindow::MacGetContainerForEmbedding() ;
	467	}
	468
	469	void wxControl::MacUpdateDimensions()
	470	{
	471	// actually in the current systems this should never be possible, but later reparenting
	472	// may become a reality
	473
	474	if ( (ControlHandle) m_macControl == NULL )
	475	return ;
	476
	477	if ( GetParent() == NULL )
	478	return ;
	479
	480	WindowRef rootwindow = (WindowRef) MacGetRootWindow() ;
	481	if ( rootwindow == NULL )
	482	return ;
	483
	484	Rect oldBounds ;
	485	GetControlBounds( (ControlHandle) m_macControl , &oldBounds ) ;
	486
	487	int new_x = m_x + MacGetLeftBorderSize() + m_macHorizontalBorder ;
	488	int new_y = m_y + MacGetTopBorderSize() + m_macVerticalBorder ;
	489	int new_width = m_width - MacGetLeftBorderSize() - MacGetRightBorderSize() - 2 * m_macHorizontalBorder ;
	490	int new_height = m_height - MacGetTopBorderSize() - MacGetBottomBorderSize() - 2 * m_macVerticalBorder ;
	491
	492	GetParent()->MacWindowToRootWindow( & new_x , & new_y ) ;
	493	bool doMove = new_x != oldBounds.left \|\| new_y != oldBounds.top ;
	494	bool doResize = ( oldBounds.right - oldBounds.left ) != new_width \|\| (oldBounds.bottom - oldBounds.top ) != new_height ;
	495	if ( doMove \|\| doResize )
	496	{
	497	InvalWindowRect( rootwindow, &oldBounds ) ;
	498	if ( doMove )
	499	{
	500	UMAMoveControl( (ControlHandle) m_macControl , new_x , new_y ) ;
	501	}
	502	if ( doResize )
	503	{
	504	UMASizeControl( (ControlHandle) m_macControl , new_width , new_height ) ;
	505	}
	506	}
	507	}
	508
	509	void wxControl::MacSuperChangedPosition()
	510	{
	511	MacUpdateDimensions() ;
	512	wxWindow::MacSuperChangedPosition() ;
	513	}
	514
	515	void wxControl::MacSuperEnabled( bool enabled )
	516	{
	517	Refresh(FALSE) ;
	518	wxWindow::MacSuperEnabled( enabled ) ;
	519	}
	520
	521	void wxControl::MacSuperShown( bool show )
	522	{
	523	if ( (ControlHandle) m_macControl )
	524	{
	525	if ( !show )
	526	{
	527	if ( m_macControlIsShown )
	528	{
	529	::UMAHideControl( (ControlHandle) m_macControl ) ;
	530	m_macControlIsShown = false ;
	531	}
	532	}
	533	else
	534	{
	535	if ( MacIsReallyShown() && !m_macControlIsShown )
	536	{
	537	::UMAShowControl( (ControlHandle) m_macControl ) ;
	538	m_macControlIsShown = true ;
	539	}
	540	}
	541	}
	542
	543	wxWindow::MacSuperShown( show ) ;
	544	}
	545
	546	void wxControl::DoSetSize(int x, int y,
	547	int width, int height,
	548	int sizeFlags )
	549	{
	550	wxWindow::DoSetSize( x , y ,width , height ,sizeFlags ) ;
	551	#if 0
	552	{
	553	Rect meta , control ;
	554	GetControlBounds( (ControlHandle) m_macControl , &control ) ;
	555	RgnHandle rgn = NewRgn() ;
	556	GetControlRegion( (ControlHandle) m_macControl , kControlStructureMetaPart , rgn ) ;
	557	GetRegionBounds( rgn , &meta ) ;
	558	if ( !EmptyRect( &meta ) )
	559	{
	560	wxASSERT( meta.left >= control.left - m_macHorizontalBorder ) ;
	561	wxASSERT( meta.right <= control.right + m_macHorizontalBorder ) ;
	562	wxASSERT( meta.top >= control.top - m_macVerticalBorder ) ;
	563	wxASSERT( meta.bottom <= control.bottom + m_macVerticalBorder ) ;
	564	}
	565	DisposeRgn( rgn ) ;
	566	}
	567	#endif
	568	return ;
	569	}
	570
	571	bool wxControl::Show(bool show)
	572	{
	573	if ( !wxWindow::Show( show ) )
	574	return FALSE ;
	575
	576	if ( (ControlHandle) m_macControl )
	577	{
	578	if ( !show )
	579	{
	580	if ( m_macControlIsShown )
	581	{
	582	::UMAHideControl( (ControlHandle) m_macControl ) ;
	583	m_macControlIsShown = false ;
	584	}
	585	}
	586	else
	587	{
	588	if ( MacIsReallyShown() && !m_macControlIsShown )
	589	{
	590	::UMAShowControl( (ControlHandle) m_macControl ) ;
	591	m_macControlIsShown = true ;
	592	}
	593	}
	594	}
	595	return TRUE ;
	596	}
	597
	598	bool wxControl::Enable(bool enable)
	599	{
	600	if ( !wxWindow::Enable(enable) )
	601	return FALSE;
	602
	603	if ( (ControlHandle) m_macControl )
	604	{
	605	if ( enable )
	606	UMAActivateControl( (ControlHandle) m_macControl ) ;
	607	else
	608	UMADeactivateControl( (ControlHandle) m_macControl ) ;
	609	}
	610	return TRUE ;
	611	}
	612
	613	void wxControl::Refresh(bool eraseBack, const wxRect *rect)
	614	{
	615	wxWindow::Refresh( eraseBack , rect ) ;
	616	}
	617
	618	void wxControl::MacRedrawControl()
	619	{
	620	if ( (ControlHandle) m_macControl && MacGetRootWindow() && m_macControlIsShown )
	621	{
	622	wxClientDC dc(this) ;
	623	wxMacPortSetter helper(&dc) ;
	624	wxMacWindowClipper clipper(this) ;
	625	wxDC::MacSetupBackgroundForCurrentPort( MacGetBackgroundBrush() ) ;
	626	UMADrawControl( (ControlHandle) m_macControl ) ;
	627	}
	628	}
	629
	630	void wxControl::OnPaint(wxPaintEvent& event)
	631	{
	632	if ( (ControlHandle) m_macControl )
	633	{
	634	wxPaintDC dc(this) ;
	635	wxMacPortSetter helper(&dc) ;
	636	wxMacWindowClipper clipper(this) ;
	637	wxDC::MacSetupBackgroundForCurrentPort( MacGetBackgroundBrush() ) ;
	638	UMADrawControl( (ControlHandle) m_macControl ) ;
	639	}
	640	else
	641	{
	642	event.Skip() ;
	643	}
	644	}
	645	void wxControl::OnEraseBackground(wxEraseEvent& event)
	646	{
	647	wxWindow::OnEraseBackground( event ) ;
	648	}
	649
	650	void wxControl::OnKeyDown( wxKeyEvent &event )
	651	{
	652	if ( (ControlHandle) m_macControl == NULL )
	653	return ;
	654
	655	#if TARGET_CARBON
	656
	657	char charCode ;
	658	UInt32 keyCode ;
	659	UInt32 modifiers ;
	660
	661	GetEventParameter( (EventRef) wxTheApp->MacGetCurrentEvent(), kEventParamKeyMacCharCodes, typeChar, NULL,sizeof(char), NULL,&charCode );
	662	GetEventParameter( (EventRef) wxTheApp->MacGetCurrentEvent(), kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
	663	GetEventParameter((EventRef) wxTheApp->MacGetCurrentEvent(), kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
	664
	665	::HandleControlKey( (ControlHandle) m_macControl , keyCode , charCode , modifiers ) ;
	666
	667	#else
	668	EventRecord ev = (EventRecord) wxTheApp->MacGetCurrentEvent() ;
	669	short keycode ;
	670	short keychar ;
	671	keychar = short(ev->message & charCodeMask);
	672	keycode = short(ev->message & keyCodeMask) >> 8 ;
	673
	674	::HandleControlKey( (ControlHandle) m_macControl , keycode , keychar , ev->modifiers ) ;
	675	#endif
	676	}
	677
	678	void wxControl::OnMouseEvent( wxMouseEvent &event )
	679	{
	680	if ( (ControlHandle) m_macControl == NULL )
	681	{
	682	event.Skip() ;
	683	return ;
	684	}
	685
	686	if (event.GetEventType() == wxEVT_LEFT_DOWN \|\| event.GetEventType() == wxEVT_LEFT_DCLICK )
	687	{
	688
	689	int x = event.m_x ;
	690	int y = event.m_y ;
	691
	692	MacClientToRootWindow( &x , &y ) ;
	693
	694	ControlHandle control ;
	695	Point localwhere ;
	696	SInt16 controlpart ;
	697
	698	localwhere.h = x ;
	699	localwhere.v = y ;
	700
	701	short modifiers = 0;
	702
	703	if ( !event.m_leftDown && !event.m_rightDown )
	704	modifiers \|= btnState ;
	705
	706	if ( event.m_shiftDown )
	707	modifiers \|= shiftKey ;
	708
	709	if ( event.m_controlDown )
	710	modifiers \|= controlKey ;
	711
	712	if ( event.m_altDown )
	713	modifiers \|= optionKey ;
	714
	715	if ( event.m_metaDown )
	716	modifiers \|= cmdKey ;
	717	{
	718	control = (ControlHandle) m_macControl ;
	719	if ( control && ::IsControlActive( control ) )
	720	{
	721	{
	722	controlpart = ::HandleControlClick( control , localwhere , modifiers , (ControlActionUPP) -1 ) ;
	723	wxTheApp->s_lastMouseDown = 0 ;
	724	if ( control && controlpart != kControlNoPart )
	725	{
	726	MacHandleControlClick( control , controlpart , false /* mouse not down anymore */ ) ;
	727	}
	728	}
	729	}
	730	}
	731	}
	732	else
	733	{
	734	event.Skip() ;
	735	}
	736	}
	737
	738	bool wxControl::MacCanFocus() const
	739	{
	740	if ( (ControlHandle) m_macControl == NULL )
	741	return true ;
	742	else
	743	return false ;
	744	}
	745
	746	void wxControl::MacHandleControlClick( WXWidget control , wxInt16 controlpart , bool WXUNUSED( mouseStillDown ) )
	747	{
	748	wxASSERT_MSG( (ControlHandle) m_macControl != NULL , wxT("No valid mac control") ) ;
	749	}
	750