MacWindows.h

Go to the documentation of this file.

 
#ifndef __MACWINDOWS__
#define __MACWINDOWS__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __ALIASES__
#include <Aliases.h>
#endif
 
#ifndef __APPLEEVENTS__
#include <AppleEvents.h>
#endif
 
#ifndef __COLLECTIONS__
#include <Collections.h>
#endif
 
#ifndef __DRAG__
#include <Drag.h>
#endif
 
#ifndef __EVENTS__
#include <Events.h>
#endif
 
#ifndef __MENUS__
#include <Menus.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
 
#ifndef __QDOFFSCREEN__
#include <QDOffscreen.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif
 
#ifndef __TEXTCOMMON__
#include <TextCommon.h>
#endif
 
#ifndef __ICONS__
#include <Icons.h>
#endif
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#ifndef __CFSTRING__
#include <CFString.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
 
  typedef OSType PropertyCreator;
  typedef OSType PropertyTag;
 
  typedef UInt32 WindowClass;
  enum
  {
    kAlertWindowClass = 1L, 
    kMovableAlertWindowClass =
        2L,                        
    kModalWindowClass = 3L,        
    kMovableModalWindowClass = 4L, 
    kFloatingWindowClass = 5L,     
    kDocumentWindowClass = 6L,     
    kUtilityWindowClass = 8L,      
    kHelpWindowClass = 10L,        
    kSheetWindowClass = 11L,       
    kToolbarWindowClass = 12L,     
    kPlainWindowClass = 13L,       
    kOverlayWindowClass = 14L,     
    kSheetAlertWindowClass = 15L,  
    kAltPlainWindowClass =
        16L, 
    kAllWindowClasses =
        (unsigned long)0xFFFFFFFF 
  };
 
  typedef UInt32 WindowAttributes;
 
  enum
  {
 
    kWindowNoAttributes = 0L,
 
    kWindowCloseBoxAttribute = (1L << 0),
 
    kWindowHorizontalZoomAttribute = (1L << 1),
 
    kWindowVerticalZoomAttribute = (1L << 2),
 
    kWindowFullZoomAttribute =
        (kWindowVerticalZoomAttribute | kWindowHorizontalZoomAttribute),
 
    kWindowCollapseBoxAttribute = (1L << 3),
 
    kWindowResizableAttribute = (1L << 4),
 
    kWindowSideTitlebarAttribute = (1L << 5),
 
    kWindowToolbarButtonAttribute = (1L << 6),
 
    kWindowNoUpdatesAttribute = (1L << 16),
 
    kWindowNoActivatesAttribute = (1L << 17),
 
    kWindowOpaqueForEventsAttribute = (1L << 18),
 
    kWindowNoShadowAttribute = (1L << 21),
 
    kWindowHideOnSuspendAttribute = (1L << 24),
 
    kWindowStandardHandlerAttribute = (1L << 25),
 
    kWindowHideOnFullScreenAttribute = (1L << 26),
 
    kWindowInWindowMenuAttribute = (1L << 27),
 
    kWindowLiveResizeAttribute = (1L << 28),
 
    kWindowNoConstrainAttribute = (unsigned long)((1L << 31)),
 
    kWindowStandardDocumentAttributes =
        (kWindowCloseBoxAttribute | kWindowFullZoomAttribute |
         kWindowCollapseBoxAttribute | kWindowResizableAttribute),
 
    kWindowStandardFloatingAttributes =
        (kWindowCloseBoxAttribute | kWindowCollapseBoxAttribute)
  };
 
  enum
  {
    kWindowDefProcType = FOUR_CHAR_CODE('WDEF')
  };
 
  enum
  {
    kStandardWindowDefinition = 0,  
    kRoundWindowDefinition = 1,     
    kFloatingWindowDefinition = 124 
  };
 
  enum
  {
    kDocumentWindowVariantCode = 0,
    kModalDialogVariantCode = 1,
    kPlainDialogVariantCode = 2,
    kShadowDialogVariantCode = 3,
    kMovableModalDialogVariantCode = 5,
    kAlertVariantCode = 7,
    kMovableAlertVariantCode = 9, 
    kSideFloaterVariantCode = 8
  };
 
  enum
  {
    documentProc = 0,
    dBoxProc = 1,
    plainDBox = 2,
    altDBoxProc = 3,
    noGrowDocProc = 4,
    movableDBoxProc = 5,
    zoomDocProc = 8,
    zoomNoGrow = 12, 
    floatProc = 1985,
    floatGrowProc = 1987,
    floatZoomProc = 1989,
    floatZoomGrowProc = 1991,
    floatSideProc = 1993,
    floatSideGrowProc = 1995,
    floatSideZoomProc = 1997,
    floatSideZoomGrowProc = 1999
  };
 
#if CALL_NOT_IN_CARBON
  enum
  {
    rDocProc = 16
  };
 
#endif 
  enum
  {
    kWindowDocumentDefProcResID = 64,
    kWindowDialogDefProcResID = 65,
    kWindowUtilityDefProcResID = 66,
    kWindowUtilitySideTitleDefProcResID = 67,
    kWindowSheetDefProcResID = 68,
    kWindowSimpleDefProcResID = 69,
    kWindowSheetAlertDefProcResID = 70
  };
 
  enum
  {
    kWindowDocumentProc = 1024,
    kWindowGrowDocumentProc = 1025,
    kWindowVertZoomDocumentProc = 1026,
    kWindowVertZoomGrowDocumentProc = 1027,
    kWindowHorizZoomDocumentProc = 1028,
    kWindowHorizZoomGrowDocumentProc = 1029,
    kWindowFullZoomDocumentProc = 1030,
    kWindowFullZoomGrowDocumentProc = 1031
  };
 
  enum
  {
    kWindowPlainDialogProc = 1040,
    kWindowShadowDialogProc = 1041,
    kWindowModalDialogProc = 1042,
    kWindowMovableModalDialogProc = 1043,
    kWindowAlertProc = 1044,
    kWindowMovableAlertProc = 1045
  };
 
  enum
  {
    kWindowMovableModalGrowProc = 1046
  };
 
  enum
  {
    kWindowFloatProc = 1057,
    kWindowFloatGrowProc = 1059,
    kWindowFloatVertZoomProc = 1061,
    kWindowFloatVertZoomGrowProc = 1063,
    kWindowFloatHorizZoomProc = 1065,
    kWindowFloatHorizZoomGrowProc = 1067,
    kWindowFloatFullZoomProc = 1069,
    kWindowFloatFullZoomGrowProc = 1071
  };
 
  enum
  {
    kWindowFloatSideProc = 1073,
    kWindowFloatSideGrowProc = 1075,
    kWindowFloatSideVertZoomProc = 1077,
    kWindowFloatSideVertZoomGrowProc = 1079,
    kWindowFloatSideHorizZoomProc = 1081,
    kWindowFloatSideHorizZoomGrowProc = 1083,
    kWindowFloatSideFullZoomProc = 1085,
    kWindowFloatSideFullZoomGrowProc = 1087
  };
 
  enum
  {
    kWindowSheetProc = 1088, 
    kWindowSheetAlertProc =
        1120 
  };
 
  enum
  {
    kWindowSimpleProc = 1104,
 
    kWindowSimpleFrameProc = 1105
  };
 
  enum
  {
    kWindowNoPosition = 0x0000,
    kWindowDefaultPosition = 0x0000, 
    kWindowCenterMainScreen = 0x280A,
    kWindowAlertPositionMainScreen = 0x300A,
    kWindowStaggerMainScreen = 0x380A,
    kWindowCenterParentWindow = 0xA80A,
    kWindowAlertPositionParentWindow = 0xB00A,
    kWindowStaggerParentWindow = 0xB80A,
    kWindowCenterParentWindowScreen = 0x680A,
    kWindowAlertPositionParentWindowScreen = 0x700A,
    kWindowStaggerParentWindowScreen = 0x780A
  };
 
  typedef UInt32 WindowPositionMethod;
  enum
  {
    kWindowCenterOnMainScreen = 0x00000001,
    kWindowCenterOnParentWindow = 0x00000002,
    kWindowCenterOnParentWindowScreen = 0x00000003,
    kWindowCascadeOnMainScreen = 0x00000004,
    kWindowCascadeOnParentWindow = 0x00000005,
    kWindowCascadeOnParentWindowScreen = 0x00000006,
    kWindowAlertPositionOnMainScreen = 0x00000007,
    kWindowAlertPositionOnParentWindow = 0x00000008,
    kWindowAlertPositionOnParentWindowScreen = 0x00000009
  };
 
  typedef UInt16 WindowRegionCode;
  enum
  {
    kWindowTitleBarRgn = 0,
    kWindowTitleTextRgn = 1,
    kWindowCloseBoxRgn = 2,
    kWindowZoomBoxRgn = 3,
    kWindowDragRgn = 5,
    kWindowGrowRgn = 6,
    kWindowCollapseBoxRgn = 7,
    kWindowTitleProxyIconRgn = 8, 
    kWindowStructureRgn = 32,
    kWindowContentRgn =
        33,                
    kWindowUpdateRgn = 34, 
    kWindowOpaqueRgn = 35, 
    kWindowGlobalPortRgn =
        40 
  };
 
  struct GetWindowRegionRec
  {
    RgnHandle winRgn;
    WindowRegionCode regionCode;
  };
  typedef struct GetWindowRegionRec GetWindowRegionRec;
  typedef GetWindowRegionRec *GetWindowRegionPtr;
  typedef GetWindowRegionRec *GetWindowRegionRecPtr;
 
  struct SetupWindowProxyDragImageRec
  {
    GWorldPtr imageGWorld; 
    RgnHandle imageRgn;    
    RgnHandle outlineRgn;  
  };
  typedef struct SetupWindowProxyDragImageRec SetupWindowProxyDragImageRec;
  struct MeasureWindowTitleRec
  {
    SInt16 fullTitleWidth; 
    SInt16 titleTextWidth; 
  };
  typedef struct MeasureWindowTitleRec MeasureWindowTitleRec;
  typedef MeasureWindowTitleRec *MeasureWindowTitleRecPtr;
  struct GetGrowImageRegionRec
  {
    Rect growRect;
    RgnHandle growImageRegion;
  };
  typedef struct GetGrowImageRegionRec GetGrowImageRegionRec;
 
  enum
  {
    dialogKind = 2,
    userKind = 8,
    kDialogWindowKind = 2,
    kApplicationWindowKind = 8
  };
 
  typedef SInt16 WindowPartCode;
  enum
  {
    inDesk = 0,
    inNoWindow = 0,
    inMenuBar = 1,
    inSysWindow = 2,
    inContent = 3,
    inDrag = 4,
    inGrow = 5,
    inGoAway = 6,
    inZoomIn = 7,
    inZoomOut = 8,
    inCollapseBox = 11,   
    inProxyIcon = 12,     
    inToolbarButton = 13, 
    inStructure = 15      
  };
 
  typedef SInt16 WindowDefPartCode;
  enum
  {
    wNoHit = 0,
    wInContent = 1,
    wInDrag = 2,
    wInGrow = 3,
    wInGoAway = 4,
    wInZoomIn = 5,
    wInZoomOut = 6,
    wInCollapseBox = 9,    
    wInProxyIcon = 10,     
    wInToolbarButton = 11, 
    wInStructure = 13      
  };
 
  enum
  {
    kWindowMsgDraw = 0,
    kWindowMsgHitTest = 1,
    kWindowMsgCalculateShape = 2,
    kWindowMsgInitialize = 3,
    kWindowMsgCleanUp = 4,
    kWindowMsgDrawGrowOutline = 5,
    kWindowMsgDrawGrowBox = 6
  };
 
  enum
  {
    kWindowMsgGetFeatures = 7,
    kWindowMsgGetRegion = 8
  };
 
  enum
  {
    kWindowMsgDragHilite = 9, 
    kWindowMsgModified =
        10, 
    kWindowMsgDrawInCurrentPort =
        11, 
    kWindowMsgSetupProxyDragImage =
        12, 
    kWindowMsgStateChanged =
        13,                     
    kWindowMsgMeasureTitle = 14 
  };
 
  enum
  {
    kWindowMsgGetGrowImageRegion =
        19 
  };
 
  enum
  {
    wDraw = 0,
    wHit = 1,
    wCalcRgns = 2,
    wNew = 3,
    wDispose = 4,
    wGrow = 5,
    wDrawGIcon = 6
  };
 
  enum
  {
    kWindowStateTitleChanged = (1 << 0)
  };
 
  enum
  {
    kWindowCanGrow = (1 << 0),
    kWindowCanZoom = (1 << 1),
    kWindowCanCollapse = (1 << 2),
    kWindowIsModal = (1 << 3),
    kWindowCanGetWindowRegion = (1 << 4),
    kWindowIsAlert = (1 << 5),
    kWindowHasTitleBar = (1 << 6)
  };
 
  enum
  {
    kWindowSupportsDragHilite =
        (1 << 7), 
    kWindowSupportsModifiedBit =
        (1 << 8), 
    kWindowCanDrawInCurrentPort =
        (1 << 9), 
    kWindowCanSetupProxyDragImage =
        (1 << 10), 
    kWindowCanMeasureTitle =
        (1 << 11), 
    kWindowWantsDisposeAtProcessDeath =
        (1 << 12), 
    kWindowSupportsGetGrowImageRegion =
        (1 << 13), 
    kWindowDefSupportsColorGrafPort = 0x40000002
  };
 
  enum
  {
    kWindowIsOpaque =
        (1 << 14) 
  };
 
  enum
  {
    kWindowSupportsSetGrowImageRegion = (1 << 13)
  };
 
  enum
  {
    deskPatID = 16
  };
 
  enum
  {
    wContentColor = 0,
    wFrameColor = 1,
    wTextColor = 2,
    wHiliteColor = 3,
    wTitleBarColor = 4
  };
 
  enum
  {
    kMouseUpOutOfSlop = (long)0x80008000
  };
 
  struct WinCTab
  {
    long wCSeed;      
    short wCReserved; 
    short ctSize;     
    ColorSpec ctTable[5];
  };
  typedef struct WinCTab WinCTab;
  typedef WinCTab *WCTabPtr;
  typedef WCTabPtr *WCTabHandle;
 
#if !OPAQUE_TOOLBOX_STRUCTS
  typedef struct WindowRecord WindowRecord;
  typedef WindowRecord *WindowPeek;
  struct WindowRecord
  {
    GrafPort port;    
    short windowKind; 
    Boolean
        visible;              
    Boolean hilited;          
    Boolean goAwayFlag;       
    Boolean spareFlag;        
    RgnHandle strucRgn;       
    RgnHandle contRgn;        
    RgnHandle updateRgn;      
    Handle windowDefProc;     
    Handle dataHandle;        
    StringHandle titleHandle; 
    short titleWidth;         
    Handle controlList;       
    WindowPeek nextWindow;    
    PicHandle windowPic;      
    long refCon;              
  };
 
#endif 
#if !OPAQUE_TOOLBOX_STRUCTS
  typedef struct CWindowRecord CWindowRecord;
  typedef CWindowRecord *CWindowPeek;
  struct CWindowRecord
  {
    CGrafPort port;   
    short windowKind; 
    Boolean
        visible;              
    Boolean hilited;          
    Boolean goAwayFlag;       
    Boolean spareFlag;        
    RgnHandle strucRgn;       
    RgnHandle contRgn;        
    RgnHandle updateRgn;      
    Handle windowDefProc;     
    Handle dataHandle;        
    StringHandle titleHandle; 
    short titleWidth;         
    Handle controlList;       
    CWindowPeek nextWindow;   
    PicHandle windowPic;      
    long refCon;              
  };
 
#endif 
#if !OPAQUE_TOOLBOX_STRUCTS
  typedef struct AuxWinRec AuxWinRec;
  typedef AuxWinRec *AuxWinPtr;
  typedef AuxWinPtr *AuxWinHandle;
  struct AuxWinRec
  {
    AuxWinHandle awNext;   
    WindowRef awOwner;     
    CTabHandle awCTable;   
    Handle reserved;       
    long awFlags;          
    CTabHandle awReserved; 
    long awRefCon;         
  };
 
#endif 
  enum
  {
    kWindowDefinitionVersionOne = 1,
    kWindowDefinitionVersionTwo = 2
  };
 
  enum
  {
    kWindowIsCollapsedState = (1 << 0L)
  };
 
  struct BasicWindowDescription
  {
    UInt32 descriptionSize; 
    Rect windowContentRect;  
    Rect windowZoomRect;     
    UInt32 windowRefCon;     
    UInt32 windowStateFlags; 
    WindowPositionMethod
        windowPositionMethod; 
    UInt32 windowDefinitionVersion;
    union
    {
      struct
      {
        SInt16 windowDefProc; 
        Boolean windowHasCloseBox;
      } versionOne;
 
      struct
      {
        WindowClass windowClass;           
        WindowAttributes windowAttributes; 
      } versionTwo;
 
    } windowDefinition;
  };
  typedef struct BasicWindowDescription BasicWindowDescription;
  enum
  {
    kStoredWindowSystemTag = FOUR_CHAR_CODE(
        'appl'), 
    kStoredBasicWindowDescriptionID =
        FOUR_CHAR_CODE('sbas'),                         
    kStoredWindowPascalTitleID = FOUR_CHAR_CODE('s255') 
  };
 
#define kFirstWindowOfClass ((WindowRef)(-1))
#define kLastWindowOfClass ((WindowRef)0)
 
  struct WStateData
  {
    Rect userState; 
    Rect stdState;  
  };
  typedef struct WStateData WStateData;
  typedef WStateData *WStateDataPtr;
  typedef WStateDataPtr *WStateDataHandle;
 
  typedef CALLBACK_API(long, WindowDefProcPtr)(short varCode, WindowRef window,
                                               short message, long param);
  typedef CALLBACK_API_REGISTER68K(void, DeskHookProcPtr,
                                   (Boolean mouseClick, EventRecord *theEvent));
  typedef CALLBACK_API(OSStatus, WindowPaintProcPtr)(
      GDHandle device, GrafPtr qdContext, WindowRef window,
      RgnHandle inClientPaintRgn, RgnHandle outSystemPaintRgn, void *refCon);
  typedef STACK_UPP_TYPE(WindowDefProcPtr) WindowDefUPP;
  typedef REGISTER_UPP_TYPE(DeskHookProcPtr) DeskHookUPP;
  typedef STACK_UPP_TYPE(WindowPaintProcPtr) WindowPaintUPP;
  WindowDefUPP
  NewWindowDefUPP(WindowDefProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppWindowDefProcInfo = 0x00003BB0
  }; 
#ifdef __cplusplus
  inline WindowDefUPP NewWindowDefUPP(WindowDefProcPtr userRoutine)
  {
    return (WindowDefUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppWindowDefProcInfo, GetCurrentArchitecture());
  }
#else
#define NewWindowDefUPP(userRoutine)   \
  (WindowDefUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppWindowDefProcInfo, GetCurrentArchitecture())
#endif
#endif
 
#if CALL_NOT_IN_CARBON
  DeskHookUPP
  NewDeskHookUPP(DeskHookProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDeskHookProcInfo = 0x00130802
  }; 
#ifdef __cplusplus
  inline DeskHookUPP NewDeskHookUPP(DeskHookProcPtr userRoutine)
  {
    return (DeskHookUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppDeskHookProcInfo, GetCurrentArchitecture());
  }
#else
#define NewDeskHookUPP(userRoutine)   \
  (DeskHookUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppDeskHookProcInfo, GetCurrentArchitecture())
#endif
#endif
 
#endif 
  WindowPaintUPP
  NewWindowPaintUPP(WindowPaintProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppWindowPaintProcInfo = 0x0003FFF0
  }; 
#ifdef __cplusplus
  inline WindowPaintUPP NewWindowPaintUPP(WindowPaintProcPtr userRoutine)
  {
    return (WindowPaintUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppWindowPaintProcInfo, GetCurrentArchitecture());
  }
#else
#define NewWindowPaintUPP(userRoutine)                                     \
  (WindowPaintUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppWindowPaintProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeWindowDefUPP(WindowDefUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeWindowDefUPP(WindowDefUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeWindowDefUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
#if CALL_NOT_IN_CARBON
  void
  DisposeDeskHookUPP(DeskHookUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDeskHookUPP(DeskHookUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDeskHookUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
#endif 
  void
  DisposeWindowPaintUPP(WindowPaintUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeWindowPaintUPP(WindowPaintUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeWindowPaintUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  long
  InvokeWindowDefUPP(short varCode, WindowRef window, short message, long param,
                     WindowDefUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline long InvokeWindowDefUPP(short varCode, WindowRef window, short message,
                                 long param, WindowDefUPP userUPP)
  {
    return (long)CALL_FOUR_PARAMETER_UPP(userUPP, uppWindowDefProcInfo, varCode,
                                         window, message, param);
  }
#else
#define InvokeWindowDefUPP(varCode, window, message, param, userUPP)        \
  (long)CALL_FOUR_PARAMETER_UPP((userUPP), uppWindowDefProcInfo, (varCode), \
                                (window), (message), (param))
#endif
#endif
 
#if CALL_NOT_IN_CARBON
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter InvokeDeskHookUPP(__D0, __A0, __A1)
#endif
  void
  InvokeDeskHookUPP(Boolean mouseClick, EventRecord *theEvent,
                    DeskHookUPP userUPP);
#if !OPAQUE_UPP_TYPES && \
    (!TARGET_OS_MAC || !TARGET_CPU_68K || TARGET_RT_MAC_CFM)
#ifdef __cplusplus
  inline void InvokeDeskHookUPP(Boolean mouseClick, EventRecord *theEvent,
                                DeskHookUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppDeskHookProcInfo, mouseClick, theEvent);
  }
#else
#define InvokeDeskHookUPP(mouseClick, theEvent, userUPP)               \
  CALL_TWO_PARAMETER_UPP((userUPP), uppDeskHookProcInfo, (mouseClick), \
                         (theEvent))
#endif
#endif
 
#endif 
  OSStatus
  InvokeWindowPaintUPP(GDHandle device, GrafPtr qdContext, WindowRef window,
                       RgnHandle inClientPaintRgn, RgnHandle outSystemPaintRgn,
                       void *refCon, WindowPaintUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeWindowPaintUPP(GDHandle device, GrafPtr qdContext,
                                       WindowRef window,
                                       RgnHandle inClientPaintRgn,
                                       RgnHandle outSystemPaintRgn, void *refCon,
                                       WindowPaintUPP userUPP)
  {
    return (OSStatus)CALL_SIX_PARAMETER_UPP(
        userUPP, uppWindowPaintProcInfo, device, qdContext, window,
        inClientPaintRgn, outSystemPaintRgn, refCon);
  }
#else
#define InvokeWindowPaintUPP(device, qdContext, window, inClientPaintRgn, \
                             outSystemPaintRgn, refCon, userUPP)          \
  (OSStatus) CALL_SIX_PARAMETER_UPP(                                      \
      (userUPP), uppWindowPaintProcInfo, (device), (qdContext), (window), \
      (inClientPaintRgn), (outSystemPaintRgn), (refCon))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewWindowDefProc(userRoutine) NewWindowDefUPP(userRoutine)
#define NewDeskHookProc(userRoutine) NewDeskHookUPP(userRoutine)
#define NewWindowPaintProc(userRoutine) NewWindowPaintUPP(userRoutine)
#define CallWindowDefProc(userRoutine, varCode, window, message, param) \
  InvokeWindowDefUPP(varCode, window, message, param, userRoutine)
#define CallDeskHookProc(userRoutine, mouseClick, theEvent) \
  InvokeDeskHookUPP(mouseClick, theEvent, userRoutine)
#define CallWindowPaintProc(userRoutine, device, qdContext, window,      \
                            inClientPaintRgn, outSystemPaintRgn, refCon) \
  InvokeWindowPaintUPP(device, qdContext, window, inClientPaintRgn,      \
                       outSystemPaintRgn, refCon, userRoutine)
#endif 
  enum
  {
    kWindowDefProcPtr = 0,     
    kWindowDefObjectClass = 1, 
    kWindowDefProcID =
        2 
  };
 
  typedef UInt32 WindowDefType;
  struct WindowDefSpec
  {
    WindowDefType defType;
    union
    {
      WindowDefUPP defProc;
      void *classRef;
      short procID;
    } u;
  };
  typedef struct WindowDefSpec WindowDefSpec;
  typedef WindowDefSpec *WindowDefSpecPtr;
 
  WindowRef
  GetNewCWindow(short windowID, void *wStorage, WindowRef behind);
 
  WindowRef
  NewWindow(void *wStorage, const Rect *boundsRect, ConstStr255Param title,
            Boolean visible, short theProc, WindowRef behind, Boolean goAwayFlag,
            long refCon);
 
  WindowRef
  GetNewWindow(short windowID, void *wStorage, WindowRef behind);
 
  WindowRef
  NewCWindow(void *wStorage, const Rect *boundsRect, ConstStr255Param title,
             Boolean visible, short procID, WindowRef behind, Boolean goAwayFlag,
             long refCon);
 
  void
  DisposeWindow(WindowRef window);
 
#if CALL_NOT_IN_CARBON
#if TARGET_OS_MAC
#define MacCloseWindow CloseWindow
#endif
  void
  MacCloseWindow(WindowRef window);
 
#endif 
  OSStatus
  CreateNewWindow(WindowClass windowClass, WindowAttributes attributes,
                  const Rect *contentBounds, WindowRef *outWindow);
 
  OSStatus
  CreateWindowFromResource(SInt16 resID, WindowRef *outWindow);
 
  OSStatus
  StoreWindowIntoCollection(WindowRef window, Collection collection);
 
  OSStatus
  CreateWindowFromCollection(Collection collection, WindowRef *outWindow);
 
  OSStatus
  GetWindowOwnerCount(WindowRef window, UInt32 *outCount);
 
  OSStatus
  CloneWindow(WindowRef window);
 
  ItemCount
  GetWindowRetainCount(WindowRef inWindow);
 
  OSStatus
  RetainWindow(WindowRef inWindow);
 
  OSStatus
  ReleaseWindow(WindowRef inWindow);
 
  OSStatus
  CreateCustomWindow(const WindowDefSpec *def, WindowClass windowClass,
                     WindowAttributes attributes, const Rect *contentBounds,
                     WindowRef *outWindow);
 
  OSStatus
  ReshapeCustomWindow(WindowRef window);
 
  OSStatus
  RegisterWindowDefinition(SInt16 inResID, const WindowDefSpec *inDefSpec);
 
  OSStatus
  GetWindowWidgetHilite(WindowRef inWindow, WindowDefPartCode *outHilite);
 
  Boolean
  IsValidWindowClass(WindowClass inClass);
 
  WindowAttributes
  GetAvailableWindowAttributes(WindowClass inClass);
 
  OSStatus
  GetWindowClass(WindowRef window, WindowClass *outClass);
 
  OSStatus
  GetWindowAttributes(WindowRef window, WindowAttributes *outAttributes);
 
  OSStatus
  ChangeWindowAttributes(WindowRef window, WindowAttributes setTheseAttributes,
                         WindowAttributes clearTheseAttributes);
 
  OSStatus
  SetWindowClass(WindowRef inWindow, WindowClass inWindowClass);
 
  typedef UInt32 WindowModality;
  enum
  {
 
    kWindowModalityNone = 0,
 
    kWindowModalitySystemModal = 1,
 
    kWindowModalityAppModal = 2,
 
    kWindowModalityWindowModal = 3
  };
 
  OSStatus
  SetWindowModality(WindowRef inWindow, WindowModality inModalKind,
                    WindowRef inUnavailableWindow);
 
  OSStatus
  GetWindowModality(WindowRef inWindow, WindowModality *outModalKind,
                    WindowRef *outUnavailableWindow); 
  OSStatus
  ShowFloatingWindows(void);
 
  OSStatus
  HideFloatingWindows(void);
 
  Boolean
  AreFloatingWindowsVisible(void);
 
  typedef struct OpaqueWindowGroupRef *WindowGroupRef;
#define kFirstWindowOfGroup ((WindowRef)(-1))
#define kLastWindowOfGroup ((WindowRef)NULL)
#define kFirstWindowGroup ((WindowGroupRef)(-1))
#define kLastWindowGroup ((WindowGroupRef)NULL)
 
  typedef UInt32 WindowGroupAttributes;
  enum
  {
 
    kWindowGroupAttrSelectAsLayer = 1 << 0,
 
    kWindowGroupAttrMoveTogether = 1 << 1,
 
    kWindowGroupAttrLayerTogether = 1 << 2,
 
    kWindowGroupAttrSharedActivation = 1 << 3,
 
    kWindowGroupAttrHideOnCollapse = 1 << 4
  };
 
  typedef UInt32 WindowActivationScope;
  enum
  {
 
    kWindowActivationScopeNone = 0,
 
    kWindowActivationScopeIndependent = 1,
 
    kWindowActivationScopeAll = 2
  };
 
  enum
  {
 
    kNextWindowGroup = true,
 
    kPreviousWindowGroup = false
  };
 
  typedef UInt32 WindowGroupContentOptions;
  enum
  {
 
    kWindowGroupContentsReturnWindows = 1 << 0,
 
    kWindowGroupContentsRecurse = 1 << 1,
 
    kWindowGroupContentsVisible = 1 << 2
  };
 
  OSStatus
  CreateWindowGroup(WindowGroupAttributes inAttributes, WindowGroupRef *outGroup);
 
  OSStatus
  RetainWindowGroup(WindowGroupRef inGroup);
 
  OSStatus
  ReleaseWindowGroup(WindowGroupRef inGroup);
 
  ItemCount
  GetWindowGroupRetainCount(WindowGroupRef inGroup);
 
  WindowGroupRef
  GetWindowGroupOfClass(WindowClass windowClass);
 
  OSStatus
  SetWindowGroupName(WindowGroupRef inGroup, CFStringRef inName);
 
  OSStatus
  CopyWindowGroupName(WindowGroupRef inGroup, CFStringRef *outName);
 
  OSStatus
  GetWindowGroupAttributes(WindowGroupRef inGroup,
                           WindowGroupAttributes *outAttributes);
 
  OSStatus
  ChangeWindowGroupAttributes(WindowGroupRef inGroup,
                              WindowGroupAttributes setTheseAttributes,
                              WindowGroupAttributes clearTheseAttributes);
 
  OSStatus
  SetWindowGroupLevel(WindowGroupRef inGroup, SInt32 inLevel);
 
  OSStatus
  GetWindowGroupLevel(WindowGroupRef inGroup, SInt32 *outLevel);
 
  OSStatus
  SendWindowGroupBehind(WindowGroupRef inGroup, WindowGroupRef behindGroup);
 
  WindowGroupRef
  GetWindowGroup(WindowRef inWindow);
 
  OSStatus
  SetWindowGroup(WindowRef inWindow, WindowGroupRef inNewGroup);
 
  Boolean
  IsWindowContainedInGroup(WindowRef inWindow, WindowGroupRef inGroup);
 
  WindowGroupRef
  GetWindowGroupParent(WindowGroupRef inGroup);
 
  OSStatus
  SetWindowGroupParent(WindowGroupRef inGroup, WindowGroupRef inNewGroup);
 
  WindowGroupRef
  GetWindowGroupSibling(WindowGroupRef inGroup, Boolean inNextGroup);
 
  WindowRef
  GetWindowGroupOwner(WindowGroupRef inGroup);
 
  OSStatus
  SetWindowGroupOwner(WindowGroupRef inGroup, WindowRef inWindow);
 
  ItemCount
  CountWindowGroupContents(WindowGroupRef inGroup,
                           WindowGroupContentOptions inOptions);
 
  OSStatus
  GetWindowGroupContents(WindowGroupRef inGroup,
                         WindowGroupContentOptions inOptions,
                         ItemCount inAllowedItems,
                         ItemCount *outNumItems, 
                         void **outItems);
 
  OSStatus
  GetIndexedWindow(WindowGroupRef inGroup, UInt32 inIndex,
                   WindowGroupContentOptions inOptions, WindowRef *outWindow);
 
  OSStatus
  GetWindowIndex(WindowRef inWindow, WindowGroupRef inStartGroup,
                 WindowGroupContentOptions inOptions, UInt32 *outIndex);
 
  WindowRef
  ActiveNonFloatingWindow(void);
 
  Boolean
  IsWindowActive(WindowRef inWindow);
 
  OSStatus
  ActivateWindow(WindowRef inWindow, Boolean inActivate);
 
  OSStatus
  GetWindowActivationScope(WindowRef inWindow, WindowActivationScope *outScope);
 
  OSStatus
  SetWindowActivationScope(WindowRef inWindow, WindowActivationScope inScope);
 
  void
  DebugPrintWindowGroup(WindowGroupRef inGroup);
 
  void
  DebugPrintAllWindowGroups(void);
 
#if CALL_NOT_IN_CARBON
  void
  SetWinColor(WindowRef window, WCTabHandle newColorTable);
 
  void
  SetDeskCPat(PixPatHandle deskPixPat);
 
#endif 
  OSStatus
  SetWindowContentColor(WindowRef window, const RGBColor *color);
 
  OSStatus
  GetWindowContentColor(WindowRef window, RGBColor *color);
 
  OSStatus
  GetWindowContentPattern(WindowRef window, PixPatHandle outPixPat);
 
  OSStatus
  SetWindowContentPattern(WindowRef window, PixPatHandle pixPat);
 
  typedef OptionBits WindowPaintProcOptions;
  enum
  {
    kWindowPaintProcOptionsNone = 0
  };
 
  OSStatus
  InstallWindowContentPaintProc(WindowRef window, WindowPaintUPP paintProc,
                                WindowPaintProcOptions options,
                                void *refCon); 
  typedef UInt32 ScrollWindowOptions;
  enum
  {
    kScrollWindowNoOptions = 0,
    kScrollWindowInvalidate =
        (1L << 0), 
    kScrollWindowEraseToPortBackground =
        (1L << 1) 
  };
 
  OSStatus
  ScrollWindowRect(WindowRef inWindow, const Rect *inScrollRect, SInt16 inHPixels,
                   SInt16 inVPixels, ScrollWindowOptions inOptions,
                   RgnHandle outExposedRgn); 
  OSStatus
  ScrollWindowRegion(WindowRef inWindow, RgnHandle inScrollRgn, SInt16 inHPixels,
                     SInt16 inVPixels, ScrollWindowOptions inOptions,
                     RgnHandle outExposedRgn); 
  void
  ClipAbove(WindowRef window);
 
#if CALL_NOT_IN_CARBON
  void
  SaveOld(WindowRef window);
 
  void
  DrawNew(WindowRef window, Boolean update);
 
#endif 
  void
  PaintOne(WindowRef window, 
           RgnHandle clobberedRgn);
 
  void
  PaintBehind(WindowRef startWindow, 
              RgnHandle clobberedRgn);
 
  void
  CalcVis(WindowRef window);
 
  void
  CalcVisBehind(WindowRef startWindow, 
                RgnHandle clobberedRgn);
 
  Boolean
  CheckUpdate(EventRecord *theEvent);
 
#if TARGET_OS_MAC
#define MacFindWindow FindWindow
#endif
  WindowPartCode
  MacFindWindow(Point thePoint, WindowRef *window);
 
  WindowRef
  FrontWindow(void);
 
  void
  BringToFront(WindowRef window);
 
  void
  SendBehind(WindowRef window, WindowRef behindWindow);
 
  void
  SelectWindow(WindowRef window);
 
  WindowRef
  FrontNonFloatingWindow(void);
 
  WindowRef
  GetNextWindowOfClass(WindowRef inWindow, WindowClass inWindowClass,
                       Boolean mustBeVisible);
 
  WindowRef
  GetFrontWindowOfClass(WindowClass inWindowClass, Boolean mustBeVisible);
 
  OSStatus
  FindWindowOfClass(const Point *where, WindowClass inWindowClass,
                    WindowRef *outWindow,
                    WindowPartCode *outWindowPart); 
  OSStatus
  CreateStandardWindowMenu(OptionBits inOptions, MenuRef *outMenu);
 
  OSStatus
  SetWindowAlternateTitle(WindowRef inWindow, CFStringRef inTitle);
 
  OSStatus
  CopyWindowAlternateTitle(WindowRef inWindow, CFStringRef *outTitle);
 
#if CALL_NOT_IN_CARBON
  void
  InitWindows(void);
 
  void
  GetWMgrPort(GrafPtr *wPort);
 
  void
  GetCWMgrPort(CGrafPtr *wMgrCPort);
 
#endif 
  Boolean
  IsValidWindowPtr(WindowRef possibleWindow);
 
#define IsValidWindowRef IsValidWindowPtr
#if CALL_NOT_IN_CARBON
  OSStatus
  InitFloatingWindows(void);
 
#endif 
  void
  HiliteWindow(WindowRef window, Boolean fHilite);
 
  void
  SetWRefCon(WindowRef window, long data);
 
  long
  GetWRefCon(WindowRef window);
 
  void
  SetWindowPic(WindowRef window, PicHandle pic);
 
  PicHandle
  GetWindowPic(WindowRef window);
 
  short
  GetWVariant(WindowRef window);
 
  OSStatus
  GetWindowFeatures(WindowRef window, UInt32 *outFeatures);
 
  OSStatus
  GetWindowRegion(WindowRef window, WindowRegionCode inRegionCode,
                  RgnHandle ioWinRgn);
 
  OSStatus
  GetWindowStructureWidths(WindowRef inWindow, Rect *outRect);
 
#if CALL_NOT_IN_CARBON
  void
  InvalRect(const Rect *badRect);
 
  void
  InvalRgn(RgnHandle badRgn);
 
  void
  ValidRect(const Rect *goodRect);
 
  void
  ValidRgn(RgnHandle goodRgn);
 
#endif 
  void
  BeginUpdate(WindowRef window);
 
  void
  EndUpdate(WindowRef window);
 
  OSStatus
  InvalWindowRgn(WindowRef window, RgnHandle region);
 
  OSStatus
  InvalWindowRect(WindowRef window, const Rect *bounds);
 
  OSStatus
  ValidWindowRgn(WindowRef window, RgnHandle region);
 
  OSStatus
  ValidWindowRect(WindowRef window, const Rect *bounds);
 
  void
  DrawGrowIcon(WindowRef window);
 
  void
  SetWTitle(WindowRef window, ConstStr255Param title);
 
  OSStatus
  SetWindowTitleWithCFString(WindowRef inWindow, CFStringRef inString);
 
  OSStatus
  CopyWindowTitleAsCFString(WindowRef inWindow, CFStringRef *outString);
 
  OSStatus
  SetWindowProxyFSSpec(WindowRef window, const FSSpec *inFile);
 
  OSStatus
  GetWindowProxyFSSpec(WindowRef window, FSSpec *outFile);
 
  OSStatus
  SetWindowProxyAlias(WindowRef window, AliasHandle alias);
 
  OSStatus
  GetWindowProxyAlias(WindowRef window, AliasHandle *alias);
 
  OSStatus
  SetWindowProxyCreatorAndType(WindowRef window, OSType fileCreator,
                               OSType fileType, SInt16 vRefNum);
 
  OSStatus
  GetWindowProxyIcon(WindowRef window, IconRef *outIcon);
 
  OSStatus
  SetWindowProxyIcon(WindowRef window, IconRef icon);
 
  OSStatus
  RemoveWindowProxy(WindowRef window);
 
  OSStatus
  BeginWindowProxyDrag(WindowRef window, DragReference *outNewDrag,
                       RgnHandle outDragOutlineRgn);
 
  OSStatus
  EndWindowProxyDrag(WindowRef window, DragReference theDrag);
 
  OSStatus
  TrackWindowProxyFromExistingDrag(WindowRef window, Point startPt,
                                   DragReference drag,
                                   RgnHandle inDragOutlineRgn);
 
  OSStatus
  TrackWindowProxyDrag(WindowRef window, Point startPt);
 
  Boolean
  IsWindowModified(WindowRef window);
 
  OSStatus
  SetWindowModified(WindowRef window, Boolean modified);
 
  Boolean
  IsWindowPathSelectClick(WindowRef window, const EventRecord *event);
 
  OSStatus
  WindowPathSelect(WindowRef window, MenuRef menu, 
                   SInt32 *outMenuResult);
 
  Boolean
  IsWindowPathSelectEvent(WindowRef window, EventRef inEvent);
 
  OSStatus
  HiliteWindowFrameForDrag(WindowRef window, Boolean hilited);
 
  typedef UInt32 WindowTransitionEffect;
  enum
  {
 
    kWindowZoomTransitionEffect = 1,
 
    kWindowSheetTransitionEffect = 2,
 
    kWindowSlideTransitionEffect = 3
  };
 
  typedef UInt32 WindowTransitionAction;
  enum
  {
 
    kWindowShowTransitionAction = 1,
 
    kWindowHideTransitionAction = 2,
 
    kWindowMoveTransitionAction = 3,
 
    kWindowResizeTransitionAction = 4
  };
 
  OSStatus
  TransitionWindow(WindowRef inWindow, WindowTransitionEffect inEffect,
                   WindowTransitionAction inAction,
                   const Rect *inRect); 
  OSStatus
  TransitionWindowAndParent(WindowRef inWindow, WindowRef inParentWindow,
                            WindowTransitionEffect inEffect,
                            WindowTransitionAction inAction,
                            const Rect *inRect); 
#if TARGET_OS_MAC
#define MacMoveWindow MoveWindow
#endif
  void
  MacMoveWindow(WindowRef window, short hGlobal, short vGlobal, Boolean front);
 
  void
  SizeWindow(WindowRef window, short w, short h, Boolean fUpdate);
 
  long
  GrowWindow(WindowRef window, Point startPt,
             const Rect *bBox) ;
 
  void
  DragWindow(WindowRef window, Point startPt,
             const Rect *boundsRect) ;
 
  void
  ZoomWindow(WindowRef window, WindowPartCode partCode, Boolean front);
 
  Boolean
  IsWindowCollapsable(WindowRef window);
 
  Boolean
  IsWindowCollapsed(WindowRef window);
 
  OSStatus
  CollapseWindow(WindowRef window, Boolean collapse);
 
  OSStatus
  CollapseAllWindows(Boolean collapse);
 
  OSStatus
  CreateQDContextForCollapsedWindowDockTile(WindowRef inWindow,
                                            CGrafPtr *outContext);
 
  OSStatus
  ReleaseQDContextForCollapsedWindowDockTile(WindowRef inWindow,
                                             CGrafPtr inContext);
 
  OSStatus
  UpdateCollapsedWindowDockTile(WindowRef inWindow);
 
  OSStatus
  GetWindowBounds(WindowRef window, WindowRegionCode regionCode,
                  Rect *globalBounds);
 
  Boolean
  ResizeWindow(WindowRef window, Point startPoint,
               const Rect *sizeConstraints, 
               Rect *newContentRect);       
  OSStatus
  SetWindowBounds(WindowRef window, WindowRegionCode regionCode,
                  const Rect *globalBounds);
 
  OSStatus
  RepositionWindow(WindowRef window, WindowRef parentWindow,
                   WindowPositionMethod method);
 
  OSStatus
  MoveWindowStructure(WindowRef window, short hGlobal, short vGlobal);
 
  Boolean
  IsWindowInStandardState(WindowRef window, Point *idealSize, 
                          Rect *idealStandardState);          
  OSStatus
  ZoomWindowIdeal(WindowRef window, WindowPartCode partCode, Point *ioIdealSize);
 
  OSStatus
  GetWindowIdealUserState(WindowRef window, Rect *userState);
 
  OSStatus
  SetWindowIdealUserState(WindowRef window, const Rect *userState);
 
  OSStatus
  GetWindowGreatestAreaDevice(WindowRef inWindow, WindowRegionCode inRegion,
                              GDHandle *outGreatestDevice,  
                              Rect *outGreatestDeviceRect); 
  typedef UInt32 WindowConstrainOptions;
  enum
  {
 
    kWindowConstrainMayResize = (1L << 0),
 
    kWindowConstrainMoveRegardlessOfFit = (1L << 1),
 
    kWindowConstrainAllowPartial = (1L << 2),
 
    kWindowConstrainCalcOnly = (1L << 3),
 
    kWindowConstrainUseTransitionWindow = (1L << 4),
 
    kWindowConstrainStandardOptions = kWindowConstrainMoveRegardlessOfFit
  };
 
  OSStatus
  ConstrainWindowToScreen(WindowRef inWindowRef, WindowRegionCode inRegionCode,
                          WindowConstrainOptions inOptions,
                          const Rect *inScreenRect, 
                          Rect *outStructure);      
  OSStatus
  GetAvailableWindowPositioningBounds(GDHandle inDevice, Rect *availableRect);
 
  void
  HideWindow(WindowRef window);
 
#if TARGET_OS_MAC
#define MacShowWindow ShowWindow
#endif
  void
  MacShowWindow(WindowRef window);
 
  void
  ShowHide(WindowRef window, Boolean showFlag);
 
#if TARGET_OS_MAC
#define MacIsWindowVisible IsWindowVisible
#endif
  Boolean
  MacIsWindowVisible(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(Boolean) MacIsWindowVisible(WindowRef window)
  {
    return ((WindowPeek)window)->visible != 0;
  }
#else
#if TARGET_OS_MAC
#define IsWindowVisible(window) (((WindowPeek)window)->visible != 0)
#else
#define MacIsWindowVisible(window) (((WindowPeek)window)->visible != 0)
#endif
#endif
#endif
 
  typedef UInt32 WindowLatentVisibility;
  enum
  {
 
    kWindowLatentVisibleFloater = 1 << 0,
 
    kWindowLatentVisibleSuspend = 1 << 1,
 
    kWindowLatentVisibleFullScreen = 1 << 2,
 
    kWindowLatentVisibleAppHidden = 1 << 3,
 
    kWindowLatentVisibleCollapsedOwner = 1 << 4,
 
    kWindowLatentVisibleCollapsedGroup = 1 << 5
  };
 
  Boolean
  IsWindowLatentVisible(
      WindowRef inWindow,
      WindowLatentVisibility *outLatentVisible); 
  OSStatus
  ShowSheetWindow(WindowRef inSheet, WindowRef inParentWindow);
 
  OSStatus
  HideSheetWindow(WindowRef inSheet);
 
  OSStatus
  GetSheetWindowParent(WindowRef inSheet, WindowRef *outParentWindow);
 
  OSStatus
  DisableScreenUpdates(void);
 
  OSStatus
  EnableScreenUpdates(void);
 
  OSStatus
  GetWindowProperty(WindowRef window, PropertyCreator propertyCreator,
                    PropertyTag propertyTag, UInt32 bufferSize,
                    UInt32 *actualSize, 
                    void *propertyBuffer);
 
  OSStatus
  GetWindowPropertySize(WindowRef window, PropertyCreator creator,
                        PropertyTag tag, UInt32 *size);
 
  OSStatus
  SetWindowProperty(WindowRef window, PropertyCreator propertyCreator,
                    PropertyTag propertyTag, UInt32 propertySize,
                    void *propertyBuffer);
 
  OSStatus
  RemoveWindowProperty(WindowRef window, PropertyCreator propertyCreator,
                       PropertyTag propertyTag);
 
  enum
  {
    kWindowPropertyPersistent = 0x00000001 
  };
 
  OSStatus
  GetWindowPropertyAttributes(WindowRef window, OSType propertyCreator,
                              OSType propertyTag, UInt32 *attributes);
 
  OSStatus
  ChangeWindowPropertyAttributes(WindowRef window, OSType propertyCreator,
                                 OSType propertyTag, UInt32 attributesToSet,
                                 UInt32 attributesToClear);
 
  long
  PinRect(const Rect *theRect, Point thePt);
 
  RgnHandle
  GetGrayRgn(void);
 
  Boolean
  TrackBox(WindowRef window, Point thePt, WindowPartCode partCode);
 
  Boolean
  TrackGoAway(WindowRef window, Point thePt);
 
  long
  DragGrayRgn(RgnHandle theRgn, Point startPt, const Rect *limitRect,
              const Rect *slopRect, short axis, DragGrayRgnUPP actionProc);
 
  long
  DragTheRgn(RgnHandle theRgn, Point startPt, const Rect *limitRect,
             const Rect *slopRect, short axis, DragGrayRgnUPP actionProc);
 
#if !OPAQUE_TOOLBOX_STRUCTS
#if CALL_NOT_IN_CARBON
 
  Boolean
  GetAuxWin(WindowRef window, AuxWinHandle *awHndl);
 
#endif 
#endif 
#if CALL_NOT_IN_CARBON
  void
  setwtitle(WindowRef window, const char *title);
 
  Boolean
  trackgoaway(WindowRef window, Point *thePt);
 
  short
  findwindow(Point *thePoint, WindowRef *window);
 
  void
  getwtitle(WindowRef window, char *title);
 
  long
  growwindow(WindowRef window, Point *startPt, const Rect *bBox);
 
  WindowRef
  newwindow(void *wStorage, const Rect *boundsRect, const char *title,
            Boolean visible, short theProc, WindowRef behind, Boolean goAwayFlag,
            long refCon);
 
  WindowRef
  newcwindow(void *wStorage, const Rect *boundsRect, const char *title,
             Boolean visible, short procID, WindowRef behind, Boolean goAwayFlag,
             long refCon);
 
  long
  pinrect(const Rect *theRect, Point *thePt);
 
  Boolean
  trackbox(WindowRef window, Point *thePt, short partCode);
 
  long
  draggrayrgn(RgnHandle theRgn, Point *startPt, const Rect *boundsRect,
              const Rect *slopRect, short axis, DragGrayRgnUPP actionProc);
 
  void
  dragwindow(WindowRef window, Point *startPt, const Rect *boundsRect);
 
#endif 
#if CALL_NOT_IN_CARBON
  Boolean
  GetWindowGoAwayFlag(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(Boolean) GetWindowGoAwayFlag(WindowRef window)
  {
    return ((WindowPeek)window)->goAwayFlag;
  }
#else
#define GetWindowGoAwayFlag(window) (((WindowPeek)window)->goAwayFlag)
#endif
#endif
 
  Boolean
  GetWindowSpareFlag(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(Boolean) GetWindowSpareFlag(WindowRef window)
  {
    return ((WindowPeek)window)->spareFlag;
  }
#else
#define GetWindowSpareFlag(window) (((WindowPeek)window)->spareFlag)
#endif
#endif
 
#endif 
  WindowRef
  GetWindowList(void);
 
  CGrafPtr
  GetWindowPort(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(CGrafPtr) GetWindowPort(WindowRef window)
  {
    return (CGrafPtr)window;
  }
#else
#define GetWindowPort(window) ((CGrafPtr)window)
#endif
#endif
 
  CGrafPtr
  GetWindowStructurePort(WindowRef inWindow);
 
  short
  GetWindowKind(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(short) GetWindowKind(WindowRef window)
  {
    return ((WindowPeek)window)->windowKind;
  }
#else
#define GetWindowKind(window) (((WindowPeek)window)->windowKind)
#endif
#endif
 
  Boolean
  IsWindowHilited(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(Boolean) IsWindowHilited(WindowRef window)
  {
    return ((WindowPeek)window)->hilited != 0;
  }
#else
#define IsWindowHilited(window) (((WindowPeek)window)->hilited != 0)
#endif
#endif
 
  Boolean
  IsWindowUpdatePending(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(Boolean) IsWindowUpdatePending(WindowRef window)
  {
    return (((WindowPeek)window)->updateRgn != NULL) &&
           !EmptyRgn(((WindowPeek)window)->updateRgn);
  }
#else
#define IsWindowUpdatePending(window)           \
  ((((WindowPeek)window)->updateRgn != NULL) && \
   !EmptyRgn(((WindowPeek)window)->updateRgn))
#endif
#endif
 
#if TARGET_OS_MAC
#define MacGetNextWindow GetNextWindow
#endif
  WindowRef
  MacGetNextWindow(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(WindowRef) MacGetNextWindow(WindowRef window)
  {
    return (WindowRef)(((WindowPeek)window)->nextWindow);
  }
#else
#if TARGET_OS_MAC
#define GetNextWindow(window) ((WindowRef)(((WindowPeek)window)->nextWindow))
#else
#define MacGetNextWindow(window) ((WindowRef)(((WindowPeek)window)->nextWindow))
#endif
#endif
#endif
 
  Rect *
  GetWindowStandardState(WindowRef window, Rect *rect);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(Rect *) GetWindowStandardState(WindowRef window, Rect *rect)
  {
    return (*(rect) = ((*(((WindowPeek)window)->dataHandle) == NULL)
                           ? *(rect)
                           : ((Rect *)(*(((WindowPeek)window)->dataHandle)))[1])),
           (rect);
  }
#else
#define GetWindowStandardState(window, rect)                               \
  ((*(rect) = ((*(((WindowPeek)window)->dataHandle) == NULL)               \
                   ? *(rect)                                               \
                   : ((Rect *)(*(((WindowPeek)window)->dataHandle)))[1])), \
   (rect))
#endif
#endif
 
  Rect *
  GetWindowUserState(WindowRef window, Rect *rect);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(Rect *) GetWindowUserState(WindowRef window, Rect *rect)
  {
    return (*(rect) = ((*(((WindowPeek)window)->dataHandle) == NULL)
                           ? *(rect)
                           : ((Rect *)(*(((WindowPeek)window)->dataHandle)))[0])),
           (rect);
  }
#else
#define GetWindowUserState(window, rect)                                   \
  ((*(rect) = ((*(((WindowPeek)window)->dataHandle) == NULL)               \
                   ? *(rect)                                               \
                   : ((Rect *)(*(((WindowPeek)window)->dataHandle)))[0])), \
   (rect))
#endif
#endif
 
  void
  SetWindowKind(WindowRef window, short kind);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(void) SetWindowKind(WindowRef window, short kind)
  {
    ((WindowPeek)window)->windowKind = kind;
  }
#else
#define SetWindowKind(window, kind) (((WindowPeek)window)->windowKind = kind)
#endif
#endif
 
  void
  SetWindowStandardState(WindowRef window, const Rect *rect);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(void)
      SetWindowStandardState(WindowRef window, const Rect *rect)
  {
    Rect *stateRects = (Rect *)(*(((WindowPeek)window)->dataHandle));
    if (stateRects != NULL)
      stateRects[1] = *rect;
  }
#else
#define SetWindowStandardState(window, rect)                          \
  do                                                                  \
  {                                                                   \
    Rect *stateRects = (Rect *)(*(((WindowPeek)window)->dataHandle)); \
    if (stateRects != NULL)                                           \
      stateRects[1] = *rect;                                          \
  } while (false)
#endif
#endif
 
  void
  SetWindowUserState(WindowRef window, const Rect *rect);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(void) SetWindowUserState(WindowRef window, const Rect *rect)
  {
    Rect *stateRects = (Rect *)(*(((WindowPeek)window)->dataHandle));
    if (stateRects != NULL)
      stateRects[0] = *rect;
  }
#else
#define SetWindowUserState(window, rect)                              \
  do                                                                  \
  {                                                                   \
    Rect *stateRects = (Rect *)(*(((WindowPeek)window)->dataHandle)); \
    if (stateRects != NULL)                                           \
      stateRects[0] = *rect;                                          \
  } while (false)
#endif
#endif
 
  void
  SetPortWindowPort(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(void) SetPortWindowPort(WindowRef window)
  {
    MacSetPort((GrafPtr)window);
  }
#else
#define SetPortWindowPort(window) (MacSetPort((GrafPtr)window))
#endif
#endif
 
  Rect *
  GetWindowPortBounds(WindowRef window, Rect *bounds);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(Rect *) GetWindowPortBounds(WindowRef window, Rect *bounds)
  {
    return ((*(bounds) = (window)->portRect)), (bounds);
  }
#else
#define GetWindowPortBounds(window, bounds) \
  (((*(bounds) = (window)->portRect)), (bounds))
#endif
#endif
 
  WindowRef
  GetWindowFromPort(CGrafPtr port);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline DEFINE_API(WindowRef) GetWindowFromPort(CGrafPtr port)
  {
    return (WindowRef)port;
  }
#else
#define GetWindowFromPort(port) ((WindowRef)port)
#endif
#endif
 
#if CALL_NOT_IN_CARBON
  Handle
  GetWindowDataHandle(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline Handle GetWindowDataHandle(WindowRef window)
  {
    return ((WindowPeek)window)->dataHandle;
  }
#else
#define GetWindowDataHandle(window) (((WindowPeek)window)->dataHandle)
#endif
#endif
 
  void
  SetWindowDataHandle(WindowRef window, Handle data);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline void SetWindowDataHandle(WindowRef window, Handle data)
  {
    ((WindowPeek)window)->dataHandle = data;
  }
#else
#define SetWindowDataHandle(window, data) \
  (((WindowPeek)window)->dataHandle = data)
#endif
#endif
 
  Boolean
  GetWindowZoomFlag(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline Boolean GetWindowZoomFlag(WindowRef window)
  {
    return ((WindowPeek)window)->spareFlag;
  }
#else
#define GetWindowZoomFlag(window) (((WindowPeek)window)->spareFlag)
#endif
#endif
 
  void
  GetWindowStructureRgn(WindowRef window, RgnHandle r);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline void GetWindowStructureRgn(WindowRef window, RgnHandle r)
  {
    MacCopyRgn(((WindowPeek)window)->strucRgn, r);
  }
#else
#define GetWindowStructureRgn(window, r) \
  (MacCopyRgn(((WindowPeek)window)->strucRgn, r))
#endif
#endif
 
  void
  GetWindowContentRgn(WindowRef window, RgnHandle r);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline void GetWindowContentRgn(WindowRef window, RgnHandle r)
  {
    MacCopyRgn(((WindowPeek)window)->contRgn, r);
  }
#else
#define GetWindowContentRgn(window, r) \
  (MacCopyRgn(((WindowPeek)window)->contRgn, r))
#endif
#endif
 
  void
  GetWindowUpdateRgn(WindowRef window, RgnHandle r);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline void GetWindowUpdateRgn(WindowRef window, RgnHandle r)
  {
    MacCopyRgn(((WindowPeek)window)->updateRgn, r);
  }
#else
#define GetWindowUpdateRgn(window, r) \
  (MacCopyRgn(((WindowPeek)window)->updateRgn, r))
#endif
#endif
 
  SInt16
  GetWindowTitleWidth(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
  inline SInt16 GetWindowTitleWidth(WindowRef window)
  {
    return ((WindowPeek)window)->titleWidth;
  }
#else
#define GetWindowTitleWidth(window) (((WindowPeek)window)->titleWidth)
#endif
#endif
 
#endif 
  enum
  {
    kWindowGroupAttrSelectable = kWindowGroupAttrSelectAsLayer,
    kWindowGroupAttrPositionFixed = kWindowGroupAttrMoveTogether,
    kWindowGroupAttrZOrderFixed = kWindowGroupAttrLayerTogether
  };
 
#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 
* /
    inline Handle GetWindowDataHandle(WindowRef window)
{
  return ((WindowPeek)window)->dataHandle;
}
#else
#define GetWindowDataHandle(window) (((WindowPeek)window)->dataHandle)
#endif
#endif
 
void SetWindowDataHandle(WindowRef window, Handle data);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
inline void SetWindowDataHandle(WindowRef window, Handle data)
{
  ((WindowPeek)window)->dataHandle = data;
}
#else
#define SetWindowDataHandle(window, data) \
  (((WindowPeek)window)->dataHandle = data)
#endif
#endif
 
Boolean
GetWindowZoomFlag(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
inline Boolean GetWindowZoomFlag(WindowRef window)
{
  return ((WindowPeek)window)->spareFlag;
}
#else
#define GetWindowZoomFlag(window) (((WindowPeek)window)->spareFlag)
#endif
#endif
 
void GetWindowStructureRgn(WindowRef window, RgnHandle r);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
inline void GetWindowStructureRgn(WindowRef window, RgnHandle r)
{
  MacCopyRgn(((WindowPeek)window)->strucRgn, r);
}
#else
#define GetWindowStructureRgn(window, r) \
  (MacCopyRgn(((WindowPeek)window)->strucRgn, r))
#endif
#endif
 
void GetWindowContentRgn(WindowRef window, RgnHandle r);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
inline void GetWindowContentRgn(WindowRef window, RgnHandle r)
{
  MacCopyRgn(((WindowPeek)window)->contRgn, r);
}
#else
#define GetWindowContentRgn(window, r) \
  (MacCopyRgn(((WindowPeek)window)->contRgn, r))
#endif
#endif
 
void GetWindowUpdateRgn(WindowRef window, RgnHandle r);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
inline void GetWindowUpdateRgn(WindowRef window, RgnHandle r)
{
  MacCopyRgn(((WindowPeek)window)->updateRgn, r);
}
#else
#define GetWindowUpdateRgn(window, r) \
  (MacCopyRgn(((WindowPeek)window)->updateRgn, r))
#endif
#endif
 
SInt16
GetWindowTitleWidth(WindowRef window);
#if !OPAQUE_TOOLBOX_STRUCTS && !ACCESSOR_CALLS_ARE_FUNCTIONS
#ifdef __cplusplus
inline SInt16 GetWindowTitleWidth(WindowRef window)
{
  return ((WindowPeek)window)->titleWidth;
}
#else
#define GetWindowTitleWidth(window) (((WindowPeek)window)->titleWidth)
#endif
#endif
 
#endif 
enum
{
  kWindowGroupAttrSelectable = kWindowGroupAttrSelectAsLayer,
  kWindowGroupAttrPositionFixed = kWindowGroupAttrMoveTogether,
  kWindowGroupAttrZOrderFixed = kWindowGroupAttrLayerTogether
};
 
#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 
* / if PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif            
* /*/*/ * /*/*/ * /*/*/