[wxWidgets.git] / 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 ;
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 ; }


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 ;

}

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