1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
25*b1cdbd2cSJim Jagielski #include "precompiled_sw.hxx"
26*b1cdbd2cSJim Jagielski #include <hintids.hxx>
27*b1cdbd2cSJim Jagielski #include <hints.hxx>
28*b1cdbd2cSJim Jagielski #include <svl/ctloptions.hxx>
29*b1cdbd2cSJim Jagielski #include <sfx2/printer.hxx>
30*b1cdbd2cSJim Jagielski #include <sfx2/sfxuno.hxx>
31*b1cdbd2cSJim Jagielski #include <editeng/langitem.hxx>
32*b1cdbd2cSJim Jagielski #include <editeng/lspcitem.hxx>
33*b1cdbd2cSJim Jagielski #include <editeng/lrspitem.hxx>
34*b1cdbd2cSJim Jagielski #include <editeng/ulspitem.hxx>
35*b1cdbd2cSJim Jagielski #include <editeng/brshitem.hxx>
36*b1cdbd2cSJim Jagielski #include <editeng/pgrditem.hxx>
37*b1cdbd2cSJim Jagielski #include <swmodule.hxx>
38*b1cdbd2cSJim Jagielski #include <SwSmartTagMgr.hxx>
39*b1cdbd2cSJim Jagielski #include <doc.hxx> // GetDoc()
40*b1cdbd2cSJim Jagielski #include "rootfrm.hxx"
41*b1cdbd2cSJim Jagielski #include <pagefrm.hxx> // InvalidateSpelling
42*b1cdbd2cSJim Jagielski #include <rootfrm.hxx>
43*b1cdbd2cSJim Jagielski #include <viewsh.hxx> // ViewShell
44*b1cdbd2cSJim Jagielski #include <pam.hxx> // SwPosition
45*b1cdbd2cSJim Jagielski #include <ndtxt.hxx> // SwTxtNode
46*b1cdbd2cSJim Jagielski #include <txtatr.hxx>
47*b1cdbd2cSJim Jagielski #include <paratr.hxx>
48*b1cdbd2cSJim Jagielski #include <viewopt.hxx>
49*b1cdbd2cSJim Jagielski #include <dflyobj.hxx>
50*b1cdbd2cSJim Jagielski #include <flyfrm.hxx>
51*b1cdbd2cSJim Jagielski #include <tabfrm.hxx>
52*b1cdbd2cSJim Jagielski #include <frmtool.hxx>
53*b1cdbd2cSJim Jagielski #include <pagedesc.hxx> // SwPageDesc
54*b1cdbd2cSJim Jagielski #include <tgrditem.hxx>
55*b1cdbd2cSJim Jagielski #include <dbg_lay.hxx>
56*b1cdbd2cSJim Jagielski #include <fmtfld.hxx>
57*b1cdbd2cSJim Jagielski #include <fmtftn.hxx>
58*b1cdbd2cSJim Jagielski #include <txtfld.hxx>
59*b1cdbd2cSJim Jagielski #include <txtftn.hxx>
60*b1cdbd2cSJim Jagielski #include <charatr.hxx>
61*b1cdbd2cSJim Jagielski #include <ftninfo.hxx>
62*b1cdbd2cSJim Jagielski #include <fmtline.hxx>
63*b1cdbd2cSJim Jagielski #include <txtfrm.hxx> // SwTxtFrm
64*b1cdbd2cSJim Jagielski #include <sectfrm.hxx> // SwSectFrm
65*b1cdbd2cSJim Jagielski #include <txtcfg.hxx> // DBG_LOOP
66*b1cdbd2cSJim Jagielski #include <itrform2.hxx> // Iteratoren
67*b1cdbd2cSJim Jagielski #include <widorp.hxx> // SwFrmBreak
68*b1cdbd2cSJim Jagielski #include <txtcache.hxx>
69*b1cdbd2cSJim Jagielski #include <fntcache.hxx> // GetLineSpace benutzt pLastFont
70*b1cdbd2cSJim Jagielski #include <SwGrammarMarkUp.hxx>
71*b1cdbd2cSJim Jagielski #include <lineinfo.hxx>
72*b1cdbd2cSJim Jagielski #include <SwPortionHandler.hxx>
73*b1cdbd2cSJim Jagielski #include <dcontact.hxx>
74*b1cdbd2cSJim Jagielski #include <sortedobjs.hxx>
75*b1cdbd2cSJim Jagielski #include <txtflcnt.hxx> // SwTxtFlyCnt
76*b1cdbd2cSJim Jagielski #include <fmtflcnt.hxx> // SwFmtFlyCnt
77*b1cdbd2cSJim Jagielski #include <fmtcntnt.hxx> // SwFmtCntnt
78*b1cdbd2cSJim Jagielski #include <numrule.hxx>
79*b1cdbd2cSJim Jagielski #include <swtable.hxx>
80*b1cdbd2cSJim Jagielski #include <fldupde.hxx>
81*b1cdbd2cSJim Jagielski #include <IGrammarContact.hxx>
82*b1cdbd2cSJim Jagielski #include <switerator.hxx>
83*b1cdbd2cSJim Jagielski
84*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 1
85*b1cdbd2cSJim Jagielski #include <txtpaint.hxx> // DbgRect
86*b1cdbd2cSJim Jagielski extern const sal_Char *GetPrepName( const enum PrepareHint ePrep );
87*b1cdbd2cSJim Jagielski #endif
88*b1cdbd2cSJim Jagielski
89*b1cdbd2cSJim Jagielski
90*b1cdbd2cSJim Jagielski TYPEINIT1( SwTxtFrm, SwCntntFrm );
91*b1cdbd2cSJim Jagielski
92*b1cdbd2cSJim Jagielski // Switches width and height of the text frame
SwapWidthAndHeight()93*b1cdbd2cSJim Jagielski void SwTxtFrm::SwapWidthAndHeight()
94*b1cdbd2cSJim Jagielski {
95*b1cdbd2cSJim Jagielski if ( ! bIsSwapped )
96*b1cdbd2cSJim Jagielski {
97*b1cdbd2cSJim Jagielski const long nPrtOfstX = Prt().Pos().X();
98*b1cdbd2cSJim Jagielski Prt().Pos().X() = Prt().Pos().Y();
99*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
100*b1cdbd2cSJim Jagielski if( IsVertLR() )
101*b1cdbd2cSJim Jagielski Prt().Pos().Y() = nPrtOfstX;
102*b1cdbd2cSJim Jagielski else
103*b1cdbd2cSJim Jagielski Prt().Pos().Y() = Frm().Width() - ( nPrtOfstX + Prt().Width() );
104*b1cdbd2cSJim Jagielski
105*b1cdbd2cSJim Jagielski }
106*b1cdbd2cSJim Jagielski else
107*b1cdbd2cSJim Jagielski {
108*b1cdbd2cSJim Jagielski const long nPrtOfstY = Prt().Pos().Y();
109*b1cdbd2cSJim Jagielski Prt().Pos().Y() = Prt().Pos().X();
110*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
111*b1cdbd2cSJim Jagielski if( IsVertLR() )
112*b1cdbd2cSJim Jagielski Prt().Pos().X() = nPrtOfstY;
113*b1cdbd2cSJim Jagielski else
114*b1cdbd2cSJim Jagielski Prt().Pos().X() = Frm().Height() - ( nPrtOfstY + Prt().Height() );
115*b1cdbd2cSJim Jagielski }
116*b1cdbd2cSJim Jagielski
117*b1cdbd2cSJim Jagielski const long nFrmWidth = Frm().Width();
118*b1cdbd2cSJim Jagielski Frm().Width( Frm().Height() );
119*b1cdbd2cSJim Jagielski Frm().Height( nFrmWidth );
120*b1cdbd2cSJim Jagielski const long nPrtWidth = Prt().Width();
121*b1cdbd2cSJim Jagielski Prt().Width( Prt().Height() );
122*b1cdbd2cSJim Jagielski Prt().Height( nPrtWidth );
123*b1cdbd2cSJim Jagielski
124*b1cdbd2cSJim Jagielski bIsSwapped = ! bIsSwapped;
125*b1cdbd2cSJim Jagielski }
126*b1cdbd2cSJim Jagielski
127*b1cdbd2cSJim Jagielski // Calculates the coordinates of a rectangle when switching from
128*b1cdbd2cSJim Jagielski // horizontal to vertical layout.
SwitchHorizontalToVertical(SwRect & rRect) const129*b1cdbd2cSJim Jagielski void SwTxtFrm::SwitchHorizontalToVertical( SwRect& rRect ) const
130*b1cdbd2cSJim Jagielski {
131*b1cdbd2cSJim Jagielski // calc offset inside frame
132*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
133*b1cdbd2cSJim Jagielski long nOfstX, nOfstY;
134*b1cdbd2cSJim Jagielski if ( IsVertLR() )
135*b1cdbd2cSJim Jagielski {
136*b1cdbd2cSJim Jagielski nOfstX = rRect.Left() - Frm().Left();
137*b1cdbd2cSJim Jagielski nOfstY = rRect.Top() - Frm().Top();
138*b1cdbd2cSJim Jagielski }
139*b1cdbd2cSJim Jagielski else
140*b1cdbd2cSJim Jagielski {
141*b1cdbd2cSJim Jagielski nOfstX = rRect.Left() - Frm().Left();
142*b1cdbd2cSJim Jagielski nOfstY = rRect.Top() + rRect.Height() - Frm().Top();
143*b1cdbd2cSJim Jagielski }
144*b1cdbd2cSJim Jagielski
145*b1cdbd2cSJim Jagielski const long nWidth = rRect.Width();
146*b1cdbd2cSJim Jagielski const long nHeight = rRect.Height();
147*b1cdbd2cSJim Jagielski
148*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
149*b1cdbd2cSJim Jagielski if ( IsVertLR() )
150*b1cdbd2cSJim Jagielski rRect.Left(Frm().Left() + nOfstY);
151*b1cdbd2cSJim Jagielski else
152*b1cdbd2cSJim Jagielski {
153*b1cdbd2cSJim Jagielski if ( bIsSwapped )
154*b1cdbd2cSJim Jagielski rRect.Left( Frm().Left() + Frm().Height() - nOfstY );
155*b1cdbd2cSJim Jagielski else
156*b1cdbd2cSJim Jagielski // frame is rotated
157*b1cdbd2cSJim Jagielski rRect.Left( Frm().Left() + Frm().Width() - nOfstY );
158*b1cdbd2cSJim Jagielski }
159*b1cdbd2cSJim Jagielski
160*b1cdbd2cSJim Jagielski rRect.Top( Frm().Top() + nOfstX );
161*b1cdbd2cSJim Jagielski rRect.Width( nHeight );
162*b1cdbd2cSJim Jagielski rRect.Height( nWidth );
163*b1cdbd2cSJim Jagielski }
164*b1cdbd2cSJim Jagielski
165*b1cdbd2cSJim Jagielski // Calculates the coordinates of a point when switching from
166*b1cdbd2cSJim Jagielski // horizontal to vertical layout.
SwitchHorizontalToVertical(Point & rPoint) const167*b1cdbd2cSJim Jagielski void SwTxtFrm::SwitchHorizontalToVertical( Point& rPoint ) const
168*b1cdbd2cSJim Jagielski {
169*b1cdbd2cSJim Jagielski // calc offset inside frame
170*b1cdbd2cSJim Jagielski const long nOfstX = rPoint.X() - Frm().Left();
171*b1cdbd2cSJim Jagielski const long nOfstY = rPoint.Y() - Frm().Top();
172*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
173*b1cdbd2cSJim Jagielski if ( IsVertLR() )
174*b1cdbd2cSJim Jagielski rPoint.X() = Frm().Left() + nOfstY;
175*b1cdbd2cSJim Jagielski else
176*b1cdbd2cSJim Jagielski {
177*b1cdbd2cSJim Jagielski if ( bIsSwapped )
178*b1cdbd2cSJim Jagielski rPoint.X() = Frm().Left() + Frm().Height() - nOfstY;
179*b1cdbd2cSJim Jagielski else
180*b1cdbd2cSJim Jagielski // calc rotated coords
181*b1cdbd2cSJim Jagielski rPoint.X() = Frm().Left() + Frm().Width() - nOfstY;
182*b1cdbd2cSJim Jagielski }
183*b1cdbd2cSJim Jagielski
184*b1cdbd2cSJim Jagielski rPoint.Y() = Frm().Top() + nOfstX;
185*b1cdbd2cSJim Jagielski }
186*b1cdbd2cSJim Jagielski
187*b1cdbd2cSJim Jagielski // Calculates the a limit value when switching from
188*b1cdbd2cSJim Jagielski // horizontal to vertical layout.
SwitchHorizontalToVertical(long nLimit) const189*b1cdbd2cSJim Jagielski long SwTxtFrm::SwitchHorizontalToVertical( long nLimit ) const
190*b1cdbd2cSJim Jagielski {
191*b1cdbd2cSJim Jagielski Point aTmp( 0, nLimit );
192*b1cdbd2cSJim Jagielski SwitchHorizontalToVertical( aTmp );
193*b1cdbd2cSJim Jagielski return aTmp.X();
194*b1cdbd2cSJim Jagielski }
195*b1cdbd2cSJim Jagielski
196*b1cdbd2cSJim Jagielski // Calculates the coordinates of a rectangle when switching from
197*b1cdbd2cSJim Jagielski // vertical to horizontal layout.
SwitchVerticalToHorizontal(SwRect & rRect) const198*b1cdbd2cSJim Jagielski void SwTxtFrm::SwitchVerticalToHorizontal( SwRect& rRect ) const
199*b1cdbd2cSJim Jagielski {
200*b1cdbd2cSJim Jagielski long nOfstX;
201*b1cdbd2cSJim Jagielski
202*b1cdbd2cSJim Jagielski // calc offset inside frame
203*b1cdbd2cSJim Jagielski
204*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
205*b1cdbd2cSJim Jagielski if ( IsVertLR() )
206*b1cdbd2cSJim Jagielski nOfstX = rRect.Left() - Frm().Left();
207*b1cdbd2cSJim Jagielski else
208*b1cdbd2cSJim Jagielski {
209*b1cdbd2cSJim Jagielski if ( bIsSwapped )
210*b1cdbd2cSJim Jagielski nOfstX = Frm().Left() + Frm().Height() - ( rRect.Left() + rRect.Width() );
211*b1cdbd2cSJim Jagielski else
212*b1cdbd2cSJim Jagielski nOfstX = Frm().Left() + Frm().Width() - ( rRect.Left() + rRect.Width() );
213*b1cdbd2cSJim Jagielski }
214*b1cdbd2cSJim Jagielski
215*b1cdbd2cSJim Jagielski const long nOfstY = rRect.Top() - Frm().Top();
216*b1cdbd2cSJim Jagielski const long nWidth = rRect.Height();
217*b1cdbd2cSJim Jagielski const long nHeight = rRect.Width();
218*b1cdbd2cSJim Jagielski
219*b1cdbd2cSJim Jagielski // calc rotated coords
220*b1cdbd2cSJim Jagielski rRect.Left( Frm().Left() + nOfstY );
221*b1cdbd2cSJim Jagielski rRect.Top( Frm().Top() + nOfstX );
222*b1cdbd2cSJim Jagielski rRect.Width( nWidth );
223*b1cdbd2cSJim Jagielski rRect.Height( nHeight );
224*b1cdbd2cSJim Jagielski }
225*b1cdbd2cSJim Jagielski
226*b1cdbd2cSJim Jagielski // Calculates the coordinates of a point when switching from
227*b1cdbd2cSJim Jagielski // vertical to horizontal layout.
SwitchVerticalToHorizontal(Point & rPoint) const228*b1cdbd2cSJim Jagielski void SwTxtFrm::SwitchVerticalToHorizontal( Point& rPoint ) const
229*b1cdbd2cSJim Jagielski {
230*b1cdbd2cSJim Jagielski long nOfstX;
231*b1cdbd2cSJim Jagielski
232*b1cdbd2cSJim Jagielski // calc offset inside frame
233*b1cdbd2cSJim Jagielski
234*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
235*b1cdbd2cSJim Jagielski if ( IsVertLR() )
236*b1cdbd2cSJim Jagielski nOfstX = rPoint.X() - Frm().Left();
237*b1cdbd2cSJim Jagielski else
238*b1cdbd2cSJim Jagielski {
239*b1cdbd2cSJim Jagielski if ( bIsSwapped )
240*b1cdbd2cSJim Jagielski nOfstX = Frm().Left() + Frm().Height() - rPoint.X();
241*b1cdbd2cSJim Jagielski else
242*b1cdbd2cSJim Jagielski nOfstX = Frm().Left() + Frm().Width() - rPoint.X();
243*b1cdbd2cSJim Jagielski }
244*b1cdbd2cSJim Jagielski
245*b1cdbd2cSJim Jagielski const long nOfstY = rPoint.Y() - Frm().Top();
246*b1cdbd2cSJim Jagielski
247*b1cdbd2cSJim Jagielski // calc rotated coords
248*b1cdbd2cSJim Jagielski rPoint.X() = Frm().Left() + nOfstY;
249*b1cdbd2cSJim Jagielski rPoint.Y() = Frm().Top() + nOfstX;
250*b1cdbd2cSJim Jagielski }
251*b1cdbd2cSJim Jagielski
252*b1cdbd2cSJim Jagielski // Calculates the a limit value when switching from
253*b1cdbd2cSJim Jagielski // vertical to horizontal layout.
SwitchVerticalToHorizontal(long nLimit) const254*b1cdbd2cSJim Jagielski long SwTxtFrm::SwitchVerticalToHorizontal( long nLimit ) const
255*b1cdbd2cSJim Jagielski {
256*b1cdbd2cSJim Jagielski Point aTmp( nLimit, 0 );
257*b1cdbd2cSJim Jagielski SwitchVerticalToHorizontal( aTmp );
258*b1cdbd2cSJim Jagielski return aTmp.Y();
259*b1cdbd2cSJim Jagielski }
260*b1cdbd2cSJim Jagielski
SwFrmSwapper(const SwTxtFrm * pTxtFrm,sal_Bool bSwapIfNotSwapped)261*b1cdbd2cSJim Jagielski SwFrmSwapper::SwFrmSwapper( const SwTxtFrm* pTxtFrm, sal_Bool bSwapIfNotSwapped )
262*b1cdbd2cSJim Jagielski : pFrm( pTxtFrm ), bUndo( sal_False )
263*b1cdbd2cSJim Jagielski {
264*b1cdbd2cSJim Jagielski if ( pFrm->IsVertical() &&
265*b1cdbd2cSJim Jagielski ( ( bSwapIfNotSwapped && ! pFrm->IsSwapped() ) ||
266*b1cdbd2cSJim Jagielski ( ! bSwapIfNotSwapped && pFrm->IsSwapped() ) ) )
267*b1cdbd2cSJim Jagielski {
268*b1cdbd2cSJim Jagielski bUndo = sal_True;
269*b1cdbd2cSJim Jagielski ((SwTxtFrm*)pFrm)->SwapWidthAndHeight();
270*b1cdbd2cSJim Jagielski }
271*b1cdbd2cSJim Jagielski }
272*b1cdbd2cSJim Jagielski
~SwFrmSwapper()273*b1cdbd2cSJim Jagielski SwFrmSwapper::~SwFrmSwapper()
274*b1cdbd2cSJim Jagielski {
275*b1cdbd2cSJim Jagielski if ( bUndo )
276*b1cdbd2cSJim Jagielski ((SwTxtFrm*)pFrm)->SwapWidthAndHeight();
277*b1cdbd2cSJim Jagielski }
278*b1cdbd2cSJim Jagielski
SwitchLTRtoRTL(SwRect & rRect) const279*b1cdbd2cSJim Jagielski void SwTxtFrm::SwitchLTRtoRTL( SwRect& rRect ) const
280*b1cdbd2cSJim Jagielski {
281*b1cdbd2cSJim Jagielski SWAP_IF_NOT_SWAPPED( this )
282*b1cdbd2cSJim Jagielski
283*b1cdbd2cSJim Jagielski long nWidth = rRect.Width();
284*b1cdbd2cSJim Jagielski rRect.Left( 2 * ( Frm().Left() + Prt().Left() ) +
285*b1cdbd2cSJim Jagielski Prt().Width() - rRect.Right() - 1 );
286*b1cdbd2cSJim Jagielski
287*b1cdbd2cSJim Jagielski rRect.Width( nWidth );
288*b1cdbd2cSJim Jagielski
289*b1cdbd2cSJim Jagielski UNDO_SWAP( this )
290*b1cdbd2cSJim Jagielski }
291*b1cdbd2cSJim Jagielski
SwitchLTRtoRTL(Point & rPoint) const292*b1cdbd2cSJim Jagielski void SwTxtFrm::SwitchLTRtoRTL( Point& rPoint ) const
293*b1cdbd2cSJim Jagielski {
294*b1cdbd2cSJim Jagielski SWAP_IF_NOT_SWAPPED( this )
295*b1cdbd2cSJim Jagielski
296*b1cdbd2cSJim Jagielski rPoint.X() = 2 * ( Frm().Left() + Prt().Left() ) + Prt().Width() - rPoint.X() - 1;
297*b1cdbd2cSJim Jagielski
298*b1cdbd2cSJim Jagielski UNDO_SWAP( this )
299*b1cdbd2cSJim Jagielski }
300*b1cdbd2cSJim Jagielski
SwLayoutModeModifier(const OutputDevice & rOutp)301*b1cdbd2cSJim Jagielski SwLayoutModeModifier::SwLayoutModeModifier( const OutputDevice& rOutp ) :
302*b1cdbd2cSJim Jagielski rOut( rOutp ), nOldLayoutMode( rOutp.GetLayoutMode() )
303*b1cdbd2cSJim Jagielski {
304*b1cdbd2cSJim Jagielski }
305*b1cdbd2cSJim Jagielski
~SwLayoutModeModifier()306*b1cdbd2cSJim Jagielski SwLayoutModeModifier::~SwLayoutModeModifier()
307*b1cdbd2cSJim Jagielski {
308*b1cdbd2cSJim Jagielski ((OutputDevice&)rOut).SetLayoutMode( nOldLayoutMode );
309*b1cdbd2cSJim Jagielski }
310*b1cdbd2cSJim Jagielski
Modify(sal_Bool bChgToRTL)311*b1cdbd2cSJim Jagielski void SwLayoutModeModifier::Modify( sal_Bool bChgToRTL )
312*b1cdbd2cSJim Jagielski {
313*b1cdbd2cSJim Jagielski ((OutputDevice&)rOut).SetLayoutMode( bChgToRTL ?
314*b1cdbd2cSJim Jagielski TEXT_LAYOUT_BIDI_STRONG | TEXT_LAYOUT_BIDI_RTL :
315*b1cdbd2cSJim Jagielski TEXT_LAYOUT_BIDI_STRONG );
316*b1cdbd2cSJim Jagielski }
317*b1cdbd2cSJim Jagielski
SetAuto()318*b1cdbd2cSJim Jagielski void SwLayoutModeModifier::SetAuto()
319*b1cdbd2cSJim Jagielski {
320*b1cdbd2cSJim Jagielski const sal_uLong nNewLayoutMode = nOldLayoutMode & ~TEXT_LAYOUT_BIDI_STRONG;
321*b1cdbd2cSJim Jagielski ((OutputDevice&)rOut).SetLayoutMode( nNewLayoutMode );
322*b1cdbd2cSJim Jagielski }
323*b1cdbd2cSJim Jagielski
SwDigitModeModifier(const OutputDevice & rOutp,LanguageType eCurLang)324*b1cdbd2cSJim Jagielski SwDigitModeModifier::SwDigitModeModifier( const OutputDevice& rOutp, LanguageType eCurLang ) :
325*b1cdbd2cSJim Jagielski rOut( rOutp ), nOldLanguageType( rOutp.GetDigitLanguage() )
326*b1cdbd2cSJim Jagielski {
327*b1cdbd2cSJim Jagielski LanguageType eLang = eCurLang;
328*b1cdbd2cSJim Jagielski const SvtCTLOptions::TextNumerals nTextNumerals = SW_MOD()->GetCTLOptions().GetCTLTextNumerals();
329*b1cdbd2cSJim Jagielski
330*b1cdbd2cSJim Jagielski if ( SvtCTLOptions::NUMERALS_HINDI == nTextNumerals )
331*b1cdbd2cSJim Jagielski eLang = LANGUAGE_ARABIC_SAUDI_ARABIA;
332*b1cdbd2cSJim Jagielski else if ( SvtCTLOptions::NUMERALS_ARABIC == nTextNumerals )
333*b1cdbd2cSJim Jagielski eLang = LANGUAGE_ENGLISH;
334*b1cdbd2cSJim Jagielski else if ( SvtCTLOptions::NUMERALS_SYSTEM == nTextNumerals )
335*b1cdbd2cSJim Jagielski eLang = (LanguageType)::GetAppLanguage();
336*b1cdbd2cSJim Jagielski
337*b1cdbd2cSJim Jagielski ((OutputDevice&)rOut).SetDigitLanguage( eLang );
338*b1cdbd2cSJim Jagielski }
339*b1cdbd2cSJim Jagielski
~SwDigitModeModifier()340*b1cdbd2cSJim Jagielski SwDigitModeModifier::~SwDigitModeModifier()
341*b1cdbd2cSJim Jagielski {
342*b1cdbd2cSJim Jagielski ((OutputDevice&)rOut).SetDigitLanguage( nOldLanguageType );
343*b1cdbd2cSJim Jagielski }
344*b1cdbd2cSJim Jagielski
345*b1cdbd2cSJim Jagielski /*************************************************************************
346*b1cdbd2cSJim Jagielski * SwTxtFrm::Init()
347*b1cdbd2cSJim Jagielski *************************************************************************/
348*b1cdbd2cSJim Jagielski
Init()349*b1cdbd2cSJim Jagielski void SwTxtFrm::Init()
350*b1cdbd2cSJim Jagielski {
351*b1cdbd2cSJim Jagielski ASSERT( !IsLocked(), "+SwTxtFrm::Init: this ist locked." );
352*b1cdbd2cSJim Jagielski if( !IsLocked() )
353*b1cdbd2cSJim Jagielski {
354*b1cdbd2cSJim Jagielski ClearPara();
355*b1cdbd2cSJim Jagielski ResetBlinkPor();
356*b1cdbd2cSJim Jagielski //Die Flags direkt setzen um ResetPreps und damit ein unnuetzes GetPara
357*b1cdbd2cSJim Jagielski //einzusparen.
358*b1cdbd2cSJim Jagielski // Nicht bOrphan, bLocked oder bWait auf sal_False setzen !
359*b1cdbd2cSJim Jagielski // bOrphan = bFlag7 = bFlag8 = sal_False;
360*b1cdbd2cSJim Jagielski }
361*b1cdbd2cSJim Jagielski }
362*b1cdbd2cSJim Jagielski
363*b1cdbd2cSJim Jagielski /*************************************************************************
364*b1cdbd2cSJim Jagielski |* SwTxtFrm::CTORen/DTOR
365*b1cdbd2cSJim Jagielski |*************************************************************************/
366*b1cdbd2cSJim Jagielski
InitCtor()367*b1cdbd2cSJim Jagielski void SwTxtFrm::InitCtor()
368*b1cdbd2cSJim Jagielski {
369*b1cdbd2cSJim Jagielski nCacheIdx = MSHRT_MAX;
370*b1cdbd2cSJim Jagielski nOfst = 0;
371*b1cdbd2cSJim Jagielski nAllLines = 0;
372*b1cdbd2cSJim Jagielski nThisLines = 0;
373*b1cdbd2cSJim Jagielski mnFlyAnchorOfst = 0;
374*b1cdbd2cSJim Jagielski mnFlyAnchorOfstNoWrap = 0;
375*b1cdbd2cSJim Jagielski mnFtnLine = 0;
376*b1cdbd2cSJim Jagielski // OD 2004-03-17 #i11860#
377*b1cdbd2cSJim Jagielski mnHeightOfLastLine = 0;
378*b1cdbd2cSJim Jagielski // --> OD 2008-01-31 #newlistlevelattrs#
379*b1cdbd2cSJim Jagielski mnAdditionalFirstLineOffset = 0;
380*b1cdbd2cSJim Jagielski // <--
381*b1cdbd2cSJim Jagielski
382*b1cdbd2cSJim Jagielski nType = FRMC_TXT;
383*b1cdbd2cSJim Jagielski bLocked = bFormatted = bWidow = bUndersized = bJustWidow =
384*b1cdbd2cSJim Jagielski bEmpty = bInFtnConnect = bFtn = bRepaint = bBlinkPor =
385*b1cdbd2cSJim Jagielski bFieldFollow = bHasAnimation = bIsSwapped = sal_False;
386*b1cdbd2cSJim Jagielski // OD 14.03.2003 #i11760#
387*b1cdbd2cSJim Jagielski mbFollowFormatAllowed = sal_True;
388*b1cdbd2cSJim Jagielski }
389*b1cdbd2cSJim Jagielski
390*b1cdbd2cSJim Jagielski /*************************************************************************
391*b1cdbd2cSJim Jagielski * SwTxtFrm::SwTxtFrm()
392*b1cdbd2cSJim Jagielski *************************************************************************/
SwTxtFrm(SwTxtNode * const pNode,SwFrm * pSib)393*b1cdbd2cSJim Jagielski SwTxtFrm::SwTxtFrm(SwTxtNode * const pNode, SwFrm* pSib )
394*b1cdbd2cSJim Jagielski : SwCntntFrm( pNode, pSib )
395*b1cdbd2cSJim Jagielski {
396*b1cdbd2cSJim Jagielski InitCtor();
397*b1cdbd2cSJim Jagielski }
398*b1cdbd2cSJim Jagielski
399*b1cdbd2cSJim Jagielski /*************************************************************************
400*b1cdbd2cSJim Jagielski * SwTxtFrm::~SwTxtFrm()
401*b1cdbd2cSJim Jagielski *************************************************************************/
~SwTxtFrm()402*b1cdbd2cSJim Jagielski SwTxtFrm::~SwTxtFrm()
403*b1cdbd2cSJim Jagielski {
404*b1cdbd2cSJim Jagielski // Remove associated SwParaPortion from pTxtCache
405*b1cdbd2cSJim Jagielski ClearPara();
406*b1cdbd2cSJim Jagielski }
407*b1cdbd2cSJim Jagielski
GetTxt() const408*b1cdbd2cSJim Jagielski const XubString& SwTxtFrm::GetTxt() const
409*b1cdbd2cSJim Jagielski {
410*b1cdbd2cSJim Jagielski return GetTxtNode()->GetTxt();
411*b1cdbd2cSJim Jagielski }
412*b1cdbd2cSJim Jagielski
ResetPreps()413*b1cdbd2cSJim Jagielski void SwTxtFrm::ResetPreps()
414*b1cdbd2cSJim Jagielski {
415*b1cdbd2cSJim Jagielski if ( GetCacheIdx() != MSHRT_MAX )
416*b1cdbd2cSJim Jagielski {
417*b1cdbd2cSJim Jagielski SwParaPortion *pPara;
418*b1cdbd2cSJim Jagielski if( 0 != (pPara = GetPara()) )
419*b1cdbd2cSJim Jagielski pPara->ResetPreps();
420*b1cdbd2cSJim Jagielski }
421*b1cdbd2cSJim Jagielski }
422*b1cdbd2cSJim Jagielski
423*b1cdbd2cSJim Jagielski /*************************************************************************
424*b1cdbd2cSJim Jagielski * SwTxtFrm::IsHiddenNow()
425*b1cdbd2cSJim Jagielski *************************************************************************/
IsHiddenNow() const426*b1cdbd2cSJim Jagielski sal_Bool SwTxtFrm::IsHiddenNow() const
427*b1cdbd2cSJim Jagielski {
428*b1cdbd2cSJim Jagielski SwFrmSwapper aSwapper( this, sal_True );
429*b1cdbd2cSJim Jagielski
430*b1cdbd2cSJim Jagielski if( !Frm().Width() && IsValid() && GetUpper()->IsValid() )
431*b1cdbd2cSJim Jagielski //bei Stackueberlauf (StackHack) invalid!
432*b1cdbd2cSJim Jagielski {
433*b1cdbd2cSJim Jagielski // ASSERT( false, "SwTxtFrm::IsHiddenNow: thin frame" );
434*b1cdbd2cSJim Jagielski return sal_True;
435*b1cdbd2cSJim Jagielski }
436*b1cdbd2cSJim Jagielski
437*b1cdbd2cSJim Jagielski const bool bHiddenCharsHidePara = GetTxtNode()->HasHiddenCharAttribute( true );
438*b1cdbd2cSJim Jagielski const bool bHiddenParaField = GetTxtNode()->HasHiddenParaField();
439*b1cdbd2cSJim Jagielski const ViewShell* pVsh = getRootFrm()->GetCurrShell();
440*b1cdbd2cSJim Jagielski
441*b1cdbd2cSJim Jagielski if ( pVsh && ( bHiddenCharsHidePara || bHiddenParaField ) )
442*b1cdbd2cSJim Jagielski {
443*b1cdbd2cSJim Jagielski if (
444*b1cdbd2cSJim Jagielski ( bHiddenParaField &&
445*b1cdbd2cSJim Jagielski ( !pVsh->GetViewOptions()->IsShowHiddenPara() &&
446*b1cdbd2cSJim Jagielski !pVsh->GetViewOptions()->IsFldName() ) ) ||
447*b1cdbd2cSJim Jagielski ( bHiddenCharsHidePara &&
448*b1cdbd2cSJim Jagielski !pVsh->GetViewOptions()->IsShowHiddenChar() ) )
449*b1cdbd2cSJim Jagielski {
450*b1cdbd2cSJim Jagielski return sal_True;
451*b1cdbd2cSJim Jagielski }
452*b1cdbd2cSJim Jagielski }
453*b1cdbd2cSJim Jagielski
454*b1cdbd2cSJim Jagielski return sal_False;
455*b1cdbd2cSJim Jagielski }
456*b1cdbd2cSJim Jagielski
457*b1cdbd2cSJim Jagielski
458*b1cdbd2cSJim Jagielski /*************************************************************************
459*b1cdbd2cSJim Jagielski * SwTxtFrm::HideHidden()
460*b1cdbd2cSJim Jagielski *************************************************************************/
461*b1cdbd2cSJim Jagielski // Entfernt die Anhaengsel des Textfrms wenn dieser hidden ist
462*b1cdbd2cSJim Jagielski
HideHidden()463*b1cdbd2cSJim Jagielski void SwTxtFrm::HideHidden()
464*b1cdbd2cSJim Jagielski {
465*b1cdbd2cSJim Jagielski ASSERT( !GetFollow() && IsHiddenNow(),
466*b1cdbd2cSJim Jagielski "HideHidden on visible frame of hidden frame has follow" );
467*b1cdbd2cSJim Jagielski
468*b1cdbd2cSJim Jagielski const xub_StrLen nEnd = STRING_LEN;
469*b1cdbd2cSJim Jagielski HideFootnotes( GetOfst(), nEnd );
470*b1cdbd2cSJim Jagielski // OD 2004-01-15 #110582#
471*b1cdbd2cSJim Jagielski HideAndShowObjects();
472*b1cdbd2cSJim Jagielski
473*b1cdbd2cSJim Jagielski //Die Formatinfos sind jetzt obsolete
474*b1cdbd2cSJim Jagielski ClearPara();
475*b1cdbd2cSJim Jagielski }
476*b1cdbd2cSJim Jagielski
477*b1cdbd2cSJim Jagielski /*************************************************************************
478*b1cdbd2cSJim Jagielski * SwTxtFrm::HideFootnotes()
479*b1cdbd2cSJim Jagielski *************************************************************************/
HideFootnotes(xub_StrLen nStart,xub_StrLen nEnd)480*b1cdbd2cSJim Jagielski void SwTxtFrm::HideFootnotes( xub_StrLen nStart, xub_StrLen nEnd )
481*b1cdbd2cSJim Jagielski {
482*b1cdbd2cSJim Jagielski const SwpHints *pHints = GetTxtNode()->GetpSwpHints();
483*b1cdbd2cSJim Jagielski if( pHints )
484*b1cdbd2cSJim Jagielski {
485*b1cdbd2cSJim Jagielski const sal_uInt16 nSize = pHints->Count();
486*b1cdbd2cSJim Jagielski SwPageFrm *pPage = 0;
487*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < nSize; ++i )
488*b1cdbd2cSJim Jagielski {
489*b1cdbd2cSJim Jagielski const SwTxtAttr *pHt = (*pHints)[i];
490*b1cdbd2cSJim Jagielski if ( pHt->Which() == RES_TXTATR_FTN )
491*b1cdbd2cSJim Jagielski {
492*b1cdbd2cSJim Jagielski const xub_StrLen nIdx = *pHt->GetStart();
493*b1cdbd2cSJim Jagielski if ( nEnd < nIdx )
494*b1cdbd2cSJim Jagielski break;
495*b1cdbd2cSJim Jagielski if( nStart <= nIdx )
496*b1cdbd2cSJim Jagielski {
497*b1cdbd2cSJim Jagielski if( !pPage )
498*b1cdbd2cSJim Jagielski pPage = FindPageFrm();
499*b1cdbd2cSJim Jagielski pPage->RemoveFtn( this, (SwTxtFtn*)pHt );
500*b1cdbd2cSJim Jagielski }
501*b1cdbd2cSJim Jagielski }
502*b1cdbd2cSJim Jagielski }
503*b1cdbd2cSJim Jagielski }
504*b1cdbd2cSJim Jagielski }
505*b1cdbd2cSJim Jagielski
506*b1cdbd2cSJim Jagielski // --> OD 2005-03-30 #120729# - hotfix: WW8 documents contain at its end hidden,
507*b1cdbd2cSJim Jagielski // as-character anchored graphics, which are used for a graphic bullet list.
508*b1cdbd2cSJim Jagielski // As long as these graphic bullet list aren't imported, do not hide a
509*b1cdbd2cSJim Jagielski // at-character anchored object, if
510*b1cdbd2cSJim Jagielski // (a) the document is an imported WW8 document -
511*b1cdbd2cSJim Jagielski // checked by checking certain compatibility options -,
512*b1cdbd2cSJim Jagielski // (b) the paragraph is the last content in the document and
513*b1cdbd2cSJim Jagielski // (c) the anchor character is an as-character anchored graphic.
lcl_HideObj(const SwTxtFrm & _rFrm,const RndStdIds _eAnchorType,const xub_StrLen _nObjAnchorPos,SwAnchoredObject * _pAnchoredObj)514*b1cdbd2cSJim Jagielski bool lcl_HideObj( const SwTxtFrm& _rFrm,
515*b1cdbd2cSJim Jagielski const RndStdIds _eAnchorType,
516*b1cdbd2cSJim Jagielski const xub_StrLen _nObjAnchorPos,
517*b1cdbd2cSJim Jagielski SwAnchoredObject* _pAnchoredObj )
518*b1cdbd2cSJim Jagielski {
519*b1cdbd2cSJim Jagielski bool bRet( true );
520*b1cdbd2cSJim Jagielski
521*b1cdbd2cSJim Jagielski if (_eAnchorType == FLY_AT_CHAR)
522*b1cdbd2cSJim Jagielski {
523*b1cdbd2cSJim Jagielski const IDocumentSettingAccess* pIDSA = _rFrm.GetTxtNode()->getIDocumentSettingAccess();
524*b1cdbd2cSJim Jagielski if ( !pIDSA->get(IDocumentSettingAccess::USE_FORMER_TEXT_WRAPPING) &&
525*b1cdbd2cSJim Jagielski !pIDSA->get(IDocumentSettingAccess::OLD_LINE_SPACING) &&
526*b1cdbd2cSJim Jagielski !pIDSA->get(IDocumentSettingAccess::USE_FORMER_OBJECT_POS) &&
527*b1cdbd2cSJim Jagielski pIDSA->get(IDocumentSettingAccess::CONSIDER_WRAP_ON_OBJECT_POSITION) &&
528*b1cdbd2cSJim Jagielski _rFrm.IsInDocBody() && !_rFrm.FindNextCnt() )
529*b1cdbd2cSJim Jagielski {
530*b1cdbd2cSJim Jagielski const xub_Unicode cAnchorChar =
531*b1cdbd2cSJim Jagielski _rFrm.GetTxtNode()->GetTxt().GetChar( _nObjAnchorPos );
532*b1cdbd2cSJim Jagielski if ( cAnchorChar == CH_TXTATR_BREAKWORD )
533*b1cdbd2cSJim Jagielski {
534*b1cdbd2cSJim Jagielski const SwTxtAttr* const pHint(
535*b1cdbd2cSJim Jagielski _rFrm.GetTxtNode()->GetTxtAttrForCharAt(_nObjAnchorPos,
536*b1cdbd2cSJim Jagielski RES_TXTATR_FLYCNT) );
537*b1cdbd2cSJim Jagielski if ( pHint )
538*b1cdbd2cSJim Jagielski {
539*b1cdbd2cSJim Jagielski const SwFrmFmt* pFrmFmt =
540*b1cdbd2cSJim Jagielski static_cast<const SwTxtFlyCnt*>(pHint)->GetFlyCnt().GetFrmFmt();
541*b1cdbd2cSJim Jagielski if ( pFrmFmt->Which() == RES_FLYFRMFMT )
542*b1cdbd2cSJim Jagielski {
543*b1cdbd2cSJim Jagielski SwNodeIndex nCntntIndex = *(pFrmFmt->GetCntnt().GetCntntIdx());
544*b1cdbd2cSJim Jagielski nCntntIndex++;
545*b1cdbd2cSJim Jagielski if ( nCntntIndex.GetNode().IsNoTxtNode() )
546*b1cdbd2cSJim Jagielski {
547*b1cdbd2cSJim Jagielski bRet = false;
548*b1cdbd2cSJim Jagielski // set needed data structure values for object positioning
549*b1cdbd2cSJim Jagielski SWRECTFN( (&_rFrm) );
550*b1cdbd2cSJim Jagielski SwRect aLastCharRect( _rFrm.Frm() );
551*b1cdbd2cSJim Jagielski (aLastCharRect.*fnRect->fnSetWidth)( 1 );
552*b1cdbd2cSJim Jagielski _pAnchoredObj->maLastCharRect = aLastCharRect;
553*b1cdbd2cSJim Jagielski _pAnchoredObj->mnLastTopOfLine = (aLastCharRect.*fnRect->fnGetTop)();
554*b1cdbd2cSJim Jagielski }
555*b1cdbd2cSJim Jagielski }
556*b1cdbd2cSJim Jagielski }
557*b1cdbd2cSJim Jagielski }
558*b1cdbd2cSJim Jagielski }
559*b1cdbd2cSJim Jagielski }
560*b1cdbd2cSJim Jagielski
561*b1cdbd2cSJim Jagielski return bRet;
562*b1cdbd2cSJim Jagielski }
563*b1cdbd2cSJim Jagielski // <--
564*b1cdbd2cSJim Jagielski /*************************************************************************
565*b1cdbd2cSJim Jagielski * SwTxtFrm::HideAndShowObjects()
566*b1cdbd2cSJim Jagielski *************************************************************************/
567*b1cdbd2cSJim Jagielski /** method to hide/show objects
568*b1cdbd2cSJim Jagielski
569*b1cdbd2cSJim Jagielski OD 2004-01-15 #110582#
570*b1cdbd2cSJim Jagielski method hides respectively shows objects, which are anchored at paragraph,
571*b1cdbd2cSJim Jagielski at/as a character of the paragraph, corresponding to the paragraph and
572*b1cdbd2cSJim Jagielski paragraph portion visibility.
573*b1cdbd2cSJim Jagielski
574*b1cdbd2cSJim Jagielski - is called from HideHidden() - should hide objects in hidden paragraphs and
575*b1cdbd2cSJim Jagielski - from _Format() - should hide/show objects in partly visible paragraphs
576*b1cdbd2cSJim Jagielski
577*b1cdbd2cSJim Jagielski @author OD
578*b1cdbd2cSJim Jagielski */
HideAndShowObjects()579*b1cdbd2cSJim Jagielski void SwTxtFrm::HideAndShowObjects()
580*b1cdbd2cSJim Jagielski {
581*b1cdbd2cSJim Jagielski if ( GetDrawObjs() )
582*b1cdbd2cSJim Jagielski {
583*b1cdbd2cSJim Jagielski if ( IsHiddenNow() )
584*b1cdbd2cSJim Jagielski {
585*b1cdbd2cSJim Jagielski // complete paragraph is hidden. Thus, hide all objects
586*b1cdbd2cSJim Jagielski for ( sal_uInt32 i = 0; i < GetDrawObjs()->Count(); ++i )
587*b1cdbd2cSJim Jagielski {
588*b1cdbd2cSJim Jagielski SdrObject* pObj = (*GetDrawObjs())[i]->DrawObj();
589*b1cdbd2cSJim Jagielski SwContact* pContact = static_cast<SwContact*>(pObj->GetUserCall());
590*b1cdbd2cSJim Jagielski // --> OD 2005-03-30 #120729# - hotfix: do not hide object
591*b1cdbd2cSJim Jagielski // under certain conditions
592*b1cdbd2cSJim Jagielski const RndStdIds eAnchorType( pContact->GetAnchorId() );
593*b1cdbd2cSJim Jagielski const xub_StrLen nObjAnchorPos = pContact->GetCntntAnchorIndex().GetIndex();
594*b1cdbd2cSJim Jagielski if ((eAnchorType != FLY_AT_CHAR) ||
595*b1cdbd2cSJim Jagielski lcl_HideObj( *this, eAnchorType, nObjAnchorPos,
596*b1cdbd2cSJim Jagielski (*GetDrawObjs())[i] ))
597*b1cdbd2cSJim Jagielski {
598*b1cdbd2cSJim Jagielski pContact->MoveObjToInvisibleLayer( pObj );
599*b1cdbd2cSJim Jagielski }
600*b1cdbd2cSJim Jagielski // <--
601*b1cdbd2cSJim Jagielski }
602*b1cdbd2cSJim Jagielski }
603*b1cdbd2cSJim Jagielski else
604*b1cdbd2cSJim Jagielski {
605*b1cdbd2cSJim Jagielski // paragraph is visible, but can contain hidden text portion.
606*b1cdbd2cSJim Jagielski // first we check if objects are allowed to be hidden:
607*b1cdbd2cSJim Jagielski const SwTxtNode& rNode = *GetTxtNode();
608*b1cdbd2cSJim Jagielski const ViewShell* pVsh = getRootFrm()->GetCurrShell();
609*b1cdbd2cSJim Jagielski const bool bShouldBeHidden = !pVsh || !pVsh->GetWin() ||
610*b1cdbd2cSJim Jagielski !pVsh->GetViewOptions()->IsShowHiddenChar();
611*b1cdbd2cSJim Jagielski
612*b1cdbd2cSJim Jagielski // Thus, show all objects, which are anchored at paragraph and
613*b1cdbd2cSJim Jagielski // hide/show objects, which are anchored at/as character, according
614*b1cdbd2cSJim Jagielski // to the visibility of the anchor character.
615*b1cdbd2cSJim Jagielski for ( sal_uInt32 i = 0; i < GetDrawObjs()->Count(); ++i )
616*b1cdbd2cSJim Jagielski {
617*b1cdbd2cSJim Jagielski SdrObject* pObj = (*GetDrawObjs())[i]->DrawObj();
618*b1cdbd2cSJim Jagielski SwContact* pContact = static_cast<SwContact*>(pObj->GetUserCall());
619*b1cdbd2cSJim Jagielski // --> OD 2005-03-30 #120729# - determine anchor type only once
620*b1cdbd2cSJim Jagielski const RndStdIds eAnchorType( pContact->GetAnchorId() );
621*b1cdbd2cSJim Jagielski // <--
622*b1cdbd2cSJim Jagielski
623*b1cdbd2cSJim Jagielski if (eAnchorType == FLY_AT_PARA)
624*b1cdbd2cSJim Jagielski {
625*b1cdbd2cSJim Jagielski pContact->MoveObjToVisibleLayer( pObj );
626*b1cdbd2cSJim Jagielski }
627*b1cdbd2cSJim Jagielski else if ((eAnchorType == FLY_AT_CHAR) ||
628*b1cdbd2cSJim Jagielski (eAnchorType == FLY_AS_CHAR))
629*b1cdbd2cSJim Jagielski {
630*b1cdbd2cSJim Jagielski xub_StrLen nHiddenStart;
631*b1cdbd2cSJim Jagielski xub_StrLen nHiddenEnd;
632*b1cdbd2cSJim Jagielski xub_StrLen nObjAnchorPos = pContact->GetCntntAnchorIndex().GetIndex();
633*b1cdbd2cSJim Jagielski SwScriptInfo::GetBoundsOfHiddenRange( rNode, nObjAnchorPos, nHiddenStart, nHiddenEnd, 0 );
634*b1cdbd2cSJim Jagielski // --> OD 2005-03-30 #120729# - hotfix: do not hide object
635*b1cdbd2cSJim Jagielski // under certain conditions
636*b1cdbd2cSJim Jagielski if ( nHiddenStart != STRING_LEN && bShouldBeHidden &&
637*b1cdbd2cSJim Jagielski lcl_HideObj( *this, eAnchorType, nObjAnchorPos, (*GetDrawObjs())[i] ) )
638*b1cdbd2cSJim Jagielski // <--
639*b1cdbd2cSJim Jagielski pContact->MoveObjToInvisibleLayer( pObj );
640*b1cdbd2cSJim Jagielski else
641*b1cdbd2cSJim Jagielski pContact->MoveObjToVisibleLayer( pObj );
642*b1cdbd2cSJim Jagielski }
643*b1cdbd2cSJim Jagielski else
644*b1cdbd2cSJim Jagielski {
645*b1cdbd2cSJim Jagielski ASSERT( false,
646*b1cdbd2cSJim Jagielski "<SwTxtFrm::HideAndShowObjects()> - object not anchored at/inside paragraph!?" );
647*b1cdbd2cSJim Jagielski }
648*b1cdbd2cSJim Jagielski }
649*b1cdbd2cSJim Jagielski }
650*b1cdbd2cSJim Jagielski }
651*b1cdbd2cSJim Jagielski
652*b1cdbd2cSJim Jagielski if ( IsFollow() )
653*b1cdbd2cSJim Jagielski {
654*b1cdbd2cSJim Jagielski FindMaster()->HideAndShowObjects();
655*b1cdbd2cSJim Jagielski }
656*b1cdbd2cSJim Jagielski }
657*b1cdbd2cSJim Jagielski
658*b1cdbd2cSJim Jagielski /*************************************************************************
659*b1cdbd2cSJim Jagielski * SwTxtFrm::FindBrk()
660*b1cdbd2cSJim Jagielski *
661*b1cdbd2cSJim Jagielski * Liefert die erste Trennmoeglichkeit in der aktuellen Zeile zurueck.
662*b1cdbd2cSJim Jagielski * Die Methode wird in SwTxtFrm::Format() benutzt, um festzustellen, ob
663*b1cdbd2cSJim Jagielski * die Vorgaengerzeile mitformatiert werden muss.
664*b1cdbd2cSJim Jagielski * nFound ist <= nEndLine.
665*b1cdbd2cSJim Jagielski *************************************************************************/
666*b1cdbd2cSJim Jagielski
FindBrk(const XubString & rTxt,const xub_StrLen nStart,const xub_StrLen nEnd) const667*b1cdbd2cSJim Jagielski xub_StrLen SwTxtFrm::FindBrk( const XubString &rTxt,
668*b1cdbd2cSJim Jagielski const xub_StrLen nStart,
669*b1cdbd2cSJim Jagielski const xub_StrLen nEnd ) const
670*b1cdbd2cSJim Jagielski {
671*b1cdbd2cSJim Jagielski // --> OD 2009-12-28 #i104291# - applying patch to avoid overflow.
672*b1cdbd2cSJim Jagielski unsigned long nFound = nStart;
673*b1cdbd2cSJim Jagielski const xub_StrLen nEndLine = Min( nEnd, rTxt.Len() );
674*b1cdbd2cSJim Jagielski
675*b1cdbd2cSJim Jagielski // Wir ueberlesen erst alle Blanks am Anfang der Zeile (vgl. Bug 2235).
676*b1cdbd2cSJim Jagielski while( nFound <= nEndLine &&
677*b1cdbd2cSJim Jagielski ' ' == rTxt.GetChar( static_cast<xub_StrLen>(nFound) ) )
678*b1cdbd2cSJim Jagielski {
679*b1cdbd2cSJim Jagielski nFound++;
680*b1cdbd2cSJim Jagielski }
681*b1cdbd2cSJim Jagielski
682*b1cdbd2cSJim Jagielski // Eine knifflige Sache mit den TxtAttr-Dummy-Zeichen (hier "$"):
683*b1cdbd2cSJim Jagielski // "Dr.$Meyer" am Anfang der zweiten Zeile. Dahinter ein Blank eingegeben
684*b1cdbd2cSJim Jagielski // und das Wort rutscht nicht in die erste Zeile, obwohl es ginge.
685*b1cdbd2cSJim Jagielski // Aus diesem Grund nehmen wir das Dummy-Zeichen noch mit.
686*b1cdbd2cSJim Jagielski while( nFound <= nEndLine &&
687*b1cdbd2cSJim Jagielski ' ' != rTxt.GetChar( static_cast<xub_StrLen>(nFound) ) )
688*b1cdbd2cSJim Jagielski {
689*b1cdbd2cSJim Jagielski nFound++;
690*b1cdbd2cSJim Jagielski }
691*b1cdbd2cSJim Jagielski
692*b1cdbd2cSJim Jagielski return nFound <= STRING_LEN
693*b1cdbd2cSJim Jagielski ? static_cast<xub_StrLen>(nFound)
694*b1cdbd2cSJim Jagielski : STRING_LEN;
695*b1cdbd2cSJim Jagielski // <--
696*b1cdbd2cSJim Jagielski }
697*b1cdbd2cSJim Jagielski
698*b1cdbd2cSJim Jagielski /*************************************************************************
699*b1cdbd2cSJim Jagielski * SwTxtFrm::IsIdxInside()
700*b1cdbd2cSJim Jagielski *************************************************************************/
701*b1cdbd2cSJim Jagielski
IsIdxInside(const xub_StrLen nPos,const xub_StrLen nLen) const702*b1cdbd2cSJim Jagielski sal_Bool SwTxtFrm::IsIdxInside( const xub_StrLen nPos, const xub_StrLen nLen ) const
703*b1cdbd2cSJim Jagielski {
704*b1cdbd2cSJim Jagielski if( GetOfst() > nPos + nLen ) // d.h., der Bereich liegt komplett vor uns.
705*b1cdbd2cSJim Jagielski return sal_False;
706*b1cdbd2cSJim Jagielski
707*b1cdbd2cSJim Jagielski if( !GetFollow() ) // der Bereich liegt nicht komplett vor uns,
708*b1cdbd2cSJim Jagielski return sal_True; // nach uns kommt niemand mehr.
709*b1cdbd2cSJim Jagielski
710*b1cdbd2cSJim Jagielski const xub_StrLen nMax = GetFollow()->GetOfst();
711*b1cdbd2cSJim Jagielski
712*b1cdbd2cSJim Jagielski // der Bereich liegt nicht komplett hinter uns bzw.
713*b1cdbd2cSJim Jagielski // unser Text ist geloescht worden.
714*b1cdbd2cSJim Jagielski if( nMax > nPos || nMax > GetTxt().Len() )
715*b1cdbd2cSJim Jagielski return sal_True;
716*b1cdbd2cSJim Jagielski
717*b1cdbd2cSJim Jagielski // changes made in the first line of a follow can modify the master
718*b1cdbd2cSJim Jagielski const SwParaPortion* pPara = GetFollow()->GetPara();
719*b1cdbd2cSJim Jagielski return pPara && ( nPos <= nMax + pPara->GetLen() );
720*b1cdbd2cSJim Jagielski }
721*b1cdbd2cSJim Jagielski
722*b1cdbd2cSJim Jagielski /*************************************************************************
723*b1cdbd2cSJim Jagielski * SwTxtFrm::InvalidateRange()
724*b1cdbd2cSJim Jagielski *************************************************************************/
InvalidateRange(const SwCharRange & aRange,const long nD)725*b1cdbd2cSJim Jagielski inline void SwTxtFrm::InvalidateRange(const SwCharRange &aRange, const long nD)
726*b1cdbd2cSJim Jagielski {
727*b1cdbd2cSJim Jagielski if ( IsIdxInside( aRange.Start(), aRange.Len() ) )
728*b1cdbd2cSJim Jagielski _InvalidateRange( aRange, nD );
729*b1cdbd2cSJim Jagielski }
730*b1cdbd2cSJim Jagielski
731*b1cdbd2cSJim Jagielski /*************************************************************************
732*b1cdbd2cSJim Jagielski * SwTxtFrm::_InvalidateRange()
733*b1cdbd2cSJim Jagielski *************************************************************************/
734*b1cdbd2cSJim Jagielski
_InvalidateRange(const SwCharRange & aRange,const long nD)735*b1cdbd2cSJim Jagielski void SwTxtFrm::_InvalidateRange( const SwCharRange &aRange, const long nD)
736*b1cdbd2cSJim Jagielski {
737*b1cdbd2cSJim Jagielski if ( !HasPara() )
738*b1cdbd2cSJim Jagielski { InvalidateSize();
739*b1cdbd2cSJim Jagielski return;
740*b1cdbd2cSJim Jagielski }
741*b1cdbd2cSJim Jagielski
742*b1cdbd2cSJim Jagielski SetWidow( sal_False );
743*b1cdbd2cSJim Jagielski SwParaPortion *pPara = GetPara();
744*b1cdbd2cSJim Jagielski
745*b1cdbd2cSJim Jagielski sal_Bool bInv = sal_False;
746*b1cdbd2cSJim Jagielski if( 0 != nD )
747*b1cdbd2cSJim Jagielski {
748*b1cdbd2cSJim Jagielski //Auf nDelta werden die Differenzen zwischen alter und
749*b1cdbd2cSJim Jagielski //neuer Zeilenlaenge aufaddiert, deshalb ist es negativ,
750*b1cdbd2cSJim Jagielski //wenn Zeichen eingefuegt wurden, positiv, wenn Zeichen
751*b1cdbd2cSJim Jagielski //geloescht wurden.
752*b1cdbd2cSJim Jagielski *(pPara->GetDelta()) += nD;
753*b1cdbd2cSJim Jagielski bInv = sal_True;
754*b1cdbd2cSJim Jagielski }
755*b1cdbd2cSJim Jagielski SwCharRange &rReformat = *(pPara->GetReformat());
756*b1cdbd2cSJim Jagielski if(aRange != rReformat) {
757*b1cdbd2cSJim Jagielski if( STRING_LEN == rReformat.Len() )
758*b1cdbd2cSJim Jagielski rReformat = aRange;
759*b1cdbd2cSJim Jagielski else
760*b1cdbd2cSJim Jagielski rReformat += aRange;
761*b1cdbd2cSJim Jagielski bInv = sal_True;
762*b1cdbd2cSJim Jagielski }
763*b1cdbd2cSJim Jagielski if(bInv)
764*b1cdbd2cSJim Jagielski {
765*b1cdbd2cSJim Jagielski // 90365: nD is passed to a follow two times
766*b1cdbd2cSJim Jagielski // if( GetFollow() )
767*b1cdbd2cSJim Jagielski // ((SwTxtFrm*)GetFollow())->InvalidateRange( aRange, nD );
768*b1cdbd2cSJim Jagielski InvalidateSize();
769*b1cdbd2cSJim Jagielski }
770*b1cdbd2cSJim Jagielski }
771*b1cdbd2cSJim Jagielski
772*b1cdbd2cSJim Jagielski /*************************************************************************
773*b1cdbd2cSJim Jagielski * SwTxtFrm::CalcLineSpace()
774*b1cdbd2cSJim Jagielski *************************************************************************/
775*b1cdbd2cSJim Jagielski
CalcLineSpace()776*b1cdbd2cSJim Jagielski void SwTxtFrm::CalcLineSpace()
777*b1cdbd2cSJim Jagielski {
778*b1cdbd2cSJim Jagielski ASSERT( ! IsVertical() || ! IsSwapped(),
779*b1cdbd2cSJim Jagielski "SwTxtFrm::CalcLineSpace with swapped frame!" )
780*b1cdbd2cSJim Jagielski
781*b1cdbd2cSJim Jagielski if( IsLocked() || !HasPara() )
782*b1cdbd2cSJim Jagielski return;
783*b1cdbd2cSJim Jagielski
784*b1cdbd2cSJim Jagielski SwParaPortion *pPara;
785*b1cdbd2cSJim Jagielski if( GetDrawObjs() ||
786*b1cdbd2cSJim Jagielski GetTxtNode()->GetSwAttrSet().GetLRSpace().IsAutoFirst() ||
787*b1cdbd2cSJim Jagielski ( pPara = GetPara() )->IsFixLineHeight() )
788*b1cdbd2cSJim Jagielski {
789*b1cdbd2cSJim Jagielski Init();
790*b1cdbd2cSJim Jagielski return;
791*b1cdbd2cSJim Jagielski }
792*b1cdbd2cSJim Jagielski
793*b1cdbd2cSJim Jagielski Size aNewSize( Prt().SSize() );
794*b1cdbd2cSJim Jagielski
795*b1cdbd2cSJim Jagielski SwTxtFormatInfo aInf( this );
796*b1cdbd2cSJim Jagielski SwTxtFormatter aLine( this, &aInf );
797*b1cdbd2cSJim Jagielski if( aLine.GetDropLines() )
798*b1cdbd2cSJim Jagielski {
799*b1cdbd2cSJim Jagielski Init();
800*b1cdbd2cSJim Jagielski return;
801*b1cdbd2cSJim Jagielski }
802*b1cdbd2cSJim Jagielski
803*b1cdbd2cSJim Jagielski aLine.Top();
804*b1cdbd2cSJim Jagielski aLine.RecalcRealHeight();
805*b1cdbd2cSJim Jagielski
806*b1cdbd2cSJim Jagielski aNewSize.Height() = (aLine.Y() - Frm().Top()) + aLine.GetLineHeight();
807*b1cdbd2cSJim Jagielski
808*b1cdbd2cSJim Jagielski SwTwips nDelta = aNewSize.Height() - Prt().Height();
809*b1cdbd2cSJim Jagielski // 4291: Unterlauf bei Flys
810*b1cdbd2cSJim Jagielski if( aInf.GetTxtFly()->IsOn() )
811*b1cdbd2cSJim Jagielski {
812*b1cdbd2cSJim Jagielski SwRect aTmpFrm( Frm() );
813*b1cdbd2cSJim Jagielski if( nDelta < 0 )
814*b1cdbd2cSJim Jagielski aTmpFrm.Height( Prt().Height() );
815*b1cdbd2cSJim Jagielski else
816*b1cdbd2cSJim Jagielski aTmpFrm.Height( aNewSize.Height() );
817*b1cdbd2cSJim Jagielski if( aInf.GetTxtFly()->Relax( aTmpFrm ) )
818*b1cdbd2cSJim Jagielski {
819*b1cdbd2cSJim Jagielski Init();
820*b1cdbd2cSJim Jagielski return;
821*b1cdbd2cSJim Jagielski }
822*b1cdbd2cSJim Jagielski }
823*b1cdbd2cSJim Jagielski
824*b1cdbd2cSJim Jagielski if( nDelta )
825*b1cdbd2cSJim Jagielski {
826*b1cdbd2cSJim Jagielski SwTxtFrmBreak aBreak( this );
827*b1cdbd2cSJim Jagielski if( GetFollow() || aBreak.IsBreakNow( aLine ) )
828*b1cdbd2cSJim Jagielski {
829*b1cdbd2cSJim Jagielski // Wenn es einen Follow() gibt, oder wenn wir an dieser
830*b1cdbd2cSJim Jagielski // Stelle aufbrechen muessen, so wird neu formatiert.
831*b1cdbd2cSJim Jagielski Init();
832*b1cdbd2cSJim Jagielski }
833*b1cdbd2cSJim Jagielski else
834*b1cdbd2cSJim Jagielski {
835*b1cdbd2cSJim Jagielski // Alles nimmt seinen gewohnten Gang ...
836*b1cdbd2cSJim Jagielski pPara->SetPrepAdjust();
837*b1cdbd2cSJim Jagielski pPara->SetPrep();
838*b1cdbd2cSJim Jagielski }
839*b1cdbd2cSJim Jagielski }
840*b1cdbd2cSJim Jagielski }
841*b1cdbd2cSJim Jagielski
842*b1cdbd2cSJim Jagielski //
843*b1cdbd2cSJim Jagielski // SET_WRONG( nPos, nCnt, bMove )
844*b1cdbd2cSJim Jagielski //
845*b1cdbd2cSJim Jagielski #define SET_WRONG( nPos, nCnt, bMove ) \
846*b1cdbd2cSJim Jagielski { \
847*b1cdbd2cSJim Jagielski lcl_SetWrong( *this, nPos, nCnt, bMove ); \
848*b1cdbd2cSJim Jagielski }
849*b1cdbd2cSJim Jagielski
lcl_SetWrong(SwTxtFrm & rFrm,xub_StrLen nPos,long nCnt,bool bMove)850*b1cdbd2cSJim Jagielski void lcl_SetWrong( SwTxtFrm& rFrm, xub_StrLen nPos, long nCnt, bool bMove )
851*b1cdbd2cSJim Jagielski {
852*b1cdbd2cSJim Jagielski if ( !rFrm.IsFollow() )
853*b1cdbd2cSJim Jagielski {
854*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNode = rFrm.GetTxtNode();
855*b1cdbd2cSJim Jagielski IGrammarContact* pGrammarContact = getGrammarContact( *pTxtNode );
856*b1cdbd2cSJim Jagielski SwGrammarMarkUp* pWrongGrammar = pGrammarContact ?
857*b1cdbd2cSJim Jagielski pGrammarContact->getGrammarCheck( *pTxtNode, false ) :
858*b1cdbd2cSJim Jagielski pTxtNode->GetGrammarCheck();
859*b1cdbd2cSJim Jagielski bool bGrammarProxy = pWrongGrammar != pTxtNode->GetGrammarCheck();
860*b1cdbd2cSJim Jagielski if( bMove )
861*b1cdbd2cSJim Jagielski {
862*b1cdbd2cSJim Jagielski if( pTxtNode->GetWrong() )
863*b1cdbd2cSJim Jagielski pTxtNode->GetWrong()->Move( nPos, nCnt );
864*b1cdbd2cSJim Jagielski if( pWrongGrammar )
865*b1cdbd2cSJim Jagielski pWrongGrammar->MoveGrammar( nPos, nCnt );
866*b1cdbd2cSJim Jagielski if( bGrammarProxy && pTxtNode->GetGrammarCheck() )
867*b1cdbd2cSJim Jagielski pTxtNode->GetGrammarCheck()->MoveGrammar( nPos, nCnt );
868*b1cdbd2cSJim Jagielski if( pTxtNode->GetSmartTags() )
869*b1cdbd2cSJim Jagielski pTxtNode->GetSmartTags()->Move( nPos, nCnt );
870*b1cdbd2cSJim Jagielski }
871*b1cdbd2cSJim Jagielski else
872*b1cdbd2cSJim Jagielski {
873*b1cdbd2cSJim Jagielski xub_StrLen nLen = (xub_StrLen)nCnt;
874*b1cdbd2cSJim Jagielski if( pTxtNode->GetWrong() )
875*b1cdbd2cSJim Jagielski pTxtNode->GetWrong()->Invalidate( nPos, nLen );
876*b1cdbd2cSJim Jagielski if( pWrongGrammar )
877*b1cdbd2cSJim Jagielski pWrongGrammar->Invalidate( nPos, nLen );
878*b1cdbd2cSJim Jagielski if( pTxtNode->GetSmartTags() )
879*b1cdbd2cSJim Jagielski pTxtNode->GetSmartTags()->Invalidate( nPos, nLen );
880*b1cdbd2cSJim Jagielski }
881*b1cdbd2cSJim Jagielski if ( !pTxtNode->GetWrong() && !pTxtNode->IsWrongDirty() )
882*b1cdbd2cSJim Jagielski {
883*b1cdbd2cSJim Jagielski pTxtNode->SetWrong( new SwWrongList( WRONGLIST_SPELL ) );
884*b1cdbd2cSJim Jagielski pTxtNode->GetWrong()->SetInvalid( nPos, nPos + (sal_uInt16)( nCnt > 0 ? nCnt : 1 ) );
885*b1cdbd2cSJim Jagielski }
886*b1cdbd2cSJim Jagielski if ( !pTxtNode->GetSmartTags() && !pTxtNode->IsSmartTagDirty() )
887*b1cdbd2cSJim Jagielski {
888*b1cdbd2cSJim Jagielski // SMARTTAGS
889*b1cdbd2cSJim Jagielski pTxtNode->SetSmartTags( new SwWrongList( WRONGLIST_SMARTTAG ) );
890*b1cdbd2cSJim Jagielski pTxtNode->GetSmartTags()->SetInvalid( nPos, nPos + (sal_uInt16)( nCnt > 0 ? nCnt : 1 ) );
891*b1cdbd2cSJim Jagielski }
892*b1cdbd2cSJim Jagielski pTxtNode->SetWrongDirty( true );
893*b1cdbd2cSJim Jagielski pTxtNode->SetGrammarCheckDirty( true );
894*b1cdbd2cSJim Jagielski pTxtNode->SetWordCountDirty( true );
895*b1cdbd2cSJim Jagielski pTxtNode->SetAutoCompleteWordDirty( true );
896*b1cdbd2cSJim Jagielski // SMARTTAGS
897*b1cdbd2cSJim Jagielski pTxtNode->SetSmartTagDirty( true );
898*b1cdbd2cSJim Jagielski }
899*b1cdbd2cSJim Jagielski
900*b1cdbd2cSJim Jagielski SwRootFrm *pRootFrm = rFrm.getRootFrm();
901*b1cdbd2cSJim Jagielski if (pRootFrm)
902*b1cdbd2cSJim Jagielski {
903*b1cdbd2cSJim Jagielski pRootFrm->SetNeedGrammarCheck( sal_True );
904*b1cdbd2cSJim Jagielski }
905*b1cdbd2cSJim Jagielski
906*b1cdbd2cSJim Jagielski SwPageFrm *pPage = rFrm.FindPageFrm();
907*b1cdbd2cSJim Jagielski if( pPage )
908*b1cdbd2cSJim Jagielski {
909*b1cdbd2cSJim Jagielski pPage->InvalidateSpelling();
910*b1cdbd2cSJim Jagielski pPage->InvalidateAutoCompleteWords();
911*b1cdbd2cSJim Jagielski pPage->InvalidateWordCount();
912*b1cdbd2cSJim Jagielski pPage->InvalidateSmartTags();
913*b1cdbd2cSJim Jagielski }
914*b1cdbd2cSJim Jagielski }
915*b1cdbd2cSJim Jagielski
916*b1cdbd2cSJim Jagielski //
917*b1cdbd2cSJim Jagielski // SET_SCRIPT_INVAL( nPos )
918*b1cdbd2cSJim Jagielski //
919*b1cdbd2cSJim Jagielski
920*b1cdbd2cSJim Jagielski #define SET_SCRIPT_INVAL( nPos )\
921*b1cdbd2cSJim Jagielski lcl_SetScriptInval( *this, nPos );
922*b1cdbd2cSJim Jagielski
lcl_SetScriptInval(SwTxtFrm & rFrm,xub_StrLen nPos)923*b1cdbd2cSJim Jagielski void lcl_SetScriptInval( SwTxtFrm& rFrm, xub_StrLen nPos )
924*b1cdbd2cSJim Jagielski {
925*b1cdbd2cSJim Jagielski if( rFrm.GetPara() )
926*b1cdbd2cSJim Jagielski rFrm.GetPara()->GetScriptInfo().SetInvalidity( nPos );
927*b1cdbd2cSJim Jagielski }
928*b1cdbd2cSJim Jagielski
lcl_ModifyOfst(SwTxtFrm * pFrm,xub_StrLen nPos,xub_StrLen nLen)929*b1cdbd2cSJim Jagielski void lcl_ModifyOfst( SwTxtFrm* pFrm, xub_StrLen nPos, xub_StrLen nLen )
930*b1cdbd2cSJim Jagielski {
931*b1cdbd2cSJim Jagielski while( pFrm && pFrm->GetOfst() <= nPos )
932*b1cdbd2cSJim Jagielski pFrm = pFrm->GetFollow();
933*b1cdbd2cSJim Jagielski while( pFrm )
934*b1cdbd2cSJim Jagielski {
935*b1cdbd2cSJim Jagielski pFrm->ManipOfst( pFrm->GetOfst() + nLen );
936*b1cdbd2cSJim Jagielski pFrm = pFrm->GetFollow();
937*b1cdbd2cSJim Jagielski }
938*b1cdbd2cSJim Jagielski }
939*b1cdbd2cSJim Jagielski
940*b1cdbd2cSJim Jagielski /*************************************************************************
941*b1cdbd2cSJim Jagielski * SwTxtFrm::Modify()
942*b1cdbd2cSJim Jagielski *************************************************************************/
943*b1cdbd2cSJim Jagielski
Modify(const SfxPoolItem * pOld,const SfxPoolItem * pNew)944*b1cdbd2cSJim Jagielski void SwTxtFrm::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew )
945*b1cdbd2cSJim Jagielski {
946*b1cdbd2cSJim Jagielski const MSHORT nWhich = pOld ? pOld->Which() : pNew ? pNew->Which() : 0;
947*b1cdbd2cSJim Jagielski
948*b1cdbd2cSJim Jagielski //Wuensche die FrmAttribute betreffen werden von der Basisklasse
949*b1cdbd2cSJim Jagielski //verarbeitet.
950*b1cdbd2cSJim Jagielski if( IsInRange( aFrmFmtSetRange, nWhich ) || RES_FMT_CHG == nWhich )
951*b1cdbd2cSJim Jagielski {
952*b1cdbd2cSJim Jagielski SwCntntFrm::Modify( pOld, pNew );
953*b1cdbd2cSJim Jagielski if( nWhich == RES_FMT_CHG && getRootFrm()->GetCurrShell() )
954*b1cdbd2cSJim Jagielski {
955*b1cdbd2cSJim Jagielski // Collection hat sich geaendert
956*b1cdbd2cSJim Jagielski Prepare( PREP_CLEAR );
957*b1cdbd2cSJim Jagielski _InvalidatePrt();
958*b1cdbd2cSJim Jagielski SET_WRONG( 0, STRING_LEN, false );
959*b1cdbd2cSJim Jagielski SetDerivedR2L( sal_False );
960*b1cdbd2cSJim Jagielski CheckDirChange();
961*b1cdbd2cSJim Jagielski // OD 09.12.2002 #105576# - Force complete paint due to existing
962*b1cdbd2cSJim Jagielski // indents.
963*b1cdbd2cSJim Jagielski SetCompletePaint();
964*b1cdbd2cSJim Jagielski InvalidateLineNum();
965*b1cdbd2cSJim Jagielski }
966*b1cdbd2cSJim Jagielski return;
967*b1cdbd2cSJim Jagielski }
968*b1cdbd2cSJim Jagielski
969*b1cdbd2cSJim Jagielski // Im gelockten Zustand werden keine Bestellungen angenommen.
970*b1cdbd2cSJim Jagielski if( IsLocked() )
971*b1cdbd2cSJim Jagielski return;
972*b1cdbd2cSJim Jagielski
973*b1cdbd2cSJim Jagielski // Dies spart Stack, man muss nur aufpassen,
974*b1cdbd2cSJim Jagielski // dass sie Variablen gesetzt werden.
975*b1cdbd2cSJim Jagielski xub_StrLen nPos, nLen;
976*b1cdbd2cSJim Jagielski sal_Bool bSetFldsDirty = sal_False;
977*b1cdbd2cSJim Jagielski sal_Bool bRecalcFtnFlag = sal_False;
978*b1cdbd2cSJim Jagielski
979*b1cdbd2cSJim Jagielski switch( nWhich )
980*b1cdbd2cSJim Jagielski {
981*b1cdbd2cSJim Jagielski case RES_LINENUMBER:
982*b1cdbd2cSJim Jagielski {
983*b1cdbd2cSJim Jagielski InvalidateLineNum();
984*b1cdbd2cSJim Jagielski }
985*b1cdbd2cSJim Jagielski break;
986*b1cdbd2cSJim Jagielski case RES_INS_TXT:
987*b1cdbd2cSJim Jagielski {
988*b1cdbd2cSJim Jagielski nPos = ((SwInsTxt*)pNew)->nPos;
989*b1cdbd2cSJim Jagielski nLen = ((SwInsTxt*)pNew)->nLen;
990*b1cdbd2cSJim Jagielski if( IsIdxInside( nPos, nLen ) )
991*b1cdbd2cSJim Jagielski {
992*b1cdbd2cSJim Jagielski if( !nLen )
993*b1cdbd2cSJim Jagielski {
994*b1cdbd2cSJim Jagielski // 6969: Aktualisierung der NumPortions auch bei leeren Zeilen!
995*b1cdbd2cSJim Jagielski if( nPos )
996*b1cdbd2cSJim Jagielski InvalidateSize();
997*b1cdbd2cSJim Jagielski else
998*b1cdbd2cSJim Jagielski Prepare( PREP_CLEAR );
999*b1cdbd2cSJim Jagielski }
1000*b1cdbd2cSJim Jagielski else
1001*b1cdbd2cSJim Jagielski _InvalidateRange( SwCharRange( nPos, nLen ), nLen );
1002*b1cdbd2cSJim Jagielski }
1003*b1cdbd2cSJim Jagielski SET_WRONG( nPos, nLen, true )
1004*b1cdbd2cSJim Jagielski SET_SCRIPT_INVAL( nPos )
1005*b1cdbd2cSJim Jagielski bSetFldsDirty = sal_True;
1006*b1cdbd2cSJim Jagielski if( HasFollow() )
1007*b1cdbd2cSJim Jagielski lcl_ModifyOfst( this, nPos, nLen );
1008*b1cdbd2cSJim Jagielski }
1009*b1cdbd2cSJim Jagielski break;
1010*b1cdbd2cSJim Jagielski case RES_DEL_CHR:
1011*b1cdbd2cSJim Jagielski {
1012*b1cdbd2cSJim Jagielski nPos = ((SwDelChr*)pNew)->nPos;
1013*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nPos, 1 ), -1 );
1014*b1cdbd2cSJim Jagielski SET_WRONG( nPos, -1, true )
1015*b1cdbd2cSJim Jagielski SET_SCRIPT_INVAL( nPos )
1016*b1cdbd2cSJim Jagielski bSetFldsDirty = bRecalcFtnFlag = sal_True;
1017*b1cdbd2cSJim Jagielski if( HasFollow() )
1018*b1cdbd2cSJim Jagielski lcl_ModifyOfst( this, nPos, STRING_LEN );
1019*b1cdbd2cSJim Jagielski }
1020*b1cdbd2cSJim Jagielski break;
1021*b1cdbd2cSJim Jagielski case RES_DEL_TXT:
1022*b1cdbd2cSJim Jagielski {
1023*b1cdbd2cSJim Jagielski nPos = ((SwDelTxt*)pNew)->nStart;
1024*b1cdbd2cSJim Jagielski nLen = ((SwDelTxt*)pNew)->nLen;
1025*b1cdbd2cSJim Jagielski long m = nLen;
1026*b1cdbd2cSJim Jagielski m *= -1;
1027*b1cdbd2cSJim Jagielski if( IsIdxInside( nPos, nLen ) )
1028*b1cdbd2cSJim Jagielski {
1029*b1cdbd2cSJim Jagielski if( !nLen )
1030*b1cdbd2cSJim Jagielski InvalidateSize();
1031*b1cdbd2cSJim Jagielski else
1032*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nPos, 1 ), m );
1033*b1cdbd2cSJim Jagielski }
1034*b1cdbd2cSJim Jagielski SET_WRONG( nPos, m, true )
1035*b1cdbd2cSJim Jagielski SET_SCRIPT_INVAL( nPos )
1036*b1cdbd2cSJim Jagielski bSetFldsDirty = bRecalcFtnFlag = sal_True;
1037*b1cdbd2cSJim Jagielski if( HasFollow() )
1038*b1cdbd2cSJim Jagielski lcl_ModifyOfst( this, nPos, nLen );
1039*b1cdbd2cSJim Jagielski }
1040*b1cdbd2cSJim Jagielski break;
1041*b1cdbd2cSJim Jagielski case RES_UPDATE_ATTR:
1042*b1cdbd2cSJim Jagielski {
1043*b1cdbd2cSJim Jagielski nPos = ((SwUpdateAttr*)pNew)->nStart;
1044*b1cdbd2cSJim Jagielski nLen = ((SwUpdateAttr*)pNew)->nEnd - nPos;
1045*b1cdbd2cSJim Jagielski if( IsIdxInside( nPos, nLen ) )
1046*b1cdbd2cSJim Jagielski {
1047*b1cdbd2cSJim Jagielski // Es muss in jedem Fall neu formatiert werden,
1048*b1cdbd2cSJim Jagielski // auch wenn der invalidierte Bereich null ist.
1049*b1cdbd2cSJim Jagielski // Beispiel: leere Zeile, 14Pt einstellen !
1050*b1cdbd2cSJim Jagielski // if( !nLen ) nLen = 1;
1051*b1cdbd2cSJim Jagielski
1052*b1cdbd2cSJim Jagielski // 6680: FtnNummern muessen formatiert werden.
1053*b1cdbd2cSJim Jagielski if( !nLen )
1054*b1cdbd2cSJim Jagielski nLen = 1;
1055*b1cdbd2cSJim Jagielski
1056*b1cdbd2cSJim Jagielski _InvalidateRange( SwCharRange( nPos, nLen) );
1057*b1cdbd2cSJim Jagielski MSHORT nTmp = ((SwUpdateAttr*)pNew)->nWhichAttr;
1058*b1cdbd2cSJim Jagielski
1059*b1cdbd2cSJim Jagielski if( ! nTmp || RES_TXTATR_CHARFMT == nTmp || RES_TXTATR_AUTOFMT == nTmp ||
1060*b1cdbd2cSJim Jagielski RES_FMT_CHG == nTmp || RES_ATTRSET_CHG == nTmp )
1061*b1cdbd2cSJim Jagielski {
1062*b1cdbd2cSJim Jagielski SET_WRONG( nPos, nPos + nLen, false )
1063*b1cdbd2cSJim Jagielski SET_SCRIPT_INVAL( nPos )
1064*b1cdbd2cSJim Jagielski }
1065*b1cdbd2cSJim Jagielski }
1066*b1cdbd2cSJim Jagielski
1067*b1cdbd2cSJim Jagielski // --> OD 2010-02-16 #i104008#
1068*b1cdbd2cSJim Jagielski ViewShell* pViewSh = getRootFrm() ? getRootFrm()->GetCurrShell() : 0;
1069*b1cdbd2cSJim Jagielski if ( pViewSh )
1070*b1cdbd2cSJim Jagielski {
1071*b1cdbd2cSJim Jagielski pViewSh->InvalidateAccessibleParaAttrs( *this );
1072*b1cdbd2cSJim Jagielski }
1073*b1cdbd2cSJim Jagielski // <--
1074*b1cdbd2cSJim Jagielski }
1075*b1cdbd2cSJim Jagielski break;
1076*b1cdbd2cSJim Jagielski case RES_OBJECTDYING:
1077*b1cdbd2cSJim Jagielski break;
1078*b1cdbd2cSJim Jagielski
1079*b1cdbd2cSJim Jagielski case RES_PARATR_LINESPACING:
1080*b1cdbd2cSJim Jagielski {
1081*b1cdbd2cSJim Jagielski CalcLineSpace();
1082*b1cdbd2cSJim Jagielski InvalidateSize();
1083*b1cdbd2cSJim Jagielski _InvalidatePrt();
1084*b1cdbd2cSJim Jagielski if( IsInSct() && !GetPrev() )
1085*b1cdbd2cSJim Jagielski {
1086*b1cdbd2cSJim Jagielski SwSectionFrm *pSect = FindSctFrm();
1087*b1cdbd2cSJim Jagielski if( pSect->ContainsAny() == this )
1088*b1cdbd2cSJim Jagielski pSect->InvalidatePrt();
1089*b1cdbd2cSJim Jagielski }
1090*b1cdbd2cSJim Jagielski
1091*b1cdbd2cSJim Jagielski // OD 09.01.2004 #i11859# - correction:
1092*b1cdbd2cSJim Jagielski // (1) Also invalidate next frame on next page/column.
1093*b1cdbd2cSJim Jagielski // (2) Skip empty sections and hidden paragraphs
1094*b1cdbd2cSJim Jagielski // Thus, use method <InvalidateNextPrtArea()>
1095*b1cdbd2cSJim Jagielski InvalidateNextPrtArea();
1096*b1cdbd2cSJim Jagielski
1097*b1cdbd2cSJim Jagielski SetCompletePaint();
1098*b1cdbd2cSJim Jagielski }
1099*b1cdbd2cSJim Jagielski break;
1100*b1cdbd2cSJim Jagielski
1101*b1cdbd2cSJim Jagielski case RES_TXTATR_FIELD:
1102*b1cdbd2cSJim Jagielski case RES_TXTATR_ANNOTATION:
1103*b1cdbd2cSJim Jagielski {
1104*b1cdbd2cSJim Jagielski nPos = *((SwFmtFld*)pNew)->GetTxtFld()->GetStart();
1105*b1cdbd2cSJim Jagielski if( IsIdxInside( nPos, 1 ) )
1106*b1cdbd2cSJim Jagielski {
1107*b1cdbd2cSJim Jagielski if( pNew == pOld )
1108*b1cdbd2cSJim Jagielski {
1109*b1cdbd2cSJim Jagielski // Nur repainten
1110*b1cdbd2cSJim Jagielski // opt: invalidate aufs Window ?
1111*b1cdbd2cSJim Jagielski InvalidatePage();
1112*b1cdbd2cSJim Jagielski SetCompletePaint();
1113*b1cdbd2cSJim Jagielski }
1114*b1cdbd2cSJim Jagielski else
1115*b1cdbd2cSJim Jagielski _InvalidateRange( SwCharRange( nPos, 1 ) );
1116*b1cdbd2cSJim Jagielski }
1117*b1cdbd2cSJim Jagielski bSetFldsDirty = sal_True;
1118*b1cdbd2cSJim Jagielski // ST2
1119*b1cdbd2cSJim Jagielski if ( SwSmartTagMgr::Get().IsSmartTagsEnabled() )
1120*b1cdbd2cSJim Jagielski SET_WRONG( nPos, nPos + 1, false )
1121*b1cdbd2cSJim Jagielski }
1122*b1cdbd2cSJim Jagielski break;
1123*b1cdbd2cSJim Jagielski
1124*b1cdbd2cSJim Jagielski case RES_TXTATR_FTN :
1125*b1cdbd2cSJim Jagielski {
1126*b1cdbd2cSJim Jagielski nPos = *((SwFmtFtn*)pNew)->GetTxtFtn()->GetStart();
1127*b1cdbd2cSJim Jagielski if( IsInFtn() || IsIdxInside( nPos, 1 ) )
1128*b1cdbd2cSJim Jagielski Prepare( PREP_FTN, ((SwFmtFtn*)pNew)->GetTxtFtn() );
1129*b1cdbd2cSJim Jagielski break;
1130*b1cdbd2cSJim Jagielski }
1131*b1cdbd2cSJim Jagielski
1132*b1cdbd2cSJim Jagielski case RES_ATTRSET_CHG:
1133*b1cdbd2cSJim Jagielski {
1134*b1cdbd2cSJim Jagielski InvalidateLineNum();
1135*b1cdbd2cSJim Jagielski
1136*b1cdbd2cSJim Jagielski SwAttrSet& rNewSet = *((SwAttrSetChg*)pNew)->GetChgSet();
1137*b1cdbd2cSJim Jagielski const SfxPoolItem* pItem = 0;
1138*b1cdbd2cSJim Jagielski int nClear = 0;
1139*b1cdbd2cSJim Jagielski MSHORT nCount = rNewSet.Count();
1140*b1cdbd2cSJim Jagielski
1141*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == rNewSet.GetItemState( RES_TXTATR_FTN, sal_False, &pItem ))
1142*b1cdbd2cSJim Jagielski {
1143*b1cdbd2cSJim Jagielski nPos = *((SwFmtFtn*)pItem)->GetTxtFtn()->GetStart();
1144*b1cdbd2cSJim Jagielski if( IsIdxInside( nPos, 1 ) )
1145*b1cdbd2cSJim Jagielski Prepare( PREP_FTN, pNew );
1146*b1cdbd2cSJim Jagielski nClear = 0x01;
1147*b1cdbd2cSJim Jagielski --nCount;
1148*b1cdbd2cSJim Jagielski }
1149*b1cdbd2cSJim Jagielski
1150*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == rNewSet.GetItemState( RES_TXTATR_FIELD, sal_False, &pItem ))
1151*b1cdbd2cSJim Jagielski {
1152*b1cdbd2cSJim Jagielski nPos = *((SwFmtFld*)pItem)->GetTxtFld()->GetStart();
1153*b1cdbd2cSJim Jagielski if( IsIdxInside( nPos, 1 ) )
1154*b1cdbd2cSJim Jagielski {
1155*b1cdbd2cSJim Jagielski const SfxPoolItem& rOldItem =
1156*b1cdbd2cSJim Jagielski ((SwAttrSetChg*)pOld)->GetChgSet()->Get( RES_TXTATR_FIELD );
1157*b1cdbd2cSJim Jagielski if( pItem == &rOldItem )
1158*b1cdbd2cSJim Jagielski {
1159*b1cdbd2cSJim Jagielski InvalidatePage();
1160*b1cdbd2cSJim Jagielski SetCompletePaint();
1161*b1cdbd2cSJim Jagielski }
1162*b1cdbd2cSJim Jagielski else
1163*b1cdbd2cSJim Jagielski _InvalidateRange( SwCharRange( nPos, 1 ) );
1164*b1cdbd2cSJim Jagielski }
1165*b1cdbd2cSJim Jagielski nClear |= 0x02;
1166*b1cdbd2cSJim Jagielski --nCount;
1167*b1cdbd2cSJim Jagielski }
1168*b1cdbd2cSJim Jagielski sal_Bool bLineSpace = SFX_ITEM_SET == rNewSet.GetItemState(
1169*b1cdbd2cSJim Jagielski RES_PARATR_LINESPACING, sal_False ),
1170*b1cdbd2cSJim Jagielski bRegister = SFX_ITEM_SET == rNewSet.GetItemState(
1171*b1cdbd2cSJim Jagielski RES_PARATR_REGISTER, sal_False );
1172*b1cdbd2cSJim Jagielski if ( bLineSpace || bRegister )
1173*b1cdbd2cSJim Jagielski {
1174*b1cdbd2cSJim Jagielski Prepare( bRegister ? PREP_REGISTER : PREP_ADJUST_FRM );
1175*b1cdbd2cSJim Jagielski CalcLineSpace();
1176*b1cdbd2cSJim Jagielski InvalidateSize();
1177*b1cdbd2cSJim Jagielski _InvalidatePrt();
1178*b1cdbd2cSJim Jagielski
1179*b1cdbd2cSJim Jagielski // OD 09.01.2004 #i11859# - correction:
1180*b1cdbd2cSJim Jagielski // (1) Also invalidate next frame on next page/column.
1181*b1cdbd2cSJim Jagielski // (2) Skip empty sections and hidden paragraphs
1182*b1cdbd2cSJim Jagielski // Thus, use method <InvalidateNextPrtArea()>
1183*b1cdbd2cSJim Jagielski InvalidateNextPrtArea();
1184*b1cdbd2cSJim Jagielski
1185*b1cdbd2cSJim Jagielski SetCompletePaint();
1186*b1cdbd2cSJim Jagielski nClear |= 0x04;
1187*b1cdbd2cSJim Jagielski if ( bLineSpace )
1188*b1cdbd2cSJim Jagielski {
1189*b1cdbd2cSJim Jagielski --nCount;
1190*b1cdbd2cSJim Jagielski if( IsInSct() && !GetPrev() )
1191*b1cdbd2cSJim Jagielski {
1192*b1cdbd2cSJim Jagielski SwSectionFrm *pSect = FindSctFrm();
1193*b1cdbd2cSJim Jagielski if( pSect->ContainsAny() == this )
1194*b1cdbd2cSJim Jagielski pSect->InvalidatePrt();
1195*b1cdbd2cSJim Jagielski }
1196*b1cdbd2cSJim Jagielski }
1197*b1cdbd2cSJim Jagielski if ( bRegister )
1198*b1cdbd2cSJim Jagielski --nCount;
1199*b1cdbd2cSJim Jagielski }
1200*b1cdbd2cSJim Jagielski if ( SFX_ITEM_SET == rNewSet.GetItemState( RES_PARATR_SPLIT,
1201*b1cdbd2cSJim Jagielski sal_False ))
1202*b1cdbd2cSJim Jagielski {
1203*b1cdbd2cSJim Jagielski if ( GetPrev() )
1204*b1cdbd2cSJim Jagielski CheckKeep();
1205*b1cdbd2cSJim Jagielski Prepare( PREP_CLEAR );
1206*b1cdbd2cSJim Jagielski InvalidateSize();
1207*b1cdbd2cSJim Jagielski nClear |= 0x08;
1208*b1cdbd2cSJim Jagielski --nCount;
1209*b1cdbd2cSJim Jagielski }
1210*b1cdbd2cSJim Jagielski
1211*b1cdbd2cSJim Jagielski if( SFX_ITEM_SET == rNewSet.GetItemState( RES_BACKGROUND, sal_False)
1212*b1cdbd2cSJim Jagielski && !IsFollow() && GetDrawObjs() )
1213*b1cdbd2cSJim Jagielski {
1214*b1cdbd2cSJim Jagielski SwSortedObjs *pObjs = GetDrawObjs();
1215*b1cdbd2cSJim Jagielski for ( int i = 0; GetDrawObjs() && i < int(pObjs->Count()); ++i )
1216*b1cdbd2cSJim Jagielski {
1217*b1cdbd2cSJim Jagielski SwAnchoredObject* pAnchoredObj = (*pObjs)[MSHORT(i)];
1218*b1cdbd2cSJim Jagielski if ( pAnchoredObj->ISA(SwFlyFrm) )
1219*b1cdbd2cSJim Jagielski {
1220*b1cdbd2cSJim Jagielski SwFlyFrm *pFly = static_cast<SwFlyFrm*>(pAnchoredObj);
1221*b1cdbd2cSJim Jagielski if( !pFly->IsFlyInCntFrm() )
1222*b1cdbd2cSJim Jagielski {
1223*b1cdbd2cSJim Jagielski const SvxBrushItem &rBack =
1224*b1cdbd2cSJim Jagielski pFly->GetAttrSet()->GetBackground();
1225*b1cdbd2cSJim Jagielski // OD 20.08.2002 #99657# #GetTransChg#
1226*b1cdbd2cSJim Jagielski // following condition determines, if the fly frame
1227*b1cdbd2cSJim Jagielski // "inherites" the background color of text frame.
1228*b1cdbd2cSJim Jagielski // This is the case, if fly frame background
1229*b1cdbd2cSJim Jagielski // color is "no fill"/"auto fill" and if the fly frame
1230*b1cdbd2cSJim Jagielski // has no background graphic.
1231*b1cdbd2cSJim Jagielski // Thus, check complete fly frame background
1232*b1cdbd2cSJim Jagielski // color and *not* only its transparency value
1233*b1cdbd2cSJim Jagielski if ( (rBack.GetColor() == COL_TRANSPARENT) &&
1234*b1cdbd2cSJim Jagielski //if( rBack.GetColor().GetTransparency() &&
1235*b1cdbd2cSJim Jagielski rBack.GetGraphicPos() == GPOS_NONE )
1236*b1cdbd2cSJim Jagielski {
1237*b1cdbd2cSJim Jagielski pFly->SetCompletePaint();
1238*b1cdbd2cSJim Jagielski pFly->InvalidatePage();
1239*b1cdbd2cSJim Jagielski }
1240*b1cdbd2cSJim Jagielski }
1241*b1cdbd2cSJim Jagielski }
1242*b1cdbd2cSJim Jagielski }
1243*b1cdbd2cSJim Jagielski }
1244*b1cdbd2cSJim Jagielski
1245*b1cdbd2cSJim Jagielski if ( SFX_ITEM_SET ==
1246*b1cdbd2cSJim Jagielski rNewSet.GetItemState( RES_TXTATR_CHARFMT, sal_False ) )
1247*b1cdbd2cSJim Jagielski {
1248*b1cdbd2cSJim Jagielski SET_WRONG( 0, STRING_LEN, false )
1249*b1cdbd2cSJim Jagielski SET_SCRIPT_INVAL( 0 )
1250*b1cdbd2cSJim Jagielski }
1251*b1cdbd2cSJim Jagielski else if ( SFX_ITEM_SET ==
1252*b1cdbd2cSJim Jagielski rNewSet.GetItemState( RES_CHRATR_LANGUAGE, sal_False ) ||
1253*b1cdbd2cSJim Jagielski SFX_ITEM_SET ==
1254*b1cdbd2cSJim Jagielski rNewSet.GetItemState( RES_CHRATR_CJK_LANGUAGE, sal_False ) ||
1255*b1cdbd2cSJim Jagielski SFX_ITEM_SET ==
1256*b1cdbd2cSJim Jagielski rNewSet.GetItemState( RES_CHRATR_CTL_LANGUAGE, sal_False ) )
1257*b1cdbd2cSJim Jagielski SET_WRONG( 0, STRING_LEN, false )
1258*b1cdbd2cSJim Jagielski else if ( SFX_ITEM_SET ==
1259*b1cdbd2cSJim Jagielski rNewSet.GetItemState( RES_CHRATR_FONT, sal_False ) ||
1260*b1cdbd2cSJim Jagielski SFX_ITEM_SET ==
1261*b1cdbd2cSJim Jagielski rNewSet.GetItemState( RES_CHRATR_CJK_FONT, sal_False ) ||
1262*b1cdbd2cSJim Jagielski SFX_ITEM_SET ==
1263*b1cdbd2cSJim Jagielski rNewSet.GetItemState( RES_CHRATR_CTL_FONT, sal_False ) )
1264*b1cdbd2cSJim Jagielski SET_SCRIPT_INVAL( 0 )
1265*b1cdbd2cSJim Jagielski else if ( SFX_ITEM_SET ==
1266*b1cdbd2cSJim Jagielski rNewSet.GetItemState( RES_FRAMEDIR, sal_False ) )
1267*b1cdbd2cSJim Jagielski {
1268*b1cdbd2cSJim Jagielski SetDerivedR2L( sal_False );
1269*b1cdbd2cSJim Jagielski CheckDirChange();
1270*b1cdbd2cSJim Jagielski // OD 09.12.2002 #105576# - Force complete paint due to existing
1271*b1cdbd2cSJim Jagielski // indents.
1272*b1cdbd2cSJim Jagielski SetCompletePaint();
1273*b1cdbd2cSJim Jagielski }
1274*b1cdbd2cSJim Jagielski
1275*b1cdbd2cSJim Jagielski
1276*b1cdbd2cSJim Jagielski if( nCount )
1277*b1cdbd2cSJim Jagielski {
1278*b1cdbd2cSJim Jagielski if( getRootFrm()->GetCurrShell() )
1279*b1cdbd2cSJim Jagielski {
1280*b1cdbd2cSJim Jagielski Prepare( PREP_CLEAR );
1281*b1cdbd2cSJim Jagielski _InvalidatePrt();
1282*b1cdbd2cSJim Jagielski }
1283*b1cdbd2cSJim Jagielski
1284*b1cdbd2cSJim Jagielski if( nClear )
1285*b1cdbd2cSJim Jagielski {
1286*b1cdbd2cSJim Jagielski SwAttrSetChg aOldSet( *(SwAttrSetChg*)pOld );
1287*b1cdbd2cSJim Jagielski SwAttrSetChg aNewSet( *(SwAttrSetChg*)pNew );
1288*b1cdbd2cSJim Jagielski
1289*b1cdbd2cSJim Jagielski if( 0x01 & nClear )
1290*b1cdbd2cSJim Jagielski {
1291*b1cdbd2cSJim Jagielski aOldSet.ClearItem( RES_TXTATR_FTN );
1292*b1cdbd2cSJim Jagielski aNewSet.ClearItem( RES_TXTATR_FTN );
1293*b1cdbd2cSJim Jagielski }
1294*b1cdbd2cSJim Jagielski if( 0x02 & nClear )
1295*b1cdbd2cSJim Jagielski {
1296*b1cdbd2cSJim Jagielski aOldSet.ClearItem( RES_TXTATR_FIELD );
1297*b1cdbd2cSJim Jagielski aNewSet.ClearItem( RES_TXTATR_FIELD );
1298*b1cdbd2cSJim Jagielski }
1299*b1cdbd2cSJim Jagielski if ( 0x04 & nClear )
1300*b1cdbd2cSJim Jagielski {
1301*b1cdbd2cSJim Jagielski if ( bLineSpace )
1302*b1cdbd2cSJim Jagielski {
1303*b1cdbd2cSJim Jagielski aOldSet.ClearItem( RES_PARATR_LINESPACING );
1304*b1cdbd2cSJim Jagielski aNewSet.ClearItem( RES_PARATR_LINESPACING );
1305*b1cdbd2cSJim Jagielski }
1306*b1cdbd2cSJim Jagielski if ( bRegister )
1307*b1cdbd2cSJim Jagielski {
1308*b1cdbd2cSJim Jagielski aOldSet.ClearItem( RES_PARATR_REGISTER );
1309*b1cdbd2cSJim Jagielski aNewSet.ClearItem( RES_PARATR_REGISTER );
1310*b1cdbd2cSJim Jagielski }
1311*b1cdbd2cSJim Jagielski }
1312*b1cdbd2cSJim Jagielski if ( 0x08 & nClear )
1313*b1cdbd2cSJim Jagielski {
1314*b1cdbd2cSJim Jagielski aOldSet.ClearItem( RES_PARATR_SPLIT );
1315*b1cdbd2cSJim Jagielski aNewSet.ClearItem( RES_PARATR_SPLIT );
1316*b1cdbd2cSJim Jagielski }
1317*b1cdbd2cSJim Jagielski SwCntntFrm::Modify( &aOldSet, &aNewSet );
1318*b1cdbd2cSJim Jagielski }
1319*b1cdbd2cSJim Jagielski else
1320*b1cdbd2cSJim Jagielski SwCntntFrm::Modify( pOld, pNew );
1321*b1cdbd2cSJim Jagielski }
1322*b1cdbd2cSJim Jagielski
1323*b1cdbd2cSJim Jagielski // --> OD 2009-01-06 #i88069#
1324*b1cdbd2cSJim Jagielski ViewShell* pViewSh = getRootFrm() ? getRootFrm()->GetCurrShell() : 0;
1325*b1cdbd2cSJim Jagielski if ( pViewSh )
1326*b1cdbd2cSJim Jagielski {
1327*b1cdbd2cSJim Jagielski pViewSh->InvalidateAccessibleParaAttrs( *this );
1328*b1cdbd2cSJim Jagielski }
1329*b1cdbd2cSJim Jagielski // <--
1330*b1cdbd2cSJim Jagielski }
1331*b1cdbd2cSJim Jagielski break;
1332*b1cdbd2cSJim Jagielski
1333*b1cdbd2cSJim Jagielski // 6870: SwDocPosUpdate auswerten.
1334*b1cdbd2cSJim Jagielski case RES_DOCPOS_UPDATE:
1335*b1cdbd2cSJim Jagielski {
1336*b1cdbd2cSJim Jagielski if( pOld && pNew )
1337*b1cdbd2cSJim Jagielski {
1338*b1cdbd2cSJim Jagielski const SwDocPosUpdate *pDocPos = (const SwDocPosUpdate*)pOld;
1339*b1cdbd2cSJim Jagielski if( pDocPos->nDocPos <= aFrm.Top() )
1340*b1cdbd2cSJim Jagielski {
1341*b1cdbd2cSJim Jagielski const SwFmtFld *pFld = (const SwFmtFld *)pNew;
1342*b1cdbd2cSJim Jagielski InvalidateRange(
1343*b1cdbd2cSJim Jagielski SwCharRange( *pFld->GetTxtFld()->GetStart(), 1 ) );
1344*b1cdbd2cSJim Jagielski }
1345*b1cdbd2cSJim Jagielski }
1346*b1cdbd2cSJim Jagielski break;
1347*b1cdbd2cSJim Jagielski }
1348*b1cdbd2cSJim Jagielski case RES_PARATR_SPLIT:
1349*b1cdbd2cSJim Jagielski if ( GetPrev() )
1350*b1cdbd2cSJim Jagielski CheckKeep();
1351*b1cdbd2cSJim Jagielski Prepare( PREP_CLEAR );
1352*b1cdbd2cSJim Jagielski bSetFldsDirty = sal_True;
1353*b1cdbd2cSJim Jagielski break;
1354*b1cdbd2cSJim Jagielski case RES_FRAMEDIR :
1355*b1cdbd2cSJim Jagielski SetDerivedR2L( sal_False );
1356*b1cdbd2cSJim Jagielski CheckDirChange();
1357*b1cdbd2cSJim Jagielski break;
1358*b1cdbd2cSJim Jagielski default:
1359*b1cdbd2cSJim Jagielski {
1360*b1cdbd2cSJim Jagielski Prepare( PREP_CLEAR );
1361*b1cdbd2cSJim Jagielski _InvalidatePrt();
1362*b1cdbd2cSJim Jagielski if ( !nWhich )
1363*b1cdbd2cSJim Jagielski {
1364*b1cdbd2cSJim Jagielski //Wird z.B. bei HiddenPara mit 0 gerufen.
1365*b1cdbd2cSJim Jagielski SwFrm *pNxt;
1366*b1cdbd2cSJim Jagielski if ( 0 != (pNxt = FindNext()) )
1367*b1cdbd2cSJim Jagielski pNxt->InvalidatePrt();
1368*b1cdbd2cSJim Jagielski }
1369*b1cdbd2cSJim Jagielski }
1370*b1cdbd2cSJim Jagielski } // switch
1371*b1cdbd2cSJim Jagielski
1372*b1cdbd2cSJim Jagielski if( bSetFldsDirty )
1373*b1cdbd2cSJim Jagielski GetNode()->getIDocumentFieldsAccess()->SetFieldsDirty( sal_True, GetNode(), 1 );
1374*b1cdbd2cSJim Jagielski
1375*b1cdbd2cSJim Jagielski if ( bRecalcFtnFlag )
1376*b1cdbd2cSJim Jagielski CalcFtnFlag();
1377*b1cdbd2cSJim Jagielski }
1378*b1cdbd2cSJim Jagielski
GetInfo(SfxPoolItem & rHnt) const1379*b1cdbd2cSJim Jagielski sal_Bool SwTxtFrm::GetInfo( SfxPoolItem &rHnt ) const
1380*b1cdbd2cSJim Jagielski {
1381*b1cdbd2cSJim Jagielski if ( RES_VIRTPAGENUM_INFO == rHnt.Which() && IsInDocBody() && ! IsFollow() )
1382*b1cdbd2cSJim Jagielski {
1383*b1cdbd2cSJim Jagielski SwVirtPageNumInfo &rInfo = (SwVirtPageNumInfo&)rHnt;
1384*b1cdbd2cSJim Jagielski const SwPageFrm *pPage = FindPageFrm();
1385*b1cdbd2cSJim Jagielski if ( pPage )
1386*b1cdbd2cSJim Jagielski {
1387*b1cdbd2cSJim Jagielski if ( pPage == rInfo.GetOrigPage() && !GetPrev() )
1388*b1cdbd2cSJim Jagielski {
1389*b1cdbd2cSJim Jagielski //Das sollte er sein (kann allenfalls temporaer anders sein,
1390*b1cdbd2cSJim Jagielski // sollte uns das beunruhigen?)
1391*b1cdbd2cSJim Jagielski rInfo.SetInfo( pPage, this );
1392*b1cdbd2cSJim Jagielski return sal_False;
1393*b1cdbd2cSJim Jagielski }
1394*b1cdbd2cSJim Jagielski if ( pPage->GetPhyPageNum() < rInfo.GetOrigPage()->GetPhyPageNum() &&
1395*b1cdbd2cSJim Jagielski (!rInfo.GetPage() || pPage->GetPhyPageNum() > rInfo.GetPage()->GetPhyPageNum()))
1396*b1cdbd2cSJim Jagielski {
1397*b1cdbd2cSJim Jagielski //Das koennte er sein.
1398*b1cdbd2cSJim Jagielski rInfo.SetInfo( pPage, this );
1399*b1cdbd2cSJim Jagielski }
1400*b1cdbd2cSJim Jagielski }
1401*b1cdbd2cSJim Jagielski }
1402*b1cdbd2cSJim Jagielski return sal_True;
1403*b1cdbd2cSJim Jagielski }
1404*b1cdbd2cSJim Jagielski
1405*b1cdbd2cSJim Jagielski /*************************************************************************
1406*b1cdbd2cSJim Jagielski * SwTxtFrm::PrepWidows()
1407*b1cdbd2cSJim Jagielski *************************************************************************/
1408*b1cdbd2cSJim Jagielski
PrepWidows(const MSHORT nNeed,sal_Bool bNotify)1409*b1cdbd2cSJim Jagielski void SwTxtFrm::PrepWidows( const MSHORT nNeed, sal_Bool bNotify )
1410*b1cdbd2cSJim Jagielski {
1411*b1cdbd2cSJim Jagielski ASSERT(GetFollow() && nNeed, "+SwTxtFrm::Prepare: lost all friends");
1412*b1cdbd2cSJim Jagielski
1413*b1cdbd2cSJim Jagielski SwParaPortion *pPara = GetPara();
1414*b1cdbd2cSJim Jagielski if ( !pPara )
1415*b1cdbd2cSJim Jagielski return;
1416*b1cdbd2cSJim Jagielski pPara->SetPrepWidows( sal_True );
1417*b1cdbd2cSJim Jagielski
1418*b1cdbd2cSJim Jagielski // These two lines of code have been deleted for #102340#.
1419*b1cdbd2cSJim Jagielski // Obviously the widow control does not work if we have a
1420*b1cdbd2cSJim Jagielski // pMaster->pFollow->pFollow situation:
1421*b1cdbd2cSJim Jagielski
1422*b1cdbd2cSJim Jagielski // returnen oder nicht ist hier die Frage.
1423*b1cdbd2cSJim Jagielski // Ohne IsLocked() ist 5156 gefaehrlich,
1424*b1cdbd2cSJim Jagielski // ohne IsFollow() werden die Orphans unterdrueckt: 6968.
1425*b1cdbd2cSJim Jagielski // Abfrage auf IsLocked erst hier, weil das Flag gesetzt werden soll.
1426*b1cdbd2cSJim Jagielski // if( IsLocked() && IsFollow() )
1427*b1cdbd2cSJim Jagielski // return;
1428*b1cdbd2cSJim Jagielski
1429*b1cdbd2cSJim Jagielski MSHORT nHave = nNeed;
1430*b1cdbd2cSJim Jagielski
1431*b1cdbd2cSJim Jagielski // Wir geben ein paar Zeilen ab und schrumpfen im CalcPreps()
1432*b1cdbd2cSJim Jagielski SWAP_IF_NOT_SWAPPED( this )
1433*b1cdbd2cSJim Jagielski
1434*b1cdbd2cSJim Jagielski SwTxtSizeInfo aInf( this );
1435*b1cdbd2cSJim Jagielski SwTxtMargin aLine( this, &aInf );
1436*b1cdbd2cSJim Jagielski aLine.Bottom();
1437*b1cdbd2cSJim Jagielski xub_StrLen nTmpLen = aLine.GetCurr()->GetLen();
1438*b1cdbd2cSJim Jagielski while( nHave && aLine.PrevLine() )
1439*b1cdbd2cSJim Jagielski {
1440*b1cdbd2cSJim Jagielski if( nTmpLen )
1441*b1cdbd2cSJim Jagielski --nHave;
1442*b1cdbd2cSJim Jagielski nTmpLen = aLine.GetCurr()->GetLen();
1443*b1cdbd2cSJim Jagielski }
1444*b1cdbd2cSJim Jagielski // In dieser Ecke tummelten sich einige Bugs: 7513, 7606.
1445*b1cdbd2cSJim Jagielski // Wenn feststeht, dass Zeilen abgegeben werden koennen,
1446*b1cdbd2cSJim Jagielski // muss der Master darueber hinaus die Widow-Regel ueberpruefen.
1447*b1cdbd2cSJim Jagielski if( !nHave )
1448*b1cdbd2cSJim Jagielski {
1449*b1cdbd2cSJim Jagielski sal_Bool bSplit;
1450*b1cdbd2cSJim Jagielski if( !IsFollow() ) //Nur ein Master entscheidet ueber Orphans
1451*b1cdbd2cSJim Jagielski {
1452*b1cdbd2cSJim Jagielski const WidowsAndOrphans aWidOrp( this );
1453*b1cdbd2cSJim Jagielski bSplit = ( aLine.GetLineNr() >= aWidOrp.GetOrphansLines() &&
1454*b1cdbd2cSJim Jagielski aLine.GetLineNr() >= aLine.GetDropLines() );
1455*b1cdbd2cSJim Jagielski }
1456*b1cdbd2cSJim Jagielski else
1457*b1cdbd2cSJim Jagielski bSplit = sal_True;
1458*b1cdbd2cSJim Jagielski
1459*b1cdbd2cSJim Jagielski if( bSplit )
1460*b1cdbd2cSJim Jagielski {
1461*b1cdbd2cSJim Jagielski GetFollow()->SetOfst( aLine.GetEnd() );
1462*b1cdbd2cSJim Jagielski aLine.TruncLines( sal_True );
1463*b1cdbd2cSJim Jagielski if( pPara->IsFollowField() )
1464*b1cdbd2cSJim Jagielski GetFollow()->SetFieldFollow( sal_True );
1465*b1cdbd2cSJim Jagielski }
1466*b1cdbd2cSJim Jagielski }
1467*b1cdbd2cSJim Jagielski if ( bNotify )
1468*b1cdbd2cSJim Jagielski {
1469*b1cdbd2cSJim Jagielski _InvalidateSize();
1470*b1cdbd2cSJim Jagielski InvalidatePage();
1471*b1cdbd2cSJim Jagielski }
1472*b1cdbd2cSJim Jagielski
1473*b1cdbd2cSJim Jagielski UNDO_SWAP( this )
1474*b1cdbd2cSJim Jagielski }
1475*b1cdbd2cSJim Jagielski
1476*b1cdbd2cSJim Jagielski /*************************************************************************
1477*b1cdbd2cSJim Jagielski * SwTxtFrm::Prepare
1478*b1cdbd2cSJim Jagielski *************************************************************************/
1479*b1cdbd2cSJim Jagielski
lcl_ErgoVadis(SwTxtFrm * pFrm,xub_StrLen & rPos,const PrepareHint ePrep)1480*b1cdbd2cSJim Jagielski sal_Bool lcl_ErgoVadis( SwTxtFrm* pFrm, xub_StrLen &rPos, const PrepareHint ePrep )
1481*b1cdbd2cSJim Jagielski {
1482*b1cdbd2cSJim Jagielski const SwFtnInfo &rFtnInfo = pFrm->GetNode()->GetDoc()->GetFtnInfo();
1483*b1cdbd2cSJim Jagielski if( ePrep == PREP_ERGOSUM )
1484*b1cdbd2cSJim Jagielski {
1485*b1cdbd2cSJim Jagielski if( !rFtnInfo.aErgoSum.Len() )
1486*b1cdbd2cSJim Jagielski return sal_False;;
1487*b1cdbd2cSJim Jagielski rPos = pFrm->GetOfst();
1488*b1cdbd2cSJim Jagielski }
1489*b1cdbd2cSJim Jagielski else
1490*b1cdbd2cSJim Jagielski {
1491*b1cdbd2cSJim Jagielski if( !rFtnInfo.aQuoVadis.Len() )
1492*b1cdbd2cSJim Jagielski return sal_False;
1493*b1cdbd2cSJim Jagielski if( pFrm->HasFollow() )
1494*b1cdbd2cSJim Jagielski rPos = pFrm->GetFollow()->GetOfst();
1495*b1cdbd2cSJim Jagielski else
1496*b1cdbd2cSJim Jagielski rPos = pFrm->GetTxt().Len();
1497*b1cdbd2cSJim Jagielski if( rPos )
1498*b1cdbd2cSJim Jagielski --rPos; // unser letztes Zeichen
1499*b1cdbd2cSJim Jagielski }
1500*b1cdbd2cSJim Jagielski return sal_True;
1501*b1cdbd2cSJim Jagielski }
1502*b1cdbd2cSJim Jagielski
Prepare(const PrepareHint ePrep,const void * pVoid,sal_Bool bNotify)1503*b1cdbd2cSJim Jagielski void SwTxtFrm::Prepare( const PrepareHint ePrep, const void* pVoid,
1504*b1cdbd2cSJim Jagielski sal_Bool bNotify )
1505*b1cdbd2cSJim Jagielski {
1506*b1cdbd2cSJim Jagielski SwFrmSwapper aSwapper( this, sal_False );
1507*b1cdbd2cSJim Jagielski
1508*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 1
1509*b1cdbd2cSJim Jagielski const SwTwips nDbgY = Frm().Top();
1510*b1cdbd2cSJim Jagielski (void)nDbgY;
1511*b1cdbd2cSJim Jagielski #endif
1512*b1cdbd2cSJim Jagielski
1513*b1cdbd2cSJim Jagielski if ( IsEmpty() )
1514*b1cdbd2cSJim Jagielski {
1515*b1cdbd2cSJim Jagielski switch ( ePrep )
1516*b1cdbd2cSJim Jagielski {
1517*b1cdbd2cSJim Jagielski case PREP_BOSS_CHGD:
1518*b1cdbd2cSJim Jagielski SetInvalidVert( sal_True ); // Test
1519*b1cdbd2cSJim Jagielski case PREP_WIDOWS_ORPHANS:
1520*b1cdbd2cSJim Jagielski case PREP_WIDOWS:
1521*b1cdbd2cSJim Jagielski case PREP_FTN_GONE : return;
1522*b1cdbd2cSJim Jagielski
1523*b1cdbd2cSJim Jagielski case PREP_POS_CHGD :
1524*b1cdbd2cSJim Jagielski {
1525*b1cdbd2cSJim Jagielski // Auch in (spaltigen) Bereichen ist ein InvalidateSize notwendig,
1526*b1cdbd2cSJim Jagielski // damit formatiert wird und ggf. das bUndersized gesetzt wird.
1527*b1cdbd2cSJim Jagielski if( IsInFly() || IsInSct() )
1528*b1cdbd2cSJim Jagielski {
1529*b1cdbd2cSJim Jagielski SwTwips nTmpBottom = GetUpper()->Frm().Top() +
1530*b1cdbd2cSJim Jagielski GetUpper()->Prt().Bottom();
1531*b1cdbd2cSJim Jagielski if( nTmpBottom < Frm().Bottom() )
1532*b1cdbd2cSJim Jagielski break;
1533*b1cdbd2cSJim Jagielski }
1534*b1cdbd2cSJim Jagielski // Gibt es ueberhaupt Flys auf der Seite ?
1535*b1cdbd2cSJim Jagielski SwTxtFly aTxtFly( this );
1536*b1cdbd2cSJim Jagielski if( aTxtFly.IsOn() )
1537*b1cdbd2cSJim Jagielski {
1538*b1cdbd2cSJim Jagielski // Ueberlappt irgendein Fly ?
1539*b1cdbd2cSJim Jagielski aTxtFly.Relax();
1540*b1cdbd2cSJim Jagielski if ( aTxtFly.IsOn() || IsUndersized() )
1541*b1cdbd2cSJim Jagielski break;
1542*b1cdbd2cSJim Jagielski }
1543*b1cdbd2cSJim Jagielski if( GetTxtNode()->GetSwAttrSet().GetRegister().GetValue())
1544*b1cdbd2cSJim Jagielski break;
1545*b1cdbd2cSJim Jagielski
1546*b1cdbd2cSJim Jagielski GETGRID( FindPageFrm() )
1547*b1cdbd2cSJim Jagielski if ( pGrid && GetTxtNode()->GetSwAttrSet().GetParaGrid().GetValue() )
1548*b1cdbd2cSJim Jagielski break;
1549*b1cdbd2cSJim Jagielski
1550*b1cdbd2cSJim Jagielski // --> OD 2004-07-16 #i28701# - consider anchored objects
1551*b1cdbd2cSJim Jagielski if ( GetDrawObjs() )
1552*b1cdbd2cSJim Jagielski break;
1553*b1cdbd2cSJim Jagielski // <--
1554*b1cdbd2cSJim Jagielski
1555*b1cdbd2cSJim Jagielski return;
1556*b1cdbd2cSJim Jagielski }
1557*b1cdbd2cSJim Jagielski default:
1558*b1cdbd2cSJim Jagielski break;
1559*b1cdbd2cSJim Jagielski }
1560*b1cdbd2cSJim Jagielski }
1561*b1cdbd2cSJim Jagielski
1562*b1cdbd2cSJim Jagielski if( !HasPara() && PREP_MUST_FIT != ePrep )
1563*b1cdbd2cSJim Jagielski {
1564*b1cdbd2cSJim Jagielski SetInvalidVert( sal_True ); // Test
1565*b1cdbd2cSJim Jagielski ASSERT( !IsLocked(), "SwTxtFrm::Prepare: three of a perfect pair" );
1566*b1cdbd2cSJim Jagielski if ( bNotify )
1567*b1cdbd2cSJim Jagielski InvalidateSize();
1568*b1cdbd2cSJim Jagielski else
1569*b1cdbd2cSJim Jagielski _InvalidateSize();
1570*b1cdbd2cSJim Jagielski return;
1571*b1cdbd2cSJim Jagielski }
1572*b1cdbd2cSJim Jagielski
1573*b1cdbd2cSJim Jagielski //Objekt mit Locking aus dem Cache holen.
1574*b1cdbd2cSJim Jagielski SwTxtLineAccess aAccess( this );
1575*b1cdbd2cSJim Jagielski SwParaPortion *pPara = aAccess.GetPara();
1576*b1cdbd2cSJim Jagielski
1577*b1cdbd2cSJim Jagielski switch( ePrep )
1578*b1cdbd2cSJim Jagielski {
1579*b1cdbd2cSJim Jagielski case PREP_MOVEFTN : Frm().Height(0);
1580*b1cdbd2cSJim Jagielski Prt().Height(0);
1581*b1cdbd2cSJim Jagielski _InvalidatePrt();
1582*b1cdbd2cSJim Jagielski _InvalidateSize();
1583*b1cdbd2cSJim Jagielski // KEIN break
1584*b1cdbd2cSJim Jagielski case PREP_ADJUST_FRM : pPara->SetPrepAdjust( sal_True );
1585*b1cdbd2cSJim Jagielski if( IsFtnNumFrm() != pPara->IsFtnNum() ||
1586*b1cdbd2cSJim Jagielski IsUndersized() )
1587*b1cdbd2cSJim Jagielski {
1588*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( 0, 1 ), 1);
1589*b1cdbd2cSJim Jagielski if( GetOfst() && !IsFollow() )
1590*b1cdbd2cSJim Jagielski _SetOfst( 0 );
1591*b1cdbd2cSJim Jagielski }
1592*b1cdbd2cSJim Jagielski break;
1593*b1cdbd2cSJim Jagielski case PREP_MUST_FIT : pPara->SetPrepMustFit( sal_True );
1594*b1cdbd2cSJim Jagielski /* no break here */
1595*b1cdbd2cSJim Jagielski case PREP_WIDOWS_ORPHANS : pPara->SetPrepAdjust( sal_True );
1596*b1cdbd2cSJim Jagielski break;
1597*b1cdbd2cSJim Jagielski
1598*b1cdbd2cSJim Jagielski case PREP_WIDOWS :
1599*b1cdbd2cSJim Jagielski // MustFit ist staerker als alles anderes
1600*b1cdbd2cSJim Jagielski if( pPara->IsPrepMustFit() )
1601*b1cdbd2cSJim Jagielski return;
1602*b1cdbd2cSJim Jagielski // Siehe Kommentar in WidowsAndOrphans::FindOrphans und CalcPreps()
1603*b1cdbd2cSJim Jagielski PrepWidows( *(const MSHORT *)pVoid, bNotify );
1604*b1cdbd2cSJim Jagielski break;
1605*b1cdbd2cSJim Jagielski
1606*b1cdbd2cSJim Jagielski case PREP_FTN :
1607*b1cdbd2cSJim Jagielski {
1608*b1cdbd2cSJim Jagielski SwTxtFtn *pFtn = (SwTxtFtn *)pVoid;
1609*b1cdbd2cSJim Jagielski if( IsInFtn() )
1610*b1cdbd2cSJim Jagielski {
1611*b1cdbd2cSJim Jagielski // Bin ich der erste TxtFrm einer Fussnote ?
1612*b1cdbd2cSJim Jagielski if( !GetPrev() )
1613*b1cdbd2cSJim Jagielski // Wir sind also ein TxtFrm der Fussnote, die
1614*b1cdbd2cSJim Jagielski // die Fussnotenzahl zur Anzeige bringen muss.
1615*b1cdbd2cSJim Jagielski // Oder den ErgoSum-Text...
1616*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( 0, 1 ), 1);
1617*b1cdbd2cSJim Jagielski
1618*b1cdbd2cSJim Jagielski if( !GetNext() )
1619*b1cdbd2cSJim Jagielski {
1620*b1cdbd2cSJim Jagielski // Wir sind der letzte Ftn, jetzt muessten die
1621*b1cdbd2cSJim Jagielski // QuoVadis-Texte geupdated werden.
1622*b1cdbd2cSJim Jagielski const SwFtnInfo &rFtnInfo = GetNode()->GetDoc()->GetFtnInfo();
1623*b1cdbd2cSJim Jagielski if( !pPara->UpdateQuoVadis( rFtnInfo.aQuoVadis ) )
1624*b1cdbd2cSJim Jagielski {
1625*b1cdbd2cSJim Jagielski xub_StrLen nPos = pPara->GetParLen();
1626*b1cdbd2cSJim Jagielski if( nPos )
1627*b1cdbd2cSJim Jagielski --nPos;
1628*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nPos, 1 ), 1);
1629*b1cdbd2cSJim Jagielski }
1630*b1cdbd2cSJim Jagielski }
1631*b1cdbd2cSJim Jagielski }
1632*b1cdbd2cSJim Jagielski else
1633*b1cdbd2cSJim Jagielski {
1634*b1cdbd2cSJim Jagielski // Wir sind also der TxtFrm _mit_ der Fussnote
1635*b1cdbd2cSJim Jagielski const xub_StrLen nPos = *pFtn->GetStart();
1636*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nPos, 1 ), 1);
1637*b1cdbd2cSJim Jagielski }
1638*b1cdbd2cSJim Jagielski break;
1639*b1cdbd2cSJim Jagielski }
1640*b1cdbd2cSJim Jagielski case PREP_BOSS_CHGD :
1641*b1cdbd2cSJim Jagielski {
1642*b1cdbd2cSJim Jagielski // Test
1643*b1cdbd2cSJim Jagielski {
1644*b1cdbd2cSJim Jagielski SetInvalidVert( sal_False );
1645*b1cdbd2cSJim Jagielski sal_Bool bOld = IsVertical();
1646*b1cdbd2cSJim Jagielski SetInvalidVert( sal_True );
1647*b1cdbd2cSJim Jagielski if( bOld != IsVertical() )
1648*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( GetOfst(), STRING_LEN ) );
1649*b1cdbd2cSJim Jagielski }
1650*b1cdbd2cSJim Jagielski
1651*b1cdbd2cSJim Jagielski if( HasFollow() )
1652*b1cdbd2cSJim Jagielski {
1653*b1cdbd2cSJim Jagielski xub_StrLen nNxtOfst = GetFollow()->GetOfst();
1654*b1cdbd2cSJim Jagielski if( nNxtOfst )
1655*b1cdbd2cSJim Jagielski --nNxtOfst;
1656*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nNxtOfst, 1 ), 1);
1657*b1cdbd2cSJim Jagielski }
1658*b1cdbd2cSJim Jagielski if( IsInFtn() )
1659*b1cdbd2cSJim Jagielski {
1660*b1cdbd2cSJim Jagielski xub_StrLen nPos;
1661*b1cdbd2cSJim Jagielski if( lcl_ErgoVadis( this, nPos, PREP_QUOVADIS ) )
1662*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nPos, 1 ), 0 );
1663*b1cdbd2cSJim Jagielski if( lcl_ErgoVadis( this, nPos, PREP_ERGOSUM ) )
1664*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nPos, 1 ), 0 );
1665*b1cdbd2cSJim Jagielski }
1666*b1cdbd2cSJim Jagielski // 4739: Wenn wir ein Seitennummernfeld besitzen, muessen wir
1667*b1cdbd2cSJim Jagielski // die Stellen invalidieren.
1668*b1cdbd2cSJim Jagielski SwpHints *pHints = GetTxtNode()->GetpSwpHints();
1669*b1cdbd2cSJim Jagielski if( pHints )
1670*b1cdbd2cSJim Jagielski {
1671*b1cdbd2cSJim Jagielski const sal_uInt16 nSize = pHints->Count();
1672*b1cdbd2cSJim Jagielski const xub_StrLen nEnd = GetFollow() ?
1673*b1cdbd2cSJim Jagielski GetFollow()->GetOfst() : STRING_LEN;
1674*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < nSize; ++i )
1675*b1cdbd2cSJim Jagielski {
1676*b1cdbd2cSJim Jagielski const SwTxtAttr *pHt = (*pHints)[i];
1677*b1cdbd2cSJim Jagielski const xub_StrLen nStart = *pHt->GetStart();
1678*b1cdbd2cSJim Jagielski if( nStart >= GetOfst() )
1679*b1cdbd2cSJim Jagielski {
1680*b1cdbd2cSJim Jagielski if( nStart >= nEnd )
1681*b1cdbd2cSJim Jagielski i = nSize; // fuehrt das Ende herbei
1682*b1cdbd2cSJim Jagielski else
1683*b1cdbd2cSJim Jagielski {
1684*b1cdbd2cSJim Jagielski // 4029: wenn wir zurueckfliessen und eine Ftn besitzen, so
1685*b1cdbd2cSJim Jagielski // fliesst die Ftn in jedem Fall auch mit. Damit sie nicht im
1686*b1cdbd2cSJim Jagielski // Weg steht, schicken wir uns ein ADJUST_FRM.
1687*b1cdbd2cSJim Jagielski // pVoid != 0 bedeutet MoveBwd()
1688*b1cdbd2cSJim Jagielski const MSHORT nWhich = pHt->Which();
1689*b1cdbd2cSJim Jagielski if( RES_TXTATR_FIELD == nWhich ||
1690*b1cdbd2cSJim Jagielski (HasFtn() && pVoid && RES_TXTATR_FTN == nWhich))
1691*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nStart, 1 ), 1 );
1692*b1cdbd2cSJim Jagielski }
1693*b1cdbd2cSJim Jagielski }
1694*b1cdbd2cSJim Jagielski }
1695*b1cdbd2cSJim Jagielski }
1696*b1cdbd2cSJim Jagielski // A new boss, a new chance for growing
1697*b1cdbd2cSJim Jagielski if( IsUndersized() )
1698*b1cdbd2cSJim Jagielski {
1699*b1cdbd2cSJim Jagielski _InvalidateSize();
1700*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( GetOfst(), 1 ), 1);
1701*b1cdbd2cSJim Jagielski }
1702*b1cdbd2cSJim Jagielski break;
1703*b1cdbd2cSJim Jagielski }
1704*b1cdbd2cSJim Jagielski
1705*b1cdbd2cSJim Jagielski case PREP_POS_CHGD :
1706*b1cdbd2cSJim Jagielski {
1707*b1cdbd2cSJim Jagielski if ( GetValidPrtAreaFlag() )
1708*b1cdbd2cSJim Jagielski {
1709*b1cdbd2cSJim Jagielski GETGRID( FindPageFrm() )
1710*b1cdbd2cSJim Jagielski if ( pGrid && GetTxtNode()->GetSwAttrSet().GetParaGrid().GetValue() )
1711*b1cdbd2cSJim Jagielski InvalidatePrt();
1712*b1cdbd2cSJim Jagielski }
1713*b1cdbd2cSJim Jagielski
1714*b1cdbd2cSJim Jagielski // Falls wir mit niemandem ueberlappen:
1715*b1cdbd2cSJim Jagielski // Ueberlappte irgendein Fly _vor_ der Positionsaenderung ?
1716*b1cdbd2cSJim Jagielski sal_Bool bFormat = pPara->HasFly();
1717*b1cdbd2cSJim Jagielski if( !bFormat )
1718*b1cdbd2cSJim Jagielski {
1719*b1cdbd2cSJim Jagielski if( IsInFly() )
1720*b1cdbd2cSJim Jagielski {
1721*b1cdbd2cSJim Jagielski SwTwips nTmpBottom = GetUpper()->Frm().Top() +
1722*b1cdbd2cSJim Jagielski GetUpper()->Prt().Bottom();
1723*b1cdbd2cSJim Jagielski if( nTmpBottom < Frm().Bottom() )
1724*b1cdbd2cSJim Jagielski bFormat = sal_True;
1725*b1cdbd2cSJim Jagielski }
1726*b1cdbd2cSJim Jagielski if( !bFormat )
1727*b1cdbd2cSJim Jagielski {
1728*b1cdbd2cSJim Jagielski if ( GetDrawObjs() )
1729*b1cdbd2cSJim Jagielski {
1730*b1cdbd2cSJim Jagielski const sal_uInt32 nCnt = GetDrawObjs()->Count();
1731*b1cdbd2cSJim Jagielski for ( MSHORT i = 0; i < nCnt; ++i )
1732*b1cdbd2cSJim Jagielski {
1733*b1cdbd2cSJim Jagielski SwAnchoredObject* pAnchoredObj = (*GetDrawObjs())[i];
1734*b1cdbd2cSJim Jagielski // --> OD 2004-07-16 #i28701# - consider all
1735*b1cdbd2cSJim Jagielski // to-character anchored objects
1736*b1cdbd2cSJim Jagielski if ( pAnchoredObj->GetFrmFmt().GetAnchor().GetAnchorId()
1737*b1cdbd2cSJim Jagielski == FLY_AT_CHAR )
1738*b1cdbd2cSJim Jagielski {
1739*b1cdbd2cSJim Jagielski bFormat = sal_True;
1740*b1cdbd2cSJim Jagielski break;
1741*b1cdbd2cSJim Jagielski }
1742*b1cdbd2cSJim Jagielski }
1743*b1cdbd2cSJim Jagielski }
1744*b1cdbd2cSJim Jagielski if( !bFormat )
1745*b1cdbd2cSJim Jagielski {
1746*b1cdbd2cSJim Jagielski // Gibt es ueberhaupt Flys auf der Seite ?
1747*b1cdbd2cSJim Jagielski SwTxtFly aTxtFly( this );
1748*b1cdbd2cSJim Jagielski if( aTxtFly.IsOn() )
1749*b1cdbd2cSJim Jagielski {
1750*b1cdbd2cSJim Jagielski // Ueberlappt irgendein Fly ?
1751*b1cdbd2cSJim Jagielski aTxtFly.Relax();
1752*b1cdbd2cSJim Jagielski bFormat = aTxtFly.IsOn() || IsUndersized();
1753*b1cdbd2cSJim Jagielski }
1754*b1cdbd2cSJim Jagielski }
1755*b1cdbd2cSJim Jagielski }
1756*b1cdbd2cSJim Jagielski }
1757*b1cdbd2cSJim Jagielski
1758*b1cdbd2cSJim Jagielski if( bFormat )
1759*b1cdbd2cSJim Jagielski {
1760*b1cdbd2cSJim Jagielski if( !IsLocked() )
1761*b1cdbd2cSJim Jagielski {
1762*b1cdbd2cSJim Jagielski if( pPara->GetRepaint()->HasArea() )
1763*b1cdbd2cSJim Jagielski SetCompletePaint();
1764*b1cdbd2cSJim Jagielski Init();
1765*b1cdbd2cSJim Jagielski pPara = 0;
1766*b1cdbd2cSJim Jagielski _InvalidateSize();
1767*b1cdbd2cSJim Jagielski }
1768*b1cdbd2cSJim Jagielski }
1769*b1cdbd2cSJim Jagielski else
1770*b1cdbd2cSJim Jagielski {
1771*b1cdbd2cSJim Jagielski if( GetTxtNode()->GetSwAttrSet().GetRegister().GetValue() )
1772*b1cdbd2cSJim Jagielski Prepare( PREP_REGISTER, 0, bNotify );
1773*b1cdbd2cSJim Jagielski // Durch Positionsverschiebungen mit Ftns muessen die
1774*b1cdbd2cSJim Jagielski // Frames neu adjustiert werden.
1775*b1cdbd2cSJim Jagielski else if( HasFtn() )
1776*b1cdbd2cSJim Jagielski {
1777*b1cdbd2cSJim Jagielski Prepare( PREP_ADJUST_FRM, 0, bNotify );
1778*b1cdbd2cSJim Jagielski _InvalidateSize();
1779*b1cdbd2cSJim Jagielski }
1780*b1cdbd2cSJim Jagielski else
1781*b1cdbd2cSJim Jagielski return; // damit kein SetPrep() erfolgt.
1782*b1cdbd2cSJim Jagielski }
1783*b1cdbd2cSJim Jagielski break;
1784*b1cdbd2cSJim Jagielski }
1785*b1cdbd2cSJim Jagielski case PREP_REGISTER:
1786*b1cdbd2cSJim Jagielski if( GetTxtNode()->GetSwAttrSet().GetRegister().GetValue() )
1787*b1cdbd2cSJim Jagielski {
1788*b1cdbd2cSJim Jagielski pPara->SetPrepAdjust( sal_True );
1789*b1cdbd2cSJim Jagielski CalcLineSpace();
1790*b1cdbd2cSJim Jagielski InvalidateSize();
1791*b1cdbd2cSJim Jagielski _InvalidatePrt();
1792*b1cdbd2cSJim Jagielski SwFrm* pNxt;
1793*b1cdbd2cSJim Jagielski if ( 0 != ( pNxt = GetIndNext() ) )
1794*b1cdbd2cSJim Jagielski {
1795*b1cdbd2cSJim Jagielski pNxt->_InvalidatePrt();
1796*b1cdbd2cSJim Jagielski if ( pNxt->IsLayoutFrm() )
1797*b1cdbd2cSJim Jagielski pNxt->InvalidatePage();
1798*b1cdbd2cSJim Jagielski }
1799*b1cdbd2cSJim Jagielski SetCompletePaint();
1800*b1cdbd2cSJim Jagielski }
1801*b1cdbd2cSJim Jagielski break;
1802*b1cdbd2cSJim Jagielski case PREP_FTN_GONE :
1803*b1cdbd2cSJim Jagielski {
1804*b1cdbd2cSJim Jagielski // Wenn ein Follow uns ruft, weil eine Fussnote geloescht wird, muss unsere
1805*b1cdbd2cSJim Jagielski // letzte Zeile formatiert werden, damit ggf. die erste Zeile des Follows
1806*b1cdbd2cSJim Jagielski // hochrutschen kann, die extra auf die naechste Seite gerutscht war, um mit
1807*b1cdbd2cSJim Jagielski // der Fussnote zusammen zu sein, insbesondere bei spaltigen Bereichen.
1808*b1cdbd2cSJim Jagielski ASSERT( GetFollow(), "PREP_FTN_GONE darf nur vom Follow gerufen werden" );
1809*b1cdbd2cSJim Jagielski xub_StrLen nPos = GetFollow()->GetOfst();
1810*b1cdbd2cSJim Jagielski if( IsFollow() && GetOfst() == nPos ) // falls wir gar keine Textmasse besitzen,
1811*b1cdbd2cSJim Jagielski FindMaster()->Prepare( PREP_FTN_GONE ); // rufen wir das Prepare unseres Masters
1812*b1cdbd2cSJim Jagielski if( nPos )
1813*b1cdbd2cSJim Jagielski --nPos; // das Zeichen vor unserem Follow
1814*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nPos, 1 ), 0 );
1815*b1cdbd2cSJim Jagielski return;
1816*b1cdbd2cSJim Jagielski }
1817*b1cdbd2cSJim Jagielski case PREP_ERGOSUM:
1818*b1cdbd2cSJim Jagielski case PREP_QUOVADIS:
1819*b1cdbd2cSJim Jagielski {
1820*b1cdbd2cSJim Jagielski xub_StrLen nPos;
1821*b1cdbd2cSJim Jagielski if( lcl_ErgoVadis( this, nPos, ePrep ) )
1822*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nPos, 1 ), 0 );
1823*b1cdbd2cSJim Jagielski }
1824*b1cdbd2cSJim Jagielski break;
1825*b1cdbd2cSJim Jagielski case PREP_FLY_ATTR_CHG:
1826*b1cdbd2cSJim Jagielski {
1827*b1cdbd2cSJim Jagielski if( pVoid )
1828*b1cdbd2cSJim Jagielski {
1829*b1cdbd2cSJim Jagielski xub_StrLen nWhere = CalcFlyPos( (SwFrmFmt*)pVoid );
1830*b1cdbd2cSJim Jagielski ASSERT( STRING_LEN != nWhere, "Prepare: Why me?" );
1831*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( nWhere, 1 ) );
1832*b1cdbd2cSJim Jagielski return;
1833*b1cdbd2cSJim Jagielski }
1834*b1cdbd2cSJim Jagielski // else ... Laufe in den Default-Switch
1835*b1cdbd2cSJim Jagielski }
1836*b1cdbd2cSJim Jagielski case PREP_CLEAR:
1837*b1cdbd2cSJim Jagielski default:
1838*b1cdbd2cSJim Jagielski {
1839*b1cdbd2cSJim Jagielski if( IsLocked() )
1840*b1cdbd2cSJim Jagielski {
1841*b1cdbd2cSJim Jagielski if( PREP_FLY_ARRIVE == ePrep || PREP_FLY_LEAVE == ePrep )
1842*b1cdbd2cSJim Jagielski {
1843*b1cdbd2cSJim Jagielski xub_StrLen nLen = ( GetFollow() ? GetFollow()->GetOfst() :
1844*b1cdbd2cSJim Jagielski STRING_LEN ) - GetOfst();
1845*b1cdbd2cSJim Jagielski InvalidateRange( SwCharRange( GetOfst(), nLen ), 0 );
1846*b1cdbd2cSJim Jagielski }
1847*b1cdbd2cSJim Jagielski }
1848*b1cdbd2cSJim Jagielski else
1849*b1cdbd2cSJim Jagielski {
1850*b1cdbd2cSJim Jagielski if( pPara->GetRepaint()->HasArea() )
1851*b1cdbd2cSJim Jagielski SetCompletePaint();
1852*b1cdbd2cSJim Jagielski Init();
1853*b1cdbd2cSJim Jagielski pPara = 0;
1854*b1cdbd2cSJim Jagielski if( GetOfst() && !IsFollow() )
1855*b1cdbd2cSJim Jagielski _SetOfst( 0 );
1856*b1cdbd2cSJim Jagielski if ( bNotify )
1857*b1cdbd2cSJim Jagielski InvalidateSize();
1858*b1cdbd2cSJim Jagielski else
1859*b1cdbd2cSJim Jagielski _InvalidateSize();
1860*b1cdbd2cSJim Jagielski }
1861*b1cdbd2cSJim Jagielski return; // damit kein SetPrep() erfolgt.
1862*b1cdbd2cSJim Jagielski }
1863*b1cdbd2cSJim Jagielski }
1864*b1cdbd2cSJim Jagielski if( pPara )
1865*b1cdbd2cSJim Jagielski pPara->SetPrep( sal_True );
1866*b1cdbd2cSJim Jagielski }
1867*b1cdbd2cSJim Jagielski
1868*b1cdbd2cSJim Jagielski /* -----------------11.02.99 17:56-------------------
1869*b1cdbd2cSJim Jagielski * Kleine Hilfsklasse mit folgender Funktion:
1870*b1cdbd2cSJim Jagielski * Sie soll eine Probeformatierung vorbereiten.
1871*b1cdbd2cSJim Jagielski * Der Frame wird in Groesse und Position angepasst, sein SwParaPortion zur Seite
1872*b1cdbd2cSJim Jagielski * gestellt und eine neue erzeugt, dazu wird formatiert mit gesetztem bTestFormat.
1873*b1cdbd2cSJim Jagielski * Im Dtor wird der TxtFrm wieder in seinen alten Zustand zurueckversetzt.
1874*b1cdbd2cSJim Jagielski *
1875*b1cdbd2cSJim Jagielski * --------------------------------------------------*/
1876*b1cdbd2cSJim Jagielski
1877*b1cdbd2cSJim Jagielski class SwTestFormat
1878*b1cdbd2cSJim Jagielski {
1879*b1cdbd2cSJim Jagielski SwTxtFrm *pFrm;
1880*b1cdbd2cSJim Jagielski SwParaPortion *pOldPara;
1881*b1cdbd2cSJim Jagielski SwRect aOldFrm, aOldPrt;
1882*b1cdbd2cSJim Jagielski public:
1883*b1cdbd2cSJim Jagielski SwTestFormat( SwTxtFrm* pTxtFrm, const SwFrm* pPrv, SwTwips nMaxHeight );
1884*b1cdbd2cSJim Jagielski ~SwTestFormat();
1885*b1cdbd2cSJim Jagielski };
1886*b1cdbd2cSJim Jagielski
SwTestFormat(SwTxtFrm * pTxtFrm,const SwFrm * pPre,SwTwips nMaxHeight)1887*b1cdbd2cSJim Jagielski SwTestFormat::SwTestFormat( SwTxtFrm* pTxtFrm, const SwFrm* pPre, SwTwips nMaxHeight )
1888*b1cdbd2cSJim Jagielski : pFrm( pTxtFrm )
1889*b1cdbd2cSJim Jagielski {
1890*b1cdbd2cSJim Jagielski aOldFrm = pFrm->Frm();
1891*b1cdbd2cSJim Jagielski aOldPrt = pFrm->Prt();
1892*b1cdbd2cSJim Jagielski
1893*b1cdbd2cSJim Jagielski SWRECTFN( pFrm )
1894*b1cdbd2cSJim Jagielski SwTwips nLower = (pFrm->*fnRect->fnGetBottomMargin)();
1895*b1cdbd2cSJim Jagielski
1896*b1cdbd2cSJim Jagielski pFrm->Frm() = pFrm->GetUpper()->Prt();
1897*b1cdbd2cSJim Jagielski pFrm->Frm() += pFrm->GetUpper()->Frm().Pos();
1898*b1cdbd2cSJim Jagielski
1899*b1cdbd2cSJim Jagielski (pFrm->Frm().*fnRect->fnSetHeight)( nMaxHeight );
1900*b1cdbd2cSJim Jagielski if( pFrm->GetPrev() )
1901*b1cdbd2cSJim Jagielski (pFrm->Frm().*fnRect->fnSetPosY)(
1902*b1cdbd2cSJim Jagielski (pFrm->GetPrev()->Frm().*fnRect->fnGetBottom)() -
1903*b1cdbd2cSJim Jagielski ( bVert ? nMaxHeight + 1 : 0 ) );
1904*b1cdbd2cSJim Jagielski
1905*b1cdbd2cSJim Jagielski SwBorderAttrAccess aAccess( SwFrm::GetCache(), pFrm );
1906*b1cdbd2cSJim Jagielski const SwBorderAttrs &rAttrs = *aAccess.Get();
1907*b1cdbd2cSJim Jagielski (pFrm->Prt().*fnRect->fnSetPosX)( rAttrs.CalcLeft( pFrm ) );
1908*b1cdbd2cSJim Jagielski
1909*b1cdbd2cSJim Jagielski if( pPre )
1910*b1cdbd2cSJim Jagielski {
1911*b1cdbd2cSJim Jagielski SwTwips nUpper = pFrm->CalcUpperSpace( &rAttrs, pPre );
1912*b1cdbd2cSJim Jagielski (pFrm->Prt().*fnRect->fnSetPosY)( nUpper );
1913*b1cdbd2cSJim Jagielski }
1914*b1cdbd2cSJim Jagielski (pFrm->Prt().*fnRect->fnSetHeight)(
1915*b1cdbd2cSJim Jagielski Max( 0L , (pFrm->Frm().*fnRect->fnGetHeight)() -
1916*b1cdbd2cSJim Jagielski (pFrm->Prt().*fnRect->fnGetTop)() - nLower ) );
1917*b1cdbd2cSJim Jagielski (pFrm->Prt().*fnRect->fnSetWidth)(
1918*b1cdbd2cSJim Jagielski (pFrm->Frm().*fnRect->fnGetWidth)() -
1919*b1cdbd2cSJim Jagielski // OD 23.01.2003 #106895# - add 1st param to <SwBorderAttrs::CalcRight(..)>
1920*b1cdbd2cSJim Jagielski ( rAttrs.CalcLeft( pFrm ) + rAttrs.CalcRight( pFrm ) ) );
1921*b1cdbd2cSJim Jagielski pOldPara = pFrm->HasPara() ? pFrm->GetPara() : NULL;
1922*b1cdbd2cSJim Jagielski pFrm->SetPara( new SwParaPortion(), sal_False );
1923*b1cdbd2cSJim Jagielski
1924*b1cdbd2cSJim Jagielski ASSERT( ! pFrm->IsSwapped(), "A frame is swapped before _Format" );
1925*b1cdbd2cSJim Jagielski
1926*b1cdbd2cSJim Jagielski if ( pFrm->IsVertical() )
1927*b1cdbd2cSJim Jagielski pFrm->SwapWidthAndHeight();
1928*b1cdbd2cSJim Jagielski
1929*b1cdbd2cSJim Jagielski SwTxtFormatInfo aInf( pFrm, sal_False, sal_True, sal_True );
1930*b1cdbd2cSJim Jagielski SwTxtFormatter aLine( pFrm, &aInf );
1931*b1cdbd2cSJim Jagielski
1932*b1cdbd2cSJim Jagielski pFrm->_Format( aLine, aInf );
1933*b1cdbd2cSJim Jagielski
1934*b1cdbd2cSJim Jagielski if ( pFrm->IsVertical() )
1935*b1cdbd2cSJim Jagielski pFrm->SwapWidthAndHeight();
1936*b1cdbd2cSJim Jagielski
1937*b1cdbd2cSJim Jagielski ASSERT( ! pFrm->IsSwapped(), "A frame is swapped after _Format" );
1938*b1cdbd2cSJim Jagielski }
1939*b1cdbd2cSJim Jagielski
~SwTestFormat()1940*b1cdbd2cSJim Jagielski SwTestFormat::~SwTestFormat()
1941*b1cdbd2cSJim Jagielski {
1942*b1cdbd2cSJim Jagielski pFrm->Frm() = aOldFrm;
1943*b1cdbd2cSJim Jagielski pFrm->Prt() = aOldPrt;
1944*b1cdbd2cSJim Jagielski pFrm->SetPara( pOldPara );
1945*b1cdbd2cSJim Jagielski }
1946*b1cdbd2cSJim Jagielski
TestFormat(const SwFrm * pPrv,SwTwips & rMaxHeight,sal_Bool & bSplit)1947*b1cdbd2cSJim Jagielski sal_Bool SwTxtFrm::TestFormat( const SwFrm* pPrv, SwTwips &rMaxHeight, sal_Bool &bSplit )
1948*b1cdbd2cSJim Jagielski {
1949*b1cdbd2cSJim Jagielski PROTOCOL_ENTER( this, PROT_TESTFORMAT, 0, 0 )
1950*b1cdbd2cSJim Jagielski
1951*b1cdbd2cSJim Jagielski if( IsLocked() && GetUpper()->Prt().Width() <= 0 )
1952*b1cdbd2cSJim Jagielski return sal_False;
1953*b1cdbd2cSJim Jagielski
1954*b1cdbd2cSJim Jagielski SwTestFormat aSave( this, pPrv, rMaxHeight );
1955*b1cdbd2cSJim Jagielski
1956*b1cdbd2cSJim Jagielski return SwTxtFrm::WouldFit( rMaxHeight, bSplit, sal_True );
1957*b1cdbd2cSJim Jagielski }
1958*b1cdbd2cSJim Jagielski
1959*b1cdbd2cSJim Jagielski
1960*b1cdbd2cSJim Jagielski /*************************************************************************
1961*b1cdbd2cSJim Jagielski * SwTxtFrm::WouldFit()
1962*b1cdbd2cSJim Jagielski *************************************************************************/
1963*b1cdbd2cSJim Jagielski
1964*b1cdbd2cSJim Jagielski /* SwTxtFrm::WouldFit()
1965*b1cdbd2cSJim Jagielski * sal_True: wenn ich aufspalten kann.
1966*b1cdbd2cSJim Jagielski * Es soll und braucht nicht neu formatiert werden.
1967*b1cdbd2cSJim Jagielski * Wir gehen davon aus, dass bereits formatiert wurde und dass
1968*b1cdbd2cSJim Jagielski * die Formatierungsdaten noch aktuell sind.
1969*b1cdbd2cSJim Jagielski * Wir gehen davon aus, dass die Framebreiten des evtl. Masters und
1970*b1cdbd2cSJim Jagielski * Follows gleich sind. Deswegen wird kein FindBreak() mit FindOrphans()
1971*b1cdbd2cSJim Jagielski * gerufen.
1972*b1cdbd2cSJim Jagielski * Die benoetigte Hoehe wird von nMaxHeight abgezogen!
1973*b1cdbd2cSJim Jagielski */
1974*b1cdbd2cSJim Jagielski
WouldFit(SwTwips & rMaxHeight,sal_Bool & bSplit,sal_Bool bTst)1975*b1cdbd2cSJim Jagielski sal_Bool SwTxtFrm::WouldFit( SwTwips &rMaxHeight, sal_Bool &bSplit, sal_Bool bTst )
1976*b1cdbd2cSJim Jagielski {
1977*b1cdbd2cSJim Jagielski ASSERT( ! IsVertical() || ! IsSwapped(),
1978*b1cdbd2cSJim Jagielski "SwTxtFrm::WouldFit with swapped frame" );
1979*b1cdbd2cSJim Jagielski SWRECTFN( this );
1980*b1cdbd2cSJim Jagielski
1981*b1cdbd2cSJim Jagielski if( IsLocked() )
1982*b1cdbd2cSJim Jagielski return sal_False;
1983*b1cdbd2cSJim Jagielski
1984*b1cdbd2cSJim Jagielski //Kann gut sein, dass mir der IdleCollector mir die gecachten
1985*b1cdbd2cSJim Jagielski //Informationen entzogen hat.
1986*b1cdbd2cSJim Jagielski if( !IsEmpty() )
1987*b1cdbd2cSJim Jagielski GetFormatted();
1988*b1cdbd2cSJim Jagielski
1989*b1cdbd2cSJim Jagielski // OD 2004-05-24 #i27801# - correction: 'short cut' for empty paragraph
1990*b1cdbd2cSJim Jagielski // can *not* be applied, if test format is in progress. The test format doesn't
1991*b1cdbd2cSJim Jagielski // adjust the frame and the printing area - see method <SwTxtFrm::_Format(..)>,
1992*b1cdbd2cSJim Jagielski // which is called in <SwTxtFrm::TestFormat(..)>
1993*b1cdbd2cSJim Jagielski if ( IsEmpty() && !bTst )
1994*b1cdbd2cSJim Jagielski {
1995*b1cdbd2cSJim Jagielski bSplit = sal_False;
1996*b1cdbd2cSJim Jagielski SwTwips nHeight = bVert ? Prt().SSize().Width() : Prt().SSize().Height();
1997*b1cdbd2cSJim Jagielski if( rMaxHeight < nHeight )
1998*b1cdbd2cSJim Jagielski return sal_False;
1999*b1cdbd2cSJim Jagielski else
2000*b1cdbd2cSJim Jagielski {
2001*b1cdbd2cSJim Jagielski rMaxHeight -= nHeight;
2002*b1cdbd2cSJim Jagielski return sal_True;
2003*b1cdbd2cSJim Jagielski }
2004*b1cdbd2cSJim Jagielski }
2005*b1cdbd2cSJim Jagielski
2006*b1cdbd2cSJim Jagielski // In sehr unguenstigen Faellen kann GetPara immer noch 0 sein.
2007*b1cdbd2cSJim Jagielski // Dann returnen wir sal_True, um auf der neuen Seite noch einmal
2008*b1cdbd2cSJim Jagielski // anformatiert zu werden.
2009*b1cdbd2cSJim Jagielski ASSERT( HasPara() || IsHiddenNow(), "WouldFit: GetFormatted() and then !HasPara()" );
2010*b1cdbd2cSJim Jagielski if( !HasPara() || ( !(Frm().*fnRect->fnGetHeight)() && IsHiddenNow() ) )
2011*b1cdbd2cSJim Jagielski return sal_True;
2012*b1cdbd2cSJim Jagielski
2013*b1cdbd2cSJim Jagielski // Da das Orphan-Flag nur sehr fluechtig existiert, wird als zweite
2014*b1cdbd2cSJim Jagielski // Bedingung ueberprueft, ob die Rahmengroesse durch CalcPreps
2015*b1cdbd2cSJim Jagielski // auf riesengross gesetzt wird, um ein MoveFwd zu erzwingen.
2016*b1cdbd2cSJim Jagielski if( IsWidow() || ( bVert ?
2017*b1cdbd2cSJim Jagielski ( 0 == Frm().Left() ) :
2018*b1cdbd2cSJim Jagielski ( LONG_MAX - 20000 < Frm().Bottom() ) ) )
2019*b1cdbd2cSJim Jagielski {
2020*b1cdbd2cSJim Jagielski SetWidow(sal_False);
2021*b1cdbd2cSJim Jagielski if ( GetFollow() )
2022*b1cdbd2cSJim Jagielski {
2023*b1cdbd2cSJim Jagielski // Wenn wir hier durch eine Widow-Anforderung unseres Follows gelandet
2024*b1cdbd2cSJim Jagielski // sind, wird ueberprueft, ob es ueberhaupt einen Follow mit einer
2025*b1cdbd2cSJim Jagielski // echten Hoehe gibt, andernfalls (z.B. in neu angelegten SctFrms)
2026*b1cdbd2cSJim Jagielski // ignorieren wir das IsWidow() und pruefen doch noch, ob wir
2027*b1cdbd2cSJim Jagielski // genung Platz finden.
2028*b1cdbd2cSJim Jagielski if( ( ( ! bVert && LONG_MAX - 20000 >= Frm().Bottom() ) ||
2029*b1cdbd2cSJim Jagielski ( bVert && 0 < Frm().Left() ) ) &&
2030*b1cdbd2cSJim Jagielski ( GetFollow()->IsVertical() ?
2031*b1cdbd2cSJim Jagielski !GetFollow()->Frm().Width() :
2032*b1cdbd2cSJim Jagielski !GetFollow()->Frm().Height() ) )
2033*b1cdbd2cSJim Jagielski {
2034*b1cdbd2cSJim Jagielski SwTxtFrm* pFoll = GetFollow()->GetFollow();
2035*b1cdbd2cSJim Jagielski while( pFoll &&
2036*b1cdbd2cSJim Jagielski ( pFoll->IsVertical() ?
2037*b1cdbd2cSJim Jagielski !pFoll->Frm().Width() :
2038*b1cdbd2cSJim Jagielski !pFoll->Frm().Height() ) )
2039*b1cdbd2cSJim Jagielski pFoll = pFoll->GetFollow();
2040*b1cdbd2cSJim Jagielski if( pFoll )
2041*b1cdbd2cSJim Jagielski return sal_False;
2042*b1cdbd2cSJim Jagielski }
2043*b1cdbd2cSJim Jagielski else
2044*b1cdbd2cSJim Jagielski return sal_False;
2045*b1cdbd2cSJim Jagielski }
2046*b1cdbd2cSJim Jagielski }
2047*b1cdbd2cSJim Jagielski
2048*b1cdbd2cSJim Jagielski SWAP_IF_NOT_SWAPPED( this );
2049*b1cdbd2cSJim Jagielski
2050*b1cdbd2cSJim Jagielski SwTxtSizeInfo aInf( this );
2051*b1cdbd2cSJim Jagielski SwTxtMargin aLine( this, &aInf );
2052*b1cdbd2cSJim Jagielski
2053*b1cdbd2cSJim Jagielski WidowsAndOrphans aFrmBreak( this, rMaxHeight, bSplit );
2054*b1cdbd2cSJim Jagielski
2055*b1cdbd2cSJim Jagielski sal_Bool bRet = sal_True;
2056*b1cdbd2cSJim Jagielski
2057*b1cdbd2cSJim Jagielski aLine.Bottom();
2058*b1cdbd2cSJim Jagielski // Ist Aufspalten ueberhaupt notwendig?
2059*b1cdbd2cSJim Jagielski if ( 0 != ( bSplit = !aFrmBreak.IsInside( aLine ) ) )
2060*b1cdbd2cSJim Jagielski bRet = !aFrmBreak.IsKeepAlways() && aFrmBreak.WouldFit( aLine, rMaxHeight, bTst );
2061*b1cdbd2cSJim Jagielski else
2062*b1cdbd2cSJim Jagielski {
2063*b1cdbd2cSJim Jagielski //Wir brauchen die Gesamthoehe inklusive der aktuellen Zeile
2064*b1cdbd2cSJim Jagielski aLine.Top();
2065*b1cdbd2cSJim Jagielski do
2066*b1cdbd2cSJim Jagielski {
2067*b1cdbd2cSJim Jagielski rMaxHeight -= aLine.GetLineHeight();
2068*b1cdbd2cSJim Jagielski } while ( aLine.Next() );
2069*b1cdbd2cSJim Jagielski }
2070*b1cdbd2cSJim Jagielski
2071*b1cdbd2cSJim Jagielski UNDO_SWAP( this )
2072*b1cdbd2cSJim Jagielski
2073*b1cdbd2cSJim Jagielski return bRet;
2074*b1cdbd2cSJim Jagielski }
2075*b1cdbd2cSJim Jagielski
2076*b1cdbd2cSJim Jagielski
2077*b1cdbd2cSJim Jagielski /*************************************************************************
2078*b1cdbd2cSJim Jagielski * SwTxtFrm::GetParHeight()
2079*b1cdbd2cSJim Jagielski *************************************************************************/
2080*b1cdbd2cSJim Jagielski
GetParHeight() const2081*b1cdbd2cSJim Jagielski KSHORT SwTxtFrm::GetParHeight() const
2082*b1cdbd2cSJim Jagielski {
2083*b1cdbd2cSJim Jagielski ASSERT( ! IsVertical() || ! IsSwapped(),
2084*b1cdbd2cSJim Jagielski "SwTxtFrm::GetParHeight with swapped frame" )
2085*b1cdbd2cSJim Jagielski
2086*b1cdbd2cSJim Jagielski if( !HasPara() )
2087*b1cdbd2cSJim Jagielski { // Fuer nichtleere Absaetze ist dies ein Sonderfall, da koennen wir
2088*b1cdbd2cSJim Jagielski // bei UnderSized ruhig nur 1 Twip mehr anfordern.
2089*b1cdbd2cSJim Jagielski KSHORT nRet = (KSHORT)Prt().SSize().Height();
2090*b1cdbd2cSJim Jagielski if( IsUndersized() )
2091*b1cdbd2cSJim Jagielski {
2092*b1cdbd2cSJim Jagielski if( IsEmpty() )
2093*b1cdbd2cSJim Jagielski nRet = (KSHORT)EmptyHeight();
2094*b1cdbd2cSJim Jagielski else
2095*b1cdbd2cSJim Jagielski ++nRet;
2096*b1cdbd2cSJim Jagielski }
2097*b1cdbd2cSJim Jagielski return nRet;
2098*b1cdbd2cSJim Jagielski }
2099*b1cdbd2cSJim Jagielski
2100*b1cdbd2cSJim Jagielski // FME, OD 08.01.2004 #i11859# - refactoring and improve code
2101*b1cdbd2cSJim Jagielski const SwLineLayout* pLineLayout = GetPara();
2102*b1cdbd2cSJim Jagielski KSHORT nHeight = pLineLayout->GetRealHeight();
2103*b1cdbd2cSJim Jagielski if( GetOfst() && !IsFollow() ) // Ist dieser Absatz gescrollt? Dann ist unsere
2104*b1cdbd2cSJim Jagielski nHeight *= 2; // bisherige Hoehe mind. eine Zeilenhoehe zu gering
2105*b1cdbd2cSJim Jagielski // OD 2004-03-04 #115793#
2106*b1cdbd2cSJim Jagielski while ( pLineLayout && pLineLayout->GetNext() )
2107*b1cdbd2cSJim Jagielski {
2108*b1cdbd2cSJim Jagielski pLineLayout = pLineLayout->GetNext();
2109*b1cdbd2cSJim Jagielski nHeight = nHeight + pLineLayout->GetRealHeight();
2110*b1cdbd2cSJim Jagielski }
2111*b1cdbd2cSJim Jagielski
2112*b1cdbd2cSJim Jagielski return nHeight;
2113*b1cdbd2cSJim Jagielski }
2114*b1cdbd2cSJim Jagielski
2115*b1cdbd2cSJim Jagielski
2116*b1cdbd2cSJim Jagielski /*************************************************************************
2117*b1cdbd2cSJim Jagielski * SwTxtFrm::GetFormatted()
2118*b1cdbd2cSJim Jagielski *************************************************************************/
2119*b1cdbd2cSJim Jagielski
2120*b1cdbd2cSJim Jagielski // returnt this _immer_ im formatierten Zustand!
GetFormatted(bool bForceQuickFormat)2121*b1cdbd2cSJim Jagielski SwTxtFrm* SwTxtFrm::GetFormatted( bool bForceQuickFormat )
2122*b1cdbd2cSJim Jagielski {
2123*b1cdbd2cSJim Jagielski SWAP_IF_SWAPPED( this )
2124*b1cdbd2cSJim Jagielski
2125*b1cdbd2cSJim Jagielski //Kann gut sein, dass mir der IdleCollector mir die gecachten
2126*b1cdbd2cSJim Jagielski //Informationen entzogen hat. Calc() ruft unser Format.
2127*b1cdbd2cSJim Jagielski //Nicht bei leeren Absaetzen!
2128*b1cdbd2cSJim Jagielski if( !HasPara() && !(IsValid() && IsEmpty()) )
2129*b1cdbd2cSJim Jagielski {
2130*b1cdbd2cSJim Jagielski // Calc() muss gerufen werden, weil unsere Frameposition
2131*b1cdbd2cSJim Jagielski // nicht stimmen muss.
2132*b1cdbd2cSJim Jagielski const sal_Bool bFormat = GetValidSizeFlag();
2133*b1cdbd2cSJim Jagielski Calc();
2134*b1cdbd2cSJim Jagielski // Es kann durchaus sein, dass Calc() das Format()
2135*b1cdbd2cSJim Jagielski // nicht anstiess (weil wir einst vom Idle-Zerstoerer
2136*b1cdbd2cSJim Jagielski // aufgefordert wurden unsere Formatinformationen wegzuschmeissen).
2137*b1cdbd2cSJim Jagielski // 6995: Optimierung mit FormatQuick()
2138*b1cdbd2cSJim Jagielski if( bFormat && !FormatQuick( bForceQuickFormat ) )
2139*b1cdbd2cSJim Jagielski Format();
2140*b1cdbd2cSJim Jagielski }
2141*b1cdbd2cSJim Jagielski
2142*b1cdbd2cSJim Jagielski UNDO_SWAP( this )
2143*b1cdbd2cSJim Jagielski
2144*b1cdbd2cSJim Jagielski return this;
2145*b1cdbd2cSJim Jagielski }
2146*b1cdbd2cSJim Jagielski
2147*b1cdbd2cSJim Jagielski /*************************************************************************
2148*b1cdbd2cSJim Jagielski * SwTxtFrm::CalcFitToContent()
2149*b1cdbd2cSJim Jagielski *************************************************************************/
2150*b1cdbd2cSJim Jagielski
CalcFitToContent()2151*b1cdbd2cSJim Jagielski SwTwips SwTxtFrm::CalcFitToContent()
2152*b1cdbd2cSJim Jagielski {
2153*b1cdbd2cSJim Jagielski // --> FME 2004-07-16 #i31490#
2154*b1cdbd2cSJim Jagielski // If we are currently locked, we better return with a
2155*b1cdbd2cSJim Jagielski // fairly reasonable value:
2156*b1cdbd2cSJim Jagielski if ( IsLocked() )
2157*b1cdbd2cSJim Jagielski return Prt().Width();
2158*b1cdbd2cSJim Jagielski // <--
2159*b1cdbd2cSJim Jagielski
2160*b1cdbd2cSJim Jagielski SwParaPortion* pOldPara = GetPara();
2161*b1cdbd2cSJim Jagielski SwParaPortion *pDummy = new SwParaPortion();
2162*b1cdbd2cSJim Jagielski SetPara( pDummy, false );
2163*b1cdbd2cSJim Jagielski const SwPageFrm* pPage = FindPageFrm();
2164*b1cdbd2cSJim Jagielski
2165*b1cdbd2cSJim Jagielski const Point aOldFrmPos = Frm().Pos();
2166*b1cdbd2cSJim Jagielski const SwTwips nOldFrmWidth = Frm().Width();
2167*b1cdbd2cSJim Jagielski const SwTwips nOldPrtWidth = Prt().Width();
2168*b1cdbd2cSJim Jagielski const SwTwips nPageWidth = GetUpper()->IsVertical() ?
2169*b1cdbd2cSJim Jagielski pPage->Prt().Height() :
2170*b1cdbd2cSJim Jagielski pPage->Prt().Width();
2171*b1cdbd2cSJim Jagielski
2172*b1cdbd2cSJim Jagielski Frm().Width( nPageWidth );
2173*b1cdbd2cSJim Jagielski Prt().Width( nPageWidth );
2174*b1cdbd2cSJim Jagielski
2175*b1cdbd2cSJim Jagielski // --> FME 2004-07-19 #i25422# objects anchored as character in RTL
2176*b1cdbd2cSJim Jagielski if ( IsRightToLeft() )
2177*b1cdbd2cSJim Jagielski Frm().Pos().X() += nOldFrmWidth - nPageWidth;
2178*b1cdbd2cSJim Jagielski
2179*b1cdbd2cSJim Jagielski // --> FME 2004-07-16 #i31490#
2180*b1cdbd2cSJim Jagielski SwTxtFrmLocker aLock( this );
2181*b1cdbd2cSJim Jagielski // <--
2182*b1cdbd2cSJim Jagielski
2183*b1cdbd2cSJim Jagielski SwTxtFormatInfo aInf( this, sal_False, sal_True, sal_True );
2184*b1cdbd2cSJim Jagielski aInf.SetIgnoreFly( sal_True );
2185*b1cdbd2cSJim Jagielski SwTxtFormatter aLine( this, &aInf );
2186*b1cdbd2cSJim Jagielski SwHookOut aHook( aInf );
2187*b1cdbd2cSJim Jagielski
2188*b1cdbd2cSJim Jagielski // --> OD 2005-09-06 #i54031# - assure mininum of MINLAY twips.
2189*b1cdbd2cSJim Jagielski const SwTwips nMax = Max( (SwTwips)MINLAY,
2190*b1cdbd2cSJim Jagielski aLine._CalcFitToContent() + 1 );
2191*b1cdbd2cSJim Jagielski // <--
2192*b1cdbd2cSJim Jagielski
2193*b1cdbd2cSJim Jagielski Frm().Width( nOldFrmWidth );
2194*b1cdbd2cSJim Jagielski Prt().Width( nOldPrtWidth );
2195*b1cdbd2cSJim Jagielski
2196*b1cdbd2cSJim Jagielski // --> FME 2004-07-19 #i25422# objects anchored as character in RTL
2197*b1cdbd2cSJim Jagielski if ( IsRightToLeft() )
2198*b1cdbd2cSJim Jagielski Frm().Pos() = aOldFrmPos;
2199*b1cdbd2cSJim Jagielski
2200*b1cdbd2cSJim Jagielski
2201*b1cdbd2cSJim Jagielski SetPara( pOldPara );
2202*b1cdbd2cSJim Jagielski
2203*b1cdbd2cSJim Jagielski return nMax;
2204*b1cdbd2cSJim Jagielski }
2205*b1cdbd2cSJim Jagielski
2206*b1cdbd2cSJim Jagielski /** simulate format for a list item paragraph, whose list level attributes
2207*b1cdbd2cSJim Jagielski are in LABEL_ALIGNMENT mode, in order to determine additional first
2208*b1cdbd2cSJim Jagielski line offset for the real text formatting due to the value of label
2209*b1cdbd2cSJim Jagielski adjustment attribute of the list level.
2210*b1cdbd2cSJim Jagielski
2211*b1cdbd2cSJim Jagielski OD 2008-01-31 #newlistlevelattrs#
2212*b1cdbd2cSJim Jagielski
2213*b1cdbd2cSJim Jagielski @author OD
2214*b1cdbd2cSJim Jagielski */
CalcAdditionalFirstLineOffset()2215*b1cdbd2cSJim Jagielski void SwTxtFrm::CalcAdditionalFirstLineOffset()
2216*b1cdbd2cSJim Jagielski {
2217*b1cdbd2cSJim Jagielski if ( IsLocked() )
2218*b1cdbd2cSJim Jagielski return;
2219*b1cdbd2cSJim Jagielski
2220*b1cdbd2cSJim Jagielski // reset additional first line offset
2221*b1cdbd2cSJim Jagielski mnAdditionalFirstLineOffset = 0;
2222*b1cdbd2cSJim Jagielski
2223*b1cdbd2cSJim Jagielski const SwTxtNode* pTxtNode( GetTxtNode() );
2224*b1cdbd2cSJim Jagielski if ( pTxtNode && pTxtNode->IsNumbered() && pTxtNode->IsCountedInList() &&
2225*b1cdbd2cSJim Jagielski pTxtNode->GetNumRule() )
2226*b1cdbd2cSJim Jagielski {
2227*b1cdbd2cSJim Jagielski const SwNumFmt& rNumFmt =
2228*b1cdbd2cSJim Jagielski pTxtNode->GetNumRule()->Get( static_cast<sal_uInt16>(pTxtNode->GetActualListLevel()) );
2229*b1cdbd2cSJim Jagielski if ( rNumFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT )
2230*b1cdbd2cSJim Jagielski {
2231*b1cdbd2cSJim Jagielski // keep current paragraph portion and apply dummy paragraph portion
2232*b1cdbd2cSJim Jagielski SwParaPortion* pOldPara = GetPara();
2233*b1cdbd2cSJim Jagielski SwParaPortion *pDummy = new SwParaPortion();
2234*b1cdbd2cSJim Jagielski SetPara( pDummy, false );
2235*b1cdbd2cSJim Jagielski
2236*b1cdbd2cSJim Jagielski // lock paragraph
2237*b1cdbd2cSJim Jagielski SwTxtFrmLocker aLock( this );
2238*b1cdbd2cSJim Jagielski
2239*b1cdbd2cSJim Jagielski // simulate text formatting
2240*b1cdbd2cSJim Jagielski SwTxtFormatInfo aInf( this, sal_False, sal_True, sal_True );
2241*b1cdbd2cSJim Jagielski aInf.SetIgnoreFly( sal_True );
2242*b1cdbd2cSJim Jagielski SwTxtFormatter aLine( this, &aInf );
2243*b1cdbd2cSJim Jagielski SwHookOut aHook( aInf );
2244*b1cdbd2cSJim Jagielski aLine._CalcFitToContent();
2245*b1cdbd2cSJim Jagielski
2246*b1cdbd2cSJim Jagielski // determine additional first line offset
2247*b1cdbd2cSJim Jagielski const SwLinePortion* pFirstPortion = aLine.GetCurr()->GetFirstPortion();
2248*b1cdbd2cSJim Jagielski if ( pFirstPortion->InNumberGrp() && !pFirstPortion->IsFtnNumPortion() )
2249*b1cdbd2cSJim Jagielski {
2250*b1cdbd2cSJim Jagielski SwTwips nNumberPortionWidth( pFirstPortion->Width() );
2251*b1cdbd2cSJim Jagielski
2252*b1cdbd2cSJim Jagielski const SwLinePortion* pPortion = pFirstPortion->GetPortion();
2253*b1cdbd2cSJim Jagielski while ( pPortion &&
2254*b1cdbd2cSJim Jagielski pPortion->InNumberGrp() && !pPortion->IsFtnNumPortion())
2255*b1cdbd2cSJim Jagielski {
2256*b1cdbd2cSJim Jagielski nNumberPortionWidth += pPortion->Width();
2257*b1cdbd2cSJim Jagielski pPortion = pPortion->GetPortion();
2258*b1cdbd2cSJim Jagielski }
2259*b1cdbd2cSJim Jagielski
2260*b1cdbd2cSJim Jagielski if ( ( IsRightToLeft() &&
2261*b1cdbd2cSJim Jagielski rNumFmt.GetNumAdjust() == SVX_ADJUST_LEFT ) ||
2262*b1cdbd2cSJim Jagielski ( !IsRightToLeft() &&
2263*b1cdbd2cSJim Jagielski rNumFmt.GetNumAdjust() == SVX_ADJUST_RIGHT ) )
2264*b1cdbd2cSJim Jagielski {
2265*b1cdbd2cSJim Jagielski mnAdditionalFirstLineOffset = -nNumberPortionWidth;
2266*b1cdbd2cSJim Jagielski }
2267*b1cdbd2cSJim Jagielski else if ( rNumFmt.GetNumAdjust() == SVX_ADJUST_CENTER )
2268*b1cdbd2cSJim Jagielski {
2269*b1cdbd2cSJim Jagielski mnAdditionalFirstLineOffset = -(nNumberPortionWidth/2);
2270*b1cdbd2cSJim Jagielski }
2271*b1cdbd2cSJim Jagielski }
2272*b1cdbd2cSJim Jagielski
2273*b1cdbd2cSJim Jagielski // restore paragraph portion
2274*b1cdbd2cSJim Jagielski SetPara( pOldPara );
2275*b1cdbd2cSJim Jagielski }
2276*b1cdbd2cSJim Jagielski }
2277*b1cdbd2cSJim Jagielski }
2278*b1cdbd2cSJim Jagielski
2279*b1cdbd2cSJim Jagielski /** determine height of last line for the calculation of the proportional line
2280*b1cdbd2cSJim Jagielski spacing
2281*b1cdbd2cSJim Jagielski
2282*b1cdbd2cSJim Jagielski OD 08.01.2004 #i11859#
2283*b1cdbd2cSJim Jagielski OD 2004-03-17 #i11860# - method <GetHeightOfLastLineForPropLineSpacing()>
2284*b1cdbd2cSJim Jagielski replace by method <_CalcHeightOfLastLine()>. Height of last line will be
2285*b1cdbd2cSJim Jagielski stored in new member <mnHeightOfLastLine> and can be accessed via method
2286*b1cdbd2cSJim Jagielski <GetHeightOfLastLine()>
2287*b1cdbd2cSJim Jagielski OD 2005-05-20 #i47162# - introduce new optional parameter <_bUseFont>
2288*b1cdbd2cSJim Jagielski in order to force the usage of the former algorithm to determine the
2289*b1cdbd2cSJim Jagielski height of the last line, which uses the font.
2290*b1cdbd2cSJim Jagielski
2291*b1cdbd2cSJim Jagielski @author OD
2292*b1cdbd2cSJim Jagielski */
_CalcHeightOfLastLine(const bool _bUseFont)2293*b1cdbd2cSJim Jagielski void SwTxtFrm::_CalcHeightOfLastLine( const bool _bUseFont )
2294*b1cdbd2cSJim Jagielski {
2295*b1cdbd2cSJim Jagielski // --> OD 2006-11-13 #i71281#
2296*b1cdbd2cSJim Jagielski // invalidate printing area, if height of last line changes
2297*b1cdbd2cSJim Jagielski const SwTwips mnOldHeightOfLastLine( mnHeightOfLastLine );
2298*b1cdbd2cSJim Jagielski // <--
2299*b1cdbd2cSJim Jagielski // determine output device
2300*b1cdbd2cSJim Jagielski ViewShell* pVsh = getRootFrm()->GetCurrShell();
2301*b1cdbd2cSJim Jagielski ASSERT( pVsh, "<SwTxtFrm::_GetHeightOfLastLineForPropLineSpacing()> - no ViewShell" );
2302*b1cdbd2cSJim Jagielski // --> OD 2007-07-02 #i78921# - make code robust, according to provided patch
2303*b1cdbd2cSJim Jagielski // There could be no <ViewShell> instance in the case of loading a binary
2304*b1cdbd2cSJim Jagielski // StarOffice file format containing an embedded Writer document.
2305*b1cdbd2cSJim Jagielski if ( !pVsh )
2306*b1cdbd2cSJim Jagielski {
2307*b1cdbd2cSJim Jagielski return;
2308*b1cdbd2cSJim Jagielski }
2309*b1cdbd2cSJim Jagielski OutputDevice* pOut = pVsh->GetOut();
2310*b1cdbd2cSJim Jagielski const IDocumentSettingAccess* pIDSA = GetTxtNode()->getIDocumentSettingAccess();
2311*b1cdbd2cSJim Jagielski if ( !pVsh->GetViewOptions()->getBrowseMode() ||
2312*b1cdbd2cSJim Jagielski pVsh->GetViewOptions()->IsPrtFormat() )
2313*b1cdbd2cSJim Jagielski {
2314*b1cdbd2cSJim Jagielski pOut = GetTxtNode()->getIDocumentDeviceAccess()->getReferenceDevice( true );
2315*b1cdbd2cSJim Jagielski }
2316*b1cdbd2cSJim Jagielski ASSERT( pOut, "<SwTxtFrm::_GetHeightOfLastLineForPropLineSpacing()> - no OutputDevice" );
2317*b1cdbd2cSJim Jagielski // --> OD 2007-07-02 #i78921# - make code robust, according to provided patch
2318*b1cdbd2cSJim Jagielski if ( !pOut )
2319*b1cdbd2cSJim Jagielski {
2320*b1cdbd2cSJim Jagielski return;
2321*b1cdbd2cSJim Jagielski }
2322*b1cdbd2cSJim Jagielski // <--
2323*b1cdbd2cSJim Jagielski
2324*b1cdbd2cSJim Jagielski // determine height of last line
2325*b1cdbd2cSJim Jagielski
2326*b1cdbd2cSJim Jagielski if ( _bUseFont || pIDSA->get(IDocumentSettingAccess::OLD_LINE_SPACING ) )
2327*b1cdbd2cSJim Jagielski {
2328*b1cdbd2cSJim Jagielski // former determination of last line height for proprotional line
2329*b1cdbd2cSJim Jagielski // spacing - take height of font set at the paragraph
2330*b1cdbd2cSJim Jagielski SwFont aFont( GetAttrSet(), pIDSA );
2331*b1cdbd2cSJim Jagielski
2332*b1cdbd2cSJim Jagielski // Wir muessen dafuer sorgen, dass am OutputDevice der Font
2333*b1cdbd2cSJim Jagielski // korrekt restauriert wird, sonst droht ein Last!=Owner.
2334*b1cdbd2cSJim Jagielski if ( pLastFont )
2335*b1cdbd2cSJim Jagielski {
2336*b1cdbd2cSJim Jagielski SwFntObj *pOldFont = pLastFont;
2337*b1cdbd2cSJim Jagielski pLastFont = NULL;
2338*b1cdbd2cSJim Jagielski aFont.SetFntChg( sal_True );
2339*b1cdbd2cSJim Jagielski aFont.ChgPhysFnt( pVsh, *pOut );
2340*b1cdbd2cSJim Jagielski mnHeightOfLastLine = aFont.GetHeight( pVsh, *pOut );
2341*b1cdbd2cSJim Jagielski pLastFont->Unlock();
2342*b1cdbd2cSJim Jagielski pLastFont = pOldFont;
2343*b1cdbd2cSJim Jagielski pLastFont->SetDevFont( pVsh, *pOut );
2344*b1cdbd2cSJim Jagielski }
2345*b1cdbd2cSJim Jagielski else
2346*b1cdbd2cSJim Jagielski {
2347*b1cdbd2cSJim Jagielski Font aOldFont = pOut->GetFont();
2348*b1cdbd2cSJim Jagielski aFont.SetFntChg( sal_True );
2349*b1cdbd2cSJim Jagielski aFont.ChgPhysFnt( pVsh, *pOut );
2350*b1cdbd2cSJim Jagielski mnHeightOfLastLine = aFont.GetHeight( pVsh, *pOut );
2351*b1cdbd2cSJim Jagielski pLastFont->Unlock();
2352*b1cdbd2cSJim Jagielski pLastFont = NULL;
2353*b1cdbd2cSJim Jagielski pOut->SetFont( aOldFont );
2354*b1cdbd2cSJim Jagielski }
2355*b1cdbd2cSJim Jagielski }
2356*b1cdbd2cSJim Jagielski else
2357*b1cdbd2cSJim Jagielski {
2358*b1cdbd2cSJim Jagielski // new determination of last line height - take actually height of last line
2359*b1cdbd2cSJim Jagielski // --> OD 2008-05-06 #i89000#
2360*b1cdbd2cSJim Jagielski // assure same results, if paragraph is undersized
2361*b1cdbd2cSJim Jagielski if ( IsUndersized() )
2362*b1cdbd2cSJim Jagielski {
2363*b1cdbd2cSJim Jagielski mnHeightOfLastLine = 0;
2364*b1cdbd2cSJim Jagielski }
2365*b1cdbd2cSJim Jagielski else
2366*b1cdbd2cSJim Jagielski {
2367*b1cdbd2cSJim Jagielski bool bCalcHeightOfLastLine = true;
2368*b1cdbd2cSJim Jagielski if ( !HasPara() )
2369*b1cdbd2cSJim Jagielski {
2370*b1cdbd2cSJim Jagielski if ( IsEmpty() )
2371*b1cdbd2cSJim Jagielski {
2372*b1cdbd2cSJim Jagielski mnHeightOfLastLine = EmptyHeight();
2373*b1cdbd2cSJim Jagielski bCalcHeightOfLastLine = false;
2374*b1cdbd2cSJim Jagielski }
2375*b1cdbd2cSJim Jagielski }
2376*b1cdbd2cSJim Jagielski
2377*b1cdbd2cSJim Jagielski if ( bCalcHeightOfLastLine )
2378*b1cdbd2cSJim Jagielski {
2379*b1cdbd2cSJim Jagielski ASSERT( HasPara(),
2380*b1cdbd2cSJim Jagielski "<SwTxtFrm::_CalcHeightOfLastLine()> - missing paragraph portions." );
2381*b1cdbd2cSJim Jagielski const SwLineLayout* pLineLayout = GetPara();
2382*b1cdbd2cSJim Jagielski while ( pLineLayout && pLineLayout->GetNext() )
2383*b1cdbd2cSJim Jagielski {
2384*b1cdbd2cSJim Jagielski // iteration to last line
2385*b1cdbd2cSJim Jagielski pLineLayout = pLineLayout->GetNext();
2386*b1cdbd2cSJim Jagielski }
2387*b1cdbd2cSJim Jagielski if ( pLineLayout )
2388*b1cdbd2cSJim Jagielski {
2389*b1cdbd2cSJim Jagielski SwTwips nAscent, nDescent, nDummy1, nDummy2;
2390*b1cdbd2cSJim Jagielski // --> OD 2005-05-20 #i47162# - suppress consideration of
2391*b1cdbd2cSJim Jagielski // fly content portions and the line portion.
2392*b1cdbd2cSJim Jagielski pLineLayout->MaxAscentDescent( nAscent, nDescent,
2393*b1cdbd2cSJim Jagielski nDummy1, nDummy2,
2394*b1cdbd2cSJim Jagielski 0, true );
2395*b1cdbd2cSJim Jagielski // <--
2396*b1cdbd2cSJim Jagielski // --> OD 2006-11-22 #i71281#
2397*b1cdbd2cSJim Jagielski // Suppress wrong invalidation of printing area, if method is
2398*b1cdbd2cSJim Jagielski // called recursive.
2399*b1cdbd2cSJim Jagielski // Thus, member <mnHeightOfLastLine> is only set directly, if
2400*b1cdbd2cSJim Jagielski // no recursive call is needed.
2401*b1cdbd2cSJim Jagielski // mnHeightOfLastLine = nAscent + nDescent;
2402*b1cdbd2cSJim Jagielski const SwTwips nNewHeightOfLastLine = nAscent + nDescent;
2403*b1cdbd2cSJim Jagielski // --> OD 2005-05-20 #i47162# - if last line only contains
2404*b1cdbd2cSJim Jagielski // fly content portions, <mnHeightOfLastLine> is zero.
2405*b1cdbd2cSJim Jagielski // In this case determine height of last line by the font
2406*b1cdbd2cSJim Jagielski if ( nNewHeightOfLastLine == 0 )
2407*b1cdbd2cSJim Jagielski {
2408*b1cdbd2cSJim Jagielski _CalcHeightOfLastLine( true );
2409*b1cdbd2cSJim Jagielski }
2410*b1cdbd2cSJim Jagielski else
2411*b1cdbd2cSJim Jagielski {
2412*b1cdbd2cSJim Jagielski mnHeightOfLastLine = nNewHeightOfLastLine;
2413*b1cdbd2cSJim Jagielski }
2414*b1cdbd2cSJim Jagielski // <--
2415*b1cdbd2cSJim Jagielski // <--
2416*b1cdbd2cSJim Jagielski }
2417*b1cdbd2cSJim Jagielski }
2418*b1cdbd2cSJim Jagielski }
2419*b1cdbd2cSJim Jagielski // <--
2420*b1cdbd2cSJim Jagielski }
2421*b1cdbd2cSJim Jagielski // --> OD 2006-11-13 #i71281#
2422*b1cdbd2cSJim Jagielski // invalidate printing area, if height of last line changes
2423*b1cdbd2cSJim Jagielski if ( mnHeightOfLastLine != mnOldHeightOfLastLine )
2424*b1cdbd2cSJim Jagielski {
2425*b1cdbd2cSJim Jagielski InvalidatePrt();
2426*b1cdbd2cSJim Jagielski }
2427*b1cdbd2cSJim Jagielski // <--
2428*b1cdbd2cSJim Jagielski }
2429*b1cdbd2cSJim Jagielski
2430*b1cdbd2cSJim Jagielski /*************************************************************************
2431*b1cdbd2cSJim Jagielski * SwTxtFrm::GetLineSpace()
2432*b1cdbd2cSJim Jagielski *************************************************************************/
2433*b1cdbd2cSJim Jagielski // OD 07.01.2004 #i11859# - change return data type
2434*b1cdbd2cSJim Jagielski // add default parameter <_bNoPropLineSpacing> to control, if the
2435*b1cdbd2cSJim Jagielski // value of a proportional line spacing is returned or not
2436*b1cdbd2cSJim Jagielski // OD 07.01.2004 - trying to describe purpose of method:
2437*b1cdbd2cSJim Jagielski // Method returns the value of the inter line spacing for a text frame.
2438*b1cdbd2cSJim Jagielski // Such a value exists for proportional line spacings ("1,5 Lines",
2439*b1cdbd2cSJim Jagielski // "Double", "Proportional" and for leading line spacing ("Leading").
2440*b1cdbd2cSJim Jagielski // By parameter <_bNoPropLineSpace> (default value false) it can be
2441*b1cdbd2cSJim Jagielski // controlled, if the value of a proportional line spacing is returned.
GetLineSpace(const bool _bNoPropLineSpace) const2442*b1cdbd2cSJim Jagielski long SwTxtFrm::GetLineSpace( const bool _bNoPropLineSpace ) const
2443*b1cdbd2cSJim Jagielski {
2444*b1cdbd2cSJim Jagielski long nRet = 0;
2445*b1cdbd2cSJim Jagielski
2446*b1cdbd2cSJim Jagielski const SwAttrSet* pSet = GetAttrSet();
2447*b1cdbd2cSJim Jagielski const SvxLineSpacingItem &rSpace = pSet->GetLineSpacing();
2448*b1cdbd2cSJim Jagielski
2449*b1cdbd2cSJim Jagielski switch( rSpace.GetInterLineSpaceRule() )
2450*b1cdbd2cSJim Jagielski {
2451*b1cdbd2cSJim Jagielski case SVX_INTER_LINE_SPACE_PROP:
2452*b1cdbd2cSJim Jagielski {
2453*b1cdbd2cSJim Jagielski // OD 07.01.2004 #i11859#
2454*b1cdbd2cSJim Jagielski if ( _bNoPropLineSpace )
2455*b1cdbd2cSJim Jagielski {
2456*b1cdbd2cSJim Jagielski break;
2457*b1cdbd2cSJim Jagielski }
2458*b1cdbd2cSJim Jagielski
2459*b1cdbd2cSJim Jagielski // OD 2004-03-17 #i11860# - use method <GetHeightOfLastLine()>
2460*b1cdbd2cSJim Jagielski nRet = GetHeightOfLastLine();
2461*b1cdbd2cSJim Jagielski
2462*b1cdbd2cSJim Jagielski long nTmp = nRet;
2463*b1cdbd2cSJim Jagielski nTmp *= rSpace.GetPropLineSpace();
2464*b1cdbd2cSJim Jagielski nTmp /= 100;
2465*b1cdbd2cSJim Jagielski nTmp -= nRet;
2466*b1cdbd2cSJim Jagielski if ( nTmp > 0 )
2467*b1cdbd2cSJim Jagielski nRet = nTmp;
2468*b1cdbd2cSJim Jagielski else
2469*b1cdbd2cSJim Jagielski nRet = 0;
2470*b1cdbd2cSJim Jagielski }
2471*b1cdbd2cSJim Jagielski break;
2472*b1cdbd2cSJim Jagielski case SVX_INTER_LINE_SPACE_FIX:
2473*b1cdbd2cSJim Jagielski {
2474*b1cdbd2cSJim Jagielski if ( rSpace.GetInterLineSpace() > 0 )
2475*b1cdbd2cSJim Jagielski nRet = rSpace.GetInterLineSpace();
2476*b1cdbd2cSJim Jagielski }
2477*b1cdbd2cSJim Jagielski break;
2478*b1cdbd2cSJim Jagielski default:
2479*b1cdbd2cSJim Jagielski break;
2480*b1cdbd2cSJim Jagielski }
2481*b1cdbd2cSJim Jagielski return nRet;
2482*b1cdbd2cSJim Jagielski }
2483*b1cdbd2cSJim Jagielski
2484*b1cdbd2cSJim Jagielski /*************************************************************************
2485*b1cdbd2cSJim Jagielski * SwTxtFrm::FirstLineHeight()
2486*b1cdbd2cSJim Jagielski *************************************************************************/
2487*b1cdbd2cSJim Jagielski
FirstLineHeight() const2488*b1cdbd2cSJim Jagielski KSHORT SwTxtFrm::FirstLineHeight() const
2489*b1cdbd2cSJim Jagielski {
2490*b1cdbd2cSJim Jagielski if ( !HasPara() )
2491*b1cdbd2cSJim Jagielski {
2492*b1cdbd2cSJim Jagielski if( IsEmpty() && IsValid() )
2493*b1cdbd2cSJim Jagielski return IsVertical() ? (KSHORT)Prt().Width() : (KSHORT)Prt().Height();
2494*b1cdbd2cSJim Jagielski return KSHRT_MAX;
2495*b1cdbd2cSJim Jagielski }
2496*b1cdbd2cSJim Jagielski const SwParaPortion *pPara = GetPara();
2497*b1cdbd2cSJim Jagielski if ( !pPara )
2498*b1cdbd2cSJim Jagielski return KSHRT_MAX;
2499*b1cdbd2cSJim Jagielski
2500*b1cdbd2cSJim Jagielski return pPara->Height();
2501*b1cdbd2cSJim Jagielski }
2502*b1cdbd2cSJim Jagielski
GetLineCount(xub_StrLen nPos)2503*b1cdbd2cSJim Jagielski MSHORT SwTxtFrm::GetLineCount( xub_StrLen nPos )
2504*b1cdbd2cSJim Jagielski {
2505*b1cdbd2cSJim Jagielski MSHORT nRet = 0;
2506*b1cdbd2cSJim Jagielski SwTxtFrm *pFrm = this;
2507*b1cdbd2cSJim Jagielski do
2508*b1cdbd2cSJim Jagielski {
2509*b1cdbd2cSJim Jagielski pFrm->GetFormatted();
2510*b1cdbd2cSJim Jagielski if( !pFrm->HasPara() )
2511*b1cdbd2cSJim Jagielski break;
2512*b1cdbd2cSJim Jagielski SwTxtSizeInfo aInf( pFrm );
2513*b1cdbd2cSJim Jagielski SwTxtMargin aLine( pFrm, &aInf );
2514*b1cdbd2cSJim Jagielski if( STRING_LEN == nPos )
2515*b1cdbd2cSJim Jagielski aLine.Bottom();
2516*b1cdbd2cSJim Jagielski else
2517*b1cdbd2cSJim Jagielski aLine.CharToLine( nPos );
2518*b1cdbd2cSJim Jagielski nRet = nRet + aLine.GetLineNr();
2519*b1cdbd2cSJim Jagielski pFrm = pFrm->GetFollow();
2520*b1cdbd2cSJim Jagielski } while ( pFrm && pFrm->GetOfst() <= nPos );
2521*b1cdbd2cSJim Jagielski return nRet;
2522*b1cdbd2cSJim Jagielski }
2523*b1cdbd2cSJim Jagielski
ChgThisLines()2524*b1cdbd2cSJim Jagielski void SwTxtFrm::ChgThisLines()
2525*b1cdbd2cSJim Jagielski {
2526*b1cdbd2cSJim Jagielski //not necassary to format here (GerFormatted etc.), because we have to come from there!
2527*b1cdbd2cSJim Jagielski
2528*b1cdbd2cSJim Jagielski sal_uLong nNew = 0;
2529*b1cdbd2cSJim Jagielski const SwLineNumberInfo &rInf = GetNode()->getIDocumentLineNumberAccess()->GetLineNumberInfo();
2530*b1cdbd2cSJim Jagielski if ( GetTxt().Len() && HasPara() )
2531*b1cdbd2cSJim Jagielski {
2532*b1cdbd2cSJim Jagielski SwTxtSizeInfo aInf( this );
2533*b1cdbd2cSJim Jagielski SwTxtMargin aLine( this, &aInf );
2534*b1cdbd2cSJim Jagielski if ( rInf.IsCountBlankLines() )
2535*b1cdbd2cSJim Jagielski {
2536*b1cdbd2cSJim Jagielski aLine.Bottom();
2537*b1cdbd2cSJim Jagielski nNew = (sal_uLong)aLine.GetLineNr();
2538*b1cdbd2cSJim Jagielski }
2539*b1cdbd2cSJim Jagielski else
2540*b1cdbd2cSJim Jagielski {
2541*b1cdbd2cSJim Jagielski do
2542*b1cdbd2cSJim Jagielski {
2543*b1cdbd2cSJim Jagielski if( aLine.GetCurr()->HasCntnt() )
2544*b1cdbd2cSJim Jagielski ++nNew;
2545*b1cdbd2cSJim Jagielski } while ( aLine.NextLine() );
2546*b1cdbd2cSJim Jagielski }
2547*b1cdbd2cSJim Jagielski }
2548*b1cdbd2cSJim Jagielski else if ( rInf.IsCountBlankLines() )
2549*b1cdbd2cSJim Jagielski nNew = 1;
2550*b1cdbd2cSJim Jagielski
2551*b1cdbd2cSJim Jagielski if ( nNew != nThisLines )
2552*b1cdbd2cSJim Jagielski {
2553*b1cdbd2cSJim Jagielski if ( !IsInTab() && GetAttrSet()->GetLineNumber().IsCount() )
2554*b1cdbd2cSJim Jagielski {
2555*b1cdbd2cSJim Jagielski nAllLines -= nThisLines;
2556*b1cdbd2cSJim Jagielski nThisLines = nNew;
2557*b1cdbd2cSJim Jagielski nAllLines += nThisLines;
2558*b1cdbd2cSJim Jagielski SwFrm *pNxt = GetNextCntntFrm();
2559*b1cdbd2cSJim Jagielski while( pNxt && pNxt->IsInTab() )
2560*b1cdbd2cSJim Jagielski {
2561*b1cdbd2cSJim Jagielski if( 0 != (pNxt = pNxt->FindTabFrm()) )
2562*b1cdbd2cSJim Jagielski pNxt = pNxt->FindNextCnt();
2563*b1cdbd2cSJim Jagielski }
2564*b1cdbd2cSJim Jagielski if( pNxt )
2565*b1cdbd2cSJim Jagielski pNxt->InvalidateLineNum();
2566*b1cdbd2cSJim Jagielski
2567*b1cdbd2cSJim Jagielski //Extend repaint to the bottom.
2568*b1cdbd2cSJim Jagielski if ( HasPara() )
2569*b1cdbd2cSJim Jagielski {
2570*b1cdbd2cSJim Jagielski SwRepaint *pRepaint = GetPara()->GetRepaint();
2571*b1cdbd2cSJim Jagielski pRepaint->Bottom( Max( pRepaint->Bottom(),
2572*b1cdbd2cSJim Jagielski Frm().Top()+Prt().Bottom()));
2573*b1cdbd2cSJim Jagielski }
2574*b1cdbd2cSJim Jagielski }
2575*b1cdbd2cSJim Jagielski else //Paragraphs which are not counted should not manipulate the AllLines.
2576*b1cdbd2cSJim Jagielski nThisLines = nNew;
2577*b1cdbd2cSJim Jagielski }
2578*b1cdbd2cSJim Jagielski
2579*b1cdbd2cSJim Jagielski //mba: invalidating is not necessary; if mongolian script has a problem, it should be fixed at the ritgh place
2580*b1cdbd2cSJim Jagielski //with invalidating we probably get too much flickering
2581*b1cdbd2cSJim Jagielski //Badaa: 2008-04-18 * Support for Classical Mongolian Script (SCMS) joint with Jiayanmin
2582*b1cdbd2cSJim Jagielski //Ugly. How can we hack if better?
2583*b1cdbd2cSJim Jagielski //InvalidatePage();
2584*b1cdbd2cSJim Jagielski }
2585*b1cdbd2cSJim Jagielski
2586*b1cdbd2cSJim Jagielski
RecalcAllLines()2587*b1cdbd2cSJim Jagielski void SwTxtFrm::RecalcAllLines()
2588*b1cdbd2cSJim Jagielski {
2589*b1cdbd2cSJim Jagielski ValidateLineNum();
2590*b1cdbd2cSJim Jagielski
2591*b1cdbd2cSJim Jagielski const SwAttrSet *pAttrSet = GetAttrSet();
2592*b1cdbd2cSJim Jagielski
2593*b1cdbd2cSJim Jagielski if ( !IsInTab() )
2594*b1cdbd2cSJim Jagielski {
2595*b1cdbd2cSJim Jagielski const sal_uLong nOld = GetAllLines();
2596*b1cdbd2cSJim Jagielski const SwFmtLineNumber &rLineNum = pAttrSet->GetLineNumber();
2597*b1cdbd2cSJim Jagielski sal_uLong nNewNum;
2598*b1cdbd2cSJim Jagielski const bool bRestart = GetTxtNode()->getIDocumentLineNumberAccess()->GetLineNumberInfo().IsRestartEachPage();
2599*b1cdbd2cSJim Jagielski
2600*b1cdbd2cSJim Jagielski if ( !IsFollow() && rLineNum.GetStartValue() && rLineNum.IsCount() )
2601*b1cdbd2cSJim Jagielski nNewNum = rLineNum.GetStartValue() - 1;
2602*b1cdbd2cSJim Jagielski //If it is a follow or not has not be considered if it is a restart at each page; the
2603*b1cdbd2cSJim Jagielski //restart should also take affekt at follows.
2604*b1cdbd2cSJim Jagielski else if ( bRestart && FindPageFrm()->FindFirstBodyCntnt() == this )
2605*b1cdbd2cSJim Jagielski {
2606*b1cdbd2cSJim Jagielski nNewNum = 0;
2607*b1cdbd2cSJim Jagielski }
2608*b1cdbd2cSJim Jagielski else
2609*b1cdbd2cSJim Jagielski {
2610*b1cdbd2cSJim Jagielski SwCntntFrm *pPrv = GetPrevCntntFrm();
2611*b1cdbd2cSJim Jagielski while ( pPrv &&
2612*b1cdbd2cSJim Jagielski (pPrv->IsInTab() || pPrv->IsInDocBody() != IsInDocBody()) )
2613*b1cdbd2cSJim Jagielski pPrv = pPrv->GetPrevCntntFrm();
2614*b1cdbd2cSJim Jagielski
2615*b1cdbd2cSJim Jagielski // --> FME 2007-06-22 #i78254# Restart line numbering at page change:
2616*b1cdbd2cSJim Jagielski // First body content may be in table!
2617*b1cdbd2cSJim Jagielski if ( bRestart && pPrv && pPrv->FindPageFrm() != FindPageFrm() )
2618*b1cdbd2cSJim Jagielski pPrv = 0;
2619*b1cdbd2cSJim Jagielski // <--
2620*b1cdbd2cSJim Jagielski
2621*b1cdbd2cSJim Jagielski nNewNum = pPrv ? ((SwTxtFrm*)pPrv)->GetAllLines() : 0;
2622*b1cdbd2cSJim Jagielski }
2623*b1cdbd2cSJim Jagielski if ( rLineNum.IsCount() )
2624*b1cdbd2cSJim Jagielski nNewNum += GetThisLines();
2625*b1cdbd2cSJim Jagielski
2626*b1cdbd2cSJim Jagielski if ( nOld != nNewNum )
2627*b1cdbd2cSJim Jagielski {
2628*b1cdbd2cSJim Jagielski nAllLines = nNewNum;
2629*b1cdbd2cSJim Jagielski SwCntntFrm *pNxt = GetNextCntntFrm();
2630*b1cdbd2cSJim Jagielski while ( pNxt &&
2631*b1cdbd2cSJim Jagielski (pNxt->IsInTab() || pNxt->IsInDocBody() != IsInDocBody()) )
2632*b1cdbd2cSJim Jagielski pNxt = pNxt->GetNextCntntFrm();
2633*b1cdbd2cSJim Jagielski if ( pNxt )
2634*b1cdbd2cSJim Jagielski {
2635*b1cdbd2cSJim Jagielski if ( pNxt->GetUpper() != GetUpper() )
2636*b1cdbd2cSJim Jagielski pNxt->InvalidateLineNum();
2637*b1cdbd2cSJim Jagielski else
2638*b1cdbd2cSJim Jagielski pNxt->_InvalidateLineNum();
2639*b1cdbd2cSJim Jagielski }
2640*b1cdbd2cSJim Jagielski }
2641*b1cdbd2cSJim Jagielski }
2642*b1cdbd2cSJim Jagielski }
2643*b1cdbd2cSJim Jagielski
VisitPortions(SwPortionHandler & rPH) const2644*b1cdbd2cSJim Jagielski void SwTxtFrm::VisitPortions( SwPortionHandler& rPH ) const
2645*b1cdbd2cSJim Jagielski {
2646*b1cdbd2cSJim Jagielski const SwParaPortion* pPara = GetPara();
2647*b1cdbd2cSJim Jagielski
2648*b1cdbd2cSJim Jagielski if( pPara )
2649*b1cdbd2cSJim Jagielski {
2650*b1cdbd2cSJim Jagielski if ( IsFollow() )
2651*b1cdbd2cSJim Jagielski rPH.Skip( GetOfst() );
2652*b1cdbd2cSJim Jagielski
2653*b1cdbd2cSJim Jagielski const SwLineLayout* pLine = pPara;
2654*b1cdbd2cSJim Jagielski while ( pLine )
2655*b1cdbd2cSJim Jagielski {
2656*b1cdbd2cSJim Jagielski const SwLinePortion* pPor = pLine->GetFirstPortion();
2657*b1cdbd2cSJim Jagielski while ( pPor )
2658*b1cdbd2cSJim Jagielski {
2659*b1cdbd2cSJim Jagielski pPor->HandlePortion( rPH );
2660*b1cdbd2cSJim Jagielski pPor = pPor->GetPortion();
2661*b1cdbd2cSJim Jagielski }
2662*b1cdbd2cSJim Jagielski
2663*b1cdbd2cSJim Jagielski rPH.LineBreak();
2664*b1cdbd2cSJim Jagielski pLine = pLine->GetNext();
2665*b1cdbd2cSJim Jagielski }
2666*b1cdbd2cSJim Jagielski }
2667*b1cdbd2cSJim Jagielski
2668*b1cdbd2cSJim Jagielski rPH.Finish();
2669*b1cdbd2cSJim Jagielski }
2670*b1cdbd2cSJim Jagielski
2671*b1cdbd2cSJim Jagielski
2672*b1cdbd2cSJim Jagielski /*************************************************************************
2673*b1cdbd2cSJim Jagielski * SwTxtFrm::GetScriptInfo()
2674*b1cdbd2cSJim Jagielski *************************************************************************/
2675*b1cdbd2cSJim Jagielski
GetScriptInfo() const2676*b1cdbd2cSJim Jagielski const SwScriptInfo* SwTxtFrm::GetScriptInfo() const
2677*b1cdbd2cSJim Jagielski {
2678*b1cdbd2cSJim Jagielski const SwParaPortion* pPara = GetPara();
2679*b1cdbd2cSJim Jagielski return pPara ? &pPara->GetScriptInfo() : 0;
2680*b1cdbd2cSJim Jagielski }
2681*b1cdbd2cSJim Jagielski
2682*b1cdbd2cSJim Jagielski /*************************************************************************
2683*b1cdbd2cSJim Jagielski * lcl_CalcFlyBasePos()
2684*b1cdbd2cSJim Jagielski * Helper function for SwTxtFrm::CalcBasePosForFly()
2685*b1cdbd2cSJim Jagielski *************************************************************************/
2686*b1cdbd2cSJim Jagielski
lcl_CalcFlyBasePos(const SwTxtFrm & rFrm,SwRect aFlyRect,SwTxtFly & rTxtFly)2687*b1cdbd2cSJim Jagielski SwTwips lcl_CalcFlyBasePos( const SwTxtFrm& rFrm, SwRect aFlyRect,
2688*b1cdbd2cSJim Jagielski SwTxtFly& rTxtFly )
2689*b1cdbd2cSJim Jagielski {
2690*b1cdbd2cSJim Jagielski SWRECTFN( (&rFrm) )
2691*b1cdbd2cSJim Jagielski SwTwips nRet = rFrm.IsRightToLeft() ?
2692*b1cdbd2cSJim Jagielski (rFrm.Frm().*fnRect->fnGetRight)() :
2693*b1cdbd2cSJim Jagielski (rFrm.Frm().*fnRect->fnGetLeft)();
2694*b1cdbd2cSJim Jagielski
2695*b1cdbd2cSJim Jagielski do
2696*b1cdbd2cSJim Jagielski {
2697*b1cdbd2cSJim Jagielski SwRect aRect = rTxtFly.GetFrm( aFlyRect );
2698*b1cdbd2cSJim Jagielski if ( 0 != (aRect.*fnRect->fnGetWidth)() )
2699*b1cdbd2cSJim Jagielski {
2700*b1cdbd2cSJim Jagielski if ( rFrm.IsRightToLeft() )
2701*b1cdbd2cSJim Jagielski {
2702*b1cdbd2cSJim Jagielski if ( (aRect.*fnRect->fnGetRight)() -
2703*b1cdbd2cSJim Jagielski (aFlyRect.*fnRect->fnGetRight)() >= 0 )
2704*b1cdbd2cSJim Jagielski {
2705*b1cdbd2cSJim Jagielski (aFlyRect.*fnRect->fnSetRight)(
2706*b1cdbd2cSJim Jagielski (aRect.*fnRect->fnGetLeft)() );
2707*b1cdbd2cSJim Jagielski nRet = (aRect.*fnRect->fnGetLeft)();
2708*b1cdbd2cSJim Jagielski }
2709*b1cdbd2cSJim Jagielski else
2710*b1cdbd2cSJim Jagielski break;
2711*b1cdbd2cSJim Jagielski }
2712*b1cdbd2cSJim Jagielski else
2713*b1cdbd2cSJim Jagielski {
2714*b1cdbd2cSJim Jagielski if ( (aFlyRect.*fnRect->fnGetLeft)() -
2715*b1cdbd2cSJim Jagielski (aRect.*fnRect->fnGetLeft)() >= 0 )
2716*b1cdbd2cSJim Jagielski {
2717*b1cdbd2cSJim Jagielski (aFlyRect.*fnRect->fnSetLeft)(
2718*b1cdbd2cSJim Jagielski (aRect.*fnRect->fnGetRight)() + 1 );
2719*b1cdbd2cSJim Jagielski nRet = (aRect.*fnRect->fnGetRight)();
2720*b1cdbd2cSJim Jagielski }
2721*b1cdbd2cSJim Jagielski else
2722*b1cdbd2cSJim Jagielski break;
2723*b1cdbd2cSJim Jagielski }
2724*b1cdbd2cSJim Jagielski }
2725*b1cdbd2cSJim Jagielski else
2726*b1cdbd2cSJim Jagielski break;
2727*b1cdbd2cSJim Jagielski }
2728*b1cdbd2cSJim Jagielski while ( (aFlyRect.*fnRect->fnGetWidth)() > 0 );
2729*b1cdbd2cSJim Jagielski
2730*b1cdbd2cSJim Jagielski return nRet;
2731*b1cdbd2cSJim Jagielski }
2732*b1cdbd2cSJim Jagielski
2733*b1cdbd2cSJim Jagielski /*************************************************************************
2734*b1cdbd2cSJim Jagielski * SwTxtFrm::CalcBasePosForFly()
2735*b1cdbd2cSJim Jagielski *************************************************************************/
2736*b1cdbd2cSJim Jagielski
CalcBaseOfstForFly()2737*b1cdbd2cSJim Jagielski void SwTxtFrm::CalcBaseOfstForFly()
2738*b1cdbd2cSJim Jagielski {
2739*b1cdbd2cSJim Jagielski ASSERT( !IsVertical() || !IsSwapped(),
2740*b1cdbd2cSJim Jagielski "SwTxtFrm::CalcBasePosForFly with swapped frame!" )
2741*b1cdbd2cSJim Jagielski
2742*b1cdbd2cSJim Jagielski const SwNode* pNode = GetTxtNode();
2743*b1cdbd2cSJim Jagielski if ( !pNode->getIDocumentSettingAccess()->get(IDocumentSettingAccess::ADD_FLY_OFFSETS) )
2744*b1cdbd2cSJim Jagielski return;
2745*b1cdbd2cSJim Jagielski
2746*b1cdbd2cSJim Jagielski SWRECTFN( this )
2747*b1cdbd2cSJim Jagielski
2748*b1cdbd2cSJim Jagielski SwRect aFlyRect( Frm().Pos() + Prt().Pos(), Prt().SSize() );
2749*b1cdbd2cSJim Jagielski
2750*b1cdbd2cSJim Jagielski // Get first 'real' line and adjust position and height of line rectangle
2751*b1cdbd2cSJim Jagielski // OD 08.09.2003 #110978#, #108749#, #110354# - correct behaviour,
2752*b1cdbd2cSJim Jagielski // if no 'real' line exists (empty paragraph with and without a dummy portion)
2753*b1cdbd2cSJim Jagielski {
2754*b1cdbd2cSJim Jagielski SwTwips nTop = (aFlyRect.*fnRect->fnGetTop)();
2755*b1cdbd2cSJim Jagielski const SwLineLayout* pLay = GetPara();
2756*b1cdbd2cSJim Jagielski SwTwips nLineHeight = 200;
2757*b1cdbd2cSJim Jagielski while( pLay && pLay->IsDummy() && pLay->GetNext() )
2758*b1cdbd2cSJim Jagielski {
2759*b1cdbd2cSJim Jagielski nTop += pLay->Height();
2760*b1cdbd2cSJim Jagielski pLay = pLay->GetNext();
2761*b1cdbd2cSJim Jagielski }
2762*b1cdbd2cSJim Jagielski if ( pLay )
2763*b1cdbd2cSJim Jagielski {
2764*b1cdbd2cSJim Jagielski nLineHeight = pLay->Height();
2765*b1cdbd2cSJim Jagielski }
2766*b1cdbd2cSJim Jagielski (aFlyRect.*fnRect->fnSetTopAndHeight)( nTop, nLineHeight );
2767*b1cdbd2cSJim Jagielski }
2768*b1cdbd2cSJim Jagielski
2769*b1cdbd2cSJim Jagielski SwTxtFly aTxtFly( this );
2770*b1cdbd2cSJim Jagielski aTxtFly.SetIgnoreCurrentFrame( sal_True );
2771*b1cdbd2cSJim Jagielski aTxtFly.SetIgnoreContour( sal_True );
2772*b1cdbd2cSJim Jagielski // --> OD 2004-12-17 #118809# - ignore objects in page header|footer for
2773*b1cdbd2cSJim Jagielski // text frames not in page header|footer
2774*b1cdbd2cSJim Jagielski aTxtFly.SetIgnoreObjsInHeaderFooter( sal_True );
2775*b1cdbd2cSJim Jagielski // <--
2776*b1cdbd2cSJim Jagielski SwTwips nRet1 = lcl_CalcFlyBasePos( *this, aFlyRect, aTxtFly );
2777*b1cdbd2cSJim Jagielski aTxtFly.SetIgnoreCurrentFrame( sal_False );
2778*b1cdbd2cSJim Jagielski SwTwips nRet2 = lcl_CalcFlyBasePos( *this, aFlyRect, aTxtFly );
2779*b1cdbd2cSJim Jagielski
2780*b1cdbd2cSJim Jagielski // make values relative to frame start position
2781*b1cdbd2cSJim Jagielski SwTwips nLeft = IsRightToLeft() ?
2782*b1cdbd2cSJim Jagielski (Frm().*fnRect->fnGetRight)() :
2783*b1cdbd2cSJim Jagielski (Frm().*fnRect->fnGetLeft)();
2784*b1cdbd2cSJim Jagielski
2785*b1cdbd2cSJim Jagielski mnFlyAnchorOfst = nRet1 - nLeft;
2786*b1cdbd2cSJim Jagielski mnFlyAnchorOfstNoWrap = nRet2 - nLeft;
2787*b1cdbd2cSJim Jagielski }
2788*b1cdbd2cSJim Jagielski
2789*b1cdbd2cSJim Jagielski /* repaint all text frames of the given text node */
repaintTextFrames(const SwTxtNode & rNode)2790*b1cdbd2cSJim Jagielski void SwTxtFrm::repaintTextFrames( const SwTxtNode& rNode )
2791*b1cdbd2cSJim Jagielski {
2792*b1cdbd2cSJim Jagielski SwIterator<SwTxtFrm,SwTxtNode> aIter( rNode );
2793*b1cdbd2cSJim Jagielski for( const SwTxtFrm *pFrm = aIter.First(); pFrm; pFrm = aIter.Next() )
2794*b1cdbd2cSJim Jagielski {
2795*b1cdbd2cSJim Jagielski SwRect aRec( pFrm->PaintArea() );
2796*b1cdbd2cSJim Jagielski const SwRootFrm *pRootFrm = pFrm->getRootFrm();
2797*b1cdbd2cSJim Jagielski ViewShell *pCurShell = pRootFrm ? pRootFrm->GetCurrShell() : NULL;
2798*b1cdbd2cSJim Jagielski if( pCurShell )
2799*b1cdbd2cSJim Jagielski pCurShell->InvalidateWindows( aRec );
2800*b1cdbd2cSJim Jagielski }
2801*b1cdbd2cSJim Jagielski }
2802*b1cdbd2cSJim Jagielski
2803