PIGeneral.h

Go to the documentation of this file.

// ADOBE SYSTEMS INCORPORATED
// (c) Copyright  1991 - 2007 Adobe Systems Incorporated
// All Rights Reserved
//
// NOTICE:  Adobe permits you to use, modify, and distribute this 
// file in accordance with the terms of the Adobe license agreement
// accompanying it.  If you have received this file from a source
// other than Adobe, then your use, modification, or distribution
// of it requires the prior written permission of Adobe.
//-------------------------------------------------------------------
#ifndef __PIGeneral_h__
#define __PIGeneral_h__

#pragma once

// application specific
#include "PITypes.h"
#include "PIResDefines.h"
#include "SPFiles.h"    // SPPlatformFileSpecificationW and XPlatFileSpec

#ifdef __PSWorld__
#include "UGeometry.h"
#include "PSWorldEnums.h"
#endif

#if PRAGMA_STRUCT_ALIGN
#pragma options align=mac68k
#endif

//-------------------------------------------------------------------------------
//  Defines -- Photoshop signature -- '8BIM'
//-------------------------------------------------------------------------------

#define kPhotoshopSignature     0x3842494d

//-------------------------------------------------------------------------------
//  Defines -- General plug-in error codes.
//-------------------------------------------------------------------------------



#define errPlugInHostInsufficient           -30900

#define errPlugInPropertyUndefined          -30901

#define errHostDoesNotSupportColStep        -30902

#define errInvalidSamplePoint               -30903
         
#define errReportString                     -30904

/* New in 8.0 */

#define errHostVersionIncompatible          -30905


//-------------------------------------------------------------------------------
//  Defines -- Channel Port error codes.
//-------------------------------------------------------------------------------


#define errUnknownPort                      -30910    
#define errUnsupportedRowBits               -30911    
#define errUnsupportedColBits               -30912    
#define errUnsupportedBitOffset             -30913    
#define errUnsupportedDepth                 -30914    
#define errUnsupportedDepthConversion       -30915    
//-------------------------------------------------------------------------------
//  Defines -- Scripting system error codes.
//-------------------------------------------------------------------------------



#define errWrongPlatformFilePath            -30916  
#define errIllegalCharInID                  -30917  
#define errMissingParameter                 -1715   
//-------------------------------------------------------------------------------
//
//  General PiPL Properties
//
//  These properties are also defined by Suite Pea, so we must bracket their
//  definition to make sure they are only defined once.
//
//-------------------------------------------------------------------------------


#ifndef kGeneralPiPLPropertiesDefined
#define kGeneralPiPLPropertiesDefined  
typedef uint32 PIType;  
//-------------------------------------------------------------------------------
//  Defines -- Current PiPL version and code descriptor properties.
//-------------------------------------------------------------------------------

#define kCurrentPiPLVersion     0




#define PIKindProperty          0x6b696e64L

// 'mi64' <PIMacCodeDesc> Intel 64 Mach-O code descriptor. See struct below.
#define PICodeMacIntel64Property    'mi64'

// 'ma64' <PIMacCodeDesc> ARM 64 Mach-O code descriptor. See struct below.
#define PICodeMacARM64Property  'ma64'


// '8664' <PIWin64CodeDesc> Win32 Intel code descriptor. See struct below.
#define PIWin64X86CodeProperty  0x38363634L

// 'wa86' <PIWin64CodeDesc> Win32 ARM code descriptor. See struct below.
#define PIWin64ARMCodeProperty  0x77613634L

//-------------------------------------------------------------------------------
//  Structures -- PiPL entry definition.
//-------------------------------------------------------------------------------

typedef struct PIProperty
{
    PIType vendorID;
    
    PIType propertyKey;
    
    int32  propertyID;
    
    int32  propertyLength;
    
    char   propertyData [1];

} PIProperty;


typedef struct PIPropertyList
{
    int32 version;

    int32 count;

    PIProperty properties[1];

} PIPropertyList;

//-------------------------------------------------------------------------------
//
//  Structures -- PiPL types.
//
//  Below are structures describing types used in plug-in property lists.
//  These structures obey Macintosh 68k alignment and padding rules though
//  generally they are laid out so fields have natural alignment and any
//  needed padding is explicit in the structure.
//
//  In addition to these structure types, simple types such as int32, int16,
//  etc. are used. Two other examples are PString and FlagSet.
//
//  PString is like a rez pstring or a Str255 except that storage may not
//  be present for all 255 characters.  The initial length byte is present
//  in the property.
//
//  FlagSet is a variable length bitstring in which the first member is
//  represented by the most significant bit of the first byte, the eighth
//  member is in the least significant bit of the first byte, etc.
//  The length of the set is in the property's length field.
//
//  Arrays are also used in places with bounds either taken from the
//  property length or explicitly represented within the property.
//
//-------------------------------------------------------------------------------

// For 'mi64' PICodeMacIntel64Property:
// For 'ma64' PICodeMacARM64Property:
typedef struct PIMacCodeDesc
{

    // Name of entrypoint ("main", "ENTRYPOINT", "", etc.):
    unsigned char fEntryName[1];

} PIMacCodeDesc;

// For compatibilty with previous name for PIMacCodeDesc
typedef PIMacCodeDesc PIMacIntelCodeDesc;

typedef struct PIWin64CodeDesc
{
    char fEntryName[1];
} PIWin64CodeDesc;

// For compatibility with previous name of PIWin64CodeDesc
typedef PIWin64CodeDesc PIWin64X86CodeDesc;

#endif // kGeneralPiPLPropertiesDefined

//-------------------------------------------------------------------------------
//
//  Additional General PiPL Properties
//
//  These are properties that don't conflict with Suite Pea and are
//  defined for Photoshop specifically.
//
//-------------------------------------------------------------------------------

// 'vers' <int32> Major<int16>.Minor<int16> version number:
#define PIVersionProperty       0x76657273L

// 'prty' <int32> Load order priority:
#define PIPriorityProperty      0x70727479L

// 'cmpt' Component/Version ids:
#define PIComponentProperty     0x636d7074L

// 'mode' <FlagSet> Image modes supported flags. (bitmask):
#define PIImageModesProperty    0x6d6f6465L

// 'enbl' <CString> Enabling expression:
#define PIEnableInfoProperty    0x656e626cL

// 'wnsc' plug in wants scrap
#define PIWantsScrapProperty    0x776E7363L

// 'coco' plug in has Cocoa, Objective-C code and should never be unloaded
#define PICocoaProperty     0x636F636FL

// 'fbaw' plug in wants in the File Browser menu
#define PIFileBrowserAwareProperty  0x66626177L

// 'nabo' plug in does not want an about box menu entry
#define PINoAboutBoxProperty    0x6E61626FL

// 'lFGm' plug in should be hidden/shown by the Preference for legacy Filter Gallery menu entries 
#define PILegacyFilterGalleryMenuItemProperty   0x6C46476DL

// 'flly' plug in filter layer properties
#define PIFilterLayerSupport    0x666c6c79L

// 'host' <PIType> giving host required if any:
#define PIRequiredHostProperty  0x686f7374L

// 'catg' <PString> Category name that appears on top level menu:
#define PICategoryProperty      0x63617467L

// 'zcat' <PString> Category name that appears on top level menu:
#define PIZCategoryProperty     0x7A636174L

// 'name' <PString> Menu name:
#define PINameProperty          0x6e616d65L

// 'znam' <PString> Menu name:
#define PIZNameProperty         0x7A6E616DL

// 'prog' <PString> Progress text:
#define PIProgressTextProperty  0x70726f67

// 'zpro' <PString> Progress text:
#define PIZProgressTextProperty 0x7A70726F

// 'pnme' <CString> picker ID:
#define PIPickerIDProperty      0x706e6d65L

// 'piLU' plug-in supports load/unload selectors:
#define PILoadUnloadProperty        0x70694c55

// 'piPF' plug-in supports preferences dialog selectors:
#define PIPreferencesProperty       0x70695046

// 'feen' plug-in is not loaded unless this feature is enabled
#define PIFeatureEnabledProperty    0x6665656e

// 'posd' plug-in is position dependent
#define PIPositionDependentProperty 0x706f7364

// 'pmsa' plug-in is UI scaling aware for each monitor
#define PIPerMonitorScalingAware    0x706d7361

//-------------------------------------------------------------------------------
//
//  Additional Structures -- PiPL types.
//
//  Below are structures describing types used in plug-in property lists.
//  These structures obey Macintosh 68k alignment and padding rules though
//  generally they are laid out so fields have natural alignment and any
//  needed padding is explicit in the structure.
//
//  In addition to these structure types, simple types such as int32, int16,
//  etc. are used. Two other examples are PString and FlagSet.
//
//  PString is like a rez pstring or a Str255 except that storage may not
//  be present for all 255 characters.  The initial length byte is present
//  in the property.
//
//  FlagSet is a variable length bitstring in which the first member is
//  represented by the most significant bit of the first byte, the eighth
//  member is in the least significant bit of the first byte, etc.
//  The length of the set is in the property's length field.
//
//  Arrays are also used in places with bounds either taken from the
//  property length or explicitly represented within the property.
//
//-------------------------------------------------------------------------------

typedef PIPropertyList **PIPropertyListHandle;

typedef struct TypeCreatorPair
{
    PIType type;     
    PIType creator;  
} TypeCreatorPair;


typedef struct PlugInInfo
{

    int16   version;

    int16   subVersion;

    int16   priority;

    int16   generalInfoSize;

    int16   typeInfoSize;

    int16   supportsMode;

    PIType  requireHost;

} PlugInInfo;

#if PRAGMA_STRUCT_ALIGN
    #pragma options align=reset
#endif

typedef struct PSBuffer *BufferID;

#define kPIGeneralInfoSize 16          

//-------------------------------------------------------------------------------
//  Defines -- Image modes.
//-------------------------------------------------------------------------------




#define plugInModeBitmap            0
#define plugInModeGrayScale         1
#define plugInModeIndexedColor      2
#define plugInModeRGBColor          3
#define plugInModeCMYKColor         4
#define plugInModeHSLColor          5
#define plugInModeHSBColor          6
#define plugInModeMultichannel      7
#define plugInModeDuotone           8
#define plugInModeLabColor          9
#define plugInModeGray16            10
#define plugInModeRGB48             11
#define plugInModeLab48             12
#define plugInModeCMYK64            13
#define plugInModeDeepMultichannel  14
#define plugInModeDuotone16         15
#define plugInModeRGB96             16
#define plugInModeGray32            17
 //end ingroup
//-------------------------------------------------------------------------------
//  Defines -- Blend modes.
//-------------------------------------------------------------------------------

/* Key for host supplied layer blend modes */
#define kPIHostBlendModeSignature   '8BIM'


#define PIBlendNormal           'norm'
#define PIBlendDarken           'dark'
#define PIBlendLighten          'lite'
#define PIBlendHue              'hue '
#define PIBlendSaturation       'sat '
#define PIBlendColor            'colr'
#define PIBlendLuminosity       'lum '
#define PIBlendMultiply         'mul '
#define PIBlendScreen           'scrn'
#define PIBlendDissolve         'diss'
#define PIBlendOverlay          'over'
#define PIBlendHardLight        'hLit'
#define PIBlendSoftLight        'sLit'
#define PIBlendDifference       'diff'
#define PIBlendExclusion        'smud'
#define PIBlendColorDodge       'div '
#define PIBlendColorBurn        'idiv'
#define PIBlendLinearDodge      'lddg'
#define PIBlendLinearBurn       'lbrn'
#define PIBlendLinearLight      'lLit'
#define PIBlendVividLight       'vLit'
#define PIBlendPinLight         'pLit'
#define PIBlendHardMix          'hMix'


//-------------------------------------------------------------------------------
//  Structures -- PiPL types.
//-------------------------------------------------------------------------------

typedef struct PIBlendMode
    {
    PIType signature;  /* kPIHostBlendModeSignature for built-in blend modes */
    PIType key;
    } PIBlendMode;
    
//-------------------------------------------------------------------------------
//
//  Defines -- Moveable Modal Dialog Window.
//
//  This is the Window procID for a Moveable Modal dialog window that can be
//  used for Mac OS System 6.  WDEF(128) is part of Photoshop.
//
//-------------------------------------------------------------------------------
//#define PSmovableDBoxProc (128*16+5)
// We don't support System 6 any longer

//-------------------------------------------------------------------------------
//  Structures -- General.
//-------------------------------------------------------------------------------

typedef int16 PlaneMap [16];

typedef struct PlugInMonitor
{
    Fixed gamma;      
    Fixed redX;       
    Fixed redY;       
    Fixed greenX;     
    Fixed greenY;     
    Fixed blueX;      
    Fixed blueY;      
    Fixed whiteX;     
    Fixed whiteY;     
    Fixed ambient;    
} PlugInMonitor;

//-------------------------------------------------------------------------------
//  Structures -- PSPixelMap
//-------------------------------------------------------------------------------
typedef struct PSPixelMask
{
    struct PSPixelMask *next;   
    void *maskData;             
    int32 rowBytes;             
    int32 colBytes;             
    int32 maskDescription;      
} PSPixelMask;

// Defines for maskDescription field:

#define kSimplePSMask   0
#define kBlackMatPSMask 1
#define kGrayMatPSMask  2
#define kWhiteMatPSMask 3
#define kInvertPSMask   4


typedef struct PSPixelOverlay
    {
    struct PSPixelOverlay *next;
    void *data;
    int32 rowBytes;
    int32 colBytes;
    unsigned8 r, g, b, opacity;
    int32 overlayAlgorithm; 
    } PSPixelOverlay;

// Overlay algorithms.

#define kStandardAlphaOverlay   0   
#define kInvertedAlphaOverlay   1   

// Color management options:

#define kViewAsMask             0xF 
#define kViewAsStandardRGB      0   
#define kViewAsMacRGB           1   
#define kViewAsWindowsRGB       2   
#define kViewAsUncompensated    3   


typedef struct PSPixelMap
{
    int32 version;      
    VRect bounds;       
    int32 imageMode;    
    int32 rowBytes;     
    int32 colBytes;     
    int32 planeBytes;   
    void *baseAddr;     
    //---------------------------------------------------------------------------
    // Fields new in version 1:
    //---------------------------------------------------------------------------   
    // New in version 1 

    PSPixelMask *mat;   
    PSPixelMask *masks; 
    // Use to set the phase of the checkerboard:
    int32 maskPhaseRow; 
    int32 maskPhaseCol; 
    //---------------------------------------------------------------------------
    // Fields new in version 2:
    //---------------------------------------------------------------------------   
    // New in version 2 
    
    PSPixelOverlay *pixelOverlays;      /* Depth of data in the overlay must match the depth in the color channels */
    unsigned32 colorManagementOptions; 
    //---------------------------------------------------------------------------
    // Fields new in version 3:
    //---------------------------------------------------------------------------   
    // New in version 3
    
    int16   depth;      
} PSPixelMap;

typedef struct PSPlatformContext
{
    void *fCGContextRef;    // fCGContextRef is CoreGraphics' CGContextRef
    VRect fScreenRect;      // screen bounds that this DisplayPixels is targeted - for color management across monitors
} PSPlatformContext;

//-------------------------------------------------------------------------------
//  Structures -- ColorServicesInfo.
//-------------------------------------------------------------------------------

typedef struct ColorServicesInfo
{
    int32 infoSize;                 
    int16 selector;                  
    int16 sourceSpace;               
    int16 resultSpace;               
    Boolean resultGamutInfoValid;    
    Boolean resultInGamut;          

    void *reservedSourceSpaceInfo;  
    void *reservedResultSpaceInfo;  
    int16 colorComponents[4];       
    void *reserved;               
    union
    {
        Str255 *pickerPrompt;     
        Point *globalSamplePoint; 
        int32 specialColorID;     
    } selectorParameter;          
} ColorServicesInfo;






#define plugIncolorServicesChooseColor      0    
#define plugIncolorServicesConvertColor     1    
#define plugIncolorServicesSamplePoint      2    
#define plugIncolorServicesGetSpecialColor  3    





// Constants for resultSpace and sourceSpace fields:


#define plugIncolorServicesRGBSpace     0    
#define plugIncolorServicesHSBSpace     1    
#define plugIncolorServicesCMYKSpace    2    
#define plugIncolorServicesLabSpace     3    
#define plugIncolorServicesGraySpace    4    
#define plugIncolorServicesHSLSpace     5    
#define plugIncolorServicesXYZSpace     6    
#define plugIncolorServicesChosenSpace  -1   




#define plugIncolorServicesForegroundColor 0   

#define plugIncolorServicesBackgroundColor 1

//-------------------------------------------------------------------------------
//  Structures -- Resampling callbacks.
//-------------------------------------------------------------------------------

typedef struct PSImagePlane
{
    void *data;      
    Rect bounds;     
    int32 rowBytes;  
    int32 colBytes;  
} PSImagePlane;

typedef struct PSImageMultiPlane
{
    void *data;      
    Rect bounds;     
    int32 rowBytes;  
    int32 colBytes;  
    int16 activeChannels;   
} PSImageMultiPlane;

typedef struct PSImageMultiPlane32
{
    void *data;            
    VRect bounds;          
    int32 rowBytes;        
    int32 colBytes;        
    int16 activeChannels;  
    int16 depth;           
} PSImageMultiPlane32;

//-------------------------------------------------------------------------------
//  Structures -- Filter Layer Index -- Filter Layer support property indexes
//-------------------------------------------------------------------------------
#define PIFilteryLayersSupported        0


//-------------------------------------------------------------------------------
//  Structures -- Channel Ports.
//-------------------------------------------------------------------------------
typedef struct PixelMemoryDesc
{
    void *data;         
    int32 rowBits;      
    int32 colBits;      
    int32 bitOffset;    
    int32 depth;        
} PixelMemoryDesc;

typedef struct PSScaling
{
    VRect sourceRect;       
    VRect destinationRect;  
} PSScaling;

// We provide access to internal channels via the following abstract types:
typedef struct _PIChannelPortDesc *PIChannelPort;

// Old declarations. (4.0)
typedef PIChannelPort ChannelReadPort;   
typedef PIChannelPort ChannelWritePort;  
//-------------------------------------------------------------------------------
//  Structures -- Channel Ports -- Channel Types
//-------------------------------------------------------------------------------


#define ctUnspecified        0       
#define ctRed                1       
#define ctGreen              2       
#define ctBlue               3       
#define ctCyan               4       
#define ctMagenta            5       
#define ctYellow             6       
#define ctBlack              7       
#define ctL                  8       
#define ctA                  9       
#define ctB                 10       
#define ctDuotone           11       
#define ctIndex             12       
#define ctBitmap            13       
#define ctColorSelected     14       
#define ctColorProtected    15       
#define ctTransparency      16       
#define ctLayerMask         17       
#define ctInvertedLayerMask 18       
#define ctSelectionMask     19       
#define ctSpotColor         20       
#define ctVectorMask        21
#define ctSmartFilterMask   22


//-------------------------------------------------------------------------------
//  Structures -- Channel Ports -- WriteChannelDesc
//-------------------------------------------------------------------------------

#define kCurrentMinVersWriteChannelDesc 0    
#define kCurrentMaxVersWriteChannelDesc 1    
typedef struct WriteChannelDesc
{
    
    int32 minVersion;   
    int32 maxVersion;   
    //---------------------------------------------------------------------------
    //  Version 0 fields:
    //---------------------------------------------------------------------------
    
    struct WriteChannelDesc *next;   
    ChannelWritePort port;  
    VRect bounds;           
    int32 depth;            
    VPoint tileSize;        
    VPoint tileOrigin;      
    int16 channelType;      
    int16 padding;          
    void *contextInfo;      
    const char *name;       
    //---------------------------------------------------------------------------
    //  Version 1 fields:
    //---------------------------------------------------------------------------
    // New in version 1 

    const uint16 *unicodeName;      
  #ifdef __cplusplus
    WriteChannelDesc()
        : minVersion(0), maxVersion(0), next(NULL), port(NULL), depth(0),
        channelType(0), padding(0), contextInfo(NULL), name(NULL), unicodeName(NULL) {}   
  #endif // __cplusplus             
} WriteChannelDesc;
//-------------------------------------------------------------------------------
//  Structures -- Channel Ports -- ReadChannelDesc
//-------------------------------------------------------------------------------
#define kCurrentMinVersReadChannelDesc  0  
#define kCurrentMaxVersReadChannelDesc  5  
typedef struct ReadChannelDesc
{
    
    int32 minVersion;     
    int32 maxVersion;     
    //---------------------------------------------------------------------------
    //  Version 0 fields:
    //---------------------------------------------------------------------------
        
    struct ReadChannelDesc *next;   
    PIChannelPort port;     
    VRect bounds;           
    int32 depth;            
    VPoint tileSize;        
    VPoint tileOrigin;      
    Boolean target;         
    Boolean shown;          
    int16 channelType;      
    void *contextInfo;      
    const char *name;       
    //---------------------------------------------------------------------------
    //  Version 1 fields:
    //---------------------------------------------------------------------------
    // New in version 1 

    PIChannelPort writePort; 
    //---------------------------------------------------------------------------
    //  Version 2 fields:
    //---------------------------------------------------------------------------
    // New in version 2 

    unsigned32 alphaID;     
    // New in version 3 

    const uint16 *unicodeName;      
    //---------------------------------------------------------------------------
    //  Version 4 fields: (added in Photoshop CS3/10)
    //---------------------------------------------------------------------------

    // New in version 4 

    Boolean isEnabled;          
    //---------------------------------------------------------------------------
    //  Version 5 fields:
    //---------------------------------------------------------------------------
    // New in version 5 

    VRect limitBounds;          
  #ifdef __cplusplus
    ReadChannelDesc() 
        : minVersion(0), maxVersion(0), next(NULL), port(NULL), depth(0),
        target(false), shown(false), channelType(0), contextInfo(NULL),
        name(NULL), writePort(NULL), alphaID(0), unicodeName(NULL), isEnabled(true) {}
  #endif // __cplusplus             
} ReadChannelDesc;

//-------------------------------------------------------------------------------
//
//  Structures -- Channel Ports -- ReadLayerDesc
//
//  We describe a layer as a collection of lists of read channels.
//
//-------------------------------------------------------------------------------
#define kCurrentMinVersReadLayerDesc    0    
#define kCurrentMaxVersReadLayerDesc    3    
typedef struct ReadLayerDesc
{
    
    int32 minVersion;     
    int32 maxVersion;     
    //---------------------------------------------------------------------------
    //  Version 0 fields:
    //---------------------------------------------------------------------------
    struct ReadLayerDesc *next;     
    ReadChannelDesc *compositeChannelsList;  
    ReadChannelDesc *transparency;  
    ReadChannelDesc *layerMask;     
    unsigned32 sheetID;             
    const char *name;               
    Boolean isPixelBased;           
    //---------------------------------------------------------------------------
    //  Version 1 fields:
    //---------------------------------------------------------------------------
    
    // New in version 1 

    const uint16 *unicodeName;      
    //---------------------------------------------------------------------------
    //  Version 2 fields (added in Photoshop CS3/10)
    //---------------------------------------------------------------------------

    // New in version 2 

    Boolean isVisible;      
    Boolean isAdjustor;     
    Boolean isContentGenerator; 
    Boolean isRendered;     
    unsigned8 opacity;      
    unsigned8 fillOpacity;  
    PIType  blendMode;      
    ReadChannelDesc *vectorMask; 
    //---------------------------------------------------------------------------
    //  Version 3 fields (added in Photoshop CS3/10)
    //---------------------------------------------------------------------------
    
    ReadChannelDesc *smartFilterMask; 

  #ifdef __cplusplus
    ReadLayerDesc()
        : minVersion(0), maxVersion(0), next(NULL), compositeChannelsList(NULL),
        transparency(NULL), layerMask(NULL), sheetID(0), name(NULL), 
        isPixelBased(true), unicodeName(NULL), isVisible(true), 
        isAdjustor(false), isContentGenerator(false), isRendered(false), 
        opacity(255), fillOpacity(255), blendMode(PIBlendNormal), 
        vectorMask(NULL), smartFilterMask(NULL) {}
  #endif // __cplusplus            
    } ReadLayerDesc;

//-------------------------------------------------------------------------------
//  Structures -- Channel Ports -- Document Types
//-------------------------------------------------------------------------------
// @{ 
#define dtImageDocument     0      
#define dtImageScrap        1      
// @}
//-------------------------------------------------------------------------------
//
//  Structures -- Channel Ports -- ImageDocumentDesc
//
//  We describe a document as a collection of lists of read channels.
//
//-------------------------------------------------------------------------------
#define kCurrentMinVersReadImageDocDesc 0  
#define kCurrentMaxVersReadImageDocDesc 6  
typedef struct ReadImageDocumentDesc
{
    
    int32 minVersion;      
    int32 maxVersion;      
    //---------------------------------------------------------------------------
    //  Version 0 fields:
    //---------------------------------------------------------------------------
    
    int32 imageMode;        
    int32 depth;            
    VRect bounds;           
    Fixed hResolution;      
    Fixed vResolution;      
    LookUpTable redLUT;     
    LookUpTable greenLUT;   
    LookUpTable blueLUT;    
    ReadChannelDesc *targetCompositeChannels;   
    ReadChannelDesc *targetTransparency;       
    ReadChannelDesc *targetLayerMask;          
    ReadChannelDesc *mergedCompositeChannels;  
    ReadChannelDesc *mergedTransparency;       
    ReadChannelDesc *alphaChannels;            
    ReadChannelDesc *selection;                
    // New with version 1.
    //---------------------------------------------------------------------------
    //  Version 1 fields
    //---------------------------------------------------------------------------
    // New in version 1 

    struct SPPlatformFileSpecification_t *fileSpec;  
    // New in version 2

    ReadLayerDesc *layersDescriptor;           
    int32 documentType;                        
    struct ReadImageDocumentDesc *next;        
    //---------------------------------------------------------------------------
    //  Version 3 fields (added in Photoshop CS3/10)
    //---------------------------------------------------------------------------

    // New in version 3

    void *  iCCprofileData;     
    int32   iCCprofileSize;     
    int32   compositeChannelCount;  
    int32   layerCount;         
    int32   alphaChannelCount;  
    //---------------------------------------------------------------------------
    //  Version 4 fields (added in Photoshop CS3/10)
    //---------------------------------------------------------------------------
    
    // Layer mask for the target layer:
    ReadChannelDesc *targetSmartFilterMask;
                
    //---------------------------------------------------------------------------
    //  Version 5 fields (added in Photoshop CS6/13)
    //---------------------------------------------------------------------------
    
    // The Unicode file specification, if any.
    struct SPPlatformFileSpecificationW *fileSpecW;

    //---------------------------------------------------------------------------
    //  Version 6 fields (added in Photoshop CC 2015.5 (17.0))
    //---------------------------------------------------------------------------
    // The file specification, if any.
    struct XPlatFileSpec *fileSpecX;


  #ifdef __cplusplus
    ReadImageDocumentDesc()
        : minVersion(0), maxVersion(0), imageMode(0), depth(0), 
          hResolution(0), vResolution(0), 
          targetCompositeChannels(NULL), targetTransparency(NULL), targetLayerMask(NULL),
          mergedCompositeChannels(NULL), mergedTransparency(NULL), alphaChannels(NULL),
          selection(NULL), fileSpec(NULL), layersDescriptor(NULL), documentType(0),
          next(NULL), iCCprofileData(NULL), iCCprofileSize(0), compositeChannelCount(0),
          layerCount(0), alphaChannelCount(0), targetSmartFilterMask(NULL), fileSpecW(NULL),
          fileSpecX(0)
            {
            }
  #endif // __cplusplus

} ReadImageDocumentDesc;
//-------------------------------------------------------------------------------
//  Defines -- Prototypes -- Callbacks.
//-------------------------------------------------------------------------------
#ifdef __cplusplus

extern "C"
{
#endif

    // Direct callbacks:


    typedef MACPASCAL Boolean (*TestAbortProc) (void);
    
    
    typedef MACPASCAL void (*ProgressProc) (int32 done, int32 total);
    
    
    typedef MACPASCAL void (*HostProc) (int16 selector, intptr_t *data);


    typedef MACPASCAL int32 (*SpaceProc) (void);


    typedef MACPASCAL void (*ProcessEventProc) (void *event);


    typedef MACPASCAL OSErr (*DisplayPixelsProc) (const PSPixelMap *source,
                                                  const VRect *srcRect,
                                                  int32 dstRow,
                                                  int32 dstCol,
                                                  void *platformContext);


    typedef MACPASCAL OSErr (*AdvanceStateProc) (void);


    typedef MACPASCAL OSErr (*ColorServicesProc) (ColorServicesInfo *info);

    // Handle procs:


    typedef MACPASCAL Handle (*NewPIHandleProc) (int32 size);

    typedef MACPASCAL void (*DisposePIHandleProc) (Handle h);

    typedef MACPASCAL void (*DisposeRegularHandlePIHandleProc) (Handle h);

    typedef MACPASCAL int32 (*GetPIHandleSizeProc) (Handle h);

    typedef MACPASCAL OSErr (*SetPIHandleSizeProc) (Handle h, int32 newSize);

    typedef MACPASCAL Ptr (*LockPIHandleProc) (Handle h, Boolean moveHigh);

    typedef MACPASCAL void (*UnlockPIHandleProc) (Handle h);

    typedef MACPASCAL void (*RecoverSpaceProc) (int32 size);





    typedef MACPASCAL OSErr (*AllocateBufferProc) (int32 size, BufferID *bufferID);

    typedef MACPASCAL OSErr (*AllocateBufferProc64) (int64 size, BufferID *bufferID);

    typedef MACPASCAL Ptr (*LockBufferProc) (BufferID bufferID, Boolean moveHigh);

    typedef MACPASCAL void (*UnlockBufferProc) (BufferID bufferID);

    typedef MACPASCAL void (*FreeBufferProc) (BufferID bufferID);

    typedef MACPASCAL int32 (*BufferSpaceProc) (void);
    
    typedef MACPASCAL int64 (*BufferSpaceProc64) (void);
    
    typedef MACPASCAL OSErr (*ReserveSpaceProc) (int32 size);
  // end ingroup



    typedef MACPASCAL int16 (*CountPIResourcesProc) (ResType type);
    
    typedef MACPASCAL Handle (*GetPIResourceProc) (ResType type, int16 index);
    
    typedef MACPASCAL void (*DeletePIResourceProc) (ResType type, int16 index);
    
    typedef MACPASCAL OSErr (*AddPIResourceProc) (ResType type, Handle data);  // end ingroup
    // Property suite:



    typedef MACPASCAL OSErr (*GetPropertyProc) (PIType signature,
                                                PIType key,
                                                int32 index,
                                                intptr_t *simpleProperty,
                                                Handle *complexProperty);

    typedef MACPASCAL OSErr (*SetPropertyProc) (PIType signature,
                                                PIType key,
                                                int32 index,
                                                intptr_t simpleProperty,
                                                Handle complexProperty);
  // end defgroup




    typedef MACPASCAL OSErr (*PIResampleProc) (PSImagePlane *source,
                                               PSImagePlane *destination,
                                               Rect *area,
                                               Fixed *coords,
                                               int16 method);

    typedef MACPASCAL OSErr (*PIResampleMultiProc) (PSImageMultiPlane *source,
                                                   PSImageMultiPlane *destination,
                                                   Rect *area,
                                                   Fixed *coords,
                                                   int16 method);

    typedef MACPASCAL OSErr (*PIResampleMulti32Proc) (PSImageMultiPlane32 *source,
                                                   PSImageMultiPlane32 *destination,
                                                   VRect *area,
                                                   int64 *coords,   // s47.16 numbers
                                                   int16 method);
      // end defgroup
    
// Channel ports suite:


    typedef MACPASCAL OSErr (*ReadPixelsProc) (ChannelReadPort port,
                                               const PSScaling *scaling,
                                               const VRect *writeRect,
                                                    /* Rectangle in destination coordinates. */
                                               const PixelMemoryDesc *destination,
                                               VRect *wroteRect);

    typedef MACPASCAL OSErr (*WriteBasePixelsProc) (ChannelWritePort port,
                                                    const VRect *writeRect,
                                                    const PixelMemoryDesc *source);

    typedef MACPASCAL OSErr (*ReadPortForWritePortProc) (ChannelReadPort *readPort,
                                                         ChannelWritePort writePort);
    
#ifdef __cplusplus
}
#endif

//-------------------------------------------------------------------------------
//  Structures -- Buffer procs.
//-------------------------------------------------------------------------------

#define kCurrentBufferProcsVersion 2   

#define kPIBufferSuite          "Photoshop Buffer Procs for Plug-ins"

#define kPIBufferSuiteVersion   kCurrentBufferProcsVersion


typedef struct BufferProcs
{

    int16 bufferProcsVersion;       
    int16 numBufferProcs;           
    AllocateBufferProc allocateProc;    
    LockBufferProc lockProc;        
    UnlockBufferProc unlockProc;    
    FreeBufferProc freeProc;        
    BufferSpaceProc spaceProc;      
    ReserveSpaceProc reserveProc;   
    AllocateBufferProc64 allocateProc64;    
    BufferSpaceProc64 spaceProc64;      
} BufferProcs;

#define kCurrentBufferProcsCount \
    ((sizeof(BufferProcs) - offsetof(BufferProcs, allocateProc)) / sizeof(void *)) 

//-------------------------------------------------------------------------------
//  Structures -- Resource Procs.
//-------------------------------------------------------------------------------

#define kCurrentResourceProcsVersion 3  

#define kPIResourceSuite            "Photoshop Resource Suite for Plug-ins"

#define kPIResourceSuiteVersion     kCurrentResourceProcsVersion

typedef struct ResourceProcs
{
    
    int16 resourceProcsVersion;      
    int16 numResourceProcs;          
    CountPIResourcesProc countProc;  
    GetPIResourceProc getProc;       
    DeletePIResourceProc deleteProc; 
    AddPIResourceProc addProc;       
} ResourceProcs;

#define kCurrentResourceProcsCount \
    ((sizeof(ResourceProcs) - offsetof(ResourceProcs, countProc)) / sizeof(void *)) 

// Reserved resource types:

#define kDayStarColorMatchingResource 'DCSR'
#define kPhotoDeluxeResource 'PHUT'

//-------------------------------------------------------------------------------
//  Structures -- Handle Procs.
//-------------------------------------------------------------------------------

#define kCurrentHandleProcsVersion 1   

#define kPIHandleSuite              "Photoshop Handle Suite for Plug-ins"

#define kPIHandleSuiteVersion       kCurrentHandleProcsVersion


typedef struct HandleProcs
{
    
    int16 handleProcsVersion;   
    int16 numHandleProcs;       
    NewPIHandleProc newProc;    
    DisposePIHandleProc disposeProc;    
    GetPIHandleSizeProc getSizeProc;    
    SetPIHandleSizeProc setSizeProc;    
    LockPIHandleProc lockProc;          
    UnlockPIHandleProc unlockProc;      
    RecoverSpaceProc recoverSpaceProc;  
    DisposeRegularHandlePIHandleProc disposeRegularHandleProc; 
} HandleProcs;

#define kCurrentHandleProcsCount \
    ((sizeof(HandleProcs) - offsetof(HandleProcs, newProc)) / sizeof(void *)) 

//-------------------------------------------------------------------------------
//  Structures -- Image Services suite.
//-------------------------------------------------------------------------------

#define kCurrentImageServicesProcsVersion 1   

#define kPIImageServicesSuite               "Photoshop Image Services Suite for Plug-ins"

#define kPIImageServicesSuiteVersion        kCurrentImageServicesProcsVersion
    
typedef struct ImageServicesProcs
{
    
    int16 imageServicesProcsVersion;        
    int16 numImageServicesProcs;            
    PIResampleProc interpolate1DProc;       
    PIResampleProc interpolate2DProc;       
    PIResampleMultiProc interpolate1DMultiProc;  
    PIResampleMultiProc interpolate2DMultiProc;  
    PIResampleMulti32Proc interpolate1DMulti32Proc;  
    PIResampleMulti32Proc interpolate2DMulti32Proc;  
} ImageServicesProcs;

#define kCurrentImageServicesProcsCount \
    ((sizeof(ImageServicesProcs) - offsetof(ImageServicesProcs, interpolate1DProc)) / sizeof(void *)) 
    
//-------------------------------------------------------------------------------
//  Structures -- Property procs.
//-------------------------------------------------------------------------------

#define kCurrentPropertyProcsVersion 1   

#define kPIPropertySuite                "Photoshop Property Suite for Plug-ins"


#define kPIPropertySuiteVersion         kCurrentPropertyProcsVersion

typedef struct PropertyProcs
{
    
    int16 propertyProcsVersion;        
    int16 numPropertyProcs;            
    GetPropertyProc getPropertyProc;   
    SetPropertyProc setPropertyProc;   
} PropertyProcs;

#define kCurrentPropertyProcsCount \
    ((sizeof(PropertyProcs) - offsetof(PropertyProcs, getPropertyProc)) / sizeof(void *))

//-------------------------------------------------------------------------------
//  Structures -- Channel Ports.
//-------------------------------------------------------------------------------

#define kCurrentChannelPortProcsVersion 1   

#define kPIChannelPortSuite             "Photoshop Channel Ports Suite for Plug-ins"


#define kPIChannelPortSuiteVersion      kCurrentChannelPortProcsVersion

typedef struct ChannelPortProcs
{
    
    int16 channelPortProcsVersion;      
    int16 numChannelPortProcs;          
    ReadPixelsProc readPixelsProc;      
    WriteBasePixelsProc writeBasePixelsProc;  
    ReadPortForWritePortProc readPortForWritePortProc;  
} ChannelPortProcs;

#define kCurrentChannelPortProcsCount \
    ((sizeof(ChannelPortProcs) - offsetof(ChannelPortProcs, readPixelsProc)) / sizeof(void *)) 
    
//-------------------------------------------------------------------------------
//  Suite - Matrix Math
//-------------------------------------------------------------------------------


#define kPSMatrixMathSuite          "9cfaa249-e6f1-11d2-b8eb-0060b0c1f95d"
#define kPSMatrixMathSuiteVersion   1  
typedef struct PSMatrixMathProcs
    {
    /* kPSMatrixMathSuiteVersion == 1 functions */
    
    // if result == NULL solution is put in m 
    SPAPI Boolean (*Inverse) (PIAffineMatrix *m,
                                PIAffineMatrix *result);
    
    SPAPI Boolean (*Equals) (const PIAffineMatrix *m1,
                                const PIAffineMatrix *m2);

    // works in-place if result == NULL
    SPAPI void (*ScalarMultiply) (const real64 scalar,
                                        PIAffineMatrix *m,
                                            PIAffineMatrix *result);

    // if result == NULL solution is put in m2 
    SPAPI void (*MatrixMultiply) (const PIAffineMatrix *m1,
                                        PIAffineMatrix *m2,
                                            PIAffineMatrix *result);
    
    // if result == NULL solution is put in m 
    SPAPI void (*PointMultiply) (PIFloatPoint *p,
                                        const PIAffineMatrix *m,
                                            PIFloatPoint *result);
    
    
    // if result == NULL solution is put in p 
    SPAPI void (*PointsMultiply) (PIFloatPoint *p,
                                            int32 count,
                                                const PIAffineMatrix *m,
                                                    PIFloatPoint *result);

    } PSMatrixMathProcs;

//-------------------------------------------------------------------------------
//
//  Defines -- Filter padding.
//
//  The following constants indicate what sort of padding to use.  Values 0
//  through 255 specify a constant value.  Negative values imply special
//  operations.
//
//  If the plug-in does not want padding and does not want errors, then
//  exterior areas will contain arbitrary values.
//
//-------------------------------------------------------------------------------


#define plugInWantsEdgeReplication          -1
#define plugInDoesNotWantPadding            -2   
#define plugInWantsErrorOnBoundsException   -3   

//-------------------------------------------------------------------------------
//  Defines -- Sampling flag
//-------------------------------------------------------------------------------


#define hostDoesNotSupportSampling      0    
#define hostSupportsIntegralSampling    1    
#define hostSupportsFractionalSampling  2    

//-------------------------------------------------------------------------------
//  Defines -- Layout values for filters and export modules.
//-------------------------------------------------------------------------------

// Traditional = Rows, columns, planes with colbytes = # planes:


#define piLayoutTraditional             0
#define piLayoutRowsColumnsPlanes       1
#define piLayoutRowsPlanesColumns       2
#define piLayoutColumnsRowsPlanes       3
#define piLayoutColumnsPlanesRows       4
#define piLayoutPlanesRowsColumns       5
#define piLayoutPlanesColumnsRows       6


//-------------------------------------------------------------------------------
//  Defines -- Property suite -- PIInterface color property.
//-------------------------------------------------------------------------------
typedef struct PIInterfaceColor
{
    RGBtuple color32;    
    RGBtuple color2;     
} PIInterfaceColor;

// Interface color selectors:

#define kPIInterfaceButtonUpFill        1
#define kPIInterfaceBevelShadow         2
#define kPIInterfaceIconFillActive      3
#define kPIInterfaceIconFillDimmed      4
#define kPIInterfacePaletteFill         5
#define kPIInterfaceIconFrameDimmed     6
#define kPIInterfaceIconFrameActive     7
#define kPIInterfaceBevelHighlight      8
#define kPIInterfaceButtonDownFill      9
#define kPIInterfaceIconFillSelected    10
#define kPIInterfaceBorder              11
#define kPIInterfaceButtonDarkShadow    12
#define kPIInterfaceIconFrameSelected   13
#define kPIInterfaceRed                 14

//-------------------------------------------------------------------------------
//  Defines -- Photoshop -- SuitePEA caller and selector strings for Photoshop.
//-------------------------------------------------------------------------------


#define kPSPhotoshopCaller          "PS Photoshop" 
#define kPSDoIt                     "Do It"       

//-------------------------------------------------------------------------------
//  Action plug-in specific PiPL properties
//-------------------------------------------------------------------------------

// 'prst' -- Always stay loaded property:
#define PIPersistentProperty        0x70727374L

// 'reen' -- Allow reentrant:
#define PIReentrantProperty         0x7265656EL

// 'adll' -- use altered search path when loading the plug-in (Windows only):
#define PILoadWithAlteredSearchPath     0x61646C6CL

//-------------------------------------------------------------------------------
//  Defines -- Image Resources for Annotation.
//-------------------------------------------------------------------------------

/* Major & Minor version number */
#define kPIAnnotMajorVersion    0x0002
#define kPIAnnotMinorVersion    0x0001

/* keys */
#define PIAnnotTextPopup    'txtA' /* text with popup annotation */
#define PIAnnotSound        'sndA' /* sound annotation */
#define PIAnnotTextContent  'txtC' /* text as content */
#define PIAnnotSoundFile    'sndF' /* content as a sound file */
#define PIAnnotSoundMem     'sndM' /* content as a sound in memory */
#define PIFilterFlate       'fltD' /* default parameters */
#define PIFilterLZW         'lzwD' /* default parameters */
#define PIFilterNone        'none' /* no compression */
#define PIFilterUndef       '    ' /* treated as 'none' */

#define PIMaxSize32Property  'ms32'     /* <VPoint> Max rows and cols supported by this plug-in.    */
#define PIMinSize32Property  'mn32'     /* <VPoint> Min rows and cols supported by this plug-in.     */


//-------------------------------------------------------------------------------
//  stack renderer plug-in specific PiPL properties
//-------------------------------------------------------------------------------


#define PIStackRendererProperty     'sRnd'

//-------------------------------------------------------------------------------
//  stack renderer and file format plug-in specific PiPL properties
//-------------------------------------------------------------------------------


#define PIEditInPluginProperty              'ediP'


#define PIPluginLaunchesEditorProperty      'piLe'

//-------------------------------------------------------------------------------

#endif // __PIGeneral_h__