lesson6.doc поправлены "формучные" картинки из битмапа

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@65008 954022d7-b5bf-4e40-9824-e11837661b57

ASCOfficeDocFile/DocDocxConverter/OfficeDrawing/BitmapBlip.h

@@ -12,6 +12,8 @@ namespace DocFileFormat
 		static const unsigned short TYPE_CODE_0xF01F = 0xF01F;
 		static const unsigned short TYPE_CODE_0xF020 = 0xF020;
 		static const unsigned short TYPE_CODE_0xF021 = 0xF021;
+		static const unsigned short TYPE_CODE_0xF02A = 0xF02A;
+		static const unsigned short TYPE_CODE_0xF029 = 0xF029;
 
 	public:
 		BitmapBlip() : Record(), m_rgbUid(NULL), m_rgbUidPrimary(NULL), m_bTag(0), m_pvBits(NULL)

ASCOfficeDocFile/DocDocxConverter/OfficeDrawing/MetafilePictBlip.h

@@ -3,9 +3,230 @@
 #include "Record.h"
 #include "../../../ASCOfficeUtils/ASCOfficeUtilsLib/OfficeUtils.h"
 
+//#if defined(_WIN32) || defined(_WIN64)
+//	#include <atlcoll.h>
+//	#include <gdiplus.h>
+//#else
+//    #include "../../../ASCOfficePPTXFile/PPTXLib/Linux/PPTXFormatLib/linux_gdiplus.h"
+//#endif
+
 namespace DocFileFormat
 {
-	typedef enum _BlipCompression
+typedef struct
+{
+    INT16           Left;
+    INT16           Top;
+    INT16           Right;
+    INT16           Bottom;
+} PWMFRect16;
+
+typedef struct
+{
+    UINT32          Key;            // GDIP_WMF_PLACEABLEKEY
+    INT16           Hmf;            // Metafile HANDLE number (always 0)
+    PWMFRect16      BoundingBox;    // Coordinates in metafile units
+    INT16           Inch;           // Number of metafile units per inch
+    UINT32          Reserved;       // Reserved (always 0)
+    INT16           Checksum;       // Checksum value for previous 10 WORDs
+} WmfPlaceableFileHeader;
+
+class CMetaHeader
+{
+
+public:
+	DWORD cbSize;
+	RECT rcBounds;
+	POINT ptSize;
+	DWORD cbSave;
+	BYTE compression;
+	BYTE filter;
+
+public:
+	CMetaHeader()
+	{
+	}
+
+
+	//void ToEMFHeader(Gdiplus::ENHMETAHEADER3* pHeader)
+	//{
+	//	if (NULL == pHeader)
+	//		return;
+
+	//	pHeader->iType				= 0x00000001;
+	//	pHeader->nSize				= 88;
+
+	//	pHeader->rclBounds.left		= rcBounds.left;
+	//	pHeader->rclBounds.top		= rcBounds.top;
+	//	pHeader->rclBounds.right	= rcBounds.right;
+	//	pHeader->rclBounds.bottom	= rcBounds.bottom;
+
+	//	// нужно перевести в мм
+	//	pHeader->rclFrame.left		= rcBounds.left;
+	//	pHeader->rclFrame.top		= rcBounds.top;
+	//	pHeader->rclFrame.right		= rcBounds.right;
+	//	pHeader->rclFrame.bottom	= rcBounds.bottom;
+
+	//	pHeader->dSignature			= 0x464D4520;
+	//	pHeader->nVersion			= 0x00010000;
+	//	pHeader->nBytes				= cbSize;
+
+	//	pHeader->nRecords			= 1;
+	//	pHeader->nHandles			= 0;
+
+	//	pHeader->sReserved			= 0;
+
+	//	pHeader->nDescription		= 0;
+	//	pHeader->offDescription		= 0;
+
+	//	pHeader->nPalEntries		= 0;
+
+	//	pHeader->szlDevice.cx		= 200;
+	//	pHeader->szlDevice.cy		= 200;
+
+	//	// нужно перевести в мм
+	//	pHeader->szlMillimeters.cx	= 100;
+	//	pHeader->szlMillimeters.cy	= 100;
+	//}
+
+	void ToWMFHeader(WmfPlaceableFileHeader* pHeader)
+	{
+		if (NULL == pHeader)
+			return;
+
+		pHeader->Key				= 0x9AC6CDD7;
+		pHeader->Hmf				= 0;
+
+		pHeader->BoundingBox.Left	= (short)rcBounds.left;
+		pHeader->BoundingBox.Top	= (short)rcBounds.top;
+		pHeader->BoundingBox.Right	= (short)rcBounds.right;
+		pHeader->BoundingBox.Bottom = (short)rcBounds.bottom;
+
+		pHeader->Inch				= 1440; // 1:1
+		pHeader->Reserved			= 0;
+
+		pHeader->Checksum			= 0;
+		pHeader->Checksum			^= (pHeader->Key & 0x0000FFFFL);
+		pHeader->Checksum			^= ((pHeader->Key & 0xFFFF0000L) >> 16);
+		
+		pHeader->Checksum			^= pHeader->Hmf; 
+		
+		pHeader->Checksum			^= pHeader->BoundingBox.Left;
+		pHeader->Checksum			^= pHeader->BoundingBox.Top; 
+		pHeader->Checksum			^= pHeader->BoundingBox.Right;
+		pHeader->Checksum			^= pHeader->BoundingBox.Bottom; 
+		
+		pHeader->Checksum			^= pHeader->Inch;
+		pHeader->Checksum			^= (pHeader->Reserved & 0x0000FFFFL);
+		pHeader->Checksum			^= ((pHeader->Reserved & 0xFFFF0000L) >> 16);
+	}
+};
+
+class CMetaFileBuffer
+{
+public:
+    bool			m_bIsValid;
+	CString			m_sExtension;
+private:
+	BYTE* m_pMetaHeader;
+	BYTE* m_pMetaFile;
+
+	LONG m_lMetaHeaderSize;
+	LONG m_lMetaFileSize;
+
+public:
+	CMetaFileBuffer()
+	{
+        m_bIsValid			= false;
+
+		m_pMetaHeader		= NULL;
+		m_pMetaFile			= NULL;
+
+		m_lMetaHeaderSize	= 0;
+		m_lMetaFileSize		= 0;
+	}
+	~CMetaFileBuffer()
+	{
+		RELEASEARRAYOBJECTS(m_pMetaHeader);
+		RELEASEARRAYOBJECTS(m_pMetaFile);
+	}
+
+	void SetHeader(BYTE* pHeader, LONG lSize)
+	{
+		m_pMetaHeader		= pHeader;
+		m_lMetaHeaderSize	= lSize;
+	}
+
+    void SetData(BYTE* pCompress, LONG lCompressSize, LONG lUncompressSize, bool bIsCompressed)
+	{
+		if (!bIsCompressed)
+		{
+			m_pMetaFile		= pCompress;
+			m_lMetaFileSize = lUncompressSize;
+		}
+		else
+		{
+			ULONG lSize = lUncompressSize;
+			m_pMetaFile = new BYTE[lUncompressSize];
+            //bool bRes	= NSZLib::Decompress(pCompress, (ULONG)lCompressSize, m_pMetaFile, lSize);
+
+			HRESULT res = S_OK;
+			COfficeUtils* pOfficeUtils = new COfficeUtils(NULL); 
+
+			if (pOfficeUtils)
+			{
+				pOfficeUtils->Uncompress( m_pMetaFile, &lSize, pCompress, lCompressSize );
+
+				delete pOfficeUtils;
+				pOfficeUtils = NULL;
+	
+				m_lMetaFileSize = (LONG)lSize;
+			}
+			else
+			{
+				RELEASEARRAYOBJECTS(m_pMetaFile);
+				m_lMetaFileSize = 0;
+			}
+		}
+	}
+
+
+	int ToBuffer(BYTE *& Data)
+	{
+		int sz = 0;
+	
+		if (NULL != m_pMetaHeader)	sz += m_lMetaHeaderSize;
+		if (NULL != m_pMetaFile)	sz += m_lMetaFileSize;
+
+		Data = new BYTE[sz];
+		int pos = 0;
+
+		if (NULL != m_pMetaHeader)
+		{
+			memcpy(Data, (BYTE*)m_pMetaHeader, m_lMetaHeaderSize);
+			pos += m_lMetaHeaderSize;
+		}
+		if (NULL != m_pMetaFile)
+		{
+			memcpy(Data + pos, (BYTE*)m_pMetaFile, m_lMetaFileSize);
+		}
+
+		return sz;
+	}
+	void ToFile(NSFile::CFileBinary* pFile)
+	{
+		if (NULL != m_pMetaHeader)
+		{
+			pFile->WriteFile((BYTE*)m_pMetaHeader, m_lMetaHeaderSize);
+		}
+		if (NULL != m_pMetaFile)
+		{
+			pFile->WriteFile((BYTE*)m_pMetaFile, m_lMetaFileSize);
+		}
+	}
+};
+
+
+typedef enum _BlipCompression
 	{
 		BlipCompressionDeflate,
 		BlipCompressionNone = 254,
@@ -37,6 +258,8 @@ namespace DocFileFormat
 		unsigned char* m_pvBits;
 
 	public:
+		CMetaFileBuffer		oMetaFile;
+		
 		static const unsigned short TYPE_CODE_0xF01A = 0xF01A;
 		static const unsigned short TYPE_CODE_0xF01B = 0xF01B;
 		static const unsigned short TYPE_CODE_0xF01C = 0xF01C;
@@ -57,7 +280,12 @@ namespace DocFileFormat
 			{
 				this->m_rgbUidPrimary = this->Reader->ReadBytes( 16, true );
 			}
-
+			
+			oMetaFile.m_bIsValid	= TRUE;
+			oMetaFile.m_sExtension	= L".emf";
+			
+			CMetaHeader oMetaHeader;
+			
 			this->m_cb = this->Reader->ReadInt32();
 
             this->m_rcBounds.left   = this->Reader->ReadInt32();
@@ -71,8 +299,43 @@ namespace DocFileFormat
 			this->m_cbSave = this->Reader->ReadInt32();
 			this->m_fCompression = (BlipCompression)this->Reader->ReadByte();
 			this->m_fFilter = ( this->Reader->ReadByte() == 1 ) ? (true) : (false);
+			
+			int sz = Reader->GetSize() - Reader->GetPosition();
+			this->m_pvBits = this->Reader->ReadBytes( sz/*this->m_cbSave*/, true );
+
+			oMetaHeader.rcBounds	= m_rcBounds;
+			oMetaHeader.cbSize		= m_cb;
+			oMetaHeader.ptSize		= m_ptSize;
+			oMetaHeader.cbSave		= m_cbSave ;
+			oMetaHeader.compression	= m_fCompression;
+			oMetaHeader.filter		= m_fFilter;
+
+			WmfPlaceableFileHeader oWmfHeader = {};
+			oMetaHeader.ToWMFHeader(&oWmfHeader);
+			
+			LONG lLenHeader = 22;
+			BYTE* pMetaHeader = new BYTE[lLenHeader];
+			memcpy(pMetaHeader, (void*)(&oWmfHeader), lLenHeader);
+
+			oMetaFile.SetHeader(pMetaHeader, lLenHeader);
+			
+			oMetaFile.SetData(m_pvBits, oMetaHeader.cbSave, oMetaHeader.cbSize, 0 == oMetaHeader.compression);
+
+			//if (pos < sz)
+			//{
+			//	NSFile::CFileBinary oFile;
 
-			this->m_pvBits = this->Reader->ReadBytes( this->m_cbSave, true );
+			//	if (oFile.CreateFile(L"d:\\blop.dat"))
+			//	{
+			//		BYTE * d = Reader->ReadBytes( sz - pos, true );
+			//		if (d)
+			//		{
+			//			oFile.WriteFile (d, sz - pos);
+			//			delete []d;
+			//			oFile.CloseFile();
+			//		}
+			//	}
+			//}
 		}
 
 		virtual ~MetafilePictBlip()

ASCOfficeDocFile/DocDocxConverter/OfficeDrawing/RecordFactory.cpp

@@ -83,17 +83,20 @@ namespace DocFileFormat
 			return new BlipStoreEntry();
 			break;
 
-		case BitmapBlip::TYPE_CODE_0xF01D:
-		case BitmapBlip::TYPE_CODE_0xF01E:
-		case BitmapBlip::TYPE_CODE_0xF01F:
-		case BitmapBlip::TYPE_CODE_0xF020:
-		case BitmapBlip::TYPE_CODE_0xF021:
+		case BitmapBlip::TYPE_CODE_0xF01D:				//OfficeArtBlipJPEG
+		case BitmapBlip::TYPE_CODE_0xF01E:				//OfficeArtBlipPNG
+		case BitmapBlip::TYPE_CODE_0xF01F:				//OfficeArtBlipDIB
+		case BitmapBlip::TYPE_CODE_0xF020:				//??
+		case BitmapBlip::TYPE_CODE_0xF021:				//??
+		case BitmapBlip::TYPE_CODE_0xF029:				//OfficeArtBlipTIFF
+		case BitmapBlip::TYPE_CODE_0xF02A:				//OfficeArtBlipJPEG
 			return new BitmapBlip();
 			break;
 
-		case MetafilePictBlip::TYPE_CODE_0xF01A:
-		case MetafilePictBlip::TYPE_CODE_0xF01B:
-		case MetafilePictBlip::TYPE_CODE_0xF01C			:	return new MetafilePictBlip();				break;
+		case MetafilePictBlip::TYPE_CODE_0xF01A:			//OfficeArtBlipEMF
+		case MetafilePictBlip::TYPE_CODE_0xF01B:			//OfficeArtBlipWMF
+		case MetafilePictBlip::TYPE_CODE_0xF01C			:	//OfficeArtBlipPICT
+															return new MetafilePictBlip();				break;
 
 		case DrawingGroup::TYPE_CODE_0xF000				:	return new DrawingGroup();					break;
 		case DrawingGroupRecord::TYPE_CODE_0xF006		:	return new DrawingGroupRecord();			break;

ASCOfficeDocFile/DocDocxConverter/VMLPictureMapping.cpp

@@ -216,16 +216,21 @@ namespace DocFileFormat
 					MetafilePictBlip* metaBlip = static_cast<MetafilePictBlip*>(oBlipEntry->Blip);
 					if (metaBlip)
 					{
-						//meta images can be compressed
-						unsigned char* decompressed = NULL;
-						int decompressedSize = 0;
-
-						decompressedSize = metaBlip->Decompress(&decompressed);
-						if (0 != decompressedSize && NULL != decompressed)
-						{
-							m_ctx->_docx->ImagesList.push_back(ImageFileStructure(GetTargetExt(oBlipEntry->btWin32), std::vector<unsigned char>(decompressed, (decompressed + decompressedSize))));
-							RELEASEARRAYOBJECTS(decompressed);
-						}
+						////meta images can be compressed
+						//unsigned char* decompressed = NULL;
+						//int decompressedSize = 0;
+
+						//decompressedSize = metaBlip->Decompress(&decompressed);
+						//if (0 != decompressedSize && NULL != decompressed)
+						//{
+							unsigned char *newData	= NULL;
+							int newDataSize = metaBlip->oMetaFile.ToBuffer(newData);
+							
+							m_ctx->_docx->ImagesList.push_back(ImageFileStructure(GetTargetExt(oBlipEntry->btWin32), std::vector<unsigned char>(newData, (newData + newDataSize))));
+							
+							//RELEASEARRAYOBJECTS(decompressed);
+							RELEASEARRAYOBJECTS(newData);
+						//}
 					}
 				}
 				break;