You can use the Control Manager to create and manage controls. An alternative method is to use the Dialog Manager to more easily create and manage controls in dialog boxes and alert boxes. In this latter case, the Dialog Manager works with the Control Manager behind the scenes. The creation and handling of controls in dialog boxes and alert boxes will be addressed at Chapter 8 - Dialogs and Alerts and in the demonstration program associated with Chapter 14 - More on Controls. The creation and handling areas of this chapter are limited to the use of the Control Manager to create and handle controls in document windows.

Every control you create must be associated with a particular window. All the controls for a window are stored in a control list, a handle to which is stored in the controlList field of the window's window structure.

Standard Controls

Available Appearance-Compliant Standard Controls

Definition of the Term "Controls"

Part of the answer to that question has to do with the matter of Appearance-compliance. For example, using the provided separator line "control" to draw separator lines will ensure that those lines are drawn with the correct appearance, in both the activated and deactivated modes, regardless of which Appearance theme has been chosen by the user.

Another part of the answer has to do with the concept of embedding (see below). The window header control, for example, is not just the visual entity it might at first appear to be; it is actually a control in which other controls may be embedded. (As will be seen, the ability to embed other controls is a powerful new feature of some of the new controls.)

Since many of the new controls are not really controls "which the user can manipulate", a more accurate blanket definition might now be "any element of the user interface that is implemented by a control definition function" (see below).

Controls Addressed in This Chapter

The Control Definition Function

Just as a window definition function can describe variations of the same basic window, a CDEF can use a variation code to describe variations of the same control. You specify a particular control with a control definition ID, which is an integer containing the resource ID of the in the upper 12 bits and the variation code in the lower four bits.

The control definition ID is arrived at by multiplying the resource ID by 16 and adding the variation code. The following shows the control definition IDs for the standard controls and variants addressed in this chapter and its associated demonstration programs, together with the derivation of those IDs. (Those variants introduced with Mac OS 8.5 are shown in dark blue.)

Note that the one CDEF caters for both horizontal and vertical scroll bars. The CDEF determines whether a scroll bar is vertical or horizontal from the rectangle you specify when you create the control.

The Basic Controls, Primary Group Boxes (Text Title Variant), and User Panes

SetControlValue may also be used to place a dash in the box to indicate that the control is in the mixed state (see Fig 1). The mixed state is a special state which indicates that a selected range of items has some in the on state and some in the off state. For example, a text formatting checkbox for bold text would be in the mixed state if a text selection contained both bold and non-bold text.

Auto-Toggling Variant

Radio Buttons

A group of radio buttons must comprise at least two radio buttons. Each group must have a label which identifies the kind of choices the group offers and each button must have a title identifying what the radio button does. If you need to display more than seven items, or if the items change as the context changes, you should use a pop-up menu button instead.

Non-Auto-Toggling Variant

• Set that control to the on state and place a black dot in its circle (see Fig 1).

• Set the previously "on" button in the group to the off state and remove the black dot from its circle.

Auto-Toggling Variant

Scroll Bars

As previously stated, the CDEF for scroll bars supports two variants. The only difference between the two variants is that one supports live feedback and the other does not. In the case of scroll bars, live feedback (a generic term) may be used to perform live scrolling of a document in a window. Live scrolling means that, when the user attempts to drag the scroll box, the scroll box moves and the document scrolls as the user moves the mouse. (Without live scrolling, only a ghosted image of the scroll box moves. In addition, the document is only scrolled, and the scroll box proper is only redrawn at its new location, when the user releases the mouse button.)

Scroll Arrows and Gray Area

When the gray area is clicked above the scroll box, your application should move the document up so that the bottom line of the previous view is at the top of the new view, and it should move the scroll box accordingly. A similar, but downward movement, should occur when the user clicks in the gray area below the scroll box.

Scroll Box

Live Feedback Variant Used. When the live feedback variant is being used, and when the user drags the scroll box, the Control Manager continually redraws the scroll box, and continually returns the control's position (that is, its value) as the scroll box moves. Once again, your application uses this value to display the appropriate portion of the document.

Proportional Scroll Boxes

Under Mac OS 8.5 and later, if the user selects Smart Scrolling on in the Options tab in the Appearance control panel, your application's scroll boxes will appear as proportional scroll boxes provided that you pass the size of the view area, in whatever units the scroll bar uses, to the function SetControlViewSize. The system automatically handles resizing the scroll box once your application supplies this information.

The following functions, introduced with Mac OS 8.5, are relevant to proportional scroll boxes:

Pop-Up Menu Buttons

The primary group box is an embedder control (see below), meaning that you can embed other controls, such as radio buttons, checkboxes, and pop-up menu buttons, within it.

User Panes

• Like the primary group box, it can be used as an embedder control, that is, other controls may be embedded within it.

• It provides a way to hook in application-defined functions, known as user pane functions, which perform actions such as drawing, hit testing, etc.

Activating and Deactivating Controls Other Than Scroll Bars

• They are not relevant to the current context.

• The window in which they reside is not the active window.

Activating and Deactivating Scroll Bars

ShowControl may be used to show a control. ShowControl makes the control visible and immediately draws the control within its window without using your window's standard updating mechanism.

SetControlVisibility may be used to both hide and show a control. With regard to showing a control, this function differs from ShowControl in that the option is available to "show" the control without redrawing it immediately.

Your application can ascertain whether a control is currently hidden or visible using IsControlVisible.

Visual Feedback From the Basic Controls

• Displaying push buttons, checkboxes and radio buttons in their pressed mode.

• Displaying and highlighting the items in pop-up menu buttons.

• Highlighting the scroll arrows in scroll bars.

• Moving the scroll box (live feedback variant of the scroll bar CDEF being used) or moving a ghosted image of the scroll box (live feedback variant not being used) when the user drags it.

Embedding Controls

Once you have created a root control, new controls will be automatically embedded in the root control when they are created. One advantage of such embedding is that, when you wish to activate and deactivate all of the window's controls on window activation and deactivation, you can do so by simply activating and deactivating the root control. (If the root control did not exist, you would have to activate and deactivate all of the window's controls individually.) You can also hide and show all of the window's control by simply hiding and showing the root control.

Other Embedders

EmbedControl may be used to embed a control in another (embedder) control. However, where the control to be embedded is visually contained by the embedder, as is the case with the radio buttons in Fig 3, AutoEmbedControl would be more appropriate.

Other Advantages of Embedding

In the example at Fig 3, assume that there is no embedding hierarchy and that the radio buttons are created after the group box. This means that the group box will be drawn after the radio buttons, thus obscuring the radio buttons. An embedding hierarchy, however, enforces drawing order by drawing the embedding control before its embedded controls regardless of which is created first.

Hit Testing

For example, assume that the radio button labelled White at Fig 3 has been separately deactivated by the application. When the primary group box is deactivated, the two remaining radio buttons will also be deactivated. When the primary group box is again enabled, the Control Manager remembers that the radio button labelled white was previously deactivated, and ensures that it remains in that mode.

Getting and Setting Control Data

Each piece of information that a particular CDEF allows access to is referenced by a tag, which is a constant that is meaningful to the CDEF and which represents the data in question. Each tagged piece of data can be of any data type, such as a menu handle or a structure.

Control data tag constants are passed in the third parameter of the getter and setter functions SetControlData and GetControlData. The control data tag constants relevant to the basic controls are as follows:

The Control Structure

     struct ControlRecord 
     {
       ControlHandle     nextControl;   // Next Control.
       WindowPtr         contrlOwner;   // Control's window.
       Rect              contrlRect;    // Rectangle.
       UInt8             contrlVis;     // 255 if visible, else 0.
       UInt8             contrlHilite;  // Highlight state.
       SInt16            contrlValue;   // Current setting.
       SInt16            contrlMin;     // Minimum Setting.
       SInt16            contrlMax;     // Maximum setting.
       Handle            contrlDefProc; // Control definition function.
       Handle            contrlData;    // Data used by contrlDefProc.
       ControlActionUPP  contrlAction;  // Action function.
       SInt32            contrlRfCon;   // Reference constant.
       Str255            contrlTitle;   // Title.
     };
     typedef struct ControlRecord ControlRecord;
     typedef ControlRecord *ControlPtr;
     typedef ControlPtr *ControlHandle;

The following describes the main fields of the 'CNTL' resource:

Values For Controls

Note that the title of each of the three value fields is somewhat of a misnomer in the case of the pop-up menu button.

Creating 'CNTL' Resources Using Resorcerer

Creating Controls

If the 'CNTL' resource specifies that a control is initially visible, the Control Manager uses the CDEF to draw the control. (The Control Manager draws the control immediately and does not wait for the window updating mechanism.) If the 'CNTL' resource specifies that the control is to be initially invisible, ShowControl may be used to draw the control when required.

Note that when you use the Dialog Manager to implement push buttons, radio buttons, checkboxes or pop-up menu buttons in alert boxes or dialog boxes, Dialog Manager functions automatically use Control Manager functions to create the controls for you.

Creating Scroll Bars

After you create the window, use GetNewControl to create the scroll bar. Then use MoveControl, SizeControl, SetControlMaximum and SetControlValue to adjust the size, location and value settings. (For example, for a window displaying a text document, you would typically calculate the number of lines of text and set the vertical scroll bar's maximum value according to the line count and the window's current height. You would set the control's value according to the part of the document to be initially displayed.) Finally, use ShowControl to display the control bar.

Most applications allow the user to change the size of windows, add information to the document and remove information from the document. It is therefore necessary, in your window handling code, to calculate a changing maximum setting based on the document's current size and its window's current size. For new documents which have no content to scroll, assign an initial value of 0 as the maximum setting (which will, as previously stated, make the scroll bars inactive). Thereafter, your window-handling code should set and maintain the maximum setting.

By convention, a scroll bar for a document window is 16 pixels wide; accordingly, there should be a sixteen-pixel difference between the left and right coordinates of a vertical scroll bar's rectangle and between the top and bottom coordinates of a horizontal scroll bar. (If you do not specify a 16-pixel width, the Control Manager scales the scroll bar to fit the width you specify.) A standard scroll bar for a document window should be at least 48 pixels long to allow room for the scroll arrows and scroll box.

The Control Manager draws one-pixel lines for the rectangle enclosing the scroll bar. As shown at Fig 6, the outside lines of the scroll bar should overlap the inside lines of the window frame.

The following calculations determine the rectangle for a vertical scroll bar for a document window:

Do not include the title bar area in these calculations.

The following calculations determine the rectangle for a horizontal scroll bar for a document window.

The top coordinate of a vertical scroll bar and the left coordinate of a horizontal scroll bar is -1 unless your application uses part of the window's typical scroll bar area for displaying information or specifying additional controls.

Just as the maximum settings change when the user resizes a document's window, so too do the scroll bar's coordinate locations change when the user resizes the window. The initial maximum settings and location, as specified in the 'CNTL' resource, must therefore be changed dynamically by the application as required. Typically, this is achieved by storing handles to each scroll bar in an application-defined document structure associated with the window and then using Control Manager functions to change control settings.

Scroll Bars in Utility Windows. You can also use scroll bars in utility windows (see Fig 7). Size boxes in utility windows are 11-by-11 pixels, and the standard Appearance-compliant scroll bar can be made to fit into this space.

Pop-up Menu Buttons

Pop-up Menu Button Title Width

Menu Width Adjustment

To set the font of a control's title, you pass a pointer to a control font style structure in the inStyle parameter of the function SetControlFontStyle.

Control Font Style Structure

     struct ControlFontStyleRec 
     {
       SInt16    flags;
       SInt16    font;
       SInt16    size;
       SInt16    style;
       SInt16    mode;
       SInt16    just;
       RGBColor  foreColor;
       RGBColor  backColor;
     };
     typedef struct ControlFontStyleRec ControlFontStyleRec;
     typedef ControlFontStyleRec *ControlFontStylePtr;

Control Font Style Flag Constants

Meta Font Constants

Another advantage of using these meta font constants is that you can be sure of getting the correct font on a Macintosh using a different script system, such as kanji.

Updating, Moving, and Removing Controls

Note that when you use the Dialog Manager to implement push buttons, radio buttons, checkboxes or pop-up menu buttons in alert boxes or dialog boxes, Dialog Manager functions automatically use Control Manager functions to update the controls for you.

Moving Controls

• Use FindWindow to determine the window in which the mouse-down event occurred.

• If the mouse-down event occurred in the content region of the active window, use FindControl to determine whether the event occurred in a control and, if so, which control.

• Call TrackControl or HandleControlClick to handle user interaction with the control as long as the user holds the mouse button down. The actionProc parameter passed to TrackControl, or the inAction parameter passed to HandleControlClick, should be as follows:

  • NULL for push buttons, checkboxes and radio buttons.

  • For scroll arrows and gray areas of scroll bars, a pointer which invokes an application-defined action function which, in turn, causes the document to scroll as long as the user holds the mouse button down.

  • For the scroll box of scroll bars:

    • NULL if the non-live-feedback variant is being used.

    • If the live-feedback variant is being used, a pointer which invokes an application-defined action function which, in turn, causes the document to scroll while the scroll box is being dragged.

  • (ControlActionUPP) -1 for pop-up menu buttons. This causes TrackControl and HandleControlClick to use the action function defined within the pop-up CDEF, a pointer to which is stored in the contrlAction field of the control structure.

  For source code that only needs to be compiled as 680x0 code, the pointer which invokes the application-defined action function need only be a procedure pointer, that is, the address of the action function. For source code that needs to be compiled as PowerPC code, or as both PowerPC code and 680x0 code, the pointer must be a Universal Procedure Pointer (UPP).

  Note that, as an alternative to passing these pointers in the actionProc parameter of TrackControl, or the inAction parameter of HandleControlClick, you can preset the action function by passing the pointer in the actionProc parameter of SetControlAction. (Ordinarily, you would call SetControlAction immediately after the control is created. SetControlAction stores the pointer in the contrlAction field of the control structure.) In this case, you must pass (ControlActionUPP) -1 in the actionProc and inAction parameters of TrackControl and HandleControlClick.

• When TrackControl or HandleControlClick reports that the user has released the mouse button with the cursor in a control, respond appropriately, that is:

  • Perform the task identified by the push button title if the cursor is over a push button.

  • Toggle the value of the checkbox when the cursor is over a checkbox. (The Control Manager then redraws or removes the checkmark, as appropriate.)

  • Turn on the radio button, and turn off all other radio buttons in the group, when the cursor is over an active radio button.

  • Show more of the document in the direction of the scroll arrow when the cursor is over the scroll arrow or gray area of a scroll bar, and move the scroll box accordingly.

  • If the non-live-feedback scroll bar variant is being used, and when the cursor is over the scroll box, determine where the user has dragged the scroll box, and then display the corresponding portion of the document.

  • Use the new setting chosen by the user when the cursor is over a pop-up menu button.

A control part code is an integer from 1 to 255. Part codes are assigned to a control by its CDEF. The CDEFs for the basic controls define the following part codes:

Tracking the Cursor in a Control

You can also use an action function to undertake additional actions as long as the user holds the mouse button down. Typically, action functions are used to continuously scroll the window's contents while the cursor is on a scroll arrow or gray area of a scroll bar, or in the scroll box of a live-feedback scroll bar. (As previously stated, you pass a pointer to this action function in the actionProc parameter of TrackControl or the inAction parameter of HandleControlClick).

TrackControl and HandleControlClick return the control's control part code if the user releases the mouse button while the cursor is still inside the control part, or kControlNoPart (0) if the cursor is outside the control part when the button is released. Your application should then respond appropriately.

Determining and Changing Control Settings

Applications must adjust some controls in response to events other than mouse events in the controls themselves. For example, when the user resizes a window, your application must use MoveControl and SizeControl to move and resize the scroll bars appropriately.

Your application can use the following functions to get and set control values. (Those appearing on in dark blue were introduced with Mac OS 8.5.)

Moving and Resizing Scroll Bars

• Resize the window.

• Use HideControl to make each scroll bar invisible.

• Use MoveControl to move the scroll bars to the appropriate edges of the window.

• Use SizeControl to lengthen or shorten each scroll bar as appropriate.

• Recalculate the maximum settings for the scroll bars and use SetControlMaximum and SetControlValue to update the settings and to redraw the scroll boxes appropriately.

• Use ShowControl to make each scroll bar visible at its new location.

Distance and Direction to Scroll

• When the user drags the scroll box to a new location, your application should scroll a corresponding distance in the document.

• When the user clicks on a scroll arrow, your application must determine an appropriate amount to scroll. Word processor applications typically scroll one line of text vertically, and horizontally by the average character width. Graphics applications typically scroll to display an entire object.

• When the user clicks in the gray area, your application must determine an appropriate amount to scroll. Typically, applications scroll by a distance of just less than the height or width of the window.

Consider the left-top of Fig 10, which illustrates the situation where the user has just opened an existing document. The document consists of 35 lines of monostyled text and the line height throughout is 10 pixels. The document is, therefore, 350 pixels long. When the user opens the document, the window origin is identical to the upper-left point of the document's space, that is, both are at (0,0).

In this example, the window displays 15 lines of text, which amounts to 150 pixels. Hence the maximum setting for the scroll bar is equivalent to 200 pixels down in the document. (As shown at Fig 9, a vertical scroll bar's maximum setting equates to the length of the document minus the height of the window.)

Now assume that the user drags the scroll box about halfway down the vertical scroll bar. Because the user wishes to scroll down, your application must move the text of the document up. Moving a document up in response to a user's request to scroll down requires a negative scrolling value.

Your application, using GetControlValue, determines that the scroll bar's control value is 100 and that it must therefore move the document up by 100 pixels. It then uses ScrollRect to shift the bits displayed in the window by a distance of -100 pixels (that is, 10 lines of text). As shown at the top-right of Fig 10, five lines from the bottom of the previous window display now appear at the top of the window. Your application adds the rest of the window to an update region for later updating.

Note that ScrollRect does not change the coordinate system of the window; instead it moves the bits in the window to new coordinates that are still in the window's local coordinate system. (For the purposes of updating the window, you can think of this as changing the coordinates of the entire document, as is illustrated at the right-top of Fig 10.) In terms of the window's local coordinate system, then, the upper left corner of the document is now at (-100,0).

To facilitate updating of the window, SetOrigin must now be used to change the local coordinate system of the window so that the application can treat the upper left corner of the document as again lying at (0,0). This restoration of the document's original coordinate space makes it easier for the application to determine which lines of the document to draw in the update region of the window. (See bottom-left of Fig 10.)

Your application should now update the window by drawing lines 16 to 24, which it stores in its document structure as beginning at (160,0) and ending at (250,0).

Finally, because the Window and Control Managers always assume that the window's upper-left point is at (0,0) when they draw in the window, the window origin cannot be left at (100,0). Accordingly, the application must use SetOrigin to reset it to (0,0) after performing its own drawing, (See bottom-right of Fig 10.)

To summarise:

• The user dragged the scroll box about half way down the vertical scroll bar. The application determined that this distance amounted to a scroll of -100 pixels.

• The application passed this distance to ScrollRect, which shifted the bits in the window 100 pixels upwards and created an update region in the vacated area of the window.

• The application passed the vertical scroll bar's current setting (100) in a parameter to SetOrigin so that the document's local coordinates were used when the update region of the window was redrawn. This changed the window's origin to (100,0).

• The application drew the text in the update region.

• The application reset the window's origin to (0,0)

As an alternative to this approach, your application can leave the upper-left corner of the window at (0,0) and instead offset the items in your document, using OffsetRect, by an amount equal to the scroll bar's settings.

Scrolling a TextEdit Document and Scrolling Using the List Manager

For scrolling lists of graphic or textual information, your application can use the List Manager to implement scroll bars. (See Chapter 20 - Lists and Custom List Definition Functions.)

Main Control Manager Constants, Data Types and Functions Relevant to the Basic Controls, Primary Group Box (Text Title Variant) and User Panes

• The constants, data types, and functions introduced with Mac OS 8 and the Appearance Manager are shown in light blue.

• The constants and functions introduced with Mac OS 8.5 are shown in dark blue.

• Those older constants, data types and functions affected by the introduction of Mac OS 8 and the Appearance Manager, but which may still be used in certain circumstances, are shown in red.

  
kControlPushButtonProc            = 368
kControlPushButLeftIconProc       = 374
kControlPushButRightIconProc      = 375
kControlCheckBoxProc              = 369
kControlCheckBoxAutoToggleProc    = 371
kControlRadioButtonProc           = 370
kControlRadioButtonAutoToggleProc = 372
kControlScrollBarProc             = 384
kControlScrollBarLiveProc         = 386
kControlPopupButtonProc           = 400
kControlGroupBoxTextTitleProc     = 160
kControlUserPaneProc              = 256

kControlPopupFixedWidthVariant     = 1 << 0
kControlPopupVariableWidthVariant  = 1 << 1
kControlPopupUseAddResMenuVariant  = 1 << 2
kControlPopupUseWFontVariant       = 1 << 3

popupTitleBold        = 1 << 8
popupTitleItalic      = 1 << 9
popupTitleUnderline   = 1 << 10
popupTitleOutline     = 1 << 11
popupTitleShadow      = 1 << 12
popupTitleCondense    = 1 << 13
popupTitleExtend      = 1 << 14
popupTitleNoStyle     = 1 << 15

kControlNoVariant                     = 0
kControlUsesOwningWindowsFontVariant  = 1 << 3

kControlNoPart          = 0
kControlLabelPart       = 1
kControlMenuPart        = 2
kControlButtonPart      = 10
kControlCheckBoxPart    = 11
kControlRadioButtonPart = 11
kControlUpButtonPart    = 20
kControlDownButtonPart  = 21
kControlPageUpPart      = 22
kControlPageDownPart    = 23
kControlIndicatorPart   = 129
kControlDisabledPart    = 254
kControlInactivePart    = 255

kControlCheckBoxUncheckedValue  = 0,
kControlCheckBoxCheckedValue    = 1,
kControlCheckBoxMixedValue      = 2

kControlRadioButtonUncheckedValue  = 0,
kControlRadioButtonCheckedValue    = 1,
kControlRadioButtonMixedValue      = 2

kControlPushButtonDefaultTag      = FOUR_CHAR_CODE('dflt')
kControlPushButtonCancelTag       = FOUR_CHAR_CODE('cncl')
kControlPopupButtonMenuHandleTag  = FOUR_CHAR_CODE('mhan')
kControlPopupButtonMenuIDTag      = FOUR_CHAR_CODE('mnid')
kControlPopupButtonExtraHeightTag = FOUR_CHAR_CODE('exht')
kControlGroupBoxTitleRectTag      = FOUR_CHAR_CODE('trec')

kControlUseFontMask       = 0x0001
kControlUseFaceMask       = 0x0002
kControlUseSizeMask       = 0x0004
kControlUseForeColorMask  = 0x0008
kControlUseBackColorMask  = 0x0010
kControlUseModeMask       = 0x0020
kControlUseJustMask       = 0x0040
kControlUseAllMask        = 0x00FF
kControlAddFontSizeMask   = 0x0100
kControlAddToMetaFontMask = 0x0200

kControlFontBigSystemFont        = -1
kControlFontSmallSystemFont      = -2
kControlFontSmallBoldSystemFont  = -3

typedef SInt16 ControlPartCode;

struct ControlRecord 
{
  ControlHandle     nextControl;   // Next Control.
  WindowPtr         contrlOwner;   // Control's window.
  Rect              contrlRect;    // Rectangle.
  UInt8             contrlVis;     // 255 if visible, else 0.
  UInt8             contrlHilite;  // Highlight state.
  SInt16            contrlValue;   // Current setting.
  SInt16            contrlMin;     // Minimum Setting.
  SInt16            contrlMax;     // Maximum setting.
  Handle            contrlDefProc; // Control definition function.
  Handle            contrlData;    // Data used by contrlDefProc.
  ControlActionUPP  contrlAction;  // Action function.
  SInt32            contrlRfCon;   // Reference constant.
  Str255            contrlTitle;   // Title.
};
typedef struct ControlRecord ControlRecord;
typedef ControlRecord *ControlPtr;
typedef ControlPtr *ControlHandle;

struct ControlFontStyleRec 
{
  SInt16    flags;
  SInt16    font;
  SInt16    size;
  SInt16    style;
  SInt16    mode;
  SInt16    just;
  RGBColor  foreColor;
  RGBColor  backColor;
};
typedef struct ControlFontStyleRec ControlFontStyleRec;
typedef ControlFontStyleRec *ControlFontStylePtr;

ControlHandle  NewControl(WindowPtr owningWindow,const Rect *boundsRect,
               ConstStr255Param title,Boolean initiallyVisible,SInt16 initialValue,
               SInt16 minimumValue,SInt16 maximumValue,SInt16 procID,
               SInt32 controlReference);
ControlHandle  GetNewControl(SInt16 controlID,WindowPtr owner);
void           DisposeControl(ControlHandle theControl);
void           KillControls(WindowPtr theWindow);

OSErr  CreateRootControl(WindowPtr inWindow,ControlHandle * outControl);
OSErr  GetRootControl(WindowPtr inWindow,ControlHandle * outControl);
OSErr  EmbedControl(ControlHandle inControl,ControlHandle inContainer);
OSErr  AutoEmbedControl(ControlHandle inControl,WindowPtr inWindow);
OSErr  CountSubControl(ControlHandle inControl,SInt16 * outNumChildren);
OSErr  GetIndexedSubControl(ControlHandle inControl,SInt16 inIndex,
       ControlHandle * outSubControl);
OSErr  GetSuperControl(ControlHandle inControl,ControlHandle * outParent);
OSErr  SetControlSupervisor(ControlHandle inControl,ControlHandle inBoss);
OSErr  DumpControlHierarchy(WindowPtr inWindow,const FSSpec *inDumpFile);

void     MoveControl(ControlHandle theControl,SInt16 h,SInt16 v);
void     SizeControl(ControlHandle theControl,SInt16 w,SInt16 h);
void     UpdateControls(WindowPtr theWindow,RgnHandle updateRgn);
void     DrawControls(WindowPtr theWindow);
void     DrawOneControl(ControlHandle theControl);
void     DrawControlInCurrentPort(ControlHandle inControl);
Boolean  IsControlActive (ControlHandle inControl);
OSErr    ActivateControl (ControlHandle inControl);
OSErr    DeactivateControl(ControlHandle inControl);
Boolean  IsControlVisible(ControlHandle inControl);
void     HideControl(ControlHandle theControl);
void     ShowControl(ControlHandle theControl);
OSErr    SetControlVisibility (ControlHandle inControl,Boolean inIsVisible,
         Boolean inDoDraw);
OSErr    SendControlMessage(ControlHandle inControl,SInt16 inMessage,SInt32 inParam);
void     DragControl(ControlHandle theControl,Point startPt,const Rect *limitRect,
         const Rect *slopRect,DragConstraint axis);
void     HiliteControl(ControlHandle theControl,ControlPartCode hiliteState);
SInt32   GetControlViewSize(ControlHandle theControl);
Void     SetControlViewSize(ControlHandle theControl,SInt32 newViewSize);

ControlPartCode  FindControl(Point thePoint,WindowPtr theWindow,
                 ControlHandle *theControl);
ControlHandle    FindControlUnderMouse(Point inWhere,WindowPtr inWindow,SInt16 *outPart); 
ControlPartCode  TrackControl(ControlHandle theControl,Point thePoint,
                 ControlActionUPP  actionProc);
Sint16           HandleControlClick(ControlHandle inControl,Point inWhere,
                 SInt16 inModifiers,  ControlActionUPP nAction);
ControlPartCode  TestControl(ControlHandle theControl, PointthePt);

SInt16            GetControlValue(ControlHandle theControl);
void              SetControlValue(ControlHandle theControl,SInt16 theValue);
SInt16            GetControlMinimum(ControlHandle theControl);
void              SetControlMinimum(ControlHandle theControl,SInt16 newMinimum);
SInt16            GetControlMaximum(ControlHandle theControl);
void              SetControlMaximum(ControlHandle theControl,SInt16 newMaximum);
SInt32            GetControl32BitValue(ControlHandle theControl);
void              SetControl32BitValue(ControlHandle theControl,SInt32 newValue);
SInt32            GetControl32BitMaximum(ControlHandle theControl);
Void              SetControl32BitMaximum(ControlHandle theControl,SInt32 newMaximum);
SInt32            GetControl32BitMinimum(ControlHandle theControl);
Void              SetControl32BitMinimum(ControlHandle theControl,SInt32 newMinimum);
void              GetControlTitle(ControlHandle theControl,Str255 title);
void              SetControlTitle(ControlHandle theControl,ConstStr255Param title);
SInt32            GetControlReference(ControlHandle theControl);
void              SetControlReference(ControlHandle theControl,SInt32 data);
ControlActionUPP  GetControlAction(ControlHandle theControl);
void              SetControlAction(ControlHandle theControl,
                  ControlActionUPP actionProc);
SInt16            GetControlVariant(ControlHandle theControl);
OSErr             SetControlData(ControlHandle inControl,ControlPartCode inPart,
                  ResType inTagName,Size inSize,Ptr inData);
OSErr             GetControlData (ControlHandle inControl,ControlPartCode inPart,
                  ResType inTagName,Size inBufferSize,Ptr inBuffer,
                  Size *outActualSize);
OSErr             GetControlDataSize(ControlHandle inControl,ControlPartCode inPart,
                  ResType inTagName,Size *outMaxSize);
OSErr             SetControlVisibility(ControlHandle inControl,Boolean inIsVisible,
                  Boolean inDoDraw);

OSErr   SetControlFontStyle  (ControlHandle inControl,
        const ControlFontStyleRec *inStyle)