mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 14:00:32 +08:00
9b9646da45
git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@63679 954022d7-b5bf-4e40-9824-e11837661b57
393 lines
7.9 KiB
C++
393 lines
7.9 KiB
C++
#ifndef _PDF_WRITER_SRC_OBJECTS_H
|
|
#define _PDF_WRITER_SRC_OBJECTS_H
|
|
|
|
#include <string>
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
#include "Types.h"
|
|
|
|
namespace PdfWriter
|
|
{
|
|
class CXref;
|
|
class CStream;
|
|
class CEncrypt;
|
|
|
|
typedef enum
|
|
{
|
|
object_type_UNKNOWN = 0x01,
|
|
object_type_NULL = 0x02,
|
|
object_type_BOOLEAN = 0x03,
|
|
object_type_NUMBER = 0x04,
|
|
object_type_REAL = 0x05,
|
|
object_type_NAME = 0x06,
|
|
object_type_STRING = 0x07,
|
|
object_type_BINARY = 0x08,
|
|
object_type_ARRAY = 0x10,
|
|
object_type_DICT = 0x11,
|
|
object_type_PROXY = 0x12,
|
|
object_type_PATTERN_REF = 0xFA,
|
|
object_type_FUNC_REF = 0xF2,
|
|
object_type_MASK_FORM = 0xF3,
|
|
object_type_MASK_REF = 0xF4,
|
|
object_type_XFORM = 0xF5
|
|
} EObjectType;
|
|
typedef enum
|
|
{
|
|
dict_type_UNKNOWN = 0x00,
|
|
dict_type_FONT = 0x01,
|
|
dict_type_CATALOG = 0x02,
|
|
dict_type_PAGES = 0x03,
|
|
dict_type_PAGE = 0x04,
|
|
dict_type_XOBJECT = 0x05,
|
|
dict_type_OUTLINE = 0x06,
|
|
dict_type_DESTINATION = 0x07,
|
|
dict_type_ANNOTATION = 0x08,
|
|
dict_type_ENCRYPT = 0x09,
|
|
dict_type_EXT_GSTATE = 0x0A,
|
|
dict_type_EXT_GSTATE_R = 0x0B /* read only object */
|
|
} EDictType;
|
|
|
|
class CObjectBase
|
|
{
|
|
public:
|
|
CObjectBase()
|
|
{
|
|
m_unFlags = 0;
|
|
m_unGenNo = 0;
|
|
m_unObjId = 0;
|
|
}
|
|
virtual ~CObjectBase()
|
|
{}
|
|
|
|
virtual EObjectType GetType() const
|
|
{
|
|
return object_type_UNKNOWN;
|
|
}
|
|
bool IsHidden() const;
|
|
bool IsDirect() const;
|
|
bool IsIndirect() const;
|
|
void SetDirect();
|
|
void SetIndirect();
|
|
void SetHidden();
|
|
void SetRef(unsigned int unObjId, unsigned int unGenNo)
|
|
{
|
|
m_unObjId = unObjId;
|
|
m_unGenNo = unGenNo;
|
|
}
|
|
void WriteValue(CStream* pStream, CEncrypt* pEncrypt);
|
|
void Write (CStream* pStream, CEncrypt* pEncrypt);
|
|
|
|
private:
|
|
|
|
unsigned int m_unFlags;
|
|
unsigned int m_unObjId;
|
|
unsigned int m_unGenNo;
|
|
};
|
|
class CNullObject : public CObjectBase
|
|
{
|
|
public:
|
|
|
|
EObjectType GetType() const
|
|
{
|
|
return object_type_NULL;
|
|
}
|
|
};
|
|
class CBoolObject : public CObjectBase
|
|
{
|
|
public:
|
|
|
|
CBoolObject(const bool& bValue)
|
|
{
|
|
m_bValue = bValue;
|
|
}
|
|
EObjectType GetType() const
|
|
{
|
|
return object_type_BOOLEAN;
|
|
}
|
|
bool Get() const
|
|
{
|
|
return m_bValue;
|
|
}
|
|
|
|
private:
|
|
bool m_bValue;
|
|
};
|
|
class CNumberObject : public CObjectBase
|
|
{
|
|
public:
|
|
CNumberObject()
|
|
{
|
|
m_nValue = 0;
|
|
}
|
|
CNumberObject(const int& nValue)
|
|
{
|
|
m_nValue = nValue;
|
|
}
|
|
EObjectType GetType() const
|
|
{
|
|
return object_type_NUMBER;
|
|
}
|
|
void Set(const int& nValue)
|
|
{
|
|
m_nValue = nValue;
|
|
}
|
|
int Get() const
|
|
{
|
|
return m_nValue;
|
|
}
|
|
void operator++(int)
|
|
{
|
|
m_nValue++;
|
|
}
|
|
|
|
private:
|
|
int m_nValue;
|
|
};
|
|
class CRealObject : public CObjectBase
|
|
{
|
|
public:
|
|
CRealObject(float fValue)
|
|
{
|
|
Set(fValue);
|
|
}
|
|
CRealObject(double dValue)
|
|
{
|
|
Set((float)dValue);
|
|
}
|
|
EObjectType GetType() const
|
|
{
|
|
return object_type_REAL;
|
|
}
|
|
void Set(float fValue)
|
|
{
|
|
m_fValue = std::min(std::max(fValue, LIMIT_MIN_REAL), LIMIT_MAX_REAL);
|
|
}
|
|
void Set(double dValue)
|
|
{
|
|
m_fValue = (float)std::min(std::max((float)dValue, LIMIT_MIN_REAL), LIMIT_MAX_REAL);
|
|
}
|
|
float Get() const
|
|
{
|
|
return m_fValue;
|
|
}
|
|
|
|
private:
|
|
float m_fValue;
|
|
};
|
|
class CNameObject : public CObjectBase
|
|
{
|
|
public:
|
|
|
|
CNameObject(const char* sValue)
|
|
{
|
|
Set(sValue);
|
|
}
|
|
void Set(const char* sValue);
|
|
const char* Get() const
|
|
{
|
|
return m_sValue;
|
|
}
|
|
EObjectType GetType() const
|
|
{
|
|
return object_type_NAME;
|
|
}
|
|
|
|
private:
|
|
char m_sValue[LIMIT_MAX_NAME_LEN + 1];
|
|
};
|
|
class CStringObject : public CObjectBase
|
|
{
|
|
public:
|
|
CStringObject(const char* sValue);
|
|
virtual ~CStringObject();
|
|
void Set(const char* sValue);
|
|
const BYTE* GetString() const
|
|
{
|
|
return (const BYTE*)m_pValue;
|
|
}
|
|
unsigned int GetLength() const
|
|
{
|
|
return m_unLen;
|
|
}
|
|
EObjectType GetType() const
|
|
{
|
|
return object_type_STRING;
|
|
}
|
|
|
|
private:
|
|
BYTE* m_pValue;
|
|
unsigned int m_unLen;
|
|
};
|
|
class CBinaryObject : public CObjectBase
|
|
{
|
|
public:
|
|
CBinaryObject(const BYTE* pValue, unsigned int unLen);
|
|
~CBinaryObject();
|
|
void Set(const BYTE* pValue, unsigned int unLen);
|
|
BYTE* GetValue() const
|
|
{
|
|
return m_pValue;
|
|
}
|
|
unsigned int GetLength() const
|
|
{
|
|
return m_unLen;
|
|
}
|
|
EObjectType GetType() const
|
|
{
|
|
return object_type_BINARY;
|
|
}
|
|
|
|
private:
|
|
BYTE* m_pValue;
|
|
unsigned int m_unLen;
|
|
};
|
|
class CProxyObject : public CObjectBase
|
|
{
|
|
public:
|
|
CProxyObject(CObjectBase* pObject)
|
|
{
|
|
m_pObject = pObject;
|
|
}
|
|
CObjectBase* Get() const
|
|
{
|
|
return m_pObject;
|
|
}
|
|
EObjectType GetType() const
|
|
{
|
|
return object_type_PROXY;
|
|
}
|
|
private:
|
|
CObjectBase* m_pObject;
|
|
};
|
|
class CArrayObject : public CObjectBase
|
|
{
|
|
public:
|
|
CArrayObject()
|
|
{
|
|
}
|
|
virtual ~CArrayObject()
|
|
{
|
|
Clear();
|
|
}
|
|
int GetCount() const
|
|
{
|
|
return m_arrList.size();
|
|
}
|
|
void Add(CObjectBase* pObject);
|
|
void Add(bool bValue);
|
|
void Add(int nValue);
|
|
void Add(unsigned int unValue);
|
|
void Add(float fValue);
|
|
void Add(const char* sValue);
|
|
void Add(double dValue);
|
|
void Insert(CObjectBase* pTarget, CObjectBase* pObject);
|
|
CObjectBase* Get(unsigned int unIndex, bool bCheckProxy = true) const;
|
|
void Clear();
|
|
EObjectType GetType() const
|
|
{
|
|
return object_type_ARRAY;
|
|
}
|
|
static CArrayObject* CreateBox(const TBox& oBox);
|
|
static CArrayObject* CreateBox(double dL, double dB, double dR, double dT);
|
|
protected:
|
|
std::vector<CObjectBase*> m_arrList;
|
|
};
|
|
class CDictObject : public CObjectBase
|
|
{
|
|
public:
|
|
CDictObject();
|
|
CDictObject(CXref* pXref);
|
|
virtual ~CDictObject();
|
|
virtual EObjectType GetType() const
|
|
{
|
|
return object_type_DICT;
|
|
}
|
|
CObjectBase* Get(const std::string& sKey) const;
|
|
void Add(const std::string& sKey, CObjectBase* pObject);
|
|
void Remove(const std::string& sKey);
|
|
void Add(const std::string& sKey, const char* sName);
|
|
void Add(const std::string& sKey, int nNumber);
|
|
void Add(const std::string& sKey, unsigned int unNumber);
|
|
void Add(const std::string& sKey, float fReal);
|
|
void Add(const std::string& sKey, double dReal);
|
|
void Add(const std::string& sKey, bool bBool);
|
|
const char* GetKey(CObjectBase* pObject);
|
|
CStream* GetStream() const
|
|
{
|
|
return m_pStream;
|
|
}
|
|
unsigned int GetFilter() const
|
|
{
|
|
return m_unFilter;
|
|
}
|
|
unsigned int GetPredictor() const
|
|
{
|
|
return m_unPredictor;
|
|
}
|
|
void SetFilter(unsigned int unFiler)
|
|
{
|
|
m_unFilter = unFiler;
|
|
}
|
|
void SetStream(CXref* pXref, CStream* pStream);
|
|
|
|
virtual void BeforeWrite(){}
|
|
virtual void Write(CStream* pStream){}
|
|
virtual void AfterWrite(){}
|
|
virtual EDictType GetDictType() const
|
|
{
|
|
return dict_type_UNKNOWN;
|
|
}
|
|
|
|
void WriteToStream(CStream* pStream, CEncrypt* pEncrypt);
|
|
|
|
private:
|
|
|
|
std::map<std::string, CObjectBase*> m_mList;
|
|
unsigned int m_unFilter;
|
|
unsigned int m_unPredictor;
|
|
CStream* m_pStream;
|
|
};
|
|
struct TXrefEntry
|
|
{
|
|
char nEntryType;
|
|
unsigned int unByteOffset;
|
|
unsigned int unGenNo;
|
|
CObjectBase* pObject;
|
|
};
|
|
class CXref
|
|
{
|
|
public:
|
|
|
|
CXref(unsigned int unOffset);
|
|
~CXref();
|
|
|
|
TXrefEntry* GetEntry(unsigned int unIndex) const;
|
|
TXrefEntry* GetEntryByObjectId(unsigned int unObjectId) const;
|
|
void Add(CObjectBase* pObject);
|
|
void WriteToStream(CStream* pStream, CEncrypt* pEncrypt);
|
|
int GetCount() const
|
|
{
|
|
return m_arrEntries.size();
|
|
}
|
|
CDictObject*GetTrailer() const
|
|
{
|
|
return m_pTrailer;
|
|
}
|
|
|
|
private:
|
|
|
|
void WriteTrailer(CStream* pStream);
|
|
|
|
private:
|
|
std::vector<TXrefEntry*> m_arrEntries;
|
|
unsigned int m_unStartOffset;
|
|
unsigned int m_unAddr;
|
|
CXref* m_pPrev;
|
|
CDictObject* m_pTrailer;
|
|
};
|
|
}
|
|
|
|
#endif // _PDF_WRITER_SRC_OBJECTS_H
|
|
|