| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| |
| #include <hintids.hxx> |
| |
| #include <com/sun/star/i18n/ScriptType.hdl> |
| #include <vcl/graph.hxx> |
| #include <editeng/brshitem.hxx> |
| #include <vcl/metric.hxx> |
| #include <vcl/outdev.hxx> |
| #include <viewopt.hxx> // SwViewOptions |
| #include <txtcfg.hxx> |
| #include <SwPortionHandler.hxx> |
| #include <porlay.hxx> |
| #include <porfld.hxx> |
| #include <inftxt.hxx> |
| #include <blink.hxx> // pBlink |
| #include <frmtool.hxx> // DrawGraphic |
| #include <viewsh.hxx> |
| #include <docsh.hxx> |
| #include <doc.hxx> |
| #include "rootfrm.hxx" |
| #include <breakit.hxx> |
| #include <porrst.hxx> |
| #include <porftn.hxx> // SwFtnPortion |
| #include <accessibilityoptions.hxx> |
| #include <editeng/lrspitem.hxx> |
| |
| #include <unicode/ubidi.h> |
| |
| using namespace ::com::sun::star; |
| |
| /************************************************************************* |
| * class SwFldPortion |
| *************************************************************************/ |
| |
| SwLinePortion *SwFldPortion::Compress() |
| { return (GetLen() || aExpand.Len() || SwLinePortion::Compress()) ? this : 0; } |
| |
| SwFldPortion *SwFldPortion::Clone( const XubString &rExpand ) const |
| { |
| SwFont *pNewFnt; |
| if( 0 != ( pNewFnt = pFnt ) ) |
| { |
| pNewFnt = new SwFont( *pFnt ); |
| } |
| SwFldPortion* pClone = new SwFldPortion( rExpand, pNewFnt, bPlaceHolder ); |
| pClone->SetNextOffset( nNextOffset ); |
| pClone->m_bNoLength = this->m_bNoLength; |
| return pClone; |
| } |
| |
| void SwFldPortion::TakeNextOffset( const SwFldPortion* pFld ) |
| { |
| ASSERT( pFld, "TakeNextOffset: Missing Source" ); |
| nNextOffset = pFld->GetNextOffset(); |
| aExpand.Erase( 0, nNextOffset ); |
| bFollow = sal_True; |
| } |
| |
| SwFldPortion::SwFldPortion( const XubString &rExpand, SwFont *pFont, sal_Bool bPlaceHold ) |
| : aExpand(rExpand), pFnt(pFont), nNextOffset(0), nNextScriptChg(STRING_LEN), nViewWidth(0), |
| bFollow( sal_False ), bHasFollow( sal_False ), bPlaceHolder( bPlaceHold ) |
| , m_bNoLength( sal_False ) |
| { |
| SetWhichPor( POR_FLD ); |
| m_nAttrFldType = 0; |
| } |
| |
| SwFldPortion::SwFldPortion( const SwFldPortion& rFld ) |
| : SwExpandPortion( rFld ), |
| aExpand( rFld.GetExp() ), |
| nNextOffset( rFld.GetNextOffset() ), |
| nNextScriptChg( rFld.GetNextScriptChg() ), |
| bFollow( rFld.IsFollow() ), |
| bLeft( rFld.IsLeft() ), |
| bHide( rFld.IsHide() ), |
| bCenter( rFld.IsCenter() ), |
| bHasFollow( rFld.HasFollow() ), |
| bPlaceHolder( rFld.bPlaceHolder ) |
| , m_bNoLength( rFld.m_bNoLength ) |
| { |
| if ( rFld.HasFont() ) |
| pFnt = new SwFont( *rFld.GetFont() ); |
| else |
| pFnt = 0; |
| |
| SetWhichPor( POR_FLD ); |
| } |
| |
| SwFldPortion::~SwFldPortion() |
| { |
| delete pFnt; |
| if( pBlink ) |
| pBlink->Delete( this ); |
| } |
| |
| /************************************************************************* |
| * virtual SwFldPortion::GetViewWidth() |
| *************************************************************************/ |
| |
| KSHORT SwFldPortion::GetViewWidth( const SwTxtSizeInfo &rInf ) const |
| { |
| // Wir stehen zwar im const, aber nViewWidth sollte erst im letzten |
| // Moment errechnet werden: |
| SwFldPortion* pThis = (SwFldPortion*)this; |
| if( !Width() && rInf.OnWin() && !rInf.GetOpt().IsPagePreview() && |
| !rInf.GetOpt().IsReadonly() && SwViewOption::IsFieldShadings() ) |
| { |
| if( !nViewWidth ) |
| pThis->nViewWidth = rInf.GetTxtSize( ' ' ).Width(); |
| } |
| else |
| pThis->nViewWidth = 0; |
| return nViewWidth; |
| } |
| |
| /************************************************************************* |
| * virtual SwFldPortion::Format() |
| *************************************************************************/ |
| |
| // 8653: in keinem Fall nur SetLen(0); |
| |
| /************************************************************************* |
| * Hilfsklasse SwFldSlot |
| **************************************************************************/ |
| |
| class SwFldSlot |
| { |
| const XubString *pOldTxt; |
| XubString aTxt; |
| xub_StrLen nIdx; |
| xub_StrLen nLen; |
| sal_Bool bOn; |
| SwTxtFormatInfo *pInf; |
| public: |
| SwFldSlot( const SwTxtFormatInfo* pNew, const SwFldPortion *pPor ); |
| ~SwFldSlot(); |
| }; |
| |
| SwFldSlot::SwFldSlot( const SwTxtFormatInfo* pNew, const SwFldPortion *pPor ) |
| { |
| bOn = pPor->GetExpTxt( *pNew, aTxt ); |
| |
| // Der Text wird ausgetauscht... |
| if( bOn ) |
| { |
| pInf = (SwTxtFormatInfo*)pNew; |
| nIdx = pInf->GetIdx(); |
| nLen = pInf->GetLen(); |
| pOldTxt = &(pInf->GetTxt()); |
| pInf->SetLen( aTxt.Len() ); |
| if( pPor->IsFollow() ) |
| { |
| pInf->SetFakeLineStart( nIdx > pInf->GetLineStart() ); |
| pInf->SetIdx( 0 ); |
| } |
| else |
| { |
| XubString aTmp( aTxt ); |
| aTxt = *pOldTxt; |
| aTxt.Erase( nIdx, 1 ); |
| aTxt.Insert( aTmp, nIdx ); |
| } |
| pInf->SetTxt( aTxt ); |
| } |
| } |
| |
| SwFldSlot::~SwFldSlot() |
| { |
| if( bOn ) |
| { |
| pInf->SetTxt( *pOldTxt ); |
| pInf->SetIdx( nIdx ); |
| pInf->SetLen( nLen ); |
| pInf->SetFakeLineStart( sal_False ); |
| } |
| } |
| |
| void SwFldPortion::CheckScript( const SwTxtSizeInfo &rInf ) |
| { |
| String aTxt; |
| if( GetExpTxt( rInf, aTxt ) && aTxt.Len() && pBreakIt->GetBreakIter().is() ) |
| { |
| sal_uInt8 nActual = pFnt ? pFnt->GetActual() : rInf.GetFont()->GetActual(); |
| sal_uInt16 nScript; |
| { |
| nScript = pBreakIt->GetBreakIter()->getScriptType( aTxt, 0 ); |
| xub_StrLen nChg = 0; |
| if( i18n::ScriptType::WEAK == nScript ) |
| { |
| nChg =(xub_StrLen)pBreakIt->GetBreakIter()->endOfScript(aTxt,0,nScript); |
| if( nChg < aTxt.Len() ) |
| nScript = pBreakIt->GetBreakIter()->getScriptType( aTxt, nChg ); |
| } |
| |
| // |
| // nNextScriptChg will be evaluated during SwFldPortion::Format() |
| // |
| if ( nChg < aTxt.Len() ) |
| nNextScriptChg = (xub_StrLen)pBreakIt->GetBreakIter()->endOfScript( aTxt, nChg, nScript ); |
| else |
| nNextScriptChg = aTxt.Len(); |
| |
| } |
| sal_uInt8 nTmp; |
| switch ( nScript ) { |
| case i18n::ScriptType::LATIN : nTmp = SW_LATIN; break; |
| case i18n::ScriptType::ASIAN : nTmp = SW_CJK; break; |
| case i18n::ScriptType::COMPLEX : nTmp = SW_CTL; break; |
| default: nTmp = nActual; |
| } |
| |
| // #i16354# Change script type for RTL text to CTL. |
| const SwScriptInfo& rSI = rInf.GetParaPortion()->GetScriptInfo(); |
| // --> OD 2009-01-29 #i98418# |
| // const sal_uInt8 nFldDir = IsNumberPortion() ? |
| const sal_uInt8 nFldDir = ( IsNumberPortion() || IsFtnNumPortion() ) ? |
| rSI.GetDefaultDir() : |
| rSI.DirType( IsFollow() ? rInf.GetIdx() - 1 : rInf.GetIdx() ); |
| // <-- |
| if ( UBIDI_RTL == nFldDir ) |
| { |
| UErrorCode nError = U_ZERO_ERROR; |
| UBiDi* pBidi = ubidi_openSized( aTxt.Len(), 0, &nError ); |
| ubidi_setPara( pBidi, reinterpret_cast<const UChar *>(aTxt.GetBuffer()), aTxt.Len(), nFldDir, NULL, &nError ); |
| int32_t nEnd; |
| UBiDiLevel nCurrDir; |
| ubidi_getLogicalRun( pBidi, 0, &nEnd, &nCurrDir ); |
| ubidi_close( pBidi ); |
| const xub_StrLen nNextDirChg = (xub_StrLen)nEnd; |
| nNextScriptChg = Min( nNextScriptChg, nNextDirChg ); |
| |
| // #i89825# change the script type also to CTL |
| // if there is no strong LTR char in the LTR run (numbers) |
| if ( nCurrDir != UBIDI_RTL ) |
| { |
| nCurrDir = UBIDI_RTL; |
| for ( xub_StrLen nCharIdx = 0; nCharIdx < nEnd; ++nCharIdx ) |
| { |
| UCharDirection nCharDir = u_charDirection ( aTxt.GetChar ( nCharIdx )); |
| if ( nCharDir == U_LEFT_TO_RIGHT || |
| nCharDir == U_LEFT_TO_RIGHT_EMBEDDING || |
| nCharDir == U_LEFT_TO_RIGHT_OVERRIDE ) |
| { |
| nCurrDir = UBIDI_LTR; |
| break; |
| } |
| } |
| } |
| |
| if ( nCurrDir == UBIDI_RTL ) |
| nTmp = SW_CTL; |
| } |
| |
| // --> OD 2009-01-29 #i98418# |
| // keep determined script type for footnote portions as preferred script type. |
| // For footnote portions a font can not be created directly - see footnote |
| // portion format method. |
| // if( !IsFtnPortion() && nTmp != nActual ) |
| if ( IsFtnPortion() ) |
| { |
| dynamic_cast<SwFtnPortion*>(this)->SetPreferredScriptType( nTmp ); |
| } |
| else if ( nTmp != nActual ) |
| { |
| if( !pFnt ) |
| pFnt = new SwFont( *rInf.GetFont() ); |
| pFnt->SetActual( nTmp ); |
| } |
| // <-- |
| } |
| } |
| |
| sal_Bool SwFldPortion::Format( SwTxtFormatInfo &rInf ) |
| { |
| // Scope wegen aDiffTxt::DTOR! |
| xub_StrLen nRest; |
| sal_Bool bFull; |
| sal_Bool bEOL = sal_False; |
| long nTxtRest = rInf.GetTxt().Len() - rInf.GetIdx(); |
| { |
| SwFldSlot aDiffTxt( &rInf, this ); |
| SwLayoutModeModifier aLayoutModeModifier( *rInf.GetOut() ); |
| aLayoutModeModifier.SetAuto(); |
| |
| // Field portion has to be split in several parts if |
| // 1. There are script/direction changes inside the field |
| // 2. There are portion breaks (tab, break) inside the field: |
| const xub_StrLen nOldFullLen = rInf.GetLen(); |
| xub_StrLen nFullLen = rInf.ScanPortionEnd( rInf.GetIdx(), rInf.GetIdx() + nOldFullLen ) - rInf.GetIdx(); |
| if ( nNextScriptChg < nFullLen ) |
| { |
| nFullLen = nNextScriptChg; |
| rInf.SetHookChar( 0 ); |
| } |
| rInf.SetLen( nFullLen ); |
| |
| if ( STRING_LEN != rInf.GetUnderScorePos() && |
| rInf.GetUnderScorePos() > rInf.GetIdx() ) |
| rInf.SetUnderScorePos( rInf.GetIdx() ); |
| |
| if( pFnt ) |
| pFnt->GoMagic( rInf.GetVsh(), pFnt->GetActual() ); |
| |
| SwFontSave aSave( rInf, pFnt ); |
| |
| // 8674: Laenge muss 0 sein, bei bFull nach Format ist die Laenge |
| // gesetzt und wird in nRest uebertragen. Ansonsten bleibt die |
| // Laenge erhalten und wuerde auch in nRest einfliessen! |
| SetLen(0); |
| const MSHORT nFollow = IsFollow() ? 0 : 1; |
| |
| // So komisch es aussieht, die Abfrage auf GetLen() muss wegen der |
| // ExpandPortions _hinter_ aDiffTxt (vgl. SoftHyphs) |
| // sal_False returnen wegen SetFull ... |
| if( !nFullLen ) |
| { |
| // nicht Init(), weil wir Hoehe und Ascent brauchen |
| Width(0); |
| bFull = rInf.Width() <= rInf.GetPos().X(); |
| } |
| else |
| { |
| xub_StrLen nOldLineStart = rInf.GetLineStart(); |
| if( IsFollow() ) |
| rInf.SetLineStart( 0 ); |
| rInf.SetNotEOL( nFullLen == nOldFullLen && nTxtRest > nFollow ); |
| |
| // the height depending on the fields font is set, |
| // this is required for SwTxtGuess::Guess |
| Height( rInf.GetTxtHeight() ); |
| // If a kerning portion is inserted after our field portion, |
| // the ascent and height must be known |
| SetAscent( rInf.GetAscent() ); |
| bFull = SwTxtPortion::Format( rInf ); |
| rInf.SetNotEOL( sal_False ); |
| rInf.SetLineStart( nOldLineStart ); |
| } |
| xub_StrLen nTmpLen = GetLen(); |
| bEOL = !nTmpLen && nFollow && bFull; |
| nRest = nOldFullLen - nTmpLen; |
| |
| // Das Zeichen wird in der ersten Portion gehalten. |
| // Unbedingt nach Format! |
| SetLen( (m_bNoLength) ? 0 : nFollow ); |
| |
| if( nRest ) |
| { |
| // aExpand ist noch nicht gekuerzt worden, der neue Ofst |
| // ergibt sich durch nRest. |
| xub_StrLen nNextOfst = aExpand.Len() - nRest; |
| |
| if ( IsQuoVadisPortion() ) |
| nNextOfst = nNextOfst + ((SwQuoVadisPortion*)this)->GetContTxt().Len(); |
| |
| XubString aNew( aExpand, nNextOfst, STRING_LEN ); |
| aExpand.Erase( nNextOfst, STRING_LEN ); |
| |
| // These characters should not be contained in the follow |
| // field portion. They are handled via the HookChar mechanism. |
| switch( aNew.GetChar( 0 )) |
| { |
| case CH_BREAK : bFull = sal_True; |
| // kein break; |
| case ' ' : |
| case CH_TAB : |
| case CHAR_HARDHYPHEN: // non-breaking hyphen |
| case CHAR_SOFTHYPHEN: |
| case CHAR_HARDBLANK: |
| case CHAR_ZWSP : |
| case CHAR_ZWNBSP : |
| case CH_TXTATR_BREAKWORD: |
| case CH_TXTATR_INWORD: |
| { |
| aNew.Erase( 0, 1 ); |
| ++nNextOfst; |
| break; |
| } |
| default: ; |
| } |
| |
| // Even if there is no more text left for a follow field, |
| // we have to build a follow field portion (without font), |
| // otherwise the HookChar mechanism would not work. |
| SwFldPortion *pFld = Clone( aNew ); |
| if( aNew.Len() && !pFld->GetFont() ) |
| { |
| SwFont *pNewFnt = new SwFont( *rInf.GetFont() ); |
| pFld->SetFont( pNewFnt ); |
| } |
| pFld->SetFollow( sal_True ); |
| SetHasFollow( sal_True ); |
| // In nNextOffset steht bei einem neuangelegten Feld zunaechst |
| // der Offset, an dem es selbst im Originalstring beginnt. |
| // Wenn beim Formatieren ein FollowFeld angelegt wird, wird |
| // der Offset dieses FollowFelds in nNextOffset festgehalten. |
| nNextOffset = nNextOffset + nNextOfst; |
| pFld->SetNextOffset( nNextOffset ); |
| rInf.SetRest( pFld ); |
| } |
| } |
| |
| if( bEOL && rInf.GetLast() && !rInf.GetUnderFlow() ) |
| rInf.GetLast()->FormatEOL( rInf ); |
| return bFull; |
| } |
| |
| /************************************************************************* |
| * virtual SwFldPortion::Paint() |
| *************************************************************************/ |
| |
| void SwFldPortion::Paint( const SwTxtPaintInfo &rInf ) const |
| { |
| SwFontSave aSave( rInf, pFnt ); |
| |
| ASSERT( GetLen() <= 1, "SwFldPortion::Paint: rest-portion polution?" ); |
| if( Width() && ( !bPlaceHolder || rInf.GetOpt().IsShowPlaceHolderFields() ) ) |
| { |
| // Dies ist eine freizuegige Auslegung der Hintergrundbelegung ... |
| rInf.DrawViewOpt( *this, POR_FLD ); |
| SwExpandPortion::Paint( rInf ); |
| } |
| } |
| |
| /************************************************************************* |
| * virtual SwFldPortion::GetExpTxt() |
| *************************************************************************/ |
| |
| sal_Bool SwFldPortion::GetExpTxt( const SwTxtSizeInfo &rInf, XubString &rTxt ) const |
| { |
| rTxt = aExpand; |
| if( !rTxt.Len() && rInf.OnWin() && |
| !rInf.GetOpt().IsPagePreview() && !rInf.GetOpt().IsReadonly() && |
| SwViewOption::IsFieldShadings() && |
| !HasFollow() ) |
| rTxt = ' '; |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| * virtual SwFldPortion::HandlePortion() |
| *************************************************************************/ |
| |
| void SwFldPortion::HandlePortion( SwPortionHandler& rPH ) const |
| { |
| rPH.Special( GetLen(), aExpand, GetWhichPor() ); |
| if( GetWhichPor() == POR_FLD ) |
| { |
| rPH.SetAttrFieldType(m_nAttrFldType); |
| } |
| } |
| |
| /************************************************************************* |
| * virtual SwFldPortion::GetTxtSize() |
| *************************************************************************/ |
| |
| SwPosSize SwFldPortion::GetTxtSize( const SwTxtSizeInfo &rInf ) const |
| { |
| SwFontSave aSave( rInf, pFnt ); |
| SwPosSize aSize( SwExpandPortion::GetTxtSize( rInf ) ); |
| return aSize; |
| } |
| |
| /************************************************************************* |
| * class SwHiddenPortion |
| *************************************************************************/ |
| |
| SwFldPortion *SwHiddenPortion::Clone(const XubString &rExpand ) const |
| { |
| SwFont *pNewFnt; |
| if( 0 != ( pNewFnt = pFnt ) ) |
| pNewFnt = new SwFont( *pFnt ); |
| return new SwHiddenPortion( rExpand, pNewFnt ); |
| } |
| |
| /************************************************************************* |
| * virtual SwHiddenPortion::Paint() |
| *************************************************************************/ |
| |
| void SwHiddenPortion::Paint( const SwTxtPaintInfo &rInf ) const |
| { |
| if( Width() ) |
| { |
| SwFontSave aSave( rInf, pFnt ); |
| rInf.DrawViewOpt( *this, POR_HIDDEN ); |
| SwExpandPortion::Paint( rInf ); |
| } |
| } |
| |
| /************************************************************************* |
| * virtual SwHiddenPortion::GetExpTxt() |
| *************************************************************************/ |
| |
| sal_Bool SwHiddenPortion::GetExpTxt( const SwTxtSizeInfo &rInf, XubString &rTxt ) const |
| { |
| // Nicht auf IsHidden() abfragen ! |
| return SwFldPortion::GetExpTxt( rInf, rTxt ); |
| } |
| |
| /************************************************************************* |
| * class SwNumberPortion |
| *************************************************************************/ |
| |
| // --> OD 2008-01-23 #newlistlevelattrs# |
| SwNumberPortion::SwNumberPortion( const XubString &rExpand, |
| SwFont *pFont, |
| const sal_Bool bLft, |
| const sal_Bool bCntr, |
| const KSHORT nMinDst, |
| const bool bLabelAlignmentPosAndSpaceModeActive ) |
| : SwFldPortion( rExpand, pFont ), |
| nFixWidth(0), |
| nMinDist( nMinDst ), |
| // --> OD 2008-01-23 #newlistlevelattrs# |
| mbLabelAlignmentPosAndSpaceModeActive( bLabelAlignmentPosAndSpaceModeActive ) |
| // <-- |
| { |
| SetWhichPor( POR_NUMBER ); |
| SetLeft( bLft ); |
| SetHide( sal_False ); |
| SetCenter( bCntr ); |
| } |
| |
| xub_StrLen SwNumberPortion::GetCrsrOfst( const MSHORT ) const |
| { |
| return 0; |
| } |
| |
| SwFldPortion *SwNumberPortion::Clone( const XubString &rExpand ) const |
| { |
| SwFont *pNewFnt; |
| if( 0 != ( pNewFnt = pFnt ) ) |
| pNewFnt = new SwFont( *pFnt ); |
| // --> OD 2008-01-23 #newlistlevelattrs# |
| return new SwNumberPortion( rExpand, pNewFnt, IsLeft(), IsCenter(), |
| nMinDist, mbLabelAlignmentPosAndSpaceModeActive ); |
| // <-- |
| } |
| |
| /************************************************************************* |
| * virtual SwNumberPortion::Format() |
| *************************************************************************/ |
| |
| // 5010: Wir sind in der Lage, mehrzeilige NumFelder anzulegen! |
| // 3689: Fies ist, wenn man in der Dialogbox soviel Davor-Text |
| // eingibt, bis die Zeile ueberlaeuft. |
| // Man muss die Fly-Ausweichmanoever beachten! |
| |
| sal_Bool SwNumberPortion::Format( SwTxtFormatInfo &rInf ) |
| { |
| SetHide( sal_False ); |
| const sal_Bool bFull = SwFldPortion::Format( rInf ); |
| SetLen( 0 ); |
| // a numbering portion can be contained in a rotated portion!!! |
| nFixWidth = rInf.IsMulti() ? Height() : Width(); |
| rInf.SetNumDone( !rInf.GetRest() ); |
| if( rInf.IsNumDone() ) |
| { |
| // SetAscent( rInf.GetAscent() ); |
| ASSERT( Height() && nAscent, "NumberPortions without Height | Ascent" ); |
| |
| long nDiff( 0 ); |
| // --> OD 2008-01-23 #newlistlevelattrs# |
| if ( !mbLabelAlignmentPosAndSpaceModeActive ) |
| { |
| if ( !rInf.GetTxtFrm()->GetTxtNode()->getIDocumentSettingAccess()->get(IDocumentSettingAccess::IGNORE_FIRST_LINE_INDENT_IN_NUMBERING) && |
| // --> FME 2004-08-13 #i32902# |
| !IsFtnNumPortion() ) |
| // <-- |
| { |
| nDiff = rInf.Left() |
| + rInf.GetTxtFrm()->GetTxtNode()-> |
| GetSwAttrSet().GetLRSpace().GetTxtFirstLineOfst() |
| - rInf.First() |
| + rInf.ForcedLeftMargin(); |
| } |
| else |
| { |
| nDiff = rInf.Left() - rInf.First() + rInf.ForcedLeftMargin(); |
| } |
| } |
| // <-- |
| // Ein Vorschlag von Juergen und Volkmar: |
| // Der Textteil hinter der Numerierung sollte immer |
| // mindestens beim linken Rand beginnen. |
| if( nDiff < 0 ) |
| nDiff = 0; |
| else if ( nDiff > rInf.X() ) |
| nDiff -= rInf.X(); |
| else |
| nDiff = 0; |
| |
| if( nDiff < nFixWidth + nMinDist ) |
| nDiff = nFixWidth + nMinDist; |
| // 2739: Numerierung weicht Fly aus, kein nDiff in der zweiten Runde |
| // fieser Sonderfall: FlyFrm liegt in dem Bereich, |
| // den wir uns gerade unter den Nagel reissen wollen. |
| // Die NumberPortion wird als verborgen markiert. |
| const sal_Bool bFly = rInf.GetFly() || |
| ( rInf.GetLast() && rInf.GetLast()->IsFlyPortion() ); |
| if( nDiff > rInf.Width() ) |
| { |
| nDiff = rInf.Width(); |
| if ( bFly ) |
| SetHide( sal_True ); |
| } |
| |
| // A numbering portion can be inside a SwRotatedPortion. Then the |
| // Height has to be changed |
| if ( rInf.IsMulti() ) |
| { |
| if ( Height() < nDiff ) |
| Height( KSHORT( nDiff ) ); |
| } |
| else if( Width() < nDiff ) |
| Width( KSHORT(nDiff) ); |
| } |
| return bFull; |
| } |
| |
| void SwNumberPortion::FormatEOL( SwTxtFormatInfo& ) |
| { |
| /* Ein FormatEOL deutet daraufhin, dass der folgende Text |
| * nicht mit auf die Zeile passte. Damit die Numerierung mitwandert, |
| * wird diese NumberPortion verborgen. |
| */ |
| |
| // This caused trouble with flys anchored as characters. |
| // If one of these is numbered but does not fit to the line, |
| // it calls this function, causing a loop because both the number |
| // portion and the fly portion go to the next line |
| // SetHide( sal_True ); |
| } |
| |
| /************************************************************************* |
| * virtual SwNumberPortion::Paint() |
| *************************************************************************/ |
| |
| void SwNumberPortion::Paint( const SwTxtPaintInfo &rInf ) const |
| { |
| /* Eine verborgene NumberPortion wird nicht angezeigt, es sei denn, es gibt |
| * Textportions in dieser Zeile oder es gibt ueberhaupt nur eine einzige Zeile. |
| */ |
| |
| if ( IsHide() && rInf.GetParaPortion() && rInf.GetParaPortion()->GetNext() ) |
| { |
| SwLinePortion *pTmp = GetPortion(); |
| while ( pTmp && !pTmp->InTxtGrp() ) |
| pTmp = pTmp->GetPortion(); |
| if ( !pTmp ) |
| return; |
| } |
| |
| // calculate the width of the number portion, including follows |
| const KSHORT nOldWidth = Width(); |
| sal_uInt16 nSumWidth = 0; |
| sal_uInt16 nOffset = 0; |
| |
| const SwLinePortion* pTmp = this; |
| while ( pTmp && pTmp->InNumberGrp() ) |
| { |
| nSumWidth = nSumWidth + pTmp->Width(); |
| if ( ((SwNumberPortion*)pTmp)->HasFollow() ) |
| pTmp = pTmp->GetPortion(); |
| else |
| { |
| nOffset = pTmp->Width() - ((SwNumberPortion*)pTmp)->nFixWidth; |
| break; |
| } |
| } |
| |
| // The master portion takes care for painting the background of the |
| // follow field portions |
| if ( ! IsFollow() ) |
| { |
| SwLinePortion *pThis = (SwLinePortion*)this; |
| pThis->Width( nSumWidth ); |
| rInf.DrawViewOpt( *this, POR_NUMBER ); |
| pThis->Width( nOldWidth ); |
| } |
| |
| if( aExpand.Len() ) |
| { |
| const SwFont *pTmpFnt = rInf.GetFont(); |
| sal_Bool bPaintSpace = ( UNDERLINE_NONE != pTmpFnt->GetUnderline() || |
| UNDERLINE_NONE != pTmpFnt->GetOverline() || |
| STRIKEOUT_NONE != pTmpFnt->GetStrikeout() ) && |
| !pTmpFnt->IsWordLineMode(); |
| if( bPaintSpace && pFnt ) |
| bPaintSpace = ( UNDERLINE_NONE != pFnt->GetUnderline() || |
| UNDERLINE_NONE != pFnt->GetOverline() || |
| STRIKEOUT_NONE != pFnt->GetStrikeout() ) && |
| !pFnt->IsWordLineMode(); |
| |
| SwFontSave aSave( rInf, pFnt ); |
| |
| if( nFixWidth == Width() && ! HasFollow() ) |
| SwExpandPortion::Paint( rInf ); |
| else |
| { |
| // logisches const: Width wird wieder zurueckgesetzt |
| SwLinePortion *pThis = (SwLinePortion*)this; |
| bPaintSpace = bPaintSpace && nFixWidth < nOldWidth; |
| KSHORT nSpaceOffs = nFixWidth; |
| pThis->Width( nFixWidth ); |
| |
| if( ( IsLeft() && ! rInf.GetTxtFrm()->IsRightToLeft() ) || |
| ( ! IsLeft() && ! IsCenter() && rInf.GetTxtFrm()->IsRightToLeft() ) ) |
| SwExpandPortion::Paint( rInf ); |
| else |
| { |
| SwTxtPaintInfo aInf( rInf ); |
| if( nOffset < nMinDist ) |
| nOffset = 0; |
| else |
| { |
| if( IsCenter() ) |
| { |
| /* #110778# a / 2 * 2 == a is not a tautology */ |
| KSHORT nTmpOffset = nOffset; |
| nOffset /= 2; |
| if( nOffset < nMinDist ) |
| nOffset = nTmpOffset - nMinDist; |
| } |
| else |
| nOffset = nOffset - nMinDist; |
| } |
| aInf.X( aInf.X() + nOffset ); |
| SwExpandPortion::Paint( aInf ); |
| if( bPaintSpace ) |
| nSpaceOffs = nSpaceOffs + nOffset; |
| } |
| if( bPaintSpace && nOldWidth > nSpaceOffs ) |
| { |
| SwTxtPaintInfo aInf( rInf ); |
| static sal_Char __READONLY_DATA sDoubleSpace[] = " "; |
| aInf.X( aInf.X() + nSpaceOffs ); |
| |
| // --> FME 2005-08-12 #i53199# Adjust position of underline: |
| if ( rInf.GetUnderFnt() ) |
| { |
| const Point aNewPos( aInf.GetPos().X(), rInf.GetUnderFnt()->GetPos().Y() ); |
| rInf.GetUnderFnt()->SetPos( aNewPos ); |
| } |
| // <-- |
| |
| pThis->Width( nOldWidth - nSpaceOffs + 12 ); |
| { |
| SwTxtSlot aDiffTxt( &aInf, this, true, false, sDoubleSpace ); |
| aInf.DrawText( *this, aInf.GetLen(), sal_True ); |
| } |
| } |
| pThis->Width( nOldWidth ); |
| } |
| } |
| } |
| |
| |
| /************************************************************************* |
| * class SwBulletPortion |
| *************************************************************************/ |
| |
| // --> OD 2008-01-23 #newlistlevelattrs# |
| SwBulletPortion::SwBulletPortion( const xub_Unicode cBullet, |
| const XubString& rBulletFollowedBy, |
| SwFont *pFont, |
| const sal_Bool bLft, |
| const sal_Bool bCntr, |
| const KSHORT nMinDst, |
| const bool bLabelAlignmentPosAndSpaceModeActive ) |
| : SwNumberPortion( XubString( rBulletFollowedBy ).Insert( cBullet, 0 ) , |
| pFont, bLft, bCntr, nMinDst, |
| bLabelAlignmentPosAndSpaceModeActive ) |
| // <-- |
| { |
| SetWhichPor( POR_BULLET ); |
| } |
| |
| /************************************************************************* |
| * class SwGrfNumPortion |
| *************************************************************************/ |
| |
| #define GRFNUM_SECURE 10 |
| |
| // --> OD 2008-01-23 #newlistlevelattrs# |
| SwGrfNumPortion::SwGrfNumPortion( |
| SwFrm*, |
| const XubString& rGraphicFollowedBy, |
| const SvxBrushItem* pGrfBrush, |
| const SwFmtVertOrient* pGrfOrient, const Size& rGrfSize, |
| const sal_Bool bLft, const sal_Bool bCntr, const KSHORT nMinDst, |
| const bool bLabelAlignmentPosAndSpaceModeActive ) : |
| SwNumberPortion( rGraphicFollowedBy, NULL, bLft, bCntr, nMinDst, |
| bLabelAlignmentPosAndSpaceModeActive ), |
| // <-- |
| pBrush( new SvxBrushItem(RES_BACKGROUND) ), nId( 0 ) |
| { |
| SetWhichPor( POR_GRFNUM ); |
| SetAnimated( sal_False ); |
| bReplace = sal_False; |
| if( pGrfBrush ) |
| { |
| *pBrush = *pGrfBrush; |
| const Graphic* pGraph = pGrfBrush->GetGraphic(); |
| if( pGraph ) |
| SetAnimated( pGraph->IsAnimated() ); |
| else |
| bReplace = sal_True; |
| } |
| if( pGrfOrient ) |
| { |
| nYPos = pGrfOrient->GetPos(); |
| eOrient = pGrfOrient->GetVertOrient(); |
| } |
| else |
| { |
| nYPos = 0; |
| eOrient = text::VertOrientation::TOP; |
| } |
| Width( static_cast<sal_uInt16>(rGrfSize.Width() + 2 * GRFNUM_SECURE) ); |
| nFixWidth = Width(); |
| nGrfHeight = rGrfSize.Height() + 2 * GRFNUM_SECURE; |
| Height( KSHORT(nGrfHeight) ); |
| bNoPaint = sal_False; |
| } |
| |
| SwGrfNumPortion::~SwGrfNumPortion() |
| { |
| if ( IsAnimated() ) |
| ( (Graphic*) pBrush->GetGraphic() )->StopAnimation( 0, nId ); |
| delete pBrush; |
| } |
| |
| void SwGrfNumPortion::StopAnimation( OutputDevice* pOut ) |
| { |
| if ( IsAnimated() ) |
| ( (Graphic*) pBrush->GetGraphic() )->StopAnimation( pOut, nId ); |
| } |
| |
| sal_Bool SwGrfNumPortion::Format( SwTxtFormatInfo &rInf ) |
| { |
| SetHide( sal_False ); |
| // --> OD 2008-01-29 #newlistlevelattrs# |
| // Width( nFixWidth ); |
| KSHORT nFollowedByWidth( 0 ); |
| if ( mbLabelAlignmentPosAndSpaceModeActive ) |
| { |
| SwFldPortion::Format( rInf ); |
| nFollowedByWidth = Width(); |
| SetLen( 0 ); |
| } |
| Width( nFixWidth + nFollowedByWidth ); |
| // <-- |
| const sal_Bool bFull = rInf.Width() < rInf.X() + Width(); |
| const sal_Bool bFly = rInf.GetFly() || |
| ( rInf.GetLast() && rInf.GetLast()->IsFlyPortion() ); |
| SetAscent( static_cast<sal_uInt16>(GetRelPos() > 0 ? GetRelPos() : 0) ); |
| if( GetAscent() > Height() ) |
| Height( GetAscent() ); |
| |
| if( bFull ) |
| { |
| Width( rInf.Width() - (KSHORT)rInf.X() ); |
| if( bFly ) |
| { |
| SetLen( 0 ); |
| SetNoPaint( sal_True ); |
| rInf.SetNumDone( sal_False ); |
| return sal_True; |
| } |
| } |
| rInf.SetNumDone( sal_True ); |
| // --> OD 2008-01-23 #newlistlevelattrs# |
| // long nDiff = rInf.Left() - rInf.First() + rInf.ForcedLeftMargin(); |
| long nDiff = mbLabelAlignmentPosAndSpaceModeActive |
| ? 0 |
| : rInf.Left() - rInf.First() + rInf.ForcedLeftMargin(); |
| // <-- |
| // Ein Vorschlag von Juergen und Volkmar: |
| // Der Textteil hinter der Numerierung sollte immer |
| // mindestens beim linken Rand beginnen. |
| if( nDiff < 0 ) |
| nDiff = 0; |
| else if ( nDiff > rInf.X() ) |
| nDiff -= rInf.X(); |
| if( nDiff < nFixWidth + nMinDist ) |
| nDiff = nFixWidth + nMinDist; |
| // 2739: Numerierung weicht Fly aus, kein nDiff in der zweiten Runde |
| // fieser Sonderfall: FlyFrm liegt in dem Bereich, |
| // den wir uns gerade unter den Nagel reissen wollen. |
| // Die NumberPortion wird als verborgen markiert. |
| if( nDiff > rInf.Width() ) |
| { |
| nDiff = rInf.Width(); |
| if( bFly ) |
| SetHide( sal_True ); |
| } |
| |
| if( Width() < nDiff ) |
| Width( KSHORT(nDiff) ); |
| return bFull; |
| } |
| |
| void SwGrfNumPortion::Paint( const SwTxtPaintInfo &rInf ) const |
| { |
| if( DontPaint() ) |
| return; |
| /* Eine verborgene NumberPortion wird nicht angezeigt, es sei denn, es gibt |
| * Textportions in dieser Zeile oder es gibt ueberhaupt nur eine einzige Zeile. |
| */ |
| if ( IsHide() && rInf.GetParaPortion() && rInf.GetParaPortion()->GetNext() ) |
| { |
| SwLinePortion *pTmp = GetPortion(); |
| while ( pTmp && !pTmp->InTxtGrp() ) |
| pTmp = pTmp->GetPortion(); |
| if ( !pTmp ) |
| return; |
| } |
| Point aPos( rInf.X() + GRFNUM_SECURE, rInf.Y() - GetRelPos() + GRFNUM_SECURE ); |
| long nTmpWidth = Max( (long)0, (long)(nFixWidth - 2 * GRFNUM_SECURE) ); |
| Size aSize( nTmpWidth, GetGrfHeight() - 2 * GRFNUM_SECURE ); |
| |
| // --> OD 2008-02-05 #newlistlevelattrs# |
| const sal_Bool bTmpLeft = mbLabelAlignmentPosAndSpaceModeActive || |
| ( IsLeft() && ! rInf.GetTxtFrm()->IsRightToLeft() ) || |
| ( ! IsLeft() && ! IsCenter() && rInf.GetTxtFrm()->IsRightToLeft() ); |
| // <-- |
| |
| if( nFixWidth < Width() && !bTmpLeft ) |
| { |
| KSHORT nOffset = Width() - nFixWidth; |
| if( nOffset < nMinDist ) |
| nOffset = 0; |
| else |
| { |
| if( IsCenter() ) |
| { |
| nOffset /= 2; |
| if( nOffset < nMinDist ) |
| nOffset = Width() - nFixWidth - nMinDist; |
| } |
| else |
| nOffset = nOffset - nMinDist; |
| } |
| aPos.X() += nOffset; |
| } |
| |
| if( bReplace ) |
| { |
| KSHORT nTmpH = GetPortion() ? GetPortion()->GetAscent() : 120; |
| aSize = Size( nTmpH, nTmpH ); |
| aPos.Y() = rInf.Y() - nTmpH; |
| } |
| SwRect aTmp( aPos, aSize ); |
| |
| sal_Bool bDraw = sal_True; |
| |
| if ( IsAnimated() ) |
| { |
| bDraw = !rInf.GetOpt().IsGraphic(); |
| if( !nId ) |
| { |
| SetId( long( rInf.GetTxtFrm() ) ); |
| rInf.GetTxtFrm()->SetAnimation(); |
| } |
| if( aTmp.IsOver( rInf.GetPaintRect() ) && !bDraw ) |
| { |
| rInf.NoteAnimation(); |
| const ViewShell* pViewShell = rInf.GetVsh(); |
| |
| // virtual device, not pdf export |
| if( OUTDEV_VIRDEV == rInf.GetOut()->GetOutDevType() && |
| pViewShell && pViewShell->GetWin() ) |
| { |
| ( (Graphic*) pBrush->GetGraphic() )->StopAnimation(0,nId); |
| rInf.GetTxtFrm()->getRootFrm()->GetCurrShell()->InvalidateWindows( aTmp ); |
| } |
| |
| |
| else if ( pViewShell && |
| !pViewShell->GetAccessibilityOptions()->IsStopAnimatedGraphics() && |
| !pViewShell->IsPreView() && |
| // --> FME 2004-06-21 #i9684# Stop animation during printing/pdf export. |
| pViewShell->GetWin() ) |
| // <-- |
| { |
| ( (Graphic*) pBrush->GetGraphic() )->StartAnimation( |
| (OutputDevice*)rInf.GetOut(), aPos, aSize, nId ); |
| } |
| |
| // pdf export, printing, preview, stop animations... |
| else |
| bDraw = sal_True; |
| } |
| if( bDraw ) |
| ( (Graphic*) pBrush->GetGraphic() )->StopAnimation( 0, nId ); |
| } |
| |
| SwRect aRepaint( rInf.GetPaintRect() ); |
| const SwTxtFrm& rFrm = *rInf.GetTxtFrm(); |
| if( rFrm.IsVertical() ) |
| { |
| rFrm.SwitchHorizontalToVertical( aTmp ); |
| rFrm.SwitchHorizontalToVertical( aRepaint ); |
| } |
| |
| if( rFrm.IsRightToLeft() ) |
| { |
| rFrm.SwitchLTRtoRTL( aTmp ); |
| rFrm.SwitchLTRtoRTL( aRepaint ); |
| } |
| |
| if( bDraw && aTmp.HasArea() ) |
| DrawGraphic( pBrush, (OutputDevice*)rInf.GetOut(), |
| aTmp, aRepaint, bReplace ? GRFNUM_REPLACE : GRFNUM_YES ); |
| } |
| |
| void SwGrfNumPortion::SetBase( long nLnAscent, long nLnDescent, |
| long nFlyAsc, long nFlyDesc ) |
| { |
| if ( GetOrient() != text::VertOrientation::NONE ) |
| { |
| SetRelPos( 0 ); |
| if ( GetOrient() == text::VertOrientation::CENTER ) |
| SetRelPos( GetGrfHeight() / 2 ); |
| else if ( GetOrient() == text::VertOrientation::TOP ) |
| SetRelPos( GetGrfHeight() - GRFNUM_SECURE ); |
| else if ( GetOrient() == text::VertOrientation::BOTTOM ) |
| ; |
| else if ( GetOrient() == text::VertOrientation::CHAR_CENTER ) |
| SetRelPos( ( GetGrfHeight() + nLnAscent - nLnDescent ) / 2 ); |
| else if ( GetOrient() == text::VertOrientation::CHAR_TOP ) |
| SetRelPos( nLnAscent ); |
| else if ( GetOrient() == text::VertOrientation::CHAR_BOTTOM ) |
| SetRelPos( GetGrfHeight() - nLnDescent ); |
| else |
| { |
| if( GetGrfHeight() >= nFlyAsc + nFlyDesc ) |
| { |
| // wenn ich genauso gross bin wie die Zeile, brauche ich mich |
| // nicht an der Zeile nicht weiter ausrichten, ich lasse |
| // dann auch den max. Ascent der Zeile unveraendert |
| |
| SetRelPos( nFlyAsc ); |
| } |
| else if ( GetOrient() == text::VertOrientation::LINE_CENTER ) |
| SetRelPos( ( GetGrfHeight() + nFlyAsc - nFlyDesc ) / 2 ); |
| else if ( GetOrient() == text::VertOrientation::LINE_TOP ) |
| SetRelPos( nFlyAsc ); |
| else if ( GetOrient() == text::VertOrientation::LINE_BOTTOM ) |
| SetRelPos( GetGrfHeight() - nFlyDesc ); |
| } |
| } |
| } |
| |
| void SwTxtFrm::StopAnimation( OutputDevice* pOut ) |
| { |
| ASSERT( HasAnimation(), "SwTxtFrm::StopAnimation: Which Animation?" ); |
| if( HasPara() ) |
| { |
| SwLineLayout *pLine = GetPara(); |
| while( pLine ) |
| { |
| SwLinePortion *pPor = pLine->GetPortion(); |
| while( pPor ) |
| { |
| if( pPor->IsGrfNumPortion() ) |
| ((SwGrfNumPortion*)pPor)->StopAnimation( pOut ); |
| // Die Numerierungsportion sitzt immer vor dem ersten Zeichen, |
| // deshalb koennen wir abbrechen, sobald wir eine Portion mit |
| // einer Laenge > 0 erreicht haben. |
| pPor = pPor->GetLen() ? 0 : pPor->GetPortion(); |
| } |
| pLine = pLine->GetLen() ? 0 : pLine->GetNext(); |
| } |
| } |
| } |
| |
| /************************************************************************* |
| * SwCombinedPortion::SwCombinedPortion(..) |
| * initializes the script array and clears the width array |
| *************************************************************************/ |
| |
| SwCombinedPortion::SwCombinedPortion( const XubString &rTxt ) |
| : SwFldPortion( rTxt ) |
| { |
| SetLen(1); |
| SetWhichPor( POR_COMBINED ); |
| if( aExpand.Len() > 6 ) |
| aExpand.Erase( 6 ); |
| // Initialization of the scripttype array, |
| // the arrays of width and position are filled by the format function |
| if( pBreakIt->GetBreakIter().is() ) |
| { |
| sal_uInt8 nScr = SW_SCRIPTS; |
| for( sal_uInt16 i = 0; i < rTxt.Len(); ++i ) |
| { |
| sal_uInt16 nScript = pBreakIt->GetBreakIter()->getScriptType( rTxt, i ); |
| switch ( nScript ) { |
| case i18n::ScriptType::LATIN : nScr = SW_LATIN; break; |
| case i18n::ScriptType::ASIAN : nScr = SW_CJK; break; |
| case i18n::ScriptType::COMPLEX : nScr = SW_CTL; break; |
| } |
| aScrType[i] = nScr; |
| } |
| } |
| else |
| { |
| for( sal_uInt16 i = 0; i < 6; aScrType[i++] = 0 ) |
| ; // nothing |
| } |
| memset( &aWidth, 0, sizeof(aWidth) ); |
| } |
| |
| /************************************************************************* |
| * SwCombinedPortion::Paint(..) |
| *************************************************************************/ |
| |
| void SwCombinedPortion::Paint( const SwTxtPaintInfo &rInf ) const |
| { |
| ASSERT( GetLen() <= 1, "SwFldPortion::Paint: rest-portion polution?" ); |
| if( Width() ) |
| { |
| rInf.DrawBackBrush( *this ); |
| rInf.DrawViewOpt( *this, POR_FLD ); |
| |
| // do we have to repaint a post it portion? |
| if( rInf.OnWin() && pPortion && !pPortion->Width() ) |
| pPortion->PrePaint( rInf, this ); |
| |
| sal_uInt16 nCount = aExpand.Len(); |
| if( !nCount ) |
| return; |
| ASSERT( nCount < 7, "Too much combined characters" ); |
| |
| // the first character of the second row |
| sal_uInt16 nTop = ( nCount + 1 ) / 2; |
| |
| SwFont aTmpFont( *rInf.GetFont() ); |
| aTmpFont.SetProportion( nProportion ); // a smaller font |
| SwFontSave aFontSave( rInf, &aTmpFont ); |
| |
| sal_uInt16 i = 0; |
| Point aOldPos = rInf.GetPos(); |
| Point aOutPos( aOldPos.X(), aOldPos.Y() - nUpPos );// Y of the first row |
| while( i < nCount ) |
| { |
| if( i == nTop ) // change the row |
| aOutPos.Y() = aOldPos.Y() + nLowPos; // Y of the second row |
| aOutPos.X() = aOldPos.X() + aPos[i]; // X position |
| const sal_uInt8 nAct = aScrType[i]; // script type |
| aTmpFont.SetActual( nAct ); |
| // if there're more than 4 characters to display, we choose fonts |
| // with 2/3 of the original font width. |
| if( aWidth[ nAct ] ) |
| { |
| Size aTmpSz = aTmpFont.GetSize( nAct ); |
| if( aTmpSz.Width() != aWidth[ nAct ] ) |
| { |
| aTmpSz.Width() = aWidth[ nAct ]; |
| aTmpFont.SetSize( aTmpSz, nAct ); |
| } |
| } |
| ((SwTxtPaintInfo&)rInf).SetPos( aOutPos ); |
| rInf.DrawText( aExpand, *this, i, 1 ); |
| ++i; |
| } |
| // rInf is const, so we have to take back our manipulations |
| ((SwTxtPaintInfo&)rInf).SetPos( aOldPos ); |
| } |
| } |
| |
| /************************************************************************* |
| * SwCombinedPortion::Format(..) |
| *************************************************************************/ |
| |
| sal_Bool SwCombinedPortion::Format( SwTxtFormatInfo &rInf ) |
| { |
| sal_uInt16 nCount = aExpand.Len(); |
| if( !nCount ) |
| { |
| Width( 0 ); |
| return sal_False; |
| } |
| |
| ASSERT( nCount < 7, "Too much combined characters" ); |
| // If there are leading "weak"-scripttyped characters in this portion, |
| // they get the actual scripttype. |
| sal_uInt16 i = 0; |
| while( i < nCount && SW_SCRIPTS == aScrType[i] ) |
| aScrType[i++] = rInf.GetFont()->GetActual(); |
| if( nCount > 4 ) |
| { |
| // more than four? Ok, then we need the 2/3 font width |
| i = 0; |
| while( i < aExpand.Len() ) |
| { |
| ASSERT( aScrType[i] < SW_SCRIPTS, "Combined: Script fault" ); |
| if( !aWidth[ aScrType[i] ] ) |
| { |
| rInf.GetOut()->SetFont( rInf.GetFont()->GetFnt( aScrType[i] ) ); |
| aWidth[ aScrType[i] ] = |
| static_cast<sal_uInt16>(2 * rInf.GetOut()->GetFontMetric().GetSize().Width() / 3); |
| } |
| ++i; |
| } |
| } |
| |
| sal_uInt16 nTop = ( nCount + 1 ) / 2; // the first character of the second line |
| ViewShell *pSh = rInf.GetTxtFrm()->getRootFrm()->GetCurrShell(); |
| SwFont aTmpFont( *rInf.GetFont() ); |
| SwFontSave aFontSave( rInf, &aTmpFont ); |
| nProportion = 55; |
| // In nMainAscent/Descent we store the ascent and descent |
| // of the original surrounding font |
| sal_uInt16 nMaxDescent, nMaxAscent, nMaxWidth; |
| sal_uInt16 nMainDescent = rInf.GetFont()->GetHeight( pSh, *rInf.GetOut() ); |
| const sal_uInt16 nMainAscent = rInf.GetFont()->GetAscent( pSh, *rInf.GetOut() ); |
| nMainDescent = nMainDescent - nMainAscent; |
| // we start with a 50% font, but if we notice that the combined portion |
| // becomes bigger than the surrounding font, we check 45% and maybe 40%. |
| do |
| { |
| nProportion -= 5; |
| aTmpFont.SetProportion( nProportion ); |
| i = 0; |
| memset( &aPos, 0, sizeof(aPos) ); |
| nMaxDescent = 0; |
| nMaxAscent = 0; |
| nMaxWidth = 0; |
| nUpPos = nLowPos = 0; |
| |
| // Now we get the width of all characters. |
| // The ascent and the width of the first line are stored in the |
| // ascent member of the portion, the descent in nLowPos. |
| // The ascent, descent and width of the second line are stored in the |
| // local nMaxAscent, nMaxDescent and nMaxWidth variables. |
| while( i < nCount ) |
| { |
| sal_uInt8 nScrp = aScrType[i]; |
| aTmpFont.SetActual( nScrp ); |
| if( aWidth[ nScrp ] ) |
| { |
| Size aFontSize( aTmpFont.GetSize( nScrp ) ); |
| aFontSize.Width() = aWidth[ nScrp ]; |
| aTmpFont.SetSize( aFontSize, nScrp ); |
| } |
| |
| SwDrawTextInfo aDrawInf( pSh, *rInf.GetOut(), 0, aExpand, i, 1 ); |
| Size aSize = aTmpFont._GetTxtSize( aDrawInf ); |
| sal_uInt16 nAsc = aTmpFont.GetAscent( pSh, *rInf.GetOut() ); |
| aPos[ i ] = (sal_uInt16)aSize.Width(); |
| if( i == nTop ) // enter the second line |
| { |
| nLowPos = nMaxDescent; |
| Height( nMaxDescent + nMaxAscent ); |
| Width( nMaxWidth ); |
| SetAscent( nMaxAscent ); |
| nMaxAscent = 0; |
| nMaxDescent = 0; |
| nMaxWidth = 0; |
| } |
| nMaxWidth = nMaxWidth + aPos[ i++ ]; |
| if( nAsc > nMaxAscent ) |
| nMaxAscent = nAsc; |
| if( aSize.Height() - nAsc > nMaxDescent ) |
| nMaxDescent = static_cast<sal_uInt16>(aSize.Height() - nAsc); |
| } |
| // for one or two characters we double the width of the portion |
| if( nCount < 3 ) |
| { |
| nMaxWidth *= 2; |
| Width( 2*Width() ); |
| if( nCount < 2 ) |
| { |
| Height( nMaxAscent + nMaxDescent ); |
| nLowPos = nMaxDescent; |
| } |
| } |
| Height( Height() + nMaxDescent + nMaxAscent ); |
| nUpPos = nMaxAscent; |
| SetAscent( Height() - nMaxDescent - nLowPos ); |
| } while( nProportion > 40 && ( GetAscent() > nMainAscent || |
| Height() - GetAscent() > nMainDescent ) ); |
| // if the combined portion is smaller than the surrounding text, |
| // the portion grows. This looks better, if there's a character background. |
| if( GetAscent() < nMainAscent ) |
| { |
| Height( Height() + nMainAscent - GetAscent() ); |
| SetAscent( nMainAscent ); |
| } |
| if( Height() < nMainAscent + nMainDescent ) |
| Height( nMainAscent + nMainDescent ); |
| |
| // We calculate the x positions of the characters in both lines.. |
| sal_uInt16 nTopDiff = 0; |
| sal_uInt16 nBotDiff = 0; |
| if( nMaxWidth > Width() ) |
| { |
| nTopDiff = ( nMaxWidth - Width() ) / 2; |
| Width( nMaxWidth ); |
| } |
| else |
| nBotDiff = ( Width() - nMaxWidth ) / 2; |
| switch( nTop) |
| { |
| case 3: aPos[1] = aPos[0] + nTopDiff; // no break |
| case 2: aPos[nTop-1] = Width() - aPos[nTop-1]; |
| } |
| aPos[0] = 0; |
| switch( nCount ) |
| { |
| case 5: aPos[4] = aPos[3] + nBotDiff; // no break |
| case 3: aPos[nTop] = nBotDiff; break; |
| case 6: aPos[4] = aPos[3] + nBotDiff; // no break |
| case 4: aPos[nTop] = 0; // no break |
| case 2: aPos[nCount-1] = Width() - aPos[nCount-1]; |
| } |
| |
| // Does the combined portion fit the line? |
| const sal_Bool bFull = rInf.Width() < rInf.X() + Width(); |
| if( bFull ) |
| { |
| if( rInf.GetLineStart() == rInf.GetIdx() && (!rInf.GetLast()->InFldGrp() |
| || !((SwFldPortion*)rInf.GetLast())->IsFollow() ) ) |
| Width( (sal_uInt16)( rInf.Width() - rInf.X() ) ); |
| else |
| { |
| Truncate(); |
| Width( 0 ); |
| SetLen( 0 ); |
| if( rInf.GetLast() ) |
| rInf.GetLast()->FormatEOL( rInf ); |
| } |
| } |
| return bFull; |
| } |
| |
| /************************************************************************* |
| * SwCombinedPortion::GetViewWidth(..) |
| *************************************************************************/ |
| |
| KSHORT SwCombinedPortion::GetViewWidth( const SwTxtSizeInfo &rInf ) const |
| { |
| if( !GetLen() ) // for the dummy part at the end of the line, where |
| return 0; // the combined portion doesn't fit. |
| return SwFldPortion::GetViewWidth( rInf ); |
| } |
