PIChannelPortsSuite.h

Go to the documentation of this file.

// ADOBE SYSTEMS INCORPORATED
// Copyright  1993 - 2005 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 __PIChannelPortsSuite__
#define __PIChannelPortsSuite__

#if PRAGMA_ONCE
#pragma once
#endif

#include "PIGeneral.h"

#ifdef __cplusplus
extern "C" {
#endif

/******************************************************************************/

#define kPSChannelPortsSuite            "Photoshop ChannelPorts Suite for Plug-ins"

/******************************************************************************/

#define kPSChannelPortsSuiteVersion2            2   
#define kPSChannelPortsSuiteVersion3            3   
/******************************************************************************/

typedef struct PSChannelPortsSuite1
    {
    SPAPI SPErr (*CountLevels)
        (
        PIChannelPort port, 
        int32 *count
        );

    SPAPI SPErr (*GetDepth)
        (
        PIChannelPort port, 
        int32 level, 
        int32 *depth
        );

    SPAPI SPErr (*GetDataBounds) 
        (
        PIChannelPort port,
        int32 level,
        VRect *bounds
        );

    SPAPI SPErr (*GetWriteLimit) 
        (
        PIChannelPort port,
        int32 level,
        VRect *writeBounds
        );

    SPAPI SPErr (*GetTilingGrid) 
        (
        PIChannelPort port,
        int32 level,
        VPoint *tileOrigin,
        VPoint *tileSize
        );

    SPAPI SPErr (*GetSupportRect) 
        (
        PIChannelPort port,
        int32 level, const 
        VRect *bounds,
        int32 *supportLevel, 
        VRect *supportBounds
        );

    SPAPI SPErr (*GetDependentRect) 
        (
        PIChannelPort port,
        int32 sourceLevel, 
        const VRect *sourceBounds,
        int32 dependentLevel, 
        VRect *dependentBounds
        );

    SPAPI SPErr (*CanRead) 
        (
        PIChannelPort port, 
        Boolean *canRead
        );

    SPAPI SPErr (*CanWrite) 
        (
        PIChannelPort port, 
        Boolean *canWrite
        );

    SPAPI SPErr (*ReadPixelsFromLevel) 
        (
        PIChannelPort port,
        int32 level, 
        VRect *bounds,  /* IN/OUT */
        const PixelMemoryDesc *destination
        );

    SPAPI SPErr (*WritePixelsToBaseLevel) 
        (
        PIChannelPort port,
        VRect *bounds,  /* IN/OUT */
        const PixelMemoryDesc *source
        );

    SPAPI SPErr (*ReadScaledPixels) 
        (
        PIChannelPort port,
        VRect *readRect,    /* IN/OUT */
        const PSScaling *scaling,
        const PixelMemoryDesc *destination
        );

    SPAPI SPErr (*FindSourceForScaledRead) 
        (
        PIChannelPort port,
        const VRect *readRect,
        const PSScaling *scaling,
        int32 dstDepth,
        int32 *sourceLevel,
        VRect *sourceRect,
        VRect *sourceScalingBounds
        );

    SPAPI SPErr (*New) 
        (
        PIChannelPort *port,
        const VRect *rect,
        int32 depth,
        Boolean globalScope
        );

    SPAPI SPErr(* Dispose)
        (
        PIChannelPort *port
        );
    
    /*********************************************************************/

    // The following routines are new in version 3.

    // We wrap a variety of filtering operations into two callbacks. One
    // checks to see whether an operation is supported and the other
    // actually applies the operation from a source port to a destination
    // port. We do this rather than adding new routines for each operation
    // because it keeps us from having to repeatedly revise the suite
    // number. The list of operations is provided in PIChannelPortOperations.h.

    // New in version 3 

    SPAPI SPErr(*SupportsOperation)
        (
        const char *operation,
        Boolean *supported
        );

    SPAPI SPErr(*ApplyOperation)
        (
        const char *operation,
        PIChannelPort sourcePort,
        PIChannelPort destinationPort,
        PIChannelPort maskPort,
        void *parameters,   // The exact structure of which will depend on the operation
        VRect *rect         // A bounding rectangle. Could also be an output.
        );

    // We also support plug-ins adding and removing operations.
    
    SPAPI SPErr(*AddOperation) (const char *operation,
                                SPErr (*proc) (PIChannelPort, PIChannelPort, PIChannelPort,
                                               void *, VRect *, void *refCon),
                                void *refCon);

    SPAPI SPErr(*RemoveOperation) (const char *operation, void **refCon);

    SPAPI SPErr (*NewCopyOnWrite) (PIChannelPort *result,
                                   PIChannelPort basePort,
                                   VRect *writeLimit,
                                   Boolean globalScope);

    SPAPI SPErr (*Freeze) (PIChannelPort port);

    SPAPI SPErr (*Restore) (PIChannelPort port, VRect *area);

    } PSChannelPortsSuite1;


#ifdef __cplusplus
}
#endif

#endif  // PIChannelPortsSuite