| /************************************************************** |
| * |
| * 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" |
| |
| #ifdef DBG_UTIL |
| |
| #include "viewsh.hxx" // IsDbg() |
| #include "viewopt.hxx" // IsDbg() |
| #include "txtatr.hxx" |
| #include "errhdl.hxx" |
| #include "txtcfg.hxx" |
| #include "txtfrm.hxx" // IsDbg() |
| #include "rootfrm.hxx" |
| #include "flyfrms.hxx" |
| #include "inftxt.hxx" |
| #include "porexp.hxx" |
| #include "porfld.hxx" |
| #include "porfly.hxx" |
| #include "porftn.hxx" |
| #include "porglue.hxx" |
| #include "porhyph.hxx" |
| #include "porlay.hxx" |
| #include "porlin.hxx" |
| #include "porref.hxx" |
| #include "porrst.hxx" |
| #include "portab.hxx" |
| #include "portox.hxx" |
| #include "portxt.hxx" |
| #include "pordrop.hxx" |
| #include "pormulti.hxx" |
| #include "ndhints.hxx" |
| |
| // So kann man die Layoutstruktur ausgeben lassen |
| // #define AMA_LAYOUT |
| #ifdef AMA_LAYOUT |
| #include <stdio.h> |
| #include <stdlib.h> // getenv() |
| #include <flowfrm.hxx> |
| #include <pagefrm.hxx> |
| #include <svx/svdobj.hxx> |
| #include <dflyobj.hxx> |
| |
| |
| void lcl_OutFollow( XubString &rTmp, const SwFrm* pFrm ) |
| { |
| if( pFrm->IsFlowFrm() ) |
| { |
| const SwFlowFrm *pFlow = SwFlowFrm::CastFlowFrm( pFrm ); |
| if( pFlow->IsFollow() || pFlow->GetFollow() ) |
| { |
| rTmp += "("; |
| if( pFlow->IsFollow() ) |
| rTmp += "."; |
| if( pFlow->GetFollow() ) |
| { |
| MSHORT nFrmId = pFlow->GetFollow()->GetFrm()->GetFrmId(); |
| rTmp += nFrmId; |
| } |
| rTmp += ")"; |
| } |
| } |
| } |
| |
| void lcl_OutFrame( SvFileStream& rStr, const SwFrm* pFrm, ByteString& rSp, sal_Bool bNxt ) |
| { |
| if( !pFrm ) |
| return; |
| KSHORT nSpc = 0; |
| MSHORT nFrmId = pFrm->GetFrmId(); |
| ByteString aTmp; |
| if( pFrm->IsLayoutFrm() ) |
| { |
| if( pFrm->IsRootFrm() ) |
| aTmp = "R"; |
| else if( pFrm->IsPageFrm() ) |
| aTmp = "P"; |
| else if( pFrm->IsBodyFrm() ) |
| aTmp = "B"; |
| else if( pFrm->IsColumnFrm() ) |
| aTmp = "C"; |
| else if( pFrm->IsTabFrm() ) |
| aTmp = "Tb"; |
| else if( pFrm->IsRowFrm() ) |
| aTmp = "Rw"; |
| else if( pFrm->IsCellFrm() ) |
| aTmp = "Ce"; |
| else if( pFrm->IsSctFrm() ) |
| aTmp = "S"; |
| else if( pFrm->IsFlyFrm() ) |
| { |
| aTmp = "F"; |
| const SwFlyFrm *pFly = (SwFlyFrm*)pFrm; |
| if( pFly->IsFlyInCntFrm() ) |
| aTmp += "in"; |
| else if( pFly->IsFlyAtCntFrm() ) |
| { |
| aTmp += "a"; |
| if( pFly->IsAutoPos() ) |
| aTmp += "u"; |
| else |
| aTmp += "t"; |
| } |
| else |
| aTmp += "l"; |
| } |
| else if( pFrm->IsHeaderFrm() ) |
| aTmp = "H"; |
| else if( pFrm->IsFooterFrm() ) |
| aTmp = "Fz"; |
| else if( pFrm->IsFtnContFrm() ) |
| aTmp = "Fc"; |
| else if( pFrm->IsFtnFrm() ) |
| aTmp = "Fn"; |
| else |
| aTmp = "?L?"; |
| aTmp += nFrmId; |
| lcl_OutFollow( aTmp, pFrm ); |
| aTmp += " "; |
| rStr << aTmp; |
| nSpc = aTmp.Len(); |
| rSp.Expand( nSpc + rSp.Len() ); |
| lcl_OutFrame( rStr, ((SwLayoutFrm*)pFrm)->Lower(), rSp, sal_True ); |
| } |
| else |
| { |
| if( pFrm->IsTxtFrm() ) |
| aTmp = "T"; |
| else if( pFrm->IsNoTxtFrm() ) |
| aTmp = "N"; |
| else |
| aTmp = "?C?"; |
| aTmp += nFrmId; |
| lcl_OutFollow( aTmp, pFrm ); |
| aTmp += " "; |
| rStr << aTmp; |
| nSpc = aTmp.Len(); |
| rSp.Expand( nSpc + rSp.Len() ); |
| } |
| if( pFrm->IsPageFrm() ) |
| { |
| const SwPageFrm* pPg = (SwPageFrm*)pFrm; |
| const SwSortedObjs *pSorted = pPg->GetSortedObjs(); |
| const MSHORT nCnt = pSorted ? pSorted->Count() : 0; |
| if( nCnt ) |
| { |
| for( MSHORT i=0; i < nCnt; ++i ) |
| { |
| // --> OD 2004-07-07 #i28701# - consider changed type of |
| // <SwSortedObjs> entries |
| SwAnchoredObject* pAnchoredObj = (*pSorted)[ i ]; |
| if( pAnchoredObj->ISA(SwFlyFrm) ) |
| { |
| SwFlyFrm* pFly = static_cast<SwFlyFrm*>(pAnchoredObj); |
| lcl_OutFrame( rStr, pFly, rSp, sal_False ); |
| } |
| else |
| { |
| aTmp = pAnchoredObj->GetDrawObj()->IsUnoObj() ? "UNO" : "Drw"; |
| rStr << aTmp; |
| } |
| // <-- |
| if( i < nCnt - 1 ) |
| rStr << endl << rSp; |
| } |
| } |
| } |
| else if( pFrm->GetDrawObjs() ) |
| { |
| MSHORT nCnt = pFrm->GetDrawObjs()->Count(); |
| if( nCnt ) |
| { |
| for( MSHORT i=0; i < nCnt; ++i ) |
| { |
| // --> OD 2004-07-07 #i28701# - consider changed type of |
| // <SwSortedObjs> entries |
| SwAnchoredObject* pAnchoredObj = (*pFrm->GetDrawObjs())[ i ]; |
| if( pAnchoredObj->ISA(SwFlyFrm) ) |
| { |
| SwFlyFrm* pFly = static_cast<SwFlyFrm*>(pAnchoredObj); |
| lcl_OutFrame( rStr, pFly, rSp, sal_False ); |
| } |
| else |
| { |
| aTmp = pAnchoredObj->GetDrawObj()->IsUnoObj() ? "UNO" : "Drw"; |
| rStr << aTmp; |
| } |
| if( i < nCnt - 1 ) |
| rStr << endl << rSp; |
| } |
| } |
| } |
| if( nSpc ) |
| rSp.Erase( rSp.Len() - nSpc ); |
| if( bNxt && pFrm->GetNext() ) |
| { |
| do |
| { |
| pFrm = pFrm->GetNext(); |
| rStr << endl << rSp; |
| lcl_OutFrame( rStr, pFrm, rSp, sal_False ); |
| } while ( pFrm->GetNext() ); |
| } |
| } |
| |
| void LayOutPut( const SwFrm* pFrm ) |
| { |
| static char* pOutName = 0; |
| const sal_Bool bFirstOpen = pOutName ? sal_False : sal_True; |
| if( bFirstOpen ) |
| { |
| char *pPath = getenv( "TEMP" ); |
| char *pName = "layout.txt"; |
| if( !pPath ) |
| pOutName = pName; |
| else |
| { |
| const int nLen = strlen(pPath); |
| // fuer dieses new wird es kein delete geben. |
| pOutName = new char[nLen + strlen(pName) + 3]; |
| if(nLen && (pPath[nLen-1] == '\\') || (pPath[nLen-1] == '/')) |
| snprintf( pOutName, sizeof(pOutName), "%s%s", pPath, pName ); |
| else |
| snprintf( pOutName, sizeof(pOutName), "%s/%s", pPath, pName ); |
| } |
| } |
| SvFileStream aStream( pOutName, (bFirstOpen |
| ? STREAM_WRITE | STREAM_TRUNC |
| : STREAM_WRITE )); |
| |
| if( !aStream.GetError() ) |
| { |
| if ( bFirstOpen ) |
| aStream << "Layout-Struktur"; |
| else |
| aStream.Seek( STREAM_SEEK_TO_END ); |
| aStream << endl; |
| aStream << "---------------------------------------------" << endl; |
| XubString aSpace; |
| lcl_OutFrame( aStream, pFrm, aSpace, sal_False ); |
| } |
| } |
| |
| #endif |
| |
| SvStream &operator<<( SvStream &rOs, const SwpHints & ) //$ ostream |
| { |
| rOs << " {HINTS:"; |
| |
| // REMOVED |
| |
| rOs << '}'; |
| return rOs; |
| } |
| |
| /************************************************************************* |
| * IsDbg() |
| *************************************************************************/ |
| |
| sal_Bool IsDbg( const SwTxtFrm *pFrm ) |
| { |
| if( pFrm && pFrm->getRootFrm()->GetCurrShell() ) |
| return pFrm->getRootFrm()->GetCurrShell()->GetViewOptions()->IsTest4(); |
| else |
| return sal_False; |
| } |
| |
| #if OSL_DEBUG_LEVEL < 2 |
| |
| static void Error() |
| { |
| // wegen PM und BCC |
| sal_Bool bFalse = sal_False; |
| ASSERT( bFalse, "txtio: No debug version" ); |
| } |
| |
| #define IMPL_OUTOP(class) \ |
| SvStream &class::operator<<( SvStream &rOs ) const /*$ostream*/\ |
| { \ |
| Error(); \ |
| return rOs; \ |
| } |
| |
| IMPL_OUTOP( SwTxtPortion ) |
| IMPL_OUTOP( SwLinePortion ) |
| IMPL_OUTOP( SwBreakPortion ) |
| IMPL_OUTOP( SwGluePortion ) |
| IMPL_OUTOP( SwFldPortion ) |
| IMPL_OUTOP( SwHiddenPortion ) |
| IMPL_OUTOP( SwHyphPortion ) |
| IMPL_OUTOP( SwFixPortion ) |
| IMPL_OUTOP( SwFlyPortion ) |
| IMPL_OUTOP( SwFlyCntPortion ) |
| IMPL_OUTOP( SwMarginPortion ) |
| IMPL_OUTOP( SwNumberPortion ) |
| IMPL_OUTOP( SwBulletPortion ) |
| IMPL_OUTOP( SwGrfNumPortion ) |
| IMPL_OUTOP( SwLineLayout ) |
| IMPL_OUTOP( SwParaPortion ) |
| IMPL_OUTOP( SwFtnPortion ) |
| IMPL_OUTOP( SwFtnNumPortion ) |
| IMPL_OUTOP( SwTmpEndPortion ) |
| IMPL_OUTOP( SwHyphStrPortion ) |
| IMPL_OUTOP( SwExpandPortion ) |
| IMPL_OUTOP( SwBlankPortion ) |
| IMPL_OUTOP( SwToxPortion ) |
| IMPL_OUTOP( SwRefPortion ) |
| IMPL_OUTOP( SwIsoToxPortion ) |
| IMPL_OUTOP( SwIsoRefPortion ) |
| IMPL_OUTOP( SwSoftHyphPortion ) |
| IMPL_OUTOP( SwSoftHyphStrPortion ) |
| IMPL_OUTOP( SwTabPortion ) |
| IMPL_OUTOP( SwTabLeftPortion ) |
| IMPL_OUTOP( SwTabRightPortion ) |
| IMPL_OUTOP( SwTabCenterPortion ) |
| IMPL_OUTOP( SwTabDecimalPortion ) |
| IMPL_OUTOP( SwPostItsPortion ) |
| IMPL_OUTOP( SwQuoVadisPortion ) |
| IMPL_OUTOP( SwErgoSumPortion ) |
| IMPL_OUTOP( SwHolePortion ) |
| IMPL_OUTOP( SwDropPortion ) |
| IMPL_OUTOP( SwKernPortion ) |
| IMPL_OUTOP( SwArrowPortion ) |
| IMPL_OUTOP( SwMultiPortion ) |
| IMPL_OUTOP( SwCombinedPortion ) |
| |
| const char *GetPortionName( const MSHORT ) |
| { |
| return 0; |
| } |
| |
| const char *GetPrepName( const PrepareHint ) |
| { |
| return 0; |
| } |
| |
| void SwLineLayout::DebugPortions( SvStream &, const XubString &, //$ ostream |
| const xub_StrLen ) |
| { |
| } |
| |
| const char *GetLangName( const MSHORT ) |
| { |
| return 0; |
| } |
| |
| #else |
| # include <limits.h> |
| # include <stdlib.h> |
| # include "swtypes.hxx" // ZTCCONST |
| # include "swfont.hxx" // SwDropPortion |
| |
| CONSTCHAR( pClose, "} " ); |
| |
| /************************************************************************* |
| * GetPortionName() |
| *************************************************************************/ |
| |
| CONSTCHAR( pPOR_LIN, "LIN" ); |
| CONSTCHAR( pPOR_TXT, "TXT" ); |
| CONSTCHAR( pPOR_SHADOW, "SHADOW" ); |
| CONSTCHAR( pPOR_TAB, "TAB" ); |
| CONSTCHAR( pPOR_TABLEFT, "TABLEFT" ); |
| CONSTCHAR( pPOR_TABRIGHT, "TABRIGHT" ); |
| CONSTCHAR( pPOR_TABCENTER, "TABCENTER" ); |
| CONSTCHAR( pPOR_TABDECIMAL, "TABDECIMAL" ); |
| CONSTCHAR( pPOR_EXP, "EXP" ); |
| CONSTCHAR( pPOR_HYPH, "HYPH" ); |
| CONSTCHAR( pPOR_HYPHSTR, "HYPHSTR" ); |
| CONSTCHAR( pPOR_FLD, "FLD" ); |
| CONSTCHAR( pPOR_FIX, "FIX" ); |
| CONSTCHAR( pPOR_FLY, "FLY" ); |
| CONSTCHAR( pPOR_FLYCNT, "FLYCNT" ); |
| CONSTCHAR( pPOR_MARGIN, "MARGIN" ); |
| CONSTCHAR( pPOR_GLUE, "GLUE" ); |
| CONSTCHAR( pPOR_HOLE, "HOLE" ); |
| CONSTCHAR( pPOR_END, "END" ); |
| CONSTCHAR( pPOR_BRK, "BRK" ); |
| CONSTCHAR( pPOR_LAY, "LAY" ); |
| CONSTCHAR( pPOR_BLANK, "BLANK" ); |
| CONSTCHAR( pPOR_FTN, "FTN" ); |
| CONSTCHAR( pPOR_FTNNUM, "FTNNUM" ); |
| CONSTCHAR( pPOR_POSTITS, "POSTITS" ); |
| CONSTCHAR( pPOR_SOFTHYPH, "SOFTHYPH" ); |
| CONSTCHAR( pPOR_SOFTHYPHSTR, "SOFTHYPHSTR" ); |
| CONSTCHAR( pPOR_TOX, "TOX" ); |
| CONSTCHAR( pPOR_REF, "REF" ); |
| |
| CONSTCHAR( pPOR_ISOTOX, "ISOTOX" ); |
| CONSTCHAR( pPOR_ISOREF, "ISOREF" ); |
| CONSTCHAR( pPOR_HIDDEN, "Hidden" ); |
| CONSTCHAR( pPOR_QUOVADIS, "QuoVadis" ); |
| CONSTCHAR( pPOR_ERGOSUM, "ErgoSum" ); |
| CONSTCHAR( pPOR_NUMBER, "NUMBER" ); |
| CONSTCHAR( pPOR_BULLET, "BULLET" ); |
| CONSTCHAR( pPOR_UNKW, "UNKW" ); |
| CONSTCHAR( pPOR_PAR, "PAR" ); |
| |
| const char *GetPortionName( const MSHORT /*nType*/ ) |
| { |
| return 0; |
| } |
| |
| CONSTCHAR( pPREP_CLEAR, "CLEAR" ); |
| CONSTCHAR( pPREP_WIDOWS_ORPHANS, "WIDOWS_ORPHANS" ); |
| CONSTCHAR( pPREP_FIXSIZE_CHG, "FIXSIZE_CHG" ); |
| CONSTCHAR( pPREP_FOLLOW_FOLLOWS, "FOLLOW_FOLLOWS" ); |
| CONSTCHAR( pPREP_ADJUST_FRM, "ADJUST_FRM" ); |
| CONSTCHAR( pPREP_FREE_SPACE, "FREE_SPACE" ); |
| CONSTCHAR( pPREP_FLY_CHGD, "FLY_CHGD" ); |
| CONSTCHAR( pPREP_FLY_ATTR_CHG, "FLY_ATTR_CHG" ); |
| CONSTCHAR( pPREP_FLY_ARRIVE, "FLY_ARRIVE" ); |
| CONSTCHAR( pPREP_FLY_LEAVE, "FLY_LEAVE" ); |
| CONSTCHAR( pPREP_VIEWOPT, "VIEWOPT" ); |
| CONSTCHAR( pPREP_FTN, "FTN" ); |
| CONSTCHAR( pPREP_POS_CHGD, "POS" ); |
| CONSTCHAR( pPREP_UL_SPACE, "UL_SPACE" ); |
| CONSTCHAR( pPREP_MUST_FIT, "MUST_FIT" ); |
| CONSTCHAR( pPREP_WIDOWS, "ORPHANS" ); |
| CONSTCHAR( pPREP_QUOVADIS, "QUOVADIS" ); |
| CONSTCHAR( pPREP_PAGE, "PAGE" ); |
| |
| const char *GetPrepName( const PrepareHint ePrep ) |
| { |
| // Kurz und schmerzlos: |
| const char *ppNameArr[PREP_END] = |
| { |
| pPREP_CLEAR, pPREP_WIDOWS_ORPHANS, pPREP_FIXSIZE_CHG, |
| pPREP_FOLLOW_FOLLOWS, pPREP_ADJUST_FRM, pPREP_FREE_SPACE, |
| pPREP_FLY_CHGD, pPREP_FLY_ATTR_CHG, pPREP_FLY_ARRIVE, |
| pPREP_FLY_LEAVE, pPREP_VIEWOPT, pPREP_FTN, pPREP_POS_CHGD, |
| pPREP_UL_SPACE, pPREP_MUST_FIT, pPREP_WIDOWS, pPREP_QUOVADIS, |
| pPREP_PAGE |
| }; |
| ASSERT( ePrep < PREP_END, "GetPrepName: unknown PrepareHint" ); |
| return( ppNameArr[ePrep] ); |
| } |
| |
| /************************************************************************* |
| * SwLineLayout::DebugPortions() |
| * |
| * DebugPortion() iteriert ueber alle Portions einer Zeile und deckt die |
| * internen Strukturen auf. |
| * Im Gegensatz zum Ausgabe-Operator werden auch die Textteile ausgegeben. |
| *************************************************************************/ |
| |
| void SwLineLayout::DebugPortions( SvStream &rOs, const XubString &/*rTxt*/, //$ ostream |
| const xub_StrLen /*nStart*/ ) |
| { |
| SwLinePortion *pPortion2 = GetPortion(); |
| |
| xub_StrLen nPos = 0; |
| MSHORT nNr = 0; |
| KSHORT nPrtWidth, nLastPrt; |
| nPrtWidth = nLastPrt = 0; |
| |
| SwLinePortion::operator<<( rOs ); |
| rOs << '\"' << endl; |
| |
| while( pPortion2 ) |
| { |
| DBG_LOOP; |
| SwTxtPortion *pTxtPor = pPortion2->InTxtGrp() ? |
| (SwTxtPortion *)pPortion2 : NULL ; |
| (void)pTxtPor; |
| ++nNr; |
| nLastPrt = nPrtWidth; |
| nPrtWidth = nPrtWidth + pPortion2->PrtWidth(); |
| rOs << "\tNr:" << nNr |
| << " Pos:" << nPos |
| << " Org:" << nLastPrt |
| << endl; |
| |
| rOs << "\t"; |
| pPortion2->operator<<( rOs ); |
| rOs << endl; |
| nPos = nPos + pPortion2->GetLen(); |
| pPortion2 = pPortion2->GetPortion(); |
| } |
| } |
| |
| const char *GetLangName( const MSHORT /*nLang*/ ) |
| { |
| return "???"; |
| } |
| |
| SvStream &SwLinePortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| rOs << " {"; |
| rOs << "L:" << nLineLength; |
| rOs << " H:" << Height(); |
| rOs << " W:" << PrtWidth(); |
| rOs << " A:" << nAscent; |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwTxtPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {TXT:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwTmpEndPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {END:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| if( PrtWidth() ) |
| rOs << "(view)"; |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwBreakPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {BREAK:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwKernPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {KERN:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwArrowPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {ARROW:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwMultiPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {MULTI:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwCombinedPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {COMBINED:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwLineLayout::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {LINE:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| SwLinePortion *pPos = GetPortion(); |
| while( pPos ) |
| { |
| DBG_LOOP; |
| rOs << "\t"; |
| pPos->operator<<( rOs ); |
| pPos = pPos->GetPortion(); |
| } |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwGluePortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {GLUE:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| rOs << " F:" << GetFixWidth(); |
| rOs << " G:" << GetPrtGlue(); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwFixPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {FIX:" ); |
| rOs << pTxt; |
| SwGluePortion::operator<<( rOs ); |
| rOs << " Fix:" << nFix; |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwFlyPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {FLY:" ); |
| rOs << pTxt; |
| SwFixPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwMarginPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {MAR:" ); |
| rOs << pTxt; |
| SwGluePortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwFlyCntPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {FLYCNT:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| if( bDraw ) |
| { |
| CONSTCHAR( pTxt2, " {DRAWINCNT" ); |
| rOs << pTxt2; |
| rOs << pClose; |
| } |
| else |
| { |
| CONSTCHAR( pTxt2, " {FRM:" ); |
| rOs << pTxt2; |
| rOs << " {FRM:" << GetFlyFrm()->Frm() << pClose; |
| rOs << " {PRT:" << GetFlyFrm()->Prt() << pClose; |
| rOs << pClose; |
| } |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwExpandPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {EXP:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwFtnPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {FTN:" ); |
| rOs << pTxt; |
| SwExpandPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwFtnNumPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {FTNNUM:" ); |
| rOs << pTxt; |
| SwNumberPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwNumberPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {NUMBER:" ); |
| rOs << pTxt; |
| SwExpandPortion::operator<<( rOs ); |
| rOs << " Exp:\"" << '\"'; |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwBulletPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {BULLET:" ); |
| rOs << pTxt; |
| SwNumberPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwGrfNumPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {GRFNUM:" ); |
| rOs << pTxt; |
| SwNumberPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwHiddenPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {Hidden:" ); |
| rOs << pTxt; |
| SwFldPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwToxPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {TOX:" ); |
| rOs << pTxt; |
| SwTxtPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwRefPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {Ref:" ); |
| rOs << pTxt; |
| SwTxtPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwIsoToxPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {ISOTOX:" ); |
| rOs << pTxt; |
| SwToxPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwIsoRefPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {ISOREF:" ); |
| rOs << pTxt; |
| SwRefPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwHyphPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {HYPH:" ); |
| rOs << pTxt; |
| SwExpandPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwHyphStrPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {HYPHSTR:" ); |
| rOs << pTxt; |
| SwExpandPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwSoftHyphPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {SOFTHYPH:" ); |
| rOs << pTxt; |
| SwHyphPortion::operator<<( rOs ); |
| rOs << (IsExpand() ? " on" : " off"); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwSoftHyphStrPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {SOFTHYPHSTR:" ); |
| rOs << pTxt; |
| SwHyphStrPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwBlankPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {BLANK:" ); |
| rOs << pTxt; |
| SwExpandPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwFldPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {FLD:" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| if( IsFollow() ) |
| rOs << " F!"; |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwPostItsPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {POSTITS" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwTabPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {TAB" ); |
| rOs << pTxt; |
| SwFixPortion::operator<<( rOs ); |
| rOs << " T:" << nTabPos; |
| if( IsFilled() ) |
| rOs << " \"" << cFill << '\"'; |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwTabLeftPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {TABLEFT" ); |
| rOs << pTxt; |
| SwTabPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwTabRightPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {TABRIGHT" ); |
| rOs << pTxt; |
| SwTabPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwTabCenterPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {TABCENTER" ); |
| rOs << pTxt; |
| SwTabPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwTabDecimalPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {TABDECIMAL" ); |
| rOs << pTxt; |
| SwTabPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwParaPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {PAR" ); |
| rOs << pTxt; |
| SwLineLayout::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwHolePortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {HOLE" ); |
| rOs << pTxt; |
| SwLinePortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwQuoVadisPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {QUOVADIS" ); |
| rOs << pTxt; |
| SwFldPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwErgoSumPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {ERGOSUM" ); |
| rOs << pTxt; |
| SwFldPortion::operator<<( rOs ); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &operator<<( SvStream &rOs, const SwTxtSizeInfo &rInf ) //$ ostream |
| { |
| CONSTCHAR( pTxt, " {SIZEINFO:" ); |
| rOs << pTxt; |
| rOs << ' ' << (rInf.OnWin() ? "WIN:" : "PRT:" ); |
| rOs << " Idx:" << rInf.GetIdx(); |
| rOs << " Len:" << rInf.GetLen(); |
| rOs << pClose; |
| return rOs; |
| } |
| |
| SvStream &SwDropPortion::operator<<( SvStream &rOs ) const //$ ostream |
| { |
| CONSTCHAR( pTxt, " {DROP:" ); |
| rOs << pTxt; |
| SwTxtPortion::operator<<( rOs ); |
| if( pPart && nDropHeight ) |
| { |
| rOs << " H:" << nDropHeight; |
| rOs << " L:" << nLines; |
| rOs <<" Fnt:" << pPart->GetFont().GetHeight(); |
| if( nX || nY ) |
| rOs << " [" << nX << '/' << nY << ']'; |
| } |
| rOs << pClose; |
| return rOs; |
| } |
| |
| #endif /* OSL_DEBUG_LEVEL */ |
| |
| #endif // DBG_UTIL |
| |
