/*
       File:       Components.h
   
       Contains:   QuickTime Interfaces.
   
       Version:    Technology: QuickTime 6.0
                   Release:    QuickTime 6.0.2
   
       Copyright:  (c) 1990-2001 by Apple Computer, Inc., all rights reserved
   
       Bugs?:      For bug reports, consult the following page on
                   the World Wide Web:
   
                       http://developer.apple.com/bugreporter/
   
  */
  ifndef __COMPONENTS__
  define __COMPONENTS__
  
  ifndef __MACERRORS__
  include <MacErrors.h>
  endif
  
  ifndef __MACTYPES__
  include <MacTypes.h>
  endif
  
  ifndef __MIXEDMODE__
  include <MixedMode.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'),       /* Apple supplied components */
      kComponentResourceType      = FOUR_CHAR_CODE('thng'),       /* a components resource type */
      kComponentAliasResourceType = FOUR_CHAR_CODE('thga')        /* component alias resource type */
  };
  
  enum {
      kAnyComponentType           = 0,
      kAnyComponentSubType        = 0,
      kAnyComponentManufacturer   = 0,
      kAnyComponentFlagsMask      = 0
  };
  
  enum {
      cmpIsMissing                = 1L << 29,
      cmpWantsRegisterMessage     = 1L << 31
  };
  
  enum {
      kComponentOpenSelect        = -1,                           /* ComponentInstance for this open */
      kComponentCloseSelect       = -2,                           /* ComponentInstance for this close */
      kComponentCanDoSelect       = -3,                           /* selector # being queried */
      kComponentVersionSelect     = -4,                           /* no params */
      kComponentRegisterSelect    = -5,                           /* no params */
      kComponentTargetSelect      = -6,                           /* ComponentInstance for top of call chain */
      kComponentUnregisterSelect  = -7,                           /* no params */
      kComponentGetMPWorkFunctionSelect = -8,                     /* some params */
      kComponentExecuteWiredActionSelect = -9,                    /* QTAtomContainer actionContainer, QTAtom actionAtom, QTCustomActionTargetPtr target, QTEventRecordPtr event */
      kComponentGetPublicResourceSelect = -10                     /* OSType resourceType, short resourceId, Handle *resource */
  };
  
  /* Component Resource Extension flags */
  enum {
      componentDoAutoVersion      = (1 << 0),
      componentWantsUnregister    = (1 << 1),
      componentAutoVersionIncludeFlags = (1 << 2),
      componentHasMultiplePlatforms = (1 << 3),
      componentLoadResident       = (1 << 4)
  };
  
  /* Set Default Component flags */
  enum {
      defaultComponentIdentical   = 0,
      defaultComponentAnyFlags    = 1,
      defaultComponentAnyManufacturer = 2,
      defaultComponentAnySubType  = 4,
      defaultComponentAnyFlagsAnyManufacturer = (defaultComponentAnyFlags + defaultComponentAnyManufacturer),
      defaultComponentAnyFlagsAnyManufacturerAnySubType = (defaultComponentAnyFlags + defaultComponentAnyManufacturer + defaultComponentAnySubType)
  };
  
  /* RegisterComponentResource flags */
  enum {
      registerComponentGlobal     = 1,
      registerComponentNoDuplicates = 2,
      registerComponentAfterExisting = 4,
      registerComponentAliasesOnly = 8
  };
  
  struct ComponentDescription {
      OSType                          componentType;              /* A unique 4-byte code indentifying the command set */
      OSType                          componentSubType;           /* Particular flavor of this instance */
      OSType                          componentManufacturer;      /* Vendor indentification */
      unsigned long                   componentFlags;             /* 8 each for Component,Type,SubType,Manuf/revision */
      unsigned long                   componentFlagsMask;         /* Mask for specifying which flags to consider in search, zero during registration */
  };
  typedef struct ComponentDescription     ComponentDescription;
  
  struct ResourceSpec {
      OSType                          resType;                    /* 4-byte code    */
      short                           resID;                      /*         */
  };
  typedef struct ResourceSpec             ResourceSpec;
  
  struct ComponentResource {
      ComponentDescription            cd;                         /* Registration parameters */
      ResourceSpec                    component;                  /* resource where Component code is found */
      ResourceSpec                    componentName;              /* name string resource */
      ResourceSpec                    componentInfo;              /* info string resource */
      ResourceSpec                    componentIcon;              /* icon resource */
  };
  typedef struct ComponentResource        ComponentResource;
  typedef ComponentResource *             ComponentResourcePtr;
  typedef ComponentResourcePtr *          ComponentResourceHandle;
  
  struct ComponentPlatformInfo {
      long                            componentFlags;             /* flags of Component */
      ResourceSpec                    component;                  /* resource where Component code is found */
      short                           platformType;               /* gestaltSysArchitecture result */
  };
  typedef struct ComponentPlatformInfo    ComponentPlatformInfo;
  
  struct ComponentResourceExtension {
      long                            componentVersion;           /* version of Component */
      long                            componentRegisterFlags;     /* flags for registration */
      short                           componentIconFamily;        /* resource id of Icon Family */
  };
  typedef struct ComponentResourceExtension ComponentResourceExtension;
  
  struct ComponentPlatformInfoArray {
      long                            count;
      ComponentPlatformInfo           platformArray[1];
  };
  typedef struct ComponentPlatformInfoArray ComponentPlatformInfoArray;
  
  struct ExtComponentResource {
      ComponentDescription            cd;                         /* registration parameters */
      ResourceSpec                    component;                  /* resource where Component code is found */
      ResourceSpec                    componentName;              /* name string resource */
      ResourceSpec                    componentInfo;              /* info string resource */
      ResourceSpec                    componentIcon;              /* icon resource */
      long                            componentVersion;           /* version of Component */
      long                            componentRegisterFlags;     /* flags for registration */
      short                           componentIconFamily;        /* resource id of Icon Family */
      long                            count;                      /* elements in platformArray */
      ComponentPlatformInfo           platformArray[1];
  };
  typedef struct ExtComponentResource     ExtComponentResource;
  typedef ExtComponentResource *          ExtComponentResourcePtr;
  typedef ExtComponentResourcePtr *       ExtComponentResourceHandle;
  
  struct ComponentAliasResource {
      ComponentResource               cr;                         /* Registration parameters */
      ComponentDescription            aliasCD;                    /* component alias description */
  };
  typedef struct ComponentAliasResource   ComponentAliasResource;
  /*  Structure received by Component:        */
  
  struct ComponentParameters {
      UInt8                           flags;                      /* call modifiers: sync/async, deferred, immed, etc */
      UInt8                           paramSize;                  /* size in bytes of actual parameters passed to this call */
      short                           what;                       /* routine selector, negative for Component management calls */
      long                            params[1];                  /* actual parameters for the indicated routine */
  };
  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;
  
  typedef RegisteredComponentRecord *     RegisteredComponentPtr;
  
  struct RegisteredComponentInstanceRecord {
      long                            data[1];
  };
  typedef struct RegisteredComponentInstanceRecord RegisteredComponentInstanceRecord;
  typedef RegisteredComponentInstanceRecord * RegisteredComponentInstanceRecordPtr;
  
  typedef RegisteredComponentInstanceRecord * RegisteredComponentInstancePtr;
  typedef long                            ComponentResult;
  enum {
      platform68k                 = 1,                            /* platform type (response from gestaltComponentPlatform) */
      platformPowerPC             = 2,                            /* (when gestaltComponentPlatform is not implemented, use */
      platformInterpreted         = 3,                            /* gestaltSysArchitecture) */
      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;
  /*
      The parameter list for each ComponentFunction is unique. It is
      therefore up to users to create the appropriate procInfo for their
      own ComponentFunctions where necessary.
  */
  
  typedef UniversalProcPtr                ComponentFunctionUPP;
  /*
      For Carbon, we add NewComponentFunctionUPP and DisposeComponentFunctionUPP
      calls that take a procInfo as their second parameter. This allows native
      Component writers to easily write a Carbon compliant component. Note that
      there is no InvokeComponentFunctionUPP, use the CallComponentFunction calls
      with the UPP instead.
  */
  
  if OPAQUE_UPP_TYPES
  EXTERN_API( ComponentFunctionUPP )
  NewComponentFunctionUPP         (ProcPtr                userRoutine,
                                   ProcInfoType           procInfo);
  
  EXTERN_API( void )
  DisposeComponentFunctionUPP     (ComponentFunctionUPP   userUPP);
  
  else
  define NewComponentFunctionUPP(userRoutine,procInfo)       (ComponentFunctionUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), (ProcInfoType)procInfo, GetCurrentArchitecture())
  define DisposeComponentFunctionUPP(userUPP)                DisposeRoutineDescriptor(userUPP)
  endif  /* OPAQUE_UPP_TYPES */
  
  if TARGET_RT_MAC_CFM
  /* 
      CallComponentUPP is a global variable exported from InterfaceLib.
      It is the ProcPtr passed to CallUniversalProc to manually call a component function.
  */
  extern UniversalProcPtr CallComponentUPP;
  endif
  
  define ComponentCallNow( callNumber, paramSize ) \
      FIVEWORDINLINE( 0x2F3C,paramSize,callNumber,0x7000,0xA82A )