DriverInfo.h

#pragma once
 
#include <ACPL/XML.h>
#include <vector>
#include <map>
 
namespace jsonxx {
        class Object;
}
 
namespace aur {
 
        namespace ACPL {
                class   String;
                class   UString;
                class   Stream;
                class   FileSpec;
                class   PipeStream;
        }
 
        class Imposition;
 
        namespace ADA {
 
                class   Curve;
        
        typedef uint32_t MarkType;
 
#define SDK_VERSION             420
 
#ifndef inch
#       define inch             * 18.0f
#endif
#ifndef mm
#       define mm               * ( 18.0f / 25.4f )
#endif
 
#define kMaxSheetLenght 20000 mm
 
        typedef enum SpotType
        {
                eAdobeRound = 0,        
                eAdobeEllipse = 1,      
                eDiamond = 2,
                eSquare = 3,
                eSimpleRound = 4,
                eEllipseA = 5,
                eEllipseB = 6,
                eEllipseC = 7,
                eCosine = 8,
                eLine = 9,
                eCross = 10,
                eRhomboid = 11,
                eEllipse2 = 12,
                eLineX = 13,
                eLineY = 14,
                eDoubleDot = 15,
                eInvertedDoubleDot = 16,
                eSimpleDot = 17,
                eInvertedEllipseA = 18,
                eInvertedEllipseC = 19
        }       SpotType;
 
        typedef enum ScreenType
        {
                eNotDefined = 0,                
                eErrorDiffusion = 1,    
                eFMScreen = 2,                  
                eAMScreen = 3,                  
                eContone8 = 4,                  
                eFloydSteinberg = 5,    
                eChromaticED = 6,               
                eContone16 = 7,                 
                eOrganic1 = 8,                  
                eOrganic2 = 9                   
        }       ScreenType;
 
        typedef enum USBFilterType
        {
                eByIEEEE = 0,
                eByModelName = 1
        }       USBFilterType;
 
        typedef enum EmbeddedProfileUse
        {
                eUseEmbeddedNone = 0,
                eUseEmbeddedProfileIntent = 1,
                eUseEmbeddedProfile = 2
        }       EmbeddedProfileUse;
 
        typedef enum ChannelType
        {
                eProcess,                               
                eSpot,                                  
                eSpecial,                               
                eDuplicate,                             
                eDisabled                               
        }       ChannelType;
 
        class   TMediaSize
        {
        public:
                enum EMediaType{
                        eLogical,               // Used in nesting and other logical operations.
                        ePhysical               // Printed size.
                };
 
                char    name[32];               
                bool    transverse;             
                bool    roll;                   
                float   width;                  
                float   length;                 
                float   left;                   
                float   right;                  
                float   top;                    
                float   bottom;                 
 
                inline float    GetLength                       ( EMediaType which = eLogical ) const noexcept;
                inline float    GetWidth                        ( EMediaType which = eLogical ) const noexcept;
                inline float    GetImageableLength      ( EMediaType which = eLogical ) const noexcept;
                inline float    GetImageableWidth       ( EMediaType which = eLogical ) const noexcept;
 
                inline float    GetLeftMargin           ( EMediaType which = eLogical ) const noexcept;
                inline float    GetRightMargin          ( EMediaType which = eLogical ) const noexcept;
                inline float    GetTopMargin            ( EMediaType which = eLogical ) const noexcept;
                inline float    GetBottomMargin         ( EMediaType which = eLogical ) const noexcept;
 
                void    FromJson( const jsonxx::Object&, float defaultWidth = 0, float defaultLength = 0 );
                void    ToJson( jsonxx::Object& ) const;
                void    Load( const ACPL::XML::Node* );
                void    Save( ACPL::XML::Node* ) const;
                ACPL::XML::Node* Save() const;
                inline bool IsEmpty() const noexcept { return name[0] == 0; }
                inline void Reset() noexcept { ::memset( this, 0, sizeof(TMediaSize) ); }
        };
 
        inline float TMediaSize::GetLength( EMediaType which ) const noexcept
        {
                return ( which == ePhysical && transverse ) ? width : length;
        }
 
        inline float TMediaSize::GetWidth( EMediaType which ) const noexcept
        {
                return ( which == ePhysical && transverse ) ? length : width;
        }
 
        inline float TMediaSize::GetImageableLength( EMediaType which ) const noexcept
        {
                return ( which == ePhysical && transverse ) ? width - left - right : length - top - bottom;
        }
 
        inline float TMediaSize::GetImageableWidth( EMediaType which ) const noexcept
        {
                return ( which == ePhysical && transverse ) ? length - top - bottom : width - left - right;
        }
 
        inline float TMediaSize::GetLeftMargin( EMediaType which ) const noexcept
        {
                return ( which == ePhysical && transverse ) ? bottom : left;
        }
 
        inline float TMediaSize::GetRightMargin( EMediaType which ) const noexcept
        {
                return ( which == ePhysical && transverse ) ? top : right;
        }
 
        inline float TMediaSize::GetTopMargin( EMediaType which ) const noexcept
        {
                return ( which == ePhysical && transverse ) ? left : top;
        }
 
        inline float TMediaSize::GetBottomMargin( EMediaType which ) const noexcept
        {
                return ( which == ePhysical && transverse ) ? right : bottom;
        }
 
        class   TTray
        {
        public:
                char    name[32];               
                bool    roll;                   
                float   width;                  
                float   length;                 
                float   left;                   
                float   right;                  
                float   top;                    
                float   bottom;                 
                
                void    FromJson( const jsonxx::Object&, float defaultWidth = 0, float defaultLength = 0 );
                void    ToJson( jsonxx::Object& ) const;
                void    Load( const ACPL::XML::Node* );
                void    Save( ACPL::XML::Node* ) const;
                bool    Fits( const TMediaSize& ) const noexcept;
                inline bool IsEmpty() const noexcept { return name[0] == 0; }
                inline void Reset() noexcept { ::memset( this, 0, sizeof(TTray) ); }
        };
 
        class   TInk
        {
        public:
                int8_t          color[3];                       
                char            name[32];                       
                ScreenType      screening;                      
                uint8_t         blueNoiseFactor;        
                float           halftoneAngle;          
                float           halftoneFrequency;      
                SpotType        halftoneShape;          
                float           maxDotAmount;           
                ChannelType     type;                           
                uint32_t        dotCount;                       
                float           dotSizes[16];           
                float           picoliter[16];          
                
                void    FromJson( const jsonxx::Object& );
                void    ToJson( jsonxx::Object& ) const;
                void    FromXML( const ACPL::XML::Node* );
                ACPL::XML::Node* ToXML() const;
                bool    isTone() const noexcept;
                bool    isColor() const noexcept;
                const char* colorName() const noexcept;
        };
 
        class Caps
        {
        public:
                bool    print;
                bool    cut;
                bool    dtg;
                bool    flatbed;
                bool    highlevel;
                bool    additiveColors;
                bool    estimateInfo;
                bool    barcodeScanner;
                bool    mediaQuery;
                bool    deviceStatus;
                bool    deviceStatusWhilePrinting;
                bool    jobStatusPost;
                bool    jobStatusTracking;
                bool    ripOnDemand;
                bool    hasConsole;
                bool    doubleSided;
                bool    sideBAsLayer;
                bool    needPreviewAtJobStart;
                bool    needUnimagedArea;
                bool    serviceUI;
                bool    needsBlocker;
                
                void    FromJson( const jsonxx::Object& );
                void    ToJson( jsonxx::Object& ) const;
        };
        class Conns
        {
        public:
                bool    tcpip;
                bool    serial;
                bool    usb;
                bool    custom;
                bool    folder;
#if ACPL_WIN
                bool    windows;
                inline bool direct() const noexcept { return windows || serial || usb; }
#else
                inline bool direct() const noexcept { return serial || usb; }
#endif
                bool    hplx;
                bool    autoIP;
                bool    printAgent;
        };
        //
        //              DriverInfo
        //
        class DriverInfo
        {
        public:
                uint32_t                version;
                //
                //      Identification
                //
                char                    name[140];
                char                    profileName[32];
                uint32_t                uniqueDriverID;
                //
                //      Capabilities
                //
                Caps                    caps;
                char                    spectro[8];
                uint32_t                previewSize;
                //
                //      Connection
                //
                Conns                   conns;
                int16_t                 serBaudRate;
                int16_t                 serFlow;
                uint16_t                tcpPort;
#if ACPL_MAC || ACPL_LINUX
                char                    usbFilter[32];
                USBFilterType   usbFilterType;
                uint8_t                 usbClass;
#else
                char                    windowsDriverFilter[32];
                char                    usbGUID[128];
#endif
                //
                //      Device capabilities
                //
                float                   dpuOutputX;
                float                   dpuOutputY;
                float                   dpuRender;
                float                   steps;
                float                   maxWidth;
                float                   maxHeight;
                char                    markerGUID[40];
                float                   sqUnitsPerHour;
                //
                //      Inks
                //
                int32_t                 inkCount;
                TInk*                   inks;
                char                    inkType[64];
                const ADA::Curve*       dotCurves;
                //
                //      Media and trays
                //
                int32_t                 mediaCount;
                int32_t                 trayCount;
                TMediaSize*             media;
                TTray*                  tray;
                //
                //      Custom settings script
                //
                char*                   script;
                char*                   deviceScript;
 
                DriverInfo() noexcept;
                ~DriverInfo();
 
                DriverInfo&             operator>>(ACPL::Stream&);
                DriverInfo&             operator<<(ACPL::Stream&);
        private:
                                                DriverInfo( const DriverInfo& );
                DriverInfo&             operator=( const DriverInfo& );
        };
 
        typedef struct ModelID
        {
                const char*     name;
                const char*     profileName;
                uint32_t        uniqueDriverID;
                float           maxWidth;
                float           maxHeight;
        }       ModelID;
 
        extern const ModelID kDriverID[];
        class ChannelDefinition
        {
        public:
                ACPL::String    name;                   
                ACPL::String    displayName;    
                ScreenType              screening;              
                double                  Lab[3];                 
                bool                    on;                             
                int                             inkDuty;                
                union Params
                {
                        struct AM
                        {
                                SpotType        shape;          
                                float           angle;          
                                float           frequency;      
                        }       am;
                        struct DO
                        {
                                float           maxDot;         
                                int                     blackSize;      
                                int                     whiteSize;      
                        }       og;
                        struct FM
                        {
                                int                     noise;          
                                float           maxDot;         
                        }       fm;
                }                               p;
 
                inline ChannelDefinition() noexcept : screening( eAMScreen ), on( true ), inkDuty(100) {
                        Lab[0] = 50; Lab[1] = Lab[2] = 0; p.am.shape = eAdobeRound; p.am.angle = 0; p.am.frequency = 45;
                }
                ChannelDefinition( const TInk& );
                bool    operator==( const ChannelDefinition& ) const;
                void    FromJson( const jsonxx::Object& );
                void    ToJson( jsonxx::Object& ) const;
                void    FromXML( const ACPL::XML::Node& );
                ACPL::XML::Node* ToXML() const;
        };
 
        class ChannelList : public std::vector<ChannelDefinition>
        {
        public:
                void    Load( const ACPL::XML::Node* );
                void    Save( ACPL::XML::Node* ) const;
        };
 
        inline DriverInfo::DriverInfo() noexcept :
                version( SDK_VERSION ),
                uniqueDriverID( 0 ),
                inkCount( 0 ),
                inks( nullptr ),
                dotCurves( nullptr ),
                mediaCount( 0 ),
                trayCount( 0 ),
                media( nullptr ),
                tray( nullptr ),
                script( nullptr ),
                deviceScript( nullptr )
        {
        }
 
        inline DriverInfo::~DriverInfo()
        {
                delete[] inks;
                delete[] media;
                delete[] tray;
                delete[] script;
                delete[] deviceScript;
        }
 
        typedef enum DirectState
        {
                ePlotterOK = 0,
                ePlotterBusy,
                ePlotterFunctionNotUsed,
                ePlotterError
        }       DirectState;
 
        class PageRect
        {
        public:
                float   left;
                float   top;
                float   right;
                float   bottom;
 
                inline  PageRect() noexcept
                {
                        left = top = 3.402823466e+38F;
                        right = bottom = -3.402823466e+38F;
                }
 
                inline  PageRect( float x1, float y1, float x2, float y2 ) noexcept
                {
                        left = x1;
                        top = y1;
                        right = x2;
                        bottom = y2;
                }
 
                inline void     Union( const PageRect& inBounds ) noexcept
                {
                        if( inBounds.left < left )
                                left = inBounds.left;
                        if( inBounds.top < top )
                                top = inBounds.top;
                        if( inBounds.right > right )
                                right = inBounds.right;
                        if( inBounds.bottom > bottom )
                                bottom = inBounds.bottom;
                }
 
                inline void     Intersect( const PageRect& inBounds ) noexcept
                {
                        if( inBounds.left > left )
                                left = inBounds.left;
                        if( inBounds.top > top )
                                top = inBounds.top;
                        if( inBounds.right < right )
                                right = inBounds.right;
                        if( inBounds.bottom < bottom )
                                bottom = inBounds.bottom;
                }
 
                inline float Width() const noexcept
                {
                        return right - left;
                }
 
                inline float Height() const noexcept
                {
                        return bottom - top;
                }
        };
 
        class MarkerPosition
        {
        public:
                float   x;
                float   y;
 
                inline  MarkerPosition() noexcept : x(0), y(0) {}
                inline  MarkerPosition( float inX, float inY ) noexcept : x(inX), y(inY) {}
        };
        
        typedef std::map<ACPL::String,double> InkUsage;
        typedef const InkUsage* InkUsagePtr;
 
        typedef struct DriverMethods
        {
                ExceptionCode   (*Initialize)( void* obj, ACPL::XML* jobDict, float dpuX, float dpuY, const char* settings );
                void                    (*Terminate)( void* obj, bool abort );
                bool                    (*ErrorToName)( ExceptionCode err, char* errorName );
                void                    (*AddPreview)( void* obj, const ACPL::UString& pathToBMP );
                DirectState             (*DirectHome)( void* obj );
                DirectState             (*DirectMove)( void* obj, float x, float y );
                DirectState             (*DirectSetHome)( void* obj );
                DirectState             (*DirectSizeQuery)( void* obj, PageRect& outSize );
                DirectState             (*DirectPosQuery)( void* obj, float& outCoordX, float& outCoordY );
                void                    (*ObsoleteMethod)();
                DirectState             (*DirectBarcodeQuery)( void*, ACPL::String& );
                void                    (*JobStart)( void* obj, const ACPL::UString& jobName, int32_t& copies, const TMediaSize& mediaSize, const TTray& tray, bool hasImageData, bool hasVectorData );
                void                    (*JobEnd)( void* obj );
                void                    (*PageRegistrationMarks)( void* obj, uint32_t nrOfPoints, const MarkerPosition * const points );
                void                    (*PageStart)( void* obj, uint32_t pageNr, char side, const ACPL::String& barcode, const TMediaSize& mediaSize, const TTray& tray, const PageRect& imagedRect, const ACPL::UString& metaPath );
                bool                    (*PageEnd)( void* obj, int16_t endOffset, InkUsagePtr& inkUsage );
                void                    (*PanelCut)( void* obj );
                //
                //      Rasterizing
                //
                void                    (*RasterStart)( void* obj, int32_t x, int32_t y, int32_t width, int32_t height );
                void                    (*RasterEnd)( void* obj );
                void                    (*ProcessRawBuffer)( void* obj, const uint8_t* planeData, int32_t dataBytes, uint8_t planeIdx );
                //
                //      Cutting
                //
                void                    (*VectorStart)( void* obj );
                void                    (*VectorEnd)( void* obj );
                void                    (*Move)( void* obj, int32_t x, int32_t y );
                void                    (*Line)( void* obj, int32_t x, int32_t y );
                void                    (*Vertex)( void* obj, int32_t x, int32_t y, bool last );
                void                    (*PenUp)( void* obj );
                void                    (*PenDown)( void* obj );
                void                    (*CurveStart)( void* obj );
                void                    (*CurveEnd)( void* obj );
                void                    (*SetTool)( void* obj, const char* settings );
                //
                //      High level
                //
                void                    (*HLMove)( void* obj, float x, float y, bool closed );
                void                    (*HLLine)( void* obj, float x, float y );
                void                    (*HLBezier)( void* obj, float x1, float y1, float x2, float y2, float x3, float y3 );
                void                    (*CustomAction)( void* obj, int a, const char* b );
                void                    (*StartOnDemandJob)( void* obj, Imposition* jobParts, const ACPL::String& requestID, const ACPL::UString& jobName );
                bool                    (*RasterRepeat)( void* obj, uint32_t repeats );
        }       DriverMethods;
 
        static const ExceptionCode      kErrorLookup = 0x4C4B4552;      //      'LKER'
        static const ExceptionCode      kErrorRefused = 0x52454655;     //      'REFU'
 
        class   Instance;
                
        typedef bool (*DriverInitCB)( void* hostObj, ACPL::XML& status );
 
        typedef struct InstanceMethods
        {
                ExceptionCode   (*Info)( Instance* driverObj, DriverInfo* info, const char* settings );
                void                    (*DisposeInfo)( DriverInfo* info );
                void*                   (*CreateSession)( Instance* driverObj, const DriverMethods** methods, const char* deviceURL );
                void                    (*DisposeSession)( Instance* driverObj, void* obj );
                void                    (*PrinterStatus)( Instance* driverObj, ACPL::XML* statusDict );
                void                    (*GetPrivateCacheData)( Instance* driverObj, ACPL::Stream& outStream );
                void                    (*SetPrivateCacheData)( Instance* driverObj, ACPL::Stream& inStream );
                bool                    (*UpdateDriver)( Instance* driverObj, const char* proxy, uint8_t region, void* hostObj, DriverInitCB progressCB );
                void                    (*SetHostInterface)( Instance* driverObj, const char* hostName, void* hostObj, bool (*hostCB)( void* hostObj, ACPL::XML& query, ACPL::XML& response ) );
                bool                    (*PrinterQuery)( Instance* driverObj, ACPL::XML& query, ACPL::XML& response );
                bool                    (*StartJobTracking)( Instance* driverObj );
                const ACPL::StringList& (*GetInkset)( Instance* driverObj );
        }       InstanceMethods;
 
        DLLAPI  const ModelID*  CALLBACK        ListModels();
        DLLAPI  Instance*               CALLBACK        PrinterInitialize( const char* modelName, const char* deviceURL, const ACPL::XML::Node* options, const InstanceMethods** methods );
        DLLAPI  void                    CALLBACK        PrinterTerminate( Instance* driverObj );
        DLLAPI  void                    CALLBACK        ListChannels( const char* modelName, const char* param, char list[4096] );
}}