/*
 	File:		ControlDefinitions.h
 
 	Contains:	Definitions of controls used by Control Mgr
 
 	Version:	Technology:	Mac OS 9
 				Release:	QuickTime 4.1
 
 	Copyright:	(c) 1999 by Apple Computer, Inc., all rights reserved.
 
 	Bugs?:		For bug reports, consult the following page on
 				the World Wide Web:
 
 					http://developer.apple.com/bugreporter/
 
*/
#ifndef __CONTROLDEFINITIONS__
#define __CONTROLDEFINITIONS__

#ifndef __APPEARANCE__
	#include <Appearance.h>
#endif

#ifndef __CONTROLS__
	#include <Controls.h>
#endif

#ifndef __LISTS__
	#include <Lists.h>
#endif

#ifndef __MACHELP__
	#include <MacHelp.h>
#endif

#ifndef __MENUS__
	#include <Menus.h>
#endif




#if PRAGMA_ONCE
#pragma once
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if PRAGMA_IMPORT
#pragma import on
#endif

#if PRAGMA_STRUCT_ALIGN
	#pragma options align=mac68k
#elif PRAGMA_STRUCT_PACKPUSH
	#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
	#pragma pack(2)
#endif

/*------------------------------------------------------------------------------------------------------*/
/*	o Resource Types																					*/
/*------------------------------------------------------------------------------------------------------*/

enum {
	kControlTabListResType		= FOUR_CHAR_CODE('tab#'),		/* used for tab control (Appearance 1.0 and later)*/
	kControlListDescResType		= FOUR_CHAR_CODE('ldes')		/* used for list box control (Appearance 1.0 and later)*/
};

/*--------------------------------------------------------------------------------------*/
/*	o Check Box Values																	*/
/*--------------------------------------------------------------------------------------*/
enum {
	kControlCheckBoxUncheckedValue = 0,
	kControlCheckBoxCheckedValue = 1,
	kControlCheckBoxMixedValue	= 2
};

/*--------------------------------------------------------------------------------------*/
/*	o Radio Button Values																*/
/*--------------------------------------------------------------------------------------*/
enum {
	kControlRadioButtonUncheckedValue = 0,
	kControlRadioButtonCheckedValue = 1,
	kControlRadioButtonMixedValue = 2
};

/*--------------------------------------------------------------------------------------*/
/*	o Pop-Up Menu Control Constants														*/
/*--------------------------------------------------------------------------------------*/
/* Variant codes for the System 7 pop-up menu*/
enum {
	popupFixedWidth				= 1 << 0,
	popupVariableWidth			= 1 << 1,
	popupUseAddResMenu			= 1 << 2,
	popupUseWFont				= 1 << 3
};

/* Menu label styles for the System 7 pop-up menu*/
enum {
	popupTitleBold				= 1 << 8,
	popupTitleItalic			= 1 << 9,
	popupTitleUnderline			= 1 << 10,
	popupTitleOutline			= 1 << 11,
	popupTitleShadow			= 1 << 12,
	popupTitleCondense			= 1 << 13,
	popupTitleExtend			= 1 << 14,
	popupTitleNoStyle			= 1 << 15
};

/* Menu label justifications for the System 7 pop-up menu*/
enum {
	popupTitleLeftJust			= 0x00000000,
	popupTitleCenterJust		= 0x00000001,
	popupTitleRightJust			= 0x000000FF
};

/*------------------------------------------------------------------------------------------------------*/
/*	o PopUp Menu Private Data Structure																	*/
/*------------------------------------------------------------------------------------------------------*/
#if !OPAQUE_TOOLBOX_STRUCTS

struct PopupPrivateData {
	MenuHandle 						mHandle;
	SInt16 							mID;
};
typedef struct PopupPrivateData			PopupPrivateData;
typedef PopupPrivateData *				PopupPrivateDataPtr;
typedef PopupPrivateDataPtr *			PopupPrivateDataHandle;
#endif  /* !OPAQUE_TOOLBOX_STRUCTS */

/*------------------------------------------------------------------------------------------------------*/
/*	o Control Definition ID's																			*/
/*------------------------------------------------------------------------------------------------------*/
/* Standard System 7 procIDs*/

enum {
	pushButProc					= 0,
	checkBoxProc				= 1,
	radioButProc				= 2,
	scrollBarProc				= 16,
	popupMenuProc				= 1008
};

/*--------------------------------------------------------------------------------------*/
/*	o Control Part Codes																*/
/*--------------------------------------------------------------------------------------*/
enum {
	kControlLabelPart			= 1,
	kControlMenuPart			= 2,
	kControlTrianglePart		= 4,
	kControlEditTextPart		= 5,							/* Appearance 1.0 and later*/
	kControlPicturePart			= 6,							/* Appearance 1.0 and later*/
	kControlIconPart			= 7,							/* Appearance 1.0 and later*/
	kControlClockPart			= 8,							/* Appearance 1.0 and later*/
	kControlListBoxPart			= 24,							/* Appearance 1.0 and later*/
	kControlListBoxDoubleClickPart = 25,						/* Appearance 1.0 and later*/
	kControlImageWellPart		= 26,							/* Appearance 1.0 and later*/
	kControlRadioGroupPart		= 27,							/* Appearance 1.0.2 and later*/
	kControlButtonPart			= 10,
	kControlCheckBoxPart		= 11,
	kControlRadioButtonPart		= 11,
	kControlUpButtonPart		= 20,
	kControlDownButtonPart		= 21,
	kControlPageUpPart			= 22,
	kControlPageDownPart		= 23,
	kControlClockHourDayPart	= 9,							/* Appearance 1.1 and later*/
	kControlClockMinuteMonthPart = 10,							/* Appearance 1.1 and later*/
	kControlClockSecondYearPart	= 11,							/* Appearance 1.1 and later*/
	kControlClockAMPMPart		= 12,							/* Appearance 1.1 and later*/
	kControlDataBrowserPart		= 24,							/* CarbonLib 1.0 and later*/
	kControlDataBrowserDraggedPart = 25							/* CarbonLib 1.0 and later*/
};



/*------------------------------------------------------------------------------------------------------*/
/*	o Control Types and ID's available only with Appearance 1.0 and later								*/
/*------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------*/
/*	o BEVEL BUTTON INTERFACE (CDEF 2)													*/
/*--------------------------------------------------------------------------------------*/
/*	Bevel buttons allow you to control the content type (pict/icon/etc.), the behavior	*/
/* (pushbutton/toggle/sticky), and the bevel size. You also have the option of			*/
/*	attaching a menu to it. When a menu is present, you can specify which way the 		*/
/*	popup arrow is facing (down or right).												*/
/*																						*/
/*	This is all made possible by overloading the Min, Max, and Value parameters for the	*/
/*	control, as well as adjusting the variant. Here's the breakdown of what goes where:	*/
/*																						*/
/*	Parameter					What Goes Here											*/
/*	-------------------			----------------------------------------------------	*/
/*	Min							Hi Byte = Behavior, Lo Byte = content type.				*/
/*	Max							ResID for resource-based content types.					*/
/*	Value						MenuID to attach, 0 = no menu, please.					*/
/*																						*/
/*	The variant is broken down into two halfs. The low 2 bits control the bevel type.	*/
/*	Bit 2 controls the popup arrow direction (if a menu is present) and bit 3 controls	*/
/*	whether or not to use the control's owning window's font.							*/
/*																						*/
/*	Constants for all you need to put this together are below. The values for behaviors	*/
/*	are set up so that you can simply add them to the content type and pass them into	*/
/*	the Min parameter of NewControl.													*/
/*																						*/
/*	An example call:																	*/
/*																						*/
/*	control = NewControl( window, &bounds, "\p", true, 0, kContentIconSuiteRes + 		*/
/*							kBehaviorToggles, myIconSuiteID, bevelButtonSmallBevelProc,	*/
/*							0L );														*/
/*																						*/
/*	Attaching a menu:																	*/
/*																						*/
/*	control = NewControl( window, &bounds, "\p", true, kMyMenuID, kContentIconSuiteRes,	*/
/*			myIconSuiteID, bevelButtonSmallBevelProc + kBevelButtonMenuOnRight, 0L );	*/
/*																						*/
/*	This will attach menu ID kMyMenuID to the button, with the popup arrow facing right.*/
/*	This also puts the menu up to the right of the button. You can also specify that a	*/
/*	menu can have multiple items checked at once by adding kBehaviorMultiValueMenus		*/
/*	into the Min parameter. If you do use multivalue menus, the GetBevelButtonMenuValue	*/
/*	helper function will return the last item chosen from the menu, whether or not it	*/
/*	was checked.																		*/
/*																						*/
/*	NOTE: 	Bevel buttons with menus actually have *two* values. The value of the 		*/
/*			button (on/off), and the value of the menu. The menu value can be gotten	*/
/*			with the GetBevelButtonMenuValue helper function.							*/
/*																						*/
/*	Handle-based Content																*/
/*	--------------------																*/
/*	You can create your control and then set the content to an existing handle to an	*/
/*	icon suite, etc. using the macros below. Please keep in mind that resource-based	*/
/*	content is owned by the control, handle-based content is owned by you. The CDEF will*/
/*	not try to dispose of handle-based content. If you are changing the content type of	*/
/*	the button on the fly, you must make sure that if you are replacing a handle-		*/
/*	based content with a resource-based content to properly dispose of the handle,		*/
/*	else a memory leak will ensue.														*/
/*																						*/
/* Bevel Button Proc IDs */
enum {
	kControlBevelButtonSmallBevelProc = 32,
	kControlBevelButtonNormalBevelProc = 33,
	kControlBevelButtonLargeBevelProc = 34
};

/* Add these variant codes to kBevelButtonSmallBevelProc to change the type of button */
enum {
	kControlBevelButtonSmallBevelVariant = 0,
	kControlBevelButtonNormalBevelVariant = (1 << 0),
	kControlBevelButtonLargeBevelVariant = (1 << 1),
	kControlBevelButtonMenuOnRightVariant = (1 << 2)
};

/* Bevel Thicknesses */

typedef UInt16 ControlBevelThickness;
enum {
	kControlBevelButtonSmallBevel = 0,
	kControlBevelButtonNormalBevel = 1,
	kControlBevelButtonLargeBevel = 2
};

/* Behaviors of bevel buttons. These are set up so you can add	*/
/* them together with the content types.						*/
enum {
	kControlBehaviorPushbutton	= 0,
	kControlBehaviorToggles		= 0x0100,
	kControlBehaviorSticky		= 0x0200,
	kControlBehaviorSingleValueMenu = 0,
	kControlBehaviorMultiValueMenu = 0x4000,					/* only makes sense when a menu is attached.*/
	kControlBehaviorOffsetContents = 0x8000
};

/* Behaviors for 1.0.1 or later */
enum {
	kControlBehaviorCommandMenu	= 0x2000						/* menu holds commands, not choices. Overrides multi-value bit.*/
};


typedef UInt16 							ControlBevelButtonBehavior;
typedef UInt16 							ControlBevelButtonMenuBehavior;
/* Bevel Button Menu Placements */

typedef UInt16 ControlBevelButtonMenuPlacement;
enum {
	kControlBevelButtonMenuOnBottom = 0,
	kControlBevelButtonMenuOnRight = (1 << 2)
};


/* Graphic Alignments */

typedef SInt16 ControlButtonGraphicAlignment;
enum {
	kControlBevelButtonAlignSysDirection = -1,					/* only left or right*/
	kControlBevelButtonAlignCenter = 0,
	kControlBevelButtonAlignLeft = 1,
	kControlBevelButtonAlignRight = 2,
	kControlBevelButtonAlignTop	= 3,
	kControlBevelButtonAlignBottom = 4,
	kControlBevelButtonAlignTopLeft = 5,
	kControlBevelButtonAlignBottomLeft = 6,
	kControlBevelButtonAlignTopRight = 7,
	kControlBevelButtonAlignBottomRight = 8
};

/* Text Alignments */

typedef SInt16 ControlButtonTextAlignment;
enum {
	kControlBevelButtonAlignTextSysDirection = teFlushDefault,
	kControlBevelButtonAlignTextCenter = teCenter,
	kControlBevelButtonAlignTextFlushRight = teFlushRight,
	kControlBevelButtonAlignTextFlushLeft = teFlushLeft
};

/* Text Placements */

typedef SInt16 ControlButtonTextPlacement;
enum {
	kControlBevelButtonPlaceSysDirection = -1,					/* if graphic on right, then on left*/
	kControlBevelButtonPlaceNormally = 0,
	kControlBevelButtonPlaceToRightOfGraphic = 1,
	kControlBevelButtonPlaceToLeftOfGraphic = 2,
	kControlBevelButtonPlaceBelowGraphic = 3,
	kControlBevelButtonPlaceAboveGraphic = 4
};


/* Data tags supported by the bevel button controls */
enum {
	kControlBevelButtonContentTag = FOUR_CHAR_CODE('cont'),		/* ButtonContentInfo*/
	kControlBevelButtonTransformTag = FOUR_CHAR_CODE('tran'),	/* IconTransformType*/
	kControlBevelButtonTextAlignTag = FOUR_CHAR_CODE('tali'),	/* ButtonTextAlignment*/
	kControlBevelButtonTextOffsetTag = FOUR_CHAR_CODE('toff'),	/* SInt16*/
	kControlBevelButtonGraphicAlignTag = FOUR_CHAR_CODE('gali'), /* ButtonGraphicAlignment*/
	kControlBevelButtonGraphicOffsetTag = FOUR_CHAR_CODE('goff'), /* Point*/
	kControlBevelButtonTextPlaceTag = FOUR_CHAR_CODE('tplc'),	/* ButtonTextPlacement*/
	kControlBevelButtonMenuValueTag = FOUR_CHAR_CODE('mval'),	/* SInt16*/
	kControlBevelButtonMenuHandleTag = FOUR_CHAR_CODE('mhnd'),	/* MenuHandle*/
	kControlBevelButtonCenterPopupGlyphTag = FOUR_CHAR_CODE('pglc') /* Boolean: true = center, false = bottom right*/
};

/* These are tags in 1.0.1 or later */
enum {
	kControlBevelButtonLastMenuTag = FOUR_CHAR_CODE('lmnu'),	/* SInt16: menuID of last menu item selected from*/
	kControlBevelButtonMenuDelayTag = FOUR_CHAR_CODE('mdly')	/* SInt32: ticks to delay before menu appears*/
};

/* tags available with Appearance 1.1 or later */
enum {
																/* Boolean: True = if an icon of the ideal size for*/
																/* the button isn't available, scale a larger or*/
																/* smaller icon to the ideal size. False = don't*/
																/* scale; draw a smaller icon or clip a larger icon.*/
																/* Default is false. Only applies to IconSuites and*/
	kControlBevelButtonScaleIconTag = FOUR_CHAR_CODE('scal')	/* IconRefs.*/
};

/* Helper routines are available only thru the shared library/glue. */
EXTERN_API( OSErr )
GetBevelButtonMenuValue			(ControlHandle 			inButton,
								 SInt16 *				outValue);

EXTERN_API( OSErr )
SetBevelButtonMenuValue			(ControlHandle 			inButton,
								 SInt16 				inValue);

EXTERN_API( OSErr )
GetBevelButtonMenuHandle		(ControlHandle 			inButton,
								 MenuHandle *			outHandle);

EXTERN_API( OSErr )
GetBevelButtonContentInfo		(ControlHandle 			inButton,
								 ControlButtonContentInfoPtr  outContent);

EXTERN_API( OSErr )
SetBevelButtonContentInfo		(ControlHandle 			inButton,
								 ControlButtonContentInfoPtr  inContent);

EXTERN_API( OSErr )
SetBevelButtonTransform			(ControlHandle 			inButton,
								 IconTransformType 		transform);

EXTERN_API( OSErr )
SetBevelButtonGraphicAlignment	(ControlHandle 			inButton,
								 ControlButtonGraphicAlignment  inAlign,
								 SInt16 				inHOffset,
								 SInt16 				inVOffset);

EXTERN_API( OSErr )
SetBevelButtonTextAlignment		(ControlHandle 			inButton,
								 ControlButtonTextAlignment  inAlign,
								 SInt16 				inHOffset);

EXTERN_API( OSErr )
SetBevelButtonTextPlacement		(ControlHandle 			inButton,
								 ControlButtonTextPlacement  inWhere);


/*--------------------------------------------------------------------------------------*/
/*	o SLIDER (CDEF 3)																	*/
/*--------------------------------------------------------------------------------------*/
/*	There are several variants that control the behavior of the slider control. Any		*/
/*	combination of the following three constants can be added to the basic CDEF ID		*/
/*	(kSliderProc).																		*/
/*																						*/
/*	Variants:																			*/
/*																						*/
/*		kSliderLiveFeedback	 	Slider does not use "ghosted" indicator when tracking.	*/
/*								ActionProc is called (set via SetControlAction) as the	*/
/*								indicator is dragged. The value is updated so that the	*/
/*								actionproc can adjust some other property based on the	*/
/*								value each time the action proc is called. If no action	*/
/*								proc is installed, it reverts to the ghost indicator.	*/
/*																						*/
/*		kSliderHasTickMarks	 	Slider is drawn with 'tick marks'. The control			*/
/*								rectangle must be large enough to accomidate the tick	*/
/*								marks.													*/
/*																						*/
/*		kSliderReverseDirection	Slider thumb points in opposite direction than normal.	*/
/*								If the slider is vertical, the thumb will point to the	*/
/*								left, if the slider is horizontal, the thumb will point	*/
/*								upwards.												*/
/*																						*/
/*		kSliderNonDirectional	This option overrides the kSliderReverseDirection and	*/
/*								kSliderHasTickMarks variants. It creates an indicator	*/
/*								which is rectangular and doesn't point in any direction	*/
/*								like the normal indicator does.							*/
/* Slider proc ID and variants */
enum {
	kControlSliderProc			= 48,
	kControlSliderLiveFeedback	= (1 << 0),
	kControlSliderHasTickMarks	= (1 << 1),
	kControlSliderReverseDirection = (1 << 2),
	kControlSliderNonDirectional = (1 << 3)
};

/*--------------------------------------------------------------------------------------*/
/*	o DISCLOSURE TRIANGLE (CDEF 4)														*/
/*--------------------------------------------------------------------------------------*/
/*	This control can be used as either left or right facing. It can also handle its own	*/
/*	tracking if you wish. This means that when the 'autotoggle' variant is used, if the	*/
/*	user clicks the control, it's state will change automatically from open to closed	*/
/*	and vice-versa depending on its initial state. After a successful call to Track-	*/
/* 	Control, you can just check the current value to see what state it was switched to.	*/
/* Triangle proc IDs */
enum {
	kControlTriangleProc		= 64,
	kControlTriangleLeftFacingProc = 65,
	kControlTriangleAutoToggleProc = 66,
	kControlTriangleLeftFacingAutoToggleProc = 67
};

/* Tagged data supported by disclosure triangles */
enum {
	kControlTriangleLastValueTag = FOUR_CHAR_CODE('last')		/* SInt16*/
};

/* Helper routines are available only thru the shared library/glue. */
EXTERN_API( OSErr )
SetDisclosureTriangleLastValue	(ControlHandle 			inTabControl,
								 SInt16 				inValue);

/*--------------------------------------------------------------------------------------*/
/*	o PROGRESS INDICATOR (CDEF 5)														*/
/*--------------------------------------------------------------------------------------*/
/*	This CDEF implements both determinate and indeterminate progress bars. To switch, 	*/
/*	just use SetControlData to set the indeterminate flag to make it indeterminate call	*/
/*	IdleControls to step thru the animation. IdleControls should be called at least		*/
/*	once during your event loop.														*/
/*																						*/
/* Progress Bar proc IDs */
enum {
	kControlProgressBarProc		= 80
};

/* Tagged data supported by progress bars */
enum {
	kControlProgressBarIndeterminateTag = FOUR_CHAR_CODE('inde') /* Boolean*/
};

/*--------------------------------------------------------------------------------------*/
/*	o LITTLE ARROWS (CDEF 6)															*/
/*--------------------------------------------------------------------------------------*/
/* 	This control implements the little up and down arrows you'd see in the Memory		*/
/*	control panel for adjusting the cache size. 										*/
/* Little Arrows proc IDs */
enum {
	kControlLittleArrowsProc	= 96
};

/*--------------------------------------------------------------------------------------*/
/*	o CHASING ARROWS (CDEF 7)															*/
/*--------------------------------------------------------------------------------------*/
/*	To animate this control, make sure to call IdleControls repeatedly.					*/
/*																						*/
/* Chasing Arrows proc IDs */
enum {
	kControlChasingArrowsProc	= 112
};

/*--------------------------------------------------------------------------------------*/
/*	o TABS (CDEF 8)																		*/
/*--------------------------------------------------------------------------------------*/
/*	Tabs use an auxiliary resource (tab#) to hold tab information such as the tab name	*/
/*	and an icon suite ID for each tab.													*/
/*																						*/
/*	The ID of the tab# resource that you wish to associate with a tab control should 	*/
/*	be passed in as the Value parameter of the control. If you are using GetNewControl, */
/*	then the Value slot in the CNTL resource should have the ID of the 'tab#' resource	*/
/*	on creation.																		*/
/*																						*/
/*	Passing zero in for the tab# resource tells the control not to read in a tab# res.	*/
/*	You can then use SetControlMaximum to add tabs, followed by a call to SetControlData*/
/*	with the kControlTabInfoTag, passing in a pointer to a ControlTabInfoRec. This sets	*/
/* 	the name and optionally an icon for a tab.											*/
/* Tabs proc IDs */
enum {
	kControlTabLargeProc		= 128,							/* Large tab size, north facing	*/
	kControlTabSmallProc		= 129,							/* Small tab size, north facing	*/
	kControlTabLargeNorthProc	= 128,							/* Large tab size, north facing	*/
	kControlTabSmallNorthProc	= 129,							/* Small tab size, north facing	*/
	kControlTabLargeSouthProc	= 130,							/* Large tab size, south facing	*/
	kControlTabSmallSouthProc	= 131,							/* Small tab size, south facing	*/
	kControlTabLargeEastProc	= 132,							/* Large tab size, east facing	*/
	kControlTabSmallEastProc	= 133,							/* Small tab size, east facing	*/
	kControlTabLargeWestProc	= 134,							/* Large tab size, west facing	*/
	kControlTabSmallWestProc	= 135							/* Small tab size, west facing	*/
};

/* Tagged data supported by tabs */
enum {
	kControlTabContentRectTag	= FOUR_CHAR_CODE('rect'),		/* Rect*/
	kControlTabEnabledFlagTag	= FOUR_CHAR_CODE('enab'),		/* Boolean*/
	kControlTabFontStyleTag		= kControlFontStyleTag			/* ControlFontStyleRec*/
};

/* New tags in 1.0.1 or later */
enum {
	kControlTabInfoTag			= FOUR_CHAR_CODE('tabi')		/* ControlTabInfoRec*/
};

enum {
	kControlTabInfoVersionZero	= 0
};


struct ControlTabInfoRec {
	SInt16 							version;					/* version of this structure.*/
	SInt16 							iconSuiteID;				/* icon suite to use. Zero indicates no icon*/
	Str255 							name;						/* name to be displayed on the tab*/
};
typedef struct ControlTabInfoRec		ControlTabInfoRec;
/* Helper routines are available only thru the shared library/glue. */
EXTERN_API( OSErr )
GetTabContentRect				(ControlHandle 			inTabControl,
								 Rect *					outContentRect);

EXTERN_API( OSErr )
SetTabEnabled					(ControlHandle 			inTabControl,
								 SInt16 				inTabToHilite,
								 Boolean 				inEnabled);

/*--------------------------------------------------------------------------------------*/
/*	o VISUAL SEPARATOR (CDEF 9)															*/
/*--------------------------------------------------------------------------------------*/
/*	Separator lines determine their orientation (horizontal or vertical) automatically	*/
/*	based on the relative height and width of their contrlRect.							*/
/* Visual separator proc IDs */
enum {
	kControlSeparatorLineProc	= 144
};

/*--------------------------------------------------------------------------------------*/
/*	o GROUP BOX (CDEF 10)																*/
/*--------------------------------------------------------------------------------------*/
/*	The group box CDEF can be use in several ways. It can have no title, a text title, 	*/
/*	a check box as the title, or a popup button as a title. There are two versions of 	*/
/*	group boxes, primary and secondary, which look slightly different.					*/
/* Group Box proc IDs */
enum {
	kControlGroupBoxTextTitleProc = 160,
	kControlGroupBoxCheckBoxProc = 161,
	kControlGroupBoxPopupButtonProc = 162,
	kControlGroupBoxSecondaryTextTitleProc = 164,
	kControlGroupBoxSecondaryCheckBoxProc = 165,
	kControlGroupBoxSecondaryPopupButtonProc = 166
};

/* Tagged data supported by group box */
enum {
	kControlGroupBoxMenuHandleTag = FOUR_CHAR_CODE('mhan'),		/* MenuHandle (popup title only)*/
	kControlGroupBoxFontStyleTag = kControlFontStyleTag			/* ControlFontStyleRec*/
};

/* tags available with Appearance 1.1 or later */
enum {
	kControlGroupBoxTitleRectTag = FOUR_CHAR_CODE('trec')		/* Rect. Rectangle that the title text/control is drawn in. (get only)*/
};

/*--------------------------------------------------------------------------------------*/
/*	o IMAGE WELL (CDEF 11)																*/
/*--------------------------------------------------------------------------------------*/
/*	Image Wells allow you to control the content type (pict/icon/etc.) shown in the 	*/
/*	well.																				*/
/*																						*/
/*	This is made possible by overloading the Min and Value parameters for the control.	*/
/*																						*/
/*	Parameter					What Goes Here											*/
/*	-------------------			--------------------------------------------------		*/
/*	Min							content type (see constants for bevel buttons)			*/
/*	Value						Resource ID of content type, if resource-based.			*/
/*																						*/
/*																						*/
/*	Handle-based Content																*/
/*	--------------------																*/
/*	You can create your control and then set the content to an existing handle to an	*/
/*	icon suite, etc. using the macros below. Please keep in mind that resource-based	*/
/*	content is owned by the control, handle-based content is owned by you. The CDEF will*/
/*	not try to dispose of handle-based content. If you are changing the content type of	*/
/*	the button on the fly, you must make sure that if you are replacing a handle-		*/
/*	based content with a resource-based content to properly dispose of the handle,		*/
/*	else a memory leak will ensue.														*/
/*																						*/
/* Image Well proc IDs */
enum {
	kControlImageWellProc		= 176
};

/* Tagged data supported by image wells */
enum {
	kControlImageWellContentTag	= FOUR_CHAR_CODE('cont'),		/* ButtonContentInfo*/
	kControlImageWellTransformTag = FOUR_CHAR_CODE('tran')		/* IconTransformType*/
};

/* Helper routines are available only thru the shared library/glue. */
EXTERN_API( OSErr )
GetImageWellContentInfo			(ControlHandle 			inButton,
								 ControlButtonContentInfoPtr  outContent);

EXTERN_API( OSErr )
SetImageWellContentInfo			(ControlHandle 			inButton,
								 ControlButtonContentInfoPtr  inContent);

EXTERN_API( OSErr )
SetImageWellTransform			(ControlHandle 			inButton,
								 IconTransformType 		inTransform);

/*--------------------------------------------------------------------------------------*/
/*	o POPUP ARROW (CDEF 12)																*/
/*--------------------------------------------------------------------------------------*/
/*	The popup arrow CDEF is used to draw the small arrow normally associated with a 	*/
/*	popup control. The arrow can point in four directions, and a small or large version */
/*	can be used. This control is provided to allow clients to draw the arrow in a 		*/
/*	normalized fashion which will take advantage of themes automatically.				*/
/*																						*/
/* Popup Arrow proc IDs */
enum {
	kControlPopupArrowEastProc	= 192,
	kControlPopupArrowWestProc	= 193,
	kControlPopupArrowNorthProc	= 194,
	kControlPopupArrowSouthProc	= 195,
	kControlPopupArrowSmallEastProc = 196,
	kControlPopupArrowSmallWestProc = 197,
	kControlPopupArrowSmallNorthProc = 198,
	kControlPopupArrowSmallSouthProc = 199
};

/* Popup Arrow Orientations */
enum {
	kControlPopupArrowOrientationEast = 0,
	kControlPopupArrowOrientationWest = 1,
	kControlPopupArrowOrientationNorth = 2,
	kControlPopupArrowOrientationSouth = 3
};


typedef UInt16 							ControlPopupArrowOrientation;
/*--------------------------------------------------------------------------------------*/
/*	o PLACARD (CDEF 14)																	*/
/*--------------------------------------------------------------------------------------*/
/* Placard proc IDs */
enum {
	kControlPlacardProc			= 224
};

/*--------------------------------------------------------------------------------------*/
/*	o CLOCK (CDEF 15)																	*/
/*--------------------------------------------------------------------------------------*/
/* 	NOTE:	You can specify more options in the Value paramter when creating the clock.	*/
/*			See below.																	*/
/*																						*/
/*	NOTE:	Under Appearance 1.1, the clock control knows and returns more part codes.	*/
/*			The new clock-specific part codes are defined with the other control parts.	*/
/*			Besides these clock-specific parts, we also return kControlUpButtonPart		*/
/*			and kControlDownButtonPart when they hit the up and down arrows.			*/
/*			The new part codes give you more flexibility for focusing and hit testing.	*/
/*																						*/
/*			The original kControlClockPart is still valid. When hit testing, it means	*/
/*			that some non-editable area of the clock's whitespace has been clicked.		*/
/*			When focusing a currently unfocused clock, it changes the focus to the		*/
/*			first part; it is the same as passing kControlFocusNextPart. When			*/
/*			re-focusing a focused clock, it will not change the focus at all.			*/
/* Clock proc IDs */
enum {
	kControlClockTimeProc		= 240,
	kControlClockTimeSecondsProc = 241,
	kControlClockDateProc		= 242,
	kControlClockMonthYearProc	= 243
};

/* Clock Types */

typedef UInt16 ControlClockType;
enum {
	kControlClockTypeHourMinute	= 0,
	kControlClockTypeHourMinuteSecond = 1,
	kControlClockTypeMonthDay	= 2,
	kControlClockTypeMonthDayYear = 3
};

/* Clock Flags */
/* 	These flags can be passed into 'value' field on creation of the control.			*/
/* 	Value is set to 0 after control is created.											*/

typedef UInt32 ControlClockFlags;
enum {
	kControlClockFlagStandard	= 0,							/* editable, non-live*/
	kControlClockNoFlags		= 0,
	kControlClockFlagDisplayOnly = 1,							/* add this to become non-editable*/
	kControlClockIsDisplayOnly	= 1,
	kControlClockFlagLive		= 2,							/* automatically shows current time on idle. only valid with display only.*/
	kControlClockIsLive			= 2
};

/* Tagged data supported by clocks */
enum {
	kControlClockLongDateTag	= FOUR_CHAR_CODE('date'),		/* LongDateRec*/
	kControlClockFontStyleTag	= kControlFontStyleTag			/* ControlFontStyleRec*/
};

/*--------------------------------------------------------------------------------------*/
/*	o USER PANE (CDEF 16)																*/
/*--------------------------------------------------------------------------------------*/
/* User Pane proc IDs */
enum {
	kControlUserPaneProc		= 256
};

/* Tagged data supported by user panes */
/* Currently, they are all proc ptrs for doing things like drawing and hit testing, etc. */
enum {
	kControlUserItemDrawProcTag	= FOUR_CHAR_CODE('uidp'),		/* UserItemUPP*/
	kControlUserPaneDrawProcTag	= FOUR_CHAR_CODE('draw'),		/* ControlUserPaneDrawingUPP*/
	kControlUserPaneHitTestProcTag = FOUR_CHAR_CODE('hitt'),	/* ControlUserPaneHitTestUPP*/
	kControlUserPaneTrackingProcTag = FOUR_CHAR_CODE('trak'),	/* ControlUserPaneTrackingUPP*/
	kControlUserPaneIdleProcTag	= FOUR_CHAR_CODE('idle'),		/* ControlUserPaneIdleUPP*/
	kControlUserPaneKeyDownProcTag = FOUR_CHAR_CODE('keyd'),	/* ControlUserPaneKeyDownUPP*/
	kControlUserPaneActivateProcTag = FOUR_CHAR_CODE('acti'),	/* ControlUserPaneActivateUPP*/
	kControlUserPaneFocusProcTag = FOUR_CHAR_CODE('foci'),		/* ControlUserPaneFocusUPP*/
	kControlUserPaneBackgroundProcTag = FOUR_CHAR_CODE('back')	/* ControlUserPaneBackgroundUPP*/
};

typedef CALLBACK_API( void , ControlUserPaneDrawProcPtr )(ControlHandle control, SInt16 part);
typedef CALLBACK_API( ControlPartCode , ControlUserPaneHitTestProcPtr )(ControlHandle control, Point where);
typedef CALLBACK_API( ControlPartCode , ControlUserPaneTrackingProcPtr )(ControlHandle control, Point startPt, ControlActionUPP actionProc);
typedef CALLBACK_API( void , ControlUserPaneIdleProcPtr )(ControlHandle control);
typedef CALLBACK_API( ControlPartCode , ControlUserPaneKeyDownProcPtr )(ControlHandle control, SInt16 keyCode, SInt16 charCode, SInt16 modifiers);
typedef CALLBACK_API( void , ControlUserPaneActivateProcPtr )(ControlHandle control, Boolean activating);
typedef CALLBACK_API( ControlPartCode , ControlUserPaneFocusProcPtr )(ControlHandle control, ControlFocusPart action);
typedef CALLBACK_API( void , ControlUserPaneBackgroundProcPtr )(ControlHandle control, ControlBackgroundPtr info);
typedef STACK_UPP_TYPE(ControlUserPaneDrawProcPtr) 				ControlUserPaneDrawUPP;
typedef STACK_UPP_TYPE(ControlUserPaneHitTestProcPtr) 			ControlUserPaneHitTestUPP;
typedef STACK_UPP_TYPE(ControlUserPaneTrackingProcPtr) 			ControlUserPaneTrackingUPP;
typedef STACK_UPP_TYPE(ControlUserPaneIdleProcPtr) 				ControlUserPaneIdleUPP;
typedef STACK_UPP_TYPE(ControlUserPaneKeyDownProcPtr) 			ControlUserPaneKeyDownUPP;
typedef STACK_UPP_TYPE(ControlUserPaneActivateProcPtr) 			ControlUserPaneActivateUPP;
typedef STACK_UPP_TYPE(ControlUserPaneFocusProcPtr) 			ControlUserPaneFocusUPP;
typedef STACK_UPP_TYPE(ControlUserPaneBackgroundProcPtr) 		ControlUserPaneBackgroundUPP;
#if OPAQUE_UPP_TYPES
	EXTERN_API(ControlUserPaneDrawUPP)
	NewControlUserPaneDrawUPP	   (ControlUserPaneDrawProcPtr userRoutine);

	EXTERN_API(ControlUserPaneHitTestUPP)
	NewControlUserPaneHitTestUPP    (ControlUserPaneHitTestProcPtr userRoutine);

	EXTERN_API(ControlUserPaneTrackingUPP)
	NewControlUserPaneTrackingUPP    (ControlUserPaneTrackingProcPtr userRoutine);

	EXTERN_API(ControlUserPaneIdleUPP)
	NewControlUserPaneIdleUPP	   (ControlUserPaneIdleProcPtr userRoutine);

	EXTERN_API(ControlUserPaneKeyDownUPP)
	NewControlUserPaneKeyDownUPP    (ControlUserPaneKeyDownProcPtr userRoutine);

	EXTERN_API(ControlUserPaneActivateUPP)
	NewControlUserPaneActivateUPP    (ControlUserPaneActivateProcPtr userRoutine);

	EXTERN_API(ControlUserPaneFocusUPP)
	NewControlUserPaneFocusUPP	   (ControlUserPaneFocusProcPtr userRoutine);

	EXTERN_API(ControlUserPaneBackgroundUPP)
	NewControlUserPaneBackgroundUPP    (ControlUserPaneBackgroundProcPtr userRoutine);

	EXTERN_API(void)
	DisposeControlUserPaneDrawUPP    (ControlUserPaneDrawUPP userUPP);

	EXTERN_API(void)
	DisposeControlUserPaneHitTestUPP    (ControlUserPaneHitTestUPP userUPP);

	EXTERN_API(void)
	DisposeControlUserPaneTrackingUPP    (ControlUserPaneTrackingUPP userUPP);

	EXTERN_API(void)
	DisposeControlUserPaneIdleUPP    (ControlUserPaneIdleUPP userUPP);

	EXTERN_API(void)
	DisposeControlUserPaneKeyDownUPP    (ControlUserPaneKeyDownUPP userUPP);

	EXTERN_API(void)
	DisposeControlUserPaneActivateUPP    (ControlUserPaneActivateUPP userUPP);

	EXTERN_API(void)
	DisposeControlUserPaneFocusUPP    (ControlUserPaneFocusUPP userUPP);

	EXTERN_API(void)
	DisposeControlUserPaneBackgroundUPP    (ControlUserPaneBackgroundUPP userUPP);

	EXTERN_API(void)
	InvokeControlUserPaneDrawUPP    (ControlHandle			control,
									SInt16					part,
									ControlUserPaneDrawUPP	userUPP);

	EXTERN_API(ControlPartCode)
	InvokeControlUserPaneHitTestUPP    (ControlHandle		control,
									Point					where,
									ControlUserPaneHitTestUPP userUPP);

	EXTERN_API(ControlPartCode)
	InvokeControlUserPaneTrackingUPP    (ControlHandle		control,
									Point					startPt,
									ControlActionUPP		actionProc,
									ControlUserPaneTrackingUPP userUPP);

	EXTERN_API(void)
	InvokeControlUserPaneIdleUPP    (ControlHandle			control,
									ControlUserPaneIdleUPP	userUPP);

	EXTERN_API(ControlPartCode)
	InvokeControlUserPaneKeyDownUPP    (ControlHandle		control,
									SInt16					keyCode,
									SInt16					charCode,
									SInt16					modifiers,
									ControlUserPaneKeyDownUPP userUPP);

	EXTERN_API(void)
	InvokeControlUserPaneActivateUPP    (ControlHandle		control,
									Boolean					activating,
									ControlUserPaneActivateUPP userUPP);

	EXTERN_API(ControlPartCode)
	InvokeControlUserPaneFocusUPP    (ControlHandle			control,
									ControlFocusPart		action,
									ControlUserPaneFocusUPP	userUPP);

	EXTERN_API(void)
	InvokeControlUserPaneBackgroundUPP    (ControlHandle	control,
									ControlBackgroundPtr	info,
									ControlUserPaneBackgroundUPP userUPP);

#else
	enum { uppControlUserPaneDrawProcInfo = 0x000002C0 }; 			/* pascal no_return_value Func(4_bytes, 2_bytes) */
	enum { uppControlUserPaneHitTestProcInfo = 0x000003E0 }; 		/* pascal 2_bytes Func(4_bytes, 4_bytes) */
	enum { uppControlUserPaneTrackingProcInfo = 0x00000FE0 }; 		/* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes) */
	enum { uppControlUserPaneIdleProcInfo = 0x000000C0 }; 			/* pascal no_return_value Func(4_bytes) */
	enum { uppControlUserPaneKeyDownProcInfo = 0x00002AE0 }; 		/* pascal 2_bytes Func(4_bytes, 2_bytes, 2_bytes, 2_bytes) */
	enum { uppControlUserPaneActivateProcInfo = 0x000001C0 }; 		/* pascal no_return_value Func(4_bytes, 1_byte) */
	enum { uppControlUserPaneFocusProcInfo = 0x000002E0 }; 			/* pascal 2_bytes Func(4_bytes, 2_bytes) */
	enum { uppControlUserPaneBackgroundProcInfo = 0x000003C0 }; 	/* pascal no_return_value Func(4_bytes, 4_bytes) */
	#define NewControlUserPaneDrawUPP(userRoutine) 					(ControlUserPaneDrawUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppControlUserPaneDrawProcInfo, GetCurrentArchitecture())
	#define NewControlUserPaneHitTestUPP(userRoutine) 				(ControlUserPaneHitTestUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppControlUserPaneHitTestProcInfo, GetCurrentArchitecture())
	#define NewControlUserPaneTrackingUPP(userRoutine) 				(ControlUserPaneTrackingUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppControlUserPaneTrackingProcInfo, GetCurrentArchitecture())
	#define NewControlUserPaneIdleUPP(userRoutine) 					(ControlUserPaneIdleUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppControlUserPaneIdleProcInfo, GetCurrentArchitecture())
	#define NewControlUserPaneKeyDownUPP(userRoutine) 				(ControlUserPaneKeyDownUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppControlUserPaneKeyDownProcInfo, GetCurrentArchitecture())
	#define NewControlUserPaneActivateUPP(userRoutine) 				(ControlUserPaneActivateUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppControlUserPaneActivateProcInfo, GetCurrentArchitecture())
	#define NewControlUserPaneFocusUPP(userRoutine) 				(ControlUserPaneFocusUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppControlUserPaneFocusProcInfo, GetCurrentArchitecture())
	#define NewControlUserPaneBackgroundUPP(userRoutine) 			(ControlUserPaneBackgroundUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppControlUserPaneBackgroundProcInfo, GetCurrentArchitecture())
	#define DisposeControlUserPaneDrawUPP(userUPP) 					DisposeRoutineDescriptor(userUPP)
	#define DisposeControlUserPaneHitTestUPP(userUPP) 				DisposeRoutineDescriptor(userUPP)
	#define DisposeControlUserPaneTrackingUPP(userUPP) 				DisposeRoutineDescriptor(userUPP)
	#define DisposeControlUserPaneIdleUPP(userUPP) 					DisposeRoutineDescriptor(userUPP)
	#define DisposeControlUserPaneKeyDownUPP(userUPP) 				DisposeRoutineDescriptor(userUPP)
	#define DisposeControlUserPaneActivateUPP(userUPP) 				DisposeRoutineDescriptor(userUPP)
	#define DisposeControlUserPaneFocusUPP(userUPP) 				DisposeRoutineDescriptor(userUPP)
	#define DisposeControlUserPaneBackgroundUPP(userUPP) 			DisposeRoutineDescriptor(userUPP)
	#define InvokeControlUserPaneDrawUPP(control, part, userUPP) 	CALL_TWO_PARAMETER_UPP((userUPP), uppControlUserPaneDrawProcInfo, (control), (part))
	#define InvokeControlUserPaneHitTestUPP(control, where, userUPP)  (ControlPartCode)CALL_TWO_PARAMETER_UPP((userUPP), uppControlUserPaneHitTestProcInfo, (control), (where))
	#define InvokeControlUserPaneTrackingUPP(control, startPt, actionProc, userUPP)  (ControlPartCode)CALL_THREE_PARAMETER_UPP((userUPP), uppControlUserPaneTrackingProcInfo, (control), (startPt), (actionProc))
	#define InvokeControlUserPaneIdleUPP(control, userUPP) 			CALL_ONE_PARAMETER_UPP((userUPP), uppControlUserPaneIdleProcInfo, (control))
	#define InvokeControlUserPaneKeyDownUPP(control, keyCode, charCode, modifiers, userUPP)  (ControlPartCode)CALL_FOUR_PARAMETER_UPP((userUPP), uppControlUserPaneKeyDownProcInfo, (control), (keyCode), (charCode), (modifiers))
	#define InvokeControlUserPaneActivateUPP(control, activating, userUPP)  CALL_TWO_PARAMETER_UPP((userUPP), uppControlUserPaneActivateProcInfo, (control), (activating))
	#define InvokeControlUserPaneFocusUPP(control, action, userUPP)  (ControlPartCode)CALL_TWO_PARAMETER_UPP((userUPP), uppControlUserPaneFocusProcInfo, (control), (action))
	#define InvokeControlUserPaneBackgroundUPP(control, info, userUPP)  CALL_TWO_PARAMETER_UPP((userUPP), uppControlUserPaneBackgroundProcInfo, (control), (info))
#endif
/* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
#define NewControlUserPaneDrawProc(userRoutine) 				NewControlUserPaneDrawUPP(userRoutine)
#define NewControlUserPaneHitTestProc(userRoutine) 				NewControlUserPaneHitTestUPP(userRoutine)
#define NewControlUserPaneTrackingProc(userRoutine) 			NewControlUserPaneTrackingUPP(userRoutine)
#define NewControlUserPaneIdleProc(userRoutine) 				NewControlUserPaneIdleUPP(userRoutine)
#define NewControlUserPaneKeyDownProc(userRoutine) 				NewControlUserPaneKeyDownUPP(userRoutine)
#define NewControlUserPaneActivateProc(userRoutine) 			NewControlUserPaneActivateUPP(userRoutine)
#define NewControlUserPaneFocusProc(userRoutine) 				NewControlUserPaneFocusUPP(userRoutine)
#define NewControlUserPaneBackgroundProc(userRoutine) 			NewControlUserPaneBackgroundUPP(userRoutine)
#define CallControlUserPaneDrawProc(userRoutine, control, part)	InvokeControlUserPaneDrawUPP(control, part, userRoutine)
#define CallControlUserPaneHitTestProc(userRoutine, control, where) InvokeControlUserPaneHitTestUPP(control, where, userRoutine)
#define CallControlUserPaneTrackingProc(userRoutine, control, startPt, actionProc) InvokeControlUserPaneTrackingUPP(control, startPt, actionProc, userRoutine)
#define CallControlUserPaneIdleProc(userRoutine, control)		InvokeControlUserPaneIdleUPP(control, userRoutine)
#define CallControlUserPaneKeyDownProc(userRoutine, control, keyCode, charCode, modifiers) InvokeControlUserPaneKeyDownUPP(control, keyCode, charCode, modifiers, userRoutine)
#define CallControlUserPaneActivateProc(userRoutine, control, activating) InvokeControlUserPaneActivateUPP(control, activating, userRoutine)
#define CallControlUserPaneFocusProc(userRoutine, control, action) InvokeControlUserPaneFocusUPP(control, action, userRoutine)
#define CallControlUserPaneBackgroundProc(userRoutine, control, info) InvokeControlUserPaneBackgroundUPP(control, info, userRoutine)
/*
  ------------------------------------------------------------------------------------------
  	o EDIT TEXT (CDEF 17)
  ------------------------------------------------------------------------------------------
*/
/* Edit Text proc IDs */
enum {
	kControlEditTextProc		= 272,
	kControlEditTextPasswordProc = 274
};

/* proc IDs available with Appearance 1.1 or later */
enum {
	kControlEditTextInlineInputProc = 276						/* Can't combine with the other variants*/
};

/* Tagged data supported by edit text */
enum {
	kControlEditTextStyleTag	= kControlFontStyleTag,			/* ControlFontStyleRec*/
	kControlEditTextTextTag		= FOUR_CHAR_CODE('text'),		/* Buffer of chars - you supply the buffer*/
	kControlEditTextTEHandleTag	= FOUR_CHAR_CODE('than'),		/* The TEHandle of the text edit record*/
	kControlEditTextKeyFilterTag = kControlKeyFilterTag,
	kControlEditTextSelectionTag = FOUR_CHAR_CODE('sele'),		/* EditTextSelectionRec*/
	kControlEditTextPasswordTag	= FOUR_CHAR_CODE('pass')		/* The clear text password text*/
};

/* tags available with Appearance 1.1 or later */
enum {
	kControlEditTextKeyScriptBehaviorTag = FOUR_CHAR_CODE('kscr'), /* ControlKeyScriptBehavior. Defaults to "PrefersRoman" for password fields,*/
																/*		or "AllowAnyScript" for non-password fields.*/
	kControlEditTextLockedTag	= FOUR_CHAR_CODE('lock'),		/* Boolean. Locking disables editability.*/
	kControlEditTextFixedTextTag = FOUR_CHAR_CODE('ftxt'),		/* Like the normal text tag, but fixes inline input first*/
	kControlEditTextValidationProcTag = FOUR_CHAR_CODE('vali'),	/* ControlEditTextValidationUPP. Called when a key filter can't be: after cut, paste, etc.*/
	kControlEditTextInlinePreUpdateProcTag = FOUR_CHAR_CODE('prup'), /* TSMTEPreUpdateUPP and TSMTEPostUpdateUpp. For use with inline input variant...*/
	kControlEditTextInlinePostUpdateProcTag = FOUR_CHAR_CODE('poup') /* ...The refCon parameter will contain the ControlHandle.*/
};

/* Structure for getting the edit text selection */

struct ControlEditTextSelectionRec {
	SInt16 							selStart;
	SInt16 							selEnd;
};
typedef struct ControlEditTextSelectionRec ControlEditTextSelectionRec;

typedef ControlEditTextSelectionRec *	ControlEditTextSelectionPtr;
typedef CALLBACK_API( void , ControlEditTextValidationProcPtr )(ControlHandle control);
typedef STACK_UPP_TYPE(ControlEditTextValidationProcPtr) 		ControlEditTextValidationUPP;
#if OPAQUE_UPP_TYPES
	EXTERN_API(ControlEditTextValidationUPP)
	NewControlEditTextValidationUPP    (ControlEditTextValidationProcPtr userRoutine);

	EXTERN_API(void)
	DisposeControlEditTextValidationUPP    (ControlEditTextValidationUPP userUPP);

	EXTERN_API(void)
	InvokeControlEditTextValidationUPP    (ControlHandle	control,
									ControlEditTextValidationUPP userUPP);

#else
	enum { uppControlEditTextValidationProcInfo = 0x000000C0 }; 	/* pascal no_return_value Func(4_bytes) */
	#define NewControlEditTextValidationUPP(userRoutine) 			(ControlEditTextValidationUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppControlEditTextValidationProcInfo, GetCurrentArchitecture())
	#define DisposeControlEditTextValidationUPP(userUPP) 			DisposeRoutineDescriptor(userUPP)
	#define InvokeControlEditTextValidationUPP(control, userUPP) 	CALL_ONE_PARAMETER_UPP((userUPP), uppControlEditTextValidationProcInfo, (control))
#endif
/* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
#define NewControlEditTextValidationProc(userRoutine) 			NewControlEditTextValidationUPP(userRoutine)
#define CallControlEditTextValidationProc(userRoutine, control)	InvokeControlEditTextValidationUPP(control, userRoutine)
/*--------------------------------------------------------------------------------------*/
/*	o STATIC TEXT (CDEF 18)																*/
/*--------------------------------------------------------------------------------------*/
/* Static Text proc IDs */
enum {
	kControlStaticTextProc		= 288
};

/* Tagged data supported by static text */
enum {
	kControlStaticTextStyleTag	= kControlFontStyleTag,			/* ControlFontStyleRec*/
	kControlStaticTextTextTag	= FOUR_CHAR_CODE('text'),		/* Copy of text*/
	kControlStaticTextTextHeightTag = FOUR_CHAR_CODE('thei')	/* SInt16*/
};

/* Tags available with appearance 1.1 or later */
enum {
	kControlStaticTextTruncTag	= FOUR_CHAR_CODE('trun')		/* TruncCode (-1 means no truncation)*/
};

/*--------------------------------------------------------------------------------------*/
/*	o PICTURE CONTROL (CDEF 19)															*/
/*--------------------------------------------------------------------------------------*/
/*	Value parameter should contain the ID of the picture you wish to display when		*/
/*	creating controls of this type. If you don't want the control tracked at all, use 	*/
/*	the 'no track' variant.																*/
/* Picture control proc IDs */
enum {
	kControlPictureProc			= 304,
	kControlPictureNoTrackProc	= 305							/* immediately returns kControlPicturePart*/
};

/*--------------------------------------------------------------------------------------*/
/*	o ICON CONTROL (CDEF 20)															*/
/*--------------------------------------------------------------------------------------*/
/*	Value parameter should contain the ID of the ICON or cicn you wish to display when	*/
/*	creating controls of this type. If you don't want the control tracked at all, use 	*/
/*	the 'no track' variant.																*/
/* Icon control proc IDs */
enum {
	kControlIconProc			= 320,
	kControlIconNoTrackProc		= 321,							/* immediately returns kControlIconPart*/
	kControlIconSuiteProc		= 322,
	kControlIconSuiteNoTrackProc = 323							/* immediately returns kControlIconPart*/
};

enum {
																/* icon ref controls may have either an icon, color icon, icon suite, or icon ref.*/
																/* for data other than icon, you must set the data by passing a*/
																/* ControlButtonContentInfo to SetControlData*/
	kControlIconRefProc			= 324,
	kControlIconRefNoTrackProc	= 325							/* immediately returns kControlIconPart*/
};

/* Tagged data supported by icon controls */
enum {
	kControlIconTransformTag	= FOUR_CHAR_CODE('trfm'),		/* IconTransformType*/
	kControlIconAlignmentTag	= FOUR_CHAR_CODE('algn')		/* IconAlignmentType*/
};

/* Tags available with appearance 1.1 or later */
enum {
	kControlIconResourceIDTag	= FOUR_CHAR_CODE('ires'),		/* SInt16 resource ID of icon to use*/
	kControlIconContentTag		= FOUR_CHAR_CODE('cont')		/* accepts a ControlButtonContentInfo*/
};

/*--------------------------------------------------------------------------------------*/
/*	o WINDOW HEADER (CDEF 21)															*/
/*--------------------------------------------------------------------------------------*/
/* Window Header proc IDs */
enum {
	kControlWindowHeaderProc	= 336,							/* normal header*/
	kControlWindowListViewHeaderProc = 337						/* variant for list views - no bottom line*/
};

/*--------------------------------------------------------------------------------------*/
/*	o LIST BOX (CDEF 22)																*/
/*--------------------------------------------------------------------------------------*/
/*	Lists use an auxiliary resource to define their format. The resource type used is 	*/
/*	'ldes' and a definition for it can be found in Appearance.r. The resource ID for 	*/
/*	the ldes is passed in the 'value' parameter when creating the control. You may pass */
/*	zero in value. This tells the List Box control to not use a resource. The list will */
/*	be created with default values, and will use the standard LDEF (0). You can change	*/
/*	the list by getting the list handle. You can set the LDEF to use by using the tag	*/
/*	below (kControlListBoxLDEFTag)														*/
/* List Box proc IDs */
enum {
	kControlListBoxProc			= 352,
	kControlListBoxAutoSizeProc	= 353
};

/* Tagged data supported by list box */
enum {
	kControlListBoxListHandleTag = FOUR_CHAR_CODE('lhan'),		/* ListHandle*/
	kControlListBoxKeyFilterTag	= kControlKeyFilterTag,			/* ControlKeyFilterUPP*/
	kControlListBoxFontStyleTag	= kControlFontStyleTag			/* ControlFontStyleRec*/
};

/* New tags in 1.0.1 or later */
enum {
	kControlListBoxDoubleClickTag = FOUR_CHAR_CODE('dblc'),		/* Boolean. Was last click a double-click?*/
	kControlListBoxLDEFTag		= FOUR_CHAR_CODE('ldef')		/* SInt16. ID of LDEF to use.*/
};

/*--------------------------------------------------------------------------------------*/
/*	o PUSH BUTTON (CDEF 23)																*/
/*--------------------------------------------------------------------------------------*/
/*	The new standard checkbox and radio button controls support a "mixed" value that	*/
/*	indicates that the current setting contains a mixed set of on and off values. The 	*/
/*	control value used to display this indication is defined in Controls.h:				*/
/*																						*/
/*		kControlCheckBoxMixedValue = 2													*/
/*																						*/
/*	Two new variants of the standard pushbutton have been added to the standard control	*/
/*	suite that draw a color icon next to the control title. One variant draws the icon	*/
/*	on the left side, the other draws it on the right side (when the system justifica-	*/
/*	tion is right to left, these are reversed).											*/
/*																						*/
/*	When either of the icon pushbuttons are created, the contrlMax field of the control */
/*	record is used to determine the ID of the 'cicn' resource drawn in the pushbutton.	*/
/*																						*/
/*	In addition, a push button can now be told to draw with a default outline using the	*/
/*	SetControlData routine with the kPushButtonDefaultTag below.						*/
/*																						*/
/*	A push button may also be marked using the kControlPushButtonCancelTag. This has	*/
/*	no visible representation, but does cause the button to play the CancelButton theme	*/
/*	sound instead of the regular pushbutton theme sound when pressed.					*/
/*																						*/
/* Theme Push Button/Check Box/Radio Button proc IDs */
enum {
	kControlPushButtonProc		= 368,
	kControlCheckBoxProc		= 369,
	kControlRadioButtonProc		= 370,
	kControlPushButLeftIconProc	= 374,							/* Standard pushbutton with left-side icon*/
	kControlPushButRightIconProc = 375							/* Standard pushbutton with right-side icon*/
};

/* Variants with Appearance 1.1 or later */
enum {
	kControlCheckBoxAutoToggleProc = 371,
	kControlRadioButtonAutoToggleProc = 372
};

/* Tagged data supported by standard buttons */
enum {
	kControlPushButtonDefaultTag = FOUR_CHAR_CODE('dflt'),		/* default ring flag*/
	kControlPushButtonCancelTag	= FOUR_CHAR_CODE('cncl')		/* cancel button flag (1.1 and later)*/
};

/*--------------------------------------------------------------------------------------*/
/*	o SCROLL BAR (CDEF 24)																*/
/*--------------------------------------------------------------------------------------*/
/*	This is the new Appearance scroll bar.												*/
/*																						*/
/* Theme Scroll Bar proc IDs */
enum {
	kControlScrollBarProc		= 384,							/* normal scroll bar*/
	kControlScrollBarLiveProc	= 386							/* live scrolling variant*/
};

/*--------------------------------------------------------------------------------------*/
/*	o POPUP BUTTON (CDEF 25)															*/
/*--------------------------------------------------------------------------------------*/
/*	This is the new Appearance Popup Button. It takes the same variants and does the 	*/
/*	same overloading as the previous popup menu control. There are some differences:	*/
/*																						*/
/*	Passing in a menu ID of -12345 causes the popup not to try and get the menu from a	*/
/*	resource. Instead, you can build the menu and later stuff the menuhandle field in 	*/
/*	the popup data information.															*/
/*																						*/
/*	You can pass -1 in the Max parameter to have the control calculate the width of the	*/
/*	title on its own instead of guessing and then tweaking to get it right. It adds the	*/
/*	appropriate amount of space between the title and the popup.						*/
/*																						*/
/* Theme Popup Button proc IDs */
enum {
	kControlPopupButtonProc		= 400,
	kControlPopupFixedWidthVariant = 1 << 0,
	kControlPopupVariableWidthVariant = 1 << 1,
	kControlPopupUseAddResMenuVariant = 1 << 2,
	kControlPopupUseWFontVariant = kControlUsesOwningWindowsFontVariant
};

/* These tags are available in 1.0.1 or later of Appearance */
enum {
	kControlPopupButtonMenuHandleTag = FOUR_CHAR_CODE('mhan'),	/* MenuHandle*/
	kControlPopupButtonMenuIDTag = FOUR_CHAR_CODE('mnid')		/* SInt16*/
};

/* These tags are available in 1.1 or later of Appearance */
enum {
	kControlPopupButtonExtraHeightTag = FOUR_CHAR_CODE('exht')	/* SInt16 extra vertical whitespace within the button*/
};


/*--------------------------------------------------------------------------------------*/
/*	o RADIO GROUP (CDEF 26)																*/
/*--------------------------------------------------------------------------------------*/
/*	This control implements a radio group. It is an embedding control and can therefore	*/
/* 	only be used when a control hierarchy is established for its owning window. You		*/
/*	should only embed radio buttons within it. As radio buttons are embedded into it,	*/
/*	the group sets up its value, min, and max to represent the number of embedded items.*/
/*	The current value of the control is the index of the sub-control that is the current*/
/*	'on' radio button. To get the current radio button control handle, you can use the	*/
/*	control manager call GetIndSubControl, passing in the value of the radio group.		*/
/*																						*/
/*	NOTE: This control is only available with Appearance 1.0.1.							*/
/* Radio Group Proc ID */
enum {
	kControlRadioGroupProc		= 416
};

/*--------------------------------------------------------------------------------------*/
/*	o SCROLL TEXT BOX (CDEF 27)															*/
/*--------------------------------------------------------------------------------------*/
/*	This control implements a scrolling box of (non-editable) text.	This is useful for	*/
/*	credits in about boxes, etc.														*/
/*	The standard version of this control has a scroll bar, but the autoscrolling		*/
/*	variant does not. The autoscrolling variant needs two pieces of information to		*/
/*	work: delay (in ticks) before the scrolling starts, and time (in ticks) between		*/
/*	scrolls. It will scroll one pixel at a time, unless changed via SetControlData.		*/
/*																						*/
/*	Parameter					What Goes Here											*/
/*	-------------------			----------------------------------------------------	*/
/*	Value						Resource ID of 'TEXT'/'styl' content.					*/
/*	Min							Scroll start delay (in ticks)						.	*/
/*	Max							Delay (in ticks) between scrolls.						*/
/*																						*/
/*	NOTE: This control is only available with Appearance 1.1.							*/
/* Scroll Text Box Proc IDs */
enum {
	kControlScrollTextBoxProc	= 432,
	kControlScrollTextBoxAutoScrollProc = 433
};

/* Tagged data supported by Scroll Text Box */
enum {
	kControlScrollTextBoxDelayBeforeAutoScrollTag = FOUR_CHAR_CODE('stdl'), /* UInt32 (ticks until autoscrolling starts)*/
	kControlScrollTextBoxDelayBetweenAutoScrollTag = FOUR_CHAR_CODE('scdl'), /* UInt32 (ticks between scrolls)*/
	kControlScrollTextBoxAutoScrollAmountTag = FOUR_CHAR_CODE('samt'), /* UInt16 (pixels per scroll) -- defaults to 1*/
	kControlScrollTextBoxContentsTag = FOUR_CHAR_CODE('tres')	/* SInt16 (resource ID of 'TEXT'/'styl') -- write only!*/
};

#if OLDROUTINENAMES
/*--------------------------------------------------------------------------------------*/
/*	o OLDROUTINENAMES																	*/
/*--------------------------------------------------------------------------------------*/
enum {
	kControlCheckboxUncheckedValue = kControlCheckBoxUncheckedValue,
	kControlCheckboxCheckedValue = kControlCheckBoxCheckedValue,
	kControlCheckboxMixedValue	= kControlCheckBoxMixedValue
};

enum {
	inLabel						= kControlLabelPart,
	inMenu						= kControlMenuPart,
	inTriangle					= kControlTrianglePart,
	inButton					= kControlButtonPart,
	inCheckBox					= kControlCheckBoxPart,
	inUpButton					= kControlUpButtonPart,
	inDownButton				= kControlDownButtonPart,
	inPageUp					= kControlPageUpPart,
	inPageDown					= kControlPageDownPart
};

enum {
	kInLabelControlPart			= kControlLabelPart,
	kInMenuControlPart			= kControlMenuPart,
	kInTriangleControlPart		= kControlTrianglePart,
	kInButtonControlPart		= kControlButtonPart,
	kInCheckBoxControlPart		= kControlCheckBoxPart,
	kInUpButtonControlPart		= kControlUpButtonPart,
	kInDownButtonControlPart	= kControlDownButtonPart,
	kInPageUpControlPart		= kControlPageUpPart,
	kInPageDownControlPart		= kControlPageDownPart
};


#endif  /* OLDROUTINENAMES */





#if PRAGMA_STRUCT_ALIGN
	#pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
	#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
	#pragma pack()
#endif

#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif

#ifdef __cplusplus
}
#endif

#endif /* __CONTROLDEFINITIONS__ */

