src/mac/uma.cpp

#include <wx/mac/uma.h>
#include <wx/mac/aga.h>

// init

static bool	sUMAHasAppearance = false ;
static long sUMAAppearanceVersion = 0 ;
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 ; }

void UMAInitToolbox( UInt16 inMoreMastersCalls )
{
#if !TARGET_CARBON
	::MaxApplZone();
	for (long i = 1; i <= inMoreMastersCalls; i++)
		::MoreMasters();

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

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

// 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 , ConstStr255Param 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 )
{
	if ( UMAHasAppearance() )
	{
		return MenuEvent( inEvent ) ;
	}
	else
	{
			if ( inEvent->what == keyDown && inEvent->modifiers & cmdKey)
			{
				return MenuKey( inEvent->message & charCodeMask ) ;
			}
		return NULL ;
	}
}

void 			UMAEnableMenuItem( MenuRef inMenu , MenuItemIndex inItem )
{
#if UMA_USE_8_6
	EnableMenuItem( inMenu , inItem ) ;
#else
	EnableItem( inMenu , inItem ) ;
#endif
}

void 			UMADisableMenuItem( MenuRef inMenu , MenuItemIndex inItem )
{
#if UMA_USE_8_6
	DisableMenuItem( inMenu , inItem ) ;
#else
	DisableItem( inMenu , inItem ) ;
#endif
}
// quickdraw

#if !TARGET_CARBON

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);
	#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 ;
	c2pstr( (char*)ptitle ) ;
	SetWTitle( inWindowRef , ptitle ) ;
}
void 			UMAGetWTitleC( WindowRef inWindowRef , char *title )
{
	GetWTitle( inWindowRef , (unsigned char*)title ) ;
	p2cstr( (unsigned char*)title ) ;
}

void			UMAShowWindow( WindowRef inWindowRef )
{
	ShowWindow( inWindowRef ) ;
}

void			UMAHideWindow( WindowRef inWindowRef )
{
	HideWindow( inWindowRef) ;
}

void 			UMASelectWindow( WindowRef inWindowRef )
{
	SelectWindow( inWindowRef ) ;
}

void			UMABringToFront( WindowRef inWindowRef )
{
	BringToFront( inWindowRef ) ;
}

void			UMASendBehind( WindowRef inWindowRef , WindowRef behindWindow )
{
	SendBehind( inWindowRef , behindWindow ) ;
}

void			UMACloseWindow(WindowRef inWindowRef)
{
#if TARGET_CARBON
#else
	CloseWindow( inWindowRef ) ;
#endif
}

// appearance additions

void UMAActivateControl( ControlHandle inControl )
{
	if ( UMAHasAppearance() )
	{
   	::ActivateControl( inControl ) ;
   }
   else
   {
   	AGAActivateControl( inControl ) ;
   }
}

void UMADrawControl( ControlHandle inControl )
{
	if ( UMAHasAppearance() )
	{
   	::DrawControlInCurrentPort( inControl ) ;
   }
   else
   {
   	AGADrawControl( inControl ) ;
   }
}

void UMAMoveControl( ControlHandle inControl , short x , short y )
{
	if ( UMAHasAppearance() )
	{
	  	::MoveControl( inControl , x , y ) ;
   }
   else
   {
   	AGAMoveControl( inControl , x ,y  ) ;
   }
}

void UMASizeControl( ControlHandle inControl , short x , short y )
{
	if ( UMAHasAppearance() )
	{
	  	::SizeControl( inControl , x , y ) ;
   }
   else
   {
   	AGASizeControl( inControl , x ,y  ) ;
   }
}

void UMADeactivateControl( ControlHandle inControl )
{
	if ( UMAHasAppearance() )
	{
   	::DeactivateControl( inControl ) ;
   }
   else
   {
   	 AGADeactivateControl( inControl ) ;
   }
}

void			UMASetThemeWindowBackground		(WindowRef 				inWindow,
								 ThemeBrush 			inBrush,
								 Boolean 				inUpdate){
	if ( UMAHasAppearance() )
	{
   	::SetThemeWindowBackground( inWindow ,inBrush , inUpdate ) ;
   }
   else
   {
   	AGASetThemeWindowBackground( inWindow , inBrush , inUpdate ) ;
   }
}


ControlHandle UMANewControl(WindowPtr 				owningWindow,
								 const Rect *			boundsRect,
								 ConstStr255Param 		controlTitle,
								 Boolean 				initiallyVisible,
								 SInt16 				initialValue,
								 SInt16 				minimumValue,
								 SInt16 				maximumValue,
								 SInt16 				procID,
								 SInt32 				controlReference)
{
	ControlHandle theControl = NULL ;
	if ( UMAHasAppearance() )
	{
   theControl =  NewControl( owningWindow , boundsRect , controlTitle , initiallyVisible ,
   		initialValue , minimumValue , maximumValue , procID , controlReference ) ;
	}
	else
	{
		theControl = AGANewControl( owningWindow , boundsRect , controlTitle , initiallyVisible ,
   		initialValue , minimumValue , maximumValue , procID , controlReference ) ;
	}
	return theControl ;
}

void UMADisposeControl (ControlHandle 			theControl)
{
	if ( UMAHasAppearance() )
	{
   	::DisposeControl( theControl ) ;
   }
   else
   {
   	::DisposeControl( theControl ) ;
   }
}


void UMAHiliteControl	(ControlHandle 			theControl,
								 ControlPartCode 		hiliteState)
								 {
	if ( UMAHasAppearance() )
	{
   	::HiliteControl( theControl , hiliteState ) ;
   }
   else
   {
   	::HiliteControl( theControl , hiliteState ) ;
	}
}


void UMAShowControl						(ControlHandle 			theControl)
{
	if ( UMAHasAppearance() )
	{
   	::ShowControl( theControl ) ;
   }
   else
   {
   	::ShowControl( theControl ) ;
   }
}


void UMAHideControl						(ControlHandle 			theControl)
{
	if ( UMAHasAppearance() )
	{
   	::HideControl( theControl ) ;
   }
   else
   {
   	::HideControl( theControl ) ;
   }
}


void UMASetControlVisibility			(ControlHandle 			inControl,
								 Boolean 				inIsVisible,
								 Boolean 				inDoDraw)
								 {
	if ( UMAHasAppearance() )
	{
   	::SetControlVisibility( inControl , inIsVisible, inDoDraw ) ;
   }
}


bool UMAIsControlActive					(ControlHandle 			inControl)
{
	if ( UMAHasAppearance() )
	{
   	return IsControlActive( inControl ) ;
   }
  else
  	return (**inControl).contrlHilite == 0 ;
}


bool UMAIsControlVisible				(ControlHandle 			inControl)
{
	if ( UMAHasAppearance() )
	{
   	return IsControlVisible( inControl ) ;
   }
  	return true ;
}

OSErr UMAGetBestControlRect				(ControlHandle 			inControl,
								 Rect *					outRect,
								 SInt16 *				outBaseLineOffset)
{
	if ( UMAHasAppearance() )
	{
   	return GetBestControlRect( inControl , outRect , outBaseLineOffset ) ;
   }
  else
  {
  	return AGAGetBestControlRect( inControl , outRect , outBaseLineOffset ) ;
  }
}


OSErr UMASetControlFontStyle				(ControlHandle 			inControl,
								 const ControlFontStyleRec * inStyle)
{
	if ( UMAHasAppearance() )
	{
		return ::SetControlFontStyle( inControl , inStyle ) ;
	}
	else
		return AGASetControlFontStyle( inControl , inStyle ) ;
}


// control hierarchy

OSErr UMACreateRootControl				(WindowPtr 				inWindow,
								 ControlHandle *		outControl)
{
	if ( UMAHasAppearance() )
	{
   	return CreateRootControl( inWindow , outControl  ) ;
   }
  else
  	return AGACreateRootControl( inWindow , outControl ) ;
}


OSErr UMAEmbedControl					(ControlHandle 			inControl,
								 ControlHandle 			inContainer)
{
	if ( UMAHasAppearance() )
	{
   	return EmbedControl( inControl , inContainer ) ;
   }
  else
  	return AGAEmbedControl( inControl , inContainer ) ; ;
}


// keyboard focus
OSErr UMASetKeyboardFocus				(WindowPtr 				inWindow,
								 ControlHandle 			inControl,
								 ControlFocusPart 		inPart)
{
	if ( UMAHasAppearance() )
	{
   	return SetKeyboardFocus( inWindow , inControl , inPart ) ;
   }
  else
  	return AGASetKeyboardFocus( inWindow , inControl , inPart ) ;
}


// events

ControlPartCode UMAHandleControlClick				(ControlHandle 			inControl,
								 Point 					inWhere,
								 SInt16 				inModifiers,
								 ControlActionUPP 		inAction)
{
	if ( UMAHasAppearance() )
	{
   	return HandleControlClick( inControl , inWhere , inModifiers , inAction ) ;
   }
   else
   {
   	return AGAHandleControlClick( inControl , inWhere , inModifiers , inAction ) ;
   }
}


SInt16 UMAHandleControlKey				(ControlHandle 			inControl,
								 SInt16 				inKeyCode,
								 SInt16 				inCharCode,
								 SInt16 				inModifiers)
{
	if ( UMAHasAppearance() )
	{
   	return HandleControlKey( inControl , inKeyCode , inCharCode , inModifiers ) ;
   }
   else
   {
   	return AGAHandleControlKey(inControl , inKeyCode , inCharCode , inModifiers ) ;
   }
}


void UMAIdleControls					(WindowPtr 				inWindow)
{
	if ( UMAHasAppearance() )
	{
   		IdleControls( inWindow ) ;
   }
   else
   {
   		AGAIdleControls( inWindow ) ;
   }
}

void UMAUpdateControls( WindowPtr inWindow , RgnHandle inRgn )
{
	if ( UMAHasAppearance() )
	{
		UpdateControls( inWindow , inRgn ) ;
	}
	else
	{
		AGAUpdateControls( inWindow , inRgn ) ;
	}
}

OSErr UMAGetRootControl( WindowPtr inWindow , ControlHandle *outControl )
{
	if ( UMAHasAppearance() )
	{
		return GetRootControl( inWindow , outControl ) ;
	}
	else
	{
		return AGAGetRootControl( inWindow , outControl ) ;
	}
}


// handling control data

OSErr UMASetControlData					(ControlHandle 			inControl,
								 ControlPartCode 		inPart,
								 ResType 				inTagName,
								 Size 					inSize,
								 Ptr 					inData)
{
	if ( UMAHasAppearance() )
	{
   	 return SetControlData( inControl , inPart , inTagName , inSize , inData ) ;
   }
   else
		return AGASetControlData( inControl , inPart , inTagName , inSize , inData ) ;
}


OSErr UMAGetControlData					(ControlHandle 			inControl,
								 ControlPartCode 		inPart,
								 ResType 				inTagName,
								 Size 					inBufferSize,
								 Ptr 					outBuffer,
								 Size *					outActualSize)
{
	if ( UMAHasAppearance() )
	{
		return ::GetControlData( inControl , inPart , inTagName , inBufferSize , outBuffer , outActualSize ) ;
	}
	else
	{
		return AGAGetControlData( inControl , inPart , inTagName , inBufferSize , outBuffer , outActualSize ) ;
	}

}


OSErr UMAGetControlDataSize				(ControlHandle 			inControl,
								 ControlPartCode 		inPart,
								 ResType 				inTagName,
								 Size *					outMaxSize)
{
	if ( UMAHasAppearance() )
	{
		return GetControlDataSize( inControl , inPart , inTagName , outMaxSize ) ;
	}
	else
	{
		return AGAGetControlDataSize( inControl , inPart , inTagName , outMaxSize ) ;
	}
}


// system 8.0 changes

short UMAFindWindow( Point inPoint , WindowRef *outWindow )
{
	// todo add the additional area codes
	return FindWindow( inPoint , outWindow ) ;
}

OSStatus UMAGetWindowFeatures( WindowRef inWindowRef , UInt32 *outFeatures )
{
#if UMA_USE_WINDOWMGR
	return GetWindowFeatures( inWindowRef , outFeatures ) ;
#else
	return 0 ;
#endif
}

OSStatus UMAGetWindowRegion( WindowRef inWindowRef , WindowRegionCode inRegionCode , RgnHandle ioWinRgn )
{
#if UMA_USE_WINDOWMGR
	return GetWindowRegion( inWindowRef , inRegionCode , ioWinRgn ) ;
#else
	return 0 ;
#endif
}

void UMADrawGrowIcon( WindowRef inWindowRef )
{
	DrawGrowIcon( inWindowRef ) ;
}

OSStatus UMACollapseWindow( WindowRef inWindowRef , Boolean inCollapseIt )
{
	return CollapseWindow( inWindowRef , inCollapseIt ) ;
}

OSStatus UMACollapseAllWindows( Boolean inCollapseEm )
{
	return CollapseAllWindows( inCollapseEm ) ;
}

Boolean UMAIsWindowCollapsed( WindowRef inWindowRef )
{
	return IsWindowCollapsed( inWindowRef ) ;
}

Boolean UMAIsWindowCollapsable( WindowRef inWindowRef )
{
	return IsWindowCollapsable( inWindowRef ) ;
}

// system 8.5 changes<MacWindows.h>
OSStatus 	UMACreateNewWindow( WindowClass windowClass , WindowAttributes attributes , const Rect *bounds,  WindowRef *outWindow )
{
#if UMA_USE_WINDOWMGR
	if ( UMAHasWindowManager() )
	{
		return CreateNewWindow( windowClass , attributes, bounds, outWindow ) ;
	}
	else
#endif
	{
		short procID ;
		if ( UMAHasAppearance() )
		{
			switch( windowClass )
			{
				case kMovableModalWindowClass :
					procID = kWindowMovableModalDialogProc;
					break ;
				case kDocumentWindowClass :
					procID = kWindowFullZoomGrowDocumentProc;
					break ;
				default :
					procID = kWindowMovableModalDialogProc;
					break ;
			}
		}
		else
		{
			switch( windowClass )
			{
				case kMovableModalWindowClass :
					procID = movableDBoxProc;
//					procID += kMovableModalDialogVariantCode;
					break ;
				case kDocumentWindowClass :
					procID = zoomDocProc;
					break ;
				default :
					procID = documentProc;
					break ;
			}
		}
		*outWindow = NewCWindow(nil, bounds, "\p", false, procID,  (WindowRef) -1 /*behind*/,
				attributes & kWindowCloseBoxAttribute , (long)NULL);
		return noErr ;
	}
}

OSStatus 	UMAGetWindowClass( WindowRef inWindowRef , WindowClass *outWindowClass )
{
#if UMA_USE_WINDOWMGR
	if ( UMAHasWindowManager() )
	{
		return GetWindowClass( inWindowRef , outWindowClass ) ;
	}
	else
#endif
		return kDocumentWindowClass ;
}

OSStatus	UMAGetWindowAttributes( WindowRef inWindowRef , WindowAttributes *outAttributes )
{
#if UMA_USE_WINDOWMGR
	if ( UMAHasWindowManager() )
	{
		return GetWindowAttributes( inWindowRef , outAttributes ) ;
	}
#endif
	return kWindowNoAttributes ;
}

void UMAShowFloatingWindows()
{
#if UMA_USE_WINDOWMGR
	if ( UMAHasWindowManager() )
	{
		ShowFloatingWindows() ;
	}
#endif
}

void UMAHideFloatingWindows()
{
#if UMA_USE_WINDOWMGR
	if ( UMAHasWindowManager() )
	{
		HideFloatingWindows() ;
	}
#endif
}

Boolean 	UMAAreFloatingWindowsVisible()
{
#if UMA_USE_WINDOWMGR
	if ( UMAHasWindowManager() )
	{
		return AreFloatingWindowsVisible() ;
	}
#endif
	return false ;
}

WindowRef UMAFrontNonFloatingWindow()
{
#if UMA_USE_WINDOWMGR
	if ( UMAHasWindowManager() )
	{
		return FrontNonFloatingWindow() ;
	}
	else
#endif
	{
		return FrontWindow() ;
	}
}

WindowRef UMAFrontWindow()
{
#if UMA_USE_WINDOWMGR
	if ( UMAHasWindowManager() )
	{
		return FrontWindow() ;
	}
	else
#endif
	{
		return FrontWindow() ;
	}
}

WindowRef UMAGetActiveNonFloatingWindow()
{
	return NULL ;
}

bool UMAIsWindowFloating( WindowRef inWindow )
{
	WindowClass cl ;

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

bool UMAIsWindowModal( WindowRef inWindow )
{
	WindowClass cl ;

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

// others

void UMAHighlightAndActivateWindow( WindowRef inWindowRef , bool inActivate )
{
	if ( inWindowRef )
	{
//		bool isHighlighted = IsWindowHighlited( inWindowRef ) ;
//		if ( inActivate != isHightlited )
				HiliteWindow( inWindowRef , inActivate ) ;
	}
}
Commit	Line	Data
	1	#include <wx/mac/uma.h>
	2	#include <wx/mac/aga.h>
	3
	4	// init
	5
	6	static bool sUMAHasAppearance = false ;
	7	static long sUMAAppearanceVersion = 0 ;
	8	extern int gAGABackgroundColor ;
	9	bool UMAHasAppearance() { return sUMAHasAppearance ; }
	10	long UMAGetAppearanceVersion() { return sUMAAppearanceVersion ; }
	11
	12	static bool sUMAHasWindowManager = false ;
	13	static long sUMAWindowManagerAttr = 0 ;
	14
	15	bool UMAHasWindowManager() { return sUMAHasWindowManager ; }
	16	long UMAGetWindowManagerAttr() { return sUMAWindowManagerAttr ; }
	17
	18	void UMAInitToolbox( UInt16 inMoreMastersCalls )
	19	{
	20	#if !TARGET_CARBON
	21	::MaxApplZone();
	22	for (long i = 1; i <= inMoreMastersCalls; i++)
	23	::MoreMasters();
	24
	25	::InitGraf(&qd.thePort);
	26	::InitFonts();
	27	::InitWindows();
	28	::InitMenus();
	29	::TEInit();
	30	::InitDialogs(0L);
	31	::FlushEvents(everyEvent, 0);
	32	::InitCursor();
	33	long total,contig;
	34	PurgeSpace(&total, &contig);
	35	#else
	36	InitMenus() ;
	37	#endif
	38
	39	#if UMA_USE_APPEARANCE
	40	long theAppearance ;
	41	if ( Gestalt( gestaltAppearanceAttr, &theAppearance ) == noErr )
	42	{
	43	sUMAHasAppearance = true ;
	44	RegisterAppearanceClient();
	45	if ( Gestalt( gestaltAppearanceVersion, &theAppearance ) == noErr )
	46	{
	47	sUMAAppearanceVersion = theAppearance ;
	48	}
	49	else
	50	{
	51	sUMAAppearanceVersion = 0x0100 ;
	52	}
	53	}
	54	#endif // UMA_USE_APPEARANCE
	55	#if UMA_USE_8_6
	56	#if UMA_USE_WINDOWMGR
	57	if ( Gestalt( gestaltWindowMgrAttr, &sUMAWindowManagerAttr ) == noErr )
	58	{
	59	sUMAHasWindowManager = sUMAWindowManagerAttr & gestaltWindowMgrPresent ;
	60	}
	61	#endif // UMA_USE_WINDOWMGR
	62	#endif
	63	}
	64
	65	// process manager
	66	long UMAGetProcessMode()
	67	{
	68	OSErr err ;
	69	ProcessInfoRec processinfo;
	70	ProcessSerialNumber procno ;
	71
	72	procno.highLongOfPSN = NULL ;
	73	procno.lowLongOfPSN = kCurrentProcess ;
	74	processinfo.processInfoLength = sizeof(ProcessInfoRec);
	75	processinfo.processName = NULL;
	76	processinfo.processAppSpec = NULL;
	77
	78	err = ::GetProcessInformation( &procno , &processinfo ) ;
	79	wxASSERT( err == noErr ) ;
	80	return processinfo.processMode ;
	81	}
	82
	83	bool UMAGetProcessModeDoesActivateOnFGSwitch()
	84	{
	85	return UMAGetProcessMode() & modeDoesActivateOnFGSwitch ;
	86	}
	87
	88	// menu manager
	89
	90	void UMASetMenuTitle( MenuRef menu , ConstStr255Param title )
	91	{
	92	#if !TARGET_CARBON
	93	long size = GetHandleSize( (Handle) menu ) ;
	94	const long headersize = 14 ;
	95	int oldlen = (**menu).menuData[0] + 1;
	96	int newlen = title[0] + 1 ;
	97
	98	if ( oldlen < newlen )
	99	{
	100	// enlarge before adjusting
	101	SetHandleSize( (Handle) menu , size + (newlen - oldlen ) );
	102	}
	103
	104	if ( oldlen != newlen )
	105	memmove( (char) (menu).menuData + newlen , (char) (**menu).menuData + oldlen , size - headersize - oldlen ) ;
	106
	107	memcpy( (char) (*menu).menuData , title , newlen ) ;
	108	if ( oldlen > newlen )
	109	{
	110	// shrink after
	111	SetHandleSize( (Handle) menu , size + (newlen - oldlen ) ) ;
	112	}
	113	#else
	114	SetMenuTitle( menu , title ) ;
	115	#endif
	116	}
	117
	118	UInt32 UMAMenuEvent( EventRecord *inEvent )
	119	{
	120	if ( UMAHasAppearance() )
	121	{
	122	return MenuEvent( inEvent ) ;
	123	}
	124	else
	125	{
	126	if ( inEvent->what == keyDown && inEvent->modifiers & cmdKey)
	127	{
	128	return MenuKey( inEvent->message & charCodeMask ) ;
	129	}
	130	return NULL ;
	131	}
	132	}
	133
	134	void UMAEnableMenuItem( MenuRef inMenu , MenuItemIndex inItem )
	135	{
	136	#if UMA_USE_8_6
	137	EnableMenuItem( inMenu , inItem ) ;
	138	#else
	139	EnableItem( inMenu , inItem ) ;
	140	#endif
	141	}
	142
	143	void UMADisableMenuItem( MenuRef inMenu , MenuItemIndex inItem )
	144	{
	145	#if UMA_USE_8_6
	146	DisableMenuItem( inMenu , inItem ) ;
	147	#else
	148	DisableItem( inMenu , inItem ) ;
	149	#endif
	150	}
	151	// quickdraw
	152
	153	#if !TARGET_CARBON
	154
	155	pascal QDGlobalsPtr GetQDGlobalsPtr (void)
	156	{
	157	return QDGlobalsPtr (* (Ptr*) LMGetCurrentA5 ( ) - 0xCA);
	158	}
	159
	160	#endif
	161
	162	void UMAShowWatchCursor()
	163	{
	164	OSErr err = noErr;
	165
	166	CursHandle watchFob = GetCursor (watchCursor);
	167
	168	if (!watchFob)
	169	err = nilHandleErr;
	170	else
	171	{
	172	#if TARGET_CARBON
	173	Cursor preservedArrow;
	174	GetQDGlobalsArrow (&preservedArrow);
	175	SetQDGlobalsArrow (*watchFob);
	176	InitCursor ( );
	177	SetQDGlobalsArrow (&preservedArrow);
	178	#else
	179	SetCursor (*watchFob);
	180	#endif
	181	}
	182	}
	183
	184	void UMAShowArrowCursor()
	185	{
	186	#if TARGET_CARBON
	187	Cursor arrow;
	188	SetCursor (GetQDGlobalsArrow (&arrow));
	189	#else
	190	SetCursor (&(qd.arrow));
	191	#endif
	192	}
	193
	194	// window manager
	195
	196	GrafPtr UMAGetWindowPort( WindowRef inWindowRef )
	197	{
	198	wxASSERT( inWindowRef != NULL ) ;
	199	#if TARGET_CARBON
	200	return GetWindowPort( inWindowRef ) ;
	201	#else
	202	return (GrafPtr) inWindowRef ;
	203	#endif
	204	}
	205
	206	void UMADisposeWindow( WindowRef inWindowRef )
	207	{
	208	wxASSERT( inWindowRef != NULL ) ;
	209	DisposeWindow( inWindowRef ) ;
	210	}
	211
	212	void UMASetWTitleC( WindowRef inWindowRef , const char *title )
	213	{
	214	Str255 ptitle ;
	215	strncpy( (char*)ptitle , title , 96 ) ;
	216	ptitle[96] = 0 ;
	217	c2pstr( (char*)ptitle ) ;
	218	SetWTitle( inWindowRef , ptitle ) ;
	219	}
	220	void UMAGetWTitleC( WindowRef inWindowRef , char *title )
	221	{
	222	GetWTitle( inWindowRef , (unsigned char*)title ) ;
	223	p2cstr( (unsigned char*)title ) ;
	224	}
	225
	226	void UMAShowWindow( WindowRef inWindowRef )
	227	{
	228	ShowWindow( inWindowRef ) ;
	229	}
	230
	231	void UMAHideWindow( WindowRef inWindowRef )
	232	{
	233	HideWindow( inWindowRef) ;
	234	}
	235
	236	void UMASelectWindow( WindowRef inWindowRef )
	237	{
	238	SelectWindow( inWindowRef ) ;
	239	}
	240
	241	void UMABringToFront( WindowRef inWindowRef )
	242	{
	243	BringToFront( inWindowRef ) ;
	244	}
	245
	246	void UMASendBehind( WindowRef inWindowRef , WindowRef behindWindow )
	247	{
	248	SendBehind( inWindowRef , behindWindow ) ;
	249	}
	250
	251	void UMACloseWindow(WindowRef inWindowRef)
	252	{
	253	#if TARGET_CARBON
	254	#else
	255	CloseWindow( inWindowRef ) ;
	256	#endif
	257	}
	258
	259	// appearance additions
	260
	261	void UMAActivateControl( ControlHandle inControl )
	262	{
	263	if ( UMAHasAppearance() )
	264	{
	265	::ActivateControl( inControl ) ;
	266	}
	267	else
	268	{
	269	AGAActivateControl( inControl ) ;
	270	}
	271	}
	272
	273	void UMADrawControl( ControlHandle inControl )
	274	{
	275	if ( UMAHasAppearance() )
	276	{
	277	::DrawControlInCurrentPort( inControl ) ;
	278	}
	279	else
	280	{
	281	AGADrawControl( inControl ) ;
	282	}
	283	}
	284
	285	void UMAMoveControl( ControlHandle inControl , short x , short y )
	286	{
	287	if ( UMAHasAppearance() )
	288	{
	289	::MoveControl( inControl , x , y ) ;
	290	}
	291	else
	292	{
	293	AGAMoveControl( inControl , x ,y ) ;
	294	}
	295	}
	296
	297	void UMASizeControl( ControlHandle inControl , short x , short y )
	298	{
	299	if ( UMAHasAppearance() )
	300	{
	301	::SizeControl( inControl , x , y ) ;
	302	}
	303	else
	304	{
	305	AGASizeControl( inControl , x ,y ) ;
	306	}
	307	}
	308
	309	void UMADeactivateControl( ControlHandle inControl )
	310	{
	311	if ( UMAHasAppearance() )
	312	{
	313	::DeactivateControl( inControl ) ;
	314	}
	315	else
	316	{
	317	AGADeactivateControl( inControl ) ;
	318	}
	319	}
	320
	321	void UMASetThemeWindowBackground (WindowRef inWindow,
	322	ThemeBrush inBrush,
	323	Boolean inUpdate){
	324	if ( UMAHasAppearance() )
	325	{
	326	::SetThemeWindowBackground( inWindow ,inBrush , inUpdate ) ;
	327	}
	328	else
	329	{
	330	AGASetThemeWindowBackground( inWindow , inBrush , inUpdate ) ;
	331	}
	332	}
	333
	334
	335	ControlHandle UMANewControl(WindowPtr owningWindow,
	336	const Rect * boundsRect,
	337	ConstStr255Param controlTitle,
	338	Boolean initiallyVisible,
	339	SInt16 initialValue,
	340	SInt16 minimumValue,
	341	SInt16 maximumValue,
	342	SInt16 procID,
	343	SInt32 controlReference)
	344	{
	345	ControlHandle theControl = NULL ;
	346	if ( UMAHasAppearance() )
	347	{
	348	theControl = NewControl( owningWindow , boundsRect , controlTitle , initiallyVisible ,
	349	initialValue , minimumValue , maximumValue , procID , controlReference ) ;
	350	}
	351	else
	352	{
	353	theControl = AGANewControl( owningWindow , boundsRect , controlTitle , initiallyVisible ,
	354	initialValue , minimumValue , maximumValue , procID , controlReference ) ;
	355	}
	356	return theControl ;
	357	}
	358
	359	void UMADisposeControl (ControlHandle theControl)
	360	{
	361	if ( UMAHasAppearance() )
	362	{
	363	::DisposeControl( theControl ) ;
	364	}
	365	else
	366	{
	367	::DisposeControl( theControl ) ;
	368	}
	369	}
	370
	371
	372	void UMAHiliteControl (ControlHandle theControl,
	373	ControlPartCode hiliteState)
	374	{
	375	if ( UMAHasAppearance() )
	376	{
	377	::HiliteControl( theControl , hiliteState ) ;
	378	}
	379	else
	380	{
	381	::HiliteControl( theControl , hiliteState ) ;
	382	}
	383	}
	384
	385
	386	void UMAShowControl (ControlHandle theControl)
	387	{
	388	if ( UMAHasAppearance() )
	389	{
	390	::ShowControl( theControl ) ;
	391	}
	392	else
	393	{
	394	::ShowControl( theControl ) ;
	395	}
	396	}
	397
	398
	399	void UMAHideControl (ControlHandle theControl)
	400	{
	401	if ( UMAHasAppearance() )
	402	{
	403	::HideControl( theControl ) ;
	404	}
	405	else
	406	{
	407	::HideControl( theControl ) ;
	408	}
	409	}
	410
	411
	412	void UMASetControlVisibility (ControlHandle inControl,
	413	Boolean inIsVisible,
	414	Boolean inDoDraw)
	415	{
	416	if ( UMAHasAppearance() )
	417	{
	418	::SetControlVisibility( inControl , inIsVisible, inDoDraw ) ;
	419	}
	420	}
	421
	422
	423
	424	bool UMAIsControlActive (ControlHandle inControl)
	425	{
	426	if ( UMAHasAppearance() )
	427	{
	428	return IsControlActive( inControl ) ;
	429	}
	430	else
	431	return (**inControl).contrlHilite == 0 ;
	432	}
	433
	434
	435	bool UMAIsControlVisible (ControlHandle inControl)
	436	{
	437	if ( UMAHasAppearance() )
	438	{
	439	return IsControlVisible( inControl ) ;
	440	}
	441	return true ;
	442	}
	443
	444	OSErr UMAGetBestControlRect (ControlHandle inControl,
	445	Rect * outRect,
	446	SInt16 * outBaseLineOffset)
	447	{
	448	if ( UMAHasAppearance() )
	449	{
	450	return GetBestControlRect( inControl , outRect , outBaseLineOffset ) ;
	451	}
	452	else
	453	{
	454	return AGAGetBestControlRect( inControl , outRect , outBaseLineOffset ) ;
	455	}
	456	}
	457
	458
	459	OSErr UMASetControlFontStyle (ControlHandle inControl,
	460	const ControlFontStyleRec * inStyle)
	461	{
	462	if ( UMAHasAppearance() )
	463	{
	464	return ::SetControlFontStyle( inControl , inStyle ) ;
	465	}
	466	else
	467	return AGASetControlFontStyle( inControl , inStyle ) ;
	468	}
	469
	470
	471
	472	// control hierarchy
	473
	474	OSErr UMACreateRootControl (WindowPtr inWindow,
	475	ControlHandle * outControl)
	476	{
	477	if ( UMAHasAppearance() )
	478	{
	479	return CreateRootControl( inWindow , outControl ) ;
	480	}
	481	else
	482	return AGACreateRootControl( inWindow , outControl ) ;
	483	}
	484
	485
	486
	487	OSErr UMAEmbedControl (ControlHandle inControl,
	488	ControlHandle inContainer)
	489	{
	490	if ( UMAHasAppearance() )
	491	{
	492	return EmbedControl( inControl , inContainer ) ;
	493	}
	494	else
	495	return AGAEmbedControl( inControl , inContainer ) ; ;
	496	}
	497
	498
	499
	500	// keyboard focus
	501	OSErr UMASetKeyboardFocus (WindowPtr inWindow,
	502	ControlHandle inControl,
	503	ControlFocusPart inPart)
	504	{
	505	if ( UMAHasAppearance() )
	506	{
	507	return SetKeyboardFocus( inWindow , inControl , inPart ) ;
	508	}
	509	else
	510	return AGASetKeyboardFocus( inWindow , inControl , inPart ) ;
	511	}
	512
	513
	514
	515
	516	// events
	517
	518	ControlPartCode UMAHandleControlClick (ControlHandle inControl,
	519	Point inWhere,
	520	SInt16 inModifiers,
	521	ControlActionUPP inAction)
	522	{
	523	if ( UMAHasAppearance() )
	524	{
	525	return HandleControlClick( inControl , inWhere , inModifiers , inAction ) ;
	526	}
	527	else
	528	{
	529	return AGAHandleControlClick( inControl , inWhere , inModifiers , inAction ) ;
	530	}
	531	}
	532
	533
	534	SInt16 UMAHandleControlKey (ControlHandle inControl,
	535	SInt16 inKeyCode,
	536	SInt16 inCharCode,
	537	SInt16 inModifiers)
	538	{
	539	if ( UMAHasAppearance() )
	540	{
	541	return HandleControlKey( inControl , inKeyCode , inCharCode , inModifiers ) ;
	542	}
	543	else
	544	{
	545	return AGAHandleControlKey(inControl , inKeyCode , inCharCode , inModifiers ) ;
	546	}
	547	}
	548
	549
	550
	551	void UMAIdleControls (WindowPtr inWindow)
	552	{
	553	if ( UMAHasAppearance() )
	554	{
	555	IdleControls( inWindow ) ;
	556	}
	557	else
	558	{
	559	AGAIdleControls( inWindow ) ;
	560	}
	561	}
	562
	563	void UMAUpdateControls( WindowPtr inWindow , RgnHandle inRgn )
	564	{
	565	if ( UMAHasAppearance() )
	566	{
	567	UpdateControls( inWindow , inRgn ) ;
	568	}
	569	else
	570	{
	571	AGAUpdateControls( inWindow , inRgn ) ;
	572	}
	573	}
	574
	575	OSErr UMAGetRootControl( WindowPtr inWindow , ControlHandle *outControl )
	576	{
	577	if ( UMAHasAppearance() )
	578	{
	579	return GetRootControl( inWindow , outControl ) ;
	580	}
	581	else
	582	{
	583	return AGAGetRootControl( inWindow , outControl ) ;
	584	}
	585	}
	586
	587
	588	// handling control data
	589
	590	OSErr UMASetControlData (ControlHandle inControl,
	591	ControlPartCode inPart,
	592	ResType inTagName,
	593	Size inSize,
	594	Ptr inData)
	595	{
	596	if ( UMAHasAppearance() )
	597	{
	598	return SetControlData( inControl , inPart , inTagName , inSize , inData ) ;
	599	}
	600	else
	601	return AGASetControlData( inControl , inPart , inTagName , inSize , inData ) ;
	602	}
	603
	604
	605
	606	OSErr UMAGetControlData (ControlHandle inControl,
	607	ControlPartCode inPart,
	608	ResType inTagName,
	609	Size inBufferSize,
	610	Ptr outBuffer,
	611	Size * outActualSize)
	612	{
	613	if ( UMAHasAppearance() )
	614	{
	615	return ::GetControlData( inControl , inPart , inTagName , inBufferSize , outBuffer , outActualSize ) ;
	616	}
	617	else
	618	{
	619	return AGAGetControlData( inControl , inPart , inTagName , inBufferSize , outBuffer , outActualSize ) ;
	620	}
	621
	622	}
	623
	624
	625	OSErr UMAGetControlDataSize (ControlHandle inControl,
	626	ControlPartCode inPart,
	627	ResType inTagName,
	628	Size * outMaxSize)
	629	{
	630	if ( UMAHasAppearance() )
	631	{
	632	return GetControlDataSize( inControl , inPart , inTagName , outMaxSize ) ;
	633	}
	634	else
	635	{
	636	return AGAGetControlDataSize( inControl , inPart , inTagName , outMaxSize ) ;
	637	}
	638	}
	639
	640
	641
	642
	643
	644	// system 8.0 changes
	645
	646	short UMAFindWindow( Point inPoint , WindowRef *outWindow )
	647	{
	648	// todo add the additional area codes
	649	return FindWindow( inPoint , outWindow ) ;
	650	}
	651
	652	OSStatus UMAGetWindowFeatures( WindowRef inWindowRef , UInt32 *outFeatures )
	653	{
	654	#if UMA_USE_WINDOWMGR
	655	return GetWindowFeatures( inWindowRef , outFeatures ) ;
	656	#else
	657	return 0 ;
	658	#endif
	659	}
	660
	661	OSStatus UMAGetWindowRegion( WindowRef inWindowRef , WindowRegionCode inRegionCode , RgnHandle ioWinRgn )
	662	{
	663	#if UMA_USE_WINDOWMGR
	664	return GetWindowRegion( inWindowRef , inRegionCode , ioWinRgn ) ;
	665	#else
	666	return 0 ;
	667	#endif
	668	}
	669
	670	void UMADrawGrowIcon( WindowRef inWindowRef )
	671	{
	672	DrawGrowIcon( inWindowRef ) ;
	673	}
	674
	675	OSStatus UMACollapseWindow( WindowRef inWindowRef , Boolean inCollapseIt )
	676	{
	677	return CollapseWindow( inWindowRef , inCollapseIt ) ;
	678	}
	679
	680	OSStatus UMACollapseAllWindows( Boolean inCollapseEm )
	681	{
	682	return CollapseAllWindows( inCollapseEm ) ;
	683	}
	684
	685	Boolean UMAIsWindowCollapsed( WindowRef inWindowRef )
	686	{
	687	return IsWindowCollapsed( inWindowRef ) ;
	688	}
	689
	690	Boolean UMAIsWindowCollapsable( WindowRef inWindowRef )
	691	{
	692	return IsWindowCollapsable( inWindowRef ) ;
	693	}
	694
	695	// system 8.5 changes<MacWindows.h>
	696	OSStatus UMACreateNewWindow( WindowClass windowClass , WindowAttributes attributes , const Rect bounds, WindowRef outWindow )
	697	{
	698	#if UMA_USE_WINDOWMGR
	699	if ( UMAHasWindowManager() )
	700	{
	701	return CreateNewWindow( windowClass , attributes, bounds, outWindow ) ;
	702	}
	703	else
	704	#endif
	705	{
	706	short procID ;
	707	if ( UMAHasAppearance() )
	708	{
	709	switch( windowClass )
	710	{
	711	case kMovableModalWindowClass :
	712	procID = kWindowMovableModalDialogProc;
	713	break ;
	714	case kDocumentWindowClass :
	715	procID = kWindowFullZoomGrowDocumentProc;
	716	break ;
	717	default :
	718	procID = kWindowMovableModalDialogProc;
	719	break ;
	720	}
	721	}
	722	else
	723	{
	724	switch( windowClass )
	725	{
	726	case kMovableModalWindowClass :
	727	procID = movableDBoxProc;
	728	// procID += kMovableModalDialogVariantCode;
	729	break ;
	730	case kDocumentWindowClass :
	731	procID = zoomDocProc;
	732	break ;
	733	default :
	734	procID = documentProc;
	735	break ;
	736	}
	737	}
	738	outWindow = NewCWindow(nil, bounds, "\p", false, procID, (WindowRef) -1 /behind*/,
	739	attributes & kWindowCloseBoxAttribute , (long)NULL);
	740	return noErr ;
	741	}
	742	}
	743
	744	OSStatus UMAGetWindowClass( WindowRef inWindowRef , WindowClass *outWindowClass )
	745	{
	746	#if UMA_USE_WINDOWMGR
	747	if ( UMAHasWindowManager() )
	748	{
	749	return GetWindowClass( inWindowRef , outWindowClass ) ;
	750	}
	751	else
	752	#endif
	753	return kDocumentWindowClass ;
	754	}
	755
	756	OSStatus UMAGetWindowAttributes( WindowRef inWindowRef , WindowAttributes *outAttributes )
	757	{
	758	#if UMA_USE_WINDOWMGR
	759	if ( UMAHasWindowManager() )
	760	{
	761	return GetWindowAttributes( inWindowRef , outAttributes ) ;
	762	}
	763	#endif
	764	return kWindowNoAttributes ;
	765	}
	766
	767	void UMAShowFloatingWindows()
	768	{
	769	#if UMA_USE_WINDOWMGR
	770	if ( UMAHasWindowManager() )
	771	{
	772	ShowFloatingWindows() ;
	773	}
	774	#endif
	775	}
	776
	777	void UMAHideFloatingWindows()
	778	{
	779	#if UMA_USE_WINDOWMGR
	780	if ( UMAHasWindowManager() )
	781	{
	782	HideFloatingWindows() ;
	783	}
	784	#endif
	785	}
	786
	787	Boolean UMAAreFloatingWindowsVisible()
	788	{
	789	#if UMA_USE_WINDOWMGR
	790	if ( UMAHasWindowManager() )
	791	{
	792	return AreFloatingWindowsVisible() ;
	793	}
	794	#endif
	795	return false ;
	796	}
	797
	798	WindowRef UMAFrontNonFloatingWindow()
	799	{
	800	#if UMA_USE_WINDOWMGR
	801	if ( UMAHasWindowManager() )
	802	{
	803	return FrontNonFloatingWindow() ;
	804	}
	805	else
	806	#endif
	807	{
	808	return FrontWindow() ;
	809	}
	810	}
	811
	812	WindowRef UMAFrontWindow()
	813	{
	814	#if UMA_USE_WINDOWMGR
	815	if ( UMAHasWindowManager() )
	816	{
	817	return FrontWindow() ;
	818	}
	819	else
	820	#endif
	821	{
	822	return FrontWindow() ;
	823	}
	824	}
	825
	826	WindowRef UMAGetActiveNonFloatingWindow()
	827	{
	828	return NULL ;
	829	}
	830
	831	bool UMAIsWindowFloating( WindowRef inWindow )
	832	{
	833	WindowClass cl ;
	834
	835	UMAGetWindowClass( inWindow , &cl ) ;
	836	return cl == kFloatingWindowClass ;
	837	}
	838
	839	bool UMAIsWindowModal( WindowRef inWindow )
	840	{
	841	WindowClass cl ;
	842
	843	UMAGetWindowClass( inWindow , &cl ) ;
	844	return cl < kFloatingWindowClass ;
	845	}
	846
	847	// others
	848
	849	void UMAHighlightAndActivateWindow( WindowRef inWindowRef , bool inActivate )
	850	{
	851	if ( inWindowRef )
	852	{
	853	// bool isHighlighted = IsWindowHighlited( inWindowRef ) ;
	854	// if ( inActivate != isHightlited )
	855	HiliteWindow( inWindowRef , inActivate ) ;
	856	}
	857	}
	858