1efeef26fSAndrew Rist /**************************************************************
2cdf0e10cSrcweir *
3efeef26fSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4efeef26fSAndrew Rist * or more contributor license agreements. See the NOTICE file
5efeef26fSAndrew Rist * distributed with this work for additional information
6efeef26fSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7efeef26fSAndrew Rist * to you under the Apache License, Version 2.0 (the
8efeef26fSAndrew Rist * "License"); you may not use this file except in compliance
9efeef26fSAndrew Rist * with the License. You may obtain a copy of the License at
10efeef26fSAndrew Rist *
11efeef26fSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12efeef26fSAndrew Rist *
13efeef26fSAndrew Rist * Unless required by applicable law or agreed to in writing,
14efeef26fSAndrew Rist * software distributed under the License is distributed on an
15efeef26fSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16efeef26fSAndrew Rist * KIND, either express or implied. See the License for the
17efeef26fSAndrew Rist * specific language governing permissions and limitations
18efeef26fSAndrew Rist * under the License.
19efeef26fSAndrew Rist *
20efeef26fSAndrew Rist *************************************************************/
21efeef26fSAndrew Rist
22efeef26fSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sw.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir #include "hintids.hxx"
28cdf0e10cSrcweir #include "cntfrm.hxx" // _GetFly
29cdf0e10cSrcweir #include "doc.hxx"
30cdf0e10cSrcweir #include <IDocumentUndoRedo.hxx>
31cdf0e10cSrcweir #include "pam.hxx" // fuer SwTxtFlyCnt
32cdf0e10cSrcweir #include "flyfrm.hxx" // fuer SwTxtFlyCnt
33cdf0e10cSrcweir #include "ndtxt.hxx" // SwFlyFrmFmt
34cdf0e10cSrcweir #include "frmfmt.hxx" // SwFlyFrmFmt
35cdf0e10cSrcweir #include <fmtflcnt.hxx>
36cdf0e10cSrcweir #include <txtflcnt.hxx>
37cdf0e10cSrcweir #include <fmtanchr.hxx>
38cdf0e10cSrcweir #include "swfont.hxx"
39cdf0e10cSrcweir #include "txtfrm.hxx"
40cdf0e10cSrcweir #include "flyfrms.hxx"
41cdf0e10cSrcweir #include <objectformatter.hxx>
42cdf0e10cSrcweir #include <switerator.hxx>
43cdf0e10cSrcweir
SwFmtFlyCnt(SwFrmFmt * pFrmFmt)44cdf0e10cSrcweir SwFmtFlyCnt::SwFmtFlyCnt( SwFrmFmt *pFrmFmt )
45cdf0e10cSrcweir : SfxPoolItem( RES_TXTATR_FLYCNT ),
46cdf0e10cSrcweir pTxtAttr( 0 ),
47cdf0e10cSrcweir pFmt( pFrmFmt )
48cdf0e10cSrcweir {
49cdf0e10cSrcweir }
50cdf0e10cSrcweir
operator ==(const SfxPoolItem & rAttr) const51cdf0e10cSrcweir int __EXPORT SwFmtFlyCnt::operator==( const SfxPoolItem& rAttr ) const
52cdf0e10cSrcweir {
53cdf0e10cSrcweir ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" );
54cdf0e10cSrcweir return( pTxtAttr && ((SwFmtFlyCnt&)rAttr).pTxtAttr &&
55cdf0e10cSrcweir *pTxtAttr->GetStart() == *((SwFmtFlyCnt&)rAttr).pTxtAttr->GetStart() &&
56cdf0e10cSrcweir pFmt == ((SwFmtFlyCnt&)rAttr).GetFrmFmt() );
57cdf0e10cSrcweir }
58cdf0e10cSrcweir
Clone(SfxItemPool *) const59cdf0e10cSrcweir SfxPoolItem* __EXPORT SwFmtFlyCnt::Clone( SfxItemPool* ) const
60cdf0e10cSrcweir {
61cdf0e10cSrcweir return new SwFmtFlyCnt( pFmt );
62cdf0e10cSrcweir }
63cdf0e10cSrcweir
SwTxtFlyCnt(SwFmtFlyCnt & rAttr,xub_StrLen nStartPos)64cdf0e10cSrcweir SwTxtFlyCnt::SwTxtFlyCnt( SwFmtFlyCnt& rAttr, xub_StrLen nStartPos )
65cdf0e10cSrcweir : SwTxtAttr( rAttr, nStartPos )
66cdf0e10cSrcweir {
67cdf0e10cSrcweir rAttr.pTxtAttr = this;
68cdf0e10cSrcweir SetHasDummyChar(true);
69cdf0e10cSrcweir }
70cdf0e10cSrcweir
71cdf0e10cSrcweir
72cdf0e10cSrcweir
73cdf0e10cSrcweir /*************************************************************************
74cdf0e10cSrcweir * SwTxtFlyCnt::MakeTxtHint()
75cdf0e10cSrcweir *
76cdf0e10cSrcweir * An dieser Stelle soll einmal der Gesamtzusammenhang bei der Erzeugung
77cdf0e10cSrcweir * eines neuen SwTxtFlyCnt erlaeutert werden.
78cdf0e10cSrcweir * Das MakeTxtHint() wird z.B. im SwTxtNode::Copy() gerufen.
79cdf0e10cSrcweir * Fuer die komplette Verdopplung sind folgende Schritte notwendig:
80cdf0e10cSrcweir * 1) Duplizieren des pFmt incl. Inhalt, Attributen etc.
81cdf0e10cSrcweir * 2) Setzen des Ankers
82cdf0e10cSrcweir * 3) Benachrichtigung
83cdf0e10cSrcweir * Da fuer die Bewaeltigung der Aufgaben nicht immer alle Informationen
84cdf0e10cSrcweir * bereitstehen und darueber hinaus bestimmte Methoden erst zu einem
85cdf0e10cSrcweir * spaeteren Zeitpunkt gerufen werden duerfen (weil nocht nicht alle
86cdf0e10cSrcweir * Nodeinformationen vorliegen), verteilt sich der Ablauf.
87cdf0e10cSrcweir * ad 1) MakeTxtHint() wird durch den Aufruf von SwDoc::CopyLayout()
88cdf0e10cSrcweir * der das neue FlyFrmFmt erzeugt und mit dem duplizierten Inhalt des
89cdf0e10cSrcweir * FlyFrm verbunden.
90cdf0e10cSrcweir * ad 2) SetAnchor() wird von SwTxtNode::Insert() gerufen und sorgt fuer das
91cdf0e10cSrcweir * setzen des Ankers (die SwPosition des Dummy-Zeichens wird dem FlyFrmFmt
92cdf0e10cSrcweir * per SetAttr bekannt gegeben). Dies kann nicht im MakeTxtHint erledigt
93cdf0e10cSrcweir * werden, da der Zielnode unbestimmt ist.
94cdf0e10cSrcweir * ad 3) _GetFlyFrm() wird im Formatierungsprozess vom LineIter gerufen
95cdf0e10cSrcweir * und sucht den FlyFrm zum Dummyzeichen des aktuellen CntntFrm. Wird keiner
96cdf0e10cSrcweir * gefunden, so wird ein neuer FlyFrm angelegt.
97cdf0e10cSrcweir * Kritisch an diesem Vorgehen ist, dass das pCntnt->AppendFly() eine
98cdf0e10cSrcweir * sofortige Neuformatierung von pCntnt anstoesst. Die Rekursion kommt
99cdf0e10cSrcweir * allerdings durch den Lockmechanismus in SwTxtFrm::Format() nicht
100cdf0e10cSrcweir * zu stande.
101cdf0e10cSrcweir * Attraktiv ist der Umstand, dass niemand ueber die vom Node abhaengigen
102cdf0e10cSrcweir * CntntFrms iterieren braucht, um die FlyInCntFrm anzulegen. Dies geschieht
103cdf0e10cSrcweir * bei der Arbeit.
104cdf0e10cSrcweir *************************************************************************/
105cdf0e10cSrcweir
CopyFlyFmt(SwDoc * pDoc)106cdf0e10cSrcweir void SwTxtFlyCnt::CopyFlyFmt( SwDoc* pDoc )
107cdf0e10cSrcweir {
108cdf0e10cSrcweir SwFrmFmt* pFmt = GetFlyCnt().GetFrmFmt();
109cdf0e10cSrcweir ASSERT( pFmt, "von welchem Format soll ich eine Kopie erzeugen?" )
110cdf0e10cSrcweir // Das FlyFrmFmt muss dupliziert werden.
111cdf0e10cSrcweir // In CopyLayoutFmt (siehe doclay.cxx) wird das FlyFrmFmt erzeugt
112cdf0e10cSrcweir // und der Inhalt dupliziert.
113cdf0e10cSrcweir
114cdf0e10cSrcweir // disable undo while copying attribute
115cdf0e10cSrcweir ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
116cdf0e10cSrcweir SwFmtAnchor aAnchor( pFmt->GetAnchor() );
117cdf0e10cSrcweir if ((FLY_AT_PAGE != aAnchor.GetAnchorId()) &&
118cdf0e10cSrcweir (pDoc != pFmt->GetDoc())) // different documents?
119cdf0e10cSrcweir {
120cdf0e10cSrcweir // JP 03.06.96: dann sorge dafuer, das der koperierte Anker auf
121cdf0e10cSrcweir // gueltigen Content zeigt! Die Umsetzung auf die
122cdf0e10cSrcweir // richtige Position erfolgt spaeter.
123cdf0e10cSrcweir SwNodeIndex aIdx( pDoc->GetNodes().GetEndOfExtras(), +2 );
124cdf0e10cSrcweir SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
125cdf0e10cSrcweir if( !pCNd )
126cdf0e10cSrcweir pCNd = pDoc->GetNodes().GoNext( &aIdx );
127cdf0e10cSrcweir
128cdf0e10cSrcweir SwPosition* pPos = (SwPosition*)aAnchor.GetCntntAnchor();
129cdf0e10cSrcweir pPos->nNode = aIdx;
130cdf0e10cSrcweir if (FLY_AS_CHAR == aAnchor.GetAnchorId())
131cdf0e10cSrcweir {
132cdf0e10cSrcweir pPos->nContent.Assign( pCNd, 0 );
133cdf0e10cSrcweir }
134cdf0e10cSrcweir else
135cdf0e10cSrcweir {
136cdf0e10cSrcweir pPos->nContent.Assign( 0, 0 );
137*870262e3SDon Lewis ASSERT( sal_False, "CopyFlyFmt: What anchor?" );
138cdf0e10cSrcweir }
139cdf0e10cSrcweir }
140cdf0e10cSrcweir
141cdf0e10cSrcweir SwFrmFmt* pNew = pDoc->CopyLayoutFmt( *pFmt, aAnchor, false, false );
142cdf0e10cSrcweir ((SwFmtFlyCnt&)GetFlyCnt()).SetFlyFmt( pNew );
143cdf0e10cSrcweir }
144cdf0e10cSrcweir
145cdf0e10cSrcweir /*************************************************************************
146cdf0e10cSrcweir * SwTxtFlyCnt::SetAnchor()
147cdf0e10cSrcweir *
148cdf0e10cSrcweir * SetAnchor() wird von SwTxtNode::Insert() gerufen und sorgt fuer das
149cdf0e10cSrcweir * setzen des Ankers (die SwPosition des Dummy-Zeichens wird dem FlyFrmFmt
150cdf0e10cSrcweir * per SetAttr bekannt gegeben). Dies kann nicht im MakeTxtHint erledigt
151cdf0e10cSrcweir * werden, da der Zielnode unbestimmt ist.
152cdf0e10cSrcweir * (siehe Kommentar in SwTxtFlyCnt::MakeTxtHint)
153cdf0e10cSrcweir *************************************************************************/
154cdf0e10cSrcweir
SetAnchor(const SwTxtNode * pNode)155cdf0e10cSrcweir void SwTxtFlyCnt::SetAnchor( const SwTxtNode *pNode )
156cdf0e10cSrcweir {
157cdf0e10cSrcweir // fuers Undo muss der neue Anker schon bekannt sein !
158cdf0e10cSrcweir
159cdf0e10cSrcweir // Wir ermitteln den Index im Nodesarray zum Node
160cdf0e10cSrcweir
161cdf0e10cSrcweir SwDoc* pDoc = (SwDoc*)pNode->GetDoc();
162cdf0e10cSrcweir
163cdf0e10cSrcweir SwIndex aIdx( (SwTxtNode*)pNode, *GetStart() );
164cdf0e10cSrcweir SwPosition aPos( *pNode->StartOfSectionNode(), aIdx );
165cdf0e10cSrcweir SwFrmFmt* pFmt = GetFlyCnt().GetFrmFmt();
166cdf0e10cSrcweir SwFmtAnchor aAnchor( pFmt->GetAnchor() );
167cdf0e10cSrcweir
168cdf0e10cSrcweir if( !aAnchor.GetCntntAnchor() ||
169cdf0e10cSrcweir !aAnchor.GetCntntAnchor()->nNode.GetNode().GetNodes().IsDocNodes() ||
170cdf0e10cSrcweir &aAnchor.GetCntntAnchor()->nNode.GetNode() != (SwNode*)pNode )
171cdf0e10cSrcweir aPos.nNode = *pNode;
172cdf0e10cSrcweir else
173cdf0e10cSrcweir aPos.nNode = aAnchor.GetCntntAnchor()->nNode;
174cdf0e10cSrcweir
175cdf0e10cSrcweir aAnchor.SetType( FLY_AS_CHAR ); // default!
176cdf0e10cSrcweir aAnchor.SetAnchor( &aPos );
177cdf0e10cSrcweir
178cdf0e10cSrcweir // beim Ankerwechsel werden immer alle FlyFrms vom Attribut geloescht
179cdf0e10cSrcweir // JP 25.04.95: wird innerhalb des SplitNodes die Frames verschoben
180cdf0e10cSrcweir // koennen die Frames erhalten bleiben.
181cdf0e10cSrcweir if( ( !pNode->GetpSwpHints() || !pNode->GetpSwpHints()->IsInSplitNode() )
182cdf0e10cSrcweir && RES_DRAWFRMFMT != pFmt->Which() )
183cdf0e10cSrcweir pFmt->DelFrms();
184cdf0e10cSrcweir
185cdf0e10cSrcweir // stehen wir noch im falschen Dokument ?
186cdf0e10cSrcweir if( pDoc != pFmt->GetDoc() )
187cdf0e10cSrcweir {
188cdf0e10cSrcweir // disable undo while copying attribute
189cdf0e10cSrcweir ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo());
190cdf0e10cSrcweir SwFrmFmt* pNew = pDoc->CopyLayoutFmt( *pFmt, aAnchor, false, false );
191cdf0e10cSrcweir
192cdf0e10cSrcweir ::sw::UndoGuard const undoGuardFmt(
193cdf0e10cSrcweir pFmt->GetDoc()->GetIDocumentUndoRedo());
194cdf0e10cSrcweir pFmt->GetDoc()->DelLayoutFmt( pFmt );
195cdf0e10cSrcweir ((SwFmtFlyCnt&)GetFlyCnt()).SetFlyFmt( pNew );
196cdf0e10cSrcweir }
197cdf0e10cSrcweir else if( pNode->GetpSwpHints() &&
198cdf0e10cSrcweir pNode->GetpSwpHints()->IsInSplitNode() &&
199cdf0e10cSrcweir RES_DRAWFRMFMT != pFmt->Which() )
200cdf0e10cSrcweir {
201cdf0e10cSrcweir pFmt->LockModify();
202cdf0e10cSrcweir pFmt->SetFmtAttr( aAnchor ); // nur den Anker neu setzen
203cdf0e10cSrcweir pFmt->UnlockModify();
204cdf0e10cSrcweir }
205cdf0e10cSrcweir else
206cdf0e10cSrcweir pFmt->SetFmtAttr( aAnchor ); // nur den Anker neu setzen
207cdf0e10cSrcweir
208cdf0e10cSrcweir // Am Node haengen u.a. abhaengige CntFrms.
209cdf0e10cSrcweir // Fuer jeden CntFrm wird ein SwFlyInCntFrm angelegt.
210cdf0e10cSrcweir }
211cdf0e10cSrcweir
212cdf0e10cSrcweir /*************************************************************************
213cdf0e10cSrcweir * SwTxtFlyCnt::_GetFlyFrm()
214cdf0e10cSrcweir *
215cdf0e10cSrcweir * _GetFlyFrm() wird im Formatierungsprozess vom LineIter gerufen
216cdf0e10cSrcweir * und sucht den FlyFrm zum Dummyzeichen des aktuellen CntntFrm. Wird keiner
217cdf0e10cSrcweir * gefunden, so wird ein neuer FlyFrm angelegt.
218cdf0e10cSrcweir * (siehe Kommentar ind SwTxtFlyCnt::MakeTxtHint)
219cdf0e10cSrcweir *************************************************************************/
220cdf0e10cSrcweir
_GetFlyFrm(const SwFrm * pCurrFrm)221cdf0e10cSrcweir SwFlyInCntFrm *SwTxtFlyCnt::_GetFlyFrm( const SwFrm *pCurrFrm )
222cdf0e10cSrcweir {
223cdf0e10cSrcweir SwFrmFmt* pFrmFmt = GetFlyCnt().GetFrmFmt();
224cdf0e10cSrcweir if( RES_DRAWFRMFMT == pFrmFmt->Which() )
225cdf0e10cSrcweir {
226*870262e3SDon Lewis ASSERT( sal_False, "SwTxtFlyCnt::_GetFlyFrm: construction site!" );
227cdf0e10cSrcweir return NULL;
228cdf0e10cSrcweir }
229cdf0e10cSrcweir
230cdf0e10cSrcweir SwIterator<SwFlyFrm,SwFmt> aIter( *GetFlyCnt().pFmt );
231cdf0e10cSrcweir ASSERT( pCurrFrm->IsTxtFrm(), "SwTxtFlyCnt::_GetFlyFrm for TxtFrms only." );
232cdf0e10cSrcweir SwFrm* pFrm = aIter.First();
233cdf0e10cSrcweir if ( pFrm )
234cdf0e10cSrcweir {
235cdf0e10cSrcweir SwTxtFrm *pFirst = (SwTxtFrm*)pCurrFrm;
236cdf0e10cSrcweir while ( pFirst->IsFollow() )
237cdf0e10cSrcweir pFirst = pFirst->FindMaster();
238cdf0e10cSrcweir do
239cdf0e10cSrcweir {
240cdf0e10cSrcweir SwTxtFrm *pTmp = pFirst;
241cdf0e10cSrcweir do
242cdf0e10cSrcweir { if( ( (SwFlyFrm*)pFrm )->GetAnchorFrm() == (SwFrm*) pTmp )
243cdf0e10cSrcweir {
244cdf0e10cSrcweir if ( pTmp != pCurrFrm )
245cdf0e10cSrcweir {
246cdf0e10cSrcweir pTmp->RemoveFly( (SwFlyFrm*)pFrm );
247cdf0e10cSrcweir ((SwTxtFrm*)pCurrFrm)->AppendFly( (SwFlyFrm*)pFrm );
248cdf0e10cSrcweir }
249cdf0e10cSrcweir return (SwFlyInCntFrm*)pFrm;
250cdf0e10cSrcweir }
251cdf0e10cSrcweir pTmp = pTmp->GetFollow();
252cdf0e10cSrcweir } while ( pTmp );
253cdf0e10cSrcweir
254cdf0e10cSrcweir pFrm = aIter.Next();
255cdf0e10cSrcweir
256cdf0e10cSrcweir } while( pFrm );
257cdf0e10cSrcweir }
258cdf0e10cSrcweir
259cdf0e10cSrcweir // Wir haben keinen passenden FlyFrm gefunden, deswegen wird ein
260cdf0e10cSrcweir // neuer angelegt.
261cdf0e10cSrcweir // Dabei wird eine sofortige Neuformatierung von pCurrFrm angestossen.
262cdf0e10cSrcweir // Die Rekursion wird durch den Lockmechanismus in SwTxtFrm::Format()
263cdf0e10cSrcweir // abgewuergt.
264cdf0e10cSrcweir SwFrm* pCurrFrame = const_cast< SwFrm* >(pCurrFrm);
265cdf0e10cSrcweir SwFlyInCntFrm *pFly = new SwFlyInCntFrm( (SwFlyFrmFmt*)pFrmFmt, pCurrFrame, pCurrFrame );
266cdf0e10cSrcweir pCurrFrame->AppendFly( pFly );
267cdf0e10cSrcweir pFly->RegistFlys();
268cdf0e10cSrcweir
269cdf0e10cSrcweir // 7922: Wir muessen dafuer sorgen, dass der Inhalt des FlyInCnt
270cdf0e10cSrcweir // nach seiner Konstruktion stramm durchformatiert wird.
271cdf0e10cSrcweir // --> OD 2004-11-09 #i26945# - Use new object formatter to format Writer
272cdf0e10cSrcweir // fly frame and its content.
273cdf0e10cSrcweir SwObjectFormatter::FormatObj( *pFly, const_cast<SwFrm*>(pCurrFrm),
274cdf0e10cSrcweir pCurrFrm->FindPageFrm() );
275cdf0e10cSrcweir // <--
276cdf0e10cSrcweir
277cdf0e10cSrcweir return pFly;
278cdf0e10cSrcweir }
279cdf0e10cSrcweir
280cdf0e10cSrcweir
281