xref: /aoo42x/main/filter/inc/filter/msfilter/msdffimp.hxx (revision 49ac0a79)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#ifndef _MSDFFIMP_HXX
#define _MSDFFIMP_HXX

#include <com/sun/star/uno/Reference.h>
#include <com/sun/star/embed/XEmbeddedObject.hpp>
#include <tools/solar.h>		// UINTXX
#include <svl/svarray.hxx>
#include <tools/color.hxx>
#include <tools/gen.hxx>
#include <tools/table.hxx>
#include <svx/msdffdef.hxx>
#include <filter/msfilter/dffpropset.hxx>
#include <filter/msfilter/dffrecordheader.hxx>
#include <filter/msfilter/msfiltertracer.hxx>
#include <vcl/graph.hxx>
#include <string.h>
#include <map>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <filter/msfilter/msfilterdllapi.h>
#include <sot/storage.hxx>

class Graphic;
class SvStream;
class SdrObject;
class SdrOle2Obj;
class SotStorageRef;
class Polygon;
class PolyPolygon;
class FmFormModel;
class SdrModel;
class DffRecordHeader;

class SwFlyFrmFmt;

struct SvxMSDffBLIPInfo;
struct SvxMSDffShapeInfo;
struct SvxMSDffShapeOrder;

class SvxMSDffManager;

class SfxItemSet;
class SdrObject;
struct DffObjData;

class MSFILTER_DLLPUBLIC DffPropertyReader : public DffPropSet
{
	const SvxMSDffManager&	rManager;
	DffPropSet*				pDefaultPropSet;

	void		ApplyCustomShapeTextAttributes( SfxItemSet& rSet ) const;
	void		CheckAndCorrectExcelTextRotation( SvStream& rIn, SfxItemSet& rSet, DffObjData& rObjData ) const;
	void		ApplyCustomShapeAdjustmentAttributes( SfxItemSet& rSet ) const;
	void		ApplyCustomShapeGeometryAttributes( SvStream& rIn, SfxItemSet& rSet, const DffObjData& rObjData ) const;
	void		ApplyLineAttributes( SfxItemSet& rSet, const MSO_SPT eShapeType ) const; // #i28269#
	void		ApplyFillAttributes( SvStream& rIn, SfxItemSet& rSet, const DffObjData& rObjData ) const;

public:

	sal_Int32					mnFix16Angle;
	sal_Bool					mbRotateGranientFillWithAngle;

	DffPropertyReader( const SvxMSDffManager& rManager );
	~DffPropertyReader();
	sal_Int32		Fix16ToAngle( sal_Int32 nAngle ) const;

#ifdef DBG_CUSTOMSHAPE
	void		ReadPropSet( SvStream& rIn, void* pClientData, sal_uInt32 nShapeType = 0 ) const;
#else
	void		ReadPropSet( SvStream& rIn, void* pClientData ) const;
#endif

	void		SetDefaultPropSet( SvStream& rIn, sal_uInt32 nOffDgg ) const;
	void		ApplyAttributes( SvStream& rIn, SfxItemSet& rSet ) const;
	void		ApplyAttributes( SvStream& rIn, SfxItemSet& rSet, DffObjData& rObjData ) const;
	void		ImportGradientColor( SfxItemSet& aSet, MSO_FillType eMSO_FillType, double dTrans = 1.0 , double dBackTrans = 1.0 ) const;
};


#define COL_DEFAULT RGB_COLORDATA( 0xFA, 0xFB, 0xFC )

typedef SvxMSDffBLIPInfo*  SvxMSDffBLIPInfo_Ptr;

typedef SvxMSDffShapeInfo* SvxMSDffShapeInfo_Ptr;

typedef SvxMSDffShapeOrder* SvxMSDffShapeOrder_Ptr;

typedef ::std::map< sal_Int32, SdrObject* > SvxMSDffShapeIdContainer;

#define SVEXT_PERSIST_STREAM "\002OlePres000"

// nach der Reihenfolge des Auftretens sortiert werden:
//
SV_DECL_PTRARR_DEL(SvxMSDffBLIPInfos,	SvxMSDffBLIPInfo_Ptr,	16,16)

SV_DECL_PTRARR_DEL(SvxMSDffShapeOrders,	SvxMSDffShapeOrder_Ptr,	16,16)

// explizit sortiert werden:
//
SV_DECL_PTRARR_SORT_DEL_VISIBILITY(SvxMSDffShapeInfos,	SvxMSDffShapeInfo_Ptr,	16,16, MSFILTER_DLLPUBLIC)

SV_DECL_PTRARR_SORT_VISIBILITY(SvxMSDffShapeTxBxSort,	SvxMSDffShapeOrder_Ptr,	16,16, MSFILTER_DLLPUBLIC)

#define SVXMSDFF_SETTINGS_CROP_BITMAPS		1
#define SVXMSDFF_SETTINGS_IMPORT_PPT		2
#define SVXMSDFF_SETTINGS_IMPORT_EXCEL		4

#define SP_FGROUP		0x001	// This shape is a group shape
#define SP_FCHILD		0x002	// Not a top-level shape
#define SP_FPATRIARCH	0x004	// This is the topmost group shape.
								// Exactly one of these per drawing.
#define SP_FDELETED		0x008	// The shape has been deleted
#define SP_FOLESHAPE	0x010	// The shape is an OLE object
#define SP_FHAVEMASTER	0x020	// Shape has a hspMaster property
#define SP_FFLIPH		0x040	// Shape is flipped horizontally
#define SP_FFLIPV		0x080	// Shape is flipped vertically
#define SP_FCONNECTOR	0x100	// Connector type of shape
#define SP_FHAVEANCHOR	0x200	// Shape has an anchor of some kind
#define SP_FBACKGROUND	0x400	// Background shape
#define SP_FHAVESPT		0x800	// Shape has a shape type property

// for the CreateSdrOLEFromStorage we need the information, how we handle
// convert able OLE-Objects - this ist stored in
#define OLE_MATHTYPE_2_STARMATH				0x0001
#define OLE_WINWORD_2_STARWRITER			0x0002
#define OLE_EXCEL_2_STARCALC				0x0004
#define OLE_POWERPOINT_2_STARIMPRESS		0x0008

struct SvxMSDffConnectorRule
{
	sal_uInt32	nRuleId;
	sal_uInt32  nShapeA;		// SPID of shape A

	sal_uInt32  nShapeB;		// SPID of shape B
	sal_uInt32  nShapeC;		// SPID of connector shape
	sal_uInt32  ncptiA;			// Connection site Index of shape A
	sal_uInt32  ncptiB;			// Connection site Index of shape B
    sal_uInt32  nSpFlagsA;      // SpFlags of shape A ( the original mirror flags must be known when solving the Solver Container )
    sal_uInt32  nSpFlagsB;      // SpFlags of shape A

	SdrObject* pAObj;		// pPtr of object ( corresponding to shape A )
	SdrObject* pBObj;		//	 "
	SdrObject* pCObj;		//	 "  of connector object

	SvxMSDffConnectorRule() : nSpFlagsA( 0 ), nSpFlagsB( 0 ), pAObj( NULL ), pBObj( NULL ), pCObj( NULL ) {};

    friend SvStream& operator>>( SvStream& rIn, SvxMSDffConnectorRule& rAtom );
};
struct MSFILTER_DLLPUBLIC SvxMSDffSolverContainer
{
	List	aCList;

			SvxMSDffSolverContainer();
			~SvxMSDffSolverContainer();

	MSFILTER_DLLPUBLIC friend SvStream& operator>>( SvStream& rIn, SvxMSDffSolverContainer& rAtom );
};

struct FIDCL
{
	sal_uInt32	dgid;		// DG owning the SPIDs in this cluster
	sal_uInt32	cspidCur;	// number of SPIDs used so far
};

//---------------------------------------------------------------------------
//  von SvxMSDffManager fuer jedes in der Gruppe enthaltene Shape geliefert
//---------------------------------------------------------------------------
struct MSDffTxId
{
	sal_uInt16 nTxBxS;
	sal_uInt16 nSequence;
	MSDffTxId(sal_uInt16 nTxBxS_, sal_uInt16 nSequence_ )
			: nTxBxS(			  nTxBxS_		),
			  nSequence(		  nSequence_	){}
	MSDffTxId(const MSDffTxId& rCopy)
			: nTxBxS(			  rCopy.nTxBxS    ),
			  nSequence(		  rCopy.nSequence ){}
};

struct MSFILTER_DLLPUBLIC SvxMSDffImportRec
{
	SdrObject*	pObj;
	Polygon*	pWrapPolygon;
	char*		pClientAnchorBuffer;
	sal_uInt32		nClientAnchorLen;
	char*		pClientDataBuffer;
	sal_uInt32		nClientDataLen;
	sal_uInt32		nXAlign;
	sal_uInt32		nXRelTo;
	sal_uInt32		nYAlign;
	sal_uInt32		nYRelTo;
	sal_uInt32		nLayoutInTableCell;
    sal_uInt32      nFlags;
	long		nTextRotationAngle;
	long		nDxTextLeft;	// Abstand der Textbox vom umgebenden Shape
	long		nDyTextTop;
	long		nDxTextRight;
	long		nDyTextBottom;
	long		nDxWrapDistLeft;
	long		nDyWrapDistTop;
	long		nDxWrapDistRight;
	long		nDyWrapDistBottom;
	long		nCropFromTop;
	long		nCropFromBottom;
	long		nCropFromLeft;
	long		nCropFromRight;
	MSDffTxId	aTextId;		// Kennungen fuer Textboxen
	sal_uLong		nNextShapeId;	// fuer verlinkte Textboxen
	sal_uLong		nShapeId;
	MSO_SPT		eShapeType;
	MSO_LineStyle eLineStyle;	// Umrandungs-Arten
	sal_Bool		bDrawHell		:1;
	sal_Bool		bHidden			:1;
	sal_Bool		bReplaceByFly	:1;
	sal_Bool		bLastBoxInChain	:1;
	sal_Bool		bHasUDefProp	:1;
	sal_Bool 		bVFlip :1;
	sal_Bool 		bHFlip :1;
	sal_Bool		bAutoWidth      :1;

	SvxMSDffImportRec();
	SvxMSDffImportRec(const SvxMSDffImportRec& rCopy);
	~SvxMSDffImportRec();
	sal_Bool operator==( const SvxMSDffImportRec& rEntry ) const
	{   return nShapeId == rEntry.nShapeId; }
	sal_Bool operator<( const SvxMSDffImportRec& rEntry ) const
	{   return nShapeId < rEntry.nShapeId;  }
};
typedef SvxMSDffImportRec* MSDffImportRec_Ptr;

// Liste aller SvxMSDffImportRec fuer eine Gruppe
SV_DECL_PTRARR_SORT_DEL_VISIBILITY(MSDffImportRecords, MSDffImportRec_Ptr, 16,16, MSFILTER_DLLPUBLIC)

//---------------------------------------------------------------------------
//   Import-/Export-Parameterblock fuer 1 x ImportObjAtCurrentStreamPos()
//---------------------------------------------------------------------------
struct SvxMSDffImportData
{
	MSDffImportRecords	aRecords;	// Shape-Pointer, -Ids und private Daten
	Rectangle			aParentRect;// Rectangle der umgebenden Gruppe
									// bzw. von aussen reingegebenes Rect
	Rectangle 			aNewRect;	// mit diesem Shape definiertes Rectangle

	SvxMSDffImportData()
		{}
	SvxMSDffImportData(const Rectangle& rParentRect)
		:aParentRect( rParentRect )
		{}
	void SetNewRect(sal_Int32 l, sal_Int32 o,
					sal_Int32 r, sal_Int32 u ){	aNewRect = Rectangle(l,o, r,u); }
	sal_Bool HasParRect() const { return aParentRect.IsEmpty(); }
	sal_Bool HasNewRect() const { return aNewRect.IsEmpty()   ; }
	sal_Bool HasRecords() const { return 0 != aRecords.Count(); }
	sal_uInt16				GetRecCount() const { return aRecords.Count();	}
	SvxMSDffImportRec*	GetRecord(sal_uInt16 iRecord) const
							{  return aRecords.GetObject( iRecord ); }
};

struct DffObjData
{
	const DffRecordHeader&	rSpHd;

	Rectangle	aBoundRect;
	Rectangle	aChildAnchor;

	sal_uInt32		nShapeId;
	sal_uInt32		nSpFlags;
	MSO_SPT		eShapeType;

	sal_Bool bShapeType				: 1;
	sal_Bool bClientAnchor			: 1;
	sal_Bool bClientData			: 1;
	sal_Bool bChildAnchor			: 1;
	sal_Bool bOpt					: 1;
	sal_Bool bOpt2					: 1;
	sal_Bool bIsAutoText			: 1;
	sal_Bool bRotateTextWithShape	: 1;

	int nCalledByGroup;

	DffObjData( const DffRecordHeader& rObjHd,
				const Rectangle& rBoundRect,
				int 			 nClByGroup ) :
		rSpHd( rObjHd ),
		aBoundRect(	rBoundRect ),
		nShapeId( 0 ),
		nSpFlags( 0 ),
		eShapeType( mso_sptNil ),
		bShapeType( sal_False ),
		bClientAnchor( sal_False ),
		bClientData( sal_False ),
		bChildAnchor( sal_False ),
		bOpt( sal_False ),
		bOpt2( sal_False ),
		bIsAutoText( sal_False ),
		bRotateTextWithShape( sal_True ),
		nCalledByGroup(	nClByGroup ){}
};

#define DFF_RECORD_MANAGER_BUF_SIZE			64

struct DffRecordList
{
		sal_uInt32				nCount;
		sal_uInt32				nCurrent;
		DffRecordList*		pPrev;
		DffRecordList*		pNext;

		DffRecordHeader		mHd[ DFF_RECORD_MANAGER_BUF_SIZE ];

							DffRecordList( DffRecordList* pList );
							~DffRecordList();
};

enum DffSeekToContentMode
{
	SEEK_FROM_BEGINNING,
	SEEK_FROM_CURRENT,
	SEEK_FROM_CURRENT_AND_RESTART
};

class MSFILTER_DLLPUBLIC DffRecordManager : public DffRecordList
{
	public :

		DffRecordList*		pCList;

		void				Clear();
		void				Consume( SvStream& rIn, sal_Bool bAppend = sal_False, sal_uInt32 nStOfs = 0 );

		sal_Bool				SeekToContent( SvStream& rIn, sal_uInt16 nRecType, DffSeekToContentMode eMode = SEEK_FROM_BEGINNING );
		DffRecordHeader*	GetRecordHeader( sal_uInt16 nRecType,  DffSeekToContentMode eMode = SEEK_FROM_BEGINNING );

							DffRecordManager();
							DffRecordManager( SvStream& rIn );
							~DffRecordManager();

		DffRecordHeader*	Current();
		DffRecordHeader*	First();
		DffRecordHeader*	Next();
		DffRecordHeader*	Prev();
		DffRecordHeader*	Last();
};

/*
	SvxMSDffManager - abstrakte Basis-Klasse fuer Escher-Import
	===============
	Zweck:	Zugriff auf Objekte im Drawing File Format
	Stand:	Zugriff nur auf BLIPs (wird spaeter erweitert)

	Beachte: in der zwecks PowerPoint-, ODER Word- ODER Excel-Import
	======== abgeleiteten Klasse
			 MUSS jeweils die Methode ProcessUserDefinedRecord()
			 implementiert werden!
*/
class MSFILTER_DLLPUBLIC SvxMSDffManager : public DffPropertyReader
{
	FmFormModel*			pFormModel;
	SvxMSDffBLIPInfos*		pBLIPInfos;
	SvxMSDffShapeInfos*		pShapeInfos;
	SvxMSDffShapeOrders*	pShapeOrders;
	sal_uLong					nDefaultFontHeight;
	long					nOffsDgg;
	sal_uInt16					nBLIPCount;
	sal_uInt16					nShapeCount;
	sal_uInt32				nGroupShapeFlags;

	void CheckTxBxStoryChain();
	void GetFidclData( long nOffsDgg );

protected :

    String                  maBaseURL;
    sal_uInt32                  mnCurMaxShapeId;    // we need this information to
	sal_uInt32					mnDrawingsSaved;	// access the right drawing
	sal_uInt32					mnIdClusters;		// while only knowing the shapeid
	FIDCL*					mpFidcls;
	Table					maDgOffsetTable;	// array of fileoffsets

	friend class DffPropertyReader;

	SvStream&		rStCtrl;
	SvStream*		pStData;
	SvStream*		pStData2;
	SdrModel*		pSdrModel;

	long			nMapMul;
	long			nMapDiv;
	long			nMapXOfs;
	long			nMapYOfs;
	long			nEmuMul;
	long			nEmuDiv;
	long			nPntMul;
	long			nPntDiv;
	FASTBOOL		bNeedMap;
	sal_uInt32			nSvxMSDffSettings;
	sal_uInt32			nSvxMSDffOLEConvFlags;

	/** stores a reference to an imported SdrObject with its shape id if
		it has one
	*/
	SvxMSDffShapeIdContainer	maShapeIdContainer;

	void GetCtrlData( long nOffsDgg );
    void GetDrawingGroupContainerData( SvStream& rSt,
                                       sal_uLong nLenDgg );
    // --> OD 2008-08-01 #156763#
    // Add internal drawing container id as parameter to the sub methods of
    // reading the control information about the drawing objects.
    // The drawing container id is used to distinguish the text ids of drawing
    // objects in different drawing containers.
    void GetDrawingContainerData( SvStream& rSt,
                                  sal_uLong nLenDg,
                                  const unsigned long nDrawingContainerId );
    sal_Bool GetShapeGroupContainerData( SvStream& rSt,
                                     sal_uLong nLenShapeGroupCont,
                                     sal_Bool bPatriarch,
                                     const unsigned long nDrawingContainerId );
    sal_Bool GetShapeContainerData( SvStream& rSt,
                                sal_uLong nLenShapeCont,
                                sal_uLong nPosGroup,
                                const unsigned long nDrawingContainerId );
    // <--

	FASTBOOL ReadGraphic( SvStream& rSt, sal_uLong nIndex, Graphic& rGraphic ) const;
	SdrObject* ImportFontWork( SvStream&, SfxItemSet&, Rectangle& rBoundRect ) const;
	SdrObject* ImportGraphic( SvStream&, SfxItemSet&, const DffObjData& ) const;
    // --> OD 2004-12-14 #i32596# - pass <nCalledByGroup> to method
    // Needed in the Writer Microsoft Word import to avoid import of OLE objects
    // inside groups. Instead a graphic object is created.
    virtual SdrObject* ImportOLE( long nOLEId,
                                  const Graphic& rGraf,
                                  const Rectangle& rBoundRect,
								  const Rectangle& rVisArea,
								  const int _nCalledByGroup,
								  sal_Int64 nAspect ) const;
    // <--
	SdrObject* GetAutoForm( MSO_SPT eTyp ) const;
#ifndef SVX_LIGHT
    static com::sun::star::uno::Reference < com::sun::star::embed::XEmbeddedObject > CheckForConvertToSOObj(
                sal_uInt32 nConvertFlags, SotStorage& rSrcStg,
                const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& xDestStg,
                const Graphic& rGrf,
				const Rectangle& rVisArea );
#endif

/*
		folgende Methoden sind zum Excel-Import zu ueberschreiben:
*/
	virtual sal_Bool ProcessClientAnchor(SvStream& rStData, sal_uLong nDatLen, char*& rpBuff, sal_uInt32& rBuffLen ) const;
	virtual void ProcessClientAnchor2( SvStream& rStData, DffRecordHeader& rHd, void* pData, DffObjData& );
	virtual sal_Bool ProcessClientData(  SvStream& rStData, sal_uLong nDatLen, char*& rpBuff, sal_uInt32& rBuffLen ) const;
	virtual SdrObject* ProcessObj( SvStream& rSt, DffObjData& rData, void* pData, Rectangle& rTextRect, SdrObject* pObj = NULL);
	virtual sal_uLong Calc_nBLIPPos( sal_uLong nOrgVal, sal_uLong nStreamPos ) const;
	virtual FASTBOOL GetColorFromPalette(sal_uInt16 nNum, Color& rColor) const;

	// SJ: New implementation of ReadObjText is used by Fontwork objects, because
	// the old one does not properly import multiple paragraphs
	void ReadObjText( const String& rText, SdrObject* pObj ) const;
	// -----------------------------------------------------------------------

	/*
		folgende Methode ist von allen zu ueberschreiben, die OLE-Objecte
		importieren moechten:
	*/
	virtual sal_Bool GetOLEStorageName( long nOLEId, String& rStorageName,
									SotStorageRef& rSrcStorage,
                com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& xDestStg
                                    ) const;

	/*
		folgende Methode ist von allen zu ueberschreiben, die verhindern
		moechten, dass (abgerundete) Rechtecke mit umgebrochenem Text
		immer in SdrRectObj( OBJ_TEXT ) umgewandelt werden:
		sal_True bedeutet umwandeln.
	*/
	virtual sal_Bool ShapeHasText(sal_uLong nShapeId, sal_uLong nFilePos) const;

public:

	void*				pSvxMSDffDummy1;
	void*				pSvxMSDffDummy2;
	DffPropertyReader*	pSecPropSet;
	List*				pEscherBlipCache;

	DffRecordManager	maShapeRecords;
	ColorData			mnDefaultColor;

	MSFilterTracer*		mpTracer;
	sal_Bool			mbTracing;

	Color MSO_TEXT_CLR_ToColor( sal_uInt32 nColorCode ) const;
	Color MSO_CLR_ToColor( sal_uInt32 nColorCode, sal_uInt16 nContextProperty = DFF_Prop_lineColor ) const;
	virtual sal_Bool SeekToShape( SvStream& rSt, void* pClientData, sal_uInt32 nId ) const;
	FASTBOOL SeekToRec( SvStream& rSt, sal_uInt16 nRecId, sal_uLong nMaxFilePos, DffRecordHeader* pRecHd = NULL, sal_uLong nSkipCount = 0 ) const;
	FASTBOOL SeekToRec2( sal_uInt16 nRecId1, sal_uInt16 nRecId2, sal_uLong nMaxFilePos, DffRecordHeader* pRecHd = NULL, sal_uLong nSkipCount = 0 ) const;

	// -----------------------------------------------------------------------
	static void MSDFFReadZString( SvStream& rIn, String& rStr, sal_uLong nMaxLen, FASTBOOL bUniCode = sal_False );

	static sal_Bool ReadCommonRecordHeader( DffRecordHeader& rRec, SvStream& rIn );
	static sal_Bool ReadCommonRecordHeader( SvStream& rSt,
										sal_uInt8&     rVer,
										sal_uInt16&   rInst,
										sal_uInt16&   rFbt,
										sal_uInt32&    rLength );
/*
	Konstruktor
	===========
	Input:	rStCtrl	  - Verwaltungsstream mit Containern,
						FBSE Objekten und Shapes
						( muss immer uebergeben werden;
						  Stream muss bereits offen sein )

			nOffsDgg  -	Offset im rStCtrl: Beginn des Drawing Group Containers

			pStData	  - Datenstream, in dem die BLIPs gespeichert sind
						( falls Null, wird angenommen, dass die
						  BLIPs ebenfalls im rStCtrl gespeichert sind;
						  dieser Stream muss ebenfalls bereits offen sein )
			pSdrModel_  kann beim Ctor-Aufruf leer bleiben, muss dann aber
						spaeter ueber SetModel() gesetzt werden!

	setzt nBLIPCount
*/
	SvxMSDffManager( SvStream& rStCtrl,
                     const String& rBaseURL,
					 long      nOffsDgg,
					 SvStream* pStData,
					 SdrModel* pSdrModel_			=  0,
					 long      nApplicationScale	=  0,
					 ColorData mnDefaultColor_		=  COL_DEFAULT,
					 sal_uLong     nDefaultFontHeight_	= 24,
					 SvStream* pStData2_			=  0,
					 MSFilterTracer* pTracer		= NULL );

	// in PPT werden die Parameter DGGContainerOffset und PicStream
	// mit Hilfe einer Init Routine Uebergeben.
    SvxMSDffManager( SvStream& rStCtrl, const String& rBaseURL, MSFilterTracer* pTracer );
	void InitSvxMSDffManager( long nOffsDgg_, SvStream* pStData_, sal_uInt32 nSvxMSDffOLEConvFlags );
	void SetDgContainer( SvStream& rSt );

	virtual ~SvxMSDffManager();

	sal_uInt32	GetSvxMSDffSettings() const { return nSvxMSDffSettings; };
	void	SetSvxMSDffSettings( sal_uInt32 nSettings ) { nSvxMSDffSettings = nSettings; };

	static sal_Bool     MakeContentStream( SotStorage * pStor, const GDIMetaFile & );
    static sal_Bool     ConvertToOle2( SvStream& rStm, sal_uInt32 nLen, const GDIMetaFile*,
								const SotStorageRef & rDest );

	void SetModel(SdrModel* pModel, long nApplicationScale);
	SdrModel*  GetModel() const { return pSdrModel; }
	void Scale(sal_Int32& rVal) const;
	void Scale(Point& rPos) const;
	void Scale(Size& rSiz) const;
	void Scale(Rectangle& rRect) const;
	void Scale(Polygon& rPoly) const;
	void Scale(PolyPolygon& rPoly) const;
	void ScaleEmu(sal_Int32& rVal) const;
	sal_uInt32 ScalePt( sal_uInt32 nPt ) const;
	sal_Int32 ScalePoint( sal_Int32 nVal ) const;

/*
	GetBLIP()			- Anforderung eines bestimmten BLIP
	=========
	Input:	nIdx		- Nummer des angeforderten BLIP
						  ( muss immer uebergeben werden )

	Output:	rData		- bereits fertig konvertierte Daten
						  ( direkt als Grafik in unsere Dokumente einzusetzen )

	Rueckgabewert: sal_True, im Erfolgsfalls, sal_False bei Fehler
*/
	sal_Bool GetBLIP( sal_uLong nIdx, Graphic& rData, Rectangle* pVisArea = NULL ) const;

/*
	GetBLIPDirect()		-Einlesen eines BLIP aus schon positioniertem Stream
	===============
	Input:	rBLIPStream	-bereits korrekt positionierter Stream
						  ( muss immer uebergeben werden )

	Output:	rData		-bereits fertig konvertierte Daten
						  ( direkt als Grafik in unsere Dokumente einzusetzen )

	Rueckgabewert: sal_True, im Erfolgsfalls, sal_False bei Fehler
*/
	sal_Bool GetBLIPDirect(SvStream& rBLIPStream, Graphic& rData, Rectangle* pVisArea = NULL ) const;

	sal_Bool GetShape(sal_uLong nId,
				  SdrObject*& rpData, SvxMSDffImportData& rData);

/*
	GetBLIPCount()	- Abfrage der verwalteten BLIP Anzahl
	==============
	Input:	./.
	Output:	./.
	Rueckgabewert: nBLIPCount	- Anzahl der im pStData (bzw. rStCtrl) enthaltenen BLIPs
								  ( sprich: Anzahl der FBSEs im Drawing Group Container )

						Werte:	0	- Struktur Ok, jedoch keine BLIPs vorhanden
								1..	- Anzahl der BLIPs
						USHRT_MAX	- Fehler: kein korrektes Drawing File Format
*/
	sal_uInt16 GetBLIPCount() const{ return nBLIPCount; }

/*
	ZCodecDecompressed()  - Dekomprimierung eines komp. WMF oder Enhanced WMF
	====================
	Input:	rIn		-bereits korrekt positionierter Stream,
					 der das komprimierte Bild enthaelt
			rOut	-bereits korrekt positionierter Ausgabe-Stream,

		bLookForEnd -Flag, ob das komp. Bild bis zum Stream-Ende reicht.
					 Falls sal_True, wird jeweils geprueft, ob das gelesene	noch
														zum Bild gehoert.
					 Falls sal_False, wird bis zum Stream-Ende gelesen.

	Output:	rIn     -Der Stream steht hinter dem Ende des komp. Bildes.
					 (es kann aber noch eine Ende-Kennung und CRC-Sum folgen)
			rOut	-Der Stream enthaelt das dekomprimierte Bild.
					 Der Stream wird auf den Anfang des Bildes positioniert.
					 (also dorthin, wo der Stream vor der Verarbeitung stand)

	Rueckgabewert:	sal_True, im Erfolgsfall
					sal_False bei Fehler oder Null Bytes geschrieben
*/
//	static sal_Bool ZCodecDecompressed(	SvStream& rIn,
//									SvStream& rOut,
//									sal_Bool bLookForEnd );
//
	SdrObject* ImportObj(SvStream& rSt, void* pData,
        Rectangle& rClientRect, const Rectangle& rGlobalChildRect, int nCalledByGroup = 0, sal_Int32* pShapeId = NULL);

	SdrObject* ImportGroup( const DffRecordHeader& rHd, SvStream& rSt, void* pData,
        Rectangle& rClientRect, const Rectangle& rGlobalChildRect, int nCalledByGroup = 0, sal_Int32* pShapeId = NULL );

	SdrObject* ImportShape( const DffRecordHeader& rHd, SvStream& rSt, void* pData,
        Rectangle& rClientRect, const Rectangle& rGlobalChildRect, int nCalledByGroup = 0, sal_Int32* pShapeId = NULL, sal_Bool bShapeGroup = sal_False);

	Rectangle GetGlobalChildAnchor( const DffRecordHeader& rHd, SvStream& rSt, Rectangle& aClientRect );
	void GetGroupAnchors( const DffRecordHeader& rHd, SvStream& rSt,
								Rectangle& rGroupClientAnchor, Rectangle& rGroupChildAnchor,
									const Rectangle& rClientRect, const Rectangle& rGlobalChildRect );

	inline const SvxMSDffShapeInfos* GetShapeInfos( void ) const
		{
			return pShapeInfos;
		}

	inline const SvxMSDffShapeOrders* GetShapeOrders( void ) const
		{
			return pShapeOrders;
		}

	void StoreShapeOrder(sal_uLong			nId,
						 sal_uLong			nTxBx,
						 SdrObject*		pObject,
						 SwFlyFrmFmt*	pFly = 0,
						 short			nHdFtSection = 0) const;

	void ExchangeInShapeOrder(SdrObject* pOldObject,
							  sal_uLong nTxBx,
							  SwFlyFrmFmt* pFly,
							  SdrObject*   pObject) const;

	void RemoveFromShapeOrder( SdrObject* pObject ) const;

	sal_uInt32	GetConvertFlags() const { return nSvxMSDffOLEConvFlags; }

	static SdrOle2Obj* CreateSdrOLEFromStorage( const String& rStorageName,
												SotStorageRef& rSrcStorage,
                                                const com::sun::star::uno::Reference < com::sun::star::embed::XStorage >& xDestStg,
												const Graphic& rGraf,
												const Rectangle& rBoundRect,
												const Rectangle& rVisArea,
												SvStream* pDataStrrm,
                                                ErrCode& rError,
												sal_uInt32 nConvertFlags,
												sal_Int64 nAspect );

	/* the method SolveSolver will create connections between shapes, it should be called after a page is imported.
	The SvxMSDffSolverContainer is containing necessary data data that is collected during the import of each shape
	*/
    void SolveSolver( const SvxMSDffSolverContainer& rSolver );

	static sal_Bool SetPropValue(
		const ::com::sun::star::uno::Any& rAny,
			const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet,
				const String& rPropertyName,
					sal_Bool bTestPropertyAvailability = sal_False );

	void insertShapeId( sal_Int32 nShapeId, SdrObject* pShape );
	void removeShapeId( SdrObject* pShape );
	SdrObject* getShapeForId( sal_Int32 nShapeId );
};

struct SvxMSDffBLIPInfo
{
	sal_uInt16 nBLIPType;	// Art des BLIP: z.B. 6 fuer PNG
	sal_uLong  nFilePos;	// Offset des BLIP im Daten-Stream
	sal_uLong  nBLIPSize;	// Anzahl Bytes, die der BLIP im Stream einnimmt
	SvxMSDffBLIPInfo(sal_uInt16 nBType, sal_uLong nFPos, sal_uLong nBSize):
		nBLIPType( nBType ), nFilePos( nFPos ), nBLIPSize( nBSize ){}
};

struct SvxMSDffShapeInfo
{
	sal_uInt32 nShapeId;	 // Shape Id, verwendet im PLCF SPA und im mso_fbtSp (FSP)
	sal_uLong nFilePos;	 // Offset des Shape im Kontroll-Stream fuer eventuelle
					 // erneute Zugriffe auf dieses Shape
	sal_uInt32 nTxBxComp;

	sal_Bool bReplaceByFly  :1; // Shape darf im Writer durch Rahmen ersetzt werden.
	sal_Bool bSortByShapeId :1;
	sal_Bool bLastBoxInChain:1;

	SvxMSDffShapeInfo(sal_uLong nFPos, sal_uInt32 nId=0, // sal_uLong nBIdx=0,
					  sal_uInt16 nSeqId=0, sal_uInt16 nBoxId=0):
		nShapeId( nId ),
		nFilePos( nFPos ),
		nTxBxComp( (nSeqId << 16) + nBoxId )
		{
			bReplaceByFly	= sal_False;
			bSortByShapeId	= sal_False;
			bLastBoxInChain	= sal_True;
		}
	SvxMSDffShapeInfo(SvxMSDffShapeInfo& rInfo):
		nShapeId( rInfo.nShapeId ),
		nFilePos( rInfo.nFilePos ),
		nTxBxComp( rInfo.nTxBxComp )
		{
			bReplaceByFly	= rInfo.bReplaceByFly;
			bSortByShapeId	= rInfo.bSortByShapeId;
			bLastBoxInChain	= rInfo.bLastBoxInChain;
		}
	sal_Bool operator==( const SvxMSDffShapeInfo& rEntry ) const
	{
		return bSortByShapeId ? (nShapeId  == rEntry.nShapeId)
							  : (nTxBxComp == rEntry.nTxBxComp && this == &rEntry);
	}
	sal_Bool operator<( const SvxMSDffShapeInfo& rEntry ) const
	{
		return bSortByShapeId ? (nShapeId  < rEntry.nShapeId)
							  : (nTxBxComp < rEntry.nTxBxComp);
	}
};

struct SvxMSDffShapeOrder
{
	sal_uLong nShapeId;		// Shape Id, verwendet im PLCF SPA und im mso_fbtSp (FSP)

	sal_uLong nTxBxComp;	// Ketten- und Boxnummer in der Text-Box-Story (bzw. Null)

	SwFlyFrmFmt* pFly;	// Frame-Format eines statt des Sdr-Text-Objektes im
						// Writer eingefuegten Rahmens: zur Verkettung benoetigt!

	short nHdFtSection; // used by Writer to find out if linked frames are in the
						// same header or footer of the same section

	SdrObject*	pObj;	// Zeiger auf das Draw-Objekt (bzw. Null, falls nicht verwendet)

	// Vorgehensweise:  im Ctor des SvxMSDffManager werden im der Shape-Order-Array
	//					nur die Shape-Ids vermerkt,
	//					Text-Box-Nummer und der Objekt-Pointer werden nur dann
	//					gespeichert, wenn das Shape tatsaechlich importiert wird!
	SvxMSDffShapeOrder( sal_uLong nId ):
		nShapeId( nId ), nTxBxComp( 0 ), pFly( 0 ), nHdFtSection( 0 ), pObj( 0 ){}

	sal_Bool operator==( const SvxMSDffShapeOrder& rEntry ) const
	{
		return (nTxBxComp == rEntry.nTxBxComp);
	}
	sal_Bool operator<( const SvxMSDffShapeOrder& rEntry ) const
	{
		return (nTxBxComp < rEntry.nTxBxComp);
	}
};

#endif