src/mac/carbon/uma.cpp

#include "wx/defs.h"
#include "wx/dc.h"
#include "wx/mac/uma.h"
#include <MacTextEditor.h>

#ifndef __DARWIN__
#  include <Navigation.h>
#  if defined(TARGET_CARBON)
#    if PM_USE_SESSION_APIS
#      include <PMCore.h>
#    endif
#    include <PMApplication.h>
#  else
#    include <Printing.h>
#  endif
#endif

// since we have decided that we only support 8.6 upwards we are
// checking for these minimum requirements in the startup code of
// the application so all wxWindows code can safely assume that appearance 1.1
// windows manager, control manager, navigation services etc. are
// present

static bool	sUMAHasAppearance = false ;
static long sUMAAppearanceVersion = 0 ;
static long sUMASystemVersion = 0 ;
static bool sUMAHasAquaLayout = false ;
static bool sUMASystemInitialized = false ;

extern int gAGABackgroundColor ;
bool UMAHasAppearance() { return sUMAHasAppearance ; }
long UMAGetAppearanceVersion() { return sUMAAppearanceVersion ; }
long UMAGetSystemVersion() { return sUMASystemVersion ; }

static bool	sUMAHasWindowManager = false ;
static long sUMAWindowManagerAttr = 0 ;

bool UMAHasWindowManager() { return sUMAHasWindowManager ; }
long UMAGetWindowManagerAttr() { return sUMAWindowManagerAttr ; }
bool UMAHasAquaLayout() { return sUMAHasAquaLayout ; }
bool UMASystemIsInitialized() { return sUMASystemInitialized ; }

void UMACleanupToolbox()
{
	if ( sUMAHasAppearance )
	{
		UnregisterAppearanceClient() ;
	}
	if ( NavServicesAvailable() )
	{
		NavUnload() ;
	}
  if ( TXNTerminateTextension != (void*) kUnresolvedCFragSymbolAddress )
	  TXNTerminateTextension( ) ;
}
void UMAInitToolbox( UInt16 inMoreMastersCalls )
{
#if !TARGET_CARBON
	::MaxApplZone();
	for (long i = 1; i <= inMoreMastersCalls; i++)
		::MoreMasters();

	::InitGraf(&qd.thePort);
	::InitFonts();
	::InitMenus();
	::TEInit();
	::InitDialogs(0L);
	::FlushEvents(everyEvent, 0);
	::InitCursor();
	long total,contig;
	PurgeSpace(&total, &contig);
#else
	InitCursor();
#endif

    if ( Gestalt(gestaltSystemVersion, &sUMASystemVersion) != noErr)
    	sUMASystemVersion = 0x0000 ;

	long theAppearance ;
	if ( Gestalt( gestaltAppearanceAttr, &theAppearance ) == noErr )
	{
		sUMAHasAppearance = true ;
		RegisterAppearanceClient();
		if ( Gestalt( gestaltAppearanceVersion, &theAppearance ) == noErr )
		{
			sUMAAppearanceVersion = theAppearance ;
		}
		else
		{
			sUMAAppearanceVersion = 0x0100 ;
		}
	}
	if ( Gestalt( gestaltWindowMgrAttr, &sUMAWindowManagerAttr ) == noErr )
	{
		sUMAHasWindowManager = sUMAWindowManagerAttr & gestaltWindowMgrPresent ;
	}

#if TARGET_CARBON
// Call currently implicitely done :		InitFloatingWindows() ;
#else
	if ( sUMAHasWindowManager )
		InitFloatingWindows() ;
	else
		InitWindows();
#endif

	if ( NavServicesAvailable() )
	{
		NavLoad() ;
	}

  long menuMgrAttr ;
  Gestalt( gestaltMenuMgrAttr , &menuMgrAttr ) ;
  if ( menuMgrAttr & gestaltMenuMgrAquaLayoutMask )
    sUMAHasAquaLayout = true ;

  if ( TXNInitTextension != (void*) kUnresolvedCFragSymbolAddress )
  {
    FontFamilyID fontId ;
	Str255 fontName ;
	SInt16 fontSize ;
	Style fontStyle ;
	GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
    GetFNum( fontName, &fontId );

    TXNMacOSPreferredFontDescription fontDescriptions[] =
    {
        { fontId , (fontSize << 16) ,kTXNDefaultFontStyle, kTXNSystemDefaultEncoding } ,
    } ;
    int noOfFontDescriptions = sizeof( fontDescriptions ) / sizeof(TXNMacOSPreferredFontDescription) ;
#if 0 // TARGET_CARBON
    --noOfFontDescriptions ;
#endif
  	// kTXNAlwaysUseQuickDrawTextMask might be desirable because of speed increases but it crashes the app under OS X upon key stroke
  	OptionBits options = kTXNWantMoviesMask | kTXNWantSoundMask | kTXNWantGraphicsMask ;
#if TARGET_CARBON
    if ( !UMAHasAquaLayout() )
#endif
    {
        options |= kTXNAlwaysUseQuickDrawTextMask ;
    }
  	TXNInitTextension(fontDescriptions,  noOfFontDescriptions, options );
  }


  sUMASystemInitialized = true ;

}

/*
Boolean CanUseATSUI()
	{
	long result;
	OSErr err = Gestalt(gestaltATSUVersion, &result);
	return (err == noErr);
	}
*/
// process manager
long UMAGetProcessMode()
{
	OSErr err ;
	ProcessInfoRec processinfo;
	ProcessSerialNumber procno ;

	procno.highLongOfPSN = NULL ;
	procno.lowLongOfPSN = kCurrentProcess ;
	processinfo.processInfoLength = sizeof(ProcessInfoRec);
	processinfo.processName = NULL;
	processinfo.processAppSpec = NULL;

	err = ::GetProcessInformation( &procno , &processinfo ) ;
	wxASSERT( err == noErr ) ;
	return processinfo.processMode ;
}

bool UMAGetProcessModeDoesActivateOnFGSwitch()
{
	return UMAGetProcessMode() & modeDoesActivateOnFGSwitch ;
}

// menu manager

void UMASetMenuTitle( MenuRef menu , StringPtr title )
{
/*
#if !TARGET_CARBON
	long 			size = GetHandleSize( (Handle) menu ) ;
	const long 		headersize = 14 ;
	int				oldlen = (**menu).menuData[0] + 1;
	int				newlen = title[0] + 1 ;

	if ( oldlen < newlen )
	{
		// enlarge before adjusting
		SetHandleSize( (Handle) menu , size + (newlen - oldlen ) );
	}

	if ( oldlen != newlen )
		memmove( (char*) (**menu).menuData + newlen , (char*) (**menu).menuData + oldlen , size - headersize - oldlen ) ;

	memcpy( (char*) (**menu).menuData , title ,  newlen ) ;
	if ( oldlen > newlen )
	{
		// shrink after
		SetHandleSize( (Handle) menu , size + (newlen - oldlen ) ) ;
	}
#else
*/
	SetMenuTitle( menu , title ) ;
//#endif
}

UInt32 UMAMenuEvent( EventRecord *inEvent )
{
		return MenuEvent( inEvent ) ;
}

void 			UMAEnableMenuItem( MenuRef inMenu , MenuItemIndex inItem )
{
	EnableMenuItem( inMenu , inItem ) ;
}

void 			UMADisableMenuItem( MenuRef inMenu , MenuItemIndex inItem )
{
	DisableMenuItem( inMenu , inItem ) ;
}

void UMAAppendSubMenuItem( MenuRef menu , StringPtr l , SInt16 id )
{
	MacAppendMenu(menu, l);
	SetMenuItemHierarchicalID( menu , CountMenuItems( menu ) , id ) ;
}

void UMAInsertSubMenuItem( MenuRef menu , StringPtr l , MenuItemIndex item , SInt16 id  )
{
	MacInsertMenuItem(menu, l , item);
	SetMenuItemHierarchicalID( menu , item , id ) ;
}

void UMASetMenuItemShortcut( MenuRef menu , MenuItemIndex item , SInt16 key , UInt8 modifiers )
{
	if ( key )
	{
	    SInt16 glyph = 0 ;
	    SInt16 macKey = key ;
	    if ( key >= WXK_F1 && key <= WXK_F15 )
	    {
	        macKey = kFunctionKeyCharCode ;
	        glyph = kMenuF1Glyph + ( key - WXK_F1 ) ;
	        if ( key >= WXK_F13 )
	            glyph += 13 ;
	        switch( key )
	        {
	            case WXK_F1 :
	                macKey += ( 0x7a << 8 ) ;
	                break ;
	            case WXK_F2 :
	                macKey += ( 0x78 << 8 ) ;
	                break ;
	            case WXK_F3 :
	                macKey += ( 0x63 << 8 ) ;
	                break ;
	            case WXK_F4 :
	                macKey += ( 0x76 << 8 ) ;
	                break ;
	            case WXK_F5 :
	                macKey += ( 0x60 << 8 ) ;
	                break ;
	            case WXK_F6 :
	                macKey += ( 0x61 << 8 ) ;
	                break ;
	            case WXK_F7 :
	                macKey += ( 0x62 << 8 ) ;
	                break ;
	            case WXK_F8 :
	                macKey += ( 0x64 << 8 ) ;
	                break ;
	            case WXK_F9 :
	                macKey += ( 0x65 << 8 ) ;
	                break ;
	            case WXK_F10 :
	                macKey += ( 0x6D << 8 ) ;
	                break ;
	            case WXK_F11 :
	                macKey += ( 0x67 << 8 ) ;
	                break ;
	            case WXK_F12 :
	                macKey += ( 0x6F << 8 ) ;
	                break ;
	            case WXK_F13 :
	                macKey += ( 0x69 << 8 ) ;
	                break ;
	            case WXK_F14 :
	                macKey += ( 0x6B << 8 ) ;
	                break ;
	            case WXK_F15 :
	                macKey += ( 0x71 << 8 ) ;
	                break ;
	            default :
	                break ;
	        } ;
	        // unfortunately this does not yet trigger the right key ,
	        // for some reason mac justs picks the first function key menu
	        // defined, so we turn this off
	        macKey = 0 ;
	        glyph = 0 ;
  	    }
	    else
    	{
    	    switch( key )
    	    {
    	        case WXK_BACK :
    	            macKey = kBackspaceCharCode ;
    	            glyph = kMenuDeleteLeftGlyph ;
    	            break ;
    	        case WXK_TAB :
    	            macKey = kTabCharCode ;
    	            glyph = kMenuTabRightGlyph ;
    	            break ;
    	        case kEnterCharCode :
    	            macKey = kEnterCharCode ;
    	            glyph = kMenuEnterGlyph ;
    	            break ;
    	        case WXK_RETURN :
    	            macKey = kReturnCharCode ;
    	            glyph = kMenuReturnGlyph ;
    	            break ;
    	        case WXK_ESCAPE :
    	            macKey = kEscapeCharCode ;
    	            glyph = kMenuEscapeGlyph ;
    	            break ;
    	        case WXK_SPACE :
    	            macKey = ' ' ;
    	            glyph = kMenuSpaceGlyph ;
    	            break ;
    	        case WXK_DELETE :
    	            macKey = kDeleteCharCode ;
    	            glyph = kMenuDeleteRightGlyph ;
    	            break ;
    	        case WXK_CLEAR :
    	            macKey = kClearCharCode ;
    	            glyph = kMenuClearGlyph ;
    	            break ;
    	        case WXK_PRIOR : // PAGE UP
    	            macKey = kPageUpCharCode ;
    	            glyph = kMenuPageUpGlyph ;
    	            break ;
    	        case WXK_NEXT :
    	            macKey = kPageDownCharCode ;
    	            glyph = kMenuPageDownGlyph ;
    	            break ;
    	        case WXK_LEFT :
    	            macKey = kLeftArrowCharCode ;
    	            glyph = kMenuLeftArrowGlyph ;
    	            break ;
    	        case WXK_UP :
    	            macKey = kUpArrowCharCode ;
    	            glyph = kMenuUpArrowGlyph ;
    	            break ;
    	        case WXK_RIGHT :
    	            macKey = kRightArrowCharCode ;
    	            glyph = kMenuRightArrowGlyph ;
    	            break ;
    	        case WXK_DOWN :
    	            macKey = kDownArrowCharCode ;
    	            glyph = kMenuDownArrowGlyph ;
    	            break ;
            }
        }

	    SetItemCmd( menu, item , macKey );
	    SetMenuItemModifiers(menu, item , modifiers ) ;

        if ( glyph )
            SetMenuItemKeyGlyph(menu, item , glyph ) ;
	}
}

void UMAAppendMenuItem( MenuRef menu , StringPtr l , SInt16 key, UInt8 modifiers )
{
	MacAppendMenu(menu, "\pA");
	SetMenuItemText(menu, (SInt16) ::CountMenuItems(menu), l);
	UMASetMenuItemShortcut( menu ,  (SInt16) ::CountMenuItems(menu), key , modifiers ) ;
}

void UMAInsertMenuItem( MenuRef menu , StringPtr l , MenuItemIndex item , SInt16 key, UInt8 modifiers )
{
	MacInsertMenuItem( menu , "\p" , item) ;
	SetMenuItemText(menu, item , l);
	UMASetMenuItemShortcut( menu , item , key , modifiers ) ;
}

// quickdraw

int gPrOpenCounter = 0 ;

OSStatus UMAPrOpen(void *macPrintSession)
{
#if !TARGET_CARBON
	OSErr err = noErr ;
	++gPrOpenCounter ;
	if ( gPrOpenCounter == 1 )
	{
		PrOpen() ;
		err = PrError() ;
		wxASSERT( err == noErr ) ;
	}
	return err ;
#else
	OSStatus err = noErr ;
	++gPrOpenCounter ;
	if ( gPrOpenCounter == 1 )
	{
  #if PM_USE_SESSION_APIS
	    err = PMCreateSession((PMPrintSession *)macPrintSession) ;
  #else
	    err = PMBegin() ;
  #endif
		wxASSERT( err == noErr ) ;
	}
	return err ;
#endif
}

OSStatus UMAPrClose(void *macPrintSession)
{
#if !TARGET_CARBON
	OSErr err = noErr ;
	wxASSERT( gPrOpenCounter >= 1 ) ;
	if ( gPrOpenCounter == 1 )
	{
		PrClose() ;
		err = PrError() ;
		wxASSERT( err == noErr ) ;
	}
	--gPrOpenCounter ;
	return err ;
#else
	OSStatus err = noErr ;
	wxASSERT( gPrOpenCounter >= 1 ) ;
	if ( gPrOpenCounter == 1 )
	{
  #if PM_USE_SESSION_APIS
	    err = PMRelease(*(PMPrintSession *)macPrintSession) ;
	    *(PMPrintSession *)macPrintSession = kPMNoReference;
  #else
	    err = PMEnd() ;
  #endif
	}
	--gPrOpenCounter ;
	return err ;
#endif
}

#if !TARGET_CARBON

pascal QDGlobalsPtr GetQDGlobalsPtr (void) ;
pascal QDGlobalsPtr GetQDGlobalsPtr (void)
{
	return QDGlobalsPtr (* (Ptr*) LMGetCurrentA5 ( ) - 0xCA);
}

#endif

void UMAShowWatchCursor()
{
	OSErr err = noErr;

	CursHandle watchFob = GetCursor (watchCursor);

	if (!watchFob)
		err = nilHandleErr;
	else
	{
	#if TARGET_CARBON
//		Cursor preservedArrow;
//		GetQDGlobalsArrow (&preservedArrow);
//		SetQDGlobalsArrow (*watchFob);
//		InitCursor ( );
//		SetQDGlobalsArrow (&preservedArrow);
		SetCursor (*watchFob);
	#else
		SetCursor (*watchFob);
	#endif
	}
}

void			UMAShowArrowCursor()
{
#if TARGET_CARBON
	Cursor arrow;
	SetCursor (GetQDGlobalsArrow (&arrow));
#else
	SetCursor (&(qd.arrow));
#endif
}

// window manager

GrafPtr		UMAGetWindowPort( WindowRef inWindowRef )
{
	wxASSERT( inWindowRef != NULL ) ;
#if TARGET_CARBON
	return (GrafPtr) GetWindowPort( inWindowRef ) ;
#else
	return (GrafPtr) inWindowRef ;
#endif
}

void		 	UMADisposeWindow( WindowRef inWindowRef )
{
	wxASSERT( inWindowRef != NULL ) ;
	DisposeWindow( inWindowRef ) ;
}

void 			UMASetWTitleC( WindowRef inWindowRef , const char *title )
{
	Str255	ptitle ;
	strncpy( (char*)ptitle , title , 96 ) ;
	ptitle[96] = 0 ;
#if TARGET_CARBON
	c2pstrcpy( ptitle, (char *)ptitle ) ;
#else
	c2pstr( (char*)ptitle ) ;
#endif
	SetWTitle( inWindowRef , ptitle ) ;
}

void 			UMAGetWTitleC( WindowRef inWindowRef , char *title )
{
	GetWTitle( inWindowRef , (unsigned char*)title ) ;
#if TARGET_CARBON
	p2cstrcpy( title, (unsigned char *)title ) ;
#else
	p2cstr( (unsigned char*)title ) ;
#endif
}

// appearance additions

void UMAActivateControl( ControlHandle inControl )
{
    // we have to add the control after again to the update rgn
    // otherwise updates get lost
  if ( !IsControlActive( inControl ) )
  {
        bool visible = IsControlVisible( inControl ) ;
        if ( visible )
          SetControlVisibility( inControl , false , false ) ;
        ::ActivateControl( inControl ) ;
        if ( visible ) {
          SetControlVisibility( inControl , true , false ) ;
          Rect ctrlBounds ;
          InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
        }
  }
}

void UMADrawControl( ControlHandle inControl )
{
    WindowRef theWindow = GetControlOwner(inControl) ;
    RgnHandle updateRgn = NewRgn() ;
    GetWindowUpdateRgn( theWindow , updateRgn ) ;
	  Point zero = { 0 , 0 } ;
	  LocalToGlobal( &zero ) ;
	  OffsetRgn( updateRgn , -zero.h , -zero.v ) ;
    ::DrawControlInCurrentPort( inControl ) ;
    InvalWindowRgn( theWindow, updateRgn) ;
	  DisposeRgn( updateRgn ) ;
}

void UMAMoveControl( ControlHandle inControl , short x , short y )
{
  bool visible = IsControlVisible( inControl ) ;
  if ( visible ) {
    SetControlVisibility( inControl , false , false ) ;
    Rect ctrlBounds ;
    InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
  }
  ::MoveControl( inControl , x , y ) ;
  if ( visible ) {
    SetControlVisibility( inControl , true , false ) ;
    Rect ctrlBounds ;
    InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
  }
}

void UMASizeControl( ControlHandle inControl , short x , short y )
{
  bool visible = IsControlVisible( inControl ) ;
  if ( visible ) {
    SetControlVisibility( inControl , false , false ) ;
    Rect ctrlBounds ;
    InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
  }
  ::SizeControl( inControl , x , y ) ;
  if ( visible ) {
    SetControlVisibility( inControl , true , false ) ;
    Rect ctrlBounds ;
    InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
  }
}

void UMADeactivateControl( ControlHandle inControl )
{
    // we have to add the control after again to the update rgn
    // otherwise updates get lost
     bool visible = IsControlVisible( inControl ) ;
     if ( visible )
       SetControlVisibility( inControl , false , false ) ;
     ::DeactivateControl( inControl ) ;
     if ( visible ) {
       SetControlVisibility( inControl , true , false ) ;
       Rect ctrlBounds ;
       InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
     }
}
// shows the control and adds the region to the update region
void UMAShowControl						(ControlHandle 			inControl)
{
        SetControlVisibility( inControl , true , false ) ;
        Rect ctrlBounds ;
        InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
}

// shows the control and adds the region to the update region
void UMAHideControl						(ControlHandle 			inControl)
{
        SetControlVisibility( inControl , false , false ) ;
        Rect ctrlBounds ;
        InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
}
// keyboard focus
OSErr UMASetKeyboardFocus				(WindowPtr 				inWindow,
								 ControlHandle 			inControl,
								 ControlFocusPart 		inPart)
{
	OSErr err = noErr;
	GrafPtr port ;
	GetPort( &port ) ;

	SetPortWindowPort( inWindow ) ;

  err = SetKeyboardFocus( inWindow , inControl , inPart ) ;
	SetPort( port ) ;
	return err ;
}


// events
void UMAUpdateControls( WindowPtr inWindow , RgnHandle inRgn )
{
  RgnHandle updateRgn = NewRgn() ;
  GetWindowUpdateRgn( inWindow , updateRgn ) ;

	Point zero = { 0 , 0 } ;
	LocalToGlobal( &zero ) ;
	OffsetRgn( updateRgn , -zero.h , -zero.v ) ;

  UpdateControls( inWindow , inRgn ) ;
  InvalWindowRgn( inWindow, updateRgn) ;
	DisposeRgn( updateRgn ) ;

}

bool UMAIsWindowFloating( WindowRef inWindow )
{
	WindowClass cl ;

	GetWindowClass( inWindow , &cl ) ;
	return cl == kFloatingWindowClass ;
}

bool UMAIsWindowModal( WindowRef inWindow )
{
	WindowClass cl ;

	GetWindowClass( inWindow , &cl ) ;
	return cl < kFloatingWindowClass ;
}

// others

void UMAHighlightAndActivateWindow( WindowRef inWindowRef , bool inActivate )
{
	if ( inWindowRef )
	{
//		bool isHighlighted = IsWindowHighlited( inWindowRef ) ;
//		if ( inActivate != isHightlited )
		GrafPtr port ;
		GetPort( &port ) ;
		SetPortWindowPort( inWindowRef ) ;
		HiliteWindow( inWindowRef , inActivate ) ;
		ControlHandle control = NULL ;
		::GetRootControl( inWindowRef , & control ) ;
		if ( control )
		{
			if ( inActivate )
				UMAActivateControl( control ) ;
			else
				UMADeactivateControl( control ) ;
		}
		SetPort( port ) ;
	}
}
OSStatus UMADrawThemePlacard( const Rect *inRect , ThemeDrawState inState )
{
  return ::DrawThemePlacard( inRect , inState ) ;
}

#if !TARGET_CARBON
static OSStatus helpMenuStatus = noErr ;
static MenuItemIndex firstCustomItemIndex = 0 ;
#endif

OSStatus UMAGetHelpMenu(
  MenuRef *        outHelpMenu,
  MenuItemIndex *  outFirstCustomItemIndex)
{
#if TARGET_CARBON
  return HMGetHelpMenu( outHelpMenu , outFirstCustomItemIndex ) ;
#else
  MenuRef helpMenuHandle ;
  helpMenuStatus = HMGetHelpMenuHandle( &helpMenuHandle ) ;
  if ( firstCustomItemIndex == 0 && helpMenuStatus == noErr )
  {
    firstCustomItemIndex = CountMenuItems( helpMenuHandle ) + 1 ;
  }
  if ( outFirstCustomItemIndex )
  {
    *outFirstCustomItemIndex = firstCustomItemIndex ;
  }
  *outHelpMenu = helpMenuHandle ;
  return helpMenuStatus ;
#endif
}

wxMacPortStateHelper::wxMacPortStateHelper( GrafPtr newport)
{
  m_clip = NULL ;
  Setup( newport ) ;
}

wxMacPortStateHelper::wxMacPortStateHelper()
{
	m_clip = NULL ;
}

void wxMacPortStateHelper::Setup( GrafPtr newport )
{
	GetPort( &m_oldPort ) ;
	SetPort( newport ) ;
	wxASSERT_MSG( m_clip == NULL , "Cannot call setup twice" ) ;
	m_clip = NewRgn() ;
	GetClip( m_clip );
	m_textFont = GetPortTextFont( (CGrafPtr) newport);
	m_textSize = GetPortTextSize( (CGrafPtr) newport);
	m_textStyle = GetPortTextFace( (CGrafPtr) newport);
	m_textMode = GetPortTextMode( (CGrafPtr) newport);
	GetThemeDrawingState( &m_drawingState ) ;
	m_currentPort = newport ;
}
void wxMacPortStateHelper::Clear()
{
	if ( m_clip )
	{
		DisposeRgn( m_clip ) ;
		DisposeThemeDrawingState( m_drawingState ) ;
		m_clip = NULL ;
	}
}

wxMacPortStateHelper::~wxMacPortStateHelper()
{
	if ( m_clip )
	{
		SetPort( m_currentPort ) ;
		SetClip( m_clip ) ;
		DisposeRgn( m_clip ) ;
		TextFont( m_textFont );
		TextSize( m_textSize );
		TextFace( m_textStyle );
		TextMode( m_textMode );
		SetThemeDrawingState( m_drawingState , true ) ;
		SetPort( m_oldPort ) ;
	}
}
Commit	Line	Data
	1	#include "wx/defs.h"
	2	#include "wx/dc.h"
	3	#include "wx/mac/uma.h"
	4	#include <MacTextEditor.h>
	5
	6	#ifndef __DARWIN__
	7	# include <Navigation.h>
	8	# if defined(TARGET_CARBON)
	9	# if PM_USE_SESSION_APIS
	10	# include <PMCore.h>
	11	# endif
	12	# include <PMApplication.h>
	13	# else
	14	# include <Printing.h>
	15	# endif
	16	#endif
	17
	18	// since we have decided that we only support 8.6 upwards we are
	19	// checking for these minimum requirements in the startup code of
	20	// the application so all wxWindows code can safely assume that appearance 1.1
	21	// windows manager, control manager, navigation services etc. are
	22	// present
	23
	24	static bool sUMAHasAppearance = false ;
	25	static long sUMAAppearanceVersion = 0 ;
	26	static long sUMASystemVersion = 0 ;
	27	static bool sUMAHasAquaLayout = false ;
	28	static bool sUMASystemInitialized = false ;
	29
	30	extern int gAGABackgroundColor ;
	31	bool UMAHasAppearance() { return sUMAHasAppearance ; }
	32	long UMAGetAppearanceVersion() { return sUMAAppearanceVersion ; }
	33	long UMAGetSystemVersion() { return sUMASystemVersion ; }
	34
	35	static bool sUMAHasWindowManager = false ;
	36	static long sUMAWindowManagerAttr = 0 ;
	37
	38	bool UMAHasWindowManager() { return sUMAHasWindowManager ; }
	39	long UMAGetWindowManagerAttr() { return sUMAWindowManagerAttr ; }
	40	bool UMAHasAquaLayout() { return sUMAHasAquaLayout ; }
	41	bool UMASystemIsInitialized() { return sUMASystemInitialized ; }
	42
	43	void UMACleanupToolbox()
	44	{
	45	if ( sUMAHasAppearance )
	46	{
	47	UnregisterAppearanceClient() ;
	48	}
	49	if ( NavServicesAvailable() )
	50	{
	51	NavUnload() ;
	52	}
	53	if ( TXNTerminateTextension != (void*) kUnresolvedCFragSymbolAddress )
	54	TXNTerminateTextension( ) ;
	55	}
	56	void UMAInitToolbox( UInt16 inMoreMastersCalls )
	57	{
	58	#if !TARGET_CARBON
	59	::MaxApplZone();
	60	for (long i = 1; i <= inMoreMastersCalls; i++)
	61	::MoreMasters();
	62
	63	::InitGraf(&qd.thePort);
	64	::InitFonts();
	65	::InitMenus();
	66	::TEInit();
	67	::InitDialogs(0L);
	68	::FlushEvents(everyEvent, 0);
	69	::InitCursor();
	70	long total,contig;
	71	PurgeSpace(&total, &contig);
	72	#else
	73	InitCursor();
	74	#endif
	75
	76	if ( Gestalt(gestaltSystemVersion, &sUMASystemVersion) != noErr)
	77	sUMASystemVersion = 0x0000 ;
	78
	79	long theAppearance ;
	80	if ( Gestalt( gestaltAppearanceAttr, &theAppearance ) == noErr )
	81	{
	82	sUMAHasAppearance = true ;
	83	RegisterAppearanceClient();
	84	if ( Gestalt( gestaltAppearanceVersion, &theAppearance ) == noErr )
	85	{
	86	sUMAAppearanceVersion = theAppearance ;
	87	}
	88	else
	89	{
	90	sUMAAppearanceVersion = 0x0100 ;
	91	}
	92	}
	93	if ( Gestalt( gestaltWindowMgrAttr, &sUMAWindowManagerAttr ) == noErr )
	94	{
	95	sUMAHasWindowManager = sUMAWindowManagerAttr & gestaltWindowMgrPresent ;
	96	}
	97
	98	#if TARGET_CARBON
	99	// Call currently implicitely done : InitFloatingWindows() ;
	100	#else
	101	if ( sUMAHasWindowManager )
	102	InitFloatingWindows() ;
	103	else
	104	InitWindows();
	105	#endif
	106
	107	if ( NavServicesAvailable() )
	108	{
	109	NavLoad() ;
	110	}
	111
	112	long menuMgrAttr ;
	113	Gestalt( gestaltMenuMgrAttr , &menuMgrAttr ) ;
	114	if ( menuMgrAttr & gestaltMenuMgrAquaLayoutMask )
	115	sUMAHasAquaLayout = true ;
	116
	117	if ( TXNInitTextension != (void*) kUnresolvedCFragSymbolAddress )
	118	{
	119	FontFamilyID fontId ;
	120	Str255 fontName ;
	121	SInt16 fontSize ;
	122	Style fontStyle ;
	123	GetThemeFont(kThemeSmallSystemFont , GetApplicationScript() , fontName , &fontSize , &fontStyle ) ;
	124	GetFNum( fontName, &fontId );
	125
	126	TXNMacOSPreferredFontDescription fontDescriptions[] =
	127	{
	128	{ fontId , (fontSize << 16) ,kTXNDefaultFontStyle, kTXNSystemDefaultEncoding } ,
	129	} ;
	130	int noOfFontDescriptions = sizeof( fontDescriptions ) / sizeof(TXNMacOSPreferredFontDescription) ;
	131	#if 0 // TARGET_CARBON
	132	--noOfFontDescriptions ;
	133	#endif
	134	// kTXNAlwaysUseQuickDrawTextMask might be desirable because of speed increases but it crashes the app under OS X upon key stroke
	135	OptionBits options = kTXNWantMoviesMask \| kTXNWantSoundMask \| kTXNWantGraphicsMask ;
	136	#if TARGET_CARBON
	137	if ( !UMAHasAquaLayout() )
	138	#endif
	139	{
	140	options \|= kTXNAlwaysUseQuickDrawTextMask ;
	141	}
	142	TXNInitTextension(fontDescriptions, noOfFontDescriptions, options );
	143	}
	144
	145
	146	sUMASystemInitialized = true ;
	147
	148	}
	149
	150	/*
	151	Boolean CanUseATSUI()
	152	{
	153	long result;
	154	OSErr err = Gestalt(gestaltATSUVersion, &result);
	155	return (err == noErr);
	156	}
	157	*/
	158	// process manager
	159	long UMAGetProcessMode()
	160	{
	161	OSErr err ;
	162	ProcessInfoRec processinfo;
	163	ProcessSerialNumber procno ;
	164
	165	procno.highLongOfPSN = NULL ;
	166	procno.lowLongOfPSN = kCurrentProcess ;
	167	processinfo.processInfoLength = sizeof(ProcessInfoRec);
	168	processinfo.processName = NULL;
	169	processinfo.processAppSpec = NULL;
	170
	171	err = ::GetProcessInformation( &procno , &processinfo ) ;
	172	wxASSERT( err == noErr ) ;
	173	return processinfo.processMode ;
	174	}
	175
	176	bool UMAGetProcessModeDoesActivateOnFGSwitch()
	177	{
	178	return UMAGetProcessMode() & modeDoesActivateOnFGSwitch ;
	179	}
	180
	181	// menu manager
	182
	183	void UMASetMenuTitle( MenuRef menu , StringPtr title )
	184	{
	185	/*
	186	#if !TARGET_CARBON
	187	long size = GetHandleSize( (Handle) menu ) ;
	188	const long headersize = 14 ;
	189	int oldlen = (**menu).menuData[0] + 1;
	190	int newlen = title[0] + 1 ;
	191
	192	if ( oldlen < newlen )
	193	{
	194	// enlarge before adjusting
	195	SetHandleSize( (Handle) menu , size + (newlen - oldlen ) );
	196	}
	197
	198	if ( oldlen != newlen )
	199	memmove( (char) (menu).menuData + newlen , (char) (**menu).menuData + oldlen , size - headersize - oldlen ) ;
	200
	201	memcpy( (char) (*menu).menuData , title , newlen ) ;
	202	if ( oldlen > newlen )
	203	{
	204	// shrink after
	205	SetHandleSize( (Handle) menu , size + (newlen - oldlen ) ) ;
	206	}
	207	#else
	208	*/
	209	SetMenuTitle( menu , title ) ;
	210	//#endif
	211	}
	212
	213	UInt32 UMAMenuEvent( EventRecord *inEvent )
	214	{
	215	return MenuEvent( inEvent ) ;
	216	}
	217
	218	void UMAEnableMenuItem( MenuRef inMenu , MenuItemIndex inItem )
	219	{
	220	EnableMenuItem( inMenu , inItem ) ;
	221	}
	222
	223	void UMADisableMenuItem( MenuRef inMenu , MenuItemIndex inItem )
	224	{
	225	DisableMenuItem( inMenu , inItem ) ;
	226	}
	227
	228	void UMAAppendSubMenuItem( MenuRef menu , StringPtr l , SInt16 id )
	229	{
	230	MacAppendMenu(menu, l);
	231	SetMenuItemHierarchicalID( menu , CountMenuItems( menu ) , id ) ;
	232	}
	233
	234	void UMAInsertSubMenuItem( MenuRef menu , StringPtr l , MenuItemIndex item , SInt16 id )
	235	{
	236	MacInsertMenuItem(menu, l , item);
	237	SetMenuItemHierarchicalID( menu , item , id ) ;
	238	}
	239
	240	void UMASetMenuItemShortcut( MenuRef menu , MenuItemIndex item , SInt16 key , UInt8 modifiers )
	241	{
	242	if ( key )
	243	{
	244	SInt16 glyph = 0 ;
	245	SInt16 macKey = key ;
	246	if ( key >= WXK_F1 && key <= WXK_F15 )
	247	{
	248	macKey = kFunctionKeyCharCode ;
	249	glyph = kMenuF1Glyph + ( key - WXK_F1 ) ;
	250	if ( key >= WXK_F13 )
	251	glyph += 13 ;
	252	switch( key )
	253	{
	254	case WXK_F1 :
	255	macKey += ( 0x7a << 8 ) ;
	256	break ;
	257	case WXK_F2 :
	258	macKey += ( 0x78 << 8 ) ;
	259	break ;
	260	case WXK_F3 :
	261	macKey += ( 0x63 << 8 ) ;
	262	break ;
	263	case WXK_F4 :
	264	macKey += ( 0x76 << 8 ) ;
	265	break ;
	266	case WXK_F5 :
	267	macKey += ( 0x60 << 8 ) ;
	268	break ;
	269	case WXK_F6 :
	270	macKey += ( 0x61 << 8 ) ;
	271	break ;
	272	case WXK_F7 :
	273	macKey += ( 0x62 << 8 ) ;
	274	break ;
	275	case WXK_F8 :
	276	macKey += ( 0x64 << 8 ) ;
	277	break ;
	278	case WXK_F9 :
	279	macKey += ( 0x65 << 8 ) ;
	280	break ;
	281	case WXK_F10 :
	282	macKey += ( 0x6D << 8 ) ;
	283	break ;
	284	case WXK_F11 :
	285	macKey += ( 0x67 << 8 ) ;
	286	break ;
	287	case WXK_F12 :
	288	macKey += ( 0x6F << 8 ) ;
	289	break ;
	290	case WXK_F13 :
	291	macKey += ( 0x69 << 8 ) ;
	292	break ;
	293	case WXK_F14 :
	294	macKey += ( 0x6B << 8 ) ;
	295	break ;
	296	case WXK_F15 :
	297	macKey += ( 0x71 << 8 ) ;
	298	break ;
	299	default :
	300	break ;
	301	} ;
	302	// unfortunately this does not yet trigger the right key ,
	303	// for some reason mac justs picks the first function key menu
	304	// defined, so we turn this off
	305	macKey = 0 ;
	306	glyph = 0 ;
	307	}
	308	else
	309	{
	310	switch( key )
	311	{
	312	case WXK_BACK :
	313	macKey = kBackspaceCharCode ;
	314	glyph = kMenuDeleteLeftGlyph ;
	315	break ;
	316	case WXK_TAB :
	317	macKey = kTabCharCode ;
	318	glyph = kMenuTabRightGlyph ;
	319	break ;
	320	case kEnterCharCode :
	321	macKey = kEnterCharCode ;
	322	glyph = kMenuEnterGlyph ;
	323	break ;
	324	case WXK_RETURN :
	325	macKey = kReturnCharCode ;
	326	glyph = kMenuReturnGlyph ;
	327	break ;
	328	case WXK_ESCAPE :
	329	macKey = kEscapeCharCode ;
	330	glyph = kMenuEscapeGlyph ;
	331	break ;
	332	case WXK_SPACE :
	333	macKey = ' ' ;
	334	glyph = kMenuSpaceGlyph ;
	335	break ;
	336	case WXK_DELETE :
	337	macKey = kDeleteCharCode ;
	338	glyph = kMenuDeleteRightGlyph ;
	339	break ;
	340	case WXK_CLEAR :
	341	macKey = kClearCharCode ;
	342	glyph = kMenuClearGlyph ;
	343	break ;
	344	case WXK_PRIOR : // PAGE UP
	345	macKey = kPageUpCharCode ;
	346	glyph = kMenuPageUpGlyph ;
	347	break ;
	348	case WXK_NEXT :
	349	macKey = kPageDownCharCode ;
	350	glyph = kMenuPageDownGlyph ;
	351	break ;
	352	case WXK_LEFT :
	353	macKey = kLeftArrowCharCode ;
	354	glyph = kMenuLeftArrowGlyph ;
	355	break ;
	356	case WXK_UP :
	357	macKey = kUpArrowCharCode ;
	358	glyph = kMenuUpArrowGlyph ;
	359	break ;
	360	case WXK_RIGHT :
	361	macKey = kRightArrowCharCode ;
	362	glyph = kMenuRightArrowGlyph ;
	363	break ;
	364	case WXK_DOWN :
	365	macKey = kDownArrowCharCode ;
	366	glyph = kMenuDownArrowGlyph ;
	367	break ;
	368	}
	369	}
	370
	371	SetItemCmd( menu, item , macKey );
	372	SetMenuItemModifiers(menu, item , modifiers ) ;
	373
	374	if ( glyph )
	375	SetMenuItemKeyGlyph(menu, item , glyph ) ;
	376	}
	377	}
	378
	379	void UMAAppendMenuItem( MenuRef menu , StringPtr l , SInt16 key, UInt8 modifiers )
	380	{
	381	MacAppendMenu(menu, "\pA");
	382	SetMenuItemText(menu, (SInt16) ::CountMenuItems(menu), l);
	383	UMASetMenuItemShortcut( menu , (SInt16) ::CountMenuItems(menu), key , modifiers ) ;
	384	}
	385
	386	void UMAInsertMenuItem( MenuRef menu , StringPtr l , MenuItemIndex item , SInt16 key, UInt8 modifiers )
	387	{
	388	MacInsertMenuItem( menu , "\p" , item) ;
	389	SetMenuItemText(menu, item , l);
	390	UMASetMenuItemShortcut( menu , item , key , modifiers ) ;
	391	}
	392
	393	// quickdraw
	394
	395	int gPrOpenCounter = 0 ;
	396
	397	OSStatus UMAPrOpen(void *macPrintSession)
	398	{
	399	#if !TARGET_CARBON
	400	OSErr err = noErr ;
	401	++gPrOpenCounter ;
	402	if ( gPrOpenCounter == 1 )
	403	{
	404	PrOpen() ;
	405	err = PrError() ;
	406	wxASSERT( err == noErr ) ;
	407	}
	408	return err ;
	409	#else
	410	OSStatus err = noErr ;
	411	++gPrOpenCounter ;
	412	if ( gPrOpenCounter == 1 )
	413	{
	414	#if PM_USE_SESSION_APIS
	415	err = PMCreateSession((PMPrintSession *)macPrintSession) ;
	416	#else
	417	err = PMBegin() ;
	418	#endif
	419	wxASSERT( err == noErr ) ;
	420	}
	421	return err ;
	422	#endif
	423	}
	424
	425	OSStatus UMAPrClose(void *macPrintSession)
	426	{
	427	#if !TARGET_CARBON
	428	OSErr err = noErr ;
	429	wxASSERT( gPrOpenCounter >= 1 ) ;
	430	if ( gPrOpenCounter == 1 )
	431	{
	432	PrClose() ;
	433	err = PrError() ;
	434	wxASSERT( err == noErr ) ;
	435	}
	436	--gPrOpenCounter ;
	437	return err ;
	438	#else
	439	OSStatus err = noErr ;
	440	wxASSERT( gPrOpenCounter >= 1 ) ;
	441	if ( gPrOpenCounter == 1 )
	442	{
	443	#if PM_USE_SESSION_APIS
	444	err = PMRelease((PMPrintSession )macPrintSession) ;
	445	(PMPrintSession )macPrintSession = kPMNoReference;
	446	#else
	447	err = PMEnd() ;
	448	#endif
	449	}
	450	--gPrOpenCounter ;
	451	return err ;
	452	#endif
	453	}
	454
	455	#if !TARGET_CARBON
	456
	457	pascal QDGlobalsPtr GetQDGlobalsPtr (void) ;
	458	pascal QDGlobalsPtr GetQDGlobalsPtr (void)
	459	{
	460	return QDGlobalsPtr (* (Ptr*) LMGetCurrentA5 ( ) - 0xCA);
	461	}
	462
	463	#endif
	464
	465	void UMAShowWatchCursor()
	466	{
	467	OSErr err = noErr;
	468
	469	CursHandle watchFob = GetCursor (watchCursor);
	470
	471	if (!watchFob)
	472	err = nilHandleErr;
	473	else
	474	{
	475	#if TARGET_CARBON
	476	// Cursor preservedArrow;
	477	// GetQDGlobalsArrow (&preservedArrow);
	478	// SetQDGlobalsArrow (*watchFob);
	479	// InitCursor ( );
	480	// SetQDGlobalsArrow (&preservedArrow);
	481	SetCursor (*watchFob);
	482	#else
	483	SetCursor (*watchFob);
	484	#endif
	485	}
	486	}
	487
	488	void UMAShowArrowCursor()
	489	{
	490	#if TARGET_CARBON
	491	Cursor arrow;
	492	SetCursor (GetQDGlobalsArrow (&arrow));
	493	#else
	494	SetCursor (&(qd.arrow));
	495	#endif
	496	}
	497
	498	// window manager
	499
	500	GrafPtr UMAGetWindowPort( WindowRef inWindowRef )
	501	{
	502	wxASSERT( inWindowRef != NULL ) ;
	503	#if TARGET_CARBON
	504	return (GrafPtr) GetWindowPort( inWindowRef ) ;
	505	#else
	506	return (GrafPtr) inWindowRef ;
	507	#endif
	508	}
	509
	510	void UMADisposeWindow( WindowRef inWindowRef )
	511	{
	512	wxASSERT( inWindowRef != NULL ) ;
	513	DisposeWindow( inWindowRef ) ;
	514	}
	515
	516	void UMASetWTitleC( WindowRef inWindowRef , const char *title )
	517	{
	518	Str255 ptitle ;
	519	strncpy( (char*)ptitle , title , 96 ) ;
	520	ptitle[96] = 0 ;
	521	#if TARGET_CARBON
	522	c2pstrcpy( ptitle, (char *)ptitle ) ;
	523	#else
	524	c2pstr( (char*)ptitle ) ;
	525	#endif
	526	SetWTitle( inWindowRef , ptitle ) ;
	527	}
	528
	529	void UMAGetWTitleC( WindowRef inWindowRef , char *title )
	530	{
	531	GetWTitle( inWindowRef , (unsigned char*)title ) ;
	532	#if TARGET_CARBON
	533	p2cstrcpy( title, (unsigned char *)title ) ;
	534	#else
	535	p2cstr( (unsigned char*)title ) ;
	536	#endif
	537	}
	538
	539	// appearance additions
	540
	541	void UMAActivateControl( ControlHandle inControl )
	542	{
	543	// we have to add the control after again to the update rgn
	544	// otherwise updates get lost
	545	if ( !IsControlActive( inControl ) )
	546	{
	547	bool visible = IsControlVisible( inControl ) ;
	548	if ( visible )
	549	SetControlVisibility( inControl , false , false ) ;
	550	::ActivateControl( inControl ) ;
	551	if ( visible ) {
	552	SetControlVisibility( inControl , true , false ) ;
	553	Rect ctrlBounds ;
	554	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	555	}
	556	}
	557	}
	558
	559	void UMADrawControl( ControlHandle inControl )
	560	{
	561	WindowRef theWindow = GetControlOwner(inControl) ;
	562	RgnHandle updateRgn = NewRgn() ;
	563	GetWindowUpdateRgn( theWindow , updateRgn ) ;
	564	Point zero = { 0 , 0 } ;
	565	LocalToGlobal( &zero ) ;
	566	OffsetRgn( updateRgn , -zero.h , -zero.v ) ;
	567	::DrawControlInCurrentPort( inControl ) ;
	568	InvalWindowRgn( theWindow, updateRgn) ;
	569	DisposeRgn( updateRgn ) ;
	570	}
	571
	572	void UMAMoveControl( ControlHandle inControl , short x , short y )
	573	{
	574	bool visible = IsControlVisible( inControl ) ;
	575	if ( visible ) {
	576	SetControlVisibility( inControl , false , false ) ;
	577	Rect ctrlBounds ;
	578	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	579	}
	580	::MoveControl( inControl , x , y ) ;
	581	if ( visible ) {
	582	SetControlVisibility( inControl , true , false ) ;
	583	Rect ctrlBounds ;
	584	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	585	}
	586	}
	587
	588	void UMASizeControl( ControlHandle inControl , short x , short y )
	589	{
	590	bool visible = IsControlVisible( inControl ) ;
	591	if ( visible ) {
	592	SetControlVisibility( inControl , false , false ) ;
	593	Rect ctrlBounds ;
	594	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	595	}
	596	::SizeControl( inControl , x , y ) ;
	597	if ( visible ) {
	598	SetControlVisibility( inControl , true , false ) ;
	599	Rect ctrlBounds ;
	600	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	601	}
	602	}
	603
	604	void UMADeactivateControl( ControlHandle inControl )
	605	{
	606	// we have to add the control after again to the update rgn
	607	// otherwise updates get lost
	608	bool visible = IsControlVisible( inControl ) ;
	609	if ( visible )
	610	SetControlVisibility( inControl , false , false ) ;
	611	::DeactivateControl( inControl ) ;
	612	if ( visible ) {
	613	SetControlVisibility( inControl , true , false ) ;
	614	Rect ctrlBounds ;
	615	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	616	}
	617	}
	618	// shows the control and adds the region to the update region
	619	void UMAShowControl (ControlHandle inControl)
	620	{
	621	SetControlVisibility( inControl , true , false ) ;
	622	Rect ctrlBounds ;
	623	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	624	}
	625
	626	// shows the control and adds the region to the update region
	627	void UMAHideControl (ControlHandle inControl)
	628	{
	629	SetControlVisibility( inControl , false , false ) ;
	630	Rect ctrlBounds ;
	631	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	632	}
	633	// keyboard focus
	634	OSErr UMASetKeyboardFocus (WindowPtr inWindow,
	635	ControlHandle inControl,
	636	ControlFocusPart inPart)
	637	{
	638	OSErr err = noErr;
	639	GrafPtr port ;
	640	GetPort( &port ) ;
	641
	642	SetPortWindowPort( inWindow ) ;
	643
	644	err = SetKeyboardFocus( inWindow , inControl , inPart ) ;
	645	SetPort( port ) ;
	646	return err ;
	647	}
	648
	649
	650
	651
	652	// events
	653	void UMAUpdateControls( WindowPtr inWindow , RgnHandle inRgn )
	654	{
	655	RgnHandle updateRgn = NewRgn() ;
	656	GetWindowUpdateRgn( inWindow , updateRgn ) ;
	657
	658	Point zero = { 0 , 0 } ;
	659	LocalToGlobal( &zero ) ;
	660	OffsetRgn( updateRgn , -zero.h , -zero.v ) ;
	661
	662	UpdateControls( inWindow , inRgn ) ;
	663	InvalWindowRgn( inWindow, updateRgn) ;
	664	DisposeRgn( updateRgn ) ;
	665
	666	}
	667
	668	bool UMAIsWindowFloating( WindowRef inWindow )
	669	{
	670	WindowClass cl ;
	671
	672	GetWindowClass( inWindow , &cl ) ;
	673	return cl == kFloatingWindowClass ;
	674	}
	675
	676	bool UMAIsWindowModal( WindowRef inWindow )
	677	{
	678	WindowClass cl ;
	679
	680	GetWindowClass( inWindow , &cl ) ;
	681	return cl < kFloatingWindowClass ;
	682	}
	683
	684	// others
	685
	686	void UMAHighlightAndActivateWindow( WindowRef inWindowRef , bool inActivate )
	687	{
	688	if ( inWindowRef )
	689	{
	690	// bool isHighlighted = IsWindowHighlited( inWindowRef ) ;
	691	// if ( inActivate != isHightlited )
	692	GrafPtr port ;
	693	GetPort( &port ) ;
	694	SetPortWindowPort( inWindowRef ) ;
	695	HiliteWindow( inWindowRef , inActivate ) ;
	696	ControlHandle control = NULL ;
	697	::GetRootControl( inWindowRef , & control ) ;
	698	if ( control )
	699	{
	700	if ( inActivate )
	701	UMAActivateControl( control ) ;
	702	else
	703	UMADeactivateControl( control ) ;
	704	}
	705	SetPort( port ) ;
	706	}
	707	}
	708	OSStatus UMADrawThemePlacard( const Rect *inRect , ThemeDrawState inState )
	709	{
	710	return ::DrawThemePlacard( inRect , inState ) ;
	711	}
	712
	713	#if !TARGET_CARBON
	714	static OSStatus helpMenuStatus = noErr ;
	715	static MenuItemIndex firstCustomItemIndex = 0 ;
	716	#endif
	717
	718	OSStatus UMAGetHelpMenu(
	719	MenuRef * outHelpMenu,
	720	MenuItemIndex * outFirstCustomItemIndex)
	721	{
	722	#if TARGET_CARBON
	723	return HMGetHelpMenu( outHelpMenu , outFirstCustomItemIndex ) ;
	724	#else
	725	MenuRef helpMenuHandle ;
	726	helpMenuStatus = HMGetHelpMenuHandle( &helpMenuHandle ) ;
	727	if ( firstCustomItemIndex == 0 && helpMenuStatus == noErr )
	728	{
	729	firstCustomItemIndex = CountMenuItems( helpMenuHandle ) + 1 ;
	730	}
	731	if ( outFirstCustomItemIndex )
	732	{
	733	*outFirstCustomItemIndex = firstCustomItemIndex ;
	734	}
	735	*outHelpMenu = helpMenuHandle ;
	736	return helpMenuStatus ;
	737	#endif
	738	}
	739
	740	wxMacPortStateHelper::wxMacPortStateHelper( GrafPtr newport)
	741	{
	742	m_clip = NULL ;
	743	Setup( newport ) ;
	744	}
	745
	746	wxMacPortStateHelper::wxMacPortStateHelper()
	747	{
	748	m_clip = NULL ;
	749	}
	750
	751	void wxMacPortStateHelper::Setup( GrafPtr newport )
	752	{
	753	GetPort( &m_oldPort ) ;
	754	SetPort( newport ) ;
	755	wxASSERT_MSG( m_clip == NULL , "Cannot call setup twice" ) ;
	756	m_clip = NewRgn() ;
	757	GetClip( m_clip );
	758	m_textFont = GetPortTextFont( (CGrafPtr) newport);
	759	m_textSize = GetPortTextSize( (CGrafPtr) newport);
	760	m_textStyle = GetPortTextFace( (CGrafPtr) newport);
	761	m_textMode = GetPortTextMode( (CGrafPtr) newport);
	762	GetThemeDrawingState( &m_drawingState ) ;
	763	m_currentPort = newport ;
	764	}
	765	void wxMacPortStateHelper::Clear()
	766	{
	767	if ( m_clip )
	768	{
	769	DisposeRgn( m_clip ) ;
	770	DisposeThemeDrawingState( m_drawingState ) ;
	771	m_clip = NULL ;
	772	}
	773	}
	774
	775	wxMacPortStateHelper::~wxMacPortStateHelper()
	776	{
	777	if ( m_clip )
	778	{
	779	SetPort( m_currentPort ) ;
	780	SetClip( m_clip ) ;
	781	DisposeRgn( m_clip ) ;
	782	TextFont( m_textFont );
	783	TextSize( m_textSize );
	784	TextFace( m_textStyle );
	785	TextMode( m_textMode );
	786	SetThemeDrawingState( m_drawingState , true ) ;
	787	SetPort( m_oldPort ) ;
	788	}
	789	}
	790