src/mac/uma.cpp

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

#ifndef __DARWIN__
  #include <Navigation.h>
#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 ;
}

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

#if TARGET_CARBON && PM_USE_SESSION_APIS
OSStatus UMAPrOpen(PMPrintSession *macPrintSession)
#else
OSStatus UMAPrOpen()
#endif
{
#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(macPrintSession) ;
  #else
	    err = PMBegin() ;
  #endif
		wxASSERT( err == noErr ) ;
	}
	return err ;
#endif
}

#if TARGET_CARBON && PM_USE_SESSION_APIS
OSStatus UMAPrClose(PMPrintSession *macPrintSession)
#else
OSStatus UMAPrClose()
#endif
{
#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(*macPrintSession) ;
	    *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 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 MenuRef helpMenuHandle = NULL ;
static MenuItemIndex firstCustomItemIndex = 0 ;

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