/************************************************************** * * 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 "hintids.hxx" #include "cntfrm.hxx" // _GetFly #include "doc.hxx" #include #include "pam.hxx" // fuer SwTxtFlyCnt #include "flyfrm.hxx" // fuer SwTxtFlyCnt #include "ndtxt.hxx" // SwFlyFrmFmt #include "frmfmt.hxx" // SwFlyFrmFmt #include #include #include #include "swfont.hxx" #include "txtfrm.hxx" #include "flyfrms.hxx" #include #include SwFmtFlyCnt::SwFmtFlyCnt( SwFrmFmt *pFrmFmt ) : SfxPoolItem( RES_TXTATR_FLYCNT ), pTxtAttr( 0 ), pFmt( pFrmFmt ) { } int __EXPORT SwFmtFlyCnt::operator==( const SfxPoolItem& rAttr ) const { ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); return( pTxtAttr && ((SwFmtFlyCnt&)rAttr).pTxtAttr && *pTxtAttr->GetStart() == *((SwFmtFlyCnt&)rAttr).pTxtAttr->GetStart() && pFmt == ((SwFmtFlyCnt&)rAttr).GetFrmFmt() ); } SfxPoolItem* __EXPORT SwFmtFlyCnt::Clone( SfxItemPool* ) const { return new SwFmtFlyCnt( pFmt ); } SwTxtFlyCnt::SwTxtFlyCnt( SwFmtFlyCnt& rAttr, xub_StrLen nStartPos ) : SwTxtAttr( rAttr, nStartPos ) { rAttr.pTxtAttr = this; SetHasDummyChar(true); } /************************************************************************* * SwTxtFlyCnt::MakeTxtHint() * * An dieser Stelle soll einmal der Gesamtzusammenhang bei der Erzeugung * eines neuen SwTxtFlyCnt erlaeutert werden. * Das MakeTxtHint() wird z.B. im SwTxtNode::Copy() gerufen. * Fuer die komplette Verdopplung sind folgende Schritte notwendig: * 1) Duplizieren des pFmt incl. Inhalt, Attributen etc. * 2) Setzen des Ankers * 3) Benachrichtigung * Da fuer die Bewaeltigung der Aufgaben nicht immer alle Informationen * bereitstehen und darueber hinaus bestimmte Methoden erst zu einem * spaeteren Zeitpunkt gerufen werden duerfen (weil nocht nicht alle * Nodeinformationen vorliegen), verteilt sich der Ablauf. * ad 1) MakeTxtHint() wird durch den Aufruf von SwDoc::CopyLayout() * der das neue FlyFrmFmt erzeugt und mit dem duplizierten Inhalt des * FlyFrm verbunden. * ad 2) SetAnchor() wird von SwTxtNode::Insert() gerufen und sorgt fuer das * setzen des Ankers (die SwPosition des Dummy-Zeichens wird dem FlyFrmFmt * per SetAttr bekannt gegeben). Dies kann nicht im MakeTxtHint erledigt * werden, da der Zielnode unbestimmt ist. * ad 3) _GetFlyFrm() wird im Formatierungsprozess vom LineIter gerufen * und sucht den FlyFrm zum Dummyzeichen des aktuellen CntntFrm. Wird keiner * gefunden, so wird ein neuer FlyFrm angelegt. * Kritisch an diesem Vorgehen ist, dass das pCntnt->AppendFly() eine * sofortige Neuformatierung von pCntnt anstoesst. Die Rekursion kommt * allerdings durch den Lockmechanismus in SwTxtFrm::Format() nicht * zu stande. * Attraktiv ist der Umstand, dass niemand ueber die vom Node abhaengigen * CntntFrms iterieren braucht, um die FlyInCntFrm anzulegen. Dies geschieht * bei der Arbeit. *************************************************************************/ void SwTxtFlyCnt::CopyFlyFmt( SwDoc* pDoc ) { SwFrmFmt* pFmt = GetFlyCnt().GetFrmFmt(); ASSERT( pFmt, "von welchem Format soll ich eine Kopie erzeugen?" ) // Das FlyFrmFmt muss dupliziert werden. // In CopyLayoutFmt (siehe doclay.cxx) wird das FlyFrmFmt erzeugt // und der Inhalt dupliziert. // disable undo while copying attribute ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo()); SwFmtAnchor aAnchor( pFmt->GetAnchor() ); if ((FLY_AT_PAGE != aAnchor.GetAnchorId()) && (pDoc != pFmt->GetDoc())) // different documents? { // JP 03.06.96: dann sorge dafuer, das der koperierte Anker auf // gueltigen Content zeigt! Die Umsetzung auf die // richtige Position erfolgt spaeter. SwNodeIndex aIdx( pDoc->GetNodes().GetEndOfExtras(), +2 ); SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode(); if( !pCNd ) pCNd = pDoc->GetNodes().GoNext( &aIdx ); SwPosition* pPos = (SwPosition*)aAnchor.GetCntntAnchor(); pPos->nNode = aIdx; if (FLY_AS_CHAR == aAnchor.GetAnchorId()) { pPos->nContent.Assign( pCNd, 0 ); } else { pPos->nContent.Assign( 0, 0 ); ASSERT( sal_False, "CopyFlyFmt: What anchor?" ); } } SwFrmFmt* pNew = pDoc->CopyLayoutFmt( *pFmt, aAnchor, false, false ); ((SwFmtFlyCnt&)GetFlyCnt()).SetFlyFmt( pNew ); } /************************************************************************* * SwTxtFlyCnt::SetAnchor() * * SetAnchor() wird von SwTxtNode::Insert() gerufen und sorgt fuer das * setzen des Ankers (die SwPosition des Dummy-Zeichens wird dem FlyFrmFmt * per SetAttr bekannt gegeben). Dies kann nicht im MakeTxtHint erledigt * werden, da der Zielnode unbestimmt ist. * (siehe Kommentar in SwTxtFlyCnt::MakeTxtHint) *************************************************************************/ void SwTxtFlyCnt::SetAnchor( const SwTxtNode *pNode ) { // fuers Undo muss der neue Anker schon bekannt sein ! // Wir ermitteln den Index im Nodesarray zum Node SwDoc* pDoc = (SwDoc*)pNode->GetDoc(); SwIndex aIdx( (SwTxtNode*)pNode, *GetStart() ); SwPosition aPos( *pNode->StartOfSectionNode(), aIdx ); SwFrmFmt* pFmt = GetFlyCnt().GetFrmFmt(); SwFmtAnchor aAnchor( pFmt->GetAnchor() ); if( !aAnchor.GetCntntAnchor() || !aAnchor.GetCntntAnchor()->nNode.GetNode().GetNodes().IsDocNodes() || &aAnchor.GetCntntAnchor()->nNode.GetNode() != (SwNode*)pNode ) aPos.nNode = *pNode; else aPos.nNode = aAnchor.GetCntntAnchor()->nNode; aAnchor.SetType( FLY_AS_CHAR ); // default! aAnchor.SetAnchor( &aPos ); // beim Ankerwechsel werden immer alle FlyFrms vom Attribut geloescht // JP 25.04.95: wird innerhalb des SplitNodes die Frames verschoben // koennen die Frames erhalten bleiben. if( ( !pNode->GetpSwpHints() || !pNode->GetpSwpHints()->IsInSplitNode() ) && RES_DRAWFRMFMT != pFmt->Which() ) pFmt->DelFrms(); // stehen wir noch im falschen Dokument ? if( pDoc != pFmt->GetDoc() ) { // disable undo while copying attribute ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo()); SwFrmFmt* pNew = pDoc->CopyLayoutFmt( *pFmt, aAnchor, false, false ); ::sw::UndoGuard const undoGuardFmt( pFmt->GetDoc()->GetIDocumentUndoRedo()); pFmt->GetDoc()->DelLayoutFmt( pFmt ); ((SwFmtFlyCnt&)GetFlyCnt()).SetFlyFmt( pNew ); } else if( pNode->GetpSwpHints() && pNode->GetpSwpHints()->IsInSplitNode() && RES_DRAWFRMFMT != pFmt->Which() ) { pFmt->LockModify(); pFmt->SetFmtAttr( aAnchor ); // nur den Anker neu setzen pFmt->UnlockModify(); } else pFmt->SetFmtAttr( aAnchor ); // nur den Anker neu setzen // Am Node haengen u.a. abhaengige CntFrms. // Fuer jeden CntFrm wird ein SwFlyInCntFrm angelegt. } /************************************************************************* * SwTxtFlyCnt::_GetFlyFrm() * * _GetFlyFrm() wird im Formatierungsprozess vom LineIter gerufen * und sucht den FlyFrm zum Dummyzeichen des aktuellen CntntFrm. Wird keiner * gefunden, so wird ein neuer FlyFrm angelegt. * (siehe Kommentar ind SwTxtFlyCnt::MakeTxtHint) *************************************************************************/ SwFlyInCntFrm *SwTxtFlyCnt::_GetFlyFrm( const SwFrm *pCurrFrm ) { SwFrmFmt* pFrmFmt = GetFlyCnt().GetFrmFmt(); if( RES_DRAWFRMFMT == pFrmFmt->Which() ) { ASSERT( sal_False, "SwTxtFlyCnt::_GetFlyFrm: construction site!" ); return NULL; } SwIterator aIter( *GetFlyCnt().pFmt ); ASSERT( pCurrFrm->IsTxtFrm(), "SwTxtFlyCnt::_GetFlyFrm for TxtFrms only." ); SwFrm* pFrm = aIter.First(); if ( pFrm ) { SwTxtFrm *pFirst = (SwTxtFrm*)pCurrFrm; while ( pFirst->IsFollow() ) pFirst = pFirst->FindMaster(); do { SwTxtFrm *pTmp = pFirst; do { if( ( (SwFlyFrm*)pFrm )->GetAnchorFrm() == (SwFrm*) pTmp ) { if ( pTmp != pCurrFrm ) { pTmp->RemoveFly( (SwFlyFrm*)pFrm ); ((SwTxtFrm*)pCurrFrm)->AppendFly( (SwFlyFrm*)pFrm ); } return (SwFlyInCntFrm*)pFrm; } pTmp = pTmp->GetFollow(); } while ( pTmp ); pFrm = aIter.Next(); } while( pFrm ); } // Wir haben keinen passenden FlyFrm gefunden, deswegen wird ein // neuer angelegt. // Dabei wird eine sofortige Neuformatierung von pCurrFrm angestossen. // Die Rekursion wird durch den Lockmechanismus in SwTxtFrm::Format() // abgewuergt. SwFrm* pCurrFrame = const_cast< SwFrm* >(pCurrFrm); SwFlyInCntFrm *pFly = new SwFlyInCntFrm( (SwFlyFrmFmt*)pFrmFmt, pCurrFrame, pCurrFrame ); pCurrFrame->AppendFly( pFly ); pFly->RegistFlys(); // 7922: Wir muessen dafuer sorgen, dass der Inhalt des FlyInCnt // nach seiner Konstruktion stramm durchformatiert wird. // --> OD 2004-11-09 #i26945# - Use new object formatter to format Writer // fly frame and its content. SwObjectFormatter::FormatObj( *pFly, const_cast(pCurrFrm), pCurrFrm->FindPageFrm() ); // <-- return pFly; }