CgmObjects.h

// CgmObjects.h: interface for the CCgmObjects class.
//

#if !defined(AFX_CGMOBJECTS_H__2E7AF564_0E6D_4CCD_8851_A39A36D9E58D__INCLUDED_)
#define AFX_CGMOBJECTS_H__2E7AF564_0E6D_4CCD_8851_A39A36D9E58D__INCLUDED_


#pragma once

#define MAX_COLOR_INDEXES 4096

#include <string>
#include <vector>
#include <set>

#include "ElementList.h"
#include "LineEdgeTypes.h"
#include "HatchStyles.h"
#include "PatternTables.h"
#include "AppStruct.h"
#include "Clipping.h"
#include "Utility/LPoint.h"
#include "FontMap.h"
#include "Utility/Color.h"
#include "Utility/Config.h"
#include "Utility/wstring.h"
#include "AppStruct.h"
#include "Segment.h"
#include "CgmObj.h"
#include "GeometricPatterns.h"
#include "WebcgmConfig.h"

namespace Larson {

template<class T>
    class ClassCallback //: public Callback
        {
          T* _classPtr;
          typedef void(T::*fncb)(int dwTime);
          fncb _cbProc;
        public:
          ClassCallback(T* classPtr,fncb cbProc):_classPtr(classPtr),_cbProc(cbProc){}
          virtual void operator()(int param){
                (_classPtr->*_cbProc)(param);
          }
        };

        #define CGMI_NO_ERROR   0
        #define CGMI_OPEN_ERROR 1               
        #define ESYNTAX_ERROR   -1              
        #define EUNDEFINED_ELEMENT      10      
        #define EMEMSPACE           11  
        #define EINVAL_BUNDLE           12      
        #define EBADLINX            13  
        #define EBADFILX            14  
        #define EBADPATN            15  
        #define EBADCOLX            16  
        #define ERLEDECODE                      17      
        #define EBADDATA            18  
        #define EFIGOPEN            19  
        #define EFIGNOPEN           20  
        #define EPATHOPEN                       21      
        #define EPATHNOTOPEN            22      
        #define EBADINDEX           23  
        #define ESEGOPEN                        24      
        #define ESEGNOPEN           25  
        #define ENPOINTS                        26      
        #define EGDPDATA            27  
        #define EESCDATA            28  
        #define ESTRING_DECODE_ERROR 29 
        #define EREAD_LENGTH            30      
        #define ECTX_DECODE                     31      
        #define EPNG_FAILED                     32      
        #define EAPS_END_MISSING        33      
        #define EBAD_POINT          34  
        #define EBAD_PARAMETER      35  
        #define ETOO_MANY_UNRECOGNIZED 36 
        #define EINVAL_FONTIX           37      
        #define ENEWREGION                      38      
        #define EINVAL_MODE                     39  
        #define EINVAL_IX                       40  
        #define ENOBEGPIC                       41      
        #define ENOBEGINMF                      42      
        #define ECHAR_ENCODING          43      
        #define EFILE_NOT_CGM           44      
        #define EUNKNOWN_THROW          98      
        #define EBADSTATE                       99      

        typedef struct CgmInError {
                int klass, element, code;
        } CgmInError;


        class CCgmIn;
        class CDrawBase;
        class CCgmBaseObj;
        class CClipping;
        class CSegment;

class ElementCallback {
        public:
                virtual void OnNextElement(long klass, long elementNumber, CCgmIn* pCgmIn) = 0; // pure virtual callback function
};


        class CCgmObjects : public CElementList
        {
        friend class CAppStruct;


        private:
                ElementCallback* pElementCallback;
        public:
                void nextElement(long klass, long elementNumber, CCgmIn* pCgmIn) 
                {               
                        if(pElementCallback)
                                pElementCallback->OnNextElement(klass, elementNumber, pCgmIn);
                };

        public:

        enum CharCodingAnnouncer {
                charCodingBasic7        = 0,
                charCodingBasic8        = 1,
                charCodingExt7          = 2,
                charCodingExt8          = 3
        };

        enum ColorModel {
                colorModelRGB = 1,
                colorModelCIELAB = 2,
                colorModelCIELUV = 3,
                colorModelCMYK = 4,
                colorModelRGBRelated = 5,
                colorModelRGBAlpha = 6,
                colorModelsRGB = 7,
                colorModelsRGBAlpha = 8
        };

        enum RealPrecisionType {
                realPrecFloat   = 0,
                realPrecFixed   = 1
        };

        enum ScalingMode {
                scalingModeAbstract     = 0,
                scalingModeMetric       = 1
        };

        enum VDCType {
                vdcTypeInt      = 0,
                vdcTypeReal     = 1
        };

        enum VdcPrecision { 
                vdcPrecision16int = 0, 
                vdcPrecision32int = 1, 
                vdcPrecision32fp = 2, 
                vdcPrecision64fp = 3 };

#ifndef CGMOBJECTS_NO_SAVE
        typedef struct CGMSaveOptions
        {
                bool unicode;
                VdcPrecision vdcPrecision;
                int bwRasterCompression;
                int colorRasterCompression;
                int autoConvertTo1BPP; 
                std::wstring profileId;
                std::wstring profileEdition;
                std::wstring description;

                int colorModel;
                /*
                // 0 = no change
                // 1 = convert all colors to greyscale
                // 2 = change all fill colors to greyscale
                int monoEnhance;
                int colorConvert;

                bool bMediaColor;
                unsigned char mediaColorRed, mediaColorGreen, mediaColorBlue;
                */
        } CGMSaveOptions;

        static void CGMSaveOptionsInit(CGMSaveOptions *pOptions)
        {
                pOptions->autoConvertTo1BPP = 0;
                pOptions->bwRasterCompression = 0; // BwRasterCompressionNone;
                pOptions->colorRasterCompression = 0; // ColorRasterCompressionNone; 
                pOptions->vdcPrecision= CCgmObjects::vdcPrecision32fp;
                pOptions->unicode = false;
                pOptions->profileId = L"WebCGM";
                pOptions->profileEdition = L"2.0";
                pOptions->description = L"\"ColourClass:Colour\",\"Source:Larson Software Technology,Inc.\"";
                pOptions->colorModel = 0;
                /*
                pOptions->monoEnhance = 0; // no mono-enhancement
                pOptions->colorConvert = 0; // no color conversion
                pOptions->bMediaColor = false; // use backgound color from CGM objects
                pOptions->mediaColorRed = pOptions->mediaColorGreen = pOptions->mediaColorBlue = 0;
                */
        };
#endif

                typedef struct charSet {
                unsigned char m_csType; 
                std::wstring m_csTail;          
                } charSet;

                typedef struct {
                        int classCode;
                        int elementIdCode;
                } metafileElementListEntry;


                CCgmObjects(Larson::CConfig* config, webcgmConfig* pWebcgmConfig = NULL); 

                virtual ~CCgmObjects();

                webcgmConfig* m_pWebcgmConfig;

                void ReCalcList(vector<PicElement> &elList);

                long LoadFile(std::wstring inputFile, int iPicture, std::vector<CgmInError> *pErrorList = NULL, ElementCallback* pElementCallback = NULL);

                long LoadFile(string inputFile, int iPicture, std::vector<CgmInError> *pErrorList = NULL, ElementCallback* pElementCallback = NULL);
        
                void Draw(CDrawBase *pDB, bool showRegions = false, bool exportAps = false);

                void DrawList(CDrawBase* pDB, vector<PicElement> &gData, bool showRegions = false, bool exportAps = false);

                bool Merge(CCgmObjects* pMergeObjects, CMatrix* pXForm);
                
                Larson::CConfig* getConfig() { return m_pConfig; };

                void add(CCgmBaseObj *pObj);

                void add(CSegment *pSegment);

                void add(CAppStruct *pAppStruct);

                void closeAppStruct();

                void add(PicElement& elem);

                DRect GetBounds(bool locus = false) const;

#ifndef CGMOBJECTS_NO_SAVE
                long Save(const std::wstring& outFile, CGMSaveOptions* pOptions);

                long Save(const std::string& outFile, std::string profile, CGMSaveOptions* pOptions);
#endif

                //      monoEnhance:
                //              0 = no change
                //              1 = convert all colors to greyscale
                //              2 = change all fill colors to greyscale
                void ConvertColors(int monoEnhance, int colorConvert);

                void ConvertColorsList(vector<PicElement> &elList, int monoEnhance, int colorConvert);

                std::string getVersion();

                CColor  m_backgroundColor;

                std::wstring m_metafileDescription;

                std::wstring m_metafileId;

                long    m_metafileVersion;

                CFontMap m_fontMap;

                bool m_unicode;

                vector<charSet> m_charSets;

                enum CharCodingAnnouncer m_charCodingAnnouncer;

                int m_encoding;

                int m_maximumColorIndex;

                Larson::DPoint  m_maxVdcExtent[2];

                int m_colorIndexPrecision;

                int m_colorPrecision;

                int m_integerPrecision;

                int m_indexPrecision;

                int m_namePrecision;

                enum ColorModel m_colorModel;

                struct {
                        long selection;
                        double refWhiteX, refWhiteY, refWhiteZ;
                        double rgbMat[3][3];
                        double abcMat[3][3];
                        long numberEntries;             
                        long numberGridLocs;    
                } m_colorCalibration;

                struct {
                        RealPrecisionType type;
                        int exponent;
                        int mantissa;
                } m_realPrecision;
                        
                vector<std::wstring> m_symbolLibraryList;

                struct {
                        int min, max;
                } m_segementPriorityExtent;

                enum VDCType m_vdcType;

                double m_defVDCextDx;
                double m_defVDCextDy;

                vector<metafileElementListEntry> m_metafileElementList;

                vector<CSegment*> m_globalSegments;

                typedef struct {
                        std::wstring pictureId;
                        long pictureLocationOffset;
                        long apsLocationOffset;
                } pictureDirEntry;
                
                struct {
                        int locationDataType; 
                        vector<pictureDirEntry> pictureList; 
                } m_pictureDirectory;

                struct {
                        long characterSetIndex;
                        long characterSetType;
                        std::wstring tail;
                        long octetsPerCode;
                        long glyphSouce;
                        vector<long> glyphCodeList;
                } m_glyphMapping;



                std::wstring m_pictureId;

                Larson::DPoint  m_vdcExtent[2];

                vector<CSegment*> m_localSegments;

                enum ScalingMode m_scalingMode;

                double  m_scalingFactor;

                Larson::CColorTableEntry m_colorTable[MAX_COLOR_INDEXES];

                CColor  getColorTable(long index);
                
                CClipping m_clipping;

                CLineEdgeTypes m_lineEdgeTypes;

                CHatchStyles m_hatchStyles;

                CPatternTables m_patternTables;

                CGeometricPatternTables m_geometricPatternTables;


                std::wstring getKeywordValue(std::wstring string, std::wstring keyword);

                std::wstring ConformCGMFontNames(std::wstring &fontName);
                
                bool m_visibility;

                ClippingPath* m_curClippingPath;
                long m_curClippingPathIndicator;
                ClipRectangle* m_curClipRectangle;

                CColor m_regionDrawFillColor;
                CColor m_regionDrawLineColor;
                int        m_regionDrawStyle;           // 0= outline, 1= fill, 2= fill + outline
                std::wstring m_hotspotIdPrefix;         // APS id prefix of hotspots, * is wildcard

                bool visbilityState;

                Larson::DPoint vdc2nvdc(Larson::DPoint vdc);
                Larson::DPoint nvdc2vdc(Larson::DPoint nvdc);

                bool m_errorChecking;

                bool m_stopDrawing;

        private:
                bool containsUnicode(std::wstring &text);
                short m_curAtaLayerNumber;
                DRect GetBoundsList(vector<PicElement> const& elList, bool locus = false) const;
                bool MergeElem(PicElement& elem, CCgmObjects* pMergeObjects, std::set<ClipRectangle*> &clippingRects, 
                                                                std::set<ClippingPath*> &clippingPaths, CMatrix* pXForm);

                bool clipState;
                CElementList *m_pCurrentList;
                Larson::CConfig* m_pConfig;
                bool    m_bModified;

                void writeFontProperties(CFontProperties* props);
#ifndef CGMOBJECTS_NO_SAVE
                long ExportAppStruct(CAppStruct* pAppStruct, int bwCompression, int colorCompression,
                        bool unicode, bool bRGBa, int vdcPrecision, std::wstring& profile);
#endif

                bool isCGMFontName(std::wstring &fontName);
                void CollectCustomsFromAppStruct(CAppStruct* pAppStruct, CLineEdgeTypes* leTypes,
                                        CHatchStyles* hStyles, bool* pFoundUnicode);
                int CheckLicense();
                std::string unicodeToAnsi(wstring wide);

        public:
                void AddDemoBanner(CDrawBase *pDB, int iDrawAddFlag = 1, wchar_t *banner = NULL);

                void *hCGMLIB2;

                long LoadAllelm01();
        };

#if defined(ANDROID) && defined(WANT_C_API)
        extern "C" {
                typedef struct { CCgmObjects real; } c_CCgmObjects;

                c_CCgmObjects* new_CCgmObjects(void *config, void *webcgmconfig);
                void delete_CCgmObjects(c_CCgmObjects* p);
                void draw_CCgmObjects(c_CCgmObjects* p, void *drawable, int bShowRegions, int bExportApps);
                long SaveA_CCgmObjects(c_CCgmObjects* p, char *outputFile);
                long LoadFileA_CCgmObjects(c_CCgmObjects* p, char *inputFile, int iPicture);
                long LoadAllelm01_CCgmObjects(c_CCgmObjects* p);
                void VDCExtent_CCgmObjects(c_CCgmObjects* p, double *left, double *right, double *top, double *bottom, double *scale);
        };
#endif
};

#endif // !defined(AFX_CGMOBJECTS_H__2E7AF564_0E6D_4CCD_8851_A39A36D9E58D__INCLUDED_)