Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <hintids.hxx>
21 : #include <sfx2/printer.hxx>
22 : #include <editeng/lspcitem.hxx>
23 : #include <editeng/adjustitem.hxx>
24 : #include <editeng/escapementitem.hxx>
25 : #include <editeng/lrspitem.hxx>
26 : #include <editeng/pgrditem.hxx>
27 : #include <vcl/window.hxx>
28 : #include <vcl/svapp.hxx>
29 : #include <viewsh.hxx>
30 : #include <viewopt.hxx>
31 : #include <ndtxt.hxx>
32 : #include <pagefrm.hxx>
33 : #include <paratr.hxx>
34 : #include <SwPortionHandler.hxx>
35 : #include <porrst.hxx>
36 : #include <inftxt.hxx>
37 : #include <txtpaint.hxx>
38 : #include <swfntcch.hxx>
39 : #include <tgrditem.hxx>
40 : #include <pagedesc.hxx>
41 : #include <frmatr.hxx>
42 : #include <redlnitr.hxx>
43 : #include <porfly.hxx>
44 : #include <atrhndl.hxx>
45 : #include "rootfrm.hxx"
46 :
47 : #include <IDocumentRedlineAccess.hxx>
48 : #include <IDocumentSettingAccess.hxx>
49 : #include <IDocumentDeviceAccess.hxx>
50 :
51 : #include <crsrsh.hxx>
52 :
53 : /*************************************************************************
54 : * class SwTmpEndPortion
55 : *************************************************************************/
56 :
57 0 : SwTmpEndPortion::SwTmpEndPortion( const SwLinePortion &rPortion )
58 : {
59 0 : Height( rPortion.Height() );
60 0 : SetAscent( rPortion.GetAscent() );
61 0 : SetWhichPor( POR_TMPEND );
62 0 : }
63 :
64 : /*************************************************************************
65 : * virtual SwTmpEndPortion::Paint()
66 : *************************************************************************/
67 :
68 0 : void SwTmpEndPortion::Paint( const SwTxtPaintInfo &rInf ) const
69 : {
70 0 : if( rInf.OnWin() && rInf.GetOpt().IsParagraph() )
71 : {
72 0 : rInf.DrawSpecial( *this, CH_PAR, Color(NON_PRINTING_CHARACTER_COLOR) );
73 : }
74 0 : }
75 :
76 : /*************************************************************************
77 : * class SwBreakPortion
78 : *************************************************************************/
79 0 : SwBreakPortion::SwBreakPortion( const SwLinePortion &rPortion )
80 0 : : SwLinePortion( rPortion )
81 : {
82 0 : nLineLength = 1;
83 0 : SetWhichPor( POR_BRK );
84 0 : }
85 :
86 0 : sal_Int32 SwBreakPortion::GetCrsrOfst( const KSHORT ) const
87 0 : { return 0; }
88 :
89 0 : KSHORT SwBreakPortion::GetViewWidth( const SwTxtSizeInfo & ) const
90 0 : { return 0; }
91 :
92 0 : SwLinePortion *SwBreakPortion::Compress()
93 0 : { return (GetPortion() && GetPortion()->InTxtGrp() ? 0 : this); }
94 :
95 0 : void SwBreakPortion::Paint( const SwTxtPaintInfo &rInf ) const
96 : {
97 0 : if( rInf.OnWin() && rInf.GetOpt().IsLineBreak() )
98 0 : rInf.DrawLineBreak( *this );
99 0 : }
100 :
101 : /*************************************************************************
102 : * virtual SwBreakPortion::Format()
103 : *************************************************************************/
104 :
105 0 : bool SwBreakPortion::Format( SwTxtFormatInfo &rInf )
106 : {
107 0 : const SwLinePortion *pRoot = rInf.GetRoot();
108 0 : Width( 0 );
109 0 : Height( pRoot->Height() );
110 0 : SetAscent( pRoot->GetAscent() );
111 0 : if ( rInf.GetIdx()+1 == rInf.GetTxt().getLength() )
112 0 : rInf.SetNewLine( true );
113 0 : return true;
114 : }
115 :
116 : /*************************************************************************
117 : * virtual SwBreakPortion::HandlePortion()
118 : *************************************************************************/
119 :
120 0 : void SwBreakPortion::HandlePortion( SwPortionHandler& rPH ) const
121 : {
122 0 : rPH.Text( GetLen(), GetWhichPor() );
123 0 : }
124 :
125 0 : SwKernPortion::SwKernPortion( SwLinePortion &rPortion, short nKrn,
126 : bool bBG, bool bGK ) :
127 0 : nKern( nKrn ), bBackground( bBG ), bGridKern( bGK )
128 : {
129 0 : Height( rPortion.Height() );
130 0 : SetAscent( rPortion.GetAscent() );
131 0 : nLineLength = 0;
132 0 : SetWhichPor( POR_KERN );
133 0 : if( nKern > 0 )
134 0 : Width( nKern );
135 0 : rPortion.Insert( this );
136 0 : }
137 :
138 0 : SwKernPortion::SwKernPortion( const SwLinePortion& rPortion ) :
139 0 : nKern( 0 ), bBackground( false ), bGridKern( true )
140 : {
141 0 : Height( rPortion.Height() );
142 0 : SetAscent( rPortion.GetAscent() );
143 :
144 0 : nLineLength = 0;
145 0 : SetWhichPor( POR_KERN );
146 0 : }
147 :
148 0 : void SwKernPortion::Paint( const SwTxtPaintInfo &rInf ) const
149 : {
150 0 : if( Width() )
151 : {
152 : // bBackground is set for Kerning Portions between two fields
153 0 : if ( bBackground )
154 0 : rInf.DrawViewOpt( *this, POR_FLD );
155 :
156 0 : rInf.DrawBackBrush( *this );
157 :
158 : // do we have to repaint a post it portion?
159 0 : if( rInf.OnWin() && pPortion && !pPortion->Width() )
160 0 : pPortion->PrePaint( rInf, this );
161 :
162 0 : if( rInf.GetFont()->IsPaintBlank() )
163 : {
164 0 : OUString aTxtDouble(" ");
165 :
166 0 : SwRect aClipRect;
167 0 : rInf.CalcRect( *this, &aClipRect, 0 );
168 0 : SwSaveClip aClip( (OutputDevice*)rInf.GetOut() );
169 0 : aClip.ChgClip( aClipRect, 0 );
170 0 : rInf.DrawText( aTxtDouble, *this, 0, 2, true );
171 : }
172 : }
173 0 : }
174 :
175 0 : void SwKernPortion::FormatEOL( SwTxtFormatInfo &rInf )
176 : {
177 0 : if ( bGridKern )
178 0 : return;
179 :
180 0 : if( rInf.GetLast() == this )
181 0 : rInf.SetLast( FindPrevPortion( rInf.GetRoot() ) );
182 0 : if( nKern < 0 )
183 0 : Width( -nKern );
184 : else
185 0 : Width( 0 );
186 0 : rInf.GetLast()->FormatEOL( rInf );
187 : }
188 :
189 0 : SwArrowPortion::SwArrowPortion( const SwLinePortion &rPortion ) :
190 0 : bLeft( true )
191 : {
192 0 : Height( rPortion.Height() );
193 0 : SetAscent( rPortion.GetAscent() );
194 0 : nLineLength = 0;
195 0 : SetWhichPor( POR_ARROW );
196 0 : }
197 :
198 0 : SwArrowPortion::SwArrowPortion( const SwTxtPaintInfo &rInf )
199 0 : : bLeft( false )
200 : {
201 0 : Height( (sal_uInt16)(rInf.GetTxtFrm()->Prt().Height()) );
202 0 : aPos.X() = rInf.GetTxtFrm()->Frm().Left() +
203 0 : rInf.GetTxtFrm()->Prt().Right();
204 0 : aPos.Y() = rInf.GetTxtFrm()->Frm().Top() +
205 0 : rInf.GetTxtFrm()->Prt().Bottom();
206 0 : SetWhichPor( POR_ARROW );
207 0 : }
208 :
209 0 : void SwArrowPortion::Paint( const SwTxtPaintInfo &rInf ) const
210 : {
211 0 : ((SwArrowPortion*)this)->aPos = rInf.GetPos();
212 0 : }
213 :
214 0 : SwLinePortion *SwArrowPortion::Compress() { return this; }
215 :
216 0 : SwTwips SwTxtFrm::EmptyHeight() const
217 : {
218 0 : if (IsCollapse()) {
219 0 : SwViewShell *pSh = getRootFrm()->GetCurrShell();
220 0 : if ( pSh->IsA( TYPE(SwCrsrShell) ) ) {
221 0 : SwCrsrShell *pCrSh=(SwCrsrShell*)pSh;
222 0 : SwCntntFrm *pCurrFrm=pCrSh->GetCurrFrm();
223 0 : if (pCurrFrm==(SwCntntFrm*)this) {
224 : // do nothing
225 : } else {
226 0 : return 1;
227 : }
228 : } else {
229 0 : return 1;
230 : }
231 : }
232 : OSL_ENSURE( ! IsVertical() || ! IsSwapped(),"SwTxtFrm::EmptyHeight with swapped frame" );
233 :
234 : SwFont *pFnt;
235 0 : const SwTxtNode& rTxtNode = *GetTxtNode();
236 0 : const IDocumentSettingAccess* pIDSA = rTxtNode.getIDocumentSettingAccess();
237 0 : SwViewShell *pSh = getRootFrm()->GetCurrShell();
238 0 : if ( rTxtNode.HasSwAttrSet() )
239 : {
240 0 : const SwAttrSet *pAttrSet = &( rTxtNode.GetSwAttrSet() );
241 0 : pFnt = new SwFont( pAttrSet, pIDSA );
242 : }
243 : else
244 : {
245 0 : SwFontAccess aFontAccess( &rTxtNode.GetAnyFmtColl(), pSh);
246 0 : pFnt = new SwFont( *aFontAccess.Get()->GetFont() );
247 0 : pFnt->ChkMagic( pSh, pFnt->GetActual() );
248 : }
249 :
250 0 : if ( IsVertical() )
251 0 : pFnt->SetVertical( 2700 );
252 :
253 0 : OutputDevice* pOut = pSh ? pSh->GetOut() : 0;
254 0 : if ( !pOut || !pSh->GetViewOptions()->getBrowseMode() ||
255 0 : pSh->GetViewOptions()->IsPrtFormat() )
256 : {
257 0 : pOut = rTxtNode.getIDocumentDeviceAccess()->getReferenceDevice(true);
258 : }
259 :
260 0 : const IDocumentRedlineAccess* pIDRA = rTxtNode.getIDocumentRedlineAccess();
261 0 : if( IDocumentRedlineAccess::IsShowChanges( pIDRA->GetRedlineMode() ) )
262 : {
263 0 : MSHORT nRedlPos = pIDRA->GetRedlinePos( rTxtNode, USHRT_MAX );
264 0 : if( MSHRT_MAX != nRedlPos )
265 : {
266 0 : SwAttrHandler aAttrHandler;
267 0 : aAttrHandler.Init( GetTxtNode()->GetSwAttrSet(),
268 0 : *GetTxtNode()->getIDocumentSettingAccess(), NULL );
269 : SwRedlineItr aRedln( rTxtNode, *pFnt, aAttrHandler,
270 0 : nRedlPos, true );
271 : }
272 : }
273 :
274 : SwTwips nRet;
275 0 : if( !pOut )
276 0 : nRet = IsVertical() ?
277 0 : Prt().SSize().Width() + 1 :
278 0 : Prt().SSize().Height() + 1;
279 : else
280 : {
281 0 : pFnt->SetFntChg( true );
282 0 : pFnt->ChgPhysFnt( pSh, *pOut );
283 0 : nRet = pFnt->GetHeight( pSh, *pOut );
284 : }
285 0 : delete pFnt;
286 0 : return nRet;
287 : }
288 :
289 : /*************************************************************************
290 : * SwTxtFrm::FormatEmpty()
291 : *************************************************************************/
292 :
293 0 : bool SwTxtFrm::FormatEmpty()
294 : {
295 : OSL_ENSURE( ! IsVertical() || ! IsSwapped(),"SwTxtFrm::FormatEmpty with swapped frame" );
296 :
297 0 : bool bCollapse = EmptyHeight( ) == 1 && this->IsCollapse( );
298 :
299 0 : if ( HasFollow() || GetTxtNode()->GetpSwpHints() ||
300 0 : 0 != GetTxtNode()->GetNumRule() ||
301 0 : GetTxtNode()->HasHiddenCharAttribute( true ) ||
302 0 : IsInFtn() || ( HasPara() && GetPara()->IsPrepMustFit() ) )
303 0 : return false;
304 0 : const SwAttrSet& aSet = GetTxtNode()->GetSwAttrSet();
305 0 : const SvxAdjust nAdjust = aSet.GetAdjust().GetAdjust();
306 0 : if( !bCollapse && ( ( ( ! IsRightToLeft() && ( SVX_ADJUST_LEFT != nAdjust ) ) ||
307 0 : ( IsRightToLeft() && ( SVX_ADJUST_RIGHT != nAdjust ) ) ) ||
308 0 : aSet.GetRegister().GetValue() ) )
309 0 : return false;
310 0 : const SvxLineSpacingItem &rSpacing = aSet.GetLineSpacing();
311 0 : if( !bCollapse && ( SVX_LINE_SPACE_MIN == rSpacing.GetLineSpaceRule() ||
312 0 : SVX_LINE_SPACE_FIX == rSpacing.GetLineSpaceRule() ||
313 0 : aSet.GetLRSpace().IsAutoFirst() ) )
314 0 : return false;
315 :
316 0 : SwTxtFly aTxtFly( this );
317 0 : SwRect aRect;
318 0 : bool bFirstFlyCheck = 0 != Prt().Height();
319 0 : if ( !bCollapse && bFirstFlyCheck &&
320 0 : aTxtFly.IsOn() && aTxtFly.IsAnyObj( aRect ) )
321 0 : return false;
322 :
323 0 : SwTwips nHeight = EmptyHeight();
324 :
325 0 : if ( GetTxtNode()->GetSwAttrSet().GetParaGrid().GetValue() &&
326 0 : IsInDocBody() )
327 : {
328 0 : SwTextGridItem const*const pGrid(GetGridItem(FindPageFrm()));
329 0 : if ( pGrid )
330 0 : nHeight = pGrid->GetBaseHeight() + pGrid->GetRubyHeight();
331 : }
332 :
333 0 : SWRECTFN( this )
334 0 : const SwTwips nChg = nHeight - (Prt().*fnRect->fnGetHeight)();
335 :
336 0 : if( !nChg )
337 0 : SetUndersized( false );
338 0 : AdjustFrm( nChg );
339 :
340 0 : if( HasBlinkPor() )
341 : {
342 0 : ClearPara();
343 0 : ResetBlinkPor();
344 : }
345 0 : SetCacheIdx( MSHRT_MAX );
346 0 : if( !IsEmpty() )
347 : {
348 0 : SetEmpty( true );
349 0 : SetCompletePaint();
350 : }
351 0 : if( !bCollapse && !bFirstFlyCheck &&
352 0 : aTxtFly.IsOn() && aTxtFly.IsAnyObj( aRect ) )
353 0 : return false;
354 :
355 : // #i35635# - call method <HideAndShowObjects()>
356 : // to assure that objects anchored at the empty paragraph are
357 : // correctly visible resp. invisible.
358 0 : HideAndShowObjects();
359 0 : return true;
360 : }
361 :
362 0 : bool SwTxtFrm::FillRegister( SwTwips& rRegStart, KSHORT& rRegDiff )
363 : {
364 0 : const SwFrm *pFrm = this;
365 0 : rRegDiff = 0;
366 0 : while( !( ( FRM_BODY | FRM_FLY )
367 0 : & pFrm->GetType() ) && pFrm->GetUpper() )
368 0 : pFrm = pFrm->GetUpper();
369 0 : if( ( FRM_BODY| FRM_FLY ) & pFrm->GetType() )
370 : {
371 0 : SWRECTFN( pFrm )
372 0 : rRegStart = (pFrm->*fnRect->fnGetPrtTop)();
373 0 : pFrm = pFrm->FindPageFrm();
374 0 : if( pFrm->IsPageFrm() )
375 : {
376 0 : SwPageDesc* pDesc = ((SwPageFrm*)pFrm)->FindPageDesc();
377 0 : if( pDesc )
378 : {
379 0 : rRegDiff = pDesc->GetRegHeight();
380 0 : if( !rRegDiff )
381 : {
382 0 : const SwTxtFmtColl *pFmt = pDesc->GetRegisterFmtColl();
383 0 : if( pFmt )
384 : {
385 0 : const SvxLineSpacingItem &rSpace = pFmt->GetLineSpacing();
386 0 : if( SVX_LINE_SPACE_FIX == rSpace.GetLineSpaceRule() )
387 : {
388 0 : rRegDiff = rSpace.GetLineHeight();
389 0 : pDesc->SetRegHeight( rRegDiff );
390 0 : pDesc->SetRegAscent( ( 4 * rRegDiff ) / 5 );
391 : }
392 : else
393 : {
394 0 : SwViewShell *pSh = getRootFrm()->GetCurrShell();
395 0 : SwFontAccess aFontAccess( pFmt, pSh );
396 0 : SwFont aFnt( *aFontAccess.Get()->GetFont() );
397 :
398 0 : OutputDevice *pOut = 0;
399 0 : if( !pSh || !pSh->GetViewOptions()->getBrowseMode() ||
400 0 : pSh->GetViewOptions()->IsPrtFormat() )
401 0 : pOut = GetTxtNode()->getIDocumentDeviceAccess()->getReferenceDevice( true );
402 :
403 0 : if( pSh && !pOut )
404 0 : pOut = pSh->GetWin();
405 :
406 0 : if( !pOut )
407 0 : pOut = GetpApp()->GetDefaultDevice();
408 :
409 0 : MapMode aOldMap( pOut->GetMapMode() );
410 0 : pOut->SetMapMode( MapMode( MAP_TWIP ) );
411 :
412 0 : aFnt.ChgFnt( pSh, *pOut );
413 0 : rRegDiff = aFnt.GetHeight( pSh, *pOut );
414 0 : KSHORT nNettoHeight = rRegDiff;
415 :
416 0 : switch( rSpace.GetLineSpaceRule() )
417 : {
418 : case SVX_LINE_SPACE_AUTO:
419 0 : break;
420 : case SVX_LINE_SPACE_MIN:
421 : {
422 0 : if( rRegDiff < KSHORT( rSpace.GetLineHeight() ) )
423 0 : rRegDiff = rSpace.GetLineHeight();
424 0 : break;
425 : }
426 : default:
427 : OSL_FAIL( ": unknown LineSpaceRule" );
428 : }
429 0 : switch( rSpace.GetInterLineSpaceRule() )
430 : {
431 : case SVX_INTER_LINE_SPACE_OFF:
432 0 : break;
433 : case SVX_INTER_LINE_SPACE_PROP:
434 : {
435 0 : long nTmp = rSpace.GetPropLineSpace();
436 0 : if( nTmp < 50 )
437 0 : nTmp = nTmp ? 50 : 100;
438 0 : nTmp *= rRegDiff;
439 0 : nTmp /= 100;
440 0 : if( !nTmp )
441 0 : ++nTmp;
442 0 : rRegDiff = (KSHORT)nTmp;
443 0 : nNettoHeight = rRegDiff;
444 0 : break;
445 : }
446 : case SVX_INTER_LINE_SPACE_FIX:
447 : {
448 0 : rRegDiff = rRegDiff + rSpace.GetInterLineSpace();
449 0 : nNettoHeight = rRegDiff;
450 0 : break;
451 : }
452 : default: OSL_FAIL( ": unknown InterLineSpaceRule" );
453 : }
454 0 : pDesc->SetRegHeight( rRegDiff );
455 : pDesc->SetRegAscent( rRegDiff - nNettoHeight +
456 0 : aFnt.GetAscent( pSh, *pOut ) );
457 0 : pOut->SetMapMode( aOldMap );
458 : }
459 : }
460 : }
461 0 : const long nTmpDiff = pDesc->GetRegAscent() - rRegDiff;
462 0 : if ( bVert )
463 0 : rRegStart -= nTmpDiff;
464 : else
465 0 : rRegStart += nTmpDiff;
466 : }
467 : }
468 : }
469 0 : return ( 0 != rRegDiff );
470 : }
471 :
472 : /*************************************************************************
473 : * virtual SwHiddenTextPortion::Paint()
474 : *************************************************************************/
475 :
476 0 : void SwHiddenTextPortion::Paint( const SwTxtPaintInfo & rInf) const
477 : {
478 : (void)rInf;
479 : #ifdef DBG_UTIL
480 : OutputDevice* pOut = (OutputDevice*)rInf.GetOut();
481 : Color aCol( SwViewOption::GetFieldShadingsColor() );
482 : Color aOldColor( pOut->GetFillColor() );
483 : pOut->SetFillColor( aCol );
484 : Point aPos( rInf.GetPos() );
485 : aPos.Y() -= 150;
486 : aPos.X() -= 25;
487 : SwRect aRect( aPos, Size( 100, 200 ) );
488 : ((OutputDevice*)pOut)->DrawRect( aRect.SVRect() );
489 : pOut->SetFillColor( aOldColor );
490 : #endif
491 0 : }
492 :
493 : /*************************************************************************
494 : * virtual SwHiddenTextPortion::Format()
495 : *************************************************************************/
496 :
497 0 : bool SwHiddenTextPortion::Format( SwTxtFormatInfo &rInf )
498 : {
499 0 : Width( 0 );
500 0 : rInf.GetTxtFrm()->HideFootnotes( rInf.GetIdx(), rInf.GetIdx() + GetLen() );
501 :
502 0 : return false;
503 : };
504 :
505 : /*************************************************************************
506 : * virtual SwControlCharPortion::Paint()
507 : *************************************************************************/
508 :
509 0 : void SwControlCharPortion::Paint( const SwTxtPaintInfo &rInf ) const
510 : {
511 0 : if ( Width() ) // is only set during prepaint mode
512 : {
513 0 : rInf.DrawViewOpt( *this, POR_CONTROLCHAR );
514 :
515 0 : if ( !rInf.GetOpt().IsPagePreview() &&
516 0 : !rInf.GetOpt().IsReadonly() &&
517 0 : SwViewOption::IsFieldShadings() &&
518 0 : CHAR_ZWNBSP != mcChar )
519 : {
520 0 : SwFont aTmpFont( *rInf.GetFont() );
521 0 : aTmpFont.SetEscapement( CHAR_ZWSP == mcChar ? DFLT_ESC_AUTO_SUB : -25 );
522 0 : const sal_uInt16 nProp = 40;
523 0 : aTmpFont.SetProportion( nProp ); // a smaller font
524 0 : SwFontSave aFontSave( rInf, &aTmpFont );
525 :
526 0 : OUString aOutString;
527 :
528 0 : switch ( mcChar )
529 : {
530 : case CHAR_ZWSP :
531 0 : aOutString = "/"; break;
532 : // case CHAR_LRM :
533 : // rTxt = sal_Unicode(0x2514); break;
534 : // case CHAR_RLM :
535 : // rTxt = sal_Unicode(0x2518); break;
536 : }
537 :
538 0 : if ( !mnHalfCharWidth )
539 0 : mnHalfCharWidth = rInf.GetTxtSize( aOutString ).Width() / 2;
540 :
541 0 : Point aOldPos = rInf.GetPos();
542 0 : Point aNewPos( aOldPos );
543 0 : aNewPos.X() = aNewPos.X() + ( Width() / 2 ) - mnHalfCharWidth;
544 0 : const_cast< SwTxtPaintInfo& >( rInf ).SetPos( aNewPos );
545 :
546 0 : rInf.DrawText( aOutString, *this );
547 :
548 0 : const_cast< SwTxtPaintInfo& >( rInf ).SetPos( aOldPos );
549 : }
550 : }
551 0 : }
552 :
553 : /*************************************************************************
554 : * virtual SwControlCharPortion::Format()
555 : *************************************************************************/
556 :
557 0 : bool SwControlCharPortion::Format( SwTxtFormatInfo &rInf )
558 : {
559 0 : const SwLinePortion* pRoot = rInf.GetRoot();
560 0 : Width( 0 );
561 0 : Height( pRoot->Height() );
562 0 : SetAscent( pRoot->GetAscent() );
563 :
564 0 : return false;
565 : }
566 :
567 : /*************************************************************************
568 : * virtual SwControlCharPortion::GetViewWidth()
569 : *************************************************************************/
570 :
571 0 : KSHORT SwControlCharPortion::GetViewWidth( const SwTxtSizeInfo& rInf ) const
572 : {
573 0 : if( !mnViewWidth )
574 0 : mnViewWidth = rInf.GetTxtSize(OUString(' ')).Width();
575 :
576 0 : return mnViewWidth;
577 : }
578 :
579 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
