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

#define wxUSE_MLTE 0


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

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

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 wxUSE_MLTE
	TXNTerminateTextension( ) ;
#endif
}
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

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

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

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

#if wxUSE_MLTE
  TXNMacOSPreferredFontDescription defaults;
  defaults.fontID = kFontIDGeneva ;
  defaults.pointSize = (10 << 16) ;
  defaults.fontStyle = kTXNDefaultFontStyle;
  defaults.encoding = kTXNSystemDefaultEncoding;
	TXNInitTextension(&defaults,  1, (kTXNAlwaysUseQuickDrawTextMask | kTXNWantMoviesMask | kTXNWantSoundMask | kTXNWantGraphicsMask));
#endif
  long menuMgrAttr ;
  Gestalt( gestaltMenuMgrAttr , &menuMgrAttr ) ;
  if ( menuMgrAttr & gestaltMenuMgrAquaLayoutMask )
    sUMAHasAquaLayout = true ;
  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 )
{
	Str255 label ;
	memcpy( label , l , l[0]+1 ) ;
	// hardcoded adding of the submenu combination for mac

	int theEnd = label[0] + 1;
	if (theEnd > 251)
		theEnd = 251; // mac allows only 255 characters
	label[theEnd++] = '/';
	label[theEnd++] = hMenuCmd;
	label[theEnd++] = '!';
	label[theEnd++] = id ;
	label[theEnd] = 0x00;
	label[0] = theEnd;
	MacAppendMenu(menu, label);
}

void UMAInsertSubMenuItem( MenuRef menu , StringPtr l , MenuItemIndex item , SInt16 id  )
{
	Str255 label ;
	memcpy( label , l , l[0]+1 ) ;
	// hardcoded adding of the submenu combination for mac

	int theEnd = label[0] + 1;
	if (theEnd > 251)
		theEnd = 251; // mac allows only 255 characters
	label[theEnd++] = '/';
	label[theEnd++] = hMenuCmd;
	label[theEnd++] = '!';
	label[theEnd++] = id;
	label[theEnd] = 0x00;
	label[0] = theEnd;
	MacInsertMenuItem(menu, label , item);
}

void UMAAppendMenuItem( MenuRef menu , StringPtr l , SInt16 key, UInt8 modifiers )
{
	Str255 label ;
	memcpy( label , l , l[0]+1 ) ;
	if ( key )
	{
			int pos = label[0] ;
			label[++pos] = '/';
			label[++pos] = toupper( key );
			label[0] = pos ;
	}
	MacAppendMenu( menu , label ) ;
}

void UMAInsertMenuItem( MenuRef menu , StringPtr l , MenuItemIndex item , SInt16 key, UInt8 modifiers )
{
	Str255 label ;
	memcpy( label , l , l[0]+1 ) ;
	if ( key )
	{
			int pos = label[0] ;
			label[++pos] = '/';
			label[++pos] = toupper( key );
			label[0] = pos ;
	}
	MacInsertMenuItem( menu , label , item) ;
}

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

static OSStatus helpMenuStatus = noErr ;
static MenuItemIndex firstCustomItemIndex = 0 ;

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	#define wxUSE_MLTE 0
	25
	26
	27	static bool sUMAHasAppearance = false ;
	28	static long sUMAAppearanceVersion = 0 ;
	29	static bool sUMAHasAquaLayout = false ;
	30	static bool sUMASystemInitialized = false ;
	31
	32	extern int gAGABackgroundColor ;
	33	bool UMAHasAppearance() { return sUMAHasAppearance ; }
	34	long UMAGetAppearanceVersion() { return sUMAAppearanceVersion ; }
	35
	36	static bool sUMAHasWindowManager = false ;
	37	static long sUMAWindowManagerAttr = 0 ;
	38
	39	bool UMAHasWindowManager() { return sUMAHasWindowManager ; }
	40	long UMAGetWindowManagerAttr() { return sUMAWindowManagerAttr ; }
	41	bool UMAHasAquaLayout() { return sUMAHasAquaLayout ; }
	42	bool UMASystemIsInitialized() { return sUMASystemInitialized ; }
	43
	44	void UMACleanupToolbox()
	45	{
	46	if ( sUMAHasAppearance )
	47	{
	48	UnregisterAppearanceClient() ;
	49	}
	50	if ( NavServicesAvailable() )
	51	{
	52	NavUnload() ;
	53	}
	54	#if wxUSE_MLTE
	55	TXNTerminateTextension( ) ;
	56	#endif
	57	}
	58	void UMAInitToolbox( UInt16 inMoreMastersCalls )
	59	{
	60	#if !TARGET_CARBON
	61	::MaxApplZone();
	62	for (long i = 1; i <= inMoreMastersCalls; i++)
	63	::MoreMasters();
	64
	65	::InitGraf(&qd.thePort);
	66	::InitFonts();
	67	::InitMenus();
	68	::TEInit();
	69	::InitDialogs(0L);
	70	::FlushEvents(everyEvent, 0);
	71	::InitCursor();
	72	long total,contig;
	73	PurgeSpace(&total, &contig);
	74	#else
	75	InitCursor();
	76	#endif
	77
	78	long theAppearance ;
	79	if ( Gestalt( gestaltAppearanceAttr, &theAppearance ) == noErr )
	80	{
	81	sUMAHasAppearance = true ;
	82	RegisterAppearanceClient();
	83	if ( Gestalt( gestaltAppearanceVersion, &theAppearance ) == noErr )
	84	{
	85	sUMAAppearanceVersion = theAppearance ;
	86	}
	87	else
	88	{
	89	sUMAAppearanceVersion = 0x0100 ;
	90	}
	91	}
	92	if ( Gestalt( gestaltWindowMgrAttr, &sUMAWindowManagerAttr ) == noErr )
	93	{
	94	sUMAHasWindowManager = sUMAWindowManagerAttr & gestaltWindowMgrPresent ;
	95	}
	96
	97	#ifndef __DARWIN__
	98	#if TARGET_CARBON
	99	// Call currently implicitely done : InitFloatingWindows() ;
	100	#else
	101	if ( sUMAHasWindowManager )
	102	InitFloatingWindows() ;
	103	else
	104	InitWindows();
	105	#endif
	106	#endif
	107
	108	if ( NavServicesAvailable() )
	109	{
	110	NavLoad() ;
	111	}
	112
	113	#if wxUSE_MLTE
	114	TXNMacOSPreferredFontDescription defaults;
	115	defaults.fontID = kFontIDGeneva ;
	116	defaults.pointSize = (10 << 16) ;
	117	defaults.fontStyle = kTXNDefaultFontStyle;
	118	defaults.encoding = kTXNSystemDefaultEncoding;
	119	TXNInitTextension(&defaults, 1, (kTXNAlwaysUseQuickDrawTextMask \| kTXNWantMoviesMask \| kTXNWantSoundMask \| kTXNWantGraphicsMask));
	120	#endif
	121	long menuMgrAttr ;
	122	Gestalt( gestaltMenuMgrAttr , &menuMgrAttr ) ;
	123	if ( menuMgrAttr & gestaltMenuMgrAquaLayoutMask )
	124	sUMAHasAquaLayout = true ;
	125	sUMASystemInitialized = true ;
	126
	127	}
	128
	129	/*
	130	Boolean CanUseATSUI()
	131	{
	132	long result;
	133	OSErr err = Gestalt(gestaltATSUVersion, &result);
	134	return (err == noErr);
	135	}
	136	*/
	137	// process manager
	138	long UMAGetProcessMode()
	139	{
	140	OSErr err ;
	141	ProcessInfoRec processinfo;
	142	ProcessSerialNumber procno ;
	143
	144	procno.highLongOfPSN = NULL ;
	145	procno.lowLongOfPSN = kCurrentProcess ;
	146	processinfo.processInfoLength = sizeof(ProcessInfoRec);
	147	processinfo.processName = NULL;
	148	processinfo.processAppSpec = NULL;
	149
	150	err = ::GetProcessInformation( &procno , &processinfo ) ;
	151	wxASSERT( err == noErr ) ;
	152	return processinfo.processMode ;
	153	}
	154
	155	bool UMAGetProcessModeDoesActivateOnFGSwitch()
	156	{
	157	return UMAGetProcessMode() & modeDoesActivateOnFGSwitch ;
	158	}
	159
	160	// menu manager
	161
	162	void UMASetMenuTitle( MenuRef menu , StringPtr title )
	163	{
	164	/*
	165	#if !TARGET_CARBON
	166	long size = GetHandleSize( (Handle) menu ) ;
	167	const long headersize = 14 ;
	168	int oldlen = (**menu).menuData[0] + 1;
	169	int newlen = title[0] + 1 ;
	170
	171	if ( oldlen < newlen )
	172	{
	173	// enlarge before adjusting
	174	SetHandleSize( (Handle) menu , size + (newlen - oldlen ) );
	175	}
	176
	177	if ( oldlen != newlen )
	178	memmove( (char) (menu).menuData + newlen , (char) (**menu).menuData + oldlen , size - headersize - oldlen ) ;
	179
	180	memcpy( (char) (*menu).menuData , title , newlen ) ;
	181	if ( oldlen > newlen )
	182	{
	183	// shrink after
	184	SetHandleSize( (Handle) menu , size + (newlen - oldlen ) ) ;
	185	}
	186	#else
	187	*/
	188	SetMenuTitle( menu , title ) ;
	189	//#endif
	190	}
	191
	192	UInt32 UMAMenuEvent( EventRecord *inEvent )
	193	{
	194	return MenuEvent( inEvent ) ;
	195	}
	196
	197	void UMAEnableMenuItem( MenuRef inMenu , MenuItemIndex inItem )
	198	{
	199	EnableMenuItem( inMenu , inItem ) ;
	200	}
	201
	202	void UMADisableMenuItem( MenuRef inMenu , MenuItemIndex inItem )
	203	{
	204	DisableMenuItem( inMenu , inItem ) ;
	205	}
	206
	207	void UMAAppendSubMenuItem( MenuRef menu , StringPtr l , SInt16 id )
	208	{
	209	Str255 label ;
	210	memcpy( label , l , l[0]+1 ) ;
	211	// hardcoded adding of the submenu combination for mac
	212
	213	int theEnd = label[0] + 1;
	214	if (theEnd > 251)
	215	theEnd = 251; // mac allows only 255 characters
	216	label[theEnd++] = '/';
	217	label[theEnd++] = hMenuCmd;
	218	label[theEnd++] = '!';
	219	label[theEnd++] = id ;
	220	label[theEnd] = 0x00;
	221	label[0] = theEnd;
	222	MacAppendMenu(menu, label);
	223	}
	224
	225	void UMAInsertSubMenuItem( MenuRef menu , StringPtr l , MenuItemIndex item , SInt16 id )
	226	{
	227	Str255 label ;
	228	memcpy( label , l , l[0]+1 ) ;
	229	// hardcoded adding of the submenu combination for mac
	230
	231	int theEnd = label[0] + 1;
	232	if (theEnd > 251)
	233	theEnd = 251; // mac allows only 255 characters
	234	label[theEnd++] = '/';
	235	label[theEnd++] = hMenuCmd;
	236	label[theEnd++] = '!';
	237	label[theEnd++] = id;
	238	label[theEnd] = 0x00;
	239	label[0] = theEnd;
	240	MacInsertMenuItem(menu, label , item);
	241	}
	242
	243	void UMAAppendMenuItem( MenuRef menu , StringPtr l , SInt16 key, UInt8 modifiers )
	244	{
	245	Str255 label ;
	246	memcpy( label , l , l[0]+1 ) ;
	247	if ( key )
	248	{
	249	int pos = label[0] ;
	250	label[++pos] = '/';
	251	label[++pos] = toupper( key );
	252	label[0] = pos ;
	253	}
	254	MacAppendMenu( menu , label ) ;
	255	}
	256
	257	void UMAInsertMenuItem( MenuRef menu , StringPtr l , MenuItemIndex item , SInt16 key, UInt8 modifiers )
	258	{
	259	Str255 label ;
	260	memcpy( label , l , l[0]+1 ) ;
	261	if ( key )
	262	{
	263	int pos = label[0] ;
	264	label[++pos] = '/';
	265	label[++pos] = toupper( key );
	266	label[0] = pos ;
	267	}
	268	MacInsertMenuItem( menu , label , item) ;
	269	}
	270
	271	// quickdraw
	272
	273	int gPrOpenCounter = 0 ;
	274
	275	OSStatus UMAPrOpen(void *macPrintSession)
	276	{
	277	#if !TARGET_CARBON
	278	OSErr err = noErr ;
	279	++gPrOpenCounter ;
	280	if ( gPrOpenCounter == 1 )
	281	{
	282	PrOpen() ;
	283	err = PrError() ;
	284	wxASSERT( err == noErr ) ;
	285	}
	286	return err ;
	287	#else
	288	OSStatus err = noErr ;
	289	++gPrOpenCounter ;
	290	if ( gPrOpenCounter == 1 )
	291	{
	292	#if PM_USE_SESSION_APIS
	293	err = PMCreateSession((PMPrintSession *)macPrintSession) ;
	294	#else
	295	err = PMBegin() ;
	296	#endif
	297	wxASSERT( err == noErr ) ;
	298	}
	299	return err ;
	300	#endif
	301	}
	302
	303	OSStatus UMAPrClose(void *macPrintSession)
	304	{
	305	#if !TARGET_CARBON
	306	OSErr err = noErr ;
	307	wxASSERT( gPrOpenCounter >= 1 ) ;
	308	if ( gPrOpenCounter == 1 )
	309	{
	310	PrClose() ;
	311	err = PrError() ;
	312	wxASSERT( err == noErr ) ;
	313	}
	314	--gPrOpenCounter ;
	315	return err ;
	316	#else
	317	OSStatus err = noErr ;
	318	wxASSERT( gPrOpenCounter >= 1 ) ;
	319	if ( gPrOpenCounter == 1 )
	320	{
	321	#if PM_USE_SESSION_APIS
	322	err = PMRelease((PMPrintSession )macPrintSession) ;
	323	(PMPrintSession )macPrintSession = kPMNoReference;
	324	#else
	325	err = PMEnd() ;
	326	#endif
	327	}
	328	--gPrOpenCounter ;
	329	return err ;
	330	#endif
	331	}
	332
	333	#if !TARGET_CARBON
	334
	335	pascal QDGlobalsPtr GetQDGlobalsPtr (void) ;
	336	pascal QDGlobalsPtr GetQDGlobalsPtr (void)
	337	{
	338	return QDGlobalsPtr (* (Ptr*) LMGetCurrentA5 ( ) - 0xCA);
	339	}
	340
	341	#endif
	342
	343	void UMAShowWatchCursor()
	344	{
	345	OSErr err = noErr;
	346
	347	CursHandle watchFob = GetCursor (watchCursor);
	348
	349	if (!watchFob)
	350	err = nilHandleErr;
	351	else
	352	{
	353	#if TARGET_CARBON
	354	// Cursor preservedArrow;
	355	// GetQDGlobalsArrow (&preservedArrow);
	356	// SetQDGlobalsArrow (*watchFob);
	357	// InitCursor ( );
	358	// SetQDGlobalsArrow (&preservedArrow);
	359	SetCursor (*watchFob);
	360	#else
	361	SetCursor (*watchFob);
	362	#endif
	363	}
	364	}
	365
	366	void UMAShowArrowCursor()
	367	{
	368	#if TARGET_CARBON
	369	Cursor arrow;
	370	SetCursor (GetQDGlobalsArrow (&arrow));
	371	#else
	372	SetCursor (&(qd.arrow));
	373	#endif
	374	}
	375
	376	// window manager
	377
	378	GrafPtr UMAGetWindowPort( WindowRef inWindowRef )
	379	{
	380	wxASSERT( inWindowRef != NULL ) ;
	381	#if TARGET_CARBON
	382	return (GrafPtr) GetWindowPort( inWindowRef ) ;
	383	#else
	384	return (GrafPtr) inWindowRef ;
	385	#endif
	386	}
	387
	388	void UMADisposeWindow( WindowRef inWindowRef )
	389	{
	390	wxASSERT( inWindowRef != NULL ) ;
	391	DisposeWindow( inWindowRef ) ;
	392	}
	393
	394	void UMASetWTitleC( WindowRef inWindowRef , const char *title )
	395	{
	396	Str255 ptitle ;
	397	strncpy( (char*)ptitle , title , 96 ) ;
	398	ptitle[96] = 0 ;
	399	#if TARGET_CARBON
	400	c2pstrcpy( ptitle, (char *)ptitle ) ;
	401	#else
	402	c2pstr( (char*)ptitle ) ;
	403	#endif
	404	SetWTitle( inWindowRef , ptitle ) ;
	405	}
	406
	407	void UMAGetWTitleC( WindowRef inWindowRef , char *title )
	408	{
	409	GetWTitle( inWindowRef , (unsigned char*)title ) ;
	410	#if TARGET_CARBON
	411	p2cstrcpy( title, (unsigned char *)title ) ;
	412	#else
	413	p2cstr( (unsigned char*)title ) ;
	414	#endif
	415	}
	416
	417	// appearance additions
	418
	419	void UMAActivateControl( ControlHandle inControl )
	420	{
	421	// we have to add the control after again to the update rgn
	422	// otherwise updates get lost
	423	if ( !IsControlActive( inControl ) )
	424	{
	425	bool visible = IsControlVisible( inControl ) ;
	426	if ( visible )
	427	SetControlVisibility( inControl , false , false ) ;
	428	::ActivateControl( inControl ) ;
	429	if ( visible ) {
	430	SetControlVisibility( inControl , true , false ) ;
	431	Rect ctrlBounds ;
	432	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	433	}
	434	}
	435	}
	436
	437	void UMADrawControl( ControlHandle inControl )
	438	{
	439	WindowRef theWindow = GetControlOwner(inControl) ;
	440	RgnHandle updateRgn = NewRgn() ;
	441	GetWindowUpdateRgn( theWindow , updateRgn ) ;
	442	Point zero = { 0 , 0 } ;
	443	LocalToGlobal( &zero ) ;
	444	OffsetRgn( updateRgn , -zero.h , -zero.v ) ;
	445	::DrawControlInCurrentPort( inControl ) ;
	446	InvalWindowRgn( theWindow, updateRgn) ;
	447	DisposeRgn( updateRgn ) ;
	448	}
	449
	450	void UMAMoveControl( ControlHandle inControl , short x , short y )
	451	{
	452	bool visible = IsControlVisible( inControl ) ;
	453	if ( visible ) {
	454	SetControlVisibility( inControl , false , false ) ;
	455	Rect ctrlBounds ;
	456	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	457	}
	458	::MoveControl( inControl , x , y ) ;
	459	if ( visible ) {
	460	SetControlVisibility( inControl , true , false ) ;
	461	Rect ctrlBounds ;
	462	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	463	}
	464	}
	465
	466	void UMASizeControl( ControlHandle inControl , short x , short y )
	467	{
	468	bool visible = IsControlVisible( inControl ) ;
	469	if ( visible ) {
	470	SetControlVisibility( inControl , false , false ) ;
	471	Rect ctrlBounds ;
	472	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	473	}
	474	::SizeControl( inControl , x , y ) ;
	475	if ( visible ) {
	476	SetControlVisibility( inControl , true , false ) ;
	477	Rect ctrlBounds ;
	478	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	479	}
	480	}
	481
	482	void UMADeactivateControl( ControlHandle inControl )
	483	{
	484	// we have to add the control after again to the update rgn
	485	// otherwise updates get lost
	486	bool visible = IsControlVisible( inControl ) ;
	487	if ( visible )
	488	SetControlVisibility( inControl , false , false ) ;
	489	::DeactivateControl( inControl ) ;
	490	if ( visible ) {
	491	SetControlVisibility( inControl , true , false ) ;
	492	Rect ctrlBounds ;
	493	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	494	}
	495	}
	496	// shows the control and adds the region to the update region
	497	void UMAShowControl (ControlHandle inControl)
	498	{
	499	SetControlVisibility( inControl , true , false ) ;
	500	Rect ctrlBounds ;
	501	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	502	}
	503
	504	// shows the control and adds the region to the update region
	505	void UMAHideControl (ControlHandle inControl)
	506	{
	507	SetControlVisibility( inControl , false , false ) ;
	508	Rect ctrlBounds ;
	509	InvalWindowRect(GetControlOwner(inControl),GetControlBounds(inControl,&ctrlBounds) ) ;
	510	}
	511	// keyboard focus
	512	OSErr UMASetKeyboardFocus (WindowPtr inWindow,
	513	ControlHandle inControl,
	514	ControlFocusPart inPart)
	515	{
	516	OSErr err = noErr;
	517	GrafPtr port ;
	518	GetPort( &port ) ;
	519
	520	SetPortWindowPort( inWindow ) ;
	521
	522	err = SetKeyboardFocus( inWindow , inControl , inPart ) ;
	523	SetPort( port ) ;
	524	return err ;
	525	}
	526
	527
	528
	529
	530	// events
	531	void UMAUpdateControls( WindowPtr inWindow , RgnHandle inRgn )
	532	{
	533	RgnHandle updateRgn = NewRgn() ;
	534	GetWindowUpdateRgn( inWindow , updateRgn ) ;
	535
	536	Point zero = { 0 , 0 } ;
	537	LocalToGlobal( &zero ) ;
	538	OffsetRgn( updateRgn , -zero.h , -zero.v ) ;
	539
	540	UpdateControls( inWindow , inRgn ) ;
	541	InvalWindowRgn( inWindow, updateRgn) ;
	542	DisposeRgn( updateRgn ) ;
	543
	544	}
	545
	546	bool UMAIsWindowFloating( WindowRef inWindow )
	547	{
	548	WindowClass cl ;
	549
	550	GetWindowClass( inWindow , &cl ) ;
	551	return cl == kFloatingWindowClass ;
	552	}
	553
	554	bool UMAIsWindowModal( WindowRef inWindow )
	555	{
	556	WindowClass cl ;
	557
	558	GetWindowClass( inWindow , &cl ) ;
	559	return cl < kFloatingWindowClass ;
	560	}
	561
	562	// others
	563
	564	void UMAHighlightAndActivateWindow( WindowRef inWindowRef , bool inActivate )
	565	{
	566	if ( inWindowRef )
	567	{
	568	// bool isHighlighted = IsWindowHighlited( inWindowRef ) ;
	569	// if ( inActivate != isHightlited )
	570	GrafPtr port ;
	571	GetPort( &port ) ;
	572	SetPortWindowPort( inWindowRef ) ;
	573	HiliteWindow( inWindowRef , inActivate ) ;
	574	ControlHandle control = NULL ;
	575	::GetRootControl( inWindowRef , & control ) ;
	576	if ( control )
	577	{
	578	if ( inActivate )
	579	UMAActivateControl( control ) ;
	580	else
	581	UMADeactivateControl( control ) ;
	582	}
	583	SetPort( port ) ;
	584	}
	585	}
	586	OSStatus UMADrawThemePlacard( const Rect *inRect , ThemeDrawState inState )
	587	{
	588	return ::DrawThemePlacard( inRect , inState ) ;
	589	}
	590
	591	static OSStatus helpMenuStatus = noErr ;
	592	static MenuItemIndex firstCustomItemIndex = 0 ;
	593
	594	OSStatus UMAGetHelpMenu(
	595	MenuRef * outHelpMenu,
	596	MenuItemIndex * outFirstCustomItemIndex)
	597	{
	598	#if TARGET_CARBON
	599	return HMGetHelpMenu( outHelpMenu , outFirstCustomItemIndex ) ;
	600	#else
	601	MenuRef helpMenuHandle ;
	602	helpMenuStatus = HMGetHelpMenuHandle( &helpMenuHandle ) ;
	603	if ( firstCustomItemIndex == 0 && helpMenuStatus == noErr )
	604	{
	605	firstCustomItemIndex = CountMenuItems( helpMenuHandle ) + 1 ;
	606	}
	607	if ( outFirstCustomItemIndex )
	608	{
	609	*outFirstCustomItemIndex = firstCustomItemIndex ;
	610	}
	611	*outHelpMenu = helpMenuHandle ;
	612	return helpMenuStatus ;
	613	#endif
	614	}
	615
	616	wxMacPortStateHelper::wxMacPortStateHelper( GrafPtr newport)
	617	{
	618	m_clip = NULL ;
	619	Setup( newport ) ;
	620	}
	621
	622	wxMacPortStateHelper::wxMacPortStateHelper()
	623	{
	624	m_clip = NULL ;
	625	}
	626
	627	void wxMacPortStateHelper::Setup( GrafPtr newport )
	628	{
	629	GetPort( &m_oldPort ) ;
	630	SetPort( newport ) ;
	631	wxASSERT_MSG( m_clip == NULL , "Cannot call setup twice" ) ;
	632	m_clip = NewRgn() ;
	633	GetClip( m_clip );
	634	m_textFont = GetPortTextFont( (CGrafPtr) newport);
	635	m_textSize = GetPortTextSize( (CGrafPtr) newport);
	636	m_textStyle = GetPortTextFace( (CGrafPtr) newport);
	637	m_textMode = GetPortTextMode( (CGrafPtr) newport);
	638	GetThemeDrawingState( &m_drawingState ) ;
	639	m_currentPort = newport ;
	640	}
	641	void wxMacPortStateHelper::Clear()
	642	{
	643	if ( m_clip )
	644	{
	645	DisposeRgn( m_clip ) ;
	646	DisposeThemeDrawingState( m_drawingState ) ;
	647	m_clip = NULL ;
	648	}
	649	}
	650
	651	wxMacPortStateHelper::~wxMacPortStateHelper()
	652	{
	653	if ( m_clip )
	654	{
	655	SetPort( m_currentPort ) ;
	656	SetClip( m_clip ) ;
	657	DisposeRgn( m_clip ) ;
	658	TextFont( m_textFont );
	659	TextSize( m_textSize );
	660	TextFace( m_textStyle );
	661	TextMode( m_textMode );
	662	SetThemeDrawingState( m_drawingState , true ) ;
	663	SetPort( m_oldPort ) ;
	664	}
	665	}
	666