Dialogs.h

Go to the documentation of this file.

 
#ifndef __DIALOGS__
#define __DIALOGS__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
 
#ifndef __EVENTS__
#include <Events.h>
#endif
 
#ifndef __MACWINDOWS__
#include <MacWindows.h>
#endif
 
#ifndef __TEXTEDIT__
#include <TextEdit.h>
#endif
 
#ifndef __CONTROLS__
#include <Controls.h>
#endif
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#ifndef __CARBONEVENTS__
#include <CarbonEvents.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
 
  enum
  {
    kControlDialogItem = 4,
    kButtonDialogItem = kControlDialogItem | 0,
    kCheckBoxDialogItem = kControlDialogItem | 1,
    kRadioButtonDialogItem = kControlDialogItem | 2,
    kResourceControlDialogItem = kControlDialogItem | 3,
    kStaticTextDialogItem = 8,
    kEditTextDialogItem = 16,
    kIconDialogItem = 32,
    kPictureDialogItem = 64,
    kUserDialogItem = 0,
    kHelpDialogItem = 1,
    kItemDisableBit = 128
  };
 
  enum
  {
    ctrlItem = 4,
    btnCtrl = 0,
    chkCtrl = 1,
    radCtrl = 2,
    resCtrl = 3,
    statText = 8,
    editText = 16,
    iconItem = 32,
    picItem = 64,
    userItem = 0,
    itemDisable = 128
  };
 
  enum
  {
    kStdOkItemIndex = 1,
    kStdCancelItemIndex = 2, 
    ok = kStdOkItemIndex,
    cancel = kStdCancelItemIndex
  };
 
  enum
  {
    kStopIcon = 0,
    kNoteIcon = 1,
    kCautionIcon = 2, 
    stopIcon = kStopIcon,
    noteIcon = kNoteIcon,
    cautionIcon = kCautionIcon
  };
 
#if OLDROUTINENAMES
  enum
  {
    kOkItemIndex = 1,
    kCancelItemIndex = 2
  };
 
#endif 
  typedef SInt16 DITLMethod;
  enum
  {
    overlayDITL = 0,
    appendDITLRight = 1,
    appendDITLBottom = 2
  };
 
  typedef SInt16 StageList;
  typedef DialogPtr DialogRef;
#if !OPAQUE_TOOLBOX_STRUCTS
  struct DialogRecord
  {
    WindowRecord window; 
    Handle items;        
    TEHandle textH;      
    SInt16 editField;    
    SInt16 editOpen;     
    SInt16 aDefItem;     
  };
  typedef struct DialogRecord DialogRecord;
  typedef DialogRecord *DialogPeek;
#endif 
  struct DialogTemplate
  {
    Rect boundsRect;
    SInt16 procID;
    Boolean visible;
    Boolean filler1;
    Boolean goAwayFlag;
    Boolean filler2;
    SInt32 refCon;
    SInt16 itemsID;
    Str255 title;
  };
  typedef struct DialogTemplate DialogTemplate;
  typedef DialogTemplate *DialogTPtr;
  typedef DialogTPtr *DialogTHndl;
  struct AlertTemplate
  {
    Rect boundsRect;
    SInt16 itemsID;
    StageList stages;
  };
  typedef struct AlertTemplate AlertTemplate;
  typedef AlertTemplate *AlertTPtr;
  typedef AlertTPtr *AlertTHndl;
  typedef SInt16 DialogItemIndexZeroBased;
  typedef SInt16 DialogItemIndex;
  typedef SInt16 DialogItemType;
  typedef CALLBACK_API(void, SoundProcPtr)(SInt16 soundNumber);
  typedef CALLBACK_API(Boolean, ModalFilterProcPtr)(DialogRef theDialog,
                                                    EventRecord *theEvent,
                                                    DialogItemIndex *itemHit);
  typedef CALLBACK_API(Boolean, ModalFilterYDProcPtr)(DialogRef theDialog,
                                                      EventRecord *theEvent,
                                                      short *itemHit,
                                                      void *yourDataPtr);
  typedef CALLBACK_API(void, UserItemProcPtr)(DialogRef theDialog,
                                              DialogItemIndex itemNo);
  typedef STACK_UPP_TYPE(SoundProcPtr) SoundUPP;
  typedef STACK_UPP_TYPE(ModalFilterProcPtr) ModalFilterUPP;
  typedef STACK_UPP_TYPE(ModalFilterYDProcPtr) ModalFilterYDUPP;
  typedef STACK_UPP_TYPE(UserItemProcPtr) UserItemUPP;
#if CALL_NOT_IN_CARBON
  SoundUPP
  NewSoundUPP(SoundProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppSoundProcInfo = 0x00000080
  }; 
#ifdef __cplusplus
  inline SoundUPP NewSoundUPP(SoundProcPtr userRoutine)
  {
    return (SoundUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppSoundProcInfo, GetCurrentArchitecture());
  }
#else
#define NewSoundUPP(userRoutine)                                            \
  (SoundUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppSoundProcInfo, \
                                  GetCurrentArchitecture())
#endif
#endif
 
#endif 
  ModalFilterUPP
  NewModalFilterUPP(ModalFilterProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppModalFilterProcInfo = 0x00000FD0
  }; 
#ifdef __cplusplus
  inline ModalFilterUPP NewModalFilterUPP(ModalFilterProcPtr userRoutine)
  {
    return (ModalFilterUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppModalFilterProcInfo, GetCurrentArchitecture());
  }
#else
#define NewModalFilterUPP(userRoutine)                                     \
  (ModalFilterUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppModalFilterProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  ModalFilterYDUPP
  NewModalFilterYDUPP(ModalFilterYDProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppModalFilterYDProcInfo = 0x00003FD0
  }; 
#ifdef __cplusplus
  inline ModalFilterYDUPP NewModalFilterYDUPP(ModalFilterYDProcPtr userRoutine)
  {
    return (ModalFilterYDUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                  uppModalFilterYDProcInfo,
                                                  GetCurrentArchitecture());
  }
#else
#define NewModalFilterYDUPP(userRoutine)                                     \
  (ModalFilterYDUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppModalFilterYDProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  UserItemUPP
  NewUserItemUPP(UserItemProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppUserItemProcInfo = 0x000002C0
  }; 
#ifdef __cplusplus
  inline UserItemUPP NewUserItemUPP(UserItemProcPtr userRoutine)
  {
    return (UserItemUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppUserItemProcInfo, GetCurrentArchitecture());
  }
#else
#define NewUserItemUPP(userRoutine)   \
  (UserItemUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppUserItemProcInfo, GetCurrentArchitecture())
#endif
#endif
 
#if CALL_NOT_IN_CARBON
  void
  DisposeSoundUPP(SoundUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeSoundUPP(SoundUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeSoundUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
#endif 
  void
  DisposeModalFilterUPP(ModalFilterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeModalFilterUPP(ModalFilterUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeModalFilterUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeModalFilterYDUPP(ModalFilterYDUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeModalFilterYDUPP(ModalFilterYDUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeModalFilterYDUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeUserItemUPP(UserItemUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeUserItemUPP(UserItemUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeUserItemUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
#if CALL_NOT_IN_CARBON
  void
  InvokeSoundUPP(SInt16 soundNumber, SoundUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeSoundUPP(SInt16 soundNumber, SoundUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppSoundProcInfo, soundNumber);
  }
#else
#define InvokeSoundUPP(soundNumber, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppSoundProcInfo, (soundNumber))
#endif
#endif
 
#endif 
  Boolean
  InvokeModalFilterUPP(DialogRef theDialog, EventRecord *theEvent,
                       DialogItemIndex *itemHit, ModalFilterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline Boolean InvokeModalFilterUPP(DialogRef theDialog, EventRecord *theEvent,
                                      DialogItemIndex *itemHit,
                                      ModalFilterUPP userUPP)
  {
    return (Boolean)CALL_THREE_PARAMETER_UPP(userUPP, uppModalFilterProcInfo,
                                             theDialog, theEvent, itemHit);
  }
#else
#define InvokeModalFilterUPP(theDialog, theEvent, itemHit, userUPP)     \
  (Boolean) CALL_THREE_PARAMETER_UPP((userUPP), uppModalFilterProcInfo, \
                                     (theDialog), (theEvent), (itemHit))
#endif
#endif
 
  Boolean
  InvokeModalFilterYDUPP(DialogRef theDialog, EventRecord *theEvent,
                         short *itemHit, void *yourDataPtr,
                         ModalFilterYDUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline Boolean InvokeModalFilterYDUPP(DialogRef theDialog,
                                        EventRecord *theEvent, short *itemHit,
                                        void *yourDataPtr,
                                        ModalFilterYDUPP userUPP)
  {
    return (Boolean)CALL_FOUR_PARAMETER_UPP(userUPP, uppModalFilterYDProcInfo,
                                            theDialog, theEvent, itemHit,
                                            yourDataPtr);
  }
#else
#define InvokeModalFilterYDUPP(theDialog, theEvent, itemHit, yourDataPtr, \
                               userUPP)                                   \
  (Boolean) CALL_FOUR_PARAMETER_UPP((userUPP), uppModalFilterYDProcInfo,  \
                                    (theDialog), (theEvent), (itemHit),   \
                                    (yourDataPtr))
#endif
#endif
 
  void
  InvokeUserItemUPP(DialogRef theDialog, DialogItemIndex itemNo,
                    UserItemUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeUserItemUPP(DialogRef theDialog, DialogItemIndex itemNo,
                                UserItemUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppUserItemProcInfo, theDialog, itemNo);
  }
#else
#define InvokeUserItemUPP(theDialog, itemNo, userUPP) \
  CALL_TWO_PARAMETER_UPP((userUPP), uppUserItemProcInfo, (theDialog), (itemNo))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewSoundProc(userRoutine) NewSoundUPP(userRoutine)
#define NewModalFilterProc(userRoutine) NewModalFilterUPP(userRoutine)
#define NewModalFilterYDProc(userRoutine) NewModalFilterYDUPP(userRoutine)
#define NewUserItemProc(userRoutine) NewUserItemUPP(userRoutine)
#define CallSoundProc(userRoutine, soundNumber) \
  InvokeSoundUPP(soundNumber, userRoutine)
#define CallModalFilterProc(userRoutine, theDialog, theEvent, itemHit) \
  InvokeModalFilterUPP(theDialog, theEvent, itemHit, userRoutine)
#define CallModalFilterYDProc(userRoutine, theDialog, theEvent, itemHit, \
                              yourDataPtr)                               \
  InvokeModalFilterYDUPP(theDialog, theEvent, itemHit, yourDataPtr, userRoutine)
#define CallUserItemProc(userRoutine, theDialog, itemNo) \
  InvokeUserItemUPP(theDialog, itemNo, userRoutine)
#endif 
#if !TARGET_OS_MAC
  typedef CALLBACK_API_C(void,
                         QTModelessCallbackProcPtr)(EventRecord *theEvent,
                                                    DialogRef theDialog,
                                                    DialogItemIndex itemHit);
#if CALL_NOT_IN_CARBON
  void
  SetModelessDialogCallbackProc(DialogRef theDialog,
                                QTModelessCallbackProcPtr callbackProc);
 
#endif 
  typedef QTModelessCallbackProcPtr QTModelessCallbackUPP;
#if CALL_NOT_IN_CARBON
  OSErr
  GetDialogControlNotificationProc(void *theProc);
 
  void
  SetDialogMovableModal(DialogRef theDialog);
 
  void *
  GetDialogParent(DialogRef theDialog);
 
#endif 
#endif 
  enum
  {
    kAlertStopAlert = 0,
    kAlertNoteAlert = 1,
    kAlertCautionAlert = 2,
    kAlertPlainAlert = 3
  };
 
  typedef SInt16 AlertType;
  enum
  {
    kAlertDefaultOKText = -1,     
    kAlertDefaultCancelText = -1, 
    kAlertDefaultOtherText = -1   
  };
 
  enum
  {
    kAlertStdAlertOKButton = 1,
    kAlertStdAlertCancelButton = 2,
    kAlertStdAlertOtherButton = 3,
    kAlertStdAlertHelpButton = 4
  };
 
  enum
  {
    kDialogFlagsUseThemeBackground = (1 << 0),
    kDialogFlagsUseControlHierarchy = (1 << 1),
    kDialogFlagsHandleMovableModal = (1 << 2),
    kDialogFlagsUseThemeControls = (1 << 3)
  };
 
  enum
  {
    kAlertFlagsUseThemeBackground = (1 << 0),
    kAlertFlagsUseControlHierarchy = (1 << 1),
    kAlertFlagsAlertIsMovable = (1 << 2),
    kAlertFlagsUseThemeControls = (1 << 3)
  };
 
  enum
  {
    kDialogFontNoFontStyle = 0,
    kDialogFontUseFontMask = 0x0001,
    kDialogFontUseFaceMask = 0x0002,
    kDialogFontUseSizeMask = 0x0004,
    kDialogFontUseForeColorMask = 0x0008,
    kDialogFontUseBackColorMask = 0x0010,
    kDialogFontUseModeMask = 0x0020,
    kDialogFontUseJustMask = 0x0040,
    kDialogFontUseAllMask = 0x00FF,
    kDialogFontAddFontSizeMask = 0x0100,
    kDialogFontUseFontNameMask = 0x0200,
    kDialogFontAddToMetaFontMask = 0x0400
  };
 
  enum
  {
    kDialogFontUseThemeFontIDMask = 0x0080
  };
 
  struct AlertStdAlertParamRec
  {
    Boolean movable;            
    Boolean helpButton;         
    ModalFilterUPP filterProc;  
    ConstStringPtr defaultText; 
    ConstStringPtr cancelText;  
    ConstStringPtr otherText;   
    SInt16 defaultButton;       
    SInt16 cancelButton;        
    UInt16 position;            
  };
  typedef struct AlertStdAlertParamRec AlertStdAlertParamRec;
  typedef AlertStdAlertParamRec *AlertStdAlertParamPtr;
  enum
  {
    kHICommandOther =
        FOUR_CHAR_CODE('othr') 
  };
 
  enum
  {
    kStdCFStringAlertVersionOne =
        1 
  };
 
  enum
  {
 
    kStdAlertDoNotDisposeSheet = 1 << 0,
 
    kStdAlertDoNotAnimateOnDefault = 1 << 1,
 
    kStdAlertDoNotAnimateOnCancel = 1 << 2,
 
    kStdAlertDoNotAnimateOnOther = 1 << 3
  };
 
  struct AlertStdCFStringAlertParamRec
  {
    UInt32 version;          
    Boolean movable;         
    Boolean helpButton;      
    CFStringRef defaultText; 
    CFStringRef cancelText;  
    CFStringRef otherText;   
    SInt16 defaultButton;    
    SInt16 cancelButton;     
    UInt16 position;         
    OptionBits flags;        
  };
  typedef struct AlertStdCFStringAlertParamRec AlertStdCFStringAlertParamRec;
  typedef AlertStdCFStringAlertParamRec *AlertStdCFStringAlertParamPtr;
#if CALL_NOT_IN_CARBON
 
  void
  InitDialogs(void *ignored);
 
  {
    SndChannelPtr myChan = 0L;
    Handle mySound;
    OSErr err;
    if (sndNum == 0)
      return;
    mySound = GetResource(soundListRsrc, kSndResNum);
    err = SndNewChannel(&myChan, 0, 0, 0L);
    HLock(mySound);
    err = SndPlay(myChan, mySound, FALSE);
    HUnlock(mySound);
    err = SndDisposeChannel(myChan, FALSE);
  }
  </ pre>
              * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
                                                        *    \non_carbon_cfm in InterfaceLib 7.1 and
      later
              *    \carbon_lib not available *    \mac_os_x not available *
          /
          void
          ErrorSound(SoundUPP soundProc);
 
#endif 
  DialogRef
  NewDialog(void *dStorage, const Rect *boundsRect, ConstStr255Param title,
            Boolean visible, SInt16 procID, WindowRef behind, Boolean goAwayFlag,
            SInt32 refCon, Handle items);
 
  DialogRef
  GetNewDialog(SInt16 dialogID, void *dStorage, WindowRef behind);
 
  DialogRef
  NewColorDialog(void *dStorage, const Rect *boundsRect, ConstStr255Param title,
                 Boolean visible, SInt16 procID, WindowRef behind,
                 Boolean goAwayFlag, SInt32 refCon, Handle items);
 
#if CALL_NOT_IN_CARBON
  void
  CloseDialog(DialogRef theDialog);
 
#endif 
  void
  DisposeDialog(DialogRef theDialog);
 
  void
  ModalDialog(ModalFilterUPP modalFilter, DialogItemIndex *itemHit);
 
  Boolean
  IsDialogEvent(const EventRecord *theEvent);
 
  Boolean
  DialogSelect(const EventRecord *theEvent, DialogRef *theDialog,
               DialogItemIndex *itemHit);
 
  void
  DrawDialog(DialogRef theDialog);
 
  void
  UpdateDialog(DialogRef theDialog, RgnHandle updateRgn);
 
  void
  HideDialogItem(DialogRef theDialog, DialogItemIndex itemNo);
 
  void
  ShowDialogItem(DialogRef theDialog, DialogItemIndex itemNo);
 
  DialogItemIndexZeroBased
  FindDialogItem(DialogRef theDialog, Point thePt);
 
  void
  DialogCut(DialogRef theDialog);
 
  void
  DialogPaste(DialogRef theDialog);
 
  void
  DialogCopy(DialogRef theDialog);
 
  void
  DialogDelete(DialogRef theDialog);
 
  DialogItemIndex
  Alert(SInt16 alertID, ModalFilterUPP modalFilter);
 
  DialogItemIndex
  StopAlert(SInt16 alertID, ModalFilterUPP modalFilter);
 
  DialogItemIndex
  NoteAlert(SInt16 alertID, ModalFilterUPP modalFilter);
 
  DialogItemIndex
  CautionAlert(SInt16 alertID, ModalFilterUPP modalFilter);
 
  void
  GetDialogItem(DialogRef theDialog, DialogItemIndex itemNo,
                DialogItemType *itemType, Handle *item, Rect *box);
 
  void
  SetDialogItem(DialogRef theDialog, DialogItemIndex itemNo,
                DialogItemType itemType, Handle item, const Rect *box);
 
  void
  ParamText(ConstStr255Param param0, ConstStr255Param param1,
            ConstStr255Param param2, ConstStr255Param param3);
 
  void
  SelectDialogItemText(DialogRef theDialog, DialogItemIndex itemNo,
                       SInt16 strtSel, SInt16 endSel);
 
  void
  GetDialogItemText(Handle item, Str255 text);
 
  void
  SetDialogItemText(Handle item, ConstStr255Param text);
 
  SInt16
  GetAlertStage(void);
 
  void
  SetDialogFont(SInt16 fontNum);
 
  void
  ResetAlertStage(void);
 
  void
  GetParamText(StringPtr param0, StringPtr param1, StringPtr param2,
               StringPtr param3);
 
#if CALL_NOT_IN_CARBON
  DialogRef
  newdialog(void *dStorage, const Rect *boundsRect, const char *title,
            Boolean visible, SInt16 procID, WindowRef behind, Boolean goAwayFlag,
            SInt32 refCon, Handle items);
 
  DialogRef
  newcolordialog(void *dStorage, const Rect *boundsRect, const char *title,
                 Boolean visible, SInt16 procID, WindowRef behind,
                 Boolean goAwayFlag, SInt32 refCon, Handle items);
 
  void
  paramtext(const char *param0, const char *param1, const char *param2,
            const char *param3);
 
  void
  getdialogitemtext(Handle item, char *text);
 
  void
  setdialogitemtext(Handle item, const char *text);
 
  DialogItemIndexZeroBased
  finddialogitem(DialogRef theDialog, Point *thePt);
 
#endif 
  void
  AppendDITL(DialogRef theDialog, Handle theHandle, DITLMethod method);
 
  DialogItemIndex
  CountDITL(DialogRef theDialog);
 
  void
  ShortenDITL(DialogRef theDialog, DialogItemIndex numberItems);
 
  OSStatus
  InsertDialogItem(DialogRef theDialog, DialogItemIndex afterItem,
                   DialogItemType itemType, Handle itemHandle, const Rect *box);
 
  OSStatus
  RemoveDialogItems(DialogRef theDialog, DialogItemIndex itemNo,
                    DialogItemIndex amountToRemove, Boolean disposeItemData);
 
  Boolean
  StdFilterProc(DialogRef theDialog, EventRecord *event,
                DialogItemIndex *itemHit);
 
  OSErr
  GetStdFilterProc(ModalFilterUPP *theProc);
 
  OSErr
  SetDialogDefaultItem(DialogRef theDialog, DialogItemIndex newItem);
 
  OSErr
  SetDialogCancelItem(DialogRef theDialog, DialogItemIndex newItem);
 
  OSErr
  SetDialogTracksCursor(DialogRef theDialog, Boolean tracks);
 
  DialogRef
  NewFeaturesDialog(void *inStorage, const Rect *inBoundsRect,
                    ConstStr255Param inTitle, Boolean inIsVisible,
                    SInt16 inProcID, WindowRef inBehind, Boolean inGoAwayFlag,
                    SInt32 inRefCon, Handle inItemListHandle, UInt32 inFlags);
 
  OSErr
  AutoSizeDialog(DialogRef inDialog);
 
  OSErr
  StandardAlert(AlertType inAlertType, ConstStr255Param inError,
                ConstStr255Param inExplanation,
                const AlertStdAlertParamRec *inAlertParam, 
                SInt16 *outItemHit);
 
  OSStatus
  GetStandardAlertDefaultParams(AlertStdCFStringAlertParamPtr param,
                                UInt32 version);
 
  OSStatus
  CreateStandardAlert(
      AlertType alertType, CFStringRef error,
      CFStringRef explanation,                    
      const AlertStdCFStringAlertParamRec *param, 
      DialogRef *outAlert);
 
  OSStatus
  RunStandardAlert(DialogRef inAlert,
                   ModalFilterUPP filterProc, 
                   DialogItemIndex *outItemHit);
 
  OSStatus
  CreateStandardSheet(
      AlertType alertType, CFStringRef error,
      CFStringRef explanation,                    
      const AlertStdCFStringAlertParamRec *param, 
      EventTargetRef notifyTarget, DialogRef *outSheet);
 
  OSStatus
  CloseStandardSheet(DialogRef inSheet, UInt32 inResultCommand);
 
  OSErr
  GetDialogItemAsControl(DialogRef inDialog, SInt16 inItemNo,
                         ControlRef *outControl);
 
  OSErr
  MoveDialogItem(DialogRef inDialog, SInt16 inItemNo, SInt16 inHoriz,
                 SInt16 inVert);
 
  OSErr
  SizeDialogItem(DialogRef inDialog, SInt16 inItemNo, SInt16 inWidth,
                 SInt16 inHeight);
 
  OSErr
  AppendDialogItemList(DialogRef dialog, SInt16 ditlID, DITLMethod method);
 
  OSStatus
  SetDialogTimeout(DialogRef inDialog, SInt16 inButtonToPress,
                   UInt32 inSecondsToWait);
 
  OSStatus
  GetDialogTimeout(DialogRef inDialog, SInt16 *outButtonToPress,
                   UInt32 *outSecondsToWait, UInt32 *outSecondsRemaining);
 
  OSStatus
  SetModalDialogEventMask(DialogRef inDialog, EventMask inMask);
 
  OSStatus
  GetModalDialogEventMask(DialogRef inDialog, EventMask *outMask);
 
  WindowRef
  GetDialogWindow(DialogRef dialog);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(WindowRef) GetDialogWindow(DialogRef dialog)
  {
    return (WindowRef)dialog;
  }
#else
#define GetDialogWindow(dialog) ((WindowRef)dialog)
#endif
#endif
 
  TEHandle
  GetDialogTextEditHandle(DialogRef dialog);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(TEHandle) GetDialogTextEditHandle(DialogRef dialog)
  {
    return ((DialogPeek)dialog)->textH;
  }
#else
#define GetDialogTextEditHandle(dialog) (((DialogPeek)dialog)->textH)
#endif
#endif
 
  SInt16
  GetDialogDefaultItem(DialogRef dialog);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(SInt16) GetDialogDefaultItem(DialogRef dialog)
  {
    return ((DialogPeek)dialog)->aDefItem;
  }
#else
#define GetDialogDefaultItem(dialog) (((DialogPeek)dialog)->aDefItem)
#endif
#endif
 
  SInt16
  GetDialogCancelItem(DialogRef dialog);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(SInt16) GetDialogCancelItem(DialogRef dialog)
  {
    return ((DialogPeek)dialog)->editOpen;
  }
#else
#define GetDialogCancelItem(dialog) (((DialogPeek)dialog)->editOpen)
#endif
#endif
 
  SInt16
  GetDialogKeyboardFocusItem(DialogRef dialog);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(SInt16) GetDialogKeyboardFocusItem(DialogRef dialog)
  {
    return ((DialogPeek)dialog)->editField < 0
               ? (short)(-1)
               : (short)(((DialogPeek)dialog)->editField + 1);
  }
#else
#define GetDialogKeyboardFocusItem(dialog) \
  (((DialogPeek)dialog)->editField < 0     \
       ? (short)(-1)                       \
       : (short)(((DialogPeek)dialog)->editField + 1))
#endif
#endif
 
  void
  SetPortDialogPort(DialogRef dialog);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(void) SetPortDialogPort(DialogRef dialog)
  {
    MacSetPort((GrafPtr)dialog);
  }
#else
#define SetPortDialogPort(dialog) (MacSetPort((GrafPtr)dialog))
#endif
#endif
 
  CGrafPtr
  GetDialogPort(DialogRef dialog);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(CGrafPtr) GetDialogPort(DialogRef dialog)
  {
    return (CGrafPtr)dialog;
  }
#else
#define GetDialogPort(dialog) ((CGrafPtr)dialog)
#endif
#endif
 
  DialogRef
  GetDialogFromWindow(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(DialogRef) GetDialogFromWindow(WindowRef window)
  {
    return (DialogRef)window;
  }
#else
#define GetDialogFromWindow(window) ((DialogRef)window)
#endif
#endif
 
#if CALL_NOT_IN_CARBON
  void
  CouldDialog(SInt16 dialogID);
 
  void
  FreeDialog(SInt16 dialogID);
 
  void
  CouldAlert(SInt16 alertID);
 
  void
  FreeAlert(SInt16 alertID);
 
#endif 
#if OLDROUTINENAMES
#define DisposDialog(theDialog) DisposeDialog(theDialog)
#define UpdtDialog(theDialog, updateRgn) UpdateDialog(theDialog, updateRgn)
#define GetDItem(theDialog, itemNo, itemType, item, box) \
  GetDialogItem(theDialog, itemNo, itemType, item, box)
#define SetDItem(theDialog, itemNo, itemType, item, box) \
  SetDialogItem(theDialog, itemNo, itemType, item, box)
#define HideDItem(theDialog, itemNo) HideDialogItem(theDialog, itemNo)
#define ShowDItem(theDialog, itemNo) ShowDialogItem(theDialog, itemNo)
#define SelIText(theDialog, itemNo, strtSel, endSel) \
  SelectDialogItemText(theDialog, itemNo, strtSel, endSel)
#define GetIText(item, text) GetDialogItemText(item, text)
#define SetIText(item, text) SetDialogItemText(item, text)
#define FindDItem(theDialog, thePt) FindDialogItem(theDialog, thePt)
#define NewCDialog(dStorage, boundsRect, title, visible, procID, behind, \
                   goAwayFlag, refCon, items)                            \
  NewColorDialog(dStorage, boundsRect, title, visible, procID, behind,   \
                 goAwayFlag, refCon, items)
#define GetAlrtStage() GetAlertStage()
#define ResetAlrtStage() ResetAlertStage()
#define DlgCut(theDialog) DialogCut(theDialog)
#define DlgPaste(theDialog) DialogPaste(theDialog)
#define DlgCopy(theDialog) DialogCopy(theDialog)
#define DlgDelete(theDialog) DialogDelete(theDialog)
#define SetDAFont(fontNum) SetDialogFont(fontNum)
#define SetGrafPortOfDialog(dialog) SetPortDialogPort(dialog)
#if CGLUESUPPORTED
#define newcdialog(dStorage, boundsRect, title, visible, procID, behind, \
                   goAwayFlag, refCon, items)                            \
  newcolordialog(dStorage, boundsRect, title, visible, procID, behind,   \
                 goAwayFlag, refCon, items)
#define getitext(item, text) getdialogitemtext(item, text)
#define setitext(item, text) setdialogitemtext(item, text)
#define findditem(theDialog, thePt) finddialogitem(theDialog, thePt)
#endif
#endif 
#if !TARGET_OS_MAC
#endif 
#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 
* / _OS_MAC
#endif 
#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 
* /*/*/ */*/