eUIUnit=FUNIT_MM;

aUIScale=Fraction(1,1);

nUIUnitKomma=0;

pLayerAdmin=NULL;

pItemPool=pPool;

m_pEmbeddedHelper=_pEmbeddedHelper;

pDrawOutliner=NULL;

pHitTestOutliner=NULL;

mbUndoEnabled=true;

nProgressPercent=0;

nLoadVersion=0;

mbChanged = sal_False;

nSwapGraphicsMode=SDR_SWAPGRAPHICSMODE_DEFAULT;

nStreamCompressMode=COMPRESSMODE_NONE;

nStreamNumberFormat=NUMBERFORMAT_INT_BIGENDIAN;

nDefaultTabulator=0;

pGradientList=NULL;

pBitmapList=NULL;

mpNumberFormatter = NULL;

nStarDrawPreviewMasterPageNum = SDRPAGE_NOTFOUND;

pModelStorage = NULL;

mpForbiddenCharactersTable = NULL;

mpOutlinerCache = NULL;

mbKernAsianPunctuation = sal_False;

mbAddExtLeading = sal_False;

// OutlinerPool als SecondaryPool des SdrPool

pItemPool->SetSecondaryPool(pOutlPool);

// Merken, dass ich mir die beiden Pools selbst gemacht habe

}

pItemPool->SetDefaultMetric((SfxMapUnit)eObjUnit);

// den DrawOutliner OnDemand erzeugen geht noch nicht, weil ich den Pool

// sonst nicht kriege (erst ab 302!)

pDrawOutliner = SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, this );

pHitTestOutliner = SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, this );

ImpCreateTables();

}

#endif

DBG_CTOR(SdrModel,NULL);

}

SdrModel::SdrModel(const String& rPath, SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* pPers, sal_Bool bLoadRefCounts):

#endif

DBG_CTOR(SdrModel,NULL);

}

SdrModel::SdrModel(SfxItemPool* pPool, ::comphelper::IEmbeddedHelper* pPers, FASTBOOL bUseExtColorTable, sal_Bool bLoadRefCounts):

FASTBOOL SdrModel::operator==(const SdrModel& /*rCmpModel*/) const

{

DBG_ERROR("SdrModel::operator==() ist noch nicht implementiert");

}

void SdrModel::SetSwapGraphics( FASTBOOL bSwap )

////////////////////////////////////////////////////////////////////////////////////////////////////

{

if (nAnz<1) nAnz=1;

nMaxUndoCount=nAnz;

FASTBOOL SdrModel::Undo()

{

if( mpImpl->mpUndoManager )

{

DBG_ERROR("svx::SdrModel::Undo(), method not supported with application undo manager!");

pDo->Undo();

if(pRedoStack==NULL)

pRedoStack=new Container(1024,16,16);

mbUndoEnabled = bWasUndoEnabled;

}

}

FASTBOOL SdrModel::Redo()

{

if( mpImpl->mpUndoManager )

{

DBG_ERROR("svx::SdrModel::Redo(), method not supported with application undo manager!");

pDo->Redo();

if(pUndoStack==NULL)

pUndoStack=new Container(1024,16,16);

mbUndoEnabled = bWasUndoEnabled;

}

}

FASTBOOL SdrModel::Repeat(SfxRepeatTarget& rView)

{

if( mpImpl->mpUndoManager )

{

DBG_ERROR("svx::SdrModel::Redo(), method not supported with application undo manager!");

if(pDo->CanRepeat(rView))

{

pDo->Repeat(rView);

}

}

}

{

if (pUndoStack==NULL)

pUndoStack=new Container(1024,16,16);

while (pUndoStack->Count()>nMaxUndoCount)

{

delete (SfxUndoAction*)pUndoStack->Remove(pUndoStack->Count()-1);

sal_Int32 nAnz=GetPageCount();

for (i=nAnz-1; i>=0; i--)

{

}

maPages.Clear();

// #109538#

nAnz=GetMasterPageCount();

for(i=nAnz-1; i>=0; i--)

{

}

maMaPag.Clear();

// #109538#

void ImpGetDefaultFontsLanguage( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rComplex)

{

static struct {

} aOutTypeArr[ nItemCnt ] = {

{ DEFAULTFONT_LATIN_TEXT, LANGUAGE_ENGLISH_US },

{ DEFAULTFONT_CJK_TEXT, LANGUAGE_ENGLISH_US },

};

SvxFontItem* aItemArr[ nItemCnt ] = { &rLatin, &rAsian, &rComplex };

{

Font aFnt( OutputDevice::GetDefaultFont(

aOutTypeArr[ n ].nFntType, aOutTypeArr[ n ].nLanguage,

}

}

{

// #95114# set application-language specific dynamic pool language defaults

SvxFontItem aSvxFontItem( EE_CHAR_FONTINFO) ;

boost::shared_ptr< SdrOutliner > SdrModel::CreateDrawOutliner(const SdrTextObj* pObj)

{

boost::shared_ptr< SdrOutliner > xDrawOutliner( SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, this ) );

xDrawOutliner->SetTextObj(pObj);

return xDrawOutliner;

}

return NULL;

}

{

/**************************************************************************

* Initialisierung der Outliner fuer Textausgabe und HitTest

if( bInit )

{

pOutliner->EraseVirtualDevice();

pOutliner->SetEditTextObjectPool(pItemPool);

pOutliner->SetDefTab(nDefaultTabulator);

}

if( isLocked() )

return;

for (nNum=0; nNum<nAnz; nNum++) {

GetMasterPage(nNum)->ReformatAllTextObjects();

}

// Die Vorlagenattribute der Zeichenobjekte in harte Attribute verwandeln.

void SdrModel::BurnInStyleSheetAttributes()

{

for (nNum=0; nNum<nAnz; nNum++) {

GetMasterPage(nNum)->BurnInStyleSheetAttributes();

}

ImpReformatAllTextObjects();

}

{

if (nVal!=nDefTextHgt) {

nDefTextHgt=nVal;

}

}

{

if (nDefaultTabulator!=nVal) {

nDefaultTabulator=nVal;

void SdrModel::TakeWinkStr(long nWink, XubString& rStr, FASTBOOL bNoDegChar) const

{

if(bNeg)

nWink = -nWink;

void SdrModel::TakePercentStr(const Fraction& rVal, XubString& rStr, FASTBOOL bNoPercentChar) const

{

if(nDiv < 0)

bNeg = !bNeg;

void SdrModel::RecalcPageNums(FASTBOOL bMaster)

{

Container& rPL=*(bMaster ? &maMaPag : &maPages);

for (i=0; i<nAnz; i++) {

SdrPage* pPg=(SdrPage*)(rPL.GetObject(i));

pPg->SetPageNum(i);

}

}

{

if (nPos>nAnz) nPos=nAnz;

maPages.Insert(pPage,nPos);

// #109538#

PageListChanged();

pPage->SetPageNum(nPos);

pPage->SetModel(this);

SetChanged();

SdrHint aHint(HINT_PAGEORDERCHG);

aHint.SetPage(pPage);

Broadcast(aHint);

}

{

SdrPage* pPg=RemovePage(nPgNum);

delete pPg;

}

{

SdrPage* pPg=(SdrPage*)maPages.Remove(nPgNum);

// #109538#

PageListChanged();

if (pPg!=NULL) {

}

SetChanged();

SdrHint aHint(HINT_PAGEORDERCHG);

aHint.SetPage(pPg);

return pPg;

}

{

SdrPage* pPg=(SdrPage*)maPages.Remove(nPgNum);

// #109538#

PageListChanged();

if (pPg!=NULL) {

InsertPage(pPg,nNewPos);

}

}

{

if (nPos>nAnz) nPos=nAnz;

maMaPag.Insert(pPage,nPos);

// #109538#

MasterPageListChanged();

pPage->SetPageNum(nPos);

pPage->SetModel(this);

if (nPos<nAnz) {

}

SetChanged();

SdrHint aHint(HINT_PAGEORDERCHG);

Broadcast(aHint);

}

{

SdrPage* pPg=RemoveMasterPage(nPgNum);

if (pPg!=NULL) delete pPg;

}

{

SdrPage* pRetPg=(SdrPage*)maMaPag.Remove(nPgNum);

// #109538#

GetPage(np)->TRG_ImpMasterPageRemoved(*pRetPg);

}

}

SetChanged();

SdrHint aHint(HINT_PAGEORDERCHG);

aHint.SetPage(pRetPg);

return pRetPg;

}

{

SdrPage* pPg=(SdrPage*)maMaPag.Remove(nPgNum);

// #109538#

MasterPageListChanged();

if (pPg!=NULL) {

maMaPag.Insert(pPg,nNewPos);

// #109538#

MasterPageListChanged();

}

SetChanged();

SdrHint aHint(HINT_PAGEORDERCHG);

aHint.SetPage(pPg);

FASTBOOL SdrModel::CheckConsistence() const

{

#ifdef DBG_UTIL

DBG_CHKTHIS(SdrModel,NULL);

#endif

////////////////////////////////////////////////////////////////////////////////////////////////////

// #48289#

FASTBOOL bUndo, FASTBOOL bMoveNoCopy)

{

if( bUndo && !IsUndoEnabled() )

if( bUndo )

BegUndo(ImpGetResStr(STR_UndoMergeModel));

if (nMaxPage!=0)

nMaxPage--;

nDestPos=nPageAnz;

// Zunaechst die Zeiger der betroffenen Seiten in einem Array sichern

SdrPage** pPagePtrs=new SdrPage*[nCopyAnz];

for(nCopyNum=0; nCopyNum<nCopyAnz; nCopyNum++)

{

pPagePtrs[nCopyNum]=GetPage(nPageNum);

}

// Jetzt die Seiten kopieren

for (nCopyNum=0; nCopyNum<nCopyAnz; nCopyNum++)

{

SdrPage* pPg=pPagePtrs[nCopyNum];

if (!bMoveNoCopy)

{

const SdrPage* pPg1=GetPage(nPageNum2);

}

void SdrModel::Merge(SdrModel& rSourceModel,

FASTBOOL bMergeMasterPages, FASTBOOL bAllMasterPages,

FASTBOOL bUndo, FASTBOOL bTreadSourceAsConst)

{

if (bUndo)

BegUndo(ImpGetResStr(STR_UndoMergeModel));

FASTBOOL bInsPages=(nFirstPageNum<nSrcPageAnz || nLastPageNum<nSrcPageAnz);

if (nFirstPageNum>nMaxSrcPage) nFirstPageNum=nMaxSrcPage;

if (nLastPageNum>nMaxSrcPage) nLastPageNum =nMaxSrcPage;

FASTBOOL bReverse=nLastPageNum<nFirstPageNum;

if (bMergeMasterPages && nSrcMasterPageAnz!=0) {

// Feststellen, welche MasterPages aus rSrcModel benoetigt werden

if (bAllMasterPages) {

} else {

const SdrPage* pPg=rSourceModel.GetPage(i);

if(pPg->TRG_HasMasterPage())

{

if(nMPgNum < nSrcMasterPageAnz)

{

}

}

}

}

// Nun das Mapping der MasterPages bestimmen

if (pMasterNeed[i]) {

pMasterMap[i]=nAktMaPagNum;

nAktMaPagNum++;

// rueberholen der Masterpages

if (pMasterMap!=NULL && pMasterNeed!=NULL && nMasterNeed!=0) {

i--;

if (pMasterNeed[i]) {

SdrPage* pPg=NULL;

maMaPag.Insert(pPg,nDstMasterPageAnz);

// #109538#

MasterPageListChanged();

pPg->SetModel(this);

if (bUndo) AddUndo(GetSdrUndoFactory().CreateUndoNewPage(*pPg));

} else {

DBG_ERROR("SdrModel::Merge(): MasterPage im SourceModel nicht gefunden");

// rueberholen der Zeichenseiten

if (bInsPages) {

if (nDestPos>GetPageCount()) nDestPos=GetPageCount();

while (nMergeCount>0) {

SdrPage* pPg=NULL;

delete [] pMasterMap;

delete [] pMasterNeed;

SetChanged();

// Fehlt: Mergen und Mapping der Layer

if (bUndo) EndUndo();

}

{

if (!bPreview && bStarDrawPreviewMode && GetPageCount())

{

// Das Zuruecksetzen ist nicht erlaubt, da das Model ev. nicht vollstaendig geladen wurde

}

else

{

return xInt;

}

{

if( mbModelLocked != bLock )

{

while(nWhich)

{

{

const SfxPoolItem* pItem = pPoolItem;

return mpForbiddenCharactersTable;

}

{

if( nType != mnCharCompressType )

{

ImpReformatAllTextObjects();

}

{

for( n = 0, nCount = GetMasterPageCount(); ( n < nCount ) && !bRet; n++ )

if( GetMasterPage( n )->HasTransparentObjects( bCheckForAlphaChannel ) )

if( !bRet )

{

for( n = 0, nCount = GetPageCount(); ( n < nCount ) && !bRet; n++ )

if( GetPage( n )->HasTransparentObjects( bCheckForAlphaChannel ) )

}

return bRet;

}

{

if( NULL == mpOutlinerCache )

mpOutlinerCache = new SdrOutlinerCache(this);

mpImpl->mpUndoManager = pUndoManager;

}

SdrUndoFactory& SdrModel::GetSdrUndoFactory() const

{

if( !mpImpl->mpUndoFactory )