AOI_Document.cpp

#include "AOI_Document.h"
#include "AOI_Instance.h"
#include "../GDocument.h"
#include "../GInstance.h"
#include "ghostscript.h"
#include <ACPL/FileStream.h>
#include <ACPL/Utilities.h>
#include "../PDF/Error.h"
#include "../GLayer.h"
#include "../GVector.h"
#include "../GGroup.h"
#include "../GPlaceHolder.h"
#include <ACPL/Multithreading.h>
#include "../GText.h"
 
using namespace aur;
using namespace aur::PDF;
using namespace aur::ACPL;
 
static bool FillObjectDetails( Object* object, PDF::Point mouse, bool stroke, Document* doc, AOI_Color* outHitColor )
{
        if( !object )
                return false;
 
        if( object->GetType() == gGroupType )
        {
                Group* grp = dynamic_cast<GroupPtr>(object);
                Object* child;
                child = grp->GetFirstChild();
                int index = 0;
                bool ret = false;
                while( child && !ret )
                {
                        ret = FillObjectDetails( child, mouse, stroke, doc, outHitColor );
                        child = grp->GetNthChild( ++index );
                }
                return ret;
        }       
        if(object->GetType() == gPlaceHolderType)
        {
                SymbolPtr sym = dynamic_cast<SymbolPtr>( object );
                if( sym && sym->GetObject()  )
                {
                        return FillObjectDetails( sym->GetObject() ,mouse ,stroke, doc, outHitColor );                  
                }
        }       
        StylePtr style = NULL;
        ColorSpaceObject* space = NULL;
        VectorPtr       vector = dynamic_cast<VectorPtr>(object);
        if( vector )
                style = ( stroke && vector->GetStrokeStyle() ) ? vector->GetStrokeStyle() : vector->GetFillStyle();
        else
        {
                SymbolPtr symbol = dynamic_cast<SymbolPtr>(object);
                if( symbol )
                        style = (StylePtr)symbol->GetColor();
                else
                {
                        RasterPtr raster = dynamic_cast<RasterPtr>(object);
                        if ( raster )
                        {
                                Color color;
                                BitmapPtr bitmap = raster->GetBitmap();
                                Mapping invertMap = raster->mapping();
                                invertMap.Invert();
                                mouse.Map(invertMap);
 
                                space = raster->GetColorSpace();
                                bitmap->Open(NULL);
                                bitmap->GetPixel(int32_t(mouse.x), int32_t(mouse.y), color);
                                bitmap->Close();
 
                                outHitColor->space = AOI_ColorSpacePtr( color.space );
                                ::memcpy( outHitColor->channel, color.channel, space->NrOfComponents() * sizeof( uint16_t ) );
                        }
                }
        }
 
        if (style)
        {
                switch(style->GetType())
                {
                case PDF::Style::eSolid:
                        {
                                SolidPtr color = dynamic_cast<SolidPtr>(style);
                                Color c;
                                color->GetColor(c);
                                space = color->GetSpace();
                                outHitColor->space = AOI_ColorSpacePtr( space );
                                ::memcpy( outHitColor->channel, c.channel, outHitColor->space->NrOfComponents() * sizeof( uint16_t ) );
                        }
                        break;
                case PDF::Style::ePattern:
                        break;
                case PDF::Style::eShading:
                        {
                                ShadingSpacePtr shade = dynamic_cast<ShadingSpacePtr>( style );
                                space = shade->GetColorSpace();
                                Color col;
                                if( shade->GetColor( mouse.x, mouse.y, col ) == false )
                                {
                                        ClearStruct( col );
                                        col.space = space;
                                }
                                outHitColor->space = AOI_ColorSpacePtr( col.space );
                                ::memcpy( outHitColor->channel, col.channel, space->NrOfComponents() * sizeof( uint16_t ) );
                                break;
                        }
                }
        }
 
        if( space )
        {
                if( space->ResourceType() == IndexColorSpace::eResourceType )
                {
                        IndexColorSpace* indexed = dynamic_cast<IndexColorSpace*>( space );
                        Color c;
                        c.space = indexed->GetBase();
                        indexed->GetColor( outHitColor->channel[0] >> 8, c.channel );
                        space = c.space;
                        outHitColor->space = AOI_ColorSpacePtr( c.space );
                        ::memcpy( outHitColor->channel, c.channel, space->NrOfComponents() * sizeof( uint16_t ) );
                }
        }
        return space != NULL;
}
 
 
AOI_Document::AOI_Document( AOI_Instance* instance ) :
        mDocument( NULL ),
        mInstance( NULL ),
        mSpotColorList( NULL ),
        mUseSimpleRenderer( false ),
        mPDFSpec( NULL ),
        mImageSpec( NULL )
{
        if( instance )
                mInstance = instance->mInstance;
}
 
::ExceptionCode AOI_Document::ConvertPStoPDF( const FileSpec& pathToPS, const FileSpec& pathToPDF )
{
        static  CriticalSection sPSAccess;
        sPSAccess.Enter();
 
        ::ExceptionCode err = NoError;
 
        try
        {
                pathToPDF.Create();
 
                String psError;
                String psFonts;
                PS2PDF( pathToPS, pathToPDF, psError, psFonts, mInstance );
                if( psError.GetLength() )
                        mInstance->Error( 1, 3, psError );
                if( psFonts.GetLength() )
                        mInstance->Error( 2, 4, psFonts );
        }
        catch( aur::ExceptionCode psErr )
        {
                err = psErr;
                pathToPDF.Delete();
        }
        catch( ... )
        {
                err = ErrFatal;
                pathToPDF.Delete();
        }
 
        sPSAccess.Leave();
        return err;
}
 
void AOI_Document::Open( const aur::ACPL::FileSpec& path, const char* ownerPassword, const char* userPassword )
{
        delete mImageSpec;
        mImageSpec = NULL;
        delete mPDFSpec;
        mPDFSpec = NULL;
 
        mDocument = new Document( NULL, mInstance );
        try
        {
                FileStream stream( path, eReadPermission );
                if( stream.GetLength() == 0 )
                {
                        mDocument->GetInstance()->Error( 1, 1, "File is 0 bytes long" );
                        return;
                }
        }
        catch(...)
        {
                mDocument->GetInstance()->Error( 1, 2, "Error while opening file" );
                return;
        }
        String  fileType;
        Document::DetermineFileType( path, fileType );
        if( mUseSimpleRenderer && ( fileType == "tif" || fileType == "jpg" ) )
        {
                Document::Info  info;
                Document::GetInfo( path, info );
                if( info.space != NoSpace &&
                        info.pages->size() == 1 &&
                        ( info.space != INDEXED( GraySpace ) || fileType != "tif" ) &&
                        ( info.reference == NULL || (info.space&IndexedSpaces)!=IndexedSpaces ) &&
                        !strstr( info.description, "+" ) )
                {
                        mImageSpec = new FileSpec( path );
                        mDocument->GetPage()->SetDimensions( info.pages->front() );
                        return;
                }
        }
        mUseSimpleRenderer = false;
 
        if( fileType == "eps" )
        {
                mPDFSpec = new FileSpec();
                mPDFSpec->CreateTemporary( NULL, "pdf" );
 
                aur::ExceptionCode psErr = ConvertPStoPDF( path, *mPDFSpec );
                if( psErr == NoError )
                        mDocument->OpenFile( *mPDFSpec, ownerPassword, userPassword );
                else
                        mDocument->GetInstance()->Error( 100, uint16_t(psErr), "PostScript Error" );
        }
        else
        {
                try
                {
                        mDocument->OpenFile( path, ownerPassword, userPassword );
                }
                catch( aur::ExceptionCode plugErr )
                {
                        if( plugErr == ErrUserCanceled )
                                mDocument->GetInstance()->Error( 100, ErrUserCanceled, "Plugin User Canceled" );
                        else
                                mDocument->GetInstance()->Error( 100, uint16_t(plugErr), "Plugin Error" );
                }
                catch( ... )
                {
                        mDocument->GetInstance()->Error( 100, 1, "Plugin fatal error" );
                }
        }
}
 
void AOI_Document::Open( const char16_t* path )
{
        Open( FileSpec( path ) );
}
 
AOI_Document::~AOI_Document()
{
        delete mDocument;
        if( mPDFSpec )
                mPDFSpec->Delete();
        delete mPDFSpec;
        delete mImageSpec;
        delete[] mSpotColorList;
}
 
uint32_t        AOI_Document::GetPageCount() const
{
        return mDocument->GetPageCount();
}
 
AOI_PagePtr     AOI_Document::GetPage( uint32_t pageNr ) const
{
        mDocument->SetCurrentPage( pageNr );
        return AOI_PagePtr( mDocument->GetPage( pageNr ) );
}
 
bool    AOI_Document::TraverseNext( AOI_Object*& object ) const
{
        ObjectPtr       o = ObjectPtr( object );
        bool            res = mDocument->TraverseNext( o );
        object = (AOI_Object*)o;
        return res;
}
 
AOI_ColorSpacePtr       AOI_Document::GetDocumentColorSpace() const
{
        return AOI_ColorSpacePtr( mDocument->GetDocumentColorSpace() );
}
 
AOI_ColorSpacePtr       AOI_Document::GetLabColorSpace() const
{
        return AOI_ColorSpacePtr( mDocument->GetLabColorSpace() );
}
 
AOI_ColorSpacePtr       AOI_Document::GetDeviceGrayColorSpace() const
{
        return AOI_ColorSpacePtr( mDocument->GetDeviceGrayColorSpace() );
}
 
AOI_ColorSpacePtr       AOI_Document::GetDeviceRGBColorSpace() const
{
        return AOI_ColorSpacePtr( mDocument->GetDeviceRGBColorSpace() );
}
 
AOI_ColorSpacePtr       AOI_Document::GetDeviceCMYKColorSpace() const
{
        return AOI_ColorSpacePtr( mDocument->GetDeviceCMYKColorSpace() );
}
 
static bool StyleIsBW( StylePtr style )
{
        bool isBW = true;
        SolidPtr color = dynamic_cast<SolidPtr>(style);
        if( color && ( color->GetSpace()->Space() & GraySpace  ) != GraySpace )
        {
                //allow non gray spaces if color is black and white based
                Color col;
                color->GetColor( col );
                if( ( col.space->Space() & DeviceNSpace ) == DeviceNSpace || ( col.space->Space() & CMYKSpace ) == CMYKSpace )
                {
                        for( uint32_t chan=0; chan != col.space->NrOfComponents(); ++chan )
                                if( ( ::strcmp( col.space->ChannelName( chan ), "Black" ) != 0 && 
                                        ::strcmp( col.space->ChannelName( chan ), "White" ) != 0 )
                                        && col.channel[chan] != 0 )
                                        isBW = false;
                }
                else if( ( col.space->Space() & RGBSpace ) == RGBSpace )
                {
                        if ( ! ( ( col.channel[0] == col.channel[1] ) && ( col.channel[1] == col.channel[2] ) ) )
                                isBW = false;
                }
                else
                        isBW = false;
        }
        return isBW;
}
 
static void     ParseLayer( ObjectPtr obj, PagePtr page, bool& isBW )
{
        if( !obj )
                return;
 
        VectorPtr vector = NULL;
        do
        {
                if( ( vector = dynamic_cast<VectorPtr>(obj) ) )
                {
                        isBW = ( StyleIsBW( vector->GetFillStyle() ) && StyleIsBW( vector->GetStrokeStyle() ) );
                        obj = obj->GetNext();
                }
                else if( obj->GetType() == gGroupType )
                {
                        ParseLayer( ((GroupPtr)obj)->GetFirstChild(), page, isBW );
                        obj = obj->GetNext();
                }
                else if( obj->GetType() == gPlaceHolderType || obj->GetType() == gSymbolType )
                {
                        ObjectPtr child = NULL;
                        if( obj->GetType() == gPlaceHolderType )
                                child = ((PlaceHolderPtr)obj)->GetObject();
                        else
                                child = ((SymbolPtr)obj)->GetObject();
                        if( child )
                                ParseLayer( child, page, isBW );
                        obj = obj->GetNext();
                }
                else
                        obj = obj->GetNext();
        }
        while( obj && isBW );
}
 
bool AOI_Document::BlackAndWhiteDoc() const
{
        bool isBW = true;
        for( uint32_t i = 0 ; i < GetPageCount() && isBW ; i++ )
        {
                PagePtr page = mDocument->GetPage( i );
                for( LayerPtr layer = page->GetFirstLayer() ; layer && isBW; layer = (LayerPtr)layer->GetNext() )
                {
                        ObjectPtr obj = layer->GetFirstChild();
                        ParseLayer( obj, page, isBW );
                }
        }
        return isBW;
}
 
bool static CheckFonts( const std::vector<FontFile*>& allFonts, ObjectPtr obj )
{
        PDF::TextPtr textObject = dynamic_cast<PDF::TextPtr>( obj );
        if( textObject && textObject->Visible() )
        {
                PropsT props;
                textObject->GetProperties( props );
                for( auto& nFont : allFonts )
                        if( ::stricmp( props.style.fontName, nFont->GetName() ) == 0 )
                                return true;
        }
        else
        {
                GroupPtr group = dynamic_cast<GroupPtr>( obj );
                if( group )
                {
                        for( ObjectPtr child = group->GetFirstChild(); child; child = child->GetNext() )
                                if( CheckFonts( allFonts, child ) )
                                        return true;
                }
        }
        return false;
}
 
bool AOI_Document::FontExists( bool onlyUsed ) const
{
        bool            fontExists = false;
        uint32_t        indexPage;
        uint32_t        currentPage = mDocument->GetCurrentPage();
 
        std::vector<FontFile*> allEmbededFonts;
 
        indexPage = currentPage;
        for( uint32_t i = 0; i < mDocument->GetPageCount(); ++i )
        {
                if( indexPage >= mDocument->GetPageCount() )
                        indexPage = 0;
                mDocument->SetCurrentPage( indexPage );
                allEmbededFonts = mDocument->FontUsage();
                fontExists = !allEmbededFonts.empty();
                if( fontExists && !onlyUsed )
                        break;
        }
        mDocument->SetCurrentPage( currentPage );
        if( fontExists && onlyUsed )
        {
                fontExists = false;
                for( uint32_t nPage = 0; nPage < mDocument->GetPageCount() && !fontExists; nPage++ )
                        for( LayerPtr layer = mDocument->GetPage( nPage )->GetFirstLayer(); layer && !fontExists; layer = layer->GetNextLayer() )
                                for( ObjectPtr obj = layer->GetFirstChild(); obj && !fontExists; obj = obj->GetNext() )
                                        if( CheckFonts( allEmbededFonts, obj ) )
                                        {
                                                fontExists = true;
                                                break;
                                        }
        }
        return fontExists;
}
 
::ExceptionCode AOI_Document::SaveAsPDF( const FileSpec& path )
{
        try
        {
                mDocument->SavePDF( path, false, path.FileTitle() );
        }
        catch( aur::ExceptionCode err )
        {
                return err;
        }
        return NoError;
}
 
SpotColorName*  AOI_Document::GetSpotColorList()
{
        delete[] mSpotColorList;
        mSpotColorList = NULL;
 
        std::vector<SpotColorName>      list;
        DeviceN*        devn = NULL;
        uint32_t        i,j;
        while( ( devn = (DeviceN*)mDocument->TraverseCommitedResources( DeviceN::eResourceType, devn ) ) != NULL )
        {
                for( j = 0; j != devn->NrOfComponents(); ++j )
                {
                        SpotColorName n = devn->ChannelName( j );
                        bool    found = ::strcmp( n, "None" ) == 0 || ::strcmp( n, "All" ) == 0;
                        //      Find channel in document colorants
                        if( !found )
                        {
                                for( i = 0; i != list.size() && ::stricmp( n, list[i] ); ++i )
                                        ;
                                if( i == list.size() )
                                        list.push_back( n );
                        }
                }
        }
 
        if( list.size() )
        {
                mSpotColorList = new SpotColorName[ list.size() + 1 ];
                for( i = 0; i != list.size(); ++i )
                        mSpotColorList[i] = list[i];
                mSpotColorList[i] = NULL;
        }
 
        return mSpotColorList;
}
 
AOI_Object*     AOI_Document::HitTest( AOI_Point p, int16_t snapDistance, bool& stroke, AOI_Color* outHitColor )
{
        PDF::Point fp;
        fp.x = p.x;
        fp.y = p.y;
        HitWhatT what;
        what.u.all = 0;
        what.u.part.stroke = true;
        what.u.part.fill = true;
        int16_t snap = mDocument->GetInstance()->GetSnapDistance();
        mDocument->GetInstance()->SetSnapDistance( snapDistance );
        ObjectPtr hitObject = mDocument->HitTest( fp, what, 32767 );
        stroke = what.u.part.stroke;
        mDocument->GetInstance()->SetSnapDistance( snap );
        if( hitObject && outHitColor )
        {
                PDF::Point mouse;
                mouse.x = p.x;
                mouse.y = p.y;
                FillObjectDetails( hitObject, mouse, stroke, mDocument, outHitColor );
        }
        return AOI_ObjectPtr( hitObject );
}
 
void    AOI_Document::SimpleImage()
{
        mUseSimpleRenderer = true;
}
 
void AOI_Document::CloseFile( bool keepVM, bool createDefaults )
{
        mDocument->CloseFile( keepVM, createDefaults );
}
 
AOI_DocumentInfo::AOI_DocumentInfo() :
        fileSize( 0 ),
        pageCount( 0 ),
        width( 0 ),
        height( 0 ),
        space( AOI_NoSpace ),
        encrypted( false ),
        denyPrint( false ),
        denyChange( false ),
        denyCopy( false ),
        denyNotes( false ),
        orientation( 0 ),
        xResolution( 0 ),
        yResolution( 0 ),
        pixelWidth( 0 ),
        pixelHeight( 0 ),
        resolutionUnit( 0 ),
        exposureTime( 0 ),
        Fnumber( 0 ),
        ISOSpeedRating( 0 ),
        exposureBiasValue( 0 )
{
}
 
bool    AOI_DocumentInfo::GetInfo( const FileSpec& path )
{
        try
        {
                aur::PDF::Document::Info        info;
                PDF::Document::GetInfo( path, info );
 
                fileSize = info.fileSize;
                pageCount = info.pages->size();
                width = info.pages->front().w;
                height = info.pages->front().h;
                space = AOI_ColorSpaceEnum( info.space );
                encrypted = info.encrypted;
                denyPrint = info.denyPrint;
                denyChange = info.denyChange;
                denyCopy = info.denyCopy;
                denyNotes = info.denyNotes;
                if( info.fonts )
                        fonts = *info.fonts;
                fileType = info.fileType;
                description = info.description ? info.description : "";
                artist = info.artist;           //      name of the camera owner
                software = info.software;       //      Exif software version
                make = info.make;
                model = info.model;
                orientation = info.orientation;
                xResolution = info.xResolution;
                yResolution = info.yResolution;
                pixelWidth = info.pixelWidth;
                pixelHeight = info.pixelHeight;
                resolutionUnit = info.resolutionUnit;
                dateTime = info.dateTime;
                exposureTime = info.exposureTime;
                Fnumber = info.Fnumber;
                ISOSpeedRating = info.ISOSpeedRating;
                exposureBiasValue = info.exposureBiasValue;
                return fileSize != 0;
        }
        catch(...)
        {
        }
        return false;
}