Components.h

Go to the documentation of this file.

 
#ifndef __COMPONENTS__
#define __COMPONENTS__
 
#ifndef __MACERRORS__
#include <MacErrors.h>
#endif
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
 
#ifndef __FILES__
#include <Files.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
  {
    kAppleManufacturer = FOUR_CHAR_CODE('appl'), 
    kComponentResourceType =
        FOUR_CHAR_CODE('thng'), 
    kComponentAliasResourceType =
        FOUR_CHAR_CODE('thga') 
  };
 
  enum
  {
    kAnyComponentType = 0,
    kAnyComponentSubType = 0,
    kAnyComponentManufacturer = 0,
    kAnyComponentFlagsMask = 0
  };
 
  enum
  {
    cmpIsMissing = 1L << 29,
    cmpWantsRegisterMessage = 1L << 31
  };
 
  enum
  {
    kComponentOpenSelect = -1,              
    kComponentCloseSelect = -2,             
    kComponentCanDoSelect = -3,             
    kComponentVersionSelect = -4,           
    kComponentRegisterSelect = -5,          
    kComponentTargetSelect = -6,            
    kComponentUnregisterSelect = -7,        
    kComponentGetMPWorkFunctionSelect = -8, 
    kComponentExecuteWiredActionSelect =
        -9, 
    kComponentGetPublicResourceSelect =
        -10 
  };
 
  enum
  {
    componentDoAutoVersion = (1 << 0),
    componentWantsUnregister = (1 << 1),
    componentAutoVersionIncludeFlags = (1 << 2),
    componentHasMultiplePlatforms = (1 << 3),
    componentLoadResident = (1 << 4)
  };
 
  enum
  {
    defaultComponentIdentical = 0,
    defaultComponentAnyFlags = 1,
    defaultComponentAnyManufacturer = 2,
    defaultComponentAnySubType = 4,
    defaultComponentAnyFlagsAnyManufacturer =
        (defaultComponentAnyFlags + defaultComponentAnyManufacturer),
    defaultComponentAnyFlagsAnyManufacturerAnySubType =
        (defaultComponentAnyFlags + defaultComponentAnyManufacturer +
         defaultComponentAnySubType)
  };
 
  enum
  {
    registerComponentGlobal = 1,
    registerComponentNoDuplicates = 2,
    registerComponentAfterExisting = 4,
    registerComponentAliasesOnly = 8
  };
 
  struct ComponentDescription
  {
    OSType componentType;         
    OSType componentSubType;      
    OSType componentManufacturer; 
    unsigned long
        componentFlags; 
    unsigned long
        componentFlagsMask; 
  };
  typedef struct ComponentDescription ComponentDescription;
 
  struct ResourceSpec
  {
    OSType resType; 
    short resID;    
  };
  typedef struct ResourceSpec ResourceSpec;
  struct ComponentResource
  {
    ComponentDescription cd;    
    ResourceSpec component;     
    ResourceSpec componentName; 
    ResourceSpec componentInfo; 
    ResourceSpec componentIcon; 
  };
  typedef struct ComponentResource ComponentResource;
  typedef ComponentResource *ComponentResourcePtr;
  typedef ComponentResourcePtr *ComponentResourceHandle;
  struct ComponentPlatformInfo
  {
    long componentFlags;    
    ResourceSpec component; 
    short platformType;     
  };
  typedef struct ComponentPlatformInfo ComponentPlatformInfo;
  struct ComponentResourceExtension
  {
    long componentVersion;       
    long componentRegisterFlags; 
    short componentIconFamily;   
  };
  typedef struct ComponentResourceExtension ComponentResourceExtension;
  struct ComponentPlatformInfoArray
  {
    long count;
    ComponentPlatformInfo platformArray[1];
  };
  typedef struct ComponentPlatformInfoArray ComponentPlatformInfoArray;
  struct ExtComponentResource
  {
    ComponentDescription cd;     
    ResourceSpec component;      
    ResourceSpec componentName;  
    ResourceSpec componentInfo;  
    ResourceSpec componentIcon;  
    long componentVersion;       
    long componentRegisterFlags; 
    short componentIconFamily;   
    long count;                  
    ComponentPlatformInfo platformArray[1];
  };
  typedef struct ExtComponentResource ExtComponentResource;
  typedef ExtComponentResource *ExtComponentResourcePtr;
  typedef ExtComponentResourcePtr *ExtComponentResourceHandle;
  struct ComponentAliasResource
  {
    ComponentResource cr;         
    ComponentDescription aliasCD; 
  };
  typedef struct ComponentAliasResource ComponentAliasResource;
  struct ComponentParameters
  {
    UInt8 flags;     
    UInt8 paramSize; 
    short what;      
    long params[1];  
  };
  typedef struct ComponentParameters ComponentParameters;
  struct ComponentRecord
  {
    long data[1];
  };
  typedef struct ComponentRecord ComponentRecord;
  typedef ComponentRecord *Component;
  struct ComponentInstanceRecord
  {
    long data[1];
  };
  typedef struct ComponentInstanceRecord ComponentInstanceRecord;
  typedef ComponentInstanceRecord *ComponentInstance;
  struct RegisteredComponentRecord
  {
    long data[1];
  };
  typedef struct RegisteredComponentRecord RegisteredComponentRecord;
  typedef RegisteredComponentRecord *RegisteredComponentRecordPtr;
  struct RegisteredComponentInstanceRecord
  {
    long data[1];
  };
  typedef struct RegisteredComponentInstanceRecord
      RegisteredComponentInstanceRecord;
  typedef RegisteredComponentInstanceRecord *RegisteredComponentInstanceRecordPtr;
  typedef long ComponentResult;
  enum
  {
    platform68k = 1, 
    platformPowerPC =
        2,                   
    platformInterpreted = 3, 
    platformWin32 = 4,
    platformPowerPCNativeEntryPoint = 5
  };
 
  enum
  {
    mpWorkFlagDoWork = (1 << 0),
    mpWorkFlagDoCompletion = (1 << 1),
    mpWorkFlagCopyWorkBlock = (1 << 2),
    mpWorkFlagDontBlock = (1 << 3),
    mpWorkFlagGetProcessorCount = (1 << 4),
    mpWorkFlagGetIsRunning = (1 << 6)
  };
 
  enum
  {
    cmpAliasNoFlags = 0,
    cmpAliasOnlyThisFile = 1
  };
 
  struct ComponentMPWorkFunctionHeaderRecord
  {
    UInt32 headerSize;
    UInt32 recordSize;
    UInt32 workFlags;
    UInt16 processorCount;
    UInt8 unused;
    UInt8 isRunning;
  };
  typedef struct ComponentMPWorkFunctionHeaderRecord
      ComponentMPWorkFunctionHeaderRecord;
  typedef ComponentMPWorkFunctionHeaderRecord
      *ComponentMPWorkFunctionHeaderRecordPtr;
  typedef CALLBACK_API(ComponentResult, ComponentMPWorkFunctionProcPtr)(
      void *globalRefCon, ComponentMPWorkFunctionHeaderRecordPtr header);
  typedef CALLBACK_API(ComponentResult,
                       ComponentRoutineProcPtr)(ComponentParameters *cp,
                                                Handle componentStorage);
  typedef CALLBACK_API(OSErr, GetMissingComponentResourceProcPtr)(
      Component c, OSType resType, short resID, void *refCon, Handle *resource);
  typedef STACK_UPP_TYPE(ComponentMPWorkFunctionProcPtr)
      ComponentMPWorkFunctionUPP;
  typedef STACK_UPP_TYPE(ComponentRoutineProcPtr) ComponentRoutineUPP;
  typedef STACK_UPP_TYPE(GetMissingComponentResourceProcPtr)
      GetMissingComponentResourceUPP;
  typedef UniversalProcPtr ComponentFunctionUPP;
  ComponentFunctionUPP
  NewComponentFunctionUPP(ProcPtr userRoutine, ProcInfoType procInfo);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline DEFINE_API(ComponentFunctionUPP)
      NewComponentFunctionUPP(ProcPtr userRoutine, ProcInfoType procInfo)
  {
    return (ComponentFunctionUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), (ProcInfoType)procInfo, GetCurrentArchitecture());
  }
#else
#define NewComponentFunctionUPP(userRoutine, procInfo)                \
  ((ComponentFunctionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), \
                                              (ProcInfoType)procInfo, \
                                              GetCurrentArchitecture()))
#endif
#endif
 
  void
  DisposeComponentFunctionUPP(ComponentFunctionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline DEFINE_API(void)
      DisposeComponentFunctionUPP(ComponentFunctionUPP userUPP)
  {
    DisposeRoutineDescriptor(userUPP);
  }
#else
#define DisposeComponentFunctionUPP(userUPP) (DisposeRoutineDescriptor(userUPP))
#endif
#endif
 
#if TARGET_RT_MAC_CFM
  extern UniversalProcPtr CallComponentUPP;
#endif
 
#define ComponentCallNow(callNumber, paramSize)                                );
 
  Component
  RegisterComponentResource(ComponentResourceHandle cr, short global);
 
  OSErr
  UnregisterComponent(Component aComponent);
 
  Component
  FindNextComponent(Component aComponent, ComponentDescription *looking);
 
  long
  CountComponents(ComponentDescription *looking);
 
  OSErr
  GetComponentInfo(Component aComponent, ComponentDescription *cd,
                   Handle componentName, Handle componentInfo,
                   Handle componentIcon);
 
  long
  GetComponentListModSeed(void);
 
  long
  GetComponentTypeModSeed(OSType componentType);
 
  /*********************************************************
   * Component Instance Allocation and dispatch routines
   ********************************************************/
  OSErr
  OpenAComponent(Component aComponent, ComponentInstance *ci);
 
  ComponentInstance
  OpenComponent(Component aComponent);
 
  OSErr
  CloseComponent(ComponentInstance aComponentInstance);
 
  OSErr
  GetComponentInstanceError(ComponentInstance aComponentInstance);
 
  /*********************************************************
   * Component aliases
   ********************************************************/
  Component
  ResolveComponentAlias(Component aComponent);
 
  /*********************************************************
   * Component public resources and public string lists
   ********************************************************/
  OSErr
  GetComponentPublicResource(Component aComponent, OSType resourceType,
                             short resourceID, Handle *theResource);
 
  OSErr
  GetComponentPublicResourceList(OSType resourceType, short resourceID,
                                 long flags, ComponentDescription *cd,
                                 GetMissingComponentResourceUPP missingProc,
                                 void *refCon, void *atomContainerPtr);
 
  OSErr
  GetComponentPublicIndString(Component aComponent, Str255 theString,
                              short strListID, short index);
 
  /*********************************************************
   *                                                       *
   *                   CALLS MADE BY COMPONENTS            *
   *                                                       *
   ********************************************************/
  /*********************************************************
   * Component Management routines
   ********************************************************/
  void
  SetComponentInstanceError(ComponentInstance aComponentInstance, OSErr theError);
 
  long
  GetComponentRefcon(Component aComponent);
 
  void
  SetComponentRefcon(Component aComponent, long theRefcon);
 
  short
  OpenComponentResFile(Component aComponent);
 
  OSErr
  OpenAComponentResFile(Component aComponent, short *resRef);
 
  OSErr
  CloseComponentResFile(short refnum);
 
  OSErr
  GetComponentResource(Component aComponent, OSType resType, short resID,
                       Handle *theResource);
 
  OSErr
  GetComponentIndString(Component aComponent, Str255 theString, short strListID,
                        short index);
 
  /*********************************************************
   * Component Instance Management routines
   ********************************************************/
  Handle
  GetComponentInstanceStorage(ComponentInstance aComponentInstance);
 
  void
  SetComponentInstanceStorage(ComponentInstance aComponentInstance,
                              Handle theStorage);
 
#if CALL_NOT_IN_CARBON
  long
  GetComponentInstanceA5(ComponentInstance aComponentInstance);
 
  void
  SetComponentInstanceA5(ComponentInstance aComponentInstance, long theA5);
 
#endif 
  long
  CountComponentInstances(Component aComponent);
 
  long
  CallComponentFunction(ComponentParameters *params, ComponentFunctionUPP func);
 
  long
  CallComponentFunctionWithStorage(Handle storage, ComponentParameters *params,
                                   ComponentFunctionUPP func);
 
#if TARGET_CPU_PPC && TARGET_OS_MAC
  long
  CallComponentFunctionWithStorageProcInfo(Handle storage,
                                           ComponentParameters *params,
                                           ProcPtr func,
                                           ProcInfoType funcProcInfo);
 
#else
#define CallComponentFunctionWithStorageProcInfo(storage, params, func, \
                                                 funcProcInfo)          \
  CallComponentFunctionWithStorage(storage, params, func)
 
#endif 
  long
  DelegateComponentCall(ComponentParameters *originalParams, ComponentInstance ci);
 
  OSErr
  SetDefaultComponent(Component aComponent, short flags);
 
  ComponentInstance
  OpenDefaultComponent(OSType componentType, OSType componentSubType);
 
  OSErr
  OpenADefaultComponent(OSType componentType, OSType componentSubType,
                        ComponentInstance *ci);
 
  Component
  CaptureComponent(Component capturedComponent, Component capturingComponent);
 
  OSErr
  UncaptureComponent(Component aComponent);
 
  long
  RegisterComponentResourceFile(short resRefNum, short global);
 
  OSErr
  GetComponentIconSuite(Component aComponent, Handle *iconSuite);
 
  /*********************************************************
   *                                                       *
   *           Direct calls to the Components              *
   *                                                       *
   ********************************************************/
  long
  ComponentFunctionImplemented(ComponentInstance ci, short ftnNumber);
 
  long
  GetComponentVersion(ComponentInstance ci);
 
  long
  ComponentSetTarget(ComponentInstance ci, ComponentInstance target);
 
  ComponentResult
  CallComponentOpen(ComponentInstance ci, ComponentInstance self);
 
  ComponentResult
  CallComponentClose(ComponentInstance ci, ComponentInstance self);
 
  ComponentResult
  CallComponentCanDo(ComponentInstance ci, short ftnNumber);
 
  ComponentResult
  CallComponentVersion(ComponentInstance ci);
 
  ComponentResult
  CallComponentRegister(ComponentInstance ci);
 
  ComponentResult
  CallComponentTarget(ComponentInstance ci, ComponentInstance target);
 
  ComponentResult
  CallComponentUnregister(ComponentInstance ci);
 
  ComponentResult
  CallComponentGetMPWorkFunction(ComponentInstance ci,
                                 ComponentMPWorkFunctionUPP *workFunction,
                                 void **refCon);
 
  ComponentResult
  CallComponentGetPublicResource(ComponentInstance ci, OSType resourceType,
                                 short resourceID, Handle *resource);
 
#if !TARGET_OS_MAC
#if CALL_NOT_IN_CARBON
  ComponentResult
  CallComponent(ComponentInstance ci, ComponentParameters *cp);
 
#endif 
#endif 
  ComponentResult
  CallComponentDispatch(ComponentParameters *cp);
 
  ComponentMPWorkFunctionUPP
  NewComponentMPWorkFunctionUPP(ComponentMPWorkFunctionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppComponentMPWorkFunctionProcInfo = 0x000003F0
  }; 
#ifdef __cplusplus
  inline ComponentMPWorkFunctionUPP
  NewComponentMPWorkFunctionUPP(ComponentMPWorkFunctionProcPtr userRoutine)
  {
    return (ComponentMPWorkFunctionUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppComponentMPWorkFunctionProcInfo,
        GetCurrentArchitecture());
  }
#else
#define NewComponentMPWorkFunctionUPP(userRoutine)                \
  (ComponentMPWorkFunctionUPP) NewRoutineDescriptor(              \
      (ProcPtr)(userRoutine), uppComponentMPWorkFunctionProcInfo, \
      GetCurrentArchitecture())
#endif
#endif
 
  ComponentRoutineUPP
  NewComponentRoutineUPP(ComponentRoutineProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppComponentRoutineProcInfo = 0x000003F0
  }; 
#ifdef __cplusplus
  inline ComponentRoutineUPP
  NewComponentRoutineUPP(ComponentRoutineProcPtr userRoutine)
  {
    return (ComponentRoutineUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                     uppComponentRoutineProcInfo,
                                                     GetCurrentArchitecture());
  }
#else
#define NewComponentRoutineUPP(userRoutine)                               \
  (ComponentRoutineUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),      \
                                             uppComponentRoutineProcInfo, \
                                             GetCurrentArchitecture())
#endif
#endif
 
  GetMissingComponentResourceUPP
  NewGetMissingComponentResourceUPP(
      GetMissingComponentResourceProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppGetMissingComponentResourceProcInfo = 0x0000FBE0
  }; 
#ifdef __cplusplus
  inline GetMissingComponentResourceUPP NewGetMissingComponentResourceUPP(
      GetMissingComponentResourceProcPtr userRoutine)
  {
    return (GetMissingComponentResourceUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppGetMissingComponentResourceProcInfo,
        GetCurrentArchitecture());
  }
#else
#define NewGetMissingComponentResourceUPP(userRoutine)                \
  (GetMissingComponentResourceUPP) NewRoutineDescriptor(              \
      (ProcPtr)(userRoutine), uppGetMissingComponentResourceProcInfo, \
      GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeComponentMPWorkFunctionUPP(ComponentMPWorkFunctionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void
  DisposeComponentMPWorkFunctionUPP(ComponentMPWorkFunctionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeComponentMPWorkFunctionUPP(userUPP) \
  DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeComponentRoutineUPP(ComponentRoutineUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeComponentRoutineUPP(ComponentRoutineUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeComponentRoutineUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeGetMissingComponentResourceUPP(GetMissingComponentResourceUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void
  DisposeGetMissingComponentResourceUPP(GetMissingComponentResourceUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeGetMissingComponentResourceUPP(userUPP) \
  DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  ComponentResult
  InvokeComponentMPWorkFunctionUPP(void *globalRefCon,
                                   ComponentMPWorkFunctionHeaderRecordPtr header,
                                   ComponentMPWorkFunctionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline ComponentResult
  InvokeComponentMPWorkFunctionUPP(void *globalRefCon,
                                   ComponentMPWorkFunctionHeaderRecordPtr header,
                                   ComponentMPWorkFunctionUPP userUPP)
  {
    return (ComponentResult)CALL_TWO_PARAMETER_UPP(
        userUPP, uppComponentMPWorkFunctionProcInfo, globalRefCon, header);
  }
#else
#define InvokeComponentMPWorkFunctionUPP(globalRefCon, header, userUPP) \
  (ComponentResult) CALL_TWO_PARAMETER_UPP(                             \
      (userUPP), uppComponentMPWorkFunctionProcInfo, (globalRefCon), (header))
#endif
#endif
 
  ComponentResult
  InvokeComponentRoutineUPP(ComponentParameters *cp, Handle componentStorage,
                            ComponentRoutineUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline ComponentResult InvokeComponentRoutineUPP(ComponentParameters *cp,
                                                   Handle componentStorage,
                                                   ComponentRoutineUPP userUPP)
  {
    return (ComponentResult)CALL_TWO_PARAMETER_UPP(
        userUPP, uppComponentRoutineProcInfo, cp, componentStorage);
  }
#else
#define InvokeComponentRoutineUPP(cp, componentStorage, userUPP) \
  (ComponentResult) CALL_TWO_PARAMETER_UPP(                      \
      (userUPP), uppComponentRoutineProcInfo, (cp), (componentStorage))
#endif
#endif
 
  OSErr
  InvokeGetMissingComponentResourceUPP(Component c, OSType resType, short resID,
                                       void *refCon, Handle *resource,
                                       GetMissingComponentResourceUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSErr
  InvokeGetMissingComponentResourceUPP(Component c, OSType resType, short resID,
                                       void *refCon, Handle *resource,
                                       GetMissingComponentResourceUPP userUPP)
  {
    return (OSErr)CALL_FIVE_PARAMETER_UPP(userUPP,
                                          uppGetMissingComponentResourceProcInfo,
                                          c, resType, resID, refCon, resource);
  }
#else
#define InvokeGetMissingComponentResourceUPP(c, resType, resID, refCon,        \
                                             resource, userUPP)                \
  (OSErr) CALL_FIVE_PARAMETER_UPP((userUPP),                                   \
                                  uppGetMissingComponentResourceProcInfo, (c), \
                                  (resType), (resID), (refCon), (resource))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
#define NewComponentMPWorkFunctionProc(userRoutine) \
  NewComponentMPWorkFunctionUPP(userRoutine)
#define NewComponentRoutineProc(userRoutine) NewComponentRoutineUPP(userRoutine)
#define NewGetMissingComponentResourceProc(userRoutine) \
  NewGetMissingComponentResourceUPP(userRoutine)
#define CallComponentMPWorkFunctionProc(userRoutine, globalRefCon, header) \
  InvokeComponentMPWorkFunctionUPP(globalRefCon, header, userRoutine)
#define CallComponentRoutineProc(userRoutine, cp, componentStorage) \
  InvokeComponentRoutineUPP(cp, componentStorage, userRoutine)
#define CallGetMissingComponentResourceProc(userRoutine, c, resType, resID, \
                                            refCon, resource)               \
  InvokeGetMissingComponentResourceUPP(c, resType, resID, refCon, resource, \
                                       userRoutine)
#endif 
  enum
  {
    uppComponentFunctionImplementedProcInfo = 0x000002F0,
    uppGetComponentVersionProcInfo = 0x000000F0,
    uppComponentSetTargetProcInfo = 0x000003F0,
    uppCallComponentOpenProcInfo = 0x000003F0,
    uppCallComponentCloseProcInfo = 0x000003F0,
    uppCallComponentCanDoProcInfo = 0x000002F0,
    uppCallComponentVersionProcInfo = 0x000000F0,
    uppCallComponentRegisterProcInfo = 0x000000F0,
    uppCallComponentTargetProcInfo = 0x000003F0,
    uppCallComponentUnregisterProcInfo = 0x000000F0,
    uppCallComponentGetMPWorkFunctionProcInfo = 0x00000FF0,
    uppCallComponentGetPublicResourceProcInfo = 0x00003BF0
  };
 
#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