[Libreoffice-commits] .: 3 commits - binfilter/bf_svtools binfilter/bf_sw binfilter/inc
Caolán McNamara
caolan at kemper.freedesktop.org
Tue Aug 9 01:33:23 PDT 2011
binfilter/bf_svtools/source/filter.vcl/filter/svt_sgvtext.cxx | 6
binfilter/bf_sw/source/core/graphic/sw_ndgrf.cxx | 16
binfilter/bf_sw/source/core/sw3io/sw3imp.hxx | 17
binfilter/bf_sw/source/core/sw3io/sw_sw3nodes.cxx | 312 --------
binfilter/bf_sw/source/core/sw3io/sw_sw3num.cxx | 298 -------
binfilter/bf_sw/source/core/sw3io/sw_sw3redln.cxx | 103 --
binfilter/bf_sw/source/core/sw3io/sw_sw3sectn.cxx | 377 ----------
binfilter/bf_sw/source/core/sw3io/sw_sw3table.cxx | 181 ----
binfilter/inc/bf_sw/ndgrf.hxx | 1
9 files changed, 2 insertions(+), 1309 deletions(-)
New commits:
commit 31815302d9f1c211659d0f9917eaf1c1cd39e71b
Author: Caolán McNamara <caolanm at redhat.com>
Date: Tue Aug 9 09:30:23 2011 +0100
remove unused code
diff --git a/binfilter/bf_sw/source/core/sw3io/sw3imp.hxx b/binfilter/bf_sw/source/core/sw3io/sw3imp.hxx
index 4d41fd0..3f7bc04 100644
--- a/binfilter/bf_sw/source/core/sw3io/sw3imp.hxx
+++ b/binfilter/bf_sw/source/core/sw3io/sw3imp.hxx
@@ -641,7 +641,6 @@ public:
void ConvertText( SwTxtNode& rNd, const ByteString& rText8,
xub_StrLen, SvUShorts*, SvXub_StrLens* ); // I: Zeichensatz-Konversion
void InTxtNode( SwTxtNode*, SwNodeIndex&, xub_StrLen, BYTE = 0 );
- void OutTxtNode( SwCntntNode&, xub_StrLen, xub_StrLen, ULONG );
void OutEmptyTxtNode( ULONG nNodeIdx=0, BOOL bNodeMarks=FALSE );
// I: hartes Attribut
Sw3ExportTxtAttrs *ExportTxtNode( const SwTxtNode& rNd,
@@ -671,10 +670,7 @@ public:
// SW3NUM.CXX
void InNumFmt( SwNumFmt& rFmt ); // I: Numerierungs-Format
- void OutNumFmt( const SwNumFmt& rFmt,
- USHORT nPrvAbsLSpace );// O: Numerierungs-Format
SwNumRule* InNumRule( BYTE ); // I: Numerierungs-Regelwerk
- void OutNumRule( BYTE, const SwNumRule& );
void InNumRules(); // I: NumRules
void InOutlineExt();
void InNodeNum( SwNodeNum& ); // I: Absatz-Numerierung
@@ -696,28 +692,16 @@ public:
// SW3SECTN.CXX
void InContents( SwNodeIndex&, xub_StrLen=0, BOOL=TRUE, BYTE=0, BOOL=FALSE );
SwStartNode& InContents(); // I: neue Section anlegen
- void OutContents( const SwNodeIndex& ); // O: abgeschlossener Bereich
- // O: contents
- void OutContents( ULONG,ULONG,xub_StrLen,xub_StrLen, BOOL bTopLevel=FALSE );
- ULONG OutNodes( ULONG nCurNode, ULONG nEndNode, xub_StrLen nCurPos,
- xub_StrLen nEndPos, BOOL bTopLevel );
void InSection( SwNodeIndex& ); // I: SwSection einlesen
- ULONG OutSection(const SwSectionNode&);// O: SwSection ausgeben
- ULONG OutTOXSection(const SwSectionNode&);// O: TOX SwSection
-
// SW3TABLE.CXX
void InTable( SwNodeIndex& rPos ); // I: Tabelle
- void OutTable( const SwTableNode& ); // O: Tabelle
void InTableLine( SwTableLines&, SwTableBox*, USHORT, SwNodeIndex& );
- USHORT OutTableLine( const SwTableLine& rLine );
void InTableBox( SwTableBoxes&, USHORT, SwTableLine*, SwNodeIndex& );
- USHORT OutTableBox( const SwTableBox& rBox );
// SW3REDLIN.CXX
/*N*/ void InRedline(); //SW50.SDW // I: Redline
/*N*/ void InRedlines(); //SW50.SDW
/*N*/ void InNodeRedline( const SwNodeIndex& rNodeIdx, INT32& nOffset, BYTE=0 ); //SW50.SDW
- void OutNodeRedlines( ULONG );
void CleanupRedlines();
void InDocStat();
diff --git a/binfilter/bf_sw/source/core/sw3io/sw_sw3nodes.cxx b/binfilter/bf_sw/source/core/sw3io/sw_sw3nodes.cxx
index 6c0e518..f858353 100644
--- a/binfilter/bf_sw/source/core/sw3io/sw_sw3nodes.cxx
+++ b/binfilter/bf_sw/source/core/sw3io/sw_sw3nodes.cxx
@@ -1624,318 +1624,6 @@ SV_DECL_PTRARR( SwTxtAttrs, SwTxtAttrPtr, 5, 5 )
/*N*/ }
/*N*/ }
-// Text Node:
-// BYTE Flags
-// 0x10 - mit Numerierung
-// 0x20 - Wrong-Liste ist nicht dirty
-// UINT16 String-Index der Absatzvorlage
-// BYTE Numerierungs-Level (opt.)
-// String Text
-// SWG_ATTRSET eigene Attribute (opt.)
-// SWG_FLYFMT FlyFrame (opt).
-// SWG_SDRFMT Drawing-Objekt (opt).
-// SWG_TEXTATTR harte Attribute (opt, mehrfach).
-// SWG_WRONGLIST Liste falscher Worte (opt)
-
-/*N*/ void Sw3IoImp::OutTxtNode
-/*N*/ ( SwCntntNode & rNode, xub_StrLen nStart, xub_StrLen nEnd1, ULONG nPosIdx )
-/*N*/ {
-/*N*/ SwTxtNode *pNd = &((SwTxtNode&) rNode );
-/*N*/ const SwFmtColl* pColl = &pNd->GetAnyFmtColl();
-/*N*/ OSL_ENSURE( pColl != pDoc->GetDfltTxtFmtColl(),
-/*N*/ "the default text format collection isn't allowed on a node" );
-/*N*/ BOOL bNewNumRule = FALSE;
-/*N*/ // 0x0L: Laenge der Daten
-/*N*/ // 0x10: Numerierung folgt (nur 3.1/4.0)
-/*N*/ // 0x20: Wrong-Liste ist nicht dirty
-/*N*/ BYTE cFlags = IsSw31Export() ? 0x02 : 0x04; // CollIdx & CondCollIdx
-/*N*/ USHORT nColl = aStringPool.Add( pColl->GetName(),
-/*N*/ pColl->GetPoolFmtId() );
-/*N*/ BYTE cNumLevel = NO_NUMBERING;
-/*N*/
-/*N*/ // Numerierungsregel fuer 3.1/4.0-Export ermitteln
-/*N*/ const SwNodeNum *pNdNum = pNd->GetNum();
-/*N*/ #ifdef DBG_UTIL
-/*N*/ {
-/*N*/ const SwNumRule* pNumRule = pNd->GetNumRule();
-/*N*/ OSL_ENSURE( pNumRule ? pNdNum!=0 : TRUE,
-/*N*/ "Node hat NumRule aber kein NodeNum" );
-/*N*/ OSL_ENSURE( pNdNum ? pNumRule!=0 : TRUE,
-/*N*/ "Node hat NodeNum aber keine NumRule" );
-/*N*/ }
-/*N*/ #endif
-/*N*/
-/*N*/ SfxItemSet *pExportAttrSet = 0;
-/*N*/ const SfxItemSet *pAttrSet = rNode.GetpSwAttrSet();
-/*N*/
-/*N*/ if( pNdNum && pNdNum->GetLevel() != NO_NUMBERING )
-/*N*/ {
-/*N*/ const SwNumRule* pNumRule = pNd->GetNumRule();
-/*N*/ if( pNumRule )
-/*N*/ {
-/*N*/ cNumLevel = pNdNum->GetLevel();
-/*N*/ BYTE cRealLevel = GetRealLevel( cNumLevel );
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ {
-/*N*/ if( cRealLevel >= OLD_MAXLEVEL )
-/*N*/ {
-/*N*/ // Die Numerierungs-Ebene ist zu hoch => die
-/*N*/ // hoechst moegliche setzen
-/*N*/ BYTE cTmp = OLD_MAXLEVEL-1;
-/*N*/ if( cNumLevel & NO_NUMLEVEL )
-/*N*/ cTmp |= NO_NUMLEVEL;
-/*N*/ cNumLevel = cTmp;
-/*N*/ }
-/*N*/ if( IsSw31Export() )
-/*N*/ cFlags += NO_NUMLEVEL & cNumLevel ? 0x12 : 0x11;
-/*N*/ else
-/*N*/ cFlags += 0x11;
-/*N*/ if( pNumRule != pCurNumRule )
-/*N*/ {
-/*N*/ // Dann vor dem betroffenen Node ausgeben
-/*N*/ pCurNumRule = (SwNumRule *)pNumRule;
-/*N*/
-/*N*/ //JP 06.10.95: falls SH mal wieder mit der Numerierung
-/*N*/ //durcheinander kommt
-/*N*/ // bNewNumRule = TRUE;
-/*N*/ bNewNumRule = 0 != pCurNumRule;
-/*N*/ }
-/*N*/ }
-/*N*/
-/*N*/ #ifdef NUM_RELSPACE
-/*N*/ // Den Erstzeilen-Einzug immer aus der NumRule uebernehmen
-/*N*/ // und als linken Einzug die Summe aus Absatz- und
-/*N*/ // NumRule-Einzug schreiben.
-/*N*/ const SwNumFmt& rNumFmt = pNumRule->Get( cRealLevel );
-/*N*/ const SvxLRSpaceItem& rLRSpace =
-/*N*/ (const SvxLRSpaceItem&)rNode.GetAttr(RES_LR_SPACE);
-/*N*/
-/*N*/ USHORT nLeft = rNumFmt.GetAbsLSpace();
-/*N*/ USHORT nOldLeft = (USHORT)rLRSpace.GetTxtLeft();
-/*N*/ if( !pNumRule->IsAbsSpaces() )
-/*N*/ nLeft += (USHORT)rLRSpace.GetTxtLeft();
-/*N*/ short nFirstLineOffset =
-/*N*/ (cNumLevel & NO_NUMLEVEL)==0 ? rNumFmt.GetFirstLineOffset() : 0;
-/*N*/ if( nLeft != rLRSpace.GetTxtLeft() ||
-/*N*/ nFirstLineOffset != rLRSpace.GetTxtFirstLineOfst() )
-/*N*/ {
-/*N*/ if( pAttrSet )
-/*N*/ pExportAttrSet = new SfxItemSet( *pAttrSet );
-/*N*/ else
-/*?*/ pExportAttrSet = new SfxItemSet( pDoc->GetAttrPool(),
-/*?*/ pColl->GetAttrSet().GetRanges() );
-/*N*/ pAttrSet = pExportAttrSet;
-/*N*/ SvxLRSpaceItem aLRSpace( rLRSpace );
-/*N*/ aLRSpace.SetTxtFirstLineOfst( nFirstLineOffset );
-/*N*/ aLRSpace.SetTxtLeft( nLeft );
-/*N*/
-/*N*/ pExportAttrSet->Put( aLRSpace );
-/*N*/
-/*N*/ if( IsSw31Or40Export() && nOldLeft != nLeft )
-/*N*/ lcl_sw3io__ConvertNumTabStop( rNode,
-/*N*/ (long)nOldLeft - (long)nLeft,
-/*N*/ *pExportAttrSet );
-/*N*/ }
-/*N*/ #endif
-/*N*/ }
-/*N*/ else if( IsSw31Or40Export() )
-/*N*/ pCurNumRule = NULL;
-/*N*/
-/*N*/ }
-/*N*/ else if( IsSw31Or40Export() )
-/*N*/ {
-/*N*/ pCurNumRule = NULL;
-/*N*/ }
-/*N*/
-/*N*/ // Wrong-List-Dirty-Flag (wird wegen alter doks invers gespeichert)
-/*N*/ if( !IsSw31Export() && !rNode.IsWrongDirty() )
-/*N*/ cFlags += 0x20;
-/*N*/
-/*N*/ OpenRec( SWG_TEXTNODE );
-/*N*/ *pStrm << cFlags << nColl;
-/*N*/ if( IsSw31Or40Export() && (cFlags & 0x10) )
-/*N*/ {
-/*N*/ // Frueher wurde hier fuer NO_NUMLEVEL noch ein NO_NUM
-/*N*/ // rausgeschrieben. Ist jetzt nicht mehr noetig.
-/*N*/ //if( NO_NUMLEVEL & cNumLevel )
-/*N*/ // *pStrm << (BYTE)NO_NUM << cNumLevel;
-/*N*/ //else
-/*N*/ if( IsSw31Export() && (NO_NUMLEVEL & cNumLevel) )
-/*?*/ *pStrm << (BYTE)NO_NUM << cNumLevel;
-/*N*/ else
-/*N*/ *pStrm << cNumLevel;
-/*N*/ }
-/*N*/
-/*N*/ // bedingte Vorlagen nicht beim SW31-Export rausschreiben
-/*N*/ if( !IsSw31Export() )
-/*N*/ {
-/*N*/ USHORT nCondColl = IDX_DFLT_VALUE;
-/*N*/ if( pNd->GetCondFmtColl() )
-/*N*/ {
-/*N*/ // dann die bedingte Vorlage schreiben!!
-/*?*/ pColl = pNd->GetFmtColl();
-/*?*/ nCondColl =
-/*?*/ aStringPool.Add( pColl->GetName(), pColl->GetPoolFmtId() );
-/*N*/ }
-/*N*/ *pStrm << nCondColl;
-/*N*/ }
-/*N*/
-/*N*/ #ifdef NUM_RELSPACE
-/*N*/ // Wenn der Absatz ein LRSpace-Item enthaelt und in der Kapitel-Numerierung
-/*N*/ // ist muss das LRSpace-Item noch angepasst werden. Relative Werte
-/*N*/ // koennen dabei nicht vorkommen. Der Ertzeilen-Einzug geht verloren.
-/*N*/ const SwNumRule *pOutline = pDoc->GetOutlineNumRule();
-/*N*/ const SfxPoolItem *pItem;
-/*N*/ if( pAttrSet && (!pNdNum || NO_NUMBERING == pNdNum->GetLevel()) &&
-/*N*/ NO_NUMBERING != ((const SwTxtFmtColl *)pColl)->GetOutlineLevel() &&
-/*N*/ SFX_ITEM_SET == pAttrSet->GetItemState( RES_LR_SPACE, FALSE, &pItem ) &&
-/*N*/ pOutline )
-/*N*/ {
-/*?*/ const SvxLRSpaceItem *pParaLRSpace = (const SvxLRSpaceItem *)pItem;
-/*?*/
-/*?*/ const SwNumFmt& rNumFmt = pOutline->Get(
-/*?*/ GetRealLevel(((const SwTxtFmtColl *)pColl)->GetOutlineLevel()) );
-/*?*/ USHORT nLSpace = (USHORT)pParaLRSpace->GetTxtLeft();
-/*?*/ USHORT nOldLSpace = nLSpace;
-/*?*/ if( pOutline->IsAbsSpaces() )
-/*?*/ nLSpace = rNumFmt.GetAbsLSpace();
-/*?*/ else
-/*?*/ nLSpace += rNumFmt.GetAbsLSpace();
-/*?*/
-/*?*/ if( nLSpace != pParaLRSpace->GetTxtLeft() ||
-/*?*/ rNumFmt.GetFirstLineOffset()!=pParaLRSpace->GetTxtFirstLineOfst() )
-/*?*/ {
-/*?*/ if( !pExportAttrSet )
-/*?*/ {
-/*?*/ pExportAttrSet = new SfxItemSet( *pAttrSet );
-/*?*/ pAttrSet = pExportAttrSet;
-/*?*/ }
-/*?*/
-/*?*/ SvxLRSpaceItem aLRSpace( *pParaLRSpace );
-/*?*/ aLRSpace.SetTxtFirstLineOfst( rNumFmt.GetFirstLineOffset());
-/*?*/ aLRSpace.SetTxtLeft( nLSpace );
-/*?*/ pExportAttrSet->Put( aLRSpace );
-/*?*/
-/*?*/ if( IsSw31Or40Export() && nOldLSpace != nLSpace )
-/*?*/ lcl_sw3io__ConvertNumTabStop( rNode,
-/*?*/ (long)nOldLSpace - (long)nLSpace,
-/*?*/ *pExportAttrSet );
-/*?*/ }
-/*N*/ }
-/*N*/ #endif
-/*N*/
-/*N*/ if( (nEnd1 == STRING_LEN ? pNd->GetTxt().Len() : nEnd1) > STRING_MAXLEN52 )
-/*N*/ nEnd1 = STRING_MAXLEN52;
-/*N*/
-/*N*/ SwInsHardBlankSoftHyph aHBSH;
-/*N*/
-/*N*/ String aText;
-/*N*/ Sw3ExportTxtAttrs *pExpInfo = IsSw31Export()
-/*N*/ ? ExportTxtNode( *pNd, nStart, nEnd1, eSrcSet, aHBSH )
-/*N*/ : 0;
-/*N*/
-/*N*/ ByteString aText8;
-/*N*/ if( !pExpInfo )
-/*N*/ {
-/*N*/ aText = pNd->GetTxt();
-/*N*/ if( nEnd1 == STRING_LEN || nEnd1 < nStart )
-/*N*/ nEnd1 = aText.Len();
-/*N*/ else if ( nEnd1 != aText.Len() )
-/*?*/ aText.Erase( nEnd1 );
-/*N*/ if( nStart )
-/*?*/ aText.Erase( 0, nStart );
-/*N*/ const SvxFontItem& rFont = pNd->GetSwAttrSet().GetFont();
-/*N*/ ConvertText( aText8, aText, nStart, *pNd, eSrcSet,
-/*N*/ rFont, &aHBSH, TRUE );
-/*N*/ }
-/*N*/ else
-/*N*/ aText8 = pExpInfo->aText;
-/*N*/
-/*N*/ if( aText.Len() )
-/*N*/ sw3io_countwords( aDefWordDelim, aText, aStat.nWord, aStat.nChar );
-/*N*/
-/*N*/ if( aText8.Len() && pCrypter )
- pCrypter->Encrypt( aText8 );
-/*N*/ pStrm->WriteByteString( aText8 );
-/*N*/ aStat.nPara++;
-/*N*/
-/*N*/ if( pAttrSet )
-/*N*/ OutAttrSet( *pAttrSet );
-/*N*/ delete pExportAttrSet;
-/*N*/ pAttrSet = pExportAttrSet = 0;
-/*N*/ OutNodeMarks( nPosIdx );
-/*N*/
-/*N*/ // die absatzgebunden Rahmen schreiben und beim SW31-Export ggf. auch
-/*N*/ // noch die zeichengebunden Zeichen-Objekte als abstzgebundene Objekte
-/*N*/ OutNodeFlyFrames( nPosIdx );
-/*N*/ if( pExpInfo && pExpInfo->nDrawFrmFmts )
- ExportNodeDrawFrmFmts( *pNd, nStart, nEnd1, pExpInfo->nDrawFrmFmts );
-/*N*/
-/*N*/ // Beim SW31-Export evtl. die "umgebauten" Hints ausgeben, sonst die
-/*N*/ // Original-Hints
-/*N*/ if( pExpInfo )
-/*N*/ ExportTxtAttrs( pExpInfo, nStart, nEnd1 );
-/*N*/ else if( ((SwTxtNode&)rNode).HasHints() )
-/*N*/ OutTxtAttrs( *pNd, nStart, nEnd1 );
-/*N*/ aHBSH.OutAttr( *this, nStart, nEnd1 );
-/*N*/
-/*N*/ // Evtl. noch die neue Numerierungsregel (3.1/4.0) oder die
-/*N*/ // SwNodeNum-Struktor (5.0 ff) ausgeben
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ {
-/*N*/ if( bNewNumRule )
-/*N*/ OutNumRule( SWG_NUMRULE, *pCurNumRule );
-/*N*/ }
-/*N*/ else if( pNdNum )
-/*N*/ {
-/*N*/ OutNodeNum( *pNdNum );
-/*N*/ }
-/*N*/
-/*N*/ // Eventuell noch die Wrong-Liste
-/*N*/ const SwWrongList* pWrong = pNd->GetWrong();
-/*N*/ if( !IsSw31Export() && pWrong )
-/*N*/ {
-/*N*/ OpenRec( SWG_WRONGLIST );
-/*N*/
-/*N*/ // der Header
-/*N*/ cFlags = 0x04; // 4 Bytes Daten
-/*N*/ xub_StrLen nBegin = pWrong->GetBeginInv();
-/*N*/ xub_StrLen nEnd2 = pWrong->GetEndInv();
-/*N*/
-/*N*/ *pStrm << cFlags
-/*N*/ << (UINT16)nBegin
-/*N*/ << (UINT16)nEnd2;
-/*N*/
-/*N*/ // nun die eigentliche Liste
-/*N*/ OpenValuePos16( 0 );
-/*N*/ USHORT nCount = pWrong->Count();
-/*N*/ for( USHORT i=0; i<nCount; i++ )
-/*N*/ {
-/*N*/ xub_StrLen nIdx = pWrong->Pos( i );
-/*N*/ if( nIdx < STRING_MAXLEN52 )
-/*N*/ {
-/*N*/ xub_StrLen nLen = pWrong->Len( i );
-/*N*/ if( nIdx + nLen > STRING_MAXLEN52 )
-/*N*/ nLen = STRING_MAXLEN52 - nIdx;
-/*N*/ UINT32 n = nIdx + (nLen << 16);
-/*N*/ *pStrm << n;
-/*N*/ }
-/*N*/ }
-/*N*/ CloseValuePos16( nCount );
-/*N*/ CloseRec( SWG_WRONGLIST );
-/*N*/ }
-/*N*/
-/*N*/ if( !IsSw31Or40Export() )
-/*N*/ {
-/*N*/ // Redline-Markierungen rausschreiben. Muss wegen geloeschter
-/*N*/ // Redlines immer als letztes passieren, weil beim Einfuegen
-/*N*/ // eines solechen Doks Attribute schon gesetzt sein muessen!
-/*N*/ OutNodeRedlines( nPosIdx );
-/*N*/ }
-/*N*/
-/*N*/ CloseRec( SWG_TEXTNODE );
-/*N*/ }
-
/*N*/ void Sw3IoImp::OutEmptyTxtNode( ULONG nNodeIdx, BOOL bNodeMarks )
/*N*/ {
/*N*/ // 0x0L: length of data
diff --git a/binfilter/bf_sw/source/core/sw3io/sw_sw3num.cxx b/binfilter/bf_sw/source/core/sw3io/sw_sw3num.cxx
index cb4184a..6adf524 100644
--- a/binfilter/bf_sw/source/core/sw3io/sw_sw3num.cxx
+++ b/binfilter/bf_sw/source/core/sw3io/sw_sw3num.cxx
@@ -262,127 +262,8 @@ namespace binfilter {
/*N*/ CloseRec( SWG_NUMFMT );
/*N*/ }
-// Numerierungs-Format ausgeben
-
-
-/*N*/ void Sw3IoImp::OutNumFmt( const SwNumFmt& rFmt, USHORT nPrvAbsLSpace )
-/*N*/ {
-/*N*/ USHORT nFmt = IDX_NO_VALUE;
-/*N*/
-/*N*/ // Wegen eines Bugs in alten Readern, wird die Zeichen-Vorlage erst
-/*N*/ // im 4.0-Format hier geschrieben
-/*N*/ const SwCharFmt* pCharFmt = rFmt.GetCharFmt();
-/*N*/ if( !IsSw31Export() && pCharFmt )
-/*N*/ nFmt = aStringPool.Add( pCharFmt->GetName(), pCharFmt->GetPoolFmtId() );
-/*N*/
-/*N*/ const Font* pFont = rFmt.GetBulletFont();
-/*N*/ String aFontName, aFontStyle;
-/*N*/ BYTE cFamily = 0, cPitch = 0;
-/*N*/ rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW;
-/*N*/ BYTE cFlags = 0;
-/*N*/ sal_Bool bToBats = sal_False;
-/*N*/ if( pFont )
-/*N*/ {
-/*N*/ cFlags |= 0x10;
-/*N*/ cFamily = (BYTE) pFont->GetFamily();
-/*N*/ cPitch = (BYTE) pFont->GetPitch();
-/*N*/ aFontName = pFont->GetName();
-/*N*/ bToBats =
-/*N*/ aFontName == sStarSymbol || aFontName == sOpenSymbol;
-/*N*/ if( bToBats )
-/*N*/ aFontName = sStarBats;
-/*N*/ aFontStyle = pFont->GetStyleName();
-/*N*/
-/*N*/ eEnc = (bToBats ? RTL_TEXTENCODING_SYMBOL
-/*N*/ : GetSOStoreTextEncoding( pFont->GetCharSet(),
-/*N*/ pStrm->GetVersion() ) );
-/*N*/ }
-/*N*/
-/*N*/ sal_Int16 eType = rFmt.GetNumberingType();
-/*N*/ if( SVX_NUM_BITMAP == eType && IsSw31Export() )
-/*N*/ eType = SVX_NUM_CHAR_SPECIAL;
-/*N*/
-/*N*/ sal_Char cBullet;
-/*N*/ if( bToBats )
-/*N*/ cBullet = ConvStarSymbolCharToStarBats( rFmt.GetBulletChar() );
-/*N*/ else
-/*N*/ cBullet = ByteString::ConvertFromUnicode( rFmt.GetBulletChar(),
-/*N*/ ((pFont && RTL_TEXTENCODING_DONTKNOW != pFont->GetCharSet())
-/*N*/ ? eEnc
-/*N*/ : eSrcSet ), FALSE);
-/*N*/ if( !cBullet )
-/*N*/ cBullet = ByteString::ConvertFromUnicode( rFmt.GetBulletChar(),
-/*N*/ RTL_TEXTENCODING_SYMBOL );
-/*N*/ OpenRec( SWG_NUMFMT );
-/*N*/ OutString( *pStrm, rFmt.GetPrefix() );
-/*N*/ OutString( *pStrm, rFmt.GetSuffix() );
-/*N*/ OutString( *pStrm, aFontName );
-/*N*/ OutString( *pStrm, aFontStyle );
-/*N*/ *pStrm << (UINT16) nFmt
-/*N*/ << (BYTE) eType
-/*N*/ << cBullet;
-/*N*/
-/*N*/ // GetIncludeUpperLevel war bis zur 4.0 (inkl) nur ein Flag
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ *pStrm << (BYTE)lcl_sw3io__IsInclUpperLevel( rFmt.GetIncludeUpperLevels() );
-/*N*/ else
-/*N*/ *pStrm << (BYTE)rFmt.GetIncludeUpperLevels();
-/*N*/
-/*N*/ *pStrm << (UINT16) rFmt.GetStart()
-/*N*/ << (BYTE) rFmt.GetNumAdjust()
-/*N*/ << (INT32) rFmt.GetAbsLSpace()
-/*N*/ << (INT32) rFmt.GetFirstLineOffset()
-/*N*/ << (BYTE) cFamily
-/*N*/ << (BYTE) cPitch
-/*N*/ << (BYTE) eEnc
-/*N*/ << (BYTE) cFlags;
-/*N*/
-/*N*/ // MIB 13.11.96: im 4.0-Format wird die Zeichen-Vorlage an der alten
-/*N*/ // Position geschrieben.
-/*N*/ // *pStrm << (UINT16) nFmt
-/*N*/
-/*N*/ // Im 4.0-Format gab es mal relative Werte fuer den Abstand.
-/*N*/ // Im 3.1-Format noch nicht um im 5.0 nicht mehr.
-/*N*/ if( IsSw40Export() )
-/*N*/ {
-/*N*/ *pStrm << (BYTE) FALSE
-/*N*/ << (INT32) (rFmt.GetAbsLSpace() - nPrvAbsLSpace);
-/*N*/ }
-/*N*/
-/*N*/ // Den Rest gibt es seit der 4.0
-/*N*/ if( !IsSw31Export() )
-/*N*/ {
-/*N*/ *pStrm << (UINT16) rFmt.GetCharTextDistance();
-/*N*/
-/*N*/ if( SVX_NUM_BITMAP == rFmt.GetNumberingType() )
-/*N*/ {
-/*?*/ *pStrm << (INT32)rFmt.GetGraphicSize().Width()
-/*?*/ << (INT32)rFmt.GetGraphicSize().Height();
-/*?*/ BYTE cFlg = ( 0 != rFmt.GetBrush() ? 1 : 0 ) +
-/*?*/ ( 0 != rFmt.GetGraphicOrientation() ? 2 : 0 );
-/*?*/ *pStrm << cFlg;
-/*?*/
-/*?*/ if( rFmt.GetBrush() )
-/*?*/ {
-/*?*/ USHORT nVersion2 = rFmt.GetBrush()->GetVersion( (USHORT)pStrm->GetVersion() );
-/*?*/ *pStrm << nVersion2;
-/*?*/ rFmt.GetBrush()->Store( *pStrm, nVersion2 );
-/*?*/ }
-/*?*/ if( rFmt.GetGraphicOrientation() )
-/*?*/ {
-/*?*/ USHORT nVersion3 = rFmt.GetGraphicOrientation()->GetVersion( (USHORT)pStrm->GetVersion() );
-/*?*/ *pStrm << nVersion3;
-/*?*/ rFmt.GetGraphicOrientation()->Store( *pStrm, nVersion3 );
-/*?*/ }
-/*N*/ }
-/*N*/ }
-/*N*/
-/*N*/ CloseRec( SWG_NUMFMT );
-/*N*/ }
-
// Numerierungs-Regelwerk einlesen
-
/*N*/ SwNumRule* Sw3IoImp::InNumRule( BYTE cType )
/*N*/ {
/*N*/ BYTE eType, nFmt, cFmt[ MAXLEVEL ];
@@ -647,185 +528,6 @@ namespace binfilter {
/*N*/ CloseRec( SWG_OUTLINEEXT );
/*N*/ }
-// Numerierungs-Regelwerk ausgeben
-
-typedef const SwTxtFmtColl *Sw3TxtFmtCollPtrConst;
-
-/*N*/ void Sw3IoImp::OutNumRule( BYTE cType, const SwNumRule& rRule )
-/*N*/ {
-/*N*/ OpenRec( cType );
-/*N*/
-/*N*/ // Ein-Flag-Record mit Pool-Ids gibt's seit der 5.0
-/*N*/ // 0x10: keine automatische Vorlage
-/*N*/ // 0x02: invalid Rule
-/*N*/ // 0x40: continus Num
-/*N*/ BYTE cFlags = 0x03;
-/*N*/ if( !IsSw31Or40Export() )
-/*N*/ {
-/*N*/ // Nur nicht-automatische Numerierungs-Regeln haben Pool-Ids
-/*N*/ if( cType != SWG_OUTLINE && !rRule.IsAutoRule() )
-/*N*/ cFlags += 0x15;
-/*N*/
-/*N*/ if( rRule.IsInvalidRule() )
-/*N*/ cFlags += 0x20;
-/*N*/
-/*N*/ if( rRule.IsContinusNum() )
-/*N*/ cFlags += 0x40;
-/*N*/
-/*N*/ #ifdef NUM_RELSPACE
-/*N*/ if( rRule.IsAbsSpaces() )
-/*N*/ cFlags += 0x80;
-/*N*/ #endif
-/*N*/
-/*N*/ *pStrm << (BYTE)cFlags
-/*N*/ << (UINT16)aStringPool.Find( rRule.GetName(),
-/*N*/ rRule.GetPoolFmtId() );
-/*N*/
-/*N*/ if( cFlags & 0x10 )
-/*N*/ {
-/*N*/ *pStrm << (UINT16) rRule.GetPoolFmtId()
-/*N*/ << (UINT16) rRule.GetPoolHelpId()
-/*N*/ << (BYTE) rRule.GetPoolHlpFileId();
-/*N*/ }
-/*N*/ }
-/*N*/
-/*N*/ // Der Rule Type steht im 5.0-Format noch im Flag-Record, auch wenn
-/*N*/ // es nicht so aussieht.
-/*N*/ *pStrm << (BYTE)rRule.GetRuleType();
-/*N*/
-/*N*/ // Tabelle der definierten Formate aufbauen
-/*N*/ USHORT nMaxLevel = IsSw31Or40Export() ? OLD_MAXLEVEL : MAXLEVEL;
-/*N*/ short nFmt = 0;
- USHORT i=0;
-/*N*/ for( i = 0; i < nMaxLevel; i++ )
-/*N*/ {
-/*N*/ const SwNumFmt* pFmt = rRule.GetNumFmt( i );
-/*N*/ if( pFmt ) nFmt++;
-/*N*/ }
-/*N*/ *pStrm << (BYTE) nFmt;
-/*N*/ for( i = 0; i < nMaxLevel; i++ )
-/*N*/ {
-/*N*/ const SwNumFmt* pFmt = rRule.GetNumFmt( i );
-/*N*/ if( pFmt )
-/*N*/ *pStrm << (BYTE) i;
-/*N*/ }
-/*N*/
-/*N*/ BOOL bOutline = SWG_OUTLINE == cType;
-/*N*/ Sw3TxtFmtCollPtrConst* ppTxtColls = 0;
-/*N*/ if( bOutline && nFmt && !rRule.IsAbsSpaces() && !IsSw31Or40Export() )
-/*N*/ {
-/*N*/ const SwTxtFmtColls& rColls = *pDoc->GetTxtFmtColls();
-/*N*/ for( i=0; i<rColls.Count(); i++ )
-/*N*/ {
-/*N*/ const SwTxtFmtColl *pColl = rColls[i];
-/*N*/ BYTE nLevel = pColl->GetOutlineLevel();
-/*N*/ if( NO_NUMBERING != nLevel )
-/*N*/ {
-/*N*/ nLevel = GetRealLevel(nLevel);
-/*N*/ if( nLevel < nMaxLevel )
-/*N*/ {
-/*N*/ if(!ppTxtColls)
-/*N*/ {
-/*N*/ ppTxtColls = new Sw3TxtFmtCollPtrConst[MAXLEVEL];
-/*N*/ for( USHORT j=0; j < MAXLEVEL; j++ )
-/*N*/ ppTxtColls[j] = 0;
-/*N*/ }
-/*N*/
-/*N*/ ppTxtColls[nLevel] = pColl;
-/*N*/ }
-/*N*/ }
-/*N*/ }
-/*N*/ }
-/*N*/
-/*N*/ // Formate ausgeben
-/*N*/ BOOL bFirst = TRUE;
-/*N*/ USHORT nPrvAbsLSpace = 0;
-/*N*/ BYTE nAbsLSpaceChanged = 0;
-/*N*/ for( i = 0; i < nMaxLevel; i++ )
-/*N*/ {
-/*N*/ const SwNumFmt* pFmt = rRule.GetNumFmt( i );
-/*N*/ if( pFmt )
-/*N*/ {
-/*N*/ BOOL bOutFmt = TRUE;
-/*N*/ #ifdef NUM_RELSPACE
-/*N*/ if( ppTxtColls && ppTxtColls[i] != 0 )
-/*N*/ {
-/*N*/ // Im 5.0-Format wird der linke Abstand der Vorlage auf
-/*N*/ // den Wert der NumRule addiert und der Original-Wert
-/*N*/ // getrennt gespeichert.
-/*N*/ OSL_ENSURE( !IsSw31Or40Export(), "Doch 3.1/4.0-Export?" );
-/*N*/ OSL_ENSURE( !rRule.IsAbsSpaces(), "Doch absolute Abstaende?" );
-/*N*/ OSL_ENSURE( bOutline, "Doch keine Kapitel-Numerierung?" );
-/*N*/ const SvxLRSpaceItem& rLRSpace = ppTxtColls[i]->GetLRSpace();
-/*N*/ if( rLRSpace.GetTxtLeft() > 0 )
-/*N*/ {
-/*N*/ SwNumFmt aFmt( *pFmt );
-/*N*/ aFmt.SetAbsLSpace( (USHORT)(aFmt.GetAbsLSpace() +
-/*N*/ rLRSpace.GetTxtLeft()) );
-/*N*/ USHORT nTmp = bFirst ? aFmt.GetAbsLSpace() : nPrvAbsLSpace;
-/*N*/ OutNumFmt( aFmt, nTmp );
-/*N*/ nPrvAbsLSpace = aFmt.GetAbsLSpace();
-/*N*/
-/*N*/ bOutFmt = FALSE;
-/*N*/ nAbsLSpaceChanged++;
-/*N*/ }
-/*N*/ else
-/*N*/ {
-/*N*/ ppTxtColls[i] = 0;
-/*N*/ }
-/*N*/ }
-/*N*/ else if( bOutline && IsSw31Or40Export() &&
-/*N*/ (pFmt->GetAbsLSpace() > 0 ||
-/*N*/ pFmt->GetFirstLineOffset() != 0) )
-/*N*/ {
-/*N*/ // Im 3.1- oder 4.0-Format gab es noch keinen linken Abstand
-/*N*/ // und keinen Erstzeilen-Einzug. Er wird ggf. bei den Vorlagen
-/*N*/ // exportiert.
-/*N*/ SwNumFmt aFmt( *pFmt );
-/*N*/ aFmt.SetAbsLSpace( 0U );
-/*N*/ aFmt.SetFirstLineOffset( 0 );
-/*N*/ USHORT nTmp = bFirst ? aFmt.GetAbsLSpace() : nPrvAbsLSpace;
-/*N*/ OutNumFmt( aFmt, nTmp );
-/*N*/ nPrvAbsLSpace = aFmt.GetAbsLSpace();
-/*N*/
-/*N*/ bOutFmt = FALSE;
-/*N*/ }
-/*N*/ #endif
-/*N*/ if( bOutFmt )
-/*N*/ {
-/*N*/ USHORT nTmp = bFirst ? pFmt->GetAbsLSpace() : nPrvAbsLSpace;
-/*N*/ OutNumFmt( *pFmt, nTmp );
-/*N*/ nPrvAbsLSpace = pFmt->GetAbsLSpace();
-/*N*/ }
-/*N*/ bFirst = FALSE;
-/*N*/ }
-/*N*/ else if( ppTxtColls )
-/*N*/ ppTxtColls[i] = 0;
-/*N*/ }
-/*N*/ CloseRec( cType );
-/*N*/
-/*N*/ #ifdef NUM_RELSPACE
-/*N*/ if( ppTxtColls && nAbsLSpaceChanged > 0 )
-/*N*/ {
-/*N*/ OSL_ENSURE( !IsSw31Or40Export(), "Doch 3.1/4.0-Export?" );
-/*N*/ OSL_ENSURE( !rRule.IsAbsSpaces(), "Doch absolute Abstaende?" );
-/*N*/
-/*N*/ OpenRec( SWG_OUTLINEEXT );
-/*N*/ *pStrm << (BYTE)0x01
-/*N*/ << (BYTE)nAbsLSpaceChanged;
-/*N*/
-/*N*/ for( BYTE j=0; j < MAXLEVEL; j++ )
-/*N*/ {
-/*N*/ if( ppTxtColls[j] )
-/*N*/ *pStrm << (BYTE)j << (UINT16)rRule.Get(j).GetAbsLSpace();
-/*N*/ }
-/*N*/ CloseRec( SWG_OUTLINEEXT );
-/*N*/ }
-/*N*/
-/*N*/ delete[] ppTxtColls;
-/*N*/ #endif
-/*N*/ }
-
// Numerierungs-Regelwerk einlesen
void lcl_sw3io__copyNumRule( const SwNumRule& rSrc, SwNumRule& rDst )
diff --git a/binfilter/bf_sw/source/core/sw3io/sw_sw3redln.cxx b/binfilter/bf_sw/source/core/sw3io/sw_sw3redln.cxx
index 01ab601..7f39db2 100644
--- a/binfilter/bf_sw/source/core/sw3io/sw_sw3redln.cxx
+++ b/binfilter/bf_sw/source/core/sw3io/sw_sw3redln.cxx
@@ -374,61 +374,6 @@ namespace binfilter {
/*N*/ CloseRec( SWG_NODEREDLINE );
/*N*/ }
-/*N*/ void Sw3IoImp::OutNodeRedlines( ULONG nIdx )
-/*N*/ {
-/*N*/ OSL_ENSURE( !IsSw31Or40Export(), "Redlines werden nicht exportiert!" );
-/*N*/
-/*N*/ if( pRedlineMarks )
-/*N*/ {
-/*?*/ for( USHORT nPos = 0; nPos < pRedlineMarks->Count(); ++nPos )
-/*?*/ {
-/*?*/ Sw3Mark *pMark = (*pRedlineMarks)[ nPos ];
-/*?*/ if( pMark->GetNodePos() == nIdx )
-/*?*/ {
-/*?*/ OSL_ENSURE( pMark->GetId() < pRedlines->Count(),
-/*?*/ "ungeuletige Redline-Id" );
-/*?*/ Sw3MarkType eMarkType = pMark->GetType();
-/*?*/ SwRedline *pRedline = (*pRedlines)[pMark->GetId()];
-/*?*/ const SwNodeIndex *pContentIdx = pRedline->GetContentIdx();
-/*?*/
-/*?*/ OpenRec( SWG_NODEREDLINE );
-/*?*/
-/*?*/ BYTE cFlags = 0x04;
-/*?*/ if( SW3_REDLINE_END == eMarkType )
-/*?*/ cFlags |= 0x10;
-/*?*/ else if( pContentIdx )
-/*?*/ cFlags |= 0x20;
-/*?*/
-/*?*/ xub_StrLen nOffs = pMark->GetNodeOff();
-/*?*/ *pStrm << (BYTE) cFlags
-/*?*/ << (UINT16)pMark->GetId()
-/*?*/ << (UINT16)nOffs;
-/*?*/
-/*?*/ if( pContentIdx )
-/*?*/ {
-/*?*/ OSL_ENSURE( pContentIdx->GetNode().EndOfSectionIndex() -
-/*?*/ pContentIdx->GetIndex(),
-/*?*/ "empty redline section exported" );
-/*?*/ OutContents( *pContentIdx );
-/*?*/ }
-/*?*/
-/*?*/ CloseRec( SWG_NODEREDLINE );
-/*?*/
-/*?*/ pRedlineMarks->Remove( nPos-- );
-/*?*/ delete pMark;
-/*?*/ if( !pRedlineMarks->Count() )
-/*?*/ {
-/*?*/ delete pRedlineMarks;
-/*?*/ pRedlineMarks = NULL;
-/*?*/ break;
-/*?*/ }
-/*?*/ }
-/*?*/ else if( pMark->GetNodePos() > nIdx )
-/*?*/ break;
-/*?*/ }
-/*N*/ }
-/*N*/ }
-
/*N*/ namespace
/*N*/ {
/*N*/ void CorrRedline( SwRedline& rRedline,
diff --git a/binfilter/bf_sw/source/core/sw3io/sw_sw3sectn.cxx b/binfilter/bf_sw/source/core/sw3io/sw_sw3sectn.cxx
index 976adee..93e7e3b 100644
--- a/binfilter/bf_sw/source/core/sw3io/sw_sw3sectn.cxx
+++ b/binfilter/bf_sw/source/core/sw3io/sw_sw3sectn.cxx
@@ -363,26 +363,6 @@ namespace binfilter {
/*N*/ return *pSttNd;
/*N*/ }
-// Ausgabe einer kompletten Contents-Section
-// Der uebergebene Index zeigt auf den StartNode
-
-/*N*/ void Sw3IoImp::OutContents( const SwNodeIndex& rStart )
-/*N*/ {
-/*N*/ // Der Index zeigt auf den Start-Node, also muessen wir einen
-/*N*/ // bauen, der auf den naechsten Node zeigt
-/*N*/ SwStartNode* pStt = pDoc->GetNodes()[ rStart ]->GetStartNode();
-/*N*/ OSL_ENSURE( pStt, "StartNode nicht gefunden" );
-/*N*/ if( pStt )
-/*N*/ {
-/*N*/ // Hole vom Node und vom letzten Node die Position in der Section
-/*N*/ ULONG nStt = rStart.GetIndex();
-/*N*/ ULONG nEnd = pStt->EndOfSectionIndex()-1;
-/*N*/ // kein Bereich also kein gueltiger Node
-/*N*/ if( nStt <= nEnd )
-/*N*/ OutContents( nStt, nEnd, 0, STRING_LEN );
-/*N*/ }
-/*N*/ }
-
// Besitzt ein Text-Knoten Markierungen oder FlyFrames?
/*N*/ BOOL lcl_sw3sectn_NodeHasFlyOrMark( Sw3IoImp& rIo, ULONG nIdx )
/*N*/ {
@@ -411,203 +391,6 @@ namespace binfilter {
/*N*/ return FALSE;
/*N*/ }
-
-// Ausgabe eines fest definierten Doc-Bereichs.
-// Der Offset wird beim ersten TextNode angewandt.
-
-/*N*/ void Sw3IoImp::OutContents
-/*N*/ ( ULONG nCurNode, ULONG nEndNode, xub_StrLen nCurPos, xub_StrLen nEndPos,
-/*N*/ BOOL bTopLevel )
-/*N*/ {
-/*N*/ // Die aktuelle NumRuke muss gerettet werden, falls ein 3.1/40-Export
-/*N*/ // stattfindet und eine Sectioninnerhalb einer Section geschrieben
-/*N*/ // wird (z.B. Flys)
-/*N*/ SwNumRule* pOld40Rule = NULL;
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ {
-/*N*/ pOld40Rule = pCurNumRule;
-/*N*/ pCurNumRule = NULL;
-/*N*/ }
-/*N*/
-/*N*/ BOOL bOldExportFlyFrmFmt = FALSE;
-/*N*/ const SwFlyFrm* pOldExportFlyFrm = NULL;
-/*N*/ if( pExportInfo )
-/*N*/ {
-/*N*/ bOldExportFlyFrmFmt = pExportInfo->bFlyFrmFmt;
-/*N*/ pOldExportFlyFrm = pExportInfo->pFlyFrm;
-/*N*/ pExportInfo->bFlyFrmFmt = FALSE;
-/*N*/ pExportInfo->pFlyFrm = NULL;
-/*N*/ }
-/*N*/
-/*N*/ SwStartNode* pStt = pDoc->GetNodes()[ nCurNode ]->GetStartNode();
-/*N*/ if( pStt && pStt->GetNodeType() == ND_STARTNODE )
-/*N*/ nCurNode++; // StartNode nicht speichern, TblNode/SectionNode wohl
-/*N*/ else
-/*N*/ pStt = pDoc->GetNodes()[ nCurNode ]->FindStartNode();
-/*N*/ OpenRec( SWG_CONTENTS );
-/*N*/ *pStrm << (BYTE) 0x04; // 4 Byte Daten, aber unterschiedliche
-/*N*/
-/*N*/ ULONG nNodes = 0;
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ {
-/*N*/ *pStrm << (UINT16) IDX_NO_VALUE; // war mal Section-Id (siehe Tbl)
-/*N*/ OpenValuePos16( (UINT16)nNodes );
-/*N*/ }
-/*N*/ else
-/*N*/ {
-/*N*/ OpenValuePos32( nNodes );
-/*N*/ }
-/*N*/
-/*N*/ nNodes = OutNodes( nCurNode, nEndNode, nCurPos, nEndPos, bTopLevel );
-/*N*/
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ CloseValuePos16( (UINT16)nNodes );
-/*N*/ else
-/*N*/ CloseValuePos32( nNodes );
-/*N*/
-/*N*/ // Jetzt noch an den Start-Node der Section (Rahmen)gebundenen
-/*N*/ // Rahmen und Redlines rausschreiben.
-/*N*/ if( !IsSw31Or40Export() )
-/*N*/ {
-/*N*/ OutNodeFlyFrames( pStt->GetIndex() );
-/*N*/ OutNodeRedlines( pStt->GetIndex() );
-/*N*/ OutNodeRedlines( pStt->EndOfSectionIndex() );
-/*N*/ }
-/*N*/
-/*N*/
-/*N*/ CloseRec( SWG_CONTENTS );
-/*N*/
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ pCurNumRule = pOld40Rule;
-/*N*/
-/*N*/ if( pExportInfo )
-/*N*/ {
-/*N*/ pExportInfo->bFlyFrmFmt = bOldExportFlyFrmFmt;
-/*N*/ pExportInfo->pFlyFrm = pOldExportFlyFrm;
-/*N*/ }
-/*N*/ }
-
-/*N*/ ULONG Sw3IoImp::OutNodes( ULONG nCurNode, ULONG nEndNode,
-/*N*/ xub_StrLen nCurPos, xub_StrLen nEndPos,
-/*N*/ BOOL bTopLevel )
-/*N*/ {
-/*N*/ ULONG nNodes = 0;
-/*N*/
-/*N*/ ULONG nWords = 0, nChars = 0;
-/*N*/ ULONG nRepNodesToWrite = 0;
-/*N*/ SwTxtNode *pLastNode = NULL;
-/*N*/ BOOL bFirstNode = bTopLevel;
-/*N*/
-/*N*/ while( nCurNode <= nEndNode && Good() )
-/*N*/ {
-/*N*/ SetPercentBar( nCurNode );
-/*N*/ SwNode* pNd = pDoc->GetNodes()[ nCurNode ];
-/*N*/
-/*N*/ BYTE nNodeType = pNd->GetNodeType();
-/*N*/
-/*N*/ if( nNodeType==ND_TEXTNODE )
-/*N*/ {
-/*N*/ // Ist der Knoten einer Wiederholung des vorherigen?
-/*N*/ // NIE(!!!) wenn dies der letzte zu speichernde Knoten des
-/*N*/ // Top-Levels ist, weil dies beim Einfuegen des Doks Probleme
-/*N*/ // bereiten kann.
-/*N*/ SwTxtNode *pTxtNd = pNd->GetTxtNode();
-/*N*/ if( pLastNode &&
-/*N*/ (!bTopLevel || nCurNode!=nEndNode) &&
-/*N*/ pLastNode->GetFmtColl() == pTxtNd->GetFmtColl() &&
-/*N*/ pLastNode->GetCondFmtColl() == pTxtNd->GetCondFmtColl() &&
-/*N*/ ( ( 0 == pLastNode->GetNum() &&
-/*N*/ 0 == pTxtNd->GetNum() ) ||
-/*N*/ ( pLastNode->GetNum() && pTxtNd->GetNum() &&
-/*N*/ ( pLastNode->GetNum()->GetLevel() ==
-/*N*/ pTxtNd->GetNum()->GetLevel() ) ) ) &&
-/*N*/ !pTxtNd->HasHints() &&
-/*N*/ !pTxtNd->GetpSwAttrSet() &&
-/*N*/ pLastNode->GetTxt().Len() == pTxtNd->GetTxt().Len() &&
-/*N*/ pLastNode->GetTxt() == pTxtNd->GetTxt() &&
-/*N*/ !lcl_sw3sectn_NodeHasFlyOrMark( *this, nCurNode ) )
-/*N*/ {
-/*N*/ nRepNodesToWrite++;
-/*N*/ nCurNode++;
-/*N*/ continue;
-/*N*/ }
-/*N*/ // Den ersten Knoeten des Top-Levels duerfen wir nie als
-/*N*/ // Ausgangsbasis einer Wiederholung benutzen, sonst gibt's beim
-/*N*/ // Einfuegen des Doks in ein anderes Probleme, weil der
-/*N*/ // Knoten kopiert wird.
-/*N*/ if( !bFirstNode &&
-/*N*/ !pTxtNd->HasHints() &&
-/*N*/ !pTxtNd->GetpSwAttrSet() &&
-/*N*/ !lcl_sw3sectn_NodeHasFlyOrMark( *this, nCurNode ) )
-/*N*/ pLastNode = pTxtNd;
-/*N*/ else
-/*N*/ pLastNode = NULL;
-/*N*/ }
-/*N*/ else
-/*N*/ pLastNode = NULL;
-/*N*/
-/*N*/ bFirstNode = FALSE;
-/*N*/
-/*N*/ if( nRepNodesToWrite>0 )
-/*N*/ {
-/*N*/ OutRepTxtNode( nRepNodesToWrite );
-/*N*/ aStat.nPara += nRepNodesToWrite;
-/*N*/ aStat.nWord += nRepNodesToWrite*(aStat.nWord-nWords);
-/*N*/ aStat.nChar += nRepNodesToWrite*(aStat.nChar-nChars);
-/*N*/ nRepNodesToWrite = 0;
-/*N*/ nNodes++;
-/*N*/ }
-/*N*/
-/*N*/ switch( (int)nNodeType )
-/*N*/ {
-/*N*/ case ND_SECTIONNODE:
-/*N*/ nNodes += OutSection( *pNd->GetSectionNode() );
-/*N*/ nCurNode = pNd->GetSectionNode()->EndOfSectionIndex() + 1;
-/*N*/ break;
-/*N*/ case ND_TABLENODE:
-/*N*/ OutTable( *pNd->GetTableNode() );
-/*N*/ nCurNode = pNd->GetTableNode()->EndOfSectionIndex() + 1;
-/*N*/ break;
-/*N*/ case ND_TEXTNODE:
-/*N*/ nWords = aStat.nWord;
-/*N*/ nChars = aStat.nChar;
-/*N*/ OutTxtNode( *pNd->GetTxtNode(), nCurPos, nEndPos, nCurNode );
-/*N*/ nCurPos = 0; nCurNode++;
-/*N*/ break;
-/*N*/ case ND_GRFNODE:
-/*N*/ OutGrfNode( *pNd->GetNoTxtNode() );
-/*N*/ nCurPos = 0; nCurNode++;
-/*N*/ break;
-/*N*/ case ND_OLENODE:
-/*N*/ OutOLENode( *pNd->GetNoTxtNode() );
-/*N*/ nCurPos = 0; nCurNode++;
-/*N*/ break;
-/*?*/ case ND_ENDNODE:
-/*?*/ // Das kann der Teil einer Section sein,
-/*?*/ // kann einfach ignoriert werden
-/*?*/ nNodes--; nCurNode++; break;
-/*?*/ default:
-/*?*/ OSL_ENSURE( !this, "Node kann nicht gespeichert werden" );
-/*?*/ Error( ERR_SWG_WRITE_ERROR );
-/*?*/ nCurNode = nEndNode;
-/*N*/ }
-/*N*/ nNodes++;
-/*N*/ }
-/*N*/
-/*N*/ // falls der letzte Knoten eine Wiederholung ist:
-/*N*/ if( nRepNodesToWrite>0 && Good() )
-/*N*/ {
-/*?*/ OutRepTxtNode( nRepNodesToWrite );
-/*?*/ aStat.nPara += nRepNodesToWrite;
-/*?*/ aStat.nWord += nRepNodesToWrite*(aStat.nWord-nWords);
-/*?*/ aStat.nChar += nRepNodesToWrite*(aStat.nChar-nChars);
-/*?*/ nRepNodesToWrite = 0;
-/*?*/ nNodes++;
-/*N*/ }
-/*N*/
-/*N*/ return nNodes;
-/*N*/ }
-
// Einlesen einer "echten" Section innerhalb eines Content-Bereichs
// Auch hier wird der uebergebene Index weitergefuehrt.
@@ -720,166 +503,6 @@ namespace binfilter {
/*N*/
/*N*/ return bRet;
/*N*/ }
-
-/*N*/ ULONG Sw3IoImp::OutTOXSection( const SwSectionNode& rNd )
-/*N*/ {
-/*N*/ const SwSection& rSect = rNd.GetSection();
-/*N*/
-/*N*/ OSL_ENSURE( TOX_HEADER_SECTION == rSect.GetType() ||
-/*N*/ TOX_CONTENT_SECTION == rSect.GetType(),
-/*N*/ "Not a TOX section" );
-/*N*/
-/*N*/ ULONG nStt = rNd.GetIndex() + 1;
-/*N*/ ULONG nEnd = rNd.EndOfSectionIndex()-1;
-/*N*/
-/*N*/ if( nStt > nEnd )
-/*N*/ return 0;
-/*N*/
-/*N*/ ULONG nNodes = 0;
-/*N*/
-/*N*/ // If a tox content section starts with a start node or ends with
-/*N*/ // an end node that doesn't belong to a tox header section, an
-/*N*/ // additional text node has to be inserted.
-/*N*/
-/*N*/ // +-- tox c +-- tox c +-- tox c +-- tox c
-/*N*/ // *| text *|+- stt |+- tox h *|+- tox h
-/*N*/ // | || *|| text ||+ stt
-/*N*/ //
-/*N*/ // | || *|| text ||+ end
-/*N*/ // *| text *|+- end |+- tox h *|+- tox h
-/*N*/ // +-- tox c +-- tox c +-- tox c +-- tox c
-/*N*/ //
-/*N*/ // node before: no yes no yes
-/*N*/ // node behind: no yes no yes
-/*N*/ //
-/*N*/ // The * indicate the position of the tox marks
-/*N*/
-/*N*/ if( TOX_CONTENT_SECTION == rSect.GetType() )
-/*N*/ {
-/*N*/ const SwStartNode *pSttNd = pDoc->GetNodes()[nStt]->GetStartNode();
-/*N*/ if( pSttNd && ( !lcl_sw3io_isTOXHeaderSection( *pSttNd ) ||
-/*N*/ !pDoc->GetNodes()[nStt+1]->IsTxtNode() ) )
-/*N*/ {
-/*?*/ OutEmptyTxtNode( nStt, TRUE );
-/*?*/ nNodes++;
-/*N*/ }
-/*N*/ }
-/*N*/
-/*N*/ nNodes += OutNodes( nStt, nEnd, 0, STRING_LEN, FALSE );
-/*N*/
-/*N*/ if( TOX_CONTENT_SECTION == rSect.GetType() )
-/*N*/ {
-/*N*/ const SwEndNode *pEndNd = pDoc->GetNodes()[nEnd]->GetEndNode();
-/*N*/ if( pEndNd &&
-/*N*/ ( !lcl_sw3io_isTOXHeaderSection(*pEndNd->StartOfSectionNode()) ||
-/*N*/ !pDoc->GetNodes()[nEnd-1]->IsTxtNode() ) )
-/*N*/ {
-/*?*/ OutEmptyTxtNode( nEnd, TRUE );
-/*?*/ nNodes++;
-/*N*/ }
-/*N*/ }
-/*N*/
-/*N*/ // The sections start node is counted by OutNodes, but it hasn't been
-/*N*/ // written. That for, the number of nodes must be reduced by one.
-/*N*/ OSL_ENSURE( nNodes > 0, "empty TOX section?" );
-/*N*/ return nNodes - 1;
-/*N*/ }
-
-/*N*/ ULONG Sw3IoImp::OutSection( const SwSectionNode& rNd )
-/*N*/ {
-/*N*/ const SwSection& rSect = rNd.GetSection();
-/*N*/
-/*N*/ if( TOX_HEADER_SECTION == rSect.GetType() ||
-/*N*/ TOX_CONTENT_SECTION == rSect.GetType() )
-/*N*/ {
-/*N*/ return OutTOXSection( rNd );
-/*N*/ }
-/*N*/
-/*N*/ OpenRec( SWG_SECTION );
-/*N*/ OutString( *pStrm, rSect.GetName() );
-/*N*/ OutString( *pStrm, rSect.GetCondition() );
-/*N*/ // 0x02 - 2 Bytes Daten (Typ)
-/*N*/ // 0x10 - hidden
-/*N*/ // 0x20 - protected
-/*N*/ // 0x40 - !conditional hidden (gedreht, fuers Einlesen von alten Docs)
-/*N*/ BYTE cFlags = 0x02;
-/*N*/ if( rSect.IsHidden() )
-/*N*/ cFlags |= 0x10;
-/*N*/ if( rSect.IsProtect() )
-/*N*/ cFlags |= 0x20;
-/*N*/ if( !rSect.IsCondHidden() )
-/*N*/ cFlags |= 0x40;
-/*N*/ if( !rSect.IsConnectFlag() )
-/*N*/ cFlags |= 0x80;
-/*N*/ *pStrm << (BYTE) cFlags
-/*N*/ << (UINT16) rSect.GetType();
-/*N*/
-/*N*/ SwSectionFmt* pFmt = rSect.GetFmt();
-/*N*/ OutFormat( SWG_SECTFMT, *rSect.GetFmt() );
-/*N*/
-/*N*/ // Hier einen auf den StartNode draufzaehlen, sonst wird
-/*N*/ // der Bereich rekursiv gespeichert!
-/*N*/ ULONG nStt = rNd.GetIndex() + 1;
-/*N*/ ULONG nEnd = rNd.EndOfSectionIndex()-1;
-/*N*/ // kein Bereich also kein gueltiger Node
-/*N*/ if( nStt <= nEnd )
-/*N*/ {
-/*N*/ if( !IsSw31Export() &&
-/*N*/ pDoc->IsGlobalDoc() && !pDoc->IsGlblDocSaveLinks() &&
-/*N*/ pFmt->GetGlobalDocSection() )
-/*N*/ {
-/*N*/ // nur eine Section mit einem DummyTextNode speichern!
-/*N*/ OpenRec( SWG_CONTENTS );
-/*N*/ *pStrm << (BYTE) 0x04; // 4 Byte Daten
-/*N*/
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ {
-/*?*/ *pStrm << (UINT16) IDX_NO_VALUE; // war mal Section-Id
-/*?*/ OpenValuePos16( 0 );
-/*N*/ }
-/*N*/ else
-/*N*/ {
-/*N*/ OpenValuePos32( 0 );
-/*N*/ }
-/*N*/
-/*N*/ // leeren TextNode schreiben
-/*N*/ OutEmptyTxtNode();
-/*N*/
-/*N*/ if( IsSw31Or40Export() )
-/*?*/ CloseValuePos16( 1 );
-/*N*/ else
-/*N*/ CloseValuePos32( 1 );
-/*N*/
-/*N*/ CloseRec( SWG_CONTENTS );
-/*N*/ }
-/*N*/ else
-/*N*/ OutContents( nStt, nEnd, 0, STRING_LEN );
-/*N*/ }
-/*N*/ // Link-Filenamen schreiben
-/*N*/ String aLinkFileName( rSect.GetLinkFileName() );
-/*N*/ if( aLinkFileName.Len() && FILE_LINK_SECTION == rSect.GetType() )
-/*N*/ {
-/*N*/ xub_StrLen nTokenPos = aLinkFileName.Search( ::binfilter::cTokenSeperator );
-/*N*/ if( STRING_NOTFOUND != nTokenPos && nTokenPos )
-/*N*/ {
-/*N*/ String sURL( aLinkFileName.Copy( 0, nTokenPos ) );
-/*N*/ aLinkFileName.Erase( 0, nTokenPos );
-/*N*/ aLinkFileName.Insert( ::binfilter::StaticBaseUrl::AbsToRel( sURL ), 0 );
-/*N*/ }
-/*N*/ }
-/*N*/
-/*N*/ ByteString s8 = ConvertStringNoDelim( aLinkFileName, ::binfilter::cTokenSeperator,
-/*N*/ '\xff', eSrcSet );
-/*N*/ pStrm->WriteByteString( s8 );
-/*N*/
-/*N*/ CloseRec( SWG_SECTION );
-/*N*/
-/*N*/ return 0;
-/*N*/ }
-
-// NEXT: sw3sectn_0a
-
-
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/binfilter/bf_sw/source/core/sw3io/sw_sw3table.cxx b/binfilter/bf_sw/source/core/sw3io/sw_sw3table.cxx
index 9a59226..48639a3 100644
--- a/binfilter/bf_sw/source/core/sw3io/sw_sw3table.cxx
+++ b/binfilter/bf_sw/source/core/sw3io/sw_sw3table.cxx
@@ -306,70 +306,6 @@ BOOL lcl_sw3io_CollectLineFmts( const SwTableLine*& rpLine, void* pPara );
/*N*/ #endif
/*N*/ }
-// Schreiben einer Tabelle
-
-
-/*N*/ void Sw3IoImp::OutTable( const SwTableNode& rNd )
-/*N*/ {
-/*N*/ Sw3FrmFmts *pOldTblLineBoxFmts = pTblLineBoxFmts;
-/*N*/ pTblLineBoxFmts = 0;
-/*N*/
-/*N*/ const SwTable& rTbl = rNd.GetTable();
-/*N*/ const SwTableLines& rLines = rTbl.GetTabLines();
-/*N*/ USHORT nLines = rLines.Count();
-/*N*/ SwTable* pOldTbl = pCurTbl;
-/*N*/ pCurTbl = (SwTable*) &rTbl;
-/*N*/ // 0x04 - Anzahl Boxes, Tabellen-ID
-/*N*/ // 0x10 - Modified
-/*N*/ // 0x20 - HeadLineRepeat
-/*N*/ BYTE cFlags;
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ cFlags = IsSw31Export() ? 0x04 : 0x05;
-/*N*/ else
-/*N*/ cFlags = 0x03;
-/*N*/ UINT16 nBoxes = 0;
-/*N*/ //JP 16.02.99: ueberflussiges Flag
-/*N*/ // if( rTbl.IsModified() )
-/*N*/ // cFlags |= 0x10;
-/*N*/ if( rTbl.IsHeadlineRepeat() )
-/*N*/ cFlags |= 0x20;
-/*N*/ OpenRec( SWG_TABLE );
-/*N*/ *pStrm << (BYTE) cFlags;
-/*N*/ OpenValuePos16( nBoxes );
-/*N*/
-/*N*/ // Im 3.1/4.0-Format stand hier der Index der Section. Bei IDX_NO_VALUE
-/*N*/ // wurde sie beim Laden nicht registriert.
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ *pStrm << (UINT16)IDX_NO_VALUE;
-/*N*/ if( !IsSw31Export() )
-/*N*/ *pStrm << (BYTE)rTbl.GetTblChgMode();
-/*N*/ OutFormat( SWG_FRAMEFMT, *rTbl.GetFrmFmt() );
-/*N*/ // DDE-Tabelle? Dann den DDE-Feldtyp speichern
-/*N*/ if( IS_TYPE(SwDDETable, &rTbl) )
-/*N*/ {
-/*?*/ SwDDETable* pDDE = (SwDDETable*) &rTbl;
-/*?*/ OutFieldType( *pDDE->GetDDEFldType() );
-/*N*/ }
-/*N*/ if( !IsSw31Or40Export() )
-/*N*/ {
-/*N*/ OutNodeRedlines( rNd.GetIndex() );
-/*N*/ OutNodeRedlines( rNd.EndOfSectionIndex() );
-/*N*/ }
-/*N*/
-/*N*/ for( USHORT i = 0; i < nLines && Good(); i++ )
-/*N*/ nBoxes += OutTableLine( *(rLines[ i ]) );
-/*N*/ CloseValuePos16( nBoxes );
-/*N*/ CloseRec( SWG_TABLE );
-/*N*/ pCurTbl = pOldTbl;
-/*N*/ aStat.nTbl++;
-/*N*/
-/*N*/ delete pTblLineBoxFmts;
-/*N*/ pTblLineBoxFmts = pOldTblLineBoxFmts;
-/*N*/ }
-
-/* */
-
-
// Einlesen einer Zeile
// Flag-Byte (0)
// 0x10 - schon immer unbenutzt. Zur Zeit nicht benutzt,
@@ -444,65 +380,6 @@ BOOL lcl_sw3io_CollectLineFmts( const SwTableLine*& rpLine, void* pPara );
/*N*/ return pLast != 0;
/*N*/ }
-// Schreiben einer Tabellenzeile. Red Returnwert ist die Summe
-// aller in der Zeile enthaltenen Zellen.
-
-/*N*/ USHORT Sw3IoImp::OutTableLine( const SwTableLine& rLine )
-/*N*/ {
-/*N*/ USHORT nTotalBoxes = 0;
-/*N*/ const SwTableBoxes& rBoxes = rLine.GetTabBoxes();
-/*N*/ UINT16 nBoxes = rBoxes.Count();
-/*N*/
-/*N*/ // 0x10: Format-Id ist enthalten (nur SW5)
-/*N*/ // 0x20: Format ist geshared (nur SW5)
-/*N*/ BYTE cFlags;
-/*N*/
-/*N*/ SwFrmFmt* pFmt = rLine.GetFrmFmt();
-/*N*/ UINT16 nFmtId(0);
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ {
-/*N*/ cFlags = 0x04; // keine Flags, Fmt-Id, Anzahl Boxen
-/*N*/ nFmtId = GetTblLineBoxFmtStrPoolId40( pFmt );
-/*N*/ }
-/*N*/ else
-/*N*/ {
-/*N*/ cFlags = 0x02; // Anzahl Boxen
-/*N*/ if( lcl_sw3io_IsLineFmtShared( *pFmt, rLine ) )
-/*N*/ {
-/*N*/ cFlags += 0x40; // Shared-Flag
-/*N*/ if( pFmt->IsWritten() )
-/*N*/ {
-/*N*/ cFlags += 0x22; // FmtId-Flag + FmtId
-/*N*/ nFmtId = GetTblLineBoxFmtId( pFmt );
-/*N*/ }
-/*N*/ else
-/*N*/ {
-/*N*/ AddTblLineBoxFmt( pFmt );
-/*N*/ }
-/*N*/ }
-/*N*/ }
-/*N*/
-/*N*/ OpenRec( SWG_TABLELINE );
-/*N*/ *pStrm << (BYTE) cFlags;
-/*N*/ if( IsSw31Or40Export() || (cFlags & 0x20) != 0 )
-/*N*/ *pStrm << nFmtId;
-/*N*/
-/*N*/ *pStrm << nBoxes;
-/*N*/
-/*N*/ // OutFormat schreibt nur noch nicht geschriebene Formate raus,
-/*N*/ // deshalb muss das hier nicht ueberprueft werden.
-/*N*/ OutFormat( SWG_FRAMEFMT, *pFmt );
-/*N*/
-/*N*/ for( USHORT i = 0; i < nBoxes && Good(); i++ )
-/*N*/ nTotalBoxes += OutTableBox( *( rBoxes[ i ]) );
-/*N*/ CloseRec( SWG_TABLELINE );
-/*N*/ return nTotalBoxes;
-/*N*/
-/*N*/ }
-
-/* */
-
-
// Einlesen einer Zelle
// BYTE Flag-Byte
// 0x10 - Zelle enthaelt weitere Zeilen
@@ -617,64 +494,6 @@ BOOL lcl_sw3io_CollectLineFmts( const SwTableLine*& rpLine, void* pPara );
/*N*/
/*N*/ return pLast != 0;
/*N*/ }
-/*N*/
-/*N*/ USHORT Sw3IoImp::OutTableBox( const SwTableBox& rBox )
-/*N*/ {
-/*N*/ const SwTableLines& rLines = rBox.GetTabLines();
-/*N*/ USHORT nLines = rLines.Count();
-/*N*/ USHORT nTotalBoxes = 0;
-/*N*/
-/*N*/ BYTE cFlags;
-/*N*/
-/*N*/ UINT16 nFmtId(0);
-/*N*/ SwFrmFmt* pFmt = rBox.GetFrmFmt();
-/*N*/ if( IsSw31Or40Export() )
-/*N*/ {
-/*N*/ cFlags = 0x02; // keine Flags, FmtId
-/*N*/ nFmtId = GetTblLineBoxFmtStrPoolId40( pFmt );
-/*N*/ }
-/*N*/ else
-/*N*/ {
-/*N*/ cFlags = 0x00; // keine Flags, keine Daten
-/*N*/ if( lcl_sw3io_IsBoxFmtShared( *pFmt, rBox ) )
-/*N*/ {
-/*N*/ cFlags += 0x40; // Format ist geshared
-/*N*/ if( pFmt->IsWritten() )
-/*N*/ {
-/*N*/ cFlags += 0x22; // FmtId-Flag + FmtId
-/*N*/ nFmtId = GetTblLineBoxFmtId( pFmt );
-/*N*/ }
-/*N*/ else
-/*N*/ {
-/*N*/ AddTblLineBoxFmt( pFmt );
-/*N*/ }
-/*N*/ }
-/*N*/ }
-/*N*/
-/*N*/ if( nLines )
-/*N*/ cFlags += 0x12;
-/*N*/ OpenRec( SWG_TABLEBOX );
-/*N*/ *pStrm << (BYTE) cFlags;
-/*N*/ if( IsSw31Or40Export() || (cFlags & 0x20) != 0 )
-/*N*/ *pStrm << (UINT16) nFmtId;
-/*N*/ if( cFlags & 0x10 )
-/*N*/ *pStrm << (UINT16) nLines;
-/*N*/ OutFormat( SWG_FRAMEFMT, *pFmt );
-/*N*/ if( rBox.GetSttNd() )
-/*N*/ // Inhalt ausgeben
-/*N*/ OutContents( SwNodeIndex( *rBox.GetSttNd() ) );
-/*N*/ if( nLines )
-/*N*/ {
-/*N*/ // Falls Zeilen vorhanden, diese ausgeben
-/*N*/ for( USHORT i = 0; i < nLines; i++)
-/*N*/ nTotalBoxes += OutTableLine( *( rLines[ i ]) );
-/*N*/ }
-/*N*/ else
-/*N*/ nTotalBoxes++;
-/*N*/ CloseRec( SWG_TABLEBOX );
-/*N*/ return nTotalBoxes;
-/*N*/ }
-
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
commit f716b5c64c500ac20363fd40e1c1c325b37a5df7
Author: Caolán McNamara <caolanm at redhat.com>
Date: Tue Aug 9 09:08:31 2011 +0100
callcatcher: remove some unused code
diff --git a/binfilter/bf_sw/source/core/graphic/sw_ndgrf.cxx b/binfilter/bf_sw/source/core/graphic/sw_ndgrf.cxx
index 82a39f0..e69c40b 100644
--- a/binfilter/bf_sw/source/core/graphic/sw_ndgrf.cxx
+++ b/binfilter/bf_sw/source/core/graphic/sw_ndgrf.cxx
@@ -445,22 +445,6 @@ short SwGrfNode::SwapIn( BOOL bWaitForData )
return nRet;
}
-
-
-// Wird nach einem SaveAs aufgerufen und setzt die StreamNamen um
-
-
-/*N*/ void SwGrfNode::SaveCompleted( BOOL bClear )
-/*N*/ {
-/*N*/ if( aNewStrmName.Len() )
-/*N*/ {
-/*N*/ if( !bClear ) // der Name wird zum aktuellen
-/*N*/ SetStreamName( aNewStrmName );
-/*N*/ aNewStrmName.Erase();
-/*N*/ }
-/*N*/ }
-
-
// Falls die Grafik noch nicht im Doc-Storage existiert,
// wird sie neu geschrieben; falls sie bereits drin ist,
// wird nicht geschrieben. Wenn der Storage nicht dem
diff --git a/binfilter/bf_sw/source/core/sw3io/sw3imp.hxx b/binfilter/bf_sw/source/core/sw3io/sw3imp.hxx
index a01df4a..4d41fd0 100644
--- a/binfilter/bf_sw/source/core/sw3io/sw3imp.hxx
+++ b/binfilter/bf_sw/source/core/sw3io/sw3imp.hxx
@@ -715,7 +715,6 @@ public:
// SW3REDLIN.CXX
/*N*/ void InRedline(); //SW50.SDW // I: Redline
- void OutRedline( const SwRedline& rRedline );
/*N*/ void InRedlines(); //SW50.SDW
/*N*/ void InNodeRedline( const SwNodeIndex& rNodeIdx, INT32& nOffset, BYTE=0 ); //SW50.SDW
void OutNodeRedlines( ULONG );
diff --git a/binfilter/bf_sw/source/core/sw3io/sw_sw3redln.cxx b/binfilter/bf_sw/source/core/sw3io/sw_sw3redln.cxx
index fbb4807..01ab601 100644
--- a/binfilter/bf_sw/source/core/sw3io/sw_sw3redln.cxx
+++ b/binfilter/bf_sw/source/core/sw3io/sw_sw3redln.cxx
@@ -128,54 +128,6 @@ namespace binfilter {
/*N*/ CloseRec( SWG_REDLINE_LCL );
/*N*/ }
-
-void Sw3IoImp::OutRedline( const SwRedline& rRedline )
-{
- OSL_ENSURE( !IsSw31Or40Export(), "Redlines werden nicht exportiert!" );
-
- OpenRec( SWG_REDLINE_LCL );
-
- BYTE cFlags = 0x02; // Count
-
- if( rRedline.IsVisible() )
- cFlags += 0x10;
- if( rRedline.IsDelLastPara() )
- cFlags += 0x20;
- if( rRedline.IsLastParaDelete() )
- cFlags += 0x40;
-
- USHORT i = rRedline.GetStackCount();
-
- *pStrm << (BYTE) cFlags
- << (UINT16)i;
-
- // Die Redline-Data-Objekte werden von hinten nach vorne geschrieben,
- // das macht das Verketten beim Einlesen leichter.
- while( i )
- {
- i--;
-
- OpenRec( SWG_REDLINEDATA_LCL );
-
- cFlags = 0x03; // Type + StrPool-Index des Autors
- UINT16 nStrIdx = aStringPool.Find( rRedline.GetAuthorString(i),
- USHRT_MAX );
- *pStrm << (BYTE) cFlags
- << (BYTE) rRedline.GetType( i )
- << (UINT16)nStrIdx;
-
- const DateTime& rDateTime = rRedline.GetTimeStamp( i );
- *pStrm << (UINT32)rDateTime.GetDate()
- << (UINT32)rDateTime.GetTime();
- OutString( *pStrm, rRedline.GetComment( i ) );
-
- CloseRec( SWG_REDLINEDATA_LCL );
- }
-
- CloseRec( SWG_REDLINE_LCL );
-}
-
-
// REDLINES:
// REDLINE*
diff --git a/binfilter/inc/bf_sw/ndgrf.hxx b/binfilter/inc/bf_sw/ndgrf.hxx
index ef64b9c..e9a1161 100644
--- a/binfilter/inc/bf_sw/ndgrf.hxx
+++ b/binfilter/inc/bf_sw/ndgrf.hxx
@@ -142,7 +142,6 @@ public:
String GetStreamName() const;
void SetStreamName( const String& r ) { aGrfObj.SetUserData( r ); }
void SetNewStreamName( const String& r ) { aNewStrmName = r; }
- void SaveCompleted( BOOL bClear );
// is this node selected by any shell?
BOOL IsSelected() const{DBG_BF_ASSERT(0, "STRIP");return FALSE;} ;
#endif
commit 64074d26722d28b722db17ee61b7b41ff65afe6a
Author: Caolán McNamara <caolanm at redhat.com>
Date: Tue Aug 9 00:10:28 2011 +0100
drop ByteString::Convert
diff --git a/binfilter/bf_svtools/source/filter.vcl/filter/svt_sgvtext.cxx b/binfilter/bf_svtools/source/filter.vcl/filter/svt_sgvtext.cxx
index 5272fb1..ab90ca7 100644
--- a/binfilter/bf_svtools/source/filter.vcl/filter/svt_sgvtext.cxx
+++ b/binfilter/bf_svtools/source/filter.vcl/filter/svt_sgvtext.cxx
@@ -693,10 +693,8 @@ UCHAR Upcase(UCHAR c)
USHORT GetCharWidth(OutputDevice& rOut, UCHAR c)
{
- UCHAR c1;
USHORT ChrWidth;
- c1 = ByteString::Convert((char)c,RTL_TEXTENCODING_IBM_437, gsl_getSystemTextEncoding() );
if (c==' ')
{
ChrWidth=(USHORT)rOut.GetTextWidth( String('A') );
@@ -709,11 +707,11 @@ USHORT GetCharWidth(OutputDevice& rOut, UCHAR c)
OSL_ENSURE( MaxChar == 255, "MaxChar not 255" );
if (c>=MinChar /*&& c<=MaxChar*/)
{
- ChrWidth=(USHORT)rOut.GetTextWidth(String((char)c1));
+ ChrWidth=(USHORT)rOut.GetTextWidth(rtl::OUString(reinterpret_cast<sal_Char*>(&c), 1, RTL_TEXTENCODING_IBM_437));
}
else
{
- ChrWidth=(USHORT)rOut.GetTextWidth(String('A'));
+ ChrWidth=(USHORT)rOut.GetTextWidth(rtl::OUString(static_cast<sal_Unicode>('A')));
}
}
return ChrWidth;
More information about the Libreoffice-commits
mailing list