/************************************************************** * * 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. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_sw.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // RES_SETEXPFLD #include // class SwFmtRefMark #include // class SwTableLines, ... #include #include // SwExpField #include // class SwSection #include // class SwSelBoxes #include #include // class SwDocSh #include #include #include #define MAX_FIELDLEN 64000 using namespace com::sun::star; static SwCntntNode* GetCntntNode(SwDoc* pDoc, SwNodeIndex& rIdx, sal_Bool bNext) { SwCntntNode * pCNd = rIdx.GetNode().GetCntntNode(); if(!pCNd && 0 == (pCNd = bNext ? pDoc->GetNodes().GoNext(&rIdx) : pDoc->GetNodes().GoPrevious(&rIdx))) { pCNd = bNext ? pDoc->GetNodes().GoPrevious(&rIdx) : pDoc->GetNodes().GoNext(&rIdx); ASSERT(pCNd, "kein ContentNode gefunden"); } return pCNd; } // ------ Stack-Eintrag fuer die gesamten - Attribute vom Text ----------- SwFltStackEntry::SwFltStackEntry(const SwPosition& rStartPos, SfxPoolItem* pHt ) : nMkNode(rStartPos.nNode, -1), //Modify here for #119405, by easyfan, 2012-05-24 nPtNode(nMkNode),mnStartCP(-1),mnEndCP(-1),bIsParaEnd(false) //End of modification, by easyfan { // Anfang vom Bereich merken nMkCntnt = rStartPos.nContent.GetIndex(); pAttr = pHt; // speicher eine Kopie vom Attribut bOld = sal_False; // used for marking Attributes *before* skipping field results bLocked = sal_True; // locke das Attribut --> darf erst bCopied = sal_False; // gesetzt werden, wenn es wieder geunlocked ist bConsumedByField = sal_False; } SwFltStackEntry::SwFltStackEntry(const SwFltStackEntry& rEntry) : nMkNode(rEntry.nMkNode), nPtNode(rEntry.nPtNode) { pAttr = rEntry.pAttr->Clone(); nMkCntnt= rEntry.nMkCntnt; bOld = rEntry.bOld; bLocked = bCopied = sal_True; // when rEntry were NOT bLocked we would never have been called bConsumedByField = rEntry.bConsumedByField; //Modify here for #119405, by chengjh, 2012-08-16 mnStartCP= rEntry.mnStartCP; mnEndCP = rEntry.mnEndCP; bIsParaEnd = rEntry.bIsParaEnd; //End } SwFltStackEntry::~SwFltStackEntry() { // Attribut kam zwar als Pointer, wird aber hier geloescht if (pAttr) delete pAttr; } void SwFltStackEntry::SetEndPos(const SwPosition& rEndPos) { // Attribut freigeben und das Ende merken. // Alles mit sal_uInt16's, weil sonst beim Einfuegen von neuem Text an der // Cursor-Position auch der Bereich vom Attribut weiter // verschoben wird. // Das ist aber nicht das gewollte! bLocked = sal_False; // freigeben und das ENDE merken nPtNode = rEndPos.nNode.GetIndex()-1; nPtCntnt = rEndPos.nContent.GetIndex(); } //Modify here for #119405, by chengjh, 2012-08-16 //The only position of 0x0D will not be able to make regin in the old logic //because it is beyond the length of para...need special consideration here. bool SwFltStackEntry::IsAbleMakeRegion() { SwCntntNode *const pCntntNode( SwNodeIndex(nMkNode, +1).GetNode().GetCntntNode() ); if ( (nMkNode.GetIndex() == nPtNode.GetIndex()) && (nMkCntnt == nPtCntnt) && ( (0 != nPtCntnt) || ( pCntntNode && ( 0 != pCntntNode->Len() ) ) ) && ( RES_TXTATR_FIELD != pAttr->Which() && RES_TXTATR_ANNOTATION != pAttr->Which() && RES_TXTATR_INPUTFIELD != pAttr->Which() ) && !( bIsParaEnd && pCntntNode && pCntntNode->IsTxtNode() && 0 != pCntntNode->Len() ) ) { return false; } return true; } //End sal_Bool SwFltStackEntry::MakeRegion(SwDoc* pDoc, SwPaM& rRegion, sal_Bool bCheck ) { // does this range actually contain something? // empty range is allowed if at start of empty paragraph // fields are special: never have range, so leave them //Modify here for #119405, by chengjh, 2012-08-16 //Revised the code and move the code segment to defined function if ( !IsAbleMakeRegion() ) { return sal_False; } //End // !!! Die Content-Indizies beziehen sich immer auf den Node !!! rRegion.GetPoint()->nNode = nMkNode.GetIndex() + 1; SwCntntNode* pCNd = GetCntntNode(pDoc, rRegion.GetPoint()->nNode, sal_True); rRegion.GetPoint()->nContent.Assign(pCNd, nMkCntnt); rRegion.SetMark(); if( nMkNode != nPtNode ) { rRegion.GetPoint()->nNode = nPtNode.GetIndex() + 1; pCNd = GetCntntNode(pDoc, rRegion.GetPoint()->nNode, sal_False); } rRegion.GetPoint()->nContent.Assign(pCNd, nPtCntnt); #if OSL_DEBUG_LEVEL > 1 ASSERT( CheckNodesRange( rRegion.Start()->nNode, rRegion.End()->nNode, sal_True ), "Attribut oder AEhnliches ueber Bereichs-Grenzen" ); #endif if( bCheck ) return CheckNodesRange( rRegion.Start()->nNode, rRegion.End()->nNode, sal_True ); else return sal_True; } SwFltControlStack::SwFltControlStack(SwDoc* pDo, sal_uLong nFieldFl) : nFieldFlags(nFieldFl), bHasSdOD(true) ,bSdODChecked(false), pDoc(pDo), bIsEndStack(false) //End { } SwFltControlStack::~SwFltControlStack() { ASSERT(!Count(), "noch Attribute auf dem Stack"); } // MoveAttrs() ist fuer folgendes Problem: // Wenn ueber den Stack ein Feld wie z.B. "Variable setzen" gesetzt wird, // verschiebt sich der Text um ein \xff - Zeichen, und alle folgenden // Attribute stimmen in ihrer Position nicht mehr. // Dann muss MoveAttrs() nach dem Setzen des Attributes ins Doc gerufen werden, // so dass alle Attribut-Positionen, // die im selben Absatz weiter hinten stehen, um 1 Zeichen weiter // nach rechts verschoben werden. void SwFltControlStack::MoveAttrs( const SwPosition& rPos ) { sal_uInt16 nCnt = static_cast< sal_uInt16 >(Count()); SwFltStackEntry* pEntry; sal_uLong nPosNd = rPos.nNode.GetIndex(); sal_uInt16 nPosCt = rPos.nContent.GetIndex() - 1; for (sal_uInt16 i=0; i < nCnt; i++){ pEntry = (*this)[ i ]; if(( pEntry->nMkNode.GetIndex() + 1 == nPosNd ) &&( pEntry->nMkCntnt >= nPosCt )){ pEntry->nMkCntnt++; ASSERT( pEntry->nMkCntnt <= pDoc->GetNodes()[nPosNd]->GetCntntNode()->Len(), "Attribut-Anfang hinter Zeilenende" ); } if(( pEntry->nPtNode.GetIndex() + 1 == nPosNd ) &&( pEntry->nPtCntnt >= nPosCt )){ pEntry->nPtCntnt++; ASSERT( pEntry->nPtCntnt <= pDoc->GetNodes()[nPosNd]->GetCntntNode()->Len(), "Attribut-Ende hinter Zeilenende" ); } } } void SwFltControlStack::MarkAllAttrsOld() { sal_uInt16 nCnt = static_cast< sal_uInt16 >(Count()); for (sal_uInt16 i=0; i < nCnt; i++) (*this)[ i ]->bOld = sal_True; } void SwFltControlStack::NewAttr(const SwPosition& rPos, const SfxPoolItem & rAttr ) { SwFltStackEntry *pTmp = new SwFltStackEntry(rPos, rAttr.Clone() ); //Modify here for #119405, by easyfan, 2012-05-24 pTmp->SetStartCP(GetCurrAttrCP()); //End of modification, by easyfan sal_uInt16 nWhich = pTmp->pAttr->Which(); SetAttr(rPos, nWhich);// Ende von evtl. gleichen Attributen auf dem Stack // Setzen, damit sich die Attribute nicht auf // dem Stack haeufen maEntries.push_back(pTmp); } void SwFltControlStack::DeleteAndDestroy(Entries::size_type nCnt) { ASSERT(nCnt < maEntries.size(), "Out of range!"); if (nCnt < maEntries.size()) { myEIter aElement = maEntries.begin() + nCnt; delete *aElement; maEntries.erase(aElement); } //Modify for #119405 by chengjh, 2012-08-16 //Clear the para end position recorded in reader intermittently for the least impact on loading performance //Because the attributes handled based on the unit of para if ( Count() == 0 ) { ClearParaEndPosition(); bHasSdOD = true; bSdODChecked = false; } //End } // SwFltControlStack::StealAttr() loescht Attribute des angegebenen Typs vom Stack. // Als nAttrId sind erlaubt: 0 fuer alle, oder ein spezieller Typ. // Damit erscheinen sie nicht in der Doc-Struktur. Dabei werden nur die // Attribute entfernt, die im selben Absatz wie pPos stehen. // Wird fuer Grafik-Apos -> Grafiken benutzt. void SwFltControlStack::StealAttr(const SwPosition* pPos, sal_uInt16 nAttrId /* = 0 */) { sal_uInt16 nCnt = static_cast< sal_uInt16 >(Count()); SwFltStackEntry* pEntry; while (nCnt) { nCnt --; pEntry = (*this)[ nCnt ]; if (pEntry->nPtNode.GetIndex()+1 == pPos->nNode.GetIndex() && (!nAttrId || nAttrId == pEntry->pAttr->Which())) DeleteAndDestroy(nCnt); // loesche aus dem Stack } } // SwFltControlStack::KillUnlockedAttr() loescht alle Attribute vom Stack, // welche punktuell auf pPos aufgespannt sind. // Damit erscheinen sie nicht in der Doc-Struktur. // Wird im WW Import benoetigt zum ignorieren der auf dem 0x0c Section- // Break-Symbol gesetzten Attribute. void SwFltControlStack::KillUnlockedAttrs(const SwPosition& pPos) { SwNodeIndex aAktNode( pPos.nNode, -1 ); sal_uInt16 nAktIdx = pPos.nContent.GetIndex(); sal_uInt16 nCnt = static_cast< sal_uInt16 >(Count()); SwFltStackEntry* pEntry; while( nCnt ) { nCnt --; pEntry = (*this)[ nCnt ]; if( !pEntry->bOld && !pEntry->bLocked && (pEntry->nMkNode == aAktNode) && (pEntry->nMkCntnt == nAktIdx ) && (pEntry->nPtNode == aAktNode) && (pEntry->nPtCntnt == nAktIdx )) { DeleteAndDestroy( nCnt ); // loesche aus dem Stack } } } // Alle gelockten Attribute freigeben (unlocken) und das Ende setzen, // alle anderen im Document setzen und wieder aus dem Stack loeschen // Returned, ob das gesuchte Attribut / die gesuchten Attribute // ueberhaupt auf dem Stack standen void SwFltControlStack::SetAttr(const SwPosition& rPos, sal_uInt16 nAttrId, sal_Bool bTstEnde, long nHand, sal_Bool consumedByField ) { ASSERT(!nAttrId || (POOLATTR_BEGIN <= nAttrId && POOLATTR_END > nAttrId) || (RES_FLTRATTR_BEGIN <= nAttrId && RES_FLTRATTR_END > nAttrId), "Falsche Id fuers Attribut") sal_uInt16 nCnt = static_cast< sal_uInt16 >(Count()); SwFltStackEntry* pEntry; for (sal_uInt16 i=0; i < nCnt; i++) { pEntry = (*this)[ i ]; if (pEntry->bLocked) { // setze das Ende vom Attribut bool bF = false; if (!nAttrId ){ bF = true; }else if( nAttrId == pEntry->pAttr->Which()){ if( nAttrId != RES_FLTR_BOOKMARK ){ // Handle abfragen bF = true; }else if( nHand == ((SwFltBookmark*)(pEntry->pAttr))->GetHandle() ) { bF = true; } } if (bF) { pEntry->bConsumedByField = consumedByField; pEntry->SetEndPos(rPos); //Modify here for #119405, by easyfan, 2012-05-24 pEntry->SetEndCP(GetCurrAttrCP()); //End of modification, by easyfan } continue; } // ist die Endposition die Cursor-Position, dann noch nicht // ins Dokument setzen, es muss noch Text folgen; // ausser am Dokumentende. (Attribut-Expandierung !!) // Beim Ende-Stack niemals ausser am DocEnde reinsetzen if (bTstEnde) { if (bIsEndStack || pEntry->nPtNode.GetIndex()+1 == rPos.nNode.GetIndex()) continue; } SetAttrInDoc(rPos, pEntry); DeleteAndDestroy(i); // loesche aus dem Stack i--; nCnt--; // Danach rutschen alle folgenden nach unten } } static void MakePoint(SwFltStackEntry* pEntry, SwDoc* pDoc, SwPaM& rRegion) { // der Anker ist der Point vom Pam. Dieser wird beim Einfugen // von Text usw. veraendert; darum wird er auf dem Stack // gespeichert. Das Attribut muss nur noch im Format // gesetzt werden. rRegion.DeleteMark(); rRegion.GetPoint()->nNode = pEntry->nMkNode.GetIndex() + 1; SwCntntNode* pCNd = GetCntntNode(pDoc, rRegion.GetPoint()->nNode, sal_True); rRegion.GetPoint()->nContent.Assign(pCNd, pEntry->nMkCntnt); } // MakeBookRegionOrPoint() ist wie MakeRegionOrPoint, aber die besonderen // Beschraenkungen von Bookmarks in Tabellen werden beachtet. // ( Anfang und Ende muessen in selber Zelle sein ) static void MakeBookRegionOrPoint(SwFltStackEntry* pEntry, SwDoc* pDoc, SwPaM& rRegion, sal_Bool bCheck ) { if (pEntry->MakeRegion(pDoc, rRegion, bCheck )){ // sal_Bool b1 = rNds[rRegion.GetPoint()->nNode]->FindTableNode() != 0; // const SwStartNode* p1 = rNds[rRegion.GetPoint()->nNode]->FindTableBoxStartNode(); // const SwStartNode* p2 = rNds[rRegion.GetMark()->nNode]->FindTableBoxStartNode(); if (rRegion.GetPoint()->nNode.GetNode().FindTableBoxStartNode() != rRegion.GetMark()->nNode.GetNode().FindTableBoxStartNode()) { rRegion.Exchange(); // Ungueltiger Bereich rRegion.DeleteMark(); // -> beide auf Mark } }else{ MakePoint(pEntry, pDoc, rRegion); } } #if OSL_DEBUG_LEVEL > 1 extern sal_Bool CheckNodesRange( const SwNodeIndex& rStt, const SwNodeIndex& rEnd, sal_Bool bChkSection ); #endif // IterateNumrulePiece() sucht von rTmpStart bis rEnd den ersten // fuer Numrules gueltigen Bereich heraus. // // rNds sind die Doc-Nodes // rEnd ist Bereichs-Ende, // rTmpStart ist ReinRaus-Parameter: Anfang des zu untersuchenden Bereiches rein, // Anfang des gueltigen Bereichs raus // rTmpEnd ist raus-Parameter // Return-Bool ist sal_True fuer gueltigen Bereich static sal_Bool IterateNumrulePiece( const SwNodeIndex& rEnd, SwNodeIndex& rTmpStart, SwNodeIndex& rTmpEnd ) { while( ( rTmpStart <= rEnd ) && !( rTmpStart.GetNode().IsTxtNode() ) ) // suche gueltigen Anfang rTmpStart++; rTmpEnd = rTmpStart; while( ( rTmpEnd <= rEnd ) && ( rTmpEnd.GetNode().IsTxtNode() ) ) // suche gueltiges Ende + 1 rTmpEnd++; rTmpEnd--; // gueltiges Ende return rTmpStart <= rTmpEnd; // gueltig ? } //Modify for #119405 by chengjh, 2012-08-16 //***This function will check whether there is existing individual attribute positon for 0x0D***/ //The check will happen only once for a paragraph during loading bool SwFltControlStack::HasSdOD() { sal_uInt16 nCnt = static_cast< sal_uInt16 >(Count()); SwFltStackEntry* pEntry = 0; bool bRet = false; for (sal_uInt16 i=0; i < nCnt; i++) { pEntry = (*this)[ i ]; if ( pEntry && pEntry->mnStartCP == pEntry->mnEndCP ) { if ( CheckSdOD(pEntry->mnStartCP,pEntry->mnEndCP) ) { bRet = true; break; } } } return bRet; } //End void SwFltControlStack::SetAttrInDoc(const SwPosition& rTmpPos, SwFltStackEntry* pEntry) { SwPaM aRegion( rTmpPos ); switch(pEntry->pAttr->Which()) { case RES_FLTR_ANCHOR: { SwFrmFmt* pFmt = ((SwFltAnchor*)pEntry->pAttr)->GetFrmFmt(); if (pFmt != NULL) { MakePoint(pEntry, pDoc, aRegion); SwFmtAnchor aAnchor(pFmt->GetAnchor()); aAnchor.SetAnchor(aRegion.GetPoint()); pFmt->SetFmtAttr(aAnchor); // Damit die Frames bei Einfuegen in existierendes Doc // erzeugt werden (erst nach Setzen des Ankers!): if(pDoc->GetCurrentViewShell() //swmod 071108//swmod 071225 && (FLY_AT_PARA == pFmt->GetAnchor().GetAnchorId())) { pFmt->MakeFrms(); } } } break; case RES_FLTR_STYLESHEET: break; case RES_TXTATR_FIELD: case RES_TXTATR_ANNOTATION: case RES_TXTATR_INPUTFIELD: break; case RES_TXTATR_TOXMARK: break; case RES_FLTR_NUMRULE: // Numrule 'reinsetzen { const String& rNumNm = ( (SfxStringItem*) pEntry->pAttr )->GetValue(); SwNumRule* pNumRule = pDoc->FindNumRulePtr( rNumNm ); if ( pNumRule ) { if ( pEntry->MakeRegion( pDoc, aRegion, sal_True ) ) { SwNodeIndex aTmpStart( aRegion.Start()->nNode ); SwNodeIndex aTmpEnd( aTmpStart ); SwNodeIndex& rRegEndNd = aRegion.End()->nNode; while (IterateNumrulePiece( rRegEndNd, aTmpStart, aTmpEnd )) { SwPaM aTmpPam( aTmpStart, aTmpEnd ); pDoc->SetNumRule( aTmpPam, *pNumRule, false ); aTmpStart = aTmpEnd; // Start fuer naechstes Teilstueck aTmpStart++; } } else pDoc->DelNumRule( rNumNm ); } } break; case RES_FLTR_NUMRULE_NUM: break; case RES_FLTR_BOOKMARK: { SwFltBookmark* pB = (SwFltBookmark*)pEntry->pAttr; const String& rName = ((SwFltBookmark*)pEntry->pAttr)->GetName(); if (IsFlagSet(BOOK_TO_VAR_REF)) { SwFieldType* pFT = pDoc->GetFldType(RES_SETEXPFLD, rName, false); if (!pFT) { SwSetExpFieldType aS(pDoc, rName, nsSwGetSetExpType::GSE_STRING); pFT = pDoc->InsertFldType(aS); } SwSetExpField aFld((SwSetExpFieldType*)pFT, pB->GetValSys()); aFld.SetSubType( nsSwExtendedSubType::SUB_INVISIBLE ); MakePoint(pEntry, pDoc, aRegion); pDoc->InsertPoolItem(aRegion, SwFmtFld(aFld), 0); MoveAttrs( *(aRegion.GetPoint()) ); } if ( ( !IsFlagSet(HYPO) || IsFlagSet(BOOK_AND_REF) ) && !pEntry->bConsumedByField ) { MakeBookRegionOrPoint(pEntry, pDoc, aRegion, sal_True); // #120879# - create a cross reference heading bookmark if appropriate. const IDocumentMarkAccess::MarkType eBookmarkType = ( pB->IsTOCBookmark() && IDocumentMarkAccess::IsLegalPaMForCrossRefHeadingBookmark( aRegion ) ) ? IDocumentMarkAccess::CROSSREF_HEADING_BOOKMARK : IDocumentMarkAccess::BOOKMARK; pDoc->getIDocumentMarkAccess()->makeMark( aRegion, rName, eBookmarkType ); } } break; case RES_FLTR_TOX: { MakePoint(pEntry, pDoc, aRegion); SwPosition* pPoint = aRegion.GetPoint(); SwFltTOX* pTOXAttr = (SwFltTOX*)pEntry->pAttr; // test if on this node there had been a pagebreak BEFORE the // tox attribut was put on the stack SfxItemSet aBkSet( pDoc->GetAttrPool(), RES_PAGEDESC, RES_BREAK ); SwCntntNode* pNd = 0; if( !pTOXAttr->HadBreakItem() || !pTOXAttr->HadPageDescItem() ) { pNd = pPoint->nNode.GetNode().GetCntntNode(); if( pNd ) { const SfxItemSet* pSet = pNd->GetpSwAttrSet(); const SfxPoolItem* pItem; if( pSet ) { if( !pTOXAttr->HadBreakItem() && SFX_ITEM_SET == pSet->GetItemState( RES_BREAK, sal_False, &pItem ) ) { aBkSet.Put( *pItem ); pNd->ResetAttr( RES_BREAK ); } if( !pTOXAttr->HadPageDescItem() && SFX_ITEM_SET == pSet->GetItemState( RES_PAGEDESC, sal_False, &pItem ) ) { aBkSet.Put( *pItem ); pNd->ResetAttr( RES_PAGEDESC ); } } } } delete pTOXAttr->GetBase(); // set (aboved saved and removed) the break item at the node following the TOX if( aBkSet.Count() ) pNd->SetAttr( aBkSet ); } break; case RES_FLTR_SECTION: MakePoint(pEntry, pDoc, aRegion); // bislang immer Point==Mark pDoc->InsertSwSection(aRegion, *(static_cast(pEntry->pAttr))->GetSectionData(), 0, 0, false); delete (((SwFltSection*)pEntry->pAttr)->GetSectionData()); break; case RES_FLTR_REDLINE: { if (pEntry->MakeRegion(pDoc, aRegion, sal_True)) { pDoc->SetRedlineMode((RedlineMode_t)( nsRedlineMode_t::REDLINE_ON | nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE )); SwFltRedline& rFltRedline = *((SwFltRedline*)pEntry->pAttr); if( USHRT_MAX != rFltRedline.nAutorNoPrev ) { SwRedlineData aData(rFltRedline.eTypePrev, rFltRedline.nAutorNoPrev, rFltRedline.aStampPrev, aEmptyStr, 0 ); pDoc->AppendRedline(new SwRedline(aData, aRegion), true); } SwRedlineData aData(rFltRedline.eType, rFltRedline.nAutorNo, rFltRedline.aStamp, aEmptyStr, 0 ); pDoc->AppendRedline( new SwRedline(aData, aRegion), true ); pDoc->SetRedlineMode((RedlineMode_t)( nsRedlineMode_t::REDLINE_NONE | nsRedlineMode_t::REDLINE_SHOW_INSERT | nsRedlineMode_t::REDLINE_SHOW_DELETE )); } } break; default: { //Modify here for #119405, by chengjh, 2012-08-16 //Revised for more complex situations should be considered if ( !bSdODChecked ) { bHasSdOD = HasSdOD(); bSdODChecked = true; } sal_Int32 nStart = pEntry->GetStartCP(); sal_Int32 nEnd = pEntry->GetEndCP(); if (nStart != -1 && nEnd != -1 && nEnd >= nStart ) { pEntry->SetIsParaEnd( IsParaEndInCPs(nStart,nEnd,bHasSdOD) ); } //End if (pEntry->MakeRegion(pDoc, aRegion, sal_False)) { //Modify here for #119405, by easyfan, 2012-05-24 //Refined 2012-08-16 if (pEntry->IsParaEnd()) { pDoc->InsertPoolItem(aRegion, *pEntry->pAttr, 0,true); }else { pDoc->InsertPoolItem(aRegion, *pEntry->pAttr, 0); } //End } } break; } } SfxPoolItem* SwFltControlStack::GetFmtStackAttr(sal_uInt16 nWhich, sal_uInt16 * pPos) { SwFltStackEntry* pEntry; sal_uInt16 nSize = static_cast< sal_uInt16 >(Count()); while (nSize) { // ist es das gesuchte Attribut ? (gueltig sind nur gelockte, // also akt. gesetzte Attribute!!) if ((pEntry = (*this)[ --nSize ])->bLocked && pEntry->pAttr->Which() == nWhich) { if (pPos) *pPos = nSize; return (SfxPoolItem*)pEntry->pAttr; // Ok, dann Ende } } return 0; } const SfxPoolItem* SwFltControlStack::GetOpenStackAttr(const SwPosition& rPos, sal_uInt16 nWhich) { SwFltStackEntry* pEntry; sal_uInt16 nSize = static_cast< sal_uInt16 >(Count()); SwNodeIndex aAktNode( rPos.nNode, -1 ); sal_uInt16 nAktIdx = rPos.nContent.GetIndex(); while (nSize) { pEntry = (*this)[ --nSize ]; if( pEntry->bLocked && (pEntry->pAttr->Which() == nWhich) && (pEntry->nMkNode == aAktNode) && (pEntry->nMkCntnt == nAktIdx )) { return (SfxPoolItem*)pEntry->pAttr; } } return 0; } const SfxPoolItem* SwFltControlStack::GetFmtAttr(const SwPosition& rPos, sal_uInt16 nWhich) { SfxPoolItem* pHt = GetFmtStackAttr(nWhich); if (pHt) return (const SfxPoolItem*)pHt; // im Stack ist das Attribut nicht vorhanden, also befrage das Dokument // SwCntntNode * pNd = rPaM.GetCntntNode(); SwCntntNode * pNd = rPos.nNode.GetNode().GetCntntNode(); if (!pNd) // kein ContentNode, dann das dflt. Attribut return &pDoc->GetAttrPool().GetDefaultItem(nWhich); return &pNd->GetAttr(nWhich); } void SwFltControlStack::Delete(const SwPaM &rPam) { const SwPosition *pStt = rPam.Start(), *pEnd = rPam.End(); if( !rPam.HasMark() || *pStt >= *pEnd ) return; SwNodeIndex aStartNode(pStt->nNode, -1); sal_uInt16 nStartIdx = pStt->nContent.GetIndex(); SwNodeIndex aEndNode(pEnd->nNode, -1); sal_uInt16 nEndIdx = pEnd->nContent.GetIndex(); //We don't support deleting content that is over one node, or removing a node. ASSERT(aEndNode == aStartNode, "nodes must be the same, or this method extended"); if (aEndNode != aStartNode) return; for (sal_uInt16 nSize = static_cast< sal_uInt16 >(Count()); nSize > 0;) { SwFltStackEntry* pEntry = (*this)[--nSize]; bool bEntryStartAfterSelStart = (pEntry->nMkNode == aStartNode && pEntry->nMkCntnt >= nStartIdx); bool bEntryStartBeforeSelEnd = (pEntry->nMkNode == aEndNode && pEntry->nMkCntnt <= nEndIdx); bool bEntryEndAfterSelStart = false; bool bEntryEndBeforeSelEnd = false; if (!pEntry->bLocked) { bEntryEndAfterSelStart = (pEntry->nPtNode == aStartNode && pEntry->nPtCntnt >= nStartIdx); bEntryEndBeforeSelEnd = (pEntry->nPtNode == aEndNode && pEntry->nPtCntnt <= nEndIdx); } bool bTotallyContained = false; if ( bEntryStartAfterSelStart && bEntryStartBeforeSelEnd && bEntryEndAfterSelStart && bEntryEndBeforeSelEnd ) { bTotallyContained = true; } if (bTotallyContained) { //after start, before end, delete DeleteAndDestroy(nSize); continue; } xub_StrLen nCntntDiff = nEndIdx - nStartIdx; //to be adjusted if (bEntryStartAfterSelStart) { if (bEntryStartBeforeSelEnd) { //move start to new start pEntry->nMkNode = aStartNode; pEntry->nMkCntnt = nStartIdx; } else pEntry->nMkCntnt = pEntry->nMkCntnt - nCntntDiff; } if (bEntryEndAfterSelStart) { if (bEntryEndBeforeSelEnd) { pEntry->nPtNode = aStartNode; pEntry->nPtCntnt = nStartIdx; } else pEntry->nPtCntnt = pEntry->nPtCntnt - nCntntDiff; } //That's what locked is, end equal to start, and nPtCntnt is invalid if (pEntry->bLocked) pEntry->nPtNode = pEntry->nMkNode; } } //------ hier stehen die Methoden von SwFltAnchor ----------- SwFltAnchor::SwFltAnchor(SwFrmFmt* pFmt) : SfxPoolItem(RES_FLTR_ANCHOR), pFrmFmt(pFmt) { pClient = new SwFltAnchorClient(this); pFrmFmt->Add(pClient); } SwFltAnchor::SwFltAnchor(const SwFltAnchor& rCpy) : SfxPoolItem(RES_FLTR_ANCHOR), pFrmFmt(rCpy.pFrmFmt) { pClient = new SwFltAnchorClient(this); pFrmFmt->Add(pClient); } SwFltAnchor::~SwFltAnchor() { delete pClient; } void SwFltAnchor::SetFrmFmt(SwFrmFmt * _pFrmFmt) { pFrmFmt = _pFrmFmt; } const SwFrmFmt * SwFltAnchor::GetFrmFmt() const { return pFrmFmt; } SwFrmFmt * SwFltAnchor::GetFrmFmt() { return pFrmFmt; } int SwFltAnchor::operator==(const SfxPoolItem& rItem) const { return pFrmFmt == ((SwFltAnchor&)rItem).pFrmFmt; } SfxPoolItem* __EXPORT SwFltAnchor::Clone(SfxItemPool*) const { return new SwFltAnchor(*this); } // SwFltAnchorClient SwFltAnchorClient::SwFltAnchorClient(SwFltAnchor * pFltAnchor) : m_pFltAnchor(pFltAnchor) { } void SwFltAnchorClient::Modify(const SfxPoolItem *, const SfxPoolItem * pNew) { if (pNew->Which() == RES_FMT_CHG) { const SwFmtChg * pFmtChg = dynamic_cast (pNew); if (pFmtChg != NULL) { SwFrmFmt * pFrmFmt = dynamic_cast (pFmtChg->pChangedFmt); if (pFrmFmt != NULL) m_pFltAnchor->SetFrmFmt(pFrmFmt); } } } //------ hier stehen die Methoden von SwFltRedline ----------- int SwFltRedline::operator==(const SfxPoolItem& rItem) const { return this == &rItem; } SfxPoolItem* SwFltRedline::Clone( SfxItemPool* ) const { return new SwFltRedline(*this); } //------ hier stehen die Methoden von SwFltBookmark ----------- SwFltBookmark::SwFltBookmark( const String& rNa, const String& rVa, long nHand, const bool bIsTOCBookmark ) : SfxPoolItem( RES_FLTR_BOOKMARK ) , mnHandle( nHand ) , maName( rNa ) , maVal( rVa ) , mbIsTOCBookmark( bIsTOCBookmark ) { // eSrc: CHARSET_DONTKNOW fuer keine UEbersetzung bei operator << // Upcase wird immer gemacht. // bei XXXStack.NewAttr(...) wird nie eine UEbersetzung vorgenommen. // ansonsten: uebergebener Src-Charset fuer aName // im Filter eingestellter Src-Charset fuer aVal ( Text ) if ( IsTOCBookmark() ) { maName = IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix(); maName += rNa; } } SwFltBookmark::SwFltBookmark(const SwFltBookmark& rCpy) : SfxPoolItem( RES_FLTR_BOOKMARK ) , mnHandle( rCpy.mnHandle ) , maName( rCpy.maName ) , maVal( rCpy.maVal ) , mbIsTOCBookmark( rCpy.mbIsTOCBookmark ) { } int SwFltBookmark::operator==(const SfxPoolItem& rItem) const { return ( maName == ((SwFltBookmark&)rItem).maName) && (mnHandle == ((SwFltBookmark&)rItem).mnHandle); } SfxPoolItem* SwFltBookmark::Clone(SfxItemPool*) const { return new SwFltBookmark(*this); } //------ hier stehen die Methoden von SwFltTOX ----------- SwFltTOX::SwFltTOX(SwTOXBase* pBase, sal_uInt16 _nCols) : SfxPoolItem(RES_FLTR_TOX), pTOXBase(pBase), nCols( _nCols ), bHadBreakItem( sal_False ), bHadPageDescItem( sal_False ) { } SwFltTOX::SwFltTOX(const SwFltTOX& rCpy) : SfxPoolItem(RES_FLTR_TOX), pTOXBase(rCpy.pTOXBase), nCols( rCpy.nCols ), bHadBreakItem( rCpy.bHadBreakItem ), bHadPageDescItem( rCpy.bHadPageDescItem ) { } int SwFltTOX::operator==(const SfxPoolItem& rItem) const { return pTOXBase == ((SwFltTOX&)rItem).pTOXBase; } SfxPoolItem* SwFltTOX::Clone(SfxItemPool*) const { return new SwFltTOX(*this); } //------ hier stehen die Methoden von SwFltSwSection ----------- SwFltSection::SwFltSection(SwSectionData *const pSect) : SfxPoolItem(RES_FLTR_SECTION) , m_pSection(pSect) { } SwFltSection::SwFltSection(const SwFltSection& rCpy) : SfxPoolItem(RES_FLTR_SECTION) , m_pSection(rCpy.m_pSection) { } int SwFltSection::operator==(const SfxPoolItem& rItem) const { return m_pSection == ((SwFltSection&)rItem).m_pSection; } SfxPoolItem* __EXPORT SwFltSection::Clone(SfxItemPool*) const { return new SwFltSection(*this); } /////////////////////////////////////////////////////////////////////// // // hier beginnt der von mdt erzeugte code. dieser ist eine shell auf // der writer-seite nach moeglichkeit bald fuer alle filter. die ganze // schwierigkeit, texte & formatattribute einzufuegen, die positionen // zu verwalten, styles & kopf/fuszzeilen etc. // //////////////////////////////////////////////////////////// SwFltShell SwFltShell::SwFltShell(SwDoc* pDoc, SwPaM& rPaM, const String& rBaseURL, sal_Bool bNew, sal_uLong nFieldFl) : pCurrentPageDesc(0), pSavedPos(0), eSubMode(None), nAktStyle(0), aStack(pDoc, nFieldFl), aEndStack(pDoc, nFieldFl), pPaM(new SwPaM(*(rPaM.GetPoint()))), sBaseURL(rBaseURL), nPageDescOffset(GetDoc().GetPageDescCnt()), eSrcCharSet(RTL_TEXTENCODING_MS_1252), bNewDoc(bNew), bStdPD(sal_False), bProtect(sal_False) { memset( pColls, 0, sizeof( pColls ) ); pOutDoc = new SwFltOutDoc( *pDoc, pPaM, aStack, aEndStack ); pOut = pOutDoc; if( !bNewDoc ){ // in ein Dokument einfuegen ? // Da immer ganze Zeile eingelesen werden, muessen // evtl. Zeilen eingefuegt / aufgebrochen werden const SwPosition* pPos = pPaM->GetPoint(); const SwTxtNode* pSttNd = pPos->nNode.GetNode().GetTxtNode(); sal_uInt16 nCntPos = pPos->nContent.GetIndex(); if( nCntPos && pSttNd->GetTxt().Len() ) // EinfuegePos nicht in leerer Zeile pDoc->SplitNode( *pPos, false ); // neue Zeile erzeugen if( pSttNd->GetTxt().Len() ){ // EinfuegePos nicht am Ende der Zeile pDoc->SplitNode( *pPos, false ); // neue Zeile pPaM->Move( fnMoveBackward ); // gehe in leere Zeile } // verhinder das Einlesen von Tabellen in Fussnoten / Tabellen sal_uLong nNd = pPos->nNode.GetIndex(); sal_Bool bReadNoTbl = 0 != pSttNd->FindTableNode() || ( nNd < pDoc->GetNodes().GetEndOfInserts().GetIndex() && pDoc->GetNodes().GetEndOfInserts().StartOfSectionIndex() < nNd ); if( bReadNoTbl ) pOutDoc->SetReadNoTable(); } pCurrentPageDesc = &((SwPageDesc&)const_cast(pDoc) ->GetPageDesc( 0 )); // Standard } SwFltShell::~SwFltShell() { sal_uInt16 i; if (eSubMode == Style) EndStyle(); if( pOutDoc->IsInTable() ) // falls nicht ordentlich abgeschlossen EndTable(); if( pOutDoc->IsInFly() ) EndFly(); GetDoc().SetUpdateExpFldStat(true); GetDoc().SetInitDBFields(sal_True); aStack.SetAttr(*pPaM->GetPoint(), 0, sal_False); aStack.SetAttr(*pPaM->GetPoint(), 0, sal_False); aEndStack.SetAttr(*pPaM->GetPoint(), 0, sal_False); aEndStack.SetAttr(*pPaM->GetPoint(), 0, sal_False); if( bProtect ){ // Das ganze Doc soll geschuetzt sein SwDoc& rDoc = GetDoc(); // 1. SectionFmt und Section anlegen SwSectionFmt* pSFmt = rDoc.MakeSectionFmt( 0 ); SwSectionData aSectionData( CONTENT_SECTION, String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM("PMW-Protect") )); aSectionData.SetProtectFlag( true ); // 2. Start- und EndIdx suchen const SwNode* pEndNd = &rDoc.GetNodes().GetEndOfContent(); SwNodeIndex aEndIdx( *pEndNd, -1L ); const SwStartNode* pSttNd = pEndNd->StartOfSectionNode(); SwNodeIndex aSttIdx( *pSttNd, 1L ); // +1 -> hinter StartNode // Section einfuegen // Section einfuegen rDoc.GetNodes().InsertTextSection( aSttIdx, *pSFmt, aSectionData, 0, &aEndIdx, false ); if( !IsFlagSet(SwFltControlStack::DONT_HARD_PROTECT) ){ SwDocShell* pDocSh = rDoc.GetDocShell(); if( pDocSh ) pDocSh->SetReadOnlyUI( sal_True ); } } // Pagedescriptoren am Dokument updaten (nur so werden auch die // linken Seiten usw. eingestellt). GetDoc().ChgPageDesc( 0, const_cast(GetDoc()). GetPageDesc( 0 )); // PageDesc "Standard" for (i=nPageDescOffset;i(GetDoc()). GetPageDesc(i); GetDoc().ChgPageDesc(i, rPD); } delete pPaM; for (i=0; iGetPoint()); } void SwFltShell::NextPage() { NextParagraph(); GetDoc().InsertPoolItem(*pPaM, SvxFmtBreakItem(SVX_BREAK_PAGE_BEFORE, RES_BREAK), 0); } SwFltShell& SwFltShell::AddGraphic( const String& rPicName ) { // embedded: GraphicFilter* pFilter = GraphicFilter::GetGraphicFilter(); Graphic aGraphic; // one of: GFF_NOT GFF_BMP GFF_GIF GFF_JPG GFF_PCD GFF_PCX GFF_PNG // GFF_TIF GFF_XBM GFF_DXF GFF_MET GFF_PCT GFF_SGF GFF_SVM GFF_WMF // GFF_SGV GFF_XXX INetURLObject aDir( URIHelper::SmartRel2Abs( INetURLObject(GetBaseURL()), rPicName, URIHelper::GetMaybeFileHdl()) ); switch (pFilter->ImportGraphic(aGraphic, aDir)) { case GRFILTER_OK: *this << aGraphic; break; case GRFILTER_OPENERROR: case GRFILTER_IOERROR: case GRFILTER_FORMATERROR: case GRFILTER_VERSIONERROR: case GRFILTER_FILTERERROR: case GRFILTER_ABORT: case GRFILTER_TOOBIG: default: AddError( "picture import error" ); break; } return *this; } SwFltShell& SwFltShell::SetStyle( sal_uInt16 nStyle ) { SwFltFormatCollection* p = pColls[ nStyle ]; if (p) { if( !pOutDoc->IsInTable() && nStyle != nAktStyle ) { if( pColls[nAktStyle]->IsInFly() && pOutDoc->IsInFly() ) pOutDoc->EndFly(); if( p->IsInFly() ) p->BeginStyleFly( pOutDoc ); } GetDoc().SetTxtFmtColl(*pPaM, p->GetColl()); nAktStyle = nStyle; } else { ASSERT( sal_False, "Ungueltiger SwFltStyleCode" ); } return *this; } SwFltShell& SwFltShell::operator << (SwFltBookmark& aBook) { ConvertUStr( aBook.maName ); aBook.maVal = QuoteStr(aBook.maVal); aEndStack.NewAttr(*pPaM->GetPoint(), aBook); return *this; } void SwFltShell::SetBookEnd(long nHandle) { aEndStack.SetAttr( *pPaM->GetPoint(), RES_FLTR_BOOKMARK, sal_True, nHandle ); } SwFltShell& SwFltShell::EndItem( sal_uInt16 nAttrId ) { switch( nAttrId ) { case RES_FLTR_BOOKMARK: ASSERT( sal_False, "Falscher Aufruf fuer Bookmark-Ende" ); break; case RES_FLTR_TOX: aEndStack.SetAttr(*pPaM->GetPoint(), nAttrId); break; default: aStack.SetAttr(*pPaM->GetPoint(), nAttrId); break; } return *this; } SwFltShell& SwFltShell::operator << (const SwField& rField) { GetDoc().InsertPoolItem(*pPaM, SwFmtFld(rField), 0); return *this; } /*virtual*/ SwFltOutBase& SwFltOutDoc::operator << (const SfxPoolItem& rItem) { rStack.NewAttr(*pPaM->GetPoint(), rItem); return *this; } /*virtual*/ SwFltOutBase& SwFltFormatCollection::operator << (const SfxPoolItem& rItem) { pColl->SetFmtAttr(rItem); return *this; } const SfxPoolItem& SwFltOutDoc::GetAttr(sal_uInt16 nWhich) { return *rStack.GetFmtAttr(*pPaM->GetPoint(), nWhich); } const SfxPoolItem& SwFltFormatCollection::GetAttr(sal_uInt16 nWhich) { return GetColl()->GetFmtAttr(nWhich); // mit Parents } // GetNodeOrStyAttr holt Attribute fuer Toggle- und Modify-Attribute: // Bei Formatdefinitionen aus dem altuellen Style mit Parents // sonst aus dem Node mit Parents // Im Stack wird nicht nachgesehen const SfxPoolItem& SwFltOutDoc::GetNodeOrStyAttr(sal_uInt16 nWhich) { SwCntntNode * pNd = pPaM->GetPoint()->nNode.GetNode().GetCntntNode(); if (pNd) // ContentNode: Attribut mit Parent return pNd->GetAttr(nWhich); else // kein ContentNode, dann das dflt. Attribut return GetDoc().GetAttrPool().GetDefaultItem(nWhich); } const SfxPoolItem& SwFltFormatCollection::GetNodeOrStyAttr(sal_uInt16 nWhich) { return GetColl()->GetFmtAttr(nWhich); // mit Parents } const SfxPoolItem& SwFltShell::GetNodeOrStyAttr(sal_uInt16 nWhich) { return pOut->GetNodeOrStyAttr( nWhich ); } const SfxPoolItem& SwFltShell::GetAttr(sal_uInt16 nWhich) { return pOut->GetAttr( nWhich ); } const SfxPoolItem& SwFltShell::GetFlyFrmAttr(sal_uInt16 nWhich) { return pOut->GetFlyFrmAttr( nWhich ); } SwFieldType* SwFltShell::GetSysFldType(sal_uInt16 eWhich) { return GetDoc().GetSysFldType(eWhich); } sal_Bool SwFltShell::GetWeightBold() { return ((SvxWeightItem&)GetNodeOrStyAttr(RES_CHRATR_WEIGHT)).GetWeight() != WEIGHT_NORMAL; } sal_Bool SwFltShell::GetPostureItalic() { return ((SvxPostureItem&)GetNodeOrStyAttr(RES_CHRATR_POSTURE)).GetPosture() != ITALIC_NONE; } sal_Bool SwFltShell::GetCrossedOut() { return ((SvxCrossedOutItem&)GetNodeOrStyAttr(RES_CHRATR_CROSSEDOUT)) .GetStrikeout() != STRIKEOUT_NONE; } sal_Bool SwFltShell::GetContour() { return ((SvxContourItem&)GetNodeOrStyAttr(RES_CHRATR_CONTOUR)).GetValue(); } sal_Bool SwFltShell::GetCaseKapitaelchen() { return ((SvxCaseMapItem&)GetNodeOrStyAttr(RES_CHRATR_CASEMAP)) .GetCaseMap() == SVX_CASEMAP_KAPITAELCHEN; } sal_Bool SwFltShell::GetCaseVersalien() { return ((SvxCaseMapItem&)GetNodeOrStyAttr(RES_CHRATR_CASEMAP)) .GetCaseMap() == SVX_CASEMAP_VERSALIEN; } //------------------------------------------------------------------------- // Tabellen //------------------------------------------------------------------------- SwFltOutBase::~SwFltOutBase() { } SwFltOutBase::SwFltOutBase(SwDoc& rDocu) : rDoc(rDocu), eFlyAnchor(FLY_AT_PARA), bFlyAbsPos(false) { } const SfxPoolItem& SwFltOutBase::GetCellAttr(sal_uInt16 nWhich) { ASSERT(sal_False, "GetCellAttr ausserhalb von normalem Text"); return GetDoc().GetAttrPool().GetDefaultItem(nWhich); } sal_Bool SwFltOutBase::BeginTable() { ASSERT(sal_False, "BeginTable ausserhalb von normalem Text"); return sal_False; } void SwFltOutBase::NextTableCell() { ASSERT(sal_False, "NextTableCell ausserhalb von normalem Text"); } void SwFltOutBase::NextTableRow() { ASSERT(sal_False, "NextTableRow ausserhalb von normalem Text"); } void SwFltOutBase::SetTableWidth(SwTwips /*nW*/) { ASSERT(sal_False, "SetTableWidth ausserhalb von normalem Text"); } void SwFltOutBase::SetTableOrient(sal_Int16 /*eOri*/) { ASSERT(sal_False, "SetTableOrient ausserhalb von normalem Text"); } void SwFltOutBase::SetCellWidth(SwTwips /*nWidth*/, sal_uInt16 /*nCell*/) { ASSERT(sal_False, "SetCellWidth ausserhalb von normalem Text"); } void SwFltOutBase::SetCellHeight(SwTwips /*nH*/) { ASSERT(sal_False, "SetCellHeight ausserhalb von normalem Text"); } void SwFltOutBase::SetCellBorder(const SvxBoxItem& /*rFmtBox*/, sal_uInt16 /*nCell*/) { ASSERT(sal_False, "SetCellBorder ausserhalb von normalem Text"); } void SwFltOutBase::SetCellSpace(sal_uInt16 /*nSp*/) { ASSERT(sal_False, "SetCellSpace ausserhalb von normalem Text"); } void SwFltOutBase::DeleteCell(sal_uInt16 /*nCell*/) { ASSERT(sal_False, "DeleteCell ausserhalb von normalem Text"); } void SwFltOutBase::EndTable() { ASSERT(sal_False, "EndTable ausserhalb von normalem Text"); } /*virtual*/ sal_Bool SwFltOutDoc::IsInTable() { return pTable != 0; }; sal_Bool SwFltOutDoc::BeginTable() { if(bReadNoTbl) return sal_False; if (pTable){ ASSERT(sal_False, "BeginTable in Table"); return sal_False; } // Alle Attribute schliessen, da sonst Attribute // entstehen koennen, die in Flys reinragen rStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); rEndStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); // create table: ASSERT(pTabSavedPos == NULL, "SwFltOutDoc"); pTabSavedPos = new SwPosition(*pPaM->GetPoint()); pTable = GetDoc().InsertTable( SwInsertTableOptions( tabopts::HEADLINE_NO_BORDER, 1 ), *pTabSavedPos, 1, 1, text::HoriOrientation::LEFT, 0, 0, sal_False, sal_False ); // TODO MULTIHEADER nTableWidth = 0; ((SwTable*)pTable)->LockModify(); // Nichts automatisch anpassen! // set pam in 1. table cell usTableX = usTableY = 0; SeekCell(usTableY, usTableX, sal_True); return sal_True; } SwTableBox* SwFltOutDoc::GetBox(sal_uInt16 ny, sal_uInt16 nx /*= USHRT_MAX */) { if(!pTable){ ASSERT(pTable, "GetBox ohne Tabelle"); return 0; } if( nx == USHRT_MAX ) // aktuelle Zelle nx = usTableX; // get structs to table cells const SwTableLines* pTableLines = &pTable->GetTabLines(); if(!pTableLines){ ASSERT(sal_False, "SwFltOutDoc:GetBox:pTableLines"); return 0; } if( ny >= pTableLines->Count() ){ // Notbremse ASSERT( sal_False, "SwFltOutDoc:GetBox:ny >= Count()"); ny = pTableLines->Count() - 1; } SwTableLine* pTableLine = (*pTableLines)[ny]; if(!pTableLine){ ASSERT(sal_False, "SwFltOutDoc:GetBox:pTableLine"); return 0; } SwTableBoxes* pTableBoxes = &pTableLine->GetTabBoxes(); if(!pTableBoxes){ ASSERT(sal_False, "SwFltOutDoc:GetBox:pTableBoxes"); return 0; } if( nx >= pTableBoxes->Count() ){ // Notbremse ASSERT(sal_False, "SwFltOutDoc:GetBox:nx >= Count()"); nx = pTableBoxes->Count() - 1; } SwTableBox* pTableBox = (*pTableBoxes)[nx]; ASSERT(pTableBox != 0, "SwFltOutDoc:GetBox:pTableBox"); return pTableBox; } void SwFltOutDoc::NextTableCell() { if(!pTable){ ASSERT(pTable, "NextTableCell ohne Tabelle"); return; } const SwTableLines* pTableLines = &pTable->GetTabLines(); SwTableLine* pTableLine = (*pTableLines)[usTableY]; SwTableBoxes* pTableBoxes = &pTableLine->GetTabBoxes(); SwTableBox* pTableBox = (*pTableBoxes)[usTableX]; ASSERT(pTableBox != 0, "SwFltOutDoc:NextTableCell:pTableBox"); if(!pTableBox) return; //#pragma message(__FILE__ "(?) : Sw's const problem") // insert cells: if (++usTableX >= pTableBoxes->Count()) GetDoc().GetNodes().InsBoxen( GetDoc().IsIdxInTbl(pPaM->GetPoint()->nNode), pTableLine, (SwTableBoxFmt*)pTableBox->GetFrmFmt(), GetDoc().GetTxtCollFromPool(RES_POOLCOLL_STANDARD, false ), 0, pTableBoxes->Count()); SeekCell(usTableY, usTableX, sal_True); pTableBox = (*pTableBoxes)[usTableX]; ASSERT(pTableBox != 0, "SwFltOutDoc:pTableBox"); if(pTableBox) (*pTableBoxes)[usTableX]->ClaimFrmFmt(); } void SwFltOutDoc::NextTableRow() { SwTableBox* pTableBox = GetBox(usTableY, 0); if (pTableBox) { // duplicate row: SwSelBoxes aSelBoxes; aSelBoxes.Insert( pTableBox ); GetDoc().InsertRow(aSelBoxes); usTableX = 0; SeekCell(++usTableY, usTableX, sal_True); GetDoc().SetTxtFmtColl(*pPaM, GetDoc().GetTxtCollFromPool(RES_POOLCOLL_STANDARD, false )); } } void SwFltOutDoc::SetTableWidth(SwTwips nSwWidth) { if(!pTable){ ASSERT(pTable, "SetTableWidth ohne Tabelle"); return; } ASSERT( nSwWidth > MINLAY, "Tabellenbreite <= MINLAY" ); if( nSwWidth != nTableWidth ){ if( nTableWidth ) // Nicht beim ersten Setzen SplitTable(); pTable->GetFrmFmt()->SetFmtAttr( SwFmtFrmSize(ATT_VAR_SIZE, nSwWidth)); nTableWidth = nSwWidth; } } void SwFltOutDoc::SetTableOrient(sal_Int16 eOri) { if(!pTable){ ASSERT(pTable, "SetTableOrient ohne Tabelle"); return; } pTable->GetFrmFmt()->SetFmtAttr( SwFmtHoriOrient( 0, eOri )); } void SwFltOutDoc::SetCellWidth(SwTwips nWidth, sal_uInt16 nCell /* = USHRT_MAX */ ) { if(!pTable){ ASSERT(pTable, "SetCellWidth ohne Tabelle"); return; } ASSERT( nWidth > MINLAY, "Tabellenzellenbreite <= MINLAY" ); if (nWidth < MINLAY) nWidth = MINLAY; SwTableBox* pTableBox = GetBox(usTableY, nCell); if(pTableBox && pTableBox->GetFrmFmt() ){ SwFmtFrmSize aFmtFrmSize(ATT_FIX_SIZE); aFmtFrmSize.SetWidth(nWidth); pTableBox->GetFrmFmt()->SetFmtAttr(aFmtFrmSize); } } void SwFltOutDoc::SetCellHeight(SwTwips nHeight) { if(!pTable){ ASSERT(pTable, "SetCellHeight ohne Tabelle"); return; } const SwTableLines* pTableLines = &pTable->GetTabLines(); SwTableLine* pTableLine = (*pTableLines)[usTableY]; SwFmtFrmSize aFmtFrmSize(ATT_MIN_SIZE, 0, 0); if (nHeight < MINLAY) nHeight = MINLAY; aFmtFrmSize.SetHeight(nHeight); pTableLine->GetFrmFmt()->SetFmtAttr(aFmtFrmSize); } const SfxPoolItem& SwFltOutDoc::GetCellAttr(sal_uInt16 nWhich) { if (!pTable){ ASSERT(pTable, "GetCellAttr ohne Table"); return GetDoc().GetAttrPool().GetDefaultItem(nWhich); } SwTableBox* pTableBox = GetBox(usTableY, usTableX); if(!pTableBox) return GetDoc().GetAttrPool().GetDefaultItem(nWhich); return pTableBox->GetFrmFmt()->GetFmtAttr( nWhich ); } void SwFltOutDoc::SetCellBorder(const SvxBoxItem& rFmtBox, sal_uInt16 nCell /* = USHRT_MAX */ ) { SwTableBox* pTableBox = GetBox(usTableY, nCell); if(pTableBox) pTableBox->GetFrmFmt()->SetFmtAttr(rFmtBox); } // nicht aktiviert !!! void SwFltOutDoc::SetCellSpace(sal_uInt16 nDist) { if(!pTable){ ASSERT(pTable, "SetCellSpace ohne Tabelle"); return; } SwTableBox* pTableBox = GetBox(usTableY, usTableX); if(!pTableBox) return; SvxBoxItem aFmtBox( *((SvxBoxItem*) &pTableBox->GetFrmFmt()->GetFmtAttr( RES_BOX ))); // versteh ich nich, sven: if (!nDist) nDist = 18; // ca. 0.03 cm if (nDist > 42) // max. 0.7 mm nDist = 42; else if (nDist < MIN_BORDER_DIST) nDist = MIN_BORDER_DIST; aFmtBox.SetDistance(nDist); pTableBox->GetFrmFmt()->SetFmtAttr(aFmtBox); } void SwFltOutDoc::DeleteCell(sal_uInt16 nCell /* = USHRT_MAX */) { SwTableBox* pTableBox = GetBox(usTableY, nCell); if(pTableBox){ SwSelBoxes aSelBoxes; aSelBoxes.Insert( pTableBox ); GetDoc().DeleteRowCol(aSelBoxes); usTableX--; } } void SwFltOutDoc::SplitTable() { if(!pTable) { ASSERT(pTable, "SplitTable ohne Tabelle"); return; } SwTableBox* pAktBox = GetBox(usTableY, usTableX); SwTableBox* pSplitBox = GetBox(usTableY - 1, 0); GetDoc().GetNodes().SplitTable(SwNodeIndex(*pSplitBox->GetSttNd()), false); pTable = &pAktBox->GetSttNd()->FindTableNode()->GetTable(); usTableY = 0; } void SwFltOutDoc::EndTable() { if (!pTable){ ASSERT(pTable, "EndTable ohne Table"); return; } // Alle Attribute schliessen, da sonst Attribute // entstehen koennen, die in Flys reinragen rStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); rEndStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); if (GetDoc().GetCurrentViewShell()){ //swmod 071108//swmod 071225 SwTableNode* pTableNode = GetDoc().IsIdxInTbl( pPaM->GetPoint()->nNode); pTableNode->DelFrms(); pTableNode->MakeFrms(&pPaM->GetPoint()->nNode); } *pPaM->GetPoint() = *pTabSavedPos; // restore Cursor delete pTabSavedPos; pTabSavedPos = 0; ((SwTable*)pTable)->UnlockModify(); // Test, nuetzt nichts gegen Assert pTable = 0; nTableWidth = 0; } sal_Bool SwFltOutDoc::SeekCell(short nRow, short nCol, sal_Bool bPam) { // get structs to table cells const SwTableLines* pTableLines = &pTable->GetTabLines(); SwTableLine* pTableLine = (*pTableLines)[usTableY]; SwTableBoxes* pTableBoxes = &pTableLine->GetTabBoxes(); SwTableBox* pTableBox = (*pTableBoxes)[usTableX]; if ((sal_uInt16)nRow >= pTableLines->Count()) { ASSERT((sal_uInt16)nRow >= pTableLines->Count(), "SwFltOutDoc"); return sal_False; } pTableLine = (*pTableLines)[nRow]; pTableBoxes = &pTableLine->GetTabBoxes(); if (nCol >= pTableBoxes->Count()) return sal_False; pTableBox = (*pTableBoxes)[nCol]; if( !pTableBox->GetSttNd() ) { ASSERT(pTableBox->GetSttNd(), "SwFltOutDoc"); return sal_False; } if(bPam) { pPaM->GetPoint()->nNode = pTableBox->GetSttIdx() + 1; pPaM->GetPoint()->nContent.Assign(pPaM->GetCntntNode(), 0); //#pragma message(__FILE__ "(?) : Sw's const problem") #if OSL_DEBUG_LEVEL > 1 const SwTxtFmtColl* p = GetDoc().GetDfltTxtFmtColl(); p = GetDoc().GetTxtCollFromPool(RES_POOLCOLL_STANDARD, false ); #endif GetDoc().SetTxtFmtColl(*pPaM, GetDoc().GetTxtCollFromPool(RES_POOLCOLL_STANDARD, false )); } return sal_True; } //----------------------------------------------------------------------------- // Flys in SwFltOutBase //----------------------------------------------------------------------------- SfxItemSet* SwFltOutBase::NewFlyDefaults() { // Unbedingt noetige Standardwerte setzen ( falls diese Werte nicht // spaeter explizit gesetzt werden ) SfxItemSet* p = new SfxItemSet( GetDoc().GetAttrPool(), RES_FRMATR_BEGIN, RES_FRMATR_END-1 ); SwFmtFrmSize aSz( ATT_VAR_SIZE, MINFLY, MINFLY ); // Default: Breite 100% ( = PMW:Auto ) aSz.SetWidthPercent( 100 ); // Hoehe: Auto p->Put( aSz ); p->Put( SwFmtHoriOrient( 0, text::HoriOrientation::NONE, text::RelOrientation::FRAME )); return p; } sal_Bool SwFltOutBase::BeginFly( RndStdIds eAnchor /*= FLY_AT_PARA*/, sal_Bool bAbsolutePos /*= sal_False*/, const SfxItemSet* #ifdef DBG_UTIL pMoreAttrs /*= 0*/ #endif ) { ASSERT(!pMoreAttrs, "SwFltOutBase:BeginFly mit pMoreAttrs" ); eFlyAnchor = eAnchor; bFlyAbsPos = bAbsolutePos; // Bloedsinn eigentlich return sal_True; } /*virtual*/ void SwFltOutBase::SetFlyAnchor( RndStdIds eAnchor ) { if( !IsInFly() ){ ASSERT( sal_False, "SetFlyAnchor() ohne Fly" ); return; } if ( eAnchor == FLY_AS_CHAR ){ ASSERT( sal_False, "SetFlyAnchor( FLY_AS_CHAR ) nicht implementiert" ); return; } SwFmtAnchor& rAnchor = (SwFmtAnchor&)GetFlyFrmAttr( RES_ANCHOR ); rAnchor.SetType( eAnchor ); } void SwFltOutBase::EndFly() { if( bFlyAbsPos ){ // hier muessen die absoluten Positionen am Fly noch in // die Writer-Koordinaten umgerechnet werden. } } //----------------------------------------------------------------------------- // Flys in SwFltDoc //----------------------------------------------------------------------------- /* virtual */ sal_Bool SwFltOutDoc::IsInFly() { return pFly != 0; }; SwFrmFmt* SwFltOutDoc::MakeFly( RndStdIds eAnchor, SfxItemSet* pSet ) { pFly = (SwFlyFrmFmt*)GetDoc().MakeFlySection( eAnchor, pPaM->GetPoint(), pSet ); return pFly; } sal_Bool SwFltOutDoc::BeginFly( RndStdIds eAnchor /*= FLY_AT_PARA*/, sal_Bool bAbsolutePos /*= sal_False*/, const SfxItemSet* pMoreAttrs /*= 0*/ ) { SwFltOutBase::BeginFly( eAnchor, bAbsolutePos, 0 ); SfxItemSet* pSet = NewFlyDefaults(); // Alle Attribute schliessen, da sonst Attribute entstehen koennen, // die in Flys reinragen rStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); rEndStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); // create Fly: ASSERT(pFlySavedPos == NULL, "BeginFly in Fly"); // rekursiv geht noch nicht pFlySavedPos = new SwPosition(*pPaM->GetPoint()); SwFmtAnchor aAnchor( eAnchor, 1 ); // Wenn Fly-Attribute im Style waren, dann jetzt als Defaults reinsetzen if (pMoreAttrs) pSet->Put(*pMoreAttrs); // dieses NICHT bei Seitengebundenem Fly mit Seiten-NUMMER ! aAnchor.SetAnchor(pPaM->GetPoint()); // braucht erstaunlicherweise // den Stack nicht // aStack.NewAttr( *pPaM->GetPoint(), SwFltAnchor( pFly ) ); pSet->Put( aAnchor ); SwFrmFmt* pF = MakeFly( eAnchor, pSet ); delete pSet; // set pam in Fly const SwFmtCntnt& rCntnt = pF->GetCntnt(); ASSERT( rCntnt.GetCntntIdx(), "Kein Inhalt vorbereitet." ); pPaM->GetPoint()->nNode = rCntnt.GetCntntIdx()->GetIndex() + 1; SwCntntNode *pNode = pPaM->GetCntntNode(); pPaM->GetPoint()->nContent.Assign( pNode, 0 ); return sal_True; } /*virtual*/ void SwFltOutDoc::SetFlyFrmAttr(const SfxPoolItem& rAttr) { if (pFly){ pFly->SetFmtAttr( rAttr ); }else{ ASSERT(pFly, "SetFlyAttr ohne Doc-Fly"); return; } } /*virtual*/ const SfxPoolItem& SwFltOutDoc::GetFlyFrmAttr(sal_uInt16 nWhich) { if (pFly){ return pFly->GetFmtAttr( nWhich ); }else{ ASSERT(pFly, "GetFlyAttr ohne Fly"); return GetDoc().GetAttrPool().GetDefaultItem(nWhich); } } void SwFltOutDoc::EndFly() { if( pTable ){ ASSERT( sal_False, "SwFltOutDoc::EndFly() in Table" ); return; } // Alle Attribute schliessen, da sonst Attribute // entstehen koennen, die aus Flys rausragen rStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); rEndStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); *pPaM->GetPoint() = *pFlySavedPos; // restore Cursor delete pFlySavedPos; pFlySavedPos = 0; SwFltOutBase::EndFly(); pFly = 0; } //----------------------------------------------------------------------------- // Flys in SwFltFormatCollection //----------------------------------------------------------------------------- /*virtual*/ sal_Bool SwFltFormatCollection::IsInFly() { return bHasFly; }; /*virtual*/ void SwFltFormatCollection::SetFlyFrmAttr(const SfxPoolItem& rAttr) { if (!pFlyAttrs) pFlyAttrs = new SfxItemSet( GetDoc().GetAttrPool(), RES_FRMATR_BEGIN, RES_FRMATR_END-1 ); pFlyAttrs->Put( rAttr ); } /*virtual*/ const SfxPoolItem& SwFltFormatCollection::GetFlyFrmAttr(sal_uInt16 nWhich) { // ASSERT( pFlyAttrs, "GetFlyFrmAttr ohne Coll-FlyAttrs" ); if( pFlyAttrs ) return pFlyAttrs->Get( nWhich, sal_False ); else return GetDoc().GetAttrPool().GetDefaultItem(nWhich); } sal_Bool SwFltFormatCollection::BeginFly( RndStdIds eAnchor /*= FLY_AT_PARA*/, sal_Bool bAbsolutePos /*= sal_False*/, const SfxItemSet* pMoreAttrs /*= 0*/ ) { SwFltOutBase::BeginFly( eAnchor, bAbsolutePos, pMoreAttrs ); bHasFly = sal_True; return sal_True; } void SwFltFormatCollection::EndFly() // Wird nie aufgerufen { } sal_Bool SwFltFormatCollection::BeginStyleFly( SwFltOutDoc* pOutDoc ) { ASSERT( pOutDoc, "BeginStyleFly ohne pOutDoc" ); ASSERT( pOutDoc && !pOutDoc->IsInFly(), "BeginStyleFly in Fly" ); if( pOutDoc && !pOutDoc->IsInFly() ) return pOutDoc->BeginFly( eFlyAnchor, bFlyAbsPos, pFlyAttrs ); else return sal_False; } //----------------------------------------------------------------------------- // Flys in SwFltShell //----------------------------------------------------------------------------- sal_Bool SwFltShell::BeginFly( RndStdIds eAnchor /*= FLY_AT_PARA*/, sal_Bool bAbsolutePos /*= sal_False*/ ) { if (pOut->IsInFly()){ ASSERT(sal_False, "BeginFly in Fly"); return sal_False; } if (pOutDoc->IsInTable()){ ASSERT(sal_False, "BeginFly in Table"); return sal_False; } pOut->BeginFly( eAnchor, bAbsolutePos, pColls[nAktStyle]->GetpFlyAttrs() ); eSubMode = Fly; return sal_True; } void SwFltShell::SetFlyXPos( short nXPos, sal_Int16 eHRel /*= text::RelOrientation::FRAME*/, sal_Int16 eHAlign /*= text::HoriOrientation::NONE*/ ) { SetFlyFrmAttr( SwFmtHoriOrient( nXPos, eHAlign, eHRel ) ); } void SwFltShell::SetFlyYPos( short nYPos, sal_Int16 eVRel /*= text::RelOrientation::FRAME*/, sal_Int16 eVAlign /*= text::VertOrientation::NONE*/ ) { SetFlyFrmAttr( SwFmtVertOrient( nYPos, eVAlign, eVRel ) ); } void SwFltShell::EndFly() { if (!pOut->IsInFly()){ ASSERT(sal_False, "EndFly ohne Fly"); return; } if (pOutDoc->IsInTable()){ // Table verschraenkt mit Fly macht keinen Sinn ASSERT(sal_False, "EndFly in Table ( verschraenkt )"); EndTable(); // -> Table beenden } pOut->EndFly(); eSubMode = None; } //----------------------------------------------------------------------------- // Fussnoten //----------------------------------------------------------------------------- void SwFltShell::BeginFootnote() { if( pOut->IsInFly() ){ // Passiert z.B. bei Fussnote in Fly ASSERT(sal_False, "Fussnote in Fly nicht erlaubt"); return; } if( pOutDoc->IsInTable() ){ ASSERT(sal_False, "Fussnote in Table z.Zt. nicht erlaubt"); return; } // Alle Attribute schliessen, da sonst Attribute entstehen koennen, // die in Fussnoten reinragen aStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); // aEndStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); // EndStack erstmal nicht zwangs-Schliessen, damit Bookmarks ueber // Fussnoten im PMW uebernommen werden SwFmtFtn aFtn; GetDoc().InsertPoolItem(*pPaM, aFtn, 0); ASSERT(pSavedPos == NULL, "SwFltShell"); pSavedPos = new SwPosition(*pPaM->GetPoint()); pPaM->Move(fnMoveBackward, fnGoCntnt); SwTxtNode* pTxt = pPaM->GetNode()->GetTxtNode(); SwTxtAttr *const pFN = pTxt->GetTxtAttrForCharAt( pPaM->GetPoint()->nContent.GetIndex(), RES_TXTATR_FTN); if( !pFN ){ // Passiert z.B. bei Fussnote in Fly ASSERT(pFN, "Probleme beim Anlegen des Fussnoten-Textes"); return; } const SwNodeIndex* pStartIndex = ((SwTxtFtn*)pFN)->GetStartNode(); ASSERT(pStartIndex, "Probleme beim Anlegen des Fussnoten-Textes"); pPaM->GetPoint()->nNode = pStartIndex->GetIndex() + 1; pPaM->GetPoint()->nContent.Assign(pPaM->GetCntntNode(), 0); eSubMode = Footnote; } void SwFltShell::EndFootnote() { if(!pSavedPos) return; // Alle Attribute schliessen, da sonst Attribute // entstehen koennen, die aus Fussnoten rausragen aStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); // aEndStack.SetAttr( *pPaM->GetPoint(), 0, sal_False ); // EndStack erstmal nicht zwangs-Schliessen, damit Bookmarks ueber // Fussnoten im PMW uebernommen werden *pPaM->GetPoint() = *pSavedPos; // restore Cursor delete pSavedPos; pSavedPos = 0; } void SwFltShell::BeginHeader(SwPageDesc* /*pPD*/) { SwFrmFmt* pFmt = &pCurrentPageDesc->GetMaster( ); //(bUseLeft) ? &pCurrentPageDesc->GetLeft() : SwFrmFmt* pHdFtFmt; pFmt->SetFmtAttr(SwFmtHeader(sal_True)); pHdFtFmt = (SwFrmFmt*)pFmt->GetHeader().GetHeaderFmt(); const SwNodeIndex* pStartIndex = pHdFtFmt->GetCntnt().GetCntntIdx(); if (!pStartIndex) return; ASSERT(pSavedPos == NULL, "SwFltShell"); pSavedPos = new SwPosition(*pPaM->GetPoint()); pPaM->GetPoint()->nNode = pStartIndex->GetIndex() + 1; pPaM->GetPoint()->nContent.Assign(pPaM->GetCntntNode(), 0); eSubMode = Header; } void SwFltShell::BeginFooter(SwPageDesc* /*pPD*/) { SwFrmFmt* pFmt = &pCurrentPageDesc->GetMaster( ); //(bUseLeft) ? &pCurrentPageDesc->GetLeft() : SwFrmFmt* pHdFtFmt; pFmt->SetFmtAttr(SwFmtFooter(sal_True)); pHdFtFmt = (SwFrmFmt*)pFmt->GetFooter().GetFooterFmt(); const SwNodeIndex* pStartIndex = pHdFtFmt->GetCntnt().GetCntntIdx(); if (!pStartIndex) return; ASSERT(pSavedPos == NULL, "SwFltShell"); pSavedPos = new SwPosition(*pPaM->GetPoint()); pPaM->GetPoint()->nNode = pStartIndex->GetIndex() + 1; pPaM->GetPoint()->nContent.Assign(pPaM->GetCntntNode(), 0); eSubMode = Footer; } void SwFltShell::EndHeaderFooter() { *pPaM->GetPoint() = *pSavedPos; // restore Cursor delete pSavedPos; pSavedPos = 0; } SwPageDesc* SwFltShell::MakePageDesc(SwPageDesc* pFirstPageDesc) { if(bStdPD) // keine Neuen PageDescs return pCurrentPageDesc; sal_Bool bFollow = (pFirstPageDesc != 0); SwPageDesc* pNewPD; sal_uInt16 nPos; if (bFollow && pFirstPageDesc->GetFollow() != pFirstPageDesc) return pFirstPageDesc; // Fehler: hat schon Follow // Erkennung doppelter Namen fehlt noch (Wahrscheinlichkeit // fuer dopp. Namen ist gering) nPos = GetDoc().MakePageDesc( ViewShell::GetShellRes()->GetPageDescName( GetDoc().GetPageDescCnt(), sal_False, bFollow ), pFirstPageDesc, sal_False ); pNewPD = &((SwPageDesc&)const_cast(GetDoc()). GetPageDesc(nPos)); if (bFollow) { // Dieser ist der folgende von pPageDesc pFirstPageDesc->SetFollow(pNewPD); pNewPD->SetFollow(pNewPD); } else { GetDoc().InsertPoolItem( *pPaM, SwFmtPageDesc( pNewPD ), 0 ); } pNewPD->WriteUseOn( // alle Seiten (UseOnPage)(nsUseOnPage::PD_ALL | nsUseOnPage::PD_HEADERSHARE | nsUseOnPage::PD_FOOTERSHARE)); return pNewPD; } ///////////////////////////////////////////////// SwFltFormatCollection SwFltFormatCollection::SwFltFormatCollection( SwDoc& _rDoc, RES_POOL_COLLFMT_TYPE nType ) : SwFltOutBase(_rDoc), pColl(_rDoc.GetTxtCollFromPool( static_cast< sal_uInt16 >(nType), false )), pFlyAttrs( 0 ), bHasFly( sal_False ) { Reset(); // Default-Attrs loeschen und Auto-Flag } SwFltFormatCollection::SwFltFormatCollection( SwDoc& _rDoc, const String& rName ) : SwFltOutBase(_rDoc), pFlyAttrs( 0 ), bHasFly( sal_False ) { pColl = _rDoc.MakeTxtFmtColl(rName, (SwTxtFmtColl*)_rDoc.GetDfltTxtFmtColl()); Reset(); // Default-Attrs loeschen und Auto-Flag } void SwFltShell::NextStyle(sal_uInt16 nWhich, sal_uInt16 nNext) { ASSERT(pColls[nWhich], "Next style for noexistent style" ); ASSERT(pColls[nNext], "Next style to noexistent style" ); if( pColls[nWhich] && pColls[nNext] ) pColls[nWhich]->GetColl()->SetNextTxtFmtColl( *pColls[nNext]->GetColl() ); } // UpdatePageDescs muss am Ende des Einlesevorganges aufgerufen werden, damit // der Writer den Inhalt der Pagedescs wirklich akzeptiert void UpdatePageDescs(SwDoc &rDoc, sal_uInt16 nInPageDescOffset) { // Pagedescriptoren am Dokument updaten (nur so werden auch die // linken Seiten usw. eingestellt). // PageDesc "Standard" rDoc.ChgPageDesc(0, const_cast(rDoc).GetPageDesc(0)); // PageDescs "Konvert..." for (sal_uInt16 i = nInPageDescOffset; i < rDoc.GetPageDescCnt(); ++i) rDoc.ChgPageDesc(i, const_cast(rDoc).GetPageDesc(i)); } /* vi:set tabstop=4 shiftwidth=4 expandtab: */