/* File: ControlDefinitions.h Contains: Definitions of controls used by Control Mgr Version: Technology: Mac OS 9 Release: QuickTime 6.0.2 Copyright: (c) 1999-2001 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 #endif #ifndef __CONTROLS__ #include #endif #ifndef __LISTS__ #include #endif #ifndef __MACHELP__ #include #endif #ifndef __MENUS__ #include #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__ */