| /************************************************************** |
| * |
| * 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.hpp> |
| #include <vcl/svapp.hxx> |
| #include <vcl/wrkwin.hxx> |
| #include <tools/urlobj.hxx> |
| #include <sfx2/sfx.hrc> |
| #if !defined _SVSTDARR_XUB_STRLEN_DECL || !defined _SVSTDARR_USHORTS_DECL |
| #define _SVSTDARR_XUB_STRLEN |
| #define _SVSTDARR_USHORTS |
| #include <svl/svstdarr.hxx> |
| #endif |
| #include <svtools/htmlout.hxx> |
| #include <svtools/htmlkywd.hxx> |
| #include <svtools/htmltokn.h> |
| #include <svl/whiter.hxx> |
| #include <svx/htmlmode.hxx> |
| #include <editeng/escpitem.hxx> |
| #include <editeng/brkitem.hxx> |
| #include <editeng/boxitem.hxx> |
| #include <editeng/ulspitem.hxx> |
| #include <editeng/udlnitem.hxx> |
| #include <editeng/crsditem.hxx> |
| #include <editeng/blnkitem.hxx> |
| #include <editeng/cmapitem.hxx> |
| #include <editeng/colritem.hxx> |
| #include <editeng/fontitem.hxx> |
| #include <editeng/fhgtitem.hxx> |
| #include <editeng/postitem.hxx> |
| #include <editeng/kernitem.hxx> |
| #include <editeng/wghtitem.hxx> |
| #include <editeng/lspcitem.hxx> |
| #include <editeng/adjitem.hxx> |
| #include <editeng/lrspitem.hxx> |
| #include <editeng/brshitem.hxx> |
| #include <editeng/langitem.hxx> |
| #include <editeng/frmdiritem.hxx> |
| #include <fchrfmt.hxx> |
| #include <fmtautofmt.hxx> |
| #include <fmtfsize.hxx> |
| #include <fmtclds.hxx> |
| #include <fmtpdsc.hxx> |
| #include <fmtflcnt.hxx> |
| #include <fmtinfmt.hxx> |
| #include <fmtftn.hxx> |
| #include <txatbase.hxx> |
| #include <frmatr.hxx> |
| #include <charfmt.hxx> |
| #include <fmtfld.hxx> |
| #include <doc.hxx> |
| #include <pam.hxx> |
| #include <ndtxt.hxx> |
| #include <paratr.hxx> |
| #include <poolfmt.hxx> |
| #include <pagedesc.hxx> |
| #include <swtable.hxx> |
| #include "fldbas.hxx" |
| #include <breakit.hxx> |
| #include <htmlnum.hxx> |
| #include <wrthtml.hxx> |
| #include <htmlfly.hxx> |
| #include <numrule.hxx> |
| |
| using namespace ::com::sun::star; |
| |
| /* |
| * um nicht immer wieder nach einem Update festzustellen, das irgendwelche |
| * Hint-Ids dazugekommen sind, wird hier definiert, die Groesse der Tabelle |
| * definiert und mit der akt. verglichen. Bei unterschieden wird der |
| * Compiler schon meckern. |
| * |
| * diese Section und die dazugeherigen Tabellen muessen in folgenden Files |
| * gepflegt werden: rtf\rtfatr.cxx, sw6\sw6atr.cxx, w4w\w4watr.cxx |
| */ |
| #if !defined(UNX) && !defined(MSC) && !defined(PPC) && !defined(CSET) && !defined(__MWERKS__) && !defined(WTC) && !defined(__MINGW32__) && !defined(OS2) |
| |
| #define ATTRFNTAB_SIZE 130 |
| #if ATTRFNTAB_SIZE != POOLATTR_END - POOLATTR_BEGIN |
| #error Attribut-Tabelle ist ungueltigt. Wurden neue Hint-IDs zugefuegt ?? |
| #endif |
| |
| #ifdef FORMAT_TABELLE |
| // da sie nicht benutzt wird! |
| #define FORMATTAB_SIZE 7 |
| #if FORMATTAB_SIZE != RES_FMT_END - RES_FMT_BEGIN |
| #error Format-Tabelle ist ungueltigt. Wurden neue Hint-IDs zugefuegt ?? |
| #endif |
| #endif |
| |
| #define NODETAB_SIZE 3 |
| #if NODETAB_SIZE != RES_NODE_END - RES_NODE_BEGIN |
| #error Node-Tabelle ist ungueltigt. Wurden neue Hint-IDs zugefuegt ?? |
| #endif |
| |
| #endif |
| |
| #define HTML_BULLETCHAR_DISC 34 |
| #define HTML_BULLETCHAR_CIRCLE 38 |
| #define HTML_BULLETCHAR_SQUARE 36 |
| |
| #define COLFUZZY 20 |
| |
| //----------------------------------------------------------------------- |
| |
| HTMLOutEvent __FAR_DATA aAnchorEventTable[] = |
| { |
| { OOO_STRING_SVTOOLS_HTML_O_SDonclick, OOO_STRING_SVTOOLS_HTML_O_onclick, SFX_EVENT_MOUSECLICK_OBJECT }, |
| { OOO_STRING_SVTOOLS_HTML_O_SDonmouseover, OOO_STRING_SVTOOLS_HTML_O_onmouseover, SFX_EVENT_MOUSEOVER_OBJECT }, |
| { OOO_STRING_SVTOOLS_HTML_O_SDonmouseout, OOO_STRING_SVTOOLS_HTML_O_onmouseout, SFX_EVENT_MOUSEOUT_OBJECT }, |
| { 0, 0, 0 } |
| }; |
| |
| static Writer& OutHTML_SvxAdjust( Writer& rWrt, const SfxPoolItem& rHt ); |
| |
| static Writer& OutHTML_HoriSpacer( Writer& rWrt, sal_Int16 nSize ) |
| { |
| ASSERT( nSize>0, "horizontaler SPACER mit negativem Wert?" ) |
| if( nSize <= 0 ) |
| return rWrt; |
| |
| if( Application::GetDefaultDevice() ) |
| { |
| nSize = (sal_Int16)Application::GetDefaultDevice() |
| ->LogicToPixel( Size(nSize,0), MapMode(MAP_TWIP) ).Width(); |
| } |
| |
| ByteString sOut( '<' ); |
| (((((((((sOut += OOO_STRING_SVTOOLS_HTML_spacer) |
| += ' ') += OOO_STRING_SVTOOLS_HTML_O_type) += '=') += OOO_STRING_SVTOOLS_HTML_SPTYPE_horizontal) |
| += ' ') += OOO_STRING_SVTOOLS_HTML_O_size) += '=') |
| +=ByteString::CreateFromInt32(nSize)) += '>'; |
| |
| rWrt.Strm() << sOut.GetBuffer(); |
| |
| return rWrt; |
| } |
| |
| sal_uInt16 SwHTMLWriter::GetDefListLvl( const String& rNm, sal_uInt16 nPoolId ) |
| { |
| if( nPoolId == RES_POOLCOLL_HTML_DD ) |
| { |
| return 1 | HTML_DLCOLL_DD; |
| } |
| else if( nPoolId == RES_POOLCOLL_HTML_DT ) |
| { |
| return 1 | HTML_DLCOLL_DT; |
| } |
| |
| String sDTDD( String::CreateFromAscii(OOO_STRING_SVTOOLS_HTML_dt) ); |
| sDTDD += ' '; |
| if( COMPARE_EQUAL == sDTDD.CompareTo( rNm, sDTDD.Len() ) ) |
| // DefinitionList - term |
| return (sal_uInt16)rNm.Copy( sDTDD.Len() ).ToInt32() | HTML_DLCOLL_DT; |
| |
| sDTDD.AssignAscii( OOO_STRING_SVTOOLS_HTML_dd ); |
| sDTDD += ' '; |
| if( COMPARE_EQUAL == sDTDD.CompareTo( rNm, sDTDD.Len() ) ) |
| // DefinitionList - definition |
| return (sal_uInt16)rNm.Copy( sDTDD.Len() ).ToInt32() | HTML_DLCOLL_DD; |
| |
| return 0; |
| } |
| |
| void SwHTMLWriter::OutAndSetDefList( sal_uInt16 nNewLvl ) |
| { |
| // eventuell muss erst mal eine Liste aufgemacht werden |
| if( nDefListLvl < nNewLvl ) |
| { |
| // output </pre> for the previous(!) pararagraph, if required. |
| // Preferable, the <pre> is exported by OutHTML_SwFmtOff for the |
| // previous paragraph already, but that's not possible, because a very |
| // deep look at the next paragraph (this one) is required to figure |
| // out that a def list starts here. |
| |
| ChangeParaToken( 0 ); |
| |
| // entsprechend dem Level-Unterschied schreiben! |
| for( sal_uInt16 i=nDefListLvl; i<nNewLvl; i++ ) |
| { |
| if( bLFPossible ) |
| OutNewLine(); |
| HTMLOutFuncs::Out_AsciiTag( Strm(), OOO_STRING_SVTOOLS_HTML_deflist, sal_True ); |
| IncIndentLevel(); |
| bLFPossible = sal_True; |
| } |
| } |
| else if( nDefListLvl > nNewLvl ) |
| { |
| for( sal_uInt16 i=nNewLvl ; i < nDefListLvl; i++ ) |
| { |
| DecIndentLevel(); |
| if( bLFPossible ) |
| OutNewLine(); |
| HTMLOutFuncs::Out_AsciiTag( Strm(), OOO_STRING_SVTOOLS_HTML_deflist, sal_False ); |
| bLFPossible = sal_True; |
| } |
| } |
| |
| nDefListLvl = nNewLvl; |
| } |
| |
| |
| void SwHTMLWriter::ChangeParaToken( sal_uInt16 nNew ) |
| { |
| if( nNew != nLastParaToken && HTML_PREFORMTXT_ON == nLastParaToken ) |
| { |
| HTMLOutFuncs::Out_AsciiTag( Strm(), OOO_STRING_SVTOOLS_HTML_preformtxt, sal_False ); |
| bLFPossible = sal_True; |
| } |
| nLastParaToken = nNew; |
| } |
| |
| sal_uInt16 SwHTMLWriter::GetCSS1ScriptForScriptType( sal_uInt16 nScriptType ) |
| { |
| sal_uInt16 nRet = CSS1_OUTMODE_ANY_SCRIPT; |
| |
| switch( nScriptType ) |
| { |
| case i18n::ScriptType::LATIN: |
| nRet = CSS1_OUTMODE_WESTERN; |
| break; |
| case i18n::ScriptType::ASIAN: |
| nRet = CSS1_OUTMODE_CJK; |
| break; |
| case i18n::ScriptType::COMPLEX: |
| nRet = CSS1_OUTMODE_CTL; |
| break; |
| } |
| |
| return nRet; |
| } |
| |
| // fuer die Formate muesste eine einzige Ausgabe-Funktion genuegen ! |
| /* |
| * Formate wie folgt ausgeben: |
| * - fuer Formate, fuer die es entsprechende HTML-Tags gibt wird das |
| * Tag ausgegeben |
| * - fuer alle anderen wird ein Absatz-Tag <P> ausgegeben und bUserFmt |
| * gesetzt |
| * - Wenn eine Absatz-Ausrichtung am uebergebenen Item-Set des Nodes |
| * oder im Item-Set des Format gesetzt ist, wird ein ALIGN=xxx ausgegeben, |
| * sofern HTML es zulaesst |
| * - in jedem Fall wird harte Attributierung als STYLE-Option geschrieben. |
| * Wenn bUserFmt nicht gesetzt ist, wird nur der uebergebene Item-Set |
| * betrachtet. Sonst werden auch Attribute des Formats ausgegeben. |
| */ |
| |
| struct SwHTMLTxtCollOutputInfo |
| { |
| ByteString aToken; // auszugendens End-Token |
| SfxItemSet *pItemSet; // harte Attributierung |
| |
| sal_Bool bInNumBulList; // in einer Aufzaehlungs-Liste; |
| sal_Bool bParaPossible; // ein </P> darf zusaetzlich ausgegeben werden |
| sal_Bool bOutPara; // ein </P> soll ausgegeben werden |
| sal_Bool bOutDiv; // write a </DIV> |
| |
| SwHTMLTxtCollOutputInfo() : |
| pItemSet( 0 ), |
| bInNumBulList( sal_False ), |
| bParaPossible( sal_False ), |
| bOutPara( sal_False ), |
| bOutDiv( sal_False ) |
| {} |
| |
| ~SwHTMLTxtCollOutputInfo(); |
| |
| sal_Bool HasParaToken() const { return aToken.Len()==1 && aToken.GetChar(0)=='P'; } |
| sal_Bool ShouldOutputToken() const { return bOutPara || !HasParaToken(); } |
| }; |
| |
| SwHTMLTxtCollOutputInfo::~SwHTMLTxtCollOutputInfo() |
| { |
| delete pItemSet; |
| } |
| |
| struct SwHTMLFmtInfo |
| { |
| const SwFmt *pFmt; // das Format selbst |
| const SwFmt *pRefFmt; // das Vergleichs-Format |
| |
| ByteString aToken; // das auszugebende Token |
| String aClass; // die auszugebende Klasse |
| |
| SfxItemSet *pItemSet; // der auszugebende Attribut-Set |
| |
| sal_Int32 nLeftMargin; // ein par default-Werte fuer |
| sal_Int32 nRightMargin; // Absatz-Vorlagen |
| short nFirstLineIndent; |
| |
| sal_uInt16 nTopMargin; |
| sal_uInt16 nBottomMargin; |
| |
| sal_Bool bScriptDependent; |
| |
| // Konstruktor fuer einen Dummy zum Suchen |
| SwHTMLFmtInfo( const SwFmt *pF ) : |
| pFmt( pF ), pItemSet( 0 ) |
| {} |
| |
| |
| // Konstruktor zum Erstellen der Format-Info |
| SwHTMLFmtInfo( const SwFmt *pFmt, SwDoc *pDoc, SwDoc *pTemlate, |
| sal_Bool bOutStyles, LanguageType eDfltLang=LANGUAGE_DONTKNOW, |
| sal_uInt16 nScript=CSS1_OUTMODE_ANY_SCRIPT, |
| sal_Bool bHardDrop=sal_False ); |
| ~SwHTMLFmtInfo(); |
| |
| friend sal_Bool operator==( const SwHTMLFmtInfo& rInfo1, |
| const SwHTMLFmtInfo& rInfo2 ) |
| { |
| return (long)rInfo1.pFmt == (long)rInfo2.pFmt; |
| } |
| |
| friend sal_Bool operator<( const SwHTMLFmtInfo& rInfo1, |
| const SwHTMLFmtInfo& rInfo2 ) |
| { |
| return (long)rInfo1.pFmt < (long)rInfo2.pFmt; |
| } |
| |
| }; |
| |
| SV_IMPL_OP_PTRARR_SORT( SwHTMLFmtInfos, SwHTMLFmtInfo* ) |
| |
| SwHTMLFmtInfo::SwHTMLFmtInfo( const SwFmt *pF, SwDoc *pDoc, SwDoc *pTemplate, |
| sal_Bool bOutStyles, |
| LanguageType eDfltLang, |
| sal_uInt16 nCSS1Script, sal_Bool bHardDrop ) : |
| pFmt( pF ), pItemSet( 0 ), bScriptDependent( sal_False ) |
| { |
| sal_uInt16 nRefPoolId = 0; |
| // Den Selektor des Formats holen |
| sal_uInt16 nDeep = SwHTMLWriter::GetCSS1Selector( pFmt, aToken, aClass, |
| nRefPoolId ); |
| ASSERT( nDeep ? aToken.Len()>0 : aToken.Len()==0, |
| "Hier stimmt doch was mit dem Token nicht!" ); |
| ASSERT( nDeep ? nRefPoolId : !nRefPoolId, |
| "Hier stimmt doch was mit der Vergleichs-Vorlage nicht!" ); |
| |
| sal_Bool bTxtColl = pFmt->Which() == RES_TXTFMTCOLL || |
| pFmt->Which() == RES_CONDTXTFMTCOLL; |
| |
| const SwFmt *pReferenceFmt = 0; // Vergleichs-Format |
| sal_Bool bSetDefaults = sal_True, bClearSame = sal_True; |
| if( nDeep != 0 ) |
| { |
| // Es ist eine HTML-Tag-Vorlage oder die Vorlage ist von einer |
| // solchen abgeleitet |
| if( !bOutStyles ) |
| { |
| // wenn keine Styles exportiert werden, muss evtl. zusaetlich |
| // harte Attributierung geschrieben werden |
| switch( nDeep ) |
| { |
| case CSS1_FMT_ISTAG: |
| case CSS1_FMT_CMPREF: |
| // fuer HTML-Tag-Vorlagen die Unterscheide zum Original |
| // (sofern verfuegbar) |
| pReferenceFmt = SwHTMLWriter::GetTemplateFmt( nRefPoolId, |
| pTemplate ); |
| break; |
| |
| default: |
| // sonst die zur HTML-Tag-Vorlage des Originals oder des |
| // aktuellen Doks, wenn die nicht verfuegbar ist |
| if( pTemplate ) |
| pReferenceFmt = SwHTMLWriter::GetTemplateFmt( nRefPoolId, |
| pTemplate ); |
| else |
| pReferenceFmt = SwHTMLWriter::GetParentFmt( *pFmt, nDeep ); |
| break; |
| } |
| } |
| } |
| else if( bTxtColl ) |
| { |
| // Nicht von einer HTML-Tag-Vorlage abgeleitete Absatz-Vorlagen |
| // muessen als harte Attributierung relativ zur Textkoerper-Volage |
| // exportiert werden. Fuer Nicht-Styles-Export sollte die der |
| // HTML-Vorlage als Referenz dienen |
| if( !bOutStyles && pTemplate ) |
| pReferenceFmt = pTemplate->GetTxtCollFromPool( RES_POOLCOLL_TEXT, false ); |
| else |
| pReferenceFmt = pDoc->GetTxtCollFromPool( RES_POOLCOLL_TEXT, false ); |
| } |
| |
| if( pReferenceFmt || nDeep==0 ) |
| { |
| pItemSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(), |
| pFmt->GetAttrSet().GetRanges() ); |
| // wenn Unterschiede zu einer anderen Vorlage geschrieben werden |
| // sollen ist harte Attributierung noetig. Fuer Vorlagen, die |
| // nicht von HTML-Tag-Vorlagen abgeleitet sind, gilt das immer |
| |
| pItemSet->Set( pFmt->GetAttrSet(), sal_True ); |
| |
| if( pReferenceFmt ) |
| SwHTMLWriter::SubtractItemSet( *pItemSet, pReferenceFmt->GetAttrSet(), |
| bSetDefaults, bClearSame ); |
| |
| // einen leeren Item-Set gleich loeschen, das spart speater |
| // Arbeit |
| if( !pItemSet->Count() ) |
| { |
| delete pItemSet; |
| pItemSet = 0; |
| } |
| } |
| |
| if( bTxtColl ) |
| { |
| if( bOutStyles ) |
| { |
| // We have to add hard attributes for any script dependent |
| // item that is not accessed by the style |
| static sal_uInt16 aWhichIds[3][4] = |
| { |
| { RES_CHRATR_FONT, RES_CHRATR_FONTSIZE, |
| RES_CHRATR_POSTURE, RES_CHRATR_WEIGHT }, |
| { RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_FONTSIZE, |
| RES_CHRATR_CJK_POSTURE, RES_CHRATR_CJK_WEIGHT }, |
| { RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_FONTSIZE, |
| RES_CHRATR_CTL_POSTURE, RES_CHRATR_CTL_WEIGHT } |
| }; |
| |
| sal_uInt16 nRef = 0; |
| sal_uInt16 aSets[2] = {0,0}; |
| switch( nCSS1Script ) |
| { |
| case CSS1_OUTMODE_WESTERN: |
| nRef = 0; |
| aSets[0] = 1; |
| aSets[1] = 2; |
| break; |
| case CSS1_OUTMODE_CJK: |
| nRef = 1; |
| aSets[0] = 0; |
| aSets[1] = 2; |
| break; |
| case CSS1_OUTMODE_CTL: |
| nRef = 2; |
| aSets[0] = 0; |
| aSets[1] = 1; |
| break; |
| } |
| for( sal_uInt16 i=0; i<4; i++ ) |
| { |
| const SfxPoolItem& rRef = pFmt->GetFmtAttr( aWhichIds[nRef][i] ); |
| for( sal_uInt16 j=0; j<2; j++ ) |
| { |
| const SfxPoolItem& rSet = pFmt->GetFmtAttr( aWhichIds[aSets[j]][i] ); |
| if( rSet != rRef ) |
| { |
| if( !pItemSet ) |
| pItemSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(), |
| pFmt->GetAttrSet().GetRanges() ); |
| pItemSet->Put( rSet ); |
| } |
| } |
| } |
| } |
| |
| // Ggf. noch ein DropCap-Attribut uebernehmen |
| if( bOutStyles && bHardDrop && nDeep != 0 ) |
| { |
| const SfxPoolItem *pItem; |
| if( SFX_ITEM_SET==pFmt->GetAttrSet().GetItemState( |
| RES_PARATR_DROP, sal_True, &pItem ) ) |
| { |
| sal_Bool bPut = sal_True; |
| if( pTemplate ) |
| { |
| pReferenceFmt = SwHTMLWriter::GetTemplateFmt( nRefPoolId, pTemplate ); |
| const SfxPoolItem *pRefItem; |
| sal_Bool bRefItemSet = |
| SFX_ITEM_SET==pReferenceFmt->GetAttrSet().GetItemState( |
| RES_PARATR_DROP, sal_True, &pRefItem ); |
| bPut = !bRefItemSet || *pItem!=*pRefItem; |
| } |
| if( bPut ) |
| { |
| if( !pItemSet ) |
| pItemSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(), |
| pFmt->GetAttrSet().GetRanges() ); |
| pItemSet->Put( *pItem ); |
| } |
| } |
| } |
| |
| |
| // Die diversen default-Abstaende aus der Vorlage oder der |
| // Vergleischs-Vorlage merken |
| const SvxLRSpaceItem &rLRSpace = |
| (pReferenceFmt ? pReferenceFmt : pFmt)->GetLRSpace(); |
| nLeftMargin = rLRSpace.GetTxtLeft(); |
| nRightMargin = rLRSpace.GetRight(); |
| nFirstLineIndent = rLRSpace.GetTxtFirstLineOfst(); |
| |
| const SvxULSpaceItem &rULSpace = |
| (pReferenceFmt ? pReferenceFmt : pFmt)->GetULSpace(); |
| nTopMargin = rULSpace.GetUpper(); |
| nBottomMargin = rULSpace.GetLower(); |
| |
| // export language if it differs from the default language |
| sal_uInt16 nWhichId = |
| SwHTMLWriter::GetLangWhichIdFromScript( nCSS1Script ); |
| const SvxLanguageItem& rLang = |
| (const SvxLanguageItem&)pFmt->GetFmtAttr( nWhichId ); |
| LanguageType eLang = rLang.GetLanguage(); |
| if( eLang != eDfltLang ) |
| { |
| if( !pItemSet ) |
| pItemSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(), |
| pFmt->GetAttrSet().GetRanges() ); |
| pItemSet->Put( rLang ); |
| } |
| |
| static sal_uInt16 aWhichIds[3] = |
| { RES_CHRATR_LANGUAGE, RES_CHRATR_CJK_LANGUAGE, |
| RES_CHRATR_CTL_LANGUAGE }; |
| for( sal_uInt16 i=0; i<3; i++ ) |
| { |
| if( aWhichIds[i] != nWhichId ) |
| { |
| const SvxLanguageItem& rTmpLang = |
| (const SvxLanguageItem&)pFmt->GetFmtAttr(aWhichIds[i]); |
| if( rTmpLang.GetLanguage() != eLang ) |
| { |
| if( !pItemSet ) |
| pItemSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(), |
| pFmt->GetAttrSet().GetRanges() ); |
| pItemSet->Put( rTmpLang ); |
| } |
| } |
| } |
| } |
| } |
| |
| SwHTMLFmtInfo::~SwHTMLFmtInfo() |
| { |
| delete pItemSet; |
| } |
| |
| void OutHTML_SwFmt( Writer& rWrt, const SwFmt& rFmt, |
| const SfxItemSet *pNodeItemSet, |
| SwHTMLTxtCollOutputInfo& rInfo ) |
| { |
| ASSERT( RES_CONDTXTFMTCOLL==rFmt.Which() || RES_TXTFMTCOLL==rFmt.Which(), |
| "keine Absatz-Vorlage" ); |
| |
| SwHTMLWriter & rHWrt = (SwHTMLWriter&)rWrt; |
| |
| // Erstmal ein par Flags ... |
| sal_uInt16 nNewDefListLvl = 0; |
| sal_uInt16 nNumStart = USHRT_MAX; |
| sal_Bool bForceDL = sal_False; |
| sal_Bool bDT = sal_False; |
| rInfo.bInNumBulList = sal_False; // Wir sind in einer Liste? |
| sal_Bool bNumbered = sal_False; // Der aktuelle Absatz ist numeriert |
| sal_Bool bPara = sal_False; // das aktuelle Token ist <P> |
| rInfo.bParaPossible = sal_False; // ein <P> darf zusaetzlich ausgegeben werden |
| sal_Bool bNoEndTag = sal_False; // kein End-Tag ausgeben |
| |
| rHWrt.bNoAlign = sal_False; // kein ALIGN=... moeglich |
| sal_Bool bNoStyle = sal_False; // kein STYLE=... moeglich |
| sal_uInt8 nBulletGrfLvl = 255; // Die auszugebende Bullet-Grafik |
| |
| // Sind wir in einer Aufzaehlungs- oder Numerierungliste? |
| const SwTxtNode* pTxtNd = rWrt.pCurPam->GetNode()->GetTxtNode(); |
| |
| SwHTMLNumRuleInfo aNumInfo; |
| if( rHWrt.GetNextNumInfo() ) |
| { |
| aNumInfo = *rHWrt.GetNextNumInfo(); |
| rHWrt.ClearNextNumInfo(); |
| } |
| else |
| { |
| aNumInfo.Set( *pTxtNd ); |
| } |
| |
| if( aNumInfo.GetNumRule() ) |
| { |
| rInfo.bInNumBulList = sal_True; |
| nNewDefListLvl = 0; |
| |
| // ist der aktuelle Absatz numeriert? |
| bNumbered = aNumInfo.IsNumbered(); |
| sal_uInt8 nLvl = aNumInfo.GetLevel(); |
| |
| ASSERT( pTxtNd->GetActualListLevel() == nLvl, |
| "Gemerkter Num-Level ist falsch" ); |
| ASSERT( bNumbered == static_cast< sal_Bool >(pTxtNd->IsCountedInList()), |
| "Gemerkter Numerierungs-Zustand ist falsch" ); |
| |
| if( bNumbered ) |
| { |
| nBulletGrfLvl = nLvl; // nur veruebergehend!!! |
| // --> OD 2005-11-15 #i57919# |
| // correction of re-factoring done by cws swnumtree: |
| // - <nNumStart> has to contain the restart value, if the |
| // numbering is restarted at this text node. Value <USHRT_MAX> |
| // indicates, that no additional restart value has to be written. |
| if ( pTxtNd->IsListRestart() ) |
| { |
| nNumStart = static_cast< sal_uInt16 >(pTxtNd->GetActualListStartValue()); |
| } |
| // <-- |
| DBG_ASSERT( rHWrt.nLastParaToken == 0, |
| "<PRE> wurde nicht vor <LI> beendet." ); |
| } |
| } |
| |
| // Jetzt holen wir das Token und ggf. die Klasse |
| SwHTMLFmtInfo aFmtInfo( &rFmt ); |
| sal_uInt16 nArrayPos; |
| const SwHTMLFmtInfo *pFmtInfo; |
| if( rHWrt.aTxtCollInfos.Seek_Entry( &aFmtInfo, &nArrayPos ) ) |
| { |
| pFmtInfo = rHWrt.aTxtCollInfos[nArrayPos]; |
| } |
| else |
| { |
| pFmtInfo = new SwHTMLFmtInfo( &rFmt, rWrt.pDoc, rHWrt.pTemplate, |
| rHWrt.bCfgOutStyles, rHWrt.eLang, |
| rHWrt.nCSS1Script, |
| !rHWrt.IsHTMLMode(HTMLMODE_DROPCAPS) ); |
| rHWrt.aTxtCollInfos.C40_PTR_INSERT( SwHTMLFmtInfo, pFmtInfo ); |
| String aName( rFmt.GetName() ); |
| if( rHWrt.aScriptParaStyles.Seek_Entry( &aName ) ) |
| ((SwHTMLFmtInfo *)pFmtInfo)->bScriptDependent = sal_True; |
| } |
| |
| // Jetzt wird festgelegt, was aufgrund des Tokens so moeglich ist |
| sal_uInt16 nToken = 0; // Token fuer Tag-Wechsel |
| sal_Bool bOutNewLine = sal_False; // nur ein LF ausgeben? |
| if( pFmtInfo->aToken.Len() ) |
| { |
| // Es ist eine HTML-Tag-Vorlage oder die Vorlage ist von einer |
| // solchen abgeleitet |
| rInfo.aToken = pFmtInfo->aToken; |
| |
| // der erste Buchstabe reicht meistens |
| switch( rInfo.aToken.GetChar( 0 ) ) |
| { |
| case 'A': ASSERT( rInfo.aToken.Equals(OOO_STRING_SVTOOLS_HTML_address), |
| "Doch kein ADDRESS?" ); |
| rInfo.bParaPossible = sal_True; |
| rHWrt.bNoAlign = sal_True; |
| break; |
| |
| case 'B': ASSERT( rInfo.aToken.Equals(OOO_STRING_SVTOOLS_HTML_blockquote), |
| "Doch kein BLOCKQUOTE?" ); |
| rInfo.bParaPossible = sal_True; |
| rHWrt.bNoAlign = sal_True; |
| break; |
| |
| case 'P': if( rInfo.aToken.Len() == 1 ) |
| { |
| bPara = sal_True; |
| } |
| else |
| { |
| ASSERT( rInfo.aToken.Equals(OOO_STRING_SVTOOLS_HTML_preformtxt), |
| "Doch kein PRE?" ); |
| if( HTML_PREFORMTXT_ON == rHWrt.nLastParaToken ) |
| { |
| bOutNewLine = sal_True; |
| } |
| else |
| { |
| nToken = HTML_PREFORMTXT_ON; |
| rHWrt.bNoAlign = sal_True; |
| bNoEndTag = sal_True; |
| } |
| } |
| break; |
| |
| case 'D': ASSERT( rInfo.aToken.Equals(OOO_STRING_SVTOOLS_HTML_dt) || |
| rInfo.aToken.Equals(OOO_STRING_SVTOOLS_HTML_dd), |
| "Doch kein DD/DT?" ); |
| bDT = rInfo.aToken.Equals(OOO_STRING_SVTOOLS_HTML_dt); |
| rInfo.bParaPossible = !bDT; |
| rHWrt.bNoAlign = sal_True; |
| bForceDL = sal_True; |
| break; |
| } |
| } |
| else |
| { |
| // alle Vorlagen, die nicht einem HTML-Tag entsprechen oder von |
| // diesem abgeleitet sind, werden als <P> exportiert |
| |
| rInfo.aToken = OOO_STRING_SVTOOLS_HTML_parabreak; |
| bPara = sal_True; |
| } |
| |
| // Falls noetig, die harte Attributierung der Vorlage uebernehmen |
| if( pFmtInfo->pItemSet ) |
| { |
| ASSERT( !rInfo.pItemSet, "Wo kommt der Item-Set her?" ); |
| rInfo.pItemSet = new SfxItemSet( *pFmtInfo->pItemSet ); |
| } |
| |
| // und noch die harte Attributierung des Absatzes dazunehmen |
| if( pNodeItemSet ) |
| { |
| if( rInfo.pItemSet ) |
| rInfo.pItemSet->Put( *pNodeItemSet ); |
| else |
| rInfo.pItemSet = new SfxItemSet( *pNodeItemSet ); |
| } |
| |
| // den unteren Absatz-Abstand brauchen wir noch |
| const SvxULSpaceItem& rULSpace = |
| pNodeItemSet ? ((const SvxULSpaceItem &)pNodeItemSet->Get(RES_UL_SPACE)) |
| : rFmt.GetULSpace(); |
| |
| |
| if( (rHWrt.bOutHeader && |
| rWrt.pCurPam->GetPoint()->nNode.GetIndex() == |
| rWrt.pCurPam->GetMark()->nNode.GetIndex()) || |
| rHWrt.bOutFooter ) |
| { |
| if( rHWrt.bCfgOutStyles ) |
| { |
| SvxULSpaceItem aULSpaceItem( rULSpace ); |
| if( rHWrt.bOutHeader ) |
| aULSpaceItem.SetLower( rHWrt.nHeaderFooterSpace ); |
| else |
| aULSpaceItem.SetUpper( rHWrt.nHeaderFooterSpace ); |
| |
| if( !rInfo.pItemSet ) |
| rInfo.pItemSet = new SfxItemSet( |
| *rFmt.GetAttrSet().GetPool(), |
| RES_UL_SPACE, RES_UL_SPACE ); |
| rInfo.pItemSet->Put( aULSpaceItem ); |
| } |
| rHWrt.bOutHeader = sal_False; |
| rHWrt.bOutFooter = sal_False; |
| } |
| |
| if( bOutNewLine ) |
| { |
| // nur einen Zeilen-Umbruch (ohne Einrueckung) am Absatz-Anfang |
| // ausgeben |
| rInfo.aToken.Erase(); // kein End-Tag ausgeben |
| rWrt.Strm() << SwHTMLWriter::sNewLine; |
| |
| return; |
| } |
| |
| |
| // soll ein ALIGN=... geschrieben werden? |
| const SfxPoolItem* pAdjItem = 0; |
| const SfxPoolItem* pItem; |
| |
| if( rInfo.pItemSet && |
| SFX_ITEM_SET == rInfo.pItemSet->GetItemState( RES_PARATR_ADJUST, |
| sal_False, &pItem ) ) |
| { |
| pAdjItem = pItem; |
| } |
| |
| // Unteren Absatz-Abstand beachten ? (nie im letzen Absatz von |
| // Tabellen) |
| sal_Bool bUseParSpace = !rHWrt.bOutTable || |
| (rWrt.pCurPam->GetPoint()->nNode.GetIndex() != |
| rWrt.pCurPam->GetMark()->nNode.GetIndex()); |
| // Wenn Styles exportiert werden, wird aus eingerueckten Absaetzen |
| // eine Definitions-Liste |
| const SvxLRSpaceItem& rLRSpace = |
| pNodeItemSet ? ((const SvxLRSpaceItem &)pNodeItemSet->Get(RES_LR_SPACE)) |
| : rFmt.GetLRSpace(); |
| if( (!rHWrt.bCfgOutStyles || bForceDL) && !rInfo.bInNumBulList ) |
| { |
| sal_Int32 nLeftMargin; |
| if( bForceDL ) |
| nLeftMargin = rLRSpace.GetTxtLeft(); |
| else |
| nLeftMargin = rLRSpace.GetTxtLeft() > pFmtInfo->nLeftMargin |
| ? rLRSpace.GetTxtLeft() - pFmtInfo->nLeftMargin |
| : 0; |
| |
| if( nLeftMargin > 0 && rHWrt.nDefListMargin > 0 ) |
| { |
| nNewDefListLvl = static_cast< sal_uInt16 >((nLeftMargin + (rHWrt.nDefListMargin/2)) / |
| rHWrt.nDefListMargin); |
| if( nNewDefListLvl == 0 && bForceDL && !bDT ) |
| nNewDefListLvl = 1; |
| } |
| else |
| { |
| // If the left margin is 0 or negative, emulating indent |
| // with <dd> does not work. We then set a def list only if |
| // the dd style is used. |
| nNewDefListLvl = (bForceDL&& !bDT) ? 1 : 0; |
| } |
| |
| sal_Bool bIsNextTxtNode = |
| rWrt.pDoc->GetNodes()[rWrt.pCurPam->GetPoint()->nNode.GetIndex()+1] |
| ->IsTxtNode(); |
| |
| if( bForceDL && bDT ) |
| { |
| // Statt eines DD muessen wir hier auch ein DT der Ebene |
| // darueber nehmen |
| nNewDefListLvl++; |
| } |
| else if( !nNewDefListLvl && !rHWrt.bCfgOutStyles && bPara && |
| rULSpace.GetLower()==0 && |
| ((bUseParSpace && bIsNextTxtNode) || rHWrt.nDefListLvl==1) && |
| (!pAdjItem || SVX_ADJUST_LEFT== |
| ((const SvxAdjustItem *)pAdjItem)->GetAdjust()) ) |
| { |
| // Absaetze ohne unteren Abstand als DT exportieren |
| nNewDefListLvl = 1; |
| bDT = sal_True; |
| rInfo.bParaPossible = sal_False; |
| rHWrt.bNoAlign = sal_True; |
| } |
| } |
| |
| if( nNewDefListLvl != rHWrt.nDefListLvl ) |
| rHWrt.OutAndSetDefList( nNewDefListLvl ); |
| |
| // ggf. eine Aufzaehlung- oder Numerierungsliste beginnen |
| if( rInfo.bInNumBulList ) |
| { |
| ASSERT( !rHWrt.nDefListLvl, "DL in OL geht nicht!" ); |
| OutHTML_NumBulListStart( rHWrt, aNumInfo ); |
| |
| if( bNumbered ) |
| { |
| if( rHWrt.aBulletGrfs[nBulletGrfLvl].Len() ) |
| bNumbered = sal_False; |
| else |
| nBulletGrfLvl = 255; |
| } |
| } |
| |
| // Die Defaults aus der Vorlage merken, denn sie muessen nicht |
| // exportiert werden |
| rHWrt.nDfltLeftMargin = pFmtInfo->nLeftMargin; |
| rHWrt.nDfltRightMargin = pFmtInfo->nRightMargin; |
| rHWrt.nDfltFirstLineIndent = pFmtInfo->nFirstLineIndent; |
| |
| if( rInfo.bInNumBulList ) |
| { |
| if( !rHWrt.IsHTMLMode( HTMLMODE_LSPACE_IN_NUMBUL ) ) |
| rHWrt.nDfltLeftMargin = rLRSpace.GetTxtLeft(); |
| |
| // In Numerierungs-Listen keinen Ertzeilen-Einzug ausgeben. |
| rHWrt.nFirstLineIndent = rLRSpace.GetTxtFirstLineOfst(); |
| } |
| |
| if( rInfo.bInNumBulList && bNumbered && bPara && !rHWrt.bCfgOutStyles ) |
| { |
| // ein einzelnes LI hat keinen Abstand |
| rHWrt.nDfltTopMargin = 0; |
| rHWrt.nDfltBottomMargin = 0; |
| } |
| else if( rHWrt.nDefListLvl && bPara ) |
| { |
| // ein einzelnes DD hat auch keinen Abstand |
| rHWrt.nDfltTopMargin = 0; |
| rHWrt.nDfltBottomMargin = 0; |
| } |
| else |
| { |
| rHWrt.nDfltTopMargin = pFmtInfo->nTopMargin; |
| // #60393#: Wenn im letzten Absatz einer Tabelle der |
| // untere Absatz-Abstand veraendert wird, vertut sich |
| // Netscape total. Deshalb exportieren wir hier erstmal |
| // nichts, indem wir den Abstand aus dem Absatz als Default |
| // setzen. |
| if( rHWrt.bCfgNetscape4 && !bUseParSpace ) |
| rHWrt.nDfltBottomMargin = rULSpace.GetLower(); |
| else |
| rHWrt.nDfltBottomMargin = pFmtInfo->nBottomMargin; |
| } |
| |
| if( rHWrt.nDefListLvl ) |
| { |
| rHWrt.nLeftMargin = |
| (rHWrt.nDefListLvl-1) * rHWrt.nDefListMargin; |
| } |
| |
| if( rHWrt.bLFPossible ) |
| rHWrt.OutNewLine(); // Absatz-Tag in neue Zeile |
| rInfo.bOutPara = sal_False; |
| |
| // das ist jetzt unser neues Token |
| rHWrt.ChangeParaToken( nToken ); |
| |
| sal_Bool bHasParSpace = bUseParSpace && rULSpace.GetLower() > 0; |
| |
| // ggf ein List-Item aufmachen |
| if( rInfo.bInNumBulList && bNumbered ) |
| { |
| ByteString sOut( '<' ); |
| sOut += OOO_STRING_SVTOOLS_HTML_li; |
| if( USHRT_MAX != nNumStart ) |
| (((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_value) += '=') |
| += ByteString::CreateFromInt32(nNumStart); |
| sOut += '>'; |
| rWrt.Strm() << sOut.GetBuffer(); |
| } |
| |
| if( rHWrt.nDefListLvl > 0 && !bForceDL ) |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), bDT ? OOO_STRING_SVTOOLS_HTML_dt : OOO_STRING_SVTOOLS_HTML_dd ); |
| } |
| |
| if( pAdjItem && |
| rHWrt.IsHTMLMode( HTMLMODE_NO_CONTROL_CENTERING ) && |
| rHWrt.HasControls() ) |
| { |
| // #64687#: The align=... attribute does behave strange in netscape |
| // if there are controls in a paragraph, because the control and |
| // all text behind the control does not recognize this attribute. |
| ByteString sOut( '<' ); |
| sOut += OOO_STRING_SVTOOLS_HTML_division; |
| rWrt.Strm() << sOut.GetBuffer(); |
| |
| rHWrt.bTxtAttr = sal_False; |
| rHWrt.bOutOpts = sal_True; |
| OutHTML_SvxAdjust( rWrt, *pAdjItem ); |
| rWrt.Strm() << '>'; |
| pAdjItem = 0; |
| rHWrt.bNoAlign = sal_False; |
| rInfo.bOutDiv = sal_True; |
| rHWrt.IncIndentLevel(); |
| rHWrt.bLFPossible = sal_True; |
| rHWrt.OutNewLine(); |
| } |
| |
| // fuer BLOCKQUOTE, ADDRESS und DD wird noch ein Absatz-Token |
| // ausgegeben, wenn, |
| // - keine Styles geschrieben werden, und |
| // - ein untere Abstand oder eine Absatz-Ausrichtung existiert |
| ByteString aToken = rInfo.aToken; |
| if( !rHWrt.bCfgOutStyles && rInfo.bParaPossible && !bPara && |
| (bHasParSpace || pAdjItem) ) |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), rInfo.aToken.GetBuffer() ); |
| aToken = OOO_STRING_SVTOOLS_HTML_parabreak; |
| bPara = sal_True; |
| rHWrt.bNoAlign = sal_False; |
| bNoStyle = sal_False; |
| } |
| |
| LanguageType eLang = rInfo.pItemSet |
| ? ((const SvxLanguageItem&)rInfo.pItemSet->Get(SwHTMLWriter::GetLangWhichIdFromScript(rHWrt.nCSS1Script))).GetLanguage() |
| : rHWrt.eLang; |
| |
| if( rInfo.pItemSet ) |
| { |
| static sal_uInt16 aWhichIds[3] = { RES_CHRATR_LANGUAGE, RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CTL_LANGUAGE }; |
| |
| for( sal_uInt16 i=0; i<3; i++ ) |
| { |
| // export language if it differs from the default language only. |
| const SfxPoolItem *pTmpItem; |
| if( SFX_ITEM_SET == rInfo.pItemSet->GetItemState( aWhichIds[i], |
| sal_True, &pTmpItem ) && |
| ((const SvxLanguageItem *)pTmpItem)->GetLanguage() == eLang ) |
| rInfo.pItemSet->ClearItem( aWhichIds[i] ); |
| } |
| } |
| |
| // and the text direction |
| sal_uInt16 nDir = rHWrt.GetHTMLDirection( |
| (pNodeItemSet ? static_cast < const SvxFrameDirectionItem& >( |
| pNodeItemSet->Get( RES_FRAMEDIR ) ) |
| : rFmt.GetFrmDir() ).GetValue() ); |
| |
| // Ein <P> wird nur geschrieben, wenn |
| // - wir in keiner OL/UL/DL sind, oder |
| // - der Absatz einer OL/UL nicht numeriert ist, oder |
| // - keine Styles exportiert werden und |
| // - ein unterer Abstand oder |
| // - eine Absatz-Ausrichtung existiert, ode |
| // - Styles exportiert werden und, |
| // - die Textkoerper-Vorlage geaendert wurde, oder |
| // - ein Benutzer-Format exportiert wird, oder |
| // - Absatz-Attribute existieren |
| if( !bPara || |
| (!rInfo.bInNumBulList && !rHWrt.nDefListLvl) || |
| (rInfo.bInNumBulList && !bNumbered) || |
| (!rHWrt.bCfgOutStyles && |
| (bHasParSpace || pAdjItem || |
| (eLang != LANGUAGE_DONTKNOW && eLang != rHWrt.eLang))) || |
| nDir != rHWrt.nDirection || |
| rHWrt.bCfgOutStyles ) |
| { |
| // jetzt werden Optionen ausgegeben |
| rHWrt.bTxtAttr = sal_False; |
| rHWrt.bOutOpts = sal_True; |
| |
| ByteString sOut( '<' ); |
| sOut += aToken; |
| |
| if( eLang != LANGUAGE_DONTKNOW && eLang != rHWrt.eLang ) |
| { |
| rWrt.Strm() << sOut.GetBuffer(); |
| rHWrt.OutLanguage( eLang ); |
| sOut.Erase(); |
| } |
| |
| if( nDir != rHWrt.nDirection ) |
| { |
| if( sOut.Len() ) |
| { |
| rWrt.Strm() << sOut.GetBuffer(); |
| sOut.Erase(); |
| } |
| rHWrt.OutDirection( nDir ); |
| } |
| |
| if( rHWrt.bCfgOutStyles && |
| (pFmtInfo->aClass.Len() || pFmtInfo->bScriptDependent) ) |
| { |
| ((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_class) += "=\""; |
| rWrt.Strm() << sOut.GetBuffer(); |
| String aClass( pFmtInfo->aClass ); |
| if( pFmtInfo->bScriptDependent ) |
| { |
| if( aClass.Len() ) |
| aClass += '-'; |
| switch( rHWrt.nCSS1Script ) |
| { |
| case CSS1_OUTMODE_WESTERN: |
| aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("western") ); |
| break; |
| case CSS1_OUTMODE_CJK: |
| aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("cjk") ); |
| break; |
| case CSS1_OUTMODE_CTL: |
| aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("ctl") ); |
| break; |
| } |
| } |
| HTMLOutFuncs::Out_String( rWrt.Strm(), aClass, |
| rHWrt.eDestEnc, &rHWrt.aNonConvertableCharacters ); |
| sOut = '\"'; |
| } |
| rWrt.Strm() << sOut.GetBuffer(); |
| |
| // ggf. Ausrichtung ausgeben. |
| if( !rHWrt.bNoAlign && pAdjItem ) |
| OutHTML_SvxAdjust( rWrt, *pAdjItem ); |
| |
| // und nun ggf. noch die STYLE-Option |
| if( rHWrt.bCfgOutStyles && rInfo.pItemSet && !bNoStyle) |
| { |
| OutCSS1_ParaTagStyleOpt( rWrt, *rInfo.pItemSet ); |
| } |
| |
| rWrt.Strm() << '>'; |
| |
| // Soll ein </P> geschrieben wenrden |
| rInfo.bOutPara = |
| bPara && |
| ( rHWrt.bCfgOutStyles || |
| (!rHWrt.bCfgOutStyles && bHasParSpace) ); |
| |
| // wenn kein End-Tag geschrieben werden soll, es loeschen |
| if( bNoEndTag ) |
| rInfo.aToken.Erase(); |
| } |
| |
| // ??? Warum nicht ueber den Hint-Mechanismus ??? |
| if( rHWrt.IsHTMLMode(HTMLMODE_FIRSTLINE) ) |
| { |
| const SvxLRSpaceItem& rLRSpaceTmp = |
| pNodeItemSet ? ((const SvxLRSpaceItem &)pNodeItemSet->Get(RES_LR_SPACE)) |
| : rFmt.GetLRSpace(); |
| if( rLRSpaceTmp.GetTxtFirstLineOfst() > 0 ) |
| { |
| OutHTML_HoriSpacer( rWrt, rLRSpaceTmp.GetTxtFirstLineOfst() ); |
| } |
| } |
| |
| if( nBulletGrfLvl != 255 ) |
| { |
| ASSERT( aNumInfo.GetNumRule(), "Wo ist die Numerierung geblieben???" ); |
| ASSERT( nBulletGrfLvl < MAXLEVEL, "So viele Ebenen gibt's nicht" ); |
| const SwNumFmt& rNumFmt = aNumInfo.GetNumRule()->Get(nBulletGrfLvl); |
| |
| OutHTML_BulletImage( rWrt, OOO_STRING_SVTOOLS_HTML_image, 0, |
| rHWrt.aBulletGrfs[nBulletGrfLvl], |
| rNumFmt.GetGraphicSize(), rNumFmt.GetGraphicOrientation() ); |
| } |
| |
| rHWrt.GetNumInfo() = aNumInfo; |
| |
| // die Defaults zuruecksetzen |
| rHWrt.nDfltLeftMargin = 0; |
| rHWrt.nDfltRightMargin = 0; |
| rHWrt.nDfltFirstLineIndent = 0; |
| rHWrt.nDfltTopMargin = 0; |
| rHWrt.nDfltBottomMargin = 0; |
| rHWrt.nLeftMargin = 0; |
| rHWrt.nFirstLineIndent = 0; |
| } |
| |
| void OutHTML_SwFmtOff( Writer& rWrt, const SwHTMLTxtCollOutputInfo& rInfo ) |
| { |
| SwHTMLWriter & rHWrt = (SwHTMLWriter&)rWrt; |
| |
| // wenn es kein Token gibt haben wir auch nichts auszugeben |
| if( !rInfo.aToken.Len() ) |
| { |
| rHWrt.FillNextNumInfo(); |
| const SwHTMLNumRuleInfo& rNextInfo = *rHWrt.GetNextNumInfo(); |
| // Auch in PRE muss eine Bullet-Liste beendet werden |
| if( rInfo.bInNumBulList ) |
| { |
| |
| const SwHTMLNumRuleInfo& rNRInfo = rHWrt.GetNumInfo(); |
| if( rNextInfo.GetNumRule() != rNRInfo.GetNumRule() || |
| rNextInfo.GetDepth() != rNRInfo.GetDepth() || |
| rNextInfo.IsNumbered() || rNextInfo.IsRestart() ) |
| rHWrt.ChangeParaToken( 0 ); |
| OutHTML_NumBulListEnd( rHWrt, rNextInfo ); |
| } |
| else if( rNextInfo.GetNumRule() != 0 ) |
| rHWrt.ChangeParaToken( 0 ); |
| |
| return; |
| } |
| |
| if( rInfo.ShouldOutputToken() ) |
| { |
| if( rHWrt.bLFPossible ) |
| rHWrt.OutNewLine( sal_True ); |
| |
| // fuer BLOCKQUOTE, ADDRESS und DD wird ggf noch ein |
| // Absatz-Token ausgegeben, wenn |
| // - keine Styles geschrieben werden, und |
| // - ein untere Abstand existiert |
| if( rInfo.bParaPossible && rInfo.bOutPara ) |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_parabreak, sal_False ); |
| |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), rInfo.aToken.GetBuffer(), |
| sal_False ); |
| rHWrt.bLFPossible = !rInfo.aToken.Equals( OOO_STRING_SVTOOLS_HTML_dt ) && |
| !rInfo.aToken.Equals( OOO_STRING_SVTOOLS_HTML_dd ) && |
| !rInfo.aToken.Equals( OOO_STRING_SVTOOLS_HTML_li ); |
| } |
| if( rInfo.bOutDiv ) |
| { |
| rHWrt.DecIndentLevel(); |
| if( rHWrt.bLFPossible ) |
| rHWrt.OutNewLine(); |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_division, sal_False ); |
| rHWrt.bLFPossible = sal_True; |
| } |
| |
| // ggf. eine Aufzaehlung- oder Numerierungsliste beenden |
| if( rInfo.bInNumBulList ) |
| { |
| rHWrt.FillNextNumInfo(); |
| OutHTML_NumBulListEnd( rHWrt, *rHWrt.GetNextNumInfo() ); |
| } |
| } |
| |
| |
| class HTMLSttEndPos |
| { |
| xub_StrLen nStart; |
| xub_StrLen nEnd; |
| SfxPoolItem* pItem; |
| |
| public: |
| |
| HTMLSttEndPos( const SfxPoolItem& rItem, xub_StrLen nStt, xub_StrLen nE ); |
| ~HTMLSttEndPos(); |
| |
| const SfxPoolItem *GetItem() const { return pItem; } |
| |
| void SetStart( xub_StrLen nStt ) { nStart = nStt; } |
| xub_StrLen GetStart() const { return nStart; } |
| |
| xub_StrLen GetEnd() const { return nEnd; } |
| void SetEnd( xub_StrLen nE ) { nEnd = nE; } |
| }; |
| |
| HTMLSttEndPos::HTMLSttEndPos( const SfxPoolItem& rItem, xub_StrLen nStt, |
| xub_StrLen nE ) : |
| nStart( nStt ), |
| nEnd( nE ), |
| pItem( rItem.Clone() ) |
| {} |
| |
| HTMLSttEndPos::~HTMLSttEndPos() |
| { |
| delete pItem; |
| } |
| |
| typedef HTMLSttEndPos *HTMLSttEndPosPtr; |
| SV_DECL_PTRARR( _HTMLEndLst, HTMLSttEndPosPtr, 5, 5 ) |
| |
| enum HTMLOnOffState { HTML_NOT_SUPPORTED, // nicht unterst. Attribut |
| HTML_REAL_VALUE, // Attribut mit Wert |
| HTML_ON_VALUE, // Attribut entspricht On-Tag |
| HTML_OFF_VALUE, // Attribut entspricht Off-Tag |
| HTML_CHRFMT_VALUE, // Attribut fuer Zeichenvorlage |
| HTML_COLOR_VALUE, // Attribut fuer Vordergrundfarbe |
| HTML_STYLE_VALUE, // Attribut muss als Style exp. |
| HTML_DROPCAP_VALUE, // DropCap-Attributs |
| HTML_AUTOFMT_VALUE }; // Attribute for automatic character styles |
| |
| |
| class HTMLEndPosLst |
| { |
| _HTMLEndLst aStartLst; // nach Anfangs-Psoitionen sortierte Liste |
| _HTMLEndLst aEndLst; // nach End-Psotionen sortierte Liste |
| SvXub_StrLens aScriptChgLst; // positions where script changes |
| // 0 is not contained in this list, |
| // but the text length |
| // the script that is valif up to the position |
| // contained in aScriptChgList at the same index |
| ::std::vector<sal_uInt16> aScriptLst; |
| |
| SwDoc *pDoc; // das aktuelle Dokument |
| SwDoc* pTemplate; // die HTML-Vorlage (oder 0) |
| const Color* pDfltColor;// die Default-Vordergrund-Farbe |
| SvStringsSortDtor& rScriptTxtStyles; // |
| |
| sal_uLong nHTMLMode; |
| sal_Bool bOutStyles : 1; // werden Styles exportiert |
| |
| |
| // die Position eines Items in der Start-/Ende-Liste suchen |
| sal_uInt16 _FindStartPos( const HTMLSttEndPos *pPos ) const; |
| sal_uInt16 _FindEndPos( const HTMLSttEndPos *pPos ) const; |
| |
| // Eine SttEndPos in die Start- und Ende-Listen eintragen bzw. aus |
| // ihnen loeschen, wobei die Ende-Position bekannt ist |
| void _InsertItem( HTMLSttEndPos *pPos, sal_uInt16 nEndPos ); |
| void _RemoveItem( sal_uInt16 nEndPos ); |
| |
| // die "Art" es Attributs ermitteln |
| HTMLOnOffState GetHTMLItemState( const SfxPoolItem& rItem ); |
| |
| // Existiert ein bestimmtes On-Tag-Item |
| sal_Bool ExistsOnTagItem( sal_uInt16 nWhich, xub_StrLen nPos ); |
| |
| // Existiert ein Item zum ausschalten eines Attributs, das genauso |
| // exportiert wird wie das uebergebene Item im gleichen Bereich? |
| sal_Bool ExistsOffTagItem( sal_uInt16 nWhich, xub_StrLen nStartPos, |
| xub_StrLen nEndPos ); |
| |
| |
| // das Ende eines gesplitteten Items anpassen |
| void FixSplittedItem( HTMLSttEndPos *pPos, sal_uInt16 nStartPos, |
| xub_StrLen nNewEnd ); |
| |
| // Ein Attribut in die Listen eintragen und ggf. aufteilen |
| void InsertItem( const SfxPoolItem& rItem, xub_StrLen nStart, |
| xub_StrLen nEnd ); |
| |
| // Ein bereits vorhandenes Attribut aufteilen |
| void SplitItem( const SfxPoolItem& rItem, xub_StrLen nStart, |
| xub_StrLen nEnd ); |
| |
| // Insert without taking care of script |
| void InsertNoScript( const SfxPoolItem& rItem, xub_StrLen nStart, |
| xub_StrLen nEnd, SwHTMLFmtInfos& rFmtInfos, |
| sal_Bool bParaAttrs=sal_False ); |
| |
| const SwHTMLFmtInfo *GetFmtInfo( const SwFmt& rFmt, |
| SwHTMLFmtInfos& rFmtInfos ); |
| |
| public: |
| |
| HTMLEndPosLst( SwDoc *pDoc, SwDoc* pTemplate, const Color* pDfltColor, |
| sal_Bool bOutStyles, sal_uLong nHTMLMode, |
| const String& rText, SvStringsSortDtor& rStyles ); |
| ~HTMLEndPosLst(); |
| |
| // Ein Attribut einfuegen |
| void Insert( const SfxPoolItem& rItem, xub_StrLen nStart, xub_StrLen nEnd, |
| SwHTMLFmtInfos& rFmtInfos, sal_Bool bParaAttrs=sal_False ); |
| void Insert( const SfxItemSet& rItemSet, xub_StrLen nStart, xub_StrLen nEnd, |
| SwHTMLFmtInfos& rFmtInfos, sal_Bool bDeep, |
| sal_Bool bParaAttrs=sal_False ); |
| void Insert( const SwDrawFrmFmt& rFmt, xub_StrLen nPos, |
| SwHTMLFmtInfos& rFmtInfos ); |
| |
| sal_uInt16 GetScriptAtPos( xub_StrLen nPos, |
| sal_uInt16 nWeak=CSS1_OUTMODE_ANY_SCRIPT ); |
| |
| void OutStartAttrs( SwHTMLWriter& rHWrt, xub_StrLen nPos, |
| HTMLOutContext *pContext = 0 ); |
| void OutEndAttrs( SwHTMLWriter& rHWrt, xub_StrLen nPos, |
| HTMLOutContext *pContext = 0 ); |
| |
| sal_uInt16 Count() const { return aEndLst.Count(); } |
| |
| sal_Bool IsHTMLMode( sal_uLong nMode ) const { return (nHTMLMode & nMode) != 0; } |
| }; |
| |
| |
| sal_uInt16 HTMLEndPosLst::_FindStartPos( const HTMLSttEndPos *pPos ) const |
| { |
| sal_uInt16 i; |
| for( i = 0; i < aStartLst.Count() && aStartLst[i] != pPos; i++ ) |
| ; |
| |
| ASSERT( i != aStartLst.Count(), "Item nicht in Start-Liste gefunden!" ); |
| |
| return i==aStartLst.Count() ? USHRT_MAX : i; |
| } |
| |
| sal_uInt16 HTMLEndPosLst::_FindEndPos( const HTMLSttEndPos *pPos ) const |
| { |
| sal_uInt16 i; |
| |
| for( i = 0; i < aEndLst.Count() && aEndLst[i] != pPos; i++ ) |
| ; |
| |
| ASSERT( i != aEndLst.Count(), "Item nicht in Ende-Liste gefunden" ); |
| |
| return i==aEndLst.Count() ? USHRT_MAX : i; |
| } |
| |
| |
| void HTMLEndPosLst::_InsertItem( HTMLSttEndPos *pPos, sal_uInt16 nEndPos ) |
| { |
| // In der Start-Liste das Attribut hinter allen vorher und an |
| // der gleichen Position gestarteten Attributen einfuegen |
| xub_StrLen nStart = pPos->GetStart(); |
| sal_uInt16 i; |
| |
| for( i = 0; i < aStartLst.Count() && |
| aStartLst[i]->GetStart() <= nStart; i++ ) |
| ; |
| aStartLst.Insert( pPos, i ); |
| |
| // die Position in der Ende-Liste wurde uebergeben |
| aEndLst.Insert( pPos, nEndPos ); |
| } |
| |
| void HTMLEndPosLst::_RemoveItem( sal_uInt16 nEndPos ) |
| { |
| HTMLSttEndPos *pPos = aEndLst[nEndPos]; |
| |
| // jetzt Suchen wir es in der Start-Liste |
| sal_uInt16 nStartPos = _FindStartPos( pPos ); |
| if( nStartPos != USHRT_MAX ) |
| aStartLst.Remove( nStartPos, 1 ); |
| |
| aEndLst.Remove( nEndPos, 1 ); |
| |
| delete pPos; |
| } |
| |
| HTMLOnOffState HTMLEndPosLst::GetHTMLItemState( const SfxPoolItem& rItem ) |
| { |
| HTMLOnOffState eState = HTML_NOT_SUPPORTED; |
| switch( rItem.Which() ) |
| { |
| case RES_CHRATR_POSTURE: |
| case RES_CHRATR_CJK_POSTURE: |
| case RES_CHRATR_CTL_POSTURE: |
| switch( ((const SvxPostureItem&)rItem).GetPosture() ) |
| { |
| case ITALIC_NORMAL: |
| eState = HTML_ON_VALUE; |
| break; |
| case ITALIC_NONE: |
| eState = HTML_OFF_VALUE; |
| break; |
| default: |
| if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) |
| eState = HTML_STYLE_VALUE; |
| break; |
| } |
| break; |
| |
| case RES_CHRATR_CROSSEDOUT: |
| switch( ((const SvxCrossedOutItem&)rItem).GetStrikeout() ) |
| { |
| case STRIKEOUT_SINGLE: |
| case STRIKEOUT_DOUBLE: |
| eState = HTML_ON_VALUE; |
| break; |
| case STRIKEOUT_NONE: |
| eState = HTML_OFF_VALUE; |
| break; |
| default: |
| ; |
| } |
| break; |
| |
| case RES_CHRATR_ESCAPEMENT: |
| switch( (const SvxEscapement) |
| ((const SvxEscapementItem&)rItem).GetEnumValue() ) |
| { |
| case SVX_ESCAPEMENT_SUPERSCRIPT: |
| case SVX_ESCAPEMENT_SUBSCRIPT: |
| eState = HTML_ON_VALUE; |
| break; |
| case SVX_ESCAPEMENT_OFF: |
| eState = HTML_OFF_VALUE; |
| break; |
| default: |
| ; |
| } |
| break; |
| |
| case RES_CHRATR_UNDERLINE: |
| switch( ((const SvxUnderlineItem&)rItem).GetLineStyle() ) |
| { |
| case UNDERLINE_SINGLE: |
| eState = HTML_ON_VALUE; |
| break; |
| case UNDERLINE_NONE: |
| eState = HTML_OFF_VALUE; |
| break; |
| default: |
| if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) |
| eState = HTML_STYLE_VALUE; |
| break; |
| } |
| break; |
| |
| case RES_CHRATR_OVERLINE: |
| if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) |
| eState = HTML_STYLE_VALUE; |
| break; |
| |
| case RES_CHRATR_WEIGHT: |
| case RES_CHRATR_CJK_WEIGHT: |
| case RES_CHRATR_CTL_WEIGHT: |
| switch( ((const SvxWeightItem&)rItem).GetWeight() ) |
| { |
| case WEIGHT_BOLD: |
| eState = HTML_ON_VALUE; |
| break; |
| case WEIGHT_NORMAL: |
| eState = HTML_OFF_VALUE; |
| break; |
| default: |
| if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) |
| eState = HTML_STYLE_VALUE; |
| break; |
| } |
| break; |
| |
| case RES_CHRATR_BLINK: |
| if( IsHTMLMode(HTMLMODE_BLINK) ) |
| eState = ((const SvxBlinkItem&)rItem).GetValue() ? HTML_ON_VALUE |
| : HTML_OFF_VALUE; |
| break; |
| |
| case RES_CHRATR_COLOR: |
| eState = HTML_COLOR_VALUE; |
| break; |
| |
| case RES_CHRATR_FONT: |
| case RES_CHRATR_FONTSIZE: |
| case RES_CHRATR_LANGUAGE: |
| case RES_CHRATR_CJK_FONT: |
| case RES_CHRATR_CJK_FONTSIZE: |
| case RES_CHRATR_CJK_LANGUAGE: |
| case RES_CHRATR_CTL_FONT: |
| case RES_CHRATR_CTL_FONTSIZE: |
| case RES_CHRATR_CTL_LANGUAGE: |
| case RES_TXTATR_INETFMT: |
| eState = HTML_REAL_VALUE; |
| break; |
| |
| case RES_TXTATR_CHARFMT: |
| eState = HTML_CHRFMT_VALUE; |
| break; |
| |
| case RES_TXTATR_AUTOFMT: |
| eState = HTML_AUTOFMT_VALUE; |
| break; |
| |
| case RES_CHRATR_CASEMAP: |
| if( IsHTMLMode(HTMLMODE_SMALL_CAPS) ) |
| eState = HTML_STYLE_VALUE; |
| |
| case RES_CHRATR_KERNING: |
| if( IsHTMLMode(HTMLMODE_FULL_STYLES) ) |
| eState = HTML_STYLE_VALUE; |
| break; |
| |
| case RES_CHRATR_BACKGROUND: |
| if( IsHTMLMode(HTMLMODE_SOME_STYLES) ) |
| eState = HTML_STYLE_VALUE; |
| break; |
| |
| case RES_PARATR_DROP: |
| eState = HTML_DROPCAP_VALUE; |
| break; |
| |
| // default: |
| // eState = HTML_NOT_SUPPORTED; |
| // break; |
| } |
| |
| return eState; |
| } |
| |
| sal_Bool HTMLEndPosLst::ExistsOnTagItem( sal_uInt16 nWhich, xub_StrLen nPos ) |
| { |
| for( sal_uInt16 i=0; i<aStartLst.Count(); i++ ) |
| { |
| HTMLSttEndPos *pTest = aStartLst[i]; |
| |
| if( pTest->GetStart() > nPos ) |
| { |
| // dieses uns alle folgenden Attribute beginnen spaeter |
| break; |
| } |
| else if( pTest->GetEnd() > nPos ) |
| { |
| // das Attribut beginnt vor oder an der aktuellen Position |
| // und endet hinter ihr |
| const SfxPoolItem *pItem = pTest->GetItem(); |
| if( pItem->Which() == nWhich && |
| HTML_ON_VALUE == GetHTMLItemState(*pItem) ) |
| { |
| // ein On-Tag-Attibut wurde gefunden |
| return sal_True; |
| } |
| } |
| } |
| |
| return sal_False; |
| } |
| |
| sal_Bool HTMLEndPosLst::ExistsOffTagItem( sal_uInt16 nWhich, xub_StrLen nStartPos, |
| xub_StrLen nEndPos ) |
| { |
| if( nWhich != RES_CHRATR_CROSSEDOUT && |
| nWhich != RES_CHRATR_UNDERLINE && |
| nWhich != RES_CHRATR_BLINK ) |
| { |
| return sal_False; |
| } |
| |
| for( sal_uInt16 i=0; i<aStartLst.Count(); i++ ) |
| { |
| HTMLSttEndPos *pTest = aStartLst[i]; |
| |
| if( pTest->GetStart() > nStartPos ) |
| { |
| // dieses uns alle folgenden Attribute beginnen spaeter |
| break; |
| } |
| else if( pTest->GetStart()==nStartPos && |
| pTest->GetEnd()==nEndPos ) |
| { |
| // das Attribut beginnt vor oder an der aktuellen Position |
| // und endet hinter ihr |
| const SfxPoolItem *pItem = pTest->GetItem(); |
| sal_uInt16 nTstWhich = pItem->Which() ; |
| if( (nTstWhich == RES_CHRATR_CROSSEDOUT || |
| nTstWhich == RES_CHRATR_UNDERLINE || |
| nTstWhich == RES_CHRATR_BLINK) && |
| HTML_OFF_VALUE == GetHTMLItemState(*pItem) ) |
| { |
| // Ein Off-Tag-Attibut wurde gefunden, das genauso |
| // exportiert wird, wie das aktuelle Item |
| return sal_True; |
| } |
| } |
| } |
| |
| return sal_False; |
| } |
| |
| void HTMLEndPosLst::FixSplittedItem( HTMLSttEndPos *pPos, xub_StrLen nNewEnd, |
| sal_uInt16 nStartPos ) |
| { |
| // die End-Position entsprechend fixen |
| pPos->SetEnd( nNewEnd ); |
| |
| // das Item aus der End-Liste entfernen |
| sal_uInt16 nEndPos = _FindEndPos( pPos ); |
| if( nEndPos != USHRT_MAX ) |
| aEndLst.Remove( nEndPos, 1 ); |
| |
| // es wird von nun an als letztes an der entsprechenden Position |
| // beendet |
| for( nEndPos=0; nEndPos < aEndLst.Count() && |
| aEndLst[nEndPos]->GetEnd() <= nNewEnd; nEndPos++ ) |
| ; |
| aEndLst.Insert( pPos, nEndPos ); |
| |
| // jetzt noch die spaeter gestarteten Attribute anpassen |
| for( sal_uInt16 i=nStartPos+1; i<aStartLst.Count(); i++ ) |
| { |
| HTMLSttEndPos *pTest = aStartLst[i]; |
| xub_StrLen nTestEnd = pTest->GetEnd(); |
| if( pTest->GetStart() >= nNewEnd ) |
| { |
| // das Test-Attribut und alle folgenden beginnen, nachdem das |
| // gesplittete Attribut endet |
| break; |
| } |
| else if( nTestEnd > nNewEnd ) |
| { |
| // das Test-Attribut beginnt, bevor das gesplittete Attribut |
| // endet und endet danach, muss also auch gesplittet werden |
| |
| // das neue Ende setzen |
| pTest->SetEnd( nNewEnd ); |
| |
| // das Attribut aus der End-Liste entfernen |
| sal_uInt16 nEPos = _FindEndPos( pTest ); |
| if( nEPos != USHRT_MAX ) |
| aEndLst.Remove( nEPos, 1 ); |
| |
| // es endet jetzt als erstes Attribut an der entsprechenden |
| // Position. Diese Position in der Ende-Liste kennen wir schon. |
| aEndLst.Insert(pTest, nEndPos ); |
| |
| // den "Rest" des Attributs neu einfuegen |
| InsertItem( *pTest->GetItem(), nNewEnd, nTestEnd ); |
| } |
| } |
| } |
| |
| |
| void HTMLEndPosLst::InsertItem( const SfxPoolItem& rItem, xub_StrLen nStart, |
| xub_StrLen nEnd ) |
| { |
| sal_uInt16 i; |
| for( i = 0; i < aEndLst.Count(); i++ ) |
| { |
| HTMLSttEndPos *pTest = aEndLst[i]; |
| xub_StrLen nTestEnd = pTest->GetEnd(); |
| if( nTestEnd <= nStart ) |
| { |
| // das Test-Attribut endet, bevor das neue beginnt |
| continue; |
| } |
| else if( nTestEnd < nEnd ) |
| { |
| // das Test-Attribut endet, bevor das neue endet. Das |
| // neue Attribut muss deshalb aufgesplittet werden |
| _InsertItem( new HTMLSttEndPos( rItem, nStart, nTestEnd ), i ); |
| nStart = nTestEnd; |
| } |
| else |
| { |
| // das Test-Attribut (und alle folgenden) endet, bevor das neue |
| // endet |
| break; |
| } |
| } |
| |
| // ein Attribut muss noch eingefuegt werden |
| _InsertItem( new HTMLSttEndPos( rItem, nStart, nEnd ), i ); |
| } |
| |
| |
| |
| void HTMLEndPosLst::SplitItem( const SfxPoolItem& rItem, xub_StrLen nStart, |
| xub_StrLen nEnd ) |
| { |
| sal_uInt16 nWhich = rItem.Which(); |
| |
| // erstmal muessen wir die alten Items anhand der Startliste suchen |
| // und die neuen Item-Bereiche festlegen |
| |
| for( sal_uInt16 i=0; i<aStartLst.Count(); i++ ) |
| { |
| HTMLSttEndPos *pTest = aStartLst[i]; |
| xub_StrLen nTestStart = pTest->GetStart(); |
| xub_StrLen nTestEnd = pTest->GetEnd(); |
| |
| if( nTestStart >= nEnd ) |
| { |
| // dieses und alle nachfolgenden Attribute beginnen spaeter |
| break; |
| } |
| else if( nTestEnd > nStart ) |
| { |
| // das Test Attribut endet im zu loeschenenden Bereich |
| const SfxPoolItem *pItem = pTest->GetItem(); |
| |
| // nur entsprechende On-Tag Attribute muessen beruecksichtigt |
| // werden |
| if( pItem->Which() == nWhich && |
| HTML_ON_VALUE == GetHTMLItemState( *pItem ) ) |
| { |
| sal_Bool bDelete = sal_True; |
| |
| if( nTestStart < nStart ) |
| { |
| // der Start des neuen Attribut entspricht |
| // dem neuen Ende des Attribts |
| FixSplittedItem( pTest, nStart, i ); |
| bDelete = sal_False; |
| } |
| else |
| { |
| // das Test-Item beginnt erst hinter dem neuen |
| // Ende des Attribts und kann deshalb komplett |
| // geloescht werden |
| aStartLst.Remove( i, 1 ); |
| i--; |
| |
| sal_uInt16 nEndPos = _FindEndPos( pTest ); |
| if( nEndPos != USHRT_MAX ) |
| aEndLst.Remove( nEndPos, 1 ); |
| } |
| |
| // ggf den zweiten Teil des gesplitteten Attribts einfuegen |
| if( nTestEnd > nEnd ) |
| { |
| InsertItem( *pTest->GetItem(), nEnd, nTestEnd ); |
| } |
| |
| if( bDelete ) |
| delete pTest; |
| } |
| } |
| } |
| } |
| |
| const SwHTMLFmtInfo *HTMLEndPosLst::GetFmtInfo( const SwFmt& rFmt, |
| SwHTMLFmtInfos& rFmtInfos ) |
| { |
| const SwHTMLFmtInfo *pFmtInfo; |
| SwHTMLFmtInfo aFmtInfo( &rFmt ); |
| sal_uInt16 nPos; |
| if( rFmtInfos.Seek_Entry( &aFmtInfo, &nPos ) ) |
| { |
| pFmtInfo = rFmtInfos[nPos]; |
| } |
| else |
| { |
| pFmtInfo = new SwHTMLFmtInfo( &rFmt, pDoc, pTemplate, |
| bOutStyles ); |
| rFmtInfos.C40_PTR_INSERT( SwHTMLFmtInfo, pFmtInfo ); |
| String aName( rFmt.GetName() ); |
| if( rScriptTxtStyles.Seek_Entry( &aName ) ) |
| ((SwHTMLFmtInfo *)pFmtInfo)->bScriptDependent = sal_True; |
| } |
| |
| return pFmtInfo; |
| } |
| |
| HTMLEndPosLst::HTMLEndPosLst( SwDoc *pD, SwDoc* pTempl, |
| const Color* pDfltCol, sal_Bool bStyles, |
| sal_uLong nMode, const String& rText, |
| SvStringsSortDtor& rStyles ): |
| pDoc( pD ), |
| pTemplate( pTempl ), |
| pDfltColor( pDfltCol ), |
| rScriptTxtStyles( rStyles ), |
| nHTMLMode( nMode ), |
| bOutStyles( bStyles ) |
| { |
| xub_StrLen nEndPos = rText.Len(); |
| xub_StrLen nPos = 0; |
| while( nPos < nEndPos ) |
| { |
| sal_uInt16 nScript = pBreakIt->GetBreakIter()->getScriptType( rText, nPos ); |
| nPos = (xub_StrLen)pBreakIt->GetBreakIter()->endOfScript( rText, nPos, nScript ); |
| aScriptChgLst.push_back( nPos ); |
| aScriptLst.push_back( nScript ); |
| } |
| } |
| |
| HTMLEndPosLst::~HTMLEndPosLst() |
| { |
| ASSERT( !aStartLst.Count(), "Start-Liste im Destruktor nicht leer" ); |
| ASSERT( !aEndLst.Count(), "End-Liste im Destruktor nicht leer" ); |
| } |
| |
| |
| |
| void HTMLEndPosLst::InsertNoScript( const SfxPoolItem& rItem, |
| xub_StrLen nStart, xub_StrLen nEnd, |
| SwHTMLFmtInfos& rFmtInfos, sal_Bool bParaAttrs ) |
| { |
| // kein Bereich ?? dann nicht aufnehmen, wird nie wirksam !! |
| if( nStart != nEnd ) |
| { |
| sal_Bool bSet = sal_False, bSplit = sal_False; |
| switch( GetHTMLItemState(rItem) ) |
| { |
| case HTML_ON_VALUE: |
| // das Attribut wird ausgegeben, wenn es nicht sowieso |
| // schon an ist |
| if( !ExistsOnTagItem( rItem.Which(), nStart ) ) |
| bSet = sal_True; |
| break; |
| |
| case HTML_OFF_VALUE: |
| // wenn das entsprechne Attribut an ist, wird es gesplittet, |
| // Zusaetlich wird es aber als Style ausgegeben, wenn es nicht |
| // am ganzen Absatz gesetzt ist, weil es dann ja schon mit dem |
| // ABsatz-Tag ausgegeben wurde. |
| if( ExistsOnTagItem( rItem.Which(), nStart ) ) |
| bSplit = sal_True; |
| bSet = bOutStyles && !bParaAttrs && |
| !ExistsOffTagItem( rItem.Which(), nStart, nEnd ); |
| break; |
| |
| case HTML_REAL_VALUE: |
| // das Attribut kann immer ausgegeben werden |
| bSet = sal_True; |
| break; |
| |
| case HTML_STYLE_VALUE: |
| // Das Attribut kann nur als CSS1 ausgegeben werden. Wenn |
| // es am Absatz gesetzt ist, wurde es schon mit dem |
| // Absatz-Tag ausgegeben. Einzige Ausnahme ist das |
| // Zeichen-Hintergrund-Attribut. Es muss immer wie ein |
| // Hint behandelt werden. |
| bSet = bOutStyles && |
| (!bParaAttrs |
| || rItem.Which()==RES_CHRATR_BACKGROUND |
| || rItem.Which()==RES_CHRATR_OVERLINE); |
| break; |
| |
| case HTML_CHRFMT_VALUE: |
| { |
| ASSERT( RES_TXTATR_CHARFMT == rItem.Which(), |
| "Doch keine Zeichen-Vorlage" ); |
| const SwFmtCharFmt& rChrFmt = (const SwFmtCharFmt&)rItem; |
| const SwCharFmt* pFmt = rChrFmt.GetCharFmt(); |
| |
| const SwHTMLFmtInfo *pFmtInfo = GetFmtInfo( *pFmt, rFmtInfos ); |
| if( pFmtInfo->aToken.Len() ) |
| { |
| // das Zeichenvorlagen-Tag muss vor den harten |
| // Attributen ausgegeben werden |
| InsertItem( rItem, nStart, nEnd ); |
| } |
| if( pFmtInfo->pItemSet ) |
| { |
| Insert( *pFmtInfo->pItemSet, nStart, nEnd, |
| rFmtInfos, sal_True, bParaAttrs ); |
| } |
| } |
| break; |
| |
| case HTML_AUTOFMT_VALUE: |
| { |
| const SwFmtAutoFmt& rAutoFmt = (const SwFmtAutoFmt&)rItem; |
| const boost::shared_ptr<SfxItemSet> pSet = rAutoFmt.GetStyleHandle(); |
| if( pSet.get() ) |
| Insert( *pSet.get(), nStart, nEnd, rFmtInfos, sal_True, bParaAttrs ); |
| } |
| break; |
| |
| case HTML_COLOR_VALUE: |
| // Eine Vordergrund-Farbe als Absatz-Attribut wird nur |
| // exportiert, wenn sie nicht der Default-Farbe entspricht. |
| { |
| ASSERT( RES_CHRATR_COLOR == rItem.Which(), |
| "Doch keine Vordergrund-Farbe" ); |
| Color aColor( ((const SvxColorItem&)rItem).GetValue() ); |
| if( COL_AUTO == aColor.GetColor() ) |
| aColor.SetColor( COL_BLACK ); |
| bSet = !bParaAttrs || !pDfltColor || |
| !pDfltColor->IsRGBEqual( aColor ); |
| } |
| break; |
| |
| case HTML_DROPCAP_VALUE: |
| { |
| ASSERT( RES_PARATR_DROP == rItem.Which(), |
| "Doch kein Drop-Cap" ); |
| const SwFmtDrop& rDrop = (const SwFmtDrop&)rItem; |
| nEnd = nStart + rDrop.GetChars(); |
| if( !bOutStyles ) |
| { |
| // Zumindest die Attribute der Zeichenvorlage uebernehmen |
| const SwCharFmt *pCharFmt = rDrop.GetCharFmt(); |
| if( pCharFmt ) |
| { |
| Insert( pCharFmt->GetAttrSet(), nStart, nEnd, |
| rFmtInfos, sal_True, bParaAttrs ); |
| } |
| } |
| else |
| { |
| bSet = sal_True; |
| } |
| } |
| break; |
| default: |
| ; |
| } |
| |
| if( bSet ) |
| InsertItem( rItem, nStart, nEnd ); |
| if( bSplit ) |
| SplitItem( rItem, nStart, nEnd ); |
| } |
| } |
| |
| void HTMLEndPosLst::Insert( const SfxPoolItem& rItem, |
| xub_StrLen nStart, xub_StrLen nEnd, |
| SwHTMLFmtInfos& rFmtInfos, sal_Bool bParaAttrs ) |
| { |
| sal_Bool bDependsOnScript = sal_False, bDependsOnAnyScript = sal_False; |
| sal_uInt16 nScript = i18n::ScriptType::LATIN; |
| switch( rItem.Which() ) |
| { |
| case RES_CHRATR_FONT: |
| case RES_CHRATR_FONTSIZE: |
| case RES_CHRATR_LANGUAGE: |
| case RES_CHRATR_POSTURE: |
| case RES_CHRATR_WEIGHT: |
| bDependsOnScript = sal_True; |
| nScript = i18n::ScriptType::LATIN; |
| break; |
| |
| case RES_CHRATR_CJK_FONT: |
| case RES_CHRATR_CJK_FONTSIZE: |
| case RES_CHRATR_CJK_LANGUAGE: |
| case RES_CHRATR_CJK_POSTURE: |
| case RES_CHRATR_CJK_WEIGHT: |
| bDependsOnScript = sal_True; |
| nScript = i18n::ScriptType::ASIAN; |
| break; |
| |
| case RES_CHRATR_CTL_FONT: |
| case RES_CHRATR_CTL_FONTSIZE: |
| case RES_CHRATR_CTL_LANGUAGE: |
| case RES_CHRATR_CTL_POSTURE: |
| case RES_CHRATR_CTL_WEIGHT: |
| bDependsOnScript = sal_True; |
| nScript = i18n::ScriptType::COMPLEX; |
| break; |
| case RES_TXTATR_CHARFMT: |
| { |
| const SwFmtCharFmt& rChrFmt = (const SwFmtCharFmt&)rItem; |
| const SwCharFmt* pFmt = rChrFmt.GetCharFmt(); |
| const SwHTMLFmtInfo *pFmtInfo = GetFmtInfo( *pFmt, rFmtInfos ); |
| if( pFmtInfo->bScriptDependent ) |
| { |
| bDependsOnScript = sal_True; |
| bDependsOnAnyScript = sal_True; |
| } |
| } |
| break; |
| case RES_TXTATR_INETFMT: |
| { |
| if( GetFmtInfo( *pDoc->GetCharFmtFromPool( |
| RES_POOLCHR_INET_NORMAL), rFmtInfos )->bScriptDependent || |
| GetFmtInfo( *pDoc->GetCharFmtFromPool( |
| RES_POOLCHR_INET_VISIT), rFmtInfos )->bScriptDependent ) |
| { |
| bDependsOnScript = sal_True; |
| bDependsOnAnyScript = sal_True; |
| } |
| } |
| break; |
| } |
| |
| if( bDependsOnScript ) |
| { |
| xub_StrLen nPos = nStart; |
| for( size_t i=0; i < aScriptChgLst.size(); i++ ) |
| { |
| xub_StrLen nChgPos = aScriptChgLst[i]; |
| if( nPos >= nChgPos ) |
| { |
| // the hint starts behind or at the next script change, |
| // so we may continue with this position. |
| continue; |
| } |
| if( nEnd <= nChgPos ) |
| { |
| // the (rest of) the hint ends before or at the next script |
| // change, so we can insert it, but only if it belongs |
| // to the current script. |
| if( bDependsOnAnyScript || nScript == aScriptLst[i] ) |
| InsertNoScript( rItem, nPos, nEnd, rFmtInfos, |
| bParaAttrs ); |
| break; |
| } |
| |
| // the hint starts before the next script change and ends behind |
| // it, so we can insert a hint upto the next script change and |
| // continue with the rest of the hint. |
| if( bDependsOnAnyScript || nScript == aScriptLst[i] ) |
| InsertNoScript( rItem, nPos, nChgPos, rFmtInfos, bParaAttrs ); |
| nPos = nChgPos; |
| } |
| } |
| else |
| { |
| InsertNoScript( rItem, nStart, nEnd, rFmtInfos, bParaAttrs ); |
| } |
| } |
| |
| void HTMLEndPosLst::Insert( const SfxItemSet& rItemSet, |
| xub_StrLen nStart, xub_StrLen nEnd, |
| SwHTMLFmtInfos& rFmtInfos, |
| sal_Bool bDeep, sal_Bool bParaAttrs ) |
| { |
| SfxWhichIter aIter( rItemSet ); |
| |
| sal_uInt16 nWhich = aIter.FirstWhich(); |
| while( nWhich ) |
| { |
| const SfxPoolItem *pItem; |
| if( SFX_ITEM_SET == rItemSet.GetItemState( nWhich, bDeep, &pItem ) ) |
| { |
| Insert( *pItem, nStart, nEnd, rFmtInfos, bParaAttrs ); |
| } |
| |
| nWhich = aIter.NextWhich(); |
| } |
| } |
| |
| void HTMLEndPosLst::Insert( const SwDrawFrmFmt& rFmt, xub_StrLen nPos, |
| SwHTMLFmtInfos& rFmtInfos ) |
| { |
| // der Type-Cast ist nur noetig, um nicht seinetwegen |
| // svdrwobt.hxx zu includem |
| const SdrObject* pTextObj = |
| (const SdrObject *)SwHTMLWriter::GetMarqueeTextObj( rFmt ); |
| |
| if( pTextObj ) |
| { |
| // die Edit-Engine-Attribute des Objekts als SW-Attribute holen |
| // und als Hints einsortieren. Wegen der Menge der Hints werden |
| // Styles hierbei nicht beruecksichtigt! |
| const SfxItemSet& rFmtItemSet = rFmt.GetAttrSet(); |
| SfxItemSet aItemSet( *rFmtItemSet.GetPool(), RES_CHRATR_BEGIN, |
| RES_CHRATR_END ); |
| SwHTMLWriter::GetEEAttrsFromDrwObj( aItemSet, pTextObj, sal_True ); |
| sal_Bool bOutStylesOld = bOutStyles; |
| bOutStyles = sal_False; |
| Insert( aItemSet, nPos, nPos+1, rFmtInfos, sal_False, sal_False ); |
| bOutStyles = bOutStylesOld; |
| } |
| } |
| |
| sal_uInt16 HTMLEndPosLst::GetScriptAtPos( xub_StrLen nPos , |
| sal_uInt16 nWeak ) |
| { |
| sal_uInt16 nRet = CSS1_OUTMODE_ANY_SCRIPT; |
| |
| size_t nScriptChgs = aScriptChgLst.size(); |
| size_t i=0; |
| while( i < nScriptChgs && nPos >= aScriptChgLst[i] ) |
| i++; |
| ASSERT( i < nScriptChgs, "script list is to short" ); |
| if( i < nScriptChgs ) |
| { |
| if( i18n::ScriptType::WEAK == aScriptLst[i] ) |
| nRet = nWeak; |
| else |
| nRet = SwHTMLWriter::GetCSS1ScriptForScriptType( aScriptLst[i] ); |
| } |
| |
| return nRet; |
| } |
| |
| void HTMLEndPosLst::OutStartAttrs( SwHTMLWriter& rHWrt, xub_StrLen nPos, |
| HTMLOutContext *pContext ) |
| { |
| rHWrt.bTagOn = sal_True; |
| |
| // die Attribute in der Start-Liste sind aufsteigend sortiert |
| for( sal_uInt16 i=0; i< aStartLst.Count(); i++ ) |
| { |
| HTMLSttEndPos *pPos = aStartLst[i]; |
| xub_StrLen nStart = pPos->GetStart(); |
| if( nStart > nPos ) |
| { |
| // dieses und alle folgenden Attribute werden erst noch geoeffnet |
| break; |
| } |
| else if( nStart == nPos ) |
| { |
| // das Attribut ausgeben |
| sal_uInt16 nCSS1Script = rHWrt.nCSS1Script; |
| sal_uInt16 nWhich = pPos->GetItem()->Which(); |
| if( RES_TXTATR_CHARFMT == nWhich || |
| RES_TXTATR_INETFMT == nWhich || |
| RES_PARATR_DROP == nWhich ) |
| { |
| rHWrt.nCSS1Script = GetScriptAtPos( nPos, nCSS1Script ); |
| } |
| if( pContext ) |
| { |
| HTMLOutFuncs::FlushToAscii( rHWrt.Strm(), *pContext ); |
| pContext = 0; // one time ony |
| } |
| Out( aHTMLAttrFnTab, *pPos->GetItem(), rHWrt ); |
| rHWrt.nCSS1Script = nCSS1Script; |
| } |
| } |
| } |
| |
| void HTMLEndPosLst::OutEndAttrs( SwHTMLWriter& rHWrt, xub_StrLen nPos, |
| HTMLOutContext *pContext ) |
| { |
| rHWrt.bTagOn = sal_False; |
| |
| // die Attribute in der End-Liste sind aufsteigend sortiert |
| sal_uInt16 i=0; |
| while( i < aEndLst.Count() ) |
| { |
| HTMLSttEndPos *pPos = aEndLst[i]; |
| xub_StrLen nEnd = pPos->GetEnd(); |
| |
| if( STRING_MAXLEN==nPos || nEnd == nPos ) |
| { |
| if( pContext ) |
| { |
| HTMLOutFuncs::FlushToAscii( rHWrt.Strm(), *pContext ); |
| pContext = 0; // one time ony |
| } |
| Out( aHTMLAttrFnTab, *pPos->GetItem(), rHWrt ); |
| _RemoveItem( i ); |
| } |
| else if( nEnd > nPos ) |
| { |
| // dieses und alle folgenden Attribute werden erst spaeter beendet |
| break; |
| } |
| else |
| { |
| // Das Attribut wird vor der aktuellen Position beendet. Das |
| // darf nicht sein, aber wie koennen trotzdem damit umgehen |
| ASSERT( nEnd >= nPos, |
| "Das Attribut sollte schon laengst beendet sein" ); |
| i++; |
| } |
| } |
| } |
| |
| |
| /* Ausgabe der Nodes */ |
| Writer& OutHTML_SwTxtNode( Writer& rWrt, const SwCntntNode& rNode ) |
| { |
| SwTxtNode * pNd = &((SwTxtNode&)rNode); |
| SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt; |
| |
| const String& rStr = pNd->GetTxt(); |
| xub_StrLen nEnde = rStr.Len(); |
| |
| // Besonderheit: leere Node und HR-Vorlage (horizontaler Strich) |
| // nur ein <HR> ausgeben |
| sal_uInt16 nPoolId = pNd->GetAnyFmtColl().GetPoolFmtId(); |
| |
| if( !nEnde && (RES_POOLCOLL_HTML_HR==nPoolId || |
| pNd->GetAnyFmtColl().GetName().EqualsAscii( OOO_STRING_SVTOOLS_HTML_horzrule) ) ) |
| { |
| // dann die absatz-gebundenen Grafiken/OLE-Objekte im Absatz |
| // MIB 8.7.97: Ein <PRE> spannen wir um die Linie auf. Dann stimmen |
| // zwar die Abstaende nicht, aber sonst bekommen wir einen leeren |
| // Absatz hinter dem <HR> und das ist noch unschoener. |
| rHTMLWrt.ChangeParaToken( 0 ); |
| |
| // Alle an dem Node verankerten Rahmen ausgeben |
| rHTMLWrt.OutFlyFrm( rNode.GetIndex(), 0, HTML_POS_ANY ); |
| |
| if( rHTMLWrt.bLFPossible ) |
| rHTMLWrt.OutNewLine(); // Absatz-Tag in eine neue Zeile |
| |
| rHTMLWrt.bLFPossible = sal_True; |
| |
| ByteString sOut( '<' ); |
| sOut += OOO_STRING_SVTOOLS_HTML_horzrule; |
| |
| const SfxItemSet* pItemSet = pNd->GetpSwAttrSet(); |
| if( !pItemSet ) |
| { |
| rWrt.Strm() << sOut.GetBuffer() << '>'; |
| return rHTMLWrt; |
| } |
| const SfxPoolItem* pItem; |
| if( SFX_ITEM_SET == pItemSet->GetItemState( RES_LR_SPACE, sal_False, &pItem )) |
| { |
| sal_Int32 nLeft = ((SvxLRSpaceItem*)pItem)->GetLeft(); |
| sal_Int32 nRight = ((SvxLRSpaceItem*)pItem)->GetRight(); |
| if( nLeft || nRight ) |
| { |
| const SwFrmFmt& rPgFmt = |
| rHTMLWrt.pDoc->GetPageDescFromPool |
| ( RES_POOLPAGE_HTML, false )->GetMaster(); |
| const SwFmtFrmSize& rSz = rPgFmt.GetFrmSize(); |
| const SvxLRSpaceItem& rLR = rPgFmt.GetLRSpace(); |
| const SwFmtCol& rCol = rPgFmt.GetCol(); |
| |
| long nPageWidth = rSz.GetWidth() - rLR.GetLeft() - rLR.GetRight(); |
| |
| if( 1 < rCol.GetNumCols() ) |
| nPageWidth /= rCol.GetNumCols(); |
| |
| const SwTableNode* pTblNd = pNd->FindTableNode(); |
| if( pTblNd ) |
| { |
| const SwTableBox* pBox = pTblNd->GetTable().GetTblBox( |
| pNd->StartOfSectionIndex() ); |
| if( pBox ) |
| nPageWidth = pBox->GetFrmFmt()->GetFrmSize().GetWidth(); |
| } |
| |
| ((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_width) += '='; |
| rWrt.Strm() << sOut.GetBuffer(); |
| rWrt.OutULong( rHTMLWrt.ToPixel(nPageWidth-nLeft-nRight) ); |
| |
| ((sOut = ' ') += OOO_STRING_SVTOOLS_HTML_O_align) += '='; |
| if( !nLeft ) |
| sOut += OOO_STRING_SVTOOLS_HTML_AL_left; |
| else if( !nRight ) |
| sOut += OOO_STRING_SVTOOLS_HTML_AL_right; |
| else |
| sOut += OOO_STRING_SVTOOLS_HTML_AL_center; |
| } |
| } |
| rWrt.Strm() << sOut.GetBuffer(); |
| if( SFX_ITEM_SET == pItemSet->GetItemState( RES_BOX, sal_False, &pItem )) |
| { |
| const SvxBoxItem* pBoxItem = (const SvxBoxItem*)pItem; |
| const SvxBorderLine* pBorderLine = pBoxItem->GetBottom(); |
| if( pBorderLine ) |
| { |
| sal_uInt16 nWidth = pBorderLine->GetOutWidth() + |
| pBorderLine->GetInWidth() + |
| pBorderLine->GetDistance(); |
| ((sOut = ' ') += OOO_STRING_SVTOOLS_HTML_O_size) += '='; |
| rWrt.Strm() << sOut.GetBuffer(); |
| rWrt.OutULong( rHTMLWrt.ToPixel(nWidth) ); |
| |
| const Color& rBorderColor = pBorderLine->GetColor(); |
| if( !rBorderColor.IsRGBEqual( Color(COL_GRAY) ) ) |
| { |
| ((sOut = ' ') += OOO_STRING_SVTOOLS_HTML_O_color) += '='; |
| rWrt.Strm() << sOut.GetBuffer(); |
| HTMLOutFuncs::Out_Color( rWrt.Strm(), rBorderColor, |
| rHTMLWrt.eDestEnc ); |
| } |
| |
| if( !pBorderLine->GetInWidth() ) |
| { |
| (sOut = ' ') += OOO_STRING_SVTOOLS_HTML_O_noshade; |
| rWrt.Strm() << sOut.GetBuffer(); |
| } |
| } |
| } |
| rWrt.Strm() << '>'; |
| return rHTMLWrt; |
| } |
| |
| // Die leeren Nodes mit 2pt Font-Hoehe und der Stand-Vorlage, die |
| // vor Tabellen und Bereichen eingefuegt werden, nicht exportieren, |
| // Bookmarks oder absatzgebundene Grafiken aber schon. |
| // MIB 21.7.97: Ausserdem auch keine leeren Tabellen-Zellen exportieren. |
| if( !nEnde && (nPoolId == RES_POOLCOLL_STANDARD || |
| nPoolId == RES_POOLCOLL_TABLE || |
| nPoolId == RES_POOLCOLL_TABLE_HDLN) ) |
| { |
| // Der aktuelle Node ist leer und enthaelt Standard-Vorlage ... |
| const SfxPoolItem* pItem; |
| const SfxItemSet *pItemSet = pNd->GetpSwAttrSet(); |
| if( pItemSet && pItemSet->Count() && |
| SFX_ITEM_SET == pItemSet->GetItemState( RES_CHRATR_FONTSIZE, sal_False, &pItem ) && |
| 40 == ((const SvxFontHeightItem *)pItem)->GetHeight() ) |
| { |
| // ... ausserdem ist die 2pt Schrift eingestellt ... |
| sal_uLong nNdPos = rWrt.pCurPam->GetPoint()->nNode.GetIndex(); |
| const SwNode *pNextNd = rWrt.pDoc->GetNodes()[nNdPos+1]; |
| const SwNode *pPrevNd = rWrt.pDoc->GetNodes()[nNdPos-1]; |
| sal_Bool bStdColl = nPoolId == RES_POOLCOLL_STANDARD; |
| if( ( bStdColl && (pNextNd->IsTableNode() || |
| pNextNd->IsSectionNode()) ) || |
| ( !bStdColl && pNextNd->IsEndNode() && |
| pPrevNd->IsStartNode() && |
| SwTableBoxStartNode== |
| pPrevNd->GetStartNode()->GetStartNodeType() ) ) |
| { |
| // ... und er steht vor einer Tabelle ohne einem Bereich |
| rHTMLWrt.OutBookmarks(); |
| rHTMLWrt.bLFPossible = !rHTMLWrt.nLastParaToken; |
| |
| // Alle an dem Node verankerten Rahmen ausgeben |
| rHTMLWrt.OutFlyFrm( rNode.GetIndex(), 0, HTML_POS_ANY ); |
| rHTMLWrt.bLFPossible = sal_False; |
| |
| return rWrt; |
| } |
| } |
| } |
| |
| // PagePreaks uns PagDescs abfangen |
| sal_Bool bPageBreakBehind = sal_False; |
| if( rHTMLWrt.bCfgFormFeed && |
| !(rHTMLWrt.bOutTable || rHTMLWrt.bOutFlyFrame) && |
| rHTMLWrt.pStartNdIdx->GetIndex() != |
| rHTMLWrt.pCurPam->GetPoint()->nNode.GetIndex() ) |
| { |
| sal_Bool bPageBreakBefore = sal_False; |
| const SfxPoolItem* pItem; |
| const SfxItemSet* pItemSet = pNd->GetpSwAttrSet(); |
| |
| if( pItemSet ) |
| { |
| if( SFX_ITEM_SET == |
| pItemSet->GetItemState( RES_PAGEDESC, sal_True, &pItem ) && |
| ((SwFmtPageDesc *)pItem)->GetPageDesc() ) |
| bPageBreakBefore = sal_True; |
| else if( SFX_ITEM_SET == |
| pItemSet->GetItemState( RES_BREAK, sal_True, &pItem ) ) |
| { |
| switch( ((SvxFmtBreakItem *)pItem)->GetBreak() ) |
| { |
| case SVX_BREAK_PAGE_BEFORE: |
| bPageBreakBefore = sal_True; |
| break; |
| case SVX_BREAK_PAGE_AFTER: |
| bPageBreakBehind = sal_True; |
| break; |
| case SVX_BREAK_PAGE_BOTH: |
| bPageBreakBefore = sal_True; |
| bPageBreakBehind = sal_True; |
| break; |
| default: |
| ; |
| } |
| } |
| } |
| |
| if( bPageBreakBefore ) |
| rWrt.Strm() << '\f'; |
| } |
| |
| // eventuell eine Form oeffnen |
| rHTMLWrt.OutForm(); |
| |
| // An dem Node "verankerte" Seitenegebunde Rahmen ausgeben |
| sal_Bool bFlysLeft = rHTMLWrt.OutFlyFrm( rNode.GetIndex(), |
| 0, HTML_POS_PREFIX ); |
| // An dem Node verankerte Rahmen ausgeben, die vor dem |
| // Absatz-Tag geschrieben werden sollen. |
| if( bFlysLeft ) |
| bFlysLeft = rHTMLWrt.OutFlyFrm( rNode.GetIndex(), |
| 0, HTML_POS_BEFORE ); |
| |
| if( rHTMLWrt.pCurPam->GetPoint()->nNode == rHTMLWrt.pCurPam->GetMark()->nNode ) |
| nEnde = rHTMLWrt.pCurPam->GetMark()->nContent.GetIndex(); |
| |
| // gibt es harte Attribute, die als Optionen geschrieben werden muessen? |
| rHTMLWrt.bTagOn = sal_True; |
| |
| // jetzt das Tag des Absatzes ausgeben |
| const SwFmt& rFmt = pNd->GetAnyFmtColl(); |
| SwHTMLTxtCollOutputInfo aFmtInfo; |
| sal_Bool bOldLFPossible = rHTMLWrt.bLFPossible; |
| OutHTML_SwFmt( rWrt, rFmt, pNd->GetpSwAttrSet(), aFmtInfo ); |
| |
| // Wenn vor dem Absatz-Tag keine neue Zeile aufgemacht wurde, dann |
| // tun wir das jetzt |
| rHTMLWrt.bLFPossible = !rHTMLWrt.nLastParaToken; |
| if( !bOldLFPossible && rHTMLWrt.bLFPossible ) |
| rHTMLWrt.OutNewLine(); |
| |
| |
| // dann die Bookmarks (inkl. End-Tag) |
| rHTMLWrt.bOutOpts = sal_False; |
| rHTMLWrt.OutBookmarks(); |
| |
| // jetzt ist noch mal eine gute Gelegenheit fuer ein LF, sofern es noch |
| // erlaubt ist |
| if( rHTMLWrt.bLFPossible && |
| rHTMLWrt.GetLineLen() >= rHTMLWrt.nWhishLineLen ) |
| { |
| rHTMLWrt.OutNewLine(); |
| } |
| rHTMLWrt.bLFPossible = sal_False; |
| |
| // Text, der aus einer Outline-Numerierung kommt ermitteln |
| xub_StrLen nOffset = 0; |
| String aOutlineTxt; |
| String aFullText; |
| // --> OD 2006-06-12 #b6435904# |
| // export numbering string as plain text only for the outline numbering, |
| // because the outline numbering isn't exported as a numbering - see <SwHTMLNumRuleInfo::Set(..)> |
| if ( pNd->IsOutline() && |
| pNd->GetNumRule() == pNd->GetDoc()->GetOutlineNumRule() ) |
| // <-- |
| { |
| aOutlineTxt = pNd->GetNumString(); |
| nOffset = nOffset + aOutlineTxt.Len(); |
| aFullText = aOutlineTxt; |
| } |
| String aFootEndNoteSym; |
| if( rHTMLWrt.pFmtFtn ) |
| { |
| aFootEndNoteSym = rHTMLWrt.GetFootEndNoteSym( *rHTMLWrt.pFmtFtn ); |
| nOffset = nOffset + aFootEndNoteSym.Len(); |
| aFullText += aFootEndNoteSym; |
| } |
| |
| // gibt es harte Attribute, die als Tags geschrieben werden muessen? |
| aFullText += rStr; |
| HTMLEndPosLst aEndPosLst( rWrt.pDoc, rHTMLWrt.pTemplate, |
| rHTMLWrt.pDfltColor, rHTMLWrt.bCfgOutStyles, |
| rHTMLWrt.GetHTMLMode(), aFullText, |
| rHTMLWrt.aScriptTextStyles ); |
| if( aFmtInfo.pItemSet ) |
| { |
| aEndPosLst.Insert( *aFmtInfo.pItemSet, 0, nEnde + nOffset, |
| rHTMLWrt.aChrFmtInfos, sal_False, sal_True ); |
| } |
| |
| |
| if( aOutlineTxt.Len() || rHTMLWrt.pFmtFtn ) |
| { |
| // Absatz-Attribute ausgeben, damit der Text die Attribute des |
| // Absatzes bekommt. |
| aEndPosLst.OutStartAttrs( rHTMLWrt, 0 ); |
| |
| // Theoretisch muesste man hier die Zeichen-Vorlage der Numerierung |
| // beachten. Da man die ueber die UI nicht setzen kann, ignorieren |
| // wir sie erstmal. |
| |
| if( aOutlineTxt.Len() ) |
| HTMLOutFuncs::Out_String( rWrt.Strm(), aOutlineTxt, |
| rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters); |
| |
| if( rHTMLWrt.pFmtFtn ) |
| { |
| rHTMLWrt.OutFootEndNoteSym( *rHTMLWrt.pFmtFtn, aFootEndNoteSym, |
| aEndPosLst.GetScriptAtPos( aOutlineTxt.Len(), rHTMLWrt.nCSS1Script ) ); |
| rHTMLWrt.pFmtFtn = 0; |
| } |
| } |
| |
| // erstmal den Start berichtigen. D.h. wird nur ein Teil vom Satz |
| // ausgegeben, so muessen auch da die Attribute stimmen!! |
| rHTMLWrt.bTxtAttr = sal_True; |
| |
| |
| sal_uInt16 nAttrPos = 0; |
| xub_StrLen nStrPos = rHTMLWrt.pCurPam->GetPoint()->nContent.GetIndex(); |
| const SwTxtAttr * pHt = 0; |
| sal_uInt16 nCntAttr = pNd->HasHints() ? pNd->GetSwpHints().Count() : 0; |
| if( nCntAttr && nStrPos > *( pHt = pNd->GetSwpHints()[ 0 ] )->GetStart() ) |
| { |
| // Ok, es gibt vorher Attribute, die ausgegeben werden muessen |
| do { |
| aEndPosLst.OutEndAttrs( rHTMLWrt, nStrPos + nOffset ); |
| |
| nAttrPos++; |
| if( pHt->Which() == RES_TXTATR_FIELD |
| || pHt->Which() == RES_TXTATR_ANNOTATION ) |
| continue; |
| |
| if ( pHt->End() && !pHt->HasDummyChar() ) |
| { |
| const xub_StrLen nHtEnd = *pHt->End(), |
| nHtStt = *pHt->GetStart(); |
| if( !rHTMLWrt.bWriteAll && nHtEnd <= nStrPos ) |
| continue; |
| |
| // leere Hints am Anfang nicht beachten, oder ?? |
| if( nHtEnd == nHtStt ) |
| continue; |
| |
| // Attribut in die Liste aufnehemen |
| if( rHTMLWrt.bWriteAll ) |
| aEndPosLst.Insert( pHt->GetAttr(), nHtStt + nOffset, |
| nHtEnd + nOffset, |
| rHTMLWrt.aChrFmtInfos ); |
| else |
| { |
| xub_StrLen nTmpStt = nHtStt < nStrPos ? nStrPos : nHtStt; |
| xub_StrLen nTmpEnd = nHtEnd < nEnde ? nHtEnd : nEnde; |
| aEndPosLst.Insert( pHt->GetAttr(), nTmpStt + nOffset, |
| nTmpEnd + nOffset, |
| rHTMLWrt.aChrFmtInfos ); |
| } |
| continue; |
| // aber nicht ausgeben, das erfolgt spaeter !! |
| } |
| |
| } while( nAttrPos < nCntAttr && nStrPos > |
| *( pHt = pNd->GetSwpHints()[ nAttrPos ] )->GetStart() ); |
| |
| // dann gebe mal alle gesammelten Attribute von der String-Pos aus |
| aEndPosLst.OutEndAttrs( rHTMLWrt, nStrPos + nOffset ); |
| aEndPosLst.OutStartAttrs( rHTMLWrt, nStrPos + nOffset ); |
| } |
| |
| sal_Bool bWriteBreak = (HTML_PREFORMTXT_ON != rHTMLWrt.nLastParaToken); |
| if( bWriteBreak && pNd->GetNumRule() ) |
| bWriteBreak = sal_False; |
| |
| { |
| HTMLOutContext aContext( rHTMLWrt.eDestEnc ); |
| |
| xub_StrLen nPreSplitPos = 0; |
| for( ; nStrPos < nEnde; nStrPos++ ) |
| { |
| aEndPosLst.OutEndAttrs( rHTMLWrt, nStrPos + nOffset, &aContext ); |
| |
| // Die an der aktuellen Position verankerten Rahmen ausgeben |
| if( bFlysLeft ) |
| bFlysLeft = rHTMLWrt.OutFlyFrm( rNode.GetIndex(), |
| nStrPos, HTML_POS_INSIDE, |
| &aContext ); |
| |
| sal_Bool bOutChar = sal_True; |
| const SwTxtAttr * pTxtHt = 0; |
| if( nAttrPos < nCntAttr && *pHt->GetStart() == nStrPos |
| && nStrPos != nEnde ) |
| { |
| do { |
| if ( pHt->End() && !pHt->HasDummyChar() ) |
| { |
| if( RES_CHRATR_KERNING == pHt->Which() && |
| rHTMLWrt.IsHTMLMode(HTMLMODE_FIRSTLINE) && |
| *pHt->End() - nStrPos == 1 && |
| ' ' == rStr.GetChar(nStrPos) && |
| ((const SvxKerningItem&)pHt->GetAttr()).GetValue() > 0 ) |
| { |
| // Wenn erlaubt, wird das Ding als Spacer exportiert |
| |
| bOutChar = sal_False; // Space nicht ausgeben |
| bWriteBreak = sal_False; // der Absatz ist aber auch nicht leer |
| HTMLOutFuncs::FlushToAscii( rWrt.Strm(), aContext ); |
| OutHTML_HoriSpacer( rWrt, |
| ((const SvxKerningItem&)pHt->GetAttr()).GetValue() ); |
| |
| // Der Hint braucht nun doch nicht weiter |
| // beruecksichtigt werden. |
| } |
| else if( *pHt->End() != nStrPos ) |
| { |
| // Hints mit Ende einsortieren, wenn sie keinen |
| // leeren Bereich aufspannen (Hints, die keinen |
| // Bereich aufspannen werden ignoriert |
| aEndPosLst.Insert( pHt->GetAttr(), nStrPos + nOffset, |
| *pHt->End() + nOffset, |
| rHTMLWrt.aChrFmtInfos ); |
| } |
| } |
| else |
| { |
| // Hints ohne-Ende werden als letztes ausgebeben |
| ASSERT( !pTxtHt, "Wieso gibt es da schon ein Attribut ohne Ende?" ); |
| if( rHTMLWrt.nTxtAttrsToIgnore>0 ) |
| { |
| rHTMLWrt.nTxtAttrsToIgnore--; |
| } |
| else |
| { |
| pTxtHt = pHt; |
| sal_uInt16 nFldWhich; |
| if( RES_TXTATR_FIELD != pHt->Which() |
| || ( RES_POSTITFLD != (nFldWhich = ((const SwFmtFld&)pHt->GetAttr()).GetField()->Which()) |
| && RES_SCRIPTFLD != nFldWhich ) ) |
| { |
| bWriteBreak = sal_False; |
| } |
| } |
| bOutChar = sal_False; // keine 255 ausgeben |
| } |
| } while( ++nAttrPos < nCntAttr && nStrPos == |
| *( pHt = pNd->GetSwpHints()[ nAttrPos ] )->GetStart() ); |
| } |
| |
| // Manche Draw-Formate koennen auch noch Attribute mitbringen |
| if( pTxtHt && RES_TXTATR_FLYCNT == pTxtHt->Which() ) |
| { |
| const SwFrmFmt* pFrmFmt = |
| ((const SwFmtFlyCnt &)pTxtHt->GetAttr()).GetFrmFmt(); |
| |
| if( RES_DRAWFRMFMT == pFrmFmt->Which() ) |
| aEndPosLst.Insert( *((const SwDrawFrmFmt *)pFrmFmt), |
| nStrPos + nOffset, |
| rHTMLWrt.aChrFmtInfos ); |
| } |
| |
| aEndPosLst.OutEndAttrs( rHTMLWrt, nStrPos + nOffset, &aContext ); |
| aEndPosLst.OutStartAttrs( rHTMLWrt, nStrPos + nOffset, &aContext ); |
| |
| if( pTxtHt ) |
| { |
| rHTMLWrt.bLFPossible = !rHTMLWrt.nLastParaToken && nStrPos > 0 && |
| rStr.GetChar(nStrPos-1) == ' '; |
| sal_uInt16 nCSS1Script = rHTMLWrt.nCSS1Script; |
| rHTMLWrt.nCSS1Script = aEndPosLst.GetScriptAtPos( |
| nStrPos + nOffset, nCSS1Script ); |
| HTMLOutFuncs::FlushToAscii( rWrt.Strm(), aContext ); |
| Out( aHTMLAttrFnTab, pTxtHt->GetAttr(), rHTMLWrt ); |
| rHTMLWrt.nCSS1Script = nCSS1Script; |
| rHTMLWrt.bLFPossible = sal_False; |
| } |
| |
| if( bOutChar ) |
| { |
| // #i120442#: get the UTF-32 codepoint by converting an eventual UTF-16 unicode surrogate pair |
| sal_uInt64 c = rStr.GetChar( nStrPos ); |
| if( nStrPos < nEnde - 1 ) |
| { |
| const sal_Unicode d = rStr.GetChar( nStrPos + 1 ); |
| if( (c >= 0xd800 && c <= 0xdbff) && (d >= 0xdc00 && d <= 0xdfff) ) |
| { |
| sal_uInt64 templow = d&0x03ff; |
| sal_uInt64 temphi = ((c&0x03ff) + 0x0040)<<10; |
| c = temphi|templow; |
| nStrPos++; |
| } |
| } |
| |
| // try to split a line after about 255 characters |
| // at a space character unless in a PRE-context |
| if( ' '==c && !rHTMLWrt.nLastParaToken ) |
| { |
| xub_StrLen nLineLen; |
| if( rHTMLWrt.nLastParaToken ) |
| nLineLen = nStrPos - nPreSplitPos; |
| else |
| nLineLen = rHTMLWrt.GetLineLen(); |
| |
| xub_StrLen nWordLen = rStr.Search( ' ', nStrPos+1 ); |
| if( nWordLen == STRING_NOTFOUND ) |
| nWordLen = nEnde; |
| nWordLen -= nStrPos; |
| |
| if( nLineLen >= rHTMLWrt.nWhishLineLen || |
| (nLineLen+nWordLen) >= rHTMLWrt.nWhishLineLen ) |
| { |
| HTMLOutFuncs::FlushToAscii( rWrt.Strm(), aContext ); |
| rHTMLWrt.OutNewLine(); |
| bOutChar = sal_False; |
| if( rHTMLWrt.nLastParaToken ) |
| nPreSplitPos = nStrPos+1; |
| } |
| } |
| |
| if( bOutChar ) |
| { |
| if( 0x0a == c ) |
| { |
| HTMLOutFuncs::FlushToAscii( rWrt.Strm(), aContext ); |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_linebreak ); |
| } |
| // #i120442#: if c is outside the unicode base plane output it as "&#******;" |
| else if( c > 0xffff) |
| { |
| ByteString sOut("&#"); |
| sOut += ByteString::CreateFromInt64( (sal_uInt64)c ); |
| sOut += ';'; |
| rWrt.Strm() << sOut.GetBuffer(); |
| } |
| else |
| HTMLOutFuncs::Out_Char( rWrt.Strm(), (sal_Unicode)c, aContext, &rHTMLWrt.aNonConvertableCharacters ); |
| |
| // if a paragraph's last character is a hard line break |
| // then we need to add an extra <br> |
| // because browsers like Mozilla wouldn't add a line for the next paragraph |
| bWriteBreak = (0x0a == c) && |
| (HTML_PREFORMTXT_ON != rHTMLWrt.nLastParaToken); |
| } |
| } |
| } |
| HTMLOutFuncs::FlushToAscii( rWrt.Strm(), aContext ); |
| } |
| |
| aEndPosLst.OutEndAttrs( rHTMLWrt, STRING_MAXLEN ); |
| |
| // Die an der letzten Position verankerten Rahmen ausgeben |
| if( bFlysLeft ) |
| bFlysLeft = rHTMLWrt.OutFlyFrm( rNode.GetIndex(), |
| nEnde, HTML_POS_INSIDE ); |
| ASSERT( !bFlysLeft, "Es wurden nicht alle Rahmen gespeichert!" ); |
| |
| rHTMLWrt.bTxtAttr = sal_False; |
| |
| if( bWriteBreak ) |
| { |
| sal_Bool bEndOfCell = rHTMLWrt.bOutTable && |
| rWrt.pCurPam->GetPoint()->nNode.GetIndex() == |
| rWrt.pCurPam->GetMark()->nNode.GetIndex(); |
| |
| if( bEndOfCell && !nEnde && |
| rHTMLWrt.IsHTMLMode(HTMLMODE_NBSP_IN_TABLES) ) |
| { |
| // Wenn der letzte Absatz einer Tabellezelle leer ist und |
| // wir fuer den MS-IE exportieren, schreiben wir statt eines |
| // <BR> ein |
| rWrt.Strm() << '&' << OOO_STRING_SVTOOLS_HTML_S_nbsp << ';'; |
| } |
| else |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_linebreak ); |
| const SvxULSpaceItem& rULSpace = |
| (const SvxULSpaceItem &)pNd->GetSwAttrSet().Get(RES_UL_SPACE); |
| if( rULSpace.GetLower() > 0 && !bEndOfCell && |
| !rHTMLWrt.IsHTMLMode(HTMLMODE_NO_BR_AT_PAREND) ) |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_linebreak ); |
| rHTMLWrt.bLFPossible = sal_True; |
| } |
| } |
| |
| if( rHTMLWrt.bClearLeft || rHTMLWrt.bClearRight ) |
| { |
| const sal_Char *pStr; |
| if( rHTMLWrt.bClearLeft ) |
| { |
| if( rHTMLWrt.bClearRight ) |
| pStr = OOO_STRING_SVTOOLS_HTML_AL_all; |
| else |
| pStr = OOO_STRING_SVTOOLS_HTML_AL_left; |
| } |
| else |
| pStr = OOO_STRING_SVTOOLS_HTML_AL_right; |
| |
| ByteString sOut( OOO_STRING_SVTOOLS_HTML_linebreak ); |
| (((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_clear) += '=') += pStr; |
| |
| HTMLOutFuncs::Out_AsciiTag( rHTMLWrt.Strm(), sOut.GetBuffer() ); |
| rHTMLWrt.bClearLeft = sal_False; |
| rHTMLWrt.bClearRight = sal_False; |
| |
| rHTMLWrt.bLFPossible = sal_True; |
| } |
| |
| // wenn ein LF nicht schon erlaubt ist wird es erlaubt, wenn der |
| // Absatz mit einem ' ' endet |
| if( !rHTMLWrt.bLFPossible && !rHTMLWrt.nLastParaToken && |
| nEnde > 0 && ' ' == rStr.GetChar(nEnde-1) ) |
| rHTMLWrt.bLFPossible = sal_True; |
| |
| rHTMLWrt.bTagOn = sal_False; |
| OutHTML_SwFmtOff( rWrt, aFmtInfo ); |
| |
| // eventuell eine Form schliessen |
| rHTMLWrt.OutForm( sal_False ); |
| |
| if( bPageBreakBehind ) |
| rWrt.Strm() << '\f'; |
| |
| return rHTMLWrt; |
| } |
| |
| |
| sal_uInt32 SwHTMLWriter::ToPixel( sal_uInt32 nVal ) const |
| { |
| if( Application::GetDefaultDevice() && nVal ) |
| { |
| nVal = Application::GetDefaultDevice()->LogicToPixel( |
| Size( nVal, nVal ), MapMode( MAP_TWIP ) ).Width(); |
| if( !nVal ) // wo ein Twip ist sollte auch ein Pixel sein |
| nVal = 1; |
| } |
| return nVal; |
| } |
| |
| |
| static Writer& OutHTML_CSS1Attr( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| // wenn gerade Hints geschrieben werden versuchen wir den Hint als |
| // CSS1-Attribut zu schreiben |
| |
| if( ((SwHTMLWriter&)rWrt).bCfgOutStyles && ((SwHTMLWriter&)rWrt).bTxtAttr ) |
| OutCSS1_HintSpanTag( rWrt, rHt ); |
| |
| return rWrt; |
| } |
| |
| |
| /* File CHRATR.HXX: */ |
| |
| static Writer& OutHTML_SvxColor( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| // die Default-Farbe nur Schreiben, wenn sie als Hint vorkommt |
| //if( rHTMLWrt.bTagOn && !rHTMLWrt.bTxtAttr && rHTMLWrt.pDfltColor |
| // && rColor == *rHTMLWrt.pDfltColor ) |
| // return rWrt; |
| |
| if( !rHTMLWrt.bTxtAttr && rHTMLWrt.bCfgOutStyles && rHTMLWrt.bCfgPreferStyles ) |
| { |
| // Font-Farbe nicht als Tag schreiben, wenn Styles normalen Tags |
| // vorgezogen werden |
| return rWrt; |
| } |
| |
| if( rHTMLWrt.bTagOn ) |
| { |
| Color aColor( ((const SvxColorItem&)rHt).GetValue() ); |
| if( COL_AUTO == aColor.GetColor() ) |
| aColor.SetColor( COL_BLACK ); |
| |
| ByteString sOut( '<' ); |
| (((sOut += OOO_STRING_SVTOOLS_HTML_font) += ' ') += OOO_STRING_SVTOOLS_HTML_O_color) += '='; |
| rWrt.Strm() << sOut.GetBuffer(); |
| HTMLOutFuncs::Out_Color( rWrt.Strm(), aColor, rHTMLWrt.eDestEnc ) << '>'; |
| } |
| else |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_font, sal_False ); |
| |
| return rWrt; |
| } |
| |
| |
| static Writer& OutHTML_SwPosture( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| const FontItalic nPosture = ((const SvxPostureItem&)rHt).GetPosture(); |
| if( ITALIC_NORMAL == nPosture ) |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_italic, rHTMLWrt.bTagOn ); |
| } |
| else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr ) |
| { |
| // vielleicht als CSS1-Attribut ? |
| OutCSS1_HintSpanTag( rWrt, rHt ); |
| } |
| |
| return rWrt; |
| } |
| |
| static Writer& OutHTML_SvxFont( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| if( rHTMLWrt.bTagOn ) |
| { |
| String aNames; |
| SwHTMLWriter::PrepareFontList( ((const SvxFontItem&)rHt), aNames, 0, |
| rHTMLWrt.IsHTMLMode(HTMLMODE_FONT_GENERIC) ); |
| ByteString sOut( '<' ); |
| (((sOut += OOO_STRING_SVTOOLS_HTML_font) += ' ') += OOO_STRING_SVTOOLS_HTML_O_face) += "=\""; |
| rWrt.Strm() << sOut.GetBuffer(); |
| HTMLOutFuncs::Out_String( rWrt.Strm(), aNames, rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters ) |
| << "\">"; |
| } |
| else |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_font , sal_False ); |
| |
| return rWrt; |
| } |
| |
| static Writer& OutHTML_SvxFontHeight( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| if( rHTMLWrt.bTagOn ) |
| { |
| ByteString sOut( '<' ); |
| sOut += OOO_STRING_SVTOOLS_HTML_font; |
| |
| sal_uInt32 nHeight = ((const SvxFontHeightItem&)rHt).GetHeight(); |
| sal_uInt16 nSize = rHTMLWrt.GetHTMLFontSize( nHeight ); |
| (((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_size) += '=') |
| += ByteString::CreateFromInt32( nSize ); |
| rWrt.Strm() << sOut.GetBuffer(); |
| |
| if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr && |
| rHTMLWrt.aFontHeights[nSize-1] != nHeight ) |
| { |
| // wenn die Groesse keiner HTML-Groesse entspricht, |
| // wird sie noch zusatzlich als Style-Option exportiert |
| OutCSS1_HintStyleOpt( rWrt, rHt ); |
| } |
| rWrt.Strm() << '>'; |
| } |
| else |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_font, sal_False ); |
| } |
| |
| return rWrt; |
| } |
| |
| static Writer& OutHTML_SvxLanguage( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| LanguageType eLang = ((const SvxLanguageItem &)rHt).GetLanguage(); |
| if( LANGUAGE_DONTKNOW == eLang ) |
| return rWrt; |
| |
| if( rHTMLWrt.bTagOn ) |
| { |
| ByteString sOut( '<' ); |
| sOut += OOO_STRING_SVTOOLS_HTML_span; |
| rWrt.Strm() << sOut.GetBuffer(); |
| rHTMLWrt.OutLanguage( ((const SvxLanguageItem &)rHt).GetLanguage() ); |
| rWrt.Strm() << '>'; |
| } |
| else |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_span, sal_False ); |
| } |
| |
| return rWrt; |
| } |
| static Writer& OutHTML_SwWeight( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| const FontWeight nBold = ((const SvxWeightItem&)rHt).GetWeight(); |
| if( WEIGHT_BOLD == nBold ) |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_bold, rHTMLWrt.bTagOn ); |
| } |
| else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr ) |
| { |
| // vielleicht als CSS1-Attribut ? |
| OutCSS1_HintSpanTag( rWrt, rHt ); |
| } |
| |
| return rWrt; |
| } |
| |
| |
| static Writer& OutHTML_SwCrossedOut( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| // Wegen Netscape schrieben wir hier STRIKE und nicht S raus! |
| const FontStrikeout nStrike = ((const SvxCrossedOutItem&)rHt).GetStrikeout(); |
| if( STRIKEOUT_NONE != nStrike ) |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_strike, rHTMLWrt.bTagOn ); |
| } |
| else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr ) |
| { |
| // vielleicht als CSS1-Attribut ? |
| OutCSS1_HintSpanTag( rWrt, rHt ); |
| } |
| |
| return rWrt; |
| } |
| |
| |
| static Writer& OutHTML_SvxEscapement( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| const SvxEscapement eEscape = |
| (const SvxEscapement)((const SvxEscapementItem&)rHt).GetEnumValue(); |
| const sal_Char *pStr = 0; |
| switch( eEscape ) |
| { |
| case SVX_ESCAPEMENT_SUPERSCRIPT: pStr = OOO_STRING_SVTOOLS_HTML_superscript; break; |
| case SVX_ESCAPEMENT_SUBSCRIPT: pStr = OOO_STRING_SVTOOLS_HTML_subscript; break; |
| default: |
| ; |
| } |
| |
| if( pStr ) |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), pStr, rHTMLWrt.bTagOn ); |
| } |
| else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr ) |
| { |
| // vielleicht als CSS1-Attribut ? |
| OutCSS1_HintSpanTag( rWrt, rHt ); |
| } |
| |
| return rWrt; |
| } |
| |
| |
| |
| static Writer& OutHTML_SwUnderline( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| const FontUnderline eUnder = ((const SvxUnderlineItem&)rHt).GetLineStyle(); |
| if( UNDERLINE_NONE != eUnder ) |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_underline, rHTMLWrt.bTagOn ); |
| } |
| else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr ) |
| { |
| // vielleicht als CSS1-Attribut ? |
| OutCSS1_HintSpanTag( rWrt, rHt ); |
| } |
| |
| return rWrt; |
| } |
| |
| |
| static Writer& OutHTML_SwFlyCnt( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt; |
| SwFmtFlyCnt& rFlyCnt = (SwFmtFlyCnt&)rHt; |
| |
| const SwFrmFmt& rFmt = *rFlyCnt.GetFrmFmt(); |
| const SdrObject *pSdrObj = 0; |
| |
| SwHTMLFrmType eType = |
| (SwHTMLFrmType)rHTMLWrt.GuessFrmType( rFmt, pSdrObj ); |
| sal_uInt8 nMode = aHTMLOutFrmAsCharTable[eType][rHTMLWrt.nExportMode]; |
| rHTMLWrt.OutFrmFmt( nMode, rFmt, pSdrObj ); |
| return rWrt; |
| } |
| |
| |
| // Das ist jetzt unser Blink-Item. Blinkend wird eingeschaltet, indem man |
| // das Item auf sal_True setzt! |
| static Writer& OutHTML_SwBlink( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts || !rHTMLWrt.IsHTMLMode(HTMLMODE_BLINK) ) |
| return rWrt; |
| |
| if( ((const SvxBlinkItem&)rHt).GetValue() ) |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_blink, rHTMLWrt.bTagOn ); |
| } |
| else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr ) |
| { |
| // vielleicht als CSS1-Attribut ? |
| OutCSS1_HintSpanTag( rWrt, rHt ); |
| } |
| |
| return rWrt; |
| } |
| |
| Writer& OutHTML_INetFmt( Writer& rWrt, const SwFmtINetFmt& rINetFmt, sal_Bool bOn ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| |
| String aURL( rINetFmt.GetValue() ); |
| const SvxMacroTableDtor *pMacTable = rINetFmt.GetMacroTbl(); |
| sal_Bool bEvents = pMacTable != 0 && pMacTable->Count() > 0; |
| |
| // Gibt es ueberhaupt etwas auszugeben? |
| if( !aURL.Len() && !bEvents && !rINetFmt.GetName().Len() ) |
| return rWrt; |
| |
| // Tag aus? Dann nur ein </A> ausgeben. |
| if( !bOn ) |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_anchor, sal_False ); |
| return rWrt; |
| } |
| |
| ByteString sOut( '<' ); |
| sOut += OOO_STRING_SVTOOLS_HTML_anchor; |
| |
| sal_Bool bScriptDependent = sal_False; |
| { |
| const SwCharFmt* pFmt = rWrt.pDoc->GetCharFmtFromPool( |
| RES_POOLCHR_INET_NORMAL ); |
| SwHTMLFmtInfo aFmtInfo( pFmt ); |
| sal_uInt16 nPos; |
| if( rHTMLWrt.aChrFmtInfos.Seek_Entry( &aFmtInfo, &nPos ) ) |
| { |
| bScriptDependent = rHTMLWrt.aChrFmtInfos[nPos]->bScriptDependent; |
| } |
| } |
| if( !bScriptDependent ) |
| { |
| const SwCharFmt* pFmt = rWrt.pDoc->GetCharFmtFromPool( |
| RES_POOLCHR_INET_VISIT ); |
| SwHTMLFmtInfo aFmtInfo( pFmt ); |
| sal_uInt16 nPos; |
| if( rHTMLWrt.aChrFmtInfos.Seek_Entry( &aFmtInfo, &nPos ) ) |
| { |
| bScriptDependent = rHTMLWrt.aChrFmtInfos[nPos]->bScriptDependent; |
| } |
| } |
| |
| if( bScriptDependent ) |
| { |
| ((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_class) += "=\""; |
| switch( rHTMLWrt.nCSS1Script ) |
| { |
| case CSS1_OUTMODE_WESTERN: |
| sOut += "western"; |
| break; |
| case CSS1_OUTMODE_CJK: |
| sOut += "cjk"; |
| break; |
| case CSS1_OUTMODE_CTL: |
| sOut += "ctl"; |
| break; |
| } |
| sOut += '\"'; |
| } |
| |
| rWrt.Strm() << sOut.GetBuffer(); |
| |
| #define REL_HACK |
| #ifdef REL_HACK |
| String sRel; |
| #endif |
| |
| if( aURL.Len() || bEvents ) |
| { |
| #ifdef REL_HACK |
| String sTmp( aURL ); |
| sTmp.ToUpperAscii(); |
| xub_StrLen nPos = sTmp.SearchAscii( "\" REL=" ); |
| if( nPos!=STRING_NOTFOUND ) |
| { |
| sRel = aURL.Copy( nPos+1 ); |
| aURL.Erase( nPos ); |
| } |
| #endif |
| aURL.EraseLeadingChars().EraseTrailingChars(); |
| |
| ((sOut = ' ') += OOO_STRING_SVTOOLS_HTML_O_href) += "=\""; |
| rWrt.Strm() << sOut.GetBuffer(); |
| rHTMLWrt.OutHyperlinkHRefValue( aURL ); |
| sOut = '\"'; |
| } |
| else |
| sOut.Erase(); |
| |
| if( rINetFmt.GetName().Len() ) |
| { |
| ((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_name) += "=\""; |
| rWrt.Strm() << sOut.GetBuffer(); |
| HTMLOutFuncs::Out_String( rWrt.Strm(), rINetFmt.GetName(), |
| rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters ); |
| sOut = '\"'; |
| } |
| |
| const String& rTarget = rINetFmt.GetTargetFrame(); |
| if( rTarget.Len() ) |
| { |
| ((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_target) += "=\""; |
| rWrt.Strm() << sOut.GetBuffer(); |
| HTMLOutFuncs::Out_String( rWrt.Strm(), rTarget, rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters ); |
| sOut = '\"'; |
| } |
| |
| #ifdef REL_HACK |
| if( sRel.Len() ) |
| sOut += ByteString( sRel, RTL_TEXTENCODING_ASCII_US ); |
| #endif |
| if( sOut.Len() ) |
| rWrt.Strm() << sOut.GetBuffer(); |
| |
| if( bEvents ) |
| HTMLOutFuncs::Out_Events( rWrt.Strm(), *pMacTable, aAnchorEventTable, |
| rHTMLWrt.bCfgStarBasic, rHTMLWrt.eDestEnc, |
| &rHTMLWrt.aNonConvertableCharacters ); |
| rWrt.Strm() << ">"; |
| |
| return rWrt; |
| } |
| |
| static Writer& OutHTML_SwFmtINetFmt( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| const SwFmtINetFmt& rINetFmt = (const SwFmtINetFmt&)rHt; |
| |
| if( rHTMLWrt.bTagOn ) |
| { |
| // ggf. ein noch offenes Attribut voruebergehend beenden |
| if( rHTMLWrt.aINetFmts.Count() ) |
| { |
| SwFmtINetFmt *pINetFmt = |
| rHTMLWrt.aINetFmts[ rHTMLWrt.aINetFmts.Count()-1 ]; |
| OutHTML_INetFmt( rWrt, *pINetFmt, sal_False ); |
| } |
| |
| // jetzt das neue aufmachen |
| OutHTML_INetFmt( rWrt, rINetFmt, sal_True ); |
| |
| // und merken |
| const SwFmtINetFmt *pINetFmt = new SwFmtINetFmt( rINetFmt ); |
| rHTMLWrt.aINetFmts.C40_INSERT( SwFmtINetFmt, pINetFmt, |
| rHTMLWrt.aINetFmts.Count() ); |
| } |
| else |
| { |
| // das |
| OutHTML_INetFmt( rWrt, rINetFmt, sal_False ); |
| |
| ASSERT( rHTMLWrt.aINetFmts.Count(), "da fehlt doch ein URL-Attribut" ); |
| if( rHTMLWrt.aINetFmts.Count() ) |
| { |
| // das eigene Attribut vom Stack holen |
| SwFmtINetFmt *pINetFmt = |
| rHTMLWrt.aINetFmts[ rHTMLWrt.aINetFmts.Count()-1 ]; |
| |
| rHTMLWrt.aINetFmts.Remove( rHTMLWrt.aINetFmts.Count()-1, 1 ); |
| delete pINetFmt; |
| } |
| |
| if( rHTMLWrt.aINetFmts.Count() ) |
| { |
| // es ist noch ein Attribut auf dem Stack, das wieder geoeffnet |
| // werden muss |
| SwFmtINetFmt *pINetFmt = |
| rHTMLWrt.aINetFmts[ rHTMLWrt.aINetFmts.Count()-1 ]; |
| OutHTML_INetFmt( rWrt, *pINetFmt, sal_True ); |
| } |
| } |
| |
| return rWrt; |
| } |
| |
| static Writer& OutHTML_SwTxtCharFmt( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( rHTMLWrt.bOutOpts ) |
| return rWrt; |
| |
| const SwFmtCharFmt& rChrFmt = (const SwFmtCharFmt&)rHt; |
| const SwCharFmt* pFmt = rChrFmt.GetCharFmt(); |
| |
| if( !pFmt ) |
| { |
| return rWrt; |
| } |
| |
| SwHTMLFmtInfo aFmtInfo( pFmt ); |
| sal_uInt16 nPos; |
| if( !rHTMLWrt.aChrFmtInfos.Seek_Entry( &aFmtInfo, &nPos ) ) |
| return rWrt; |
| |
| const SwHTMLFmtInfo *pFmtInfo = rHTMLWrt.aChrFmtInfos[nPos]; |
| ASSERT( pFmtInfo, "Wieso gint es keine Infos ueber die Zeichenvorlage?" ); |
| |
| if( rHTMLWrt.bTagOn ) |
| { |
| ByteString sOut( '<' ); |
| if( pFmtInfo->aToken.Len() > 0 ) |
| sOut += pFmtInfo->aToken; |
| else |
| sOut += OOO_STRING_SVTOOLS_HTML_span; |
| if( rHTMLWrt.bCfgOutStyles && |
| (pFmtInfo->aClass.Len() || pFmtInfo->bScriptDependent) ) |
| { |
| ((sOut += ' ') += OOO_STRING_SVTOOLS_HTML_O_class) += "=\""; |
| rWrt.Strm() << sOut.GetBuffer(); |
| String aClass( pFmtInfo->aClass ); |
| if( pFmtInfo->bScriptDependent ) |
| { |
| if( aClass.Len() ) |
| aClass += '-'; |
| switch( rHTMLWrt.nCSS1Script ) |
| { |
| case CSS1_OUTMODE_WESTERN: |
| aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("western") ); |
| break; |
| case CSS1_OUTMODE_CJK: |
| aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("cjk") ); |
| break; |
| case CSS1_OUTMODE_CTL: |
| aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("ctl") ); |
| break; |
| } |
| } |
| HTMLOutFuncs::Out_String( rWrt.Strm(), aClass, |
| rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters ); |
| sOut = '\"'; |
| } |
| sOut += '>'; |
| rWrt.Strm() << sOut.GetBuffer(); |
| } |
| else |
| { |
| HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), |
| pFmtInfo->aToken.Len() ? pFmtInfo->aToken.GetBuffer() |
| : OOO_STRING_SVTOOLS_HTML_span, |
| sal_False ); |
| } |
| |
| return rWrt; |
| } |
| |
| static Writer& OutHTML_SvxAdjust( Writer& rWrt, const SfxPoolItem& rHt ) |
| { |
| SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt; |
| if( !rHTMLWrt.bOutOpts || !rHTMLWrt.bTagOn ) |
| return rWrt; |
| |
| SvxAdjustItem& rAdjust = (SvxAdjustItem&)rHt; |
| const sal_Char* pStr = 0; |
| switch( rAdjust.GetAdjust() ) |
| { |
| case SVX_ADJUST_CENTER: pStr = OOO_STRING_SVTOOLS_HTML_AL_center; break; |
| case SVX_ADJUST_LEFT: pStr = OOO_STRING_SVTOOLS_HTML_AL_left; break; |
| case SVX_ADJUST_RIGHT: pStr = OOO_STRING_SVTOOLS_HTML_AL_right; break; |
| case SVX_ADJUST_BLOCK: pStr = OOO_STRING_SVTOOLS_HTML_AL_justify; break; |
| default: |
| ; |
| } |
| if( pStr ) |
| { |
| ByteString sOut( ' ' ); |
| ((sOut += OOO_STRING_SVTOOLS_HTML_O_align) += '=') += pStr; |
| rWrt.Strm() << sOut.GetBuffer(); |
| } |
| |
| return rWrt; |
| } |
| |
| /* |
| * lege hier die Tabellen fuer die HTML-Funktions-Pointer auf |
| * die Ausgabe-Funktionen an. |
| * Es sind lokale Strukturen, die nur innerhalb der HTML-DLL |
| * bekannt sein muessen. |
| */ |
| |
| |
| SwAttrFnTab aHTMLAttrFnTab = { |
| /* RES_CHRATR_CASEMAP */ OutHTML_CSS1Attr, |
| /* RES_CHRATR_CHARSETCOLOR */ 0, |
| /* RES_CHRATR_COLOR */ OutHTML_SvxColor, |
| /* RES_CHRATR_CONTOUR */ 0, |
| /* RES_CHRATR_CROSSEDOUT */ OutHTML_SwCrossedOut, |
| /* RES_CHRATR_ESCAPEMENT */ OutHTML_SvxEscapement, |
| /* RES_CHRATR_FONT */ OutHTML_SvxFont, |
| /* RES_CHRATR_FONTSIZE */ OutHTML_SvxFontHeight, |
| /* RES_CHRATR_KERNING */ OutHTML_CSS1Attr, |
| /* RES_CHRATR_LANGUAGE */ OutHTML_SvxLanguage, |
| /* RES_CHRATR_POSTURE */ OutHTML_SwPosture, |
| /* RES_CHRATR_PROPORTIONALFONTSIZE*/0, |
| /* RES_CHRATR_SHADOWED */ 0, |
| /* RES_CHRATR_UNDERLINE */ OutHTML_SwUnderline, |
| /* RES_CHRATR_WEIGHT */ OutHTML_SwWeight, |
| /* RES_CHRATR_WORDLINEMODE */ 0, |
| /* RES_CHRATR_AUTOKERN */ 0, |
| /* RES_CHRATR_BLINK */ OutHTML_SwBlink, |
| /* RES_CHRATR_NOHYPHEN */ 0, // Neu: nicht trennen |
| /* RES_CHRATR_NOLINEBREAK */ 0, // Neu: nicht umbrechen |
| /* RES_CHRATR_BACKGROUND */ OutHTML_CSS1Attr, // Neu: Zeichenhintergrund |
| /* RES_CHRATR_CJK_FONT */ OutHTML_SvxFont, |
| /* RES_CHRATR_CJK_FONTSIZE */ OutHTML_SvxFontHeight, |
| /* RES_CHRATR_CJK_LANGUAGE */ OutHTML_SvxLanguage, |
| /* RES_CHRATR_CJK_POSTURE */ OutHTML_SwPosture, |
| /* RES_CHRATR_CJK_WEIGHT */ OutHTML_SwWeight, |
| /* RES_CHRATR_CTL_FONT */ OutHTML_SvxFont, |
| /* RES_CHRATR_CTL_FONTSIZE */ OutHTML_SvxFontHeight, |
| /* RES_CHRATR_CTL_LANGUAGE */ OutHTML_SvxLanguage, |
| /* RES_CHRATR_CTL_POSTURE */ OutHTML_SwPosture, |
| /* RES_CHRATR_CTL_WEIGHT */ OutHTML_SwWeight, |
| /* RES_CHRATR_ROTATE */ 0, |
| /* RES_CHRATR_EMPHASIS_MARK */ 0, |
| /* RES_CHRATR_TWO_LINES */ 0, |
| /* RES_CHRATR_SCALEW */ 0, |
| /* RES_CHRATR_RELIEF */ 0, |
| /* RES_CHRATR_HIDDEN */ 0, |
| /* RES_CHRATR_OVERLINE */ OutHTML_CSS1Attr, |
| /* RES_CHRATR_DUMMY1 */ 0, |
| /* RES_CHRATR_DUMMY2 */ 0, |
| //For i120935, Insert blank entry for RES_CHRATR_BIDITRL and RES_CHRATR_IDCTHINT, for keep the identical res order |
| /*RES_CHRATR_BIDIRTL*/ 0, |
| /*RES_CHRATR_IDCTHINT*/ 0, |
| /* RES_TXTATR_REFMARK */ 0, |
| /* RES_TXTATR_TOXMARK */ 0, |
| /* RES_TXTATR_META */ 0, |
| /* RES_TXTATR_METAFIELD */ 0, |
| /* RES_TXTATR_AUTOFMT */ 0, |
| /* RES_TXTATR_INETFMT */ OutHTML_SwFmtINetFmt, |
| /* RES_TXTATR_CHARFMT */ OutHTML_SwTxtCharFmt, |
| /* RES_TXTATR_CJK_RUBY */ 0, |
| /* RES_TXTATR_UNKNOWN_CONTAINER */ 0, |
| /* RES_TXTATR_INPUTFIELD */ OutHTML_SwFmtFld, |
| |
| /* RES_TXTATR_FIELD */ OutHTML_SwFmtFld, |
| /* RES_TXTATR_FLYCNT */ OutHTML_SwFlyCnt, |
| /* RES_TXTATR_FTN */ OutHTML_SwFmtFtn, |
| /* RES_TXTATR_ANNOTATION */ OutHTML_SwFmtFld, |
| /* RES_TXTATR_DUMMY3 */ 0, |
| /* RES_TXTATR_DUMMY1 */ 0, // Dummy: |
| /* RES_TXTATR_DUMMY2 */ 0, // Dummy: |
| |
| /* RES_PARATR_LINESPACING */ 0, |
| /* RES_PARATR_ADJUST */ OutHTML_SvxAdjust, |
| /* RES_PARATR_SPLIT */ 0, |
| /* RES_PARATR_WIDOWS */ 0, |
| /* RES_PARATR_ORPHANS */ 0, |
| /* RES_PARATR_TABSTOP */ 0, |
| /* RES_PARATR_HYPHENZONE*/ 0, |
| /* RES_PARATR_DROP */ OutHTML_CSS1Attr, |
| /* RES_PARATR_REGISTER */ 0, // neu: Registerhaltigkeit |
| /* RES_PARATR_NUMRULE */ 0, // Dummy: |
| /* RES_PARATR_SCRIPTSPACE */ 0, // Dummy: |
| /* RES_PARATR_HANGINGPUNCTUATION */ 0, // Dummy: |
| /* RES_PARATR_FORBIDDEN_RULES */ 0, // new |
| /* RES_PARATR_VERTALIGN */ 0, // new |
| /* RES_PARATR_SNAPTOGRID*/ 0, // new |
| /* RES_PARATR_CONNECT_TO_BORDER */ 0, // new |
| |
| /* RES_PARATR_LIST_ID */ 0, // new |
| /* RES_PARATR_LIST_LEVEL */ 0, // new |
| /* RES_PARATR_LIST_ISRESTART */ 0, // new |
| /* RES_PARATR_LIST_RESTARTVALUE */ 0, // new |
| /* RES_PARATR_LIST_ISCOUNTED */ 0, // new |
| |
| /* RES_FILL_ORDER */ 0, |
| /* RES_FRM_SIZE */ 0, |
| /* RES_PAPER_BIN */ 0, |
| /* RES_LR_SPACE */ 0, |
| /* RES_UL_SPACE */ 0, |
| /* RES_PAGEDESC */ 0, |
| /* RES_BREAK */ 0, |
| /* RES_CNTNT */ 0, |
| /* RES_HEADER */ 0, |
| /* RES_FOOTER */ 0, |
| /* RES_PRINT */ 0, |
| /* RES_OPAQUE */ 0, |
| /* RES_PROTECT */ 0, |
| /* RES_SURROUND */ 0, |
| /* RES_VERT_ORIENT */ 0, |
| /* RES_HORI_ORIENT */ 0, |
| /* RES_ANCHOR */ 0, |
| /* RES_BACKGROUND */ 0, |
| /* RES_BOX */ 0, |
| /* RES_SHADOW */ 0, |
| /* RES_FRMMACRO */ 0, |
| /* RES_COL */ 0, |
| /* RES_KEEP */ 0, |
| /* RES_URL */ 0, |
| /* RES_EDIT_IN_READONLY */ 0, |
| /* RES_LAYOUT_SPLIT */ 0, |
| /* RES_FRMATR_DUMMY1 */ 0, // Dummy: |
| /* RES_FRMATR_DUMMY2 */ 0, // Dummy: |
| /* RES_AUTO_STYLE */ 0, // Dummy: |
| /* RES_FRMATR_DUMMY4 */ 0, // Dummy: |
| /* RES_FRMATR_DUMMY5 */ 0, // Dummy: |
| /* RES_FRMATR_DUMMY6 */ 0, // Dummy: |
| /* RES_FRMATR_DUMMY7 */ 0, // Dummy: |
| /* RES_FRMATR_DUMMY8 */ 0, // Dummy: |
| /* RES_FRMATR_DUMMY9 */ 0, // Dummy: |
| /* RES_FOLLOW_TEXT_FLOW */ 0, |
| /* RES_WRAP_INFLUENCE_ON_OBJPOS */ 0, |
| /* RES_FRMATR_DUMMY2 */ 0, // Dummy: |
| /* RES_AUTO_STYLE */ 0, // Dummy: |
| /* RES_FRMATR_DUMMY4 */ 0, // Dummy: |
| /* RES_FRMATR_DUMMY5 */ 0, // Dummy: |
| |
| /* RES_GRFATR_MIRRORGRF */ 0, |
| /* RES_GRFATR_CROPGRF */ 0, |
| /* RES_GRFATR_ROTATION */ 0, |
| /* RES_GRFATR_LUMINANCE */ 0, |
| /* RES_GRFATR_CONTRAST */ 0, |
| /* RES_GRFATR_CHANNELR */ 0, |
| /* RES_GRFATR_CHANNELG */ 0, |
| /* RES_GRFATR_CHANNELB */ 0, |
| /* RES_GRFATR_GAMMA */ 0, |
| /* RES_GRFATR_INVERT */ 0, |
| /* RES_GRFATR_TRANSPARENCY */ 0, |
| /* RES_GRFATR_DRWAMODE */ 0, |
| /* RES_GRFATR_DUMMY1 */ 0, |
| /* RES_GRFATR_DUMMY2 */ 0, |
| /* RES_GRFATR_DUMMY3 */ 0, |
| /* RES_GRFATR_DUMMY4 */ 0, |
| /* RES_GRFATR_DUMMY5 */ 0, |
| |
| /* RES_BOXATR_FORMAT */ 0, |
| /* RES_BOXATR_FORMULA */ 0, |
| /* RES_BOXATR_VALUE */ 0 |
| }; |
