Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <hintids.hxx>
21 : #include <com/sun/star/i18n/ScriptType.hpp>
22 : #include <comphelper/string.hxx>
23 : #include <vcl/svapp.hxx>
24 : #include <vcl/wrkwin.hxx>
25 : #include <sfx2/sfx.hrc>
26 : #include <svtools/htmlout.hxx>
27 : #include <svtools/htmlkywd.hxx>
28 : #include <svtools/htmltokn.h>
29 : #include <svl/whiter.hxx>
30 : #include <sfx2/htmlmode.hxx>
31 : #include <editeng/escapementitem.hxx>
32 : #include <editeng/formatbreakitem.hxx>
33 : #include <editeng/boxitem.hxx>
34 : #include <editeng/ulspitem.hxx>
35 : #include <editeng/udlnitem.hxx>
36 : #include <editeng/crossedoutitem.hxx>
37 : #include <editeng/blinkitem.hxx>
38 : #include <editeng/cmapitem.hxx>
39 : #include <editeng/colritem.hxx>
40 : #include <editeng/fontitem.hxx>
41 : #include <editeng/fhgtitem.hxx>
42 : #include <editeng/postitem.hxx>
43 : #include <editeng/kernitem.hxx>
44 : #include <editeng/wghtitem.hxx>
45 : #include <editeng/lspcitem.hxx>
46 : #include <editeng/adjustitem.hxx>
47 : #include <editeng/lrspitem.hxx>
48 : #include <editeng/brushitem.hxx>
49 : #include <editeng/langitem.hxx>
50 : #include <editeng/frmdiritem.hxx>
51 : #include <fchrfmt.hxx>
52 : #include <fmtautofmt.hxx>
53 : #include <fmtfsize.hxx>
54 : #include <fmtclds.hxx>
55 : #include <fmtpdsc.hxx>
56 : #include <fmtflcnt.hxx>
57 : #include <fmtinfmt.hxx>
58 : #include <fmtftn.hxx>
59 : #include <txatbase.hxx>
60 : #include <frmatr.hxx>
61 : #include <charfmt.hxx>
62 : #include <fmtfld.hxx>
63 : #include <doc.hxx>
64 : #include <pam.hxx>
65 : #include <ndtxt.hxx>
66 : #include <paratr.hxx>
67 : #include <poolfmt.hxx>
68 : #include <pagedesc.hxx>
69 : #include <swtable.hxx>
70 : #include "fldbas.hxx"
71 : #include <breakit.hxx>
72 : #include <htmlnum.hxx>
73 : #include <wrthtml.hxx>
74 : #include <htmlfly.hxx>
75 : #include <numrule.hxx>
76 : #include <rtl/strbuf.hxx>
77 :
78 : using namespace ::com::sun::star;
79 :
80 : HTMLOutEvent aAnchorEventTable[] =
81 : {
82 : { OOO_STRING_SVTOOLS_HTML_O_SDonclick, OOO_STRING_SVTOOLS_HTML_O_onclick, SFX_EVENT_MOUSECLICK_OBJECT },
83 : { OOO_STRING_SVTOOLS_HTML_O_SDonmouseover, OOO_STRING_SVTOOLS_HTML_O_onmouseover, SFX_EVENT_MOUSEOVER_OBJECT },
84 : { OOO_STRING_SVTOOLS_HTML_O_SDonmouseout, OOO_STRING_SVTOOLS_HTML_O_onmouseout, SFX_EVENT_MOUSEOUT_OBJECT },
85 : { 0, 0, 0 }
86 : };
87 :
88 : static Writer& OutHTML_SvxAdjust( Writer& rWrt, const SfxPoolItem& rHt );
89 :
90 0 : sal_uInt16 SwHTMLWriter::GetDefListLvl( const String& rNm, sal_uInt16 nPoolId )
91 : {
92 0 : if( nPoolId == RES_POOLCOLL_HTML_DD )
93 : {
94 0 : return 1 | HTML_DLCOLL_DD;
95 : }
96 0 : else if( nPoolId == RES_POOLCOLL_HTML_DT )
97 : {
98 0 : return 1 | HTML_DLCOLL_DT;
99 : }
100 :
101 0 : String sDTDD( OUString(OOO_STRING_SVTOOLS_HTML_dt) );
102 0 : sDTDD += ' ';
103 0 : if( COMPARE_EQUAL == sDTDD.CompareTo( rNm, sDTDD.Len() ) )
104 : // DefinitionList - term
105 0 : return (sal_uInt16)rNm.Copy( sDTDD.Len() ).ToInt32() | HTML_DLCOLL_DT;
106 :
107 0 : sDTDD.AssignAscii( OOO_STRING_SVTOOLS_HTML_dd );
108 0 : sDTDD += ' ';
109 0 : if( COMPARE_EQUAL == sDTDD.CompareTo( rNm, sDTDD.Len() ) )
110 : // DefinitionList - definition
111 0 : return (sal_uInt16)rNm.Copy( sDTDD.Len() ).ToInt32() | HTML_DLCOLL_DD;
112 :
113 0 : return 0;
114 : }
115 :
116 262 : void SwHTMLWriter::OutAndSetDefList( sal_uInt16 nNewLvl )
117 : {
118 : // eventuell muss erst mal eine Liste aufgemacht werden
119 262 : if( nDefListLvl < nNewLvl )
120 : {
121 : // output </pre> for the previous(!) pararagraph, if required.
122 : // Preferable, the <pre> is exported by OutHTML_SwFmtOff for the
123 : // previous paragraph already, but that's not possible, because a very
124 : // deep look at the next paragraph (this one) is required to figure
125 : // out that a def list starts here.
126 :
127 0 : ChangeParaToken( 0 );
128 :
129 : // entsprechend dem Level-Unterschied schreiben!
130 0 : for( sal_uInt16 i=nDefListLvl; i<nNewLvl; i++ )
131 : {
132 0 : if( bLFPossible )
133 0 : OutNewLine();
134 0 : HTMLOutFuncs::Out_AsciiTag( Strm(), OOO_STRING_SVTOOLS_HTML_deflist, sal_True );
135 0 : IncIndentLevel();
136 0 : bLFPossible = sal_True;
137 : }
138 : }
139 262 : else if( nDefListLvl > nNewLvl )
140 : {
141 0 : for( sal_uInt16 i=nNewLvl ; i < nDefListLvl; i++ )
142 : {
143 0 : DecIndentLevel();
144 0 : if( bLFPossible )
145 0 : OutNewLine();
146 0 : HTMLOutFuncs::Out_AsciiTag( Strm(), OOO_STRING_SVTOOLS_HTML_deflist, sal_False );
147 0 : bLFPossible = sal_True;
148 : }
149 : }
150 :
151 262 : nDefListLvl = nNewLvl;
152 262 : }
153 :
154 :
155 526 : void SwHTMLWriter::ChangeParaToken( sal_uInt16 nNew )
156 : {
157 526 : if( nNew != nLastParaToken && HTML_PREFORMTXT_ON == nLastParaToken )
158 : {
159 0 : HTMLOutFuncs::Out_AsciiTag( Strm(), OOO_STRING_SVTOOLS_HTML_preformtxt, sal_False );
160 0 : bLFPossible = sal_True;
161 : }
162 526 : nLastParaToken = nNew;
163 526 : }
164 :
165 0 : sal_uInt16 SwHTMLWriter::GetCSS1ScriptForScriptType( sal_uInt16 nScriptType )
166 : {
167 0 : sal_uInt16 nRet = CSS1_OUTMODE_ANY_SCRIPT;
168 :
169 0 : switch( nScriptType )
170 : {
171 : case i18n::ScriptType::LATIN:
172 0 : nRet = CSS1_OUTMODE_WESTERN;
173 0 : break;
174 : case i18n::ScriptType::ASIAN:
175 0 : nRet = CSS1_OUTMODE_CJK;
176 0 : break;
177 : case i18n::ScriptType::COMPLEX:
178 0 : nRet = CSS1_OUTMODE_CTL;
179 0 : break;
180 : }
181 :
182 0 : return nRet;
183 : }
184 :
185 : // fuer die Formate muesste eine einzige Ausgabe-Funktion genuegen !
186 : /*
187 : * Formate wie folgt ausgeben:
188 : * - fuer Formate, fuer die es entsprechende HTML-Tags gibt wird das
189 : * Tag ausgegeben
190 : * - fuer alle anderen wird ein Absatz-Tag <P> ausgegeben und bUserFmt
191 : * gesetzt
192 : * - Wenn eine Absatz-Ausrichtung am uebergebenen Item-Set des Nodes
193 : * oder im Item-Set des Format gesetzt ist, wird ein ALIGN=xxx ausgegeben,
194 : * sofern HTML es zulaesst
195 : * - in jedem Fall wird harte Attributierung als STYLE-Option geschrieben.
196 : * Wenn bUserFmt nicht gesetzt ist, wird nur der uebergebene Item-Set
197 : * betrachtet. Sonst werden auch Attribute des Formats ausgegeben.
198 : */
199 :
200 : struct SwHTMLTxtCollOutputInfo
201 : {
202 : OString aToken; // auszugendens End-Token
203 : SfxItemSet *pItemSet; // harte Attributierung
204 :
205 : sal_Bool bInNumBulList; // in einer Aufzaehlungs-Liste;
206 : sal_Bool bParaPossible; // ein </P> darf zusaetzlich ausgegeben werden
207 : sal_Bool bOutPara; // ein </P> soll ausgegeben werden
208 : sal_Bool bOutDiv; // write a </DIV>
209 :
210 263 : SwHTMLTxtCollOutputInfo() :
211 : pItemSet( 0 ),
212 : bInNumBulList( sal_False ),
213 : bParaPossible( sal_False ),
214 : bOutPara( sal_False ),
215 263 : bOutDiv( sal_False )
216 263 : {}
217 :
218 : ~SwHTMLTxtCollOutputInfo();
219 :
220 0 : sal_Bool HasParaToken() const { return aToken.getLength()==1 && aToken[0]=='P'; }
221 263 : sal_Bool ShouldOutputToken() const { return bOutPara || !HasParaToken(); }
222 : };
223 :
224 526 : SwHTMLTxtCollOutputInfo::~SwHTMLTxtCollOutputInfo()
225 : {
226 263 : delete pItemSet;
227 263 : }
228 :
229 3 : SwHTMLFmtInfo::SwHTMLFmtInfo( const SwFmt *pF, SwDoc *pDoc, SwDoc *pTemplate,
230 : sal_Bool bOutStyles,
231 : LanguageType eDfltLang,
232 : sal_uInt16 nCSS1Script, sal_Bool bHardDrop ) :
233 3 : pFmt( pF ), pRefFmt(0), pItemSet( 0 ), bScriptDependent( false )
234 : {
235 3 : sal_uInt16 nRefPoolId = 0;
236 : // Den Selektor des Formats holen
237 : sal_uInt16 nDeep = SwHTMLWriter::GetCSS1Selector( pFmt, aToken, aClass,
238 3 : nRefPoolId );
239 : OSL_ENSURE( nDeep ? !aToken.isEmpty() : aToken.isEmpty(),
240 : "Hier stimmt doch was mit dem Token nicht!" );
241 : OSL_ENSURE( nDeep ? nRefPoolId : !nRefPoolId,
242 : "Hier stimmt doch was mit der Vergleichs-Vorlage nicht!" );
243 :
244 4 : sal_Bool bTxtColl = pFmt->Which() == RES_TXTFMTCOLL ||
245 4 : pFmt->Which() == RES_CONDTXTFMTCOLL;
246 :
247 3 : const SwFmt *pReferenceFmt = 0; // Vergleichs-Format
248 3 : sal_Bool bSetDefaults = sal_True, bClearSame = sal_True;
249 3 : if( nDeep != 0 )
250 : {
251 : // Es ist eine HTML-Tag-Vorlage oder die Vorlage ist von einer
252 : // solchen abgeleitet
253 1 : if( !bOutStyles )
254 : {
255 : // wenn keine Styles exportiert werden, muss evtl. zusaetlich
256 : // harte Attributierung geschrieben werden
257 0 : switch( nDeep )
258 : {
259 : case CSS1_FMT_ISTAG:
260 : case CSS1_FMT_CMPREF:
261 : // fuer HTML-Tag-Vorlagen die Unterscheide zum Original
262 : // (sofern verfuegbar)
263 : pReferenceFmt = SwHTMLWriter::GetTemplateFmt( nRefPoolId,
264 0 : pTemplate );
265 0 : break;
266 :
267 : default:
268 : // sonst die zur HTML-Tag-Vorlage des Originals oder des
269 : // aktuellen Doks, wenn die nicht verfuegbar ist
270 0 : if( pTemplate )
271 : pReferenceFmt = SwHTMLWriter::GetTemplateFmt( nRefPoolId,
272 0 : pTemplate );
273 : else
274 0 : pReferenceFmt = SwHTMLWriter::GetParentFmt( *pFmt, nDeep );
275 0 : break;
276 : }
277 : }
278 : }
279 2 : else if( bTxtColl )
280 : {
281 : // Nicht von einer HTML-Tag-Vorlage abgeleitete Absatz-Vorlagen
282 : // muessen als harte Attributierung relativ zur Textkoerper-Volage
283 : // exportiert werden. Fuer Nicht-Styles-Export sollte die der
284 : // HTML-Vorlage als Referenz dienen
285 2 : if( !bOutStyles && pTemplate )
286 0 : pReferenceFmt = pTemplate->GetTxtCollFromPool( RES_POOLCOLL_TEXT, false );
287 : else
288 2 : pReferenceFmt = pDoc->GetTxtCollFromPool( RES_POOLCOLL_TEXT, false );
289 : }
290 :
291 3 : if( pReferenceFmt || nDeep==0 )
292 : {
293 2 : pItemSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(),
294 2 : pFmt->GetAttrSet().GetRanges() );
295 : // wenn Unterschiede zu einer anderen Vorlage geschrieben werden
296 : // sollen ist harte Attributierung noetig. Fuer Vorlagen, die
297 : // nicht von HTML-Tag-Vorlagen abgeleitet sind, gilt das immer
298 :
299 2 : pItemSet->Set( pFmt->GetAttrSet(), sal_True );
300 :
301 2 : if( pReferenceFmt )
302 2 : SwHTMLWriter::SubtractItemSet( *pItemSet, pReferenceFmt->GetAttrSet(),
303 4 : bSetDefaults, bClearSame );
304 :
305 : // einen leeren Item-Set gleich loeschen, das spart speater
306 : // Arbeit
307 2 : if( !pItemSet->Count() )
308 : {
309 0 : delete pItemSet;
310 0 : pItemSet = 0;
311 : }
312 : }
313 :
314 3 : if( bTxtColl )
315 : {
316 3 : if( bOutStyles )
317 : {
318 : // We have to add hard attributes for any script dependent
319 : // item that is not accessed by the style
320 : static sal_uInt16 aWhichIds[3][4] =
321 : {
322 : { RES_CHRATR_FONT, RES_CHRATR_FONTSIZE,
323 : RES_CHRATR_POSTURE, RES_CHRATR_WEIGHT },
324 : { RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_FONTSIZE,
325 : RES_CHRATR_CJK_POSTURE, RES_CHRATR_CJK_WEIGHT },
326 : { RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_FONTSIZE,
327 : RES_CHRATR_CTL_POSTURE, RES_CHRATR_CTL_WEIGHT }
328 : };
329 :
330 3 : sal_uInt16 nRef = 0;
331 3 : sal_uInt16 aSets[2] = {0,0};
332 3 : switch( nCSS1Script )
333 : {
334 : case CSS1_OUTMODE_WESTERN:
335 3 : nRef = 0;
336 3 : aSets[0] = 1;
337 3 : aSets[1] = 2;
338 3 : break;
339 : case CSS1_OUTMODE_CJK:
340 0 : nRef = 1;
341 0 : aSets[0] = 0;
342 0 : aSets[1] = 2;
343 0 : break;
344 : case CSS1_OUTMODE_CTL:
345 0 : nRef = 2;
346 0 : aSets[0] = 0;
347 0 : aSets[1] = 1;
348 0 : break;
349 : }
350 15 : for( sal_uInt16 i=0; i<4; i++ )
351 : {
352 12 : const SfxPoolItem& rRef = pFmt->GetFmtAttr( aWhichIds[nRef][i] );
353 36 : for( sal_uInt16 j=0; j<2; j++ )
354 : {
355 24 : const SfxPoolItem& rSet = pFmt->GetFmtAttr( aWhichIds[aSets[j]][i] );
356 24 : if( rSet != rRef )
357 : {
358 7 : if( !pItemSet )
359 1 : pItemSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(),
360 1 : pFmt->GetAttrSet().GetRanges() );
361 7 : pItemSet->Put( rSet );
362 : }
363 : }
364 : }
365 : }
366 :
367 : // Ggf. noch ein DropCap-Attribut uebernehmen
368 3 : if( bOutStyles && bHardDrop && nDeep != 0 )
369 : {
370 : const SfxPoolItem *pItem;
371 0 : if( SFX_ITEM_SET==pFmt->GetAttrSet().GetItemState(
372 0 : RES_PARATR_DROP, sal_True, &pItem ) )
373 : {
374 0 : sal_Bool bPut = sal_True;
375 0 : if( pTemplate )
376 : {
377 0 : pReferenceFmt = SwHTMLWriter::GetTemplateFmt( nRefPoolId, pTemplate );
378 : const SfxPoolItem *pRefItem;
379 : sal_Bool bRefItemSet =
380 0 : SFX_ITEM_SET==pReferenceFmt->GetAttrSet().GetItemState(
381 0 : RES_PARATR_DROP, sal_True, &pRefItem );
382 0 : bPut = !bRefItemSet || *pItem!=*pRefItem;
383 : }
384 0 : if( bPut )
385 : {
386 0 : if( !pItemSet )
387 0 : pItemSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(),
388 0 : pFmt->GetAttrSet().GetRanges() );
389 0 : pItemSet->Put( *pItem );
390 : }
391 : }
392 : }
393 :
394 :
395 : // Die diversen default-Abstaende aus der Vorlage oder der
396 : // Vergleischs-Vorlage merken
397 : const SvxLRSpaceItem &rLRSpace =
398 3 : (pReferenceFmt ? pReferenceFmt : pFmt)->GetLRSpace();
399 3 : nLeftMargin = rLRSpace.GetTxtLeft();
400 3 : nRightMargin = rLRSpace.GetRight();
401 3 : nFirstLineIndent = rLRSpace.GetTxtFirstLineOfst();
402 :
403 : const SvxULSpaceItem &rULSpace =
404 3 : (pReferenceFmt ? pReferenceFmt : pFmt)->GetULSpace();
405 3 : nTopMargin = rULSpace.GetUpper();
406 3 : nBottomMargin = rULSpace.GetLower();
407 :
408 : // export language if it differs from the default language
409 : sal_uInt16 nWhichId =
410 3 : SwHTMLWriter::GetLangWhichIdFromScript( nCSS1Script );
411 : const SvxLanguageItem& rLang =
412 3 : (const SvxLanguageItem&)pFmt->GetFmtAttr( nWhichId );
413 3 : LanguageType eLang = rLang.GetLanguage();
414 3 : if( eLang != eDfltLang )
415 : {
416 2 : if( !pItemSet )
417 0 : pItemSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(),
418 0 : pFmt->GetAttrSet().GetRanges() );
419 2 : pItemSet->Put( rLang );
420 : }
421 :
422 : static sal_uInt16 aWhichIds[3] =
423 : { RES_CHRATR_LANGUAGE, RES_CHRATR_CJK_LANGUAGE,
424 : RES_CHRATR_CTL_LANGUAGE };
425 12 : for( sal_uInt16 i=0; i<3; i++ )
426 : {
427 9 : if( aWhichIds[i] != nWhichId )
428 : {
429 : const SvxLanguageItem& rTmpLang =
430 6 : (const SvxLanguageItem&)pFmt->GetFmtAttr(aWhichIds[i]);
431 6 : if( rTmpLang.GetLanguage() != eLang )
432 : {
433 4 : if( !pItemSet )
434 0 : pItemSet = new SfxItemSet( *pFmt->GetAttrSet().GetPool(),
435 0 : pFmt->GetAttrSet().GetRanges() );
436 4 : pItemSet->Put( rTmpLang );
437 : }
438 : }
439 : }
440 : }
441 3 : }
442 :
443 532 : SwHTMLFmtInfo::~SwHTMLFmtInfo()
444 : {
445 266 : delete pItemSet;
446 266 : }
447 :
448 263 : void OutHTML_SwFmt( Writer& rWrt, const SwFmt& rFmt,
449 : const SfxItemSet *pNodeItemSet,
450 : SwHTMLTxtCollOutputInfo& rInfo )
451 : {
452 : OSL_ENSURE( RES_CONDTXTFMTCOLL==rFmt.Which() || RES_TXTFMTCOLL==rFmt.Which(),
453 : "keine Absatz-Vorlage" );
454 :
455 263 : SwHTMLWriter & rHWrt = (SwHTMLWriter&)rWrt;
456 :
457 : // Erstmal ein par Flags ...
458 263 : sal_uInt16 nNewDefListLvl = 0;
459 263 : sal_uInt16 nNumStart = USHRT_MAX;
460 263 : sal_Bool bForceDL = sal_False;
461 263 : sal_Bool bDT = sal_False;
462 263 : rInfo.bInNumBulList = sal_False; // Wir sind in einer Liste?
463 263 : sal_Bool bNumbered = sal_False; // Der aktuelle Absatz ist numeriert
464 263 : sal_Bool bPara = sal_False; // das aktuelle Token ist <P>
465 263 : rInfo.bParaPossible = sal_False; // ein <P> darf zusaetzlich ausgegeben werden
466 263 : sal_Bool bNoEndTag = sal_False; // kein End-Tag ausgeben
467 :
468 263 : rHWrt.bNoAlign = sal_False; // kein ALIGN=... moeglich
469 263 : sal_Bool bNoStyle = sal_False; // kein STYLE=... moeglich
470 263 : sal_uInt8 nBulletGrfLvl = 255; // Die auszugebende Bullet-Grafik
471 :
472 : // Sind wir in einer Aufzaehlungs- oder Numerierungliste?
473 263 : const SwTxtNode* pTxtNd = rWrt.pCurPam->GetNode()->GetTxtNode();
474 :
475 263 : SwHTMLNumRuleInfo aNumInfo;
476 263 : if( rHWrt.GetNextNumInfo() )
477 : {
478 0 : aNumInfo = *rHWrt.GetNextNumInfo();
479 0 : rHWrt.ClearNextNumInfo();
480 : }
481 : else
482 : {
483 263 : aNumInfo.Set( *pTxtNd );
484 : }
485 :
486 263 : if( aNumInfo.GetNumRule() )
487 : {
488 0 : rInfo.bInNumBulList = sal_True;
489 0 : nNewDefListLvl = 0;
490 :
491 : // ist der aktuelle Absatz numeriert?
492 0 : bNumbered = aNumInfo.IsNumbered();
493 0 : sal_uInt8 nLvl = aNumInfo.GetLevel();
494 :
495 : OSL_ENSURE( pTxtNd->GetActualListLevel() == nLvl,
496 : "Gemerkter Num-Level ist falsch" );
497 : OSL_ENSURE( bNumbered == static_cast< sal_Bool >(pTxtNd->IsCountedInList()),
498 : "Gemerkter Numerierungs-Zustand ist falsch" );
499 :
500 0 : if( bNumbered )
501 : {
502 0 : nBulletGrfLvl = nLvl; // nur veruebergehend!!!
503 : // #i57919#
504 : // correction of re-factoring done by cws swnumtree:
505 : // - <nNumStart> has to contain the restart value, if the
506 : // numbering is restarted at this text node. Value <USHRT_MAX>
507 : // indicates, that no additional restart value has to be written.
508 0 : if ( pTxtNd->IsListRestart() )
509 : {
510 0 : nNumStart = static_cast< sal_uInt16 >(pTxtNd->GetActualListStartValue());
511 : }
512 : OSL_ENSURE( rHWrt.nLastParaToken == 0,
513 : "<PRE> wurde nicht vor <LI> beendet." );
514 : }
515 : }
516 :
517 : // Jetzt holen wir das Token und ggf. die Klasse
518 263 : SwHTMLFmtInfo aFmtInfo( &rFmt );
519 : SwHTMLFmtInfo *pFmtInfo;
520 263 : SwHTMLFmtInfos::iterator it = rHWrt.aTxtCollInfos.find( aFmtInfo );
521 263 : if( it != rHWrt.aTxtCollInfos.end() )
522 : {
523 260 : pFmtInfo = &*it;
524 : }
525 : else
526 : {
527 : pFmtInfo = new SwHTMLFmtInfo( &rFmt, rWrt.pDoc, rHWrt.pTemplate,
528 : rHWrt.bCfgOutStyles, rHWrt.eLang,
529 : rHWrt.nCSS1Script,
530 3 : false );
531 3 : rHWrt.aTxtCollInfos.insert( pFmtInfo );
532 3 : String aName( rFmt.GetName() );
533 3 : if( 0 != rHWrt.aScriptParaStyles.count( aName ) )
534 1 : ((SwHTMLFmtInfo *)pFmtInfo)->bScriptDependent = true;
535 : }
536 :
537 : // Jetzt wird festgelegt, was aufgrund des Tokens so moeglich ist
538 263 : sal_uInt16 nToken = 0; // Token fuer Tag-Wechsel
539 263 : sal_Bool bOutNewLine = sal_False; // nur ein LF ausgeben?
540 263 : if( !pFmtInfo->aToken.isEmpty() )
541 : {
542 : // Es ist eine HTML-Tag-Vorlage oder die Vorlage ist von einer
543 : // solchen abgeleitet
544 1 : rInfo.aToken = pFmtInfo->aToken;
545 :
546 : // der erste Buchstabe reicht meistens
547 1 : switch( rInfo.aToken[0] )
548 : {
549 : case 'A': OSL_ENSURE( rInfo.aToken.equalsL(RTL_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_address)),
550 : "Doch kein ADDRESS?" );
551 0 : rInfo.bParaPossible = sal_True;
552 0 : rHWrt.bNoAlign = sal_True;
553 0 : break;
554 :
555 : case 'B': OSL_ENSURE( rInfo.aToken.equalsL(RTL_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_blockquote)),
556 : "Doch kein BLOCKQUOTE?" );
557 0 : rInfo.bParaPossible = sal_True;
558 0 : rHWrt.bNoAlign = sal_True;
559 0 : break;
560 :
561 1 : case 'P': if( rInfo.aToken.getLength() == 1 )
562 : {
563 1 : bPara = sal_True;
564 : }
565 : else
566 : {
567 : OSL_ENSURE( rInfo.aToken.equalsL(RTL_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_preformtxt)),
568 : "Doch kein PRE?" );
569 0 : if( HTML_PREFORMTXT_ON == rHWrt.nLastParaToken )
570 : {
571 0 : bOutNewLine = sal_True;
572 : }
573 : else
574 : {
575 0 : nToken = HTML_PREFORMTXT_ON;
576 0 : rHWrt.bNoAlign = sal_True;
577 0 : bNoEndTag = sal_True;
578 : }
579 : }
580 1 : break;
581 :
582 : case 'D': OSL_ENSURE( rInfo.aToken.equalsL(RTL_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_dt)) ||
583 : rInfo.aToken.equalsL(RTL_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_dd)),
584 : "Doch kein DD/DT?" );
585 0 : bDT = rInfo.aToken.equalsL(RTL_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_dt));
586 0 : rInfo.bParaPossible = !bDT;
587 0 : rHWrt.bNoAlign = sal_True;
588 0 : bForceDL = sal_True;
589 0 : break;
590 : }
591 : }
592 : else
593 : {
594 : // alle Vorlagen, die nicht einem HTML-Tag entsprechen oder von
595 : // diesem abgeleitet sind, werden als <P> exportiert
596 :
597 262 : rInfo.aToken = OOO_STRING_SVTOOLS_HTML_parabreak;
598 262 : bPara = sal_True;
599 : }
600 :
601 : // Falls noetig, die harte Attributierung der Vorlage uebernehmen
602 263 : if( pFmtInfo->pItemSet )
603 : {
604 : OSL_ENSURE( !rInfo.pItemSet, "Wo kommt der Item-Set her?" );
605 263 : rInfo.pItemSet = new SfxItemSet( *pFmtInfo->pItemSet );
606 : }
607 :
608 : // und noch die harte Attributierung des Absatzes dazunehmen
609 263 : if( pNodeItemSet )
610 : {
611 263 : if( rInfo.pItemSet )
612 263 : rInfo.pItemSet->Put( *pNodeItemSet );
613 : else
614 0 : rInfo.pItemSet = new SfxItemSet( *pNodeItemSet );
615 : }
616 :
617 : // den unteren Absatz-Abstand brauchen wir noch
618 : const SvxULSpaceItem& rULSpace =
619 263 : pNodeItemSet ? ((const SvxULSpaceItem &)pNodeItemSet->Get(RES_UL_SPACE))
620 526 : : rFmt.GetULSpace();
621 :
622 :
623 263 : if( (rHWrt.bOutHeader &&
624 0 : rWrt.pCurPam->GetPoint()->nNode.GetIndex() ==
625 526 : rWrt.pCurPam->GetMark()->nNode.GetIndex()) ||
626 : rHWrt.bOutFooter )
627 : {
628 0 : if( rHWrt.bCfgOutStyles )
629 : {
630 0 : SvxULSpaceItem aULSpaceItem( rULSpace );
631 0 : if( rHWrt.bOutHeader )
632 0 : aULSpaceItem.SetLower( rHWrt.nHeaderFooterSpace );
633 : else
634 0 : aULSpaceItem.SetUpper( rHWrt.nHeaderFooterSpace );
635 :
636 0 : if( !rInfo.pItemSet )
637 : rInfo.pItemSet = new SfxItemSet(
638 0 : *rFmt.GetAttrSet().GetPool(),
639 0 : RES_UL_SPACE, RES_UL_SPACE );
640 0 : rInfo.pItemSet->Put( aULSpaceItem );
641 : }
642 0 : rHWrt.bOutHeader = sal_False;
643 0 : rHWrt.bOutFooter = sal_False;
644 : }
645 :
646 263 : if( bOutNewLine )
647 : {
648 : // nur einen Zeilen-Umbruch (ohne Einrueckung) am Absatz-Anfang
649 : // ausgeben
650 0 : rInfo.aToken = OString(); // kein End-Tag ausgeben
651 0 : rWrt.Strm() << SwHTMLWriter::sNewLine;
652 :
653 263 : return;
654 : }
655 :
656 :
657 : // soll ein ALIGN=... geschrieben werden?
658 263 : const SfxPoolItem* pAdjItem = 0;
659 : const SfxPoolItem* pItem;
660 :
661 526 : if( rInfo.pItemSet &&
662 : SFX_ITEM_SET == rInfo.pItemSet->GetItemState( RES_PARATR_ADJUST,
663 263 : sal_False, &pItem ) )
664 : {
665 0 : pAdjItem = pItem;
666 : }
667 :
668 : // Unteren Absatz-Abstand beachten ? (nie im letzen Absatz von
669 : // Tabellen)
670 524 : sal_Bool bUseParSpace = !rHWrt.bOutTable ||
671 261 : (rWrt.pCurPam->GetPoint()->nNode.GetIndex() !=
672 524 : rWrt.pCurPam->GetMark()->nNode.GetIndex());
673 : // Wenn Styles exportiert werden, wird aus eingerueckten Absaetzen
674 : // eine Definitions-Liste
675 : const SvxLRSpaceItem& rLRSpace =
676 263 : pNodeItemSet ? ((const SvxLRSpaceItem &)pNodeItemSet->Get(RES_LR_SPACE))
677 526 : : rFmt.GetLRSpace();
678 263 : if( (!rHWrt.bCfgOutStyles || bForceDL) && !rInfo.bInNumBulList )
679 : {
680 : sal_Int32 nLeftMargin;
681 0 : if( bForceDL )
682 0 : nLeftMargin = rLRSpace.GetTxtLeft();
683 : else
684 0 : nLeftMargin = rLRSpace.GetTxtLeft() > pFmtInfo->nLeftMargin
685 0 : ? rLRSpace.GetTxtLeft() - pFmtInfo->nLeftMargin
686 0 : : 0;
687 :
688 0 : if( nLeftMargin > 0 && rHWrt.nDefListMargin > 0 )
689 : {
690 0 : nNewDefListLvl = static_cast< sal_uInt16 >((nLeftMargin + (rHWrt.nDefListMargin/2)) /
691 0 : rHWrt.nDefListMargin);
692 0 : if( nNewDefListLvl == 0 && bForceDL && !bDT )
693 0 : nNewDefListLvl = 1;
694 : }
695 : else
696 : {
697 : // If the left margin is 0 or negative, emulating indent
698 : // with <dd> does not work. We then set a def list only if
699 : // the dd style is used.
700 0 : nNewDefListLvl = (bForceDL&& !bDT) ? 1 : 0;
701 : }
702 :
703 : sal_Bool bIsNextTxtNode =
704 0 : rWrt.pDoc->GetNodes()[rWrt.pCurPam->GetPoint()->nNode.GetIndex()+1]
705 0 : ->IsTxtNode();
706 :
707 0 : if( bForceDL && bDT )
708 : {
709 : // Statt eines DD muessen wir hier auch ein DT der Ebene
710 : // darueber nehmen
711 0 : nNewDefListLvl++;
712 : }
713 0 : else if( !nNewDefListLvl && !rHWrt.bCfgOutStyles && bPara &&
714 0 : rULSpace.GetLower()==0 &&
715 0 : ((bUseParSpace && bIsNextTxtNode) || rHWrt.nDefListLvl==1) &&
716 0 : (!pAdjItem || SVX_ADJUST_LEFT==
717 0 : ((const SvxAdjustItem *)pAdjItem)->GetAdjust()) )
718 : {
719 : // Absaetze ohne unteren Abstand als DT exportieren
720 0 : nNewDefListLvl = 1;
721 0 : bDT = sal_True;
722 0 : rInfo.bParaPossible = sal_False;
723 0 : rHWrt.bNoAlign = sal_True;
724 : }
725 : }
726 :
727 263 : if( nNewDefListLvl != rHWrt.nDefListLvl )
728 0 : rHWrt.OutAndSetDefList( nNewDefListLvl );
729 :
730 : // ggf. eine Aufzaehlung- oder Numerierungsliste beginnen
731 263 : if( rInfo.bInNumBulList )
732 : {
733 : OSL_ENSURE( !rHWrt.nDefListLvl, "DL in OL geht nicht!" );
734 0 : OutHTML_NumBulListStart( rHWrt, aNumInfo );
735 :
736 0 : if( bNumbered )
737 : {
738 0 : if( rHWrt.aBulletGrfs[nBulletGrfLvl].Len() )
739 0 : bNumbered = sal_False;
740 : else
741 0 : nBulletGrfLvl = 255;
742 : }
743 : }
744 :
745 : // Die Defaults aus der Vorlage merken, denn sie muessen nicht
746 : // exportiert werden
747 263 : rHWrt.nDfltLeftMargin = pFmtInfo->nLeftMargin;
748 263 : rHWrt.nDfltRightMargin = pFmtInfo->nRightMargin;
749 263 : rHWrt.nDfltFirstLineIndent = pFmtInfo->nFirstLineIndent;
750 :
751 263 : if( rInfo.bInNumBulList )
752 : {
753 0 : if( !rHWrt.IsHTMLMode( HTMLMODE_LSPACE_IN_NUMBUL ) )
754 0 : rHWrt.nDfltLeftMargin = rLRSpace.GetTxtLeft();
755 :
756 : // In Numerierungs-Listen keinen Ertzeilen-Einzug ausgeben.
757 0 : rHWrt.nFirstLineIndent = rLRSpace.GetTxtFirstLineOfst();
758 : }
759 :
760 263 : if( rInfo.bInNumBulList && bNumbered && bPara && !rHWrt.bCfgOutStyles )
761 : {
762 : // ein einzelnes LI hat keinen Abstand
763 0 : rHWrt.nDfltTopMargin = 0;
764 0 : rHWrt.nDfltBottomMargin = 0;
765 : }
766 263 : else if( rHWrt.nDefListLvl && bPara )
767 : {
768 : // ein einzelnes DD hat auch keinen Abstand
769 0 : rHWrt.nDfltTopMargin = 0;
770 0 : rHWrt.nDfltBottomMargin = 0;
771 : }
772 : else
773 : {
774 263 : rHWrt.nDfltTopMargin = pFmtInfo->nTopMargin;
775 : // Wenn im letzten Absatz einer Tabelle der
776 : // untere Absatz-Abstand veraendert wird, vertut sich
777 : // Netscape total. Deshalb exportieren wir hier erstmal
778 : // nichts, indem wir den Abstand aus dem Absatz als Default
779 : // setzen.
780 263 : if( rHWrt.bCfgNetscape4 && !bUseParSpace )
781 260 : rHWrt.nDfltBottomMargin = rULSpace.GetLower();
782 : else
783 3 : rHWrt.nDfltBottomMargin = pFmtInfo->nBottomMargin;
784 : }
785 :
786 263 : if( rHWrt.nDefListLvl )
787 : {
788 : rHWrt.nLeftMargin =
789 0 : (rHWrt.nDefListLvl-1) * rHWrt.nDefListMargin;
790 : }
791 :
792 263 : if( rHWrt.bLFPossible )
793 263 : rHWrt.OutNewLine(); // Absatz-Tag in neue Zeile
794 263 : rInfo.bOutPara = sal_False;
795 :
796 : // das ist jetzt unser neues Token
797 263 : rHWrt.ChangeParaToken( nToken );
798 :
799 263 : sal_Bool bHasParSpace = bUseParSpace && rULSpace.GetLower() > 0;
800 :
801 : // ggf ein List-Item aufmachen
802 263 : if( rInfo.bInNumBulList && bNumbered )
803 : {
804 0 : OStringBuffer sOut;
805 0 : sOut.append('<').append(OOO_STRING_SVTOOLS_HTML_li);
806 0 : if( USHRT_MAX != nNumStart )
807 : {
808 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_value).
809 0 : append('=').append(static_cast<sal_Int32>(nNumStart));
810 : }
811 0 : sOut.append('>');
812 0 : rWrt.Strm() << sOut.getStr();
813 : }
814 :
815 263 : if( rHWrt.nDefListLvl > 0 && !bForceDL )
816 : {
817 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), bDT ? OOO_STRING_SVTOOLS_HTML_dt : OOO_STRING_SVTOOLS_HTML_dd );
818 : }
819 :
820 263 : if( pAdjItem &&
821 263 : rHWrt.IsHTMLMode( HTMLMODE_NO_CONTROL_CENTERING ) &&
822 0 : rHWrt.HasControls() )
823 : {
824 : // The align=... attribute does behave strange in netscape
825 : // if there are controls in a paragraph, because the control and
826 : // all text behind the control does not recognize this attribute.
827 0 : OStringBuffer sOut;
828 0 : sOut.append('<').append(OOO_STRING_SVTOOLS_HTML_division);
829 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
830 :
831 0 : rHWrt.bTxtAttr = sal_False;
832 0 : rHWrt.bOutOpts = sal_True;
833 0 : OutHTML_SvxAdjust( rWrt, *pAdjItem );
834 0 : rWrt.Strm() << '>';
835 0 : pAdjItem = 0;
836 0 : rHWrt.bNoAlign = sal_False;
837 0 : rInfo.bOutDiv = sal_True;
838 0 : rHWrt.IncIndentLevel();
839 0 : rHWrt.bLFPossible = sal_True;
840 0 : rHWrt.OutNewLine();
841 : }
842 :
843 : // fuer BLOCKQUOTE, ADDRESS und DD wird noch ein Absatz-Token
844 : // ausgegeben, wenn,
845 : // - keine Styles geschrieben werden, und
846 : // - ein untere Abstand oder eine Absatz-Ausrichtung existiert
847 263 : OString aToken = rInfo.aToken;
848 263 : if( !rHWrt.bCfgOutStyles && rInfo.bParaPossible && !bPara &&
849 0 : (bHasParSpace || pAdjItem) )
850 : {
851 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), rInfo.aToken.getStr() );
852 0 : aToken = OOO_STRING_SVTOOLS_HTML_parabreak;
853 0 : bPara = sal_True;
854 0 : rHWrt.bNoAlign = sal_False;
855 0 : bNoStyle = sal_False;
856 : }
857 :
858 : LanguageType eLang = rInfo.pItemSet
859 263 : ? ((const SvxLanguageItem&)rInfo.pItemSet->Get(SwHTMLWriter::GetLangWhichIdFromScript(rHWrt.nCSS1Script))).GetLanguage()
860 526 : : rHWrt.eLang;
861 :
862 263 : if( rInfo.pItemSet )
863 : {
864 : static sal_uInt16 aWhichIds[3] = { RES_CHRATR_LANGUAGE, RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CTL_LANGUAGE };
865 :
866 1052 : for( sal_uInt16 i=0; i<3; i++ )
867 : {
868 : // export language if it differs from the default language only.
869 : const SfxPoolItem *pTmpItem;
870 1578 : if( SFX_ITEM_SET == rInfo.pItemSet->GetItemState( aWhichIds[i],
871 1315 : sal_True, &pTmpItem ) &&
872 526 : ((const SvxLanguageItem *)pTmpItem)->GetLanguage() == eLang )
873 262 : rInfo.pItemSet->ClearItem( aWhichIds[i] );
874 : }
875 : }
876 :
877 : // and the text direction
878 : sal_uInt16 nDir = rHWrt.GetHTMLDirection(
879 : (pNodeItemSet ? static_cast < const SvxFrameDirectionItem& >(
880 263 : pNodeItemSet->Get( RES_FRAMEDIR ) )
881 526 : : rFmt.GetFrmDir() ).GetValue() );
882 :
883 : // Ein <P> wird nur geschrieben, wenn
884 : // - wir in keiner OL/UL/DL sind, oder
885 : // - der Absatz einer OL/UL nicht numeriert ist, oder
886 : // - keine Styles exportiert werden und
887 : // - ein unterer Abstand oder
888 : // - eine Absatz-Ausrichtung existiert, ode
889 : // - Styles exportiert werden und,
890 : // - die Textkoerper-Vorlage geaendert wurde, oder
891 : // - ein Benutzer-Format exportiert wird, oder
892 : // - Absatz-Attribute existieren
893 526 : if( !bPara ||
894 526 : (!rInfo.bInNumBulList && !rHWrt.nDefListLvl) ||
895 0 : (rInfo.bInNumBulList && !bNumbered) ||
896 0 : (!rHWrt.bCfgOutStyles &&
897 0 : (bHasParSpace || pAdjItem ||
898 0 : (eLang != LANGUAGE_DONTKNOW && eLang != rHWrt.eLang))) ||
899 0 : nDir != rHWrt.nDirection ||
900 : rHWrt.bCfgOutStyles )
901 : {
902 : // jetzt werden Optionen ausgegeben
903 263 : rHWrt.bTxtAttr = sal_False;
904 263 : rHWrt.bOutOpts = sal_True;
905 :
906 263 : OStringBuffer sOut;
907 263 : sOut.append('<').append(aToken);
908 :
909 263 : if( eLang != LANGUAGE_DONTKNOW && eLang != rHWrt.eLang )
910 : {
911 256 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
912 256 : rHWrt.OutLanguage( eLang );
913 : }
914 :
915 263 : if( nDir != rHWrt.nDirection )
916 : {
917 0 : if( !sOut.isEmpty() )
918 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
919 0 : rHWrt.OutDirection( nDir );
920 : }
921 :
922 578 : if( rHWrt.bCfgOutStyles &&
923 526 : (pFmtInfo->aClass.Len() || pFmtInfo->bScriptDependent) )
924 : {
925 52 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_class)
926 52 : .append("=\"");
927 52 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
928 52 : String aClass( pFmtInfo->aClass );
929 52 : if( pFmtInfo->bScriptDependent )
930 : {
931 52 : if( aClass.Len() )
932 0 : aClass += '-';
933 52 : switch( rHWrt.nCSS1Script )
934 : {
935 : case CSS1_OUTMODE_WESTERN:
936 52 : aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("western") );
937 52 : break;
938 : case CSS1_OUTMODE_CJK:
939 0 : aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("cjk") );
940 0 : break;
941 : case CSS1_OUTMODE_CTL:
942 0 : aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("ctl") );
943 0 : break;
944 : }
945 : }
946 52 : HTMLOutFuncs::Out_String( rWrt.Strm(), aClass,
947 104 : rHWrt.eDestEnc, &rHWrt.aNonConvertableCharacters );
948 52 : sOut.append('\"');
949 : }
950 263 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
951 :
952 : // ggf. Ausrichtung ausgeben.
953 263 : if( !rHWrt.bNoAlign && pAdjItem )
954 0 : OutHTML_SvxAdjust( rWrt, *pAdjItem );
955 :
956 : // und nun ggf. noch die STYLE-Option
957 263 : if( rHWrt.bCfgOutStyles && rInfo.pItemSet && !bNoStyle)
958 : {
959 263 : OutCSS1_ParaTagStyleOpt( rWrt, *rInfo.pItemSet );
960 : }
961 :
962 263 : rWrt.Strm() << '>';
963 :
964 : // Soll ein </P> geschrieben wenrden
965 : rInfo.bOutPara =
966 526 : bPara &&
967 0 : ( rHWrt.bCfgOutStyles ||
968 263 : (!rHWrt.bCfgOutStyles && bHasParSpace) );
969 :
970 : // wenn kein End-Tag geschrieben werden soll, es loeschen
971 263 : if( bNoEndTag )
972 0 : rInfo.aToken = OString();
973 : }
974 :
975 263 : if( nBulletGrfLvl != 255 )
976 : {
977 : OSL_ENSURE( aNumInfo.GetNumRule(), "Wo ist die Numerierung geblieben???" );
978 : OSL_ENSURE( nBulletGrfLvl < MAXLEVEL, "So viele Ebenen gibt's nicht" );
979 0 : const SwNumFmt& rNumFmt = aNumInfo.GetNumRule()->Get(nBulletGrfLvl);
980 :
981 : OutHTML_BulletImage( rWrt, OOO_STRING_SVTOOLS_HTML_image, 0,
982 0 : rHWrt.aBulletGrfs[nBulletGrfLvl],
983 0 : rNumFmt.GetGraphicSize(), rNumFmt.GetGraphicOrientation() );
984 : }
985 :
986 263 : rHWrt.GetNumInfo() = aNumInfo;
987 :
988 : // die Defaults zuruecksetzen
989 263 : rHWrt.nDfltLeftMargin = 0;
990 263 : rHWrt.nDfltRightMargin = 0;
991 263 : rHWrt.nDfltFirstLineIndent = 0;
992 263 : rHWrt.nDfltTopMargin = 0;
993 263 : rHWrt.nDfltBottomMargin = 0;
994 263 : rHWrt.nLeftMargin = 0;
995 263 : rHWrt.nFirstLineIndent = 0;
996 : }
997 :
998 263 : void OutHTML_SwFmtOff( Writer& rWrt, const SwHTMLTxtCollOutputInfo& rInfo )
999 : {
1000 263 : SwHTMLWriter & rHWrt = (SwHTMLWriter&)rWrt;
1001 :
1002 : // wenn es kein Token gibt haben wir auch nichts auszugeben
1003 263 : if( rInfo.aToken.isEmpty() )
1004 : {
1005 0 : rHWrt.FillNextNumInfo();
1006 0 : const SwHTMLNumRuleInfo& rNextInfo = *rHWrt.GetNextNumInfo();
1007 : // Auch in PRE muss eine Bullet-Liste beendet werden
1008 0 : if( rInfo.bInNumBulList )
1009 : {
1010 :
1011 0 : const SwHTMLNumRuleInfo& rNRInfo = rHWrt.GetNumInfo();
1012 0 : if( rNextInfo.GetNumRule() != rNRInfo.GetNumRule() ||
1013 0 : rNextInfo.GetDepth() != rNRInfo.GetDepth() ||
1014 0 : rNextInfo.IsNumbered() || rNextInfo.IsRestart() )
1015 0 : rHWrt.ChangeParaToken( 0 );
1016 0 : OutHTML_NumBulListEnd( rHWrt, rNextInfo );
1017 : }
1018 0 : else if( rNextInfo.GetNumRule() != 0 )
1019 0 : rHWrt.ChangeParaToken( 0 );
1020 :
1021 263 : return;
1022 : }
1023 :
1024 263 : if( rInfo.ShouldOutputToken() )
1025 : {
1026 263 : if( rHWrt.bLFPossible )
1027 258 : rHWrt.OutNewLine( sal_True );
1028 :
1029 : // fuer BLOCKQUOTE, ADDRESS und DD wird ggf noch ein
1030 : // Absatz-Token ausgegeben, wenn
1031 : // - keine Styles geschrieben werden, und
1032 : // - ein untere Abstand existiert
1033 263 : if( rInfo.bParaPossible && rInfo.bOutPara )
1034 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_parabreak, sal_False );
1035 :
1036 263 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), rInfo.aToken.getStr(),
1037 526 : sal_False );
1038 : rHWrt.bLFPossible =
1039 526 : !rInfo.aToken.equalsL(RTL_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_dt)) &&
1040 526 : !rInfo.aToken.equalsL(RTL_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_dd)) &&
1041 526 : !rInfo.aToken.equalsL(RTL_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_li));
1042 : }
1043 263 : if( rInfo.bOutDiv )
1044 : {
1045 0 : rHWrt.DecIndentLevel();
1046 0 : if( rHWrt.bLFPossible )
1047 0 : rHWrt.OutNewLine();
1048 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_division, sal_False );
1049 0 : rHWrt.bLFPossible = sal_True;
1050 : }
1051 :
1052 : // ggf. eine Aufzaehlung- oder Numerierungsliste beenden
1053 263 : if( rInfo.bInNumBulList )
1054 : {
1055 0 : rHWrt.FillNextNumInfo();
1056 0 : OutHTML_NumBulListEnd( rHWrt, *rHWrt.GetNextNumInfo() );
1057 : }
1058 : }
1059 :
1060 :
1061 : class HTMLSttEndPos
1062 : {
1063 : xub_StrLen nStart;
1064 : xub_StrLen nEnd;
1065 : SfxPoolItem* pItem;
1066 :
1067 : public:
1068 :
1069 : HTMLSttEndPos( const SfxPoolItem& rItem, xub_StrLen nStt, xub_StrLen nE );
1070 : ~HTMLSttEndPos();
1071 :
1072 79 : const SfxPoolItem *GetItem() const { return pItem; }
1073 :
1074 : void SetStart( xub_StrLen nStt ) { nStart = nStt; }
1075 170 : xub_StrLen GetStart() const { return nStart; }
1076 :
1077 96 : xub_StrLen GetEnd() const { return nEnd; }
1078 0 : void SetEnd( xub_StrLen nE ) { nEnd = nE; }
1079 : };
1080 :
1081 21 : HTMLSttEndPos::HTMLSttEndPos( const SfxPoolItem& rItem, xub_StrLen nStt,
1082 : xub_StrLen nE ) :
1083 : nStart( nStt ),
1084 : nEnd( nE ),
1085 21 : pItem( rItem.Clone() )
1086 21 : {}
1087 :
1088 21 : HTMLSttEndPos::~HTMLSttEndPos()
1089 : {
1090 21 : delete pItem;
1091 21 : }
1092 :
1093 : typedef std::vector<HTMLSttEndPos *> _HTMLEndLst;
1094 :
1095 : enum HTMLOnOffState { HTML_NOT_SUPPORTED, // nicht unterst. Attribut
1096 : HTML_REAL_VALUE, // Attribut mit Wert
1097 : HTML_ON_VALUE, // Attribut entspricht On-Tag
1098 : HTML_OFF_VALUE, // Attribut entspricht Off-Tag
1099 : HTML_CHRFMT_VALUE, // Attribut fuer Zeichenvorlage
1100 : HTML_COLOR_VALUE, // Attribut fuer Vordergrundfarbe
1101 : HTML_STYLE_VALUE, // Attribut muss als Style exp.
1102 : HTML_DROPCAP_VALUE, // DropCap-Attributs
1103 : HTML_AUTOFMT_VALUE }; // Attribute for automatic character styles
1104 :
1105 :
1106 : class HTMLEndPosLst
1107 : {
1108 : _HTMLEndLst aStartLst; // nach Anfangs-Psoitionen sortierte Liste
1109 : _HTMLEndLst aEndLst; // nach End-Psotionen sortierte Liste
1110 : std::deque<xub_StrLen> aScriptChgLst; // positions where script changes
1111 : // 0 is not contained in this list,
1112 : // but the text length
1113 : // the script that is valif up to the position
1114 : // contained in aScriptChgList at the same index
1115 : ::std::vector<sal_uInt16> aScriptLst;
1116 :
1117 : SwDoc *pDoc; // das aktuelle Dokument
1118 : SwDoc* pTemplate; // die HTML-Vorlage (oder 0)
1119 : const Color* pDfltColor;// die Default-Vordergrund-Farbe
1120 : std::set<String>& rScriptTxtStyles; //
1121 :
1122 : sal_uLong nHTMLMode;
1123 : sal_Bool bOutStyles : 1; // werden Styles exportiert
1124 :
1125 :
1126 : // die Position eines Items in der Start-/Ende-Liste suchen
1127 : sal_uInt16 _FindStartPos( const HTMLSttEndPos *pPos ) const;
1128 : sal_uInt16 _FindEndPos( const HTMLSttEndPos *pPos ) const;
1129 :
1130 : // Eine SttEndPos in die Start- und Ende-Listen eintragen bzw. aus
1131 : // ihnen loeschen, wobei die Ende-Position bekannt ist
1132 : void _InsertItem( HTMLSttEndPos *pPos, sal_uInt16 nEndPos );
1133 : void _RemoveItem( sal_uInt16 nEndPos );
1134 :
1135 : // die "Art" es Attributs ermitteln
1136 : HTMLOnOffState GetHTMLItemState( const SfxPoolItem& rItem );
1137 :
1138 : // Existiert ein bestimmtes On-Tag-Item
1139 : sal_Bool ExistsOnTagItem( sal_uInt16 nWhich, xub_StrLen nPos );
1140 :
1141 : // Existiert ein Item zum ausschalten eines Attributs, das genauso
1142 : // exportiert wird wie das uebergebene Item im gleichen Bereich?
1143 : sal_Bool ExistsOffTagItem( sal_uInt16 nWhich, xub_StrLen nStartPos,
1144 : xub_StrLen nEndPos );
1145 :
1146 :
1147 : // das Ende eines gesplitteten Items anpassen
1148 : void FixSplittedItem( HTMLSttEndPos *pPos, sal_uInt16 nStartPos,
1149 : xub_StrLen nNewEnd );
1150 :
1151 : // Ein Attribut in die Listen eintragen und ggf. aufteilen
1152 : void InsertItem( const SfxPoolItem& rItem, xub_StrLen nStart,
1153 : xub_StrLen nEnd );
1154 :
1155 : // Ein bereits vorhandenes Attribut aufteilen
1156 : void SplitItem( const SfxPoolItem& rItem, xub_StrLen nStart,
1157 : xub_StrLen nEnd );
1158 :
1159 : // Insert without taking care of script
1160 : void InsertNoScript( const SfxPoolItem& rItem, xub_StrLen nStart,
1161 : xub_StrLen nEnd, SwHTMLFmtInfos& rFmtInfos,
1162 : sal_Bool bParaAttrs=sal_False );
1163 :
1164 : const SwHTMLFmtInfo *GetFmtInfo( const SwFmt& rFmt,
1165 : SwHTMLFmtInfos& rFmtInfos );
1166 :
1167 : public:
1168 :
1169 : HTMLEndPosLst( SwDoc *pDoc, SwDoc* pTemplate, const Color* pDfltColor,
1170 : sal_Bool bOutStyles, sal_uLong nHTMLMode,
1171 : const String& rText, std::set<String>& rStyles );
1172 : ~HTMLEndPosLst();
1173 :
1174 : // Ein Attribut einfuegen
1175 : void Insert( const SfxPoolItem& rItem, xub_StrLen nStart, xub_StrLen nEnd,
1176 : SwHTMLFmtInfos& rFmtInfos, sal_Bool bParaAttrs=sal_False );
1177 : void Insert( const SfxItemSet& rItemSet, xub_StrLen nStart, xub_StrLen nEnd,
1178 : SwHTMLFmtInfos& rFmtInfos, sal_Bool bDeep,
1179 : sal_Bool bParaAttrs=sal_False );
1180 : void Insert( const SwDrawFrmFmt& rFmt, xub_StrLen nPos,
1181 : SwHTMLFmtInfos& rFmtInfos );
1182 :
1183 : sal_uInt16 GetScriptAtPos( xub_StrLen nPos,
1184 : sal_uInt16 nWeak=CSS1_OUTMODE_ANY_SCRIPT );
1185 :
1186 : void OutStartAttrs( SwHTMLWriter& rHWrt, xub_StrLen nPos,
1187 : HTMLOutContext *pContext = 0 );
1188 : void OutEndAttrs( SwHTMLWriter& rHWrt, xub_StrLen nPos,
1189 : HTMLOutContext *pContext = 0 );
1190 :
1191 : sal_uInt16 Count() const { return aEndLst.size(); }
1192 :
1193 0 : sal_Bool IsHTMLMode( sal_uLong nMode ) const { return (nHTMLMode & nMode) != 0; }
1194 : };
1195 :
1196 :
1197 21 : sal_uInt16 HTMLEndPosLst::_FindStartPos( const HTMLSttEndPos *pPos ) const
1198 : {
1199 : sal_uInt16 i;
1200 21 : for( i = 0; i < aStartLst.size() && aStartLst[i] != pPos; i++ )
1201 : ;
1202 :
1203 : OSL_ENSURE(i != aStartLst.size(), "Item not found in Start List!" );
1204 :
1205 21 : return i==aStartLst.size() ? USHRT_MAX : i;
1206 : }
1207 :
1208 0 : sal_uInt16 HTMLEndPosLst::_FindEndPos( const HTMLSttEndPos *pPos ) const
1209 : {
1210 : sal_uInt16 i;
1211 :
1212 0 : for( i = 0; i < aEndLst.size() && aEndLst[i] != pPos; i++ )
1213 : ;
1214 :
1215 : OSL_ENSURE(i != aEndLst.size(), "Item not found in End List!" );
1216 :
1217 0 : return i==aEndLst.size() ? USHRT_MAX : i;
1218 : }
1219 :
1220 :
1221 21 : void HTMLEndPosLst::_InsertItem( HTMLSttEndPos *pPos, sal_uInt16 nEndPos )
1222 : {
1223 : // In der Start-Liste das Attribut hinter allen vorher und an
1224 : // der gleichen Position gestarteten Attributen einfuegen
1225 21 : xub_StrLen nStart = pPos->GetStart();
1226 : sal_uInt16 i;
1227 :
1228 55 : for( i = 0; i < aStartLst.size() &&
1229 34 : aStartLst[i]->GetStart() <= nStart; i++ )
1230 : ;
1231 21 : aStartLst.insert( aStartLst.begin() + i, pPos );
1232 :
1233 : // die Position in der Ende-Liste wurde uebergeben
1234 21 : aEndLst.insert( aEndLst.begin() + nEndPos, pPos );
1235 21 : }
1236 :
1237 21 : void HTMLEndPosLst::_RemoveItem( sal_uInt16 nEndPos )
1238 : {
1239 21 : HTMLSttEndPos *pPos = aEndLst[nEndPos];
1240 :
1241 : // jetzt Suchen wir es in der Start-Liste
1242 21 : sal_uInt16 nStartPos = _FindStartPos( pPos );
1243 21 : if( nStartPos != USHRT_MAX )
1244 21 : aStartLst.erase( aStartLst.begin() + nStartPos );
1245 :
1246 21 : aEndLst.erase( aEndLst.begin() + nEndPos );
1247 :
1248 21 : delete pPos;
1249 21 : }
1250 :
1251 41 : HTMLOnOffState HTMLEndPosLst::GetHTMLItemState( const SfxPoolItem& rItem )
1252 : {
1253 41 : HTMLOnOffState eState = HTML_NOT_SUPPORTED;
1254 41 : switch( rItem.Which() )
1255 : {
1256 : case RES_CHRATR_POSTURE:
1257 : case RES_CHRATR_CJK_POSTURE:
1258 : case RES_CHRATR_CTL_POSTURE:
1259 0 : switch( ((const SvxPostureItem&)rItem).GetPosture() )
1260 : {
1261 : case ITALIC_NORMAL:
1262 0 : eState = HTML_ON_VALUE;
1263 0 : break;
1264 : case ITALIC_NONE:
1265 0 : eState = HTML_OFF_VALUE;
1266 0 : break;
1267 : default:
1268 0 : if( IsHTMLMode(HTMLMODE_SOME_STYLES) )
1269 0 : eState = HTML_STYLE_VALUE;
1270 0 : break;
1271 : }
1272 0 : break;
1273 :
1274 : case RES_CHRATR_CROSSEDOUT:
1275 0 : switch( ((const SvxCrossedOutItem&)rItem).GetStrikeout() )
1276 : {
1277 : case STRIKEOUT_SINGLE:
1278 : case STRIKEOUT_DOUBLE:
1279 0 : eState = HTML_ON_VALUE;
1280 0 : break;
1281 : case STRIKEOUT_NONE:
1282 0 : eState = HTML_OFF_VALUE;
1283 0 : break;
1284 : default:
1285 : ;
1286 : }
1287 0 : break;
1288 :
1289 : case RES_CHRATR_ESCAPEMENT:
1290 0 : switch( (const SvxEscapement)
1291 0 : ((const SvxEscapementItem&)rItem).GetEnumValue() )
1292 : {
1293 : case SVX_ESCAPEMENT_SUPERSCRIPT:
1294 : case SVX_ESCAPEMENT_SUBSCRIPT:
1295 0 : eState = HTML_ON_VALUE;
1296 0 : break;
1297 : case SVX_ESCAPEMENT_OFF:
1298 0 : eState = HTML_OFF_VALUE;
1299 0 : break;
1300 : default:
1301 : ;
1302 : }
1303 0 : break;
1304 :
1305 : case RES_CHRATR_UNDERLINE:
1306 0 : switch( ((const SvxUnderlineItem&)rItem).GetLineStyle() )
1307 : {
1308 : case UNDERLINE_SINGLE:
1309 0 : eState = HTML_ON_VALUE;
1310 0 : break;
1311 : case UNDERLINE_NONE:
1312 0 : eState = HTML_OFF_VALUE;
1313 0 : break;
1314 : default:
1315 0 : if( IsHTMLMode(HTMLMODE_SOME_STYLES) )
1316 0 : eState = HTML_STYLE_VALUE;
1317 0 : break;
1318 : }
1319 0 : break;
1320 :
1321 : case RES_CHRATR_OVERLINE:
1322 : case RES_CHRATR_HIDDEN:
1323 0 : if( IsHTMLMode(HTMLMODE_SOME_STYLES) )
1324 0 : eState = HTML_STYLE_VALUE;
1325 0 : break;
1326 :
1327 : case RES_CHRATR_WEIGHT:
1328 : case RES_CHRATR_CJK_WEIGHT:
1329 : case RES_CHRATR_CTL_WEIGHT:
1330 5 : switch( ((const SvxWeightItem&)rItem).GetWeight() )
1331 : {
1332 : case WEIGHT_BOLD:
1333 5 : eState = HTML_ON_VALUE;
1334 5 : break;
1335 : case WEIGHT_NORMAL:
1336 0 : eState = HTML_OFF_VALUE;
1337 0 : break;
1338 : default:
1339 0 : if( IsHTMLMode(HTMLMODE_SOME_STYLES) )
1340 0 : eState = HTML_STYLE_VALUE;
1341 0 : break;
1342 : }
1343 5 : break;
1344 :
1345 : case RES_CHRATR_BLINK:
1346 0 : eState = ((const SvxBlinkItem&)rItem).GetValue() ? HTML_ON_VALUE
1347 0 : : HTML_OFF_VALUE;
1348 0 : break;
1349 :
1350 : case RES_CHRATR_COLOR:
1351 5 : eState = HTML_COLOR_VALUE;
1352 5 : break;
1353 :
1354 : case RES_CHRATR_FONT:
1355 : case RES_CHRATR_FONTSIZE:
1356 : case RES_CHRATR_LANGUAGE:
1357 : case RES_CHRATR_CJK_FONT:
1358 : case RES_CHRATR_CJK_FONTSIZE:
1359 : case RES_CHRATR_CJK_LANGUAGE:
1360 : case RES_CHRATR_CTL_FONT:
1361 : case RES_CHRATR_CTL_FONTSIZE:
1362 : case RES_CHRATR_CTL_LANGUAGE:
1363 : case RES_TXTATR_INETFMT:
1364 6 : eState = HTML_REAL_VALUE;
1365 6 : break;
1366 :
1367 : case RES_TXTATR_CHARFMT:
1368 0 : eState = HTML_CHRFMT_VALUE;
1369 0 : break;
1370 :
1371 : case RES_TXTATR_AUTOFMT:
1372 5 : eState = HTML_AUTOFMT_VALUE;
1373 5 : break;
1374 :
1375 : case RES_CHRATR_CASEMAP:
1376 5 : eState = HTML_STYLE_VALUE;
1377 5 : break;
1378 :
1379 : case RES_CHRATR_KERNING:
1380 0 : if( IsHTMLMode(HTMLMODE_FULL_STYLES) )
1381 0 : eState = HTML_STYLE_VALUE;
1382 0 : break;
1383 :
1384 : case RES_CHRATR_BACKGROUND:
1385 0 : if( IsHTMLMode(HTMLMODE_SOME_STYLES) )
1386 0 : eState = HTML_STYLE_VALUE;
1387 0 : break;
1388 :
1389 : case RES_PARATR_DROP:
1390 0 : eState = HTML_DROPCAP_VALUE;
1391 0 : break;
1392 : }
1393 :
1394 41 : return eState;
1395 : }
1396 :
1397 5 : sal_Bool HTMLEndPosLst::ExistsOnTagItem( sal_uInt16 nWhich, xub_StrLen nPos )
1398 : {
1399 21 : for( sal_uInt16 i=0; i<aStartLst.size(); i++ )
1400 : {
1401 16 : HTMLSttEndPos *pTest = aStartLst[i];
1402 :
1403 16 : if( pTest->GetStart() > nPos )
1404 : {
1405 : // dieses uns alle folgenden Attribute beginnen spaeter
1406 0 : break;
1407 : }
1408 16 : else if( pTest->GetEnd() > nPos )
1409 : {
1410 : // das Attribut beginnt vor oder an der aktuellen Position
1411 : // und endet hinter ihr
1412 16 : const SfxPoolItem *pItem = pTest->GetItem();
1413 16 : if( pItem->Which() == nWhich &&
1414 0 : HTML_ON_VALUE == GetHTMLItemState(*pItem) )
1415 : {
1416 : // ein On-Tag-Attibut wurde gefunden
1417 0 : return sal_True;
1418 : }
1419 : }
1420 : }
1421 :
1422 5 : return sal_False;
1423 : }
1424 :
1425 0 : sal_Bool HTMLEndPosLst::ExistsOffTagItem( sal_uInt16 nWhich, xub_StrLen nStartPos,
1426 : xub_StrLen nEndPos )
1427 : {
1428 0 : if( nWhich != RES_CHRATR_CROSSEDOUT &&
1429 0 : nWhich != RES_CHRATR_UNDERLINE &&
1430 : nWhich != RES_CHRATR_BLINK )
1431 : {
1432 0 : return sal_False;
1433 : }
1434 :
1435 0 : for( sal_uInt16 i=0; i<aStartLst.size(); i++ )
1436 : {
1437 0 : HTMLSttEndPos *pTest = aStartLst[i];
1438 :
1439 0 : if( pTest->GetStart() > nStartPos )
1440 : {
1441 : // dieses uns alle folgenden Attribute beginnen spaeter
1442 0 : break;
1443 : }
1444 0 : else if( pTest->GetStart()==nStartPos &&
1445 0 : pTest->GetEnd()==nEndPos )
1446 : {
1447 : // das Attribut beginnt vor oder an der aktuellen Position
1448 : // und endet hinter ihr
1449 0 : const SfxPoolItem *pItem = pTest->GetItem();
1450 0 : sal_uInt16 nTstWhich = pItem->Which() ;
1451 0 : if( (nTstWhich == RES_CHRATR_CROSSEDOUT ||
1452 0 : nTstWhich == RES_CHRATR_UNDERLINE ||
1453 0 : nTstWhich == RES_CHRATR_BLINK) &&
1454 0 : HTML_OFF_VALUE == GetHTMLItemState(*pItem) )
1455 : {
1456 : // Ein Off-Tag-Attibut wurde gefunden, das genauso
1457 : // exportiert wird, wie das aktuelle Item
1458 0 : return sal_True;
1459 : }
1460 : }
1461 : }
1462 :
1463 0 : return sal_False;
1464 : }
1465 :
1466 0 : void HTMLEndPosLst::FixSplittedItem( HTMLSttEndPos *pPos, xub_StrLen nNewEnd,
1467 : sal_uInt16 nStartPos )
1468 : {
1469 : // die End-Position entsprechend fixen
1470 0 : pPos->SetEnd( nNewEnd );
1471 :
1472 : // das Item aus der End-Liste entfernen
1473 0 : sal_uInt16 nEndPos = _FindEndPos( pPos );
1474 0 : if( nEndPos != USHRT_MAX )
1475 0 : aEndLst.erase( aEndLst.begin() + nEndPos );
1476 :
1477 : // es wird von nun an als letztes an der entsprechenden Position
1478 : // beendet
1479 0 : for( nEndPos=0; nEndPos < aEndLst.size() &&
1480 0 : aEndLst[nEndPos]->GetEnd() <= nNewEnd; nEndPos++ )
1481 : ;
1482 0 : aEndLst.insert( aEndLst.begin() + nEndPos, pPos );
1483 :
1484 : // jetzt noch die spaeter gestarteten Attribute anpassen
1485 0 : for( sal_uInt16 i=nStartPos+1; i<aStartLst.size(); i++ )
1486 : {
1487 0 : HTMLSttEndPos *pTest = aStartLst[i];
1488 0 : xub_StrLen nTestEnd = pTest->GetEnd();
1489 0 : if( pTest->GetStart() >= nNewEnd )
1490 : {
1491 : // das Test-Attribut und alle folgenden beginnen, nachdem das
1492 : // gesplittete Attribut endet
1493 0 : break;
1494 : }
1495 0 : else if( nTestEnd > nNewEnd )
1496 : {
1497 : // das Test-Attribut beginnt, bevor das gesplittete Attribut
1498 : // endet und endet danach, muss also auch gesplittet werden
1499 :
1500 : // das neue Ende setzen
1501 0 : pTest->SetEnd( nNewEnd );
1502 :
1503 : // das Attribut aus der End-Liste entfernen
1504 0 : sal_uInt16 nEPos = _FindEndPos( pTest );
1505 0 : if( nEPos != USHRT_MAX )
1506 0 : aEndLst.erase( aEndLst.begin() + nEPos );
1507 :
1508 : // es endet jetzt als erstes Attribut an der entsprechenden
1509 : // Position. Diese Position in der Ende-Liste kennen wir schon.
1510 0 : aEndLst.insert( aEndLst.begin() + nEndPos, pTest );
1511 :
1512 : // den "Rest" des Attributs neu einfuegen
1513 0 : InsertItem( *pTest->GetItem(), nNewEnd, nTestEnd );
1514 : }
1515 : }
1516 0 : }
1517 :
1518 :
1519 21 : void HTMLEndPosLst::InsertItem( const SfxPoolItem& rItem, xub_StrLen nStart,
1520 : xub_StrLen nEnd )
1521 : {
1522 : sal_uInt16 i;
1523 21 : for( i = 0; i < aEndLst.size(); i++ )
1524 : {
1525 16 : HTMLSttEndPos *pTest = aEndLst[i];
1526 16 : xub_StrLen nTestEnd = pTest->GetEnd();
1527 16 : if( nTestEnd <= nStart )
1528 : {
1529 : // das Test-Attribut endet, bevor das neue beginnt
1530 0 : continue;
1531 : }
1532 16 : else if( nTestEnd < nEnd )
1533 : {
1534 : // das Test-Attribut endet, bevor das neue endet. Das
1535 : // neue Attribut muss deshalb aufgesplittet werden
1536 0 : _InsertItem( new HTMLSttEndPos( rItem, nStart, nTestEnd ), i );
1537 0 : nStart = nTestEnd;
1538 : }
1539 : else
1540 : {
1541 : // das Test-Attribut (und alle folgenden) endet, bevor das neue
1542 : // endet
1543 16 : break;
1544 : }
1545 : }
1546 :
1547 : // ein Attribut muss noch eingefuegt werden
1548 21 : _InsertItem( new HTMLSttEndPos( rItem, nStart, nEnd ), i );
1549 21 : }
1550 :
1551 :
1552 :
1553 0 : void HTMLEndPosLst::SplitItem( const SfxPoolItem& rItem, xub_StrLen nStart,
1554 : xub_StrLen nEnd )
1555 : {
1556 0 : sal_uInt16 nWhich = rItem.Which();
1557 :
1558 : // erstmal muessen wir die alten Items anhand der Startliste suchen
1559 : // und die neuen Item-Bereiche festlegen
1560 :
1561 0 : for( sal_uInt16 i=0; i<aStartLst.size(); i++ )
1562 : {
1563 0 : HTMLSttEndPos *pTest = aStartLst[i];
1564 0 : xub_StrLen nTestStart = pTest->GetStart();
1565 0 : xub_StrLen nTestEnd = pTest->GetEnd();
1566 :
1567 0 : if( nTestStart >= nEnd )
1568 : {
1569 : // dieses und alle nachfolgenden Attribute beginnen spaeter
1570 0 : break;
1571 : }
1572 0 : else if( nTestEnd > nStart )
1573 : {
1574 : // das Test Attribut endet im zu loeschenenden Bereich
1575 0 : const SfxPoolItem *pItem = pTest->GetItem();
1576 :
1577 : // nur entsprechende On-Tag Attribute muessen beruecksichtigt
1578 : // werden
1579 0 : if( pItem->Which() == nWhich &&
1580 0 : HTML_ON_VALUE == GetHTMLItemState( *pItem ) )
1581 : {
1582 0 : bool bDelete = true;
1583 :
1584 0 : if( nTestStart < nStart )
1585 : {
1586 : // der Start des neuen Attribut entspricht
1587 : // dem neuen Ende des Attribts
1588 0 : FixSplittedItem( pTest, nStart, i );
1589 0 : bDelete = false;
1590 : }
1591 : else
1592 : {
1593 : // das Test-Item beginnt erst hinter dem neuen
1594 : // Ende des Attribts und kann deshalb komplett
1595 : // geloescht werden
1596 0 : aStartLst.erase( aStartLst.begin() + i );
1597 0 : i--;
1598 :
1599 0 : sal_uInt16 nEndPos = _FindEndPos( pTest );
1600 0 : if( nEndPos != USHRT_MAX )
1601 0 : aEndLst.erase( aEndLst.begin() + nEndPos );
1602 : }
1603 :
1604 : // ggf den zweiten Teil des gesplitteten Attribts einfuegen
1605 0 : if( nTestEnd > nEnd )
1606 : {
1607 0 : InsertItem( *pTest->GetItem(), nEnd, nTestEnd );
1608 : }
1609 :
1610 0 : if( bDelete )
1611 0 : delete pTest;
1612 : }
1613 : }
1614 : }
1615 0 : }
1616 :
1617 0 : const SwHTMLFmtInfo *HTMLEndPosLst::GetFmtInfo( const SwFmt& rFmt,
1618 : SwHTMLFmtInfos& rFmtInfos )
1619 : {
1620 : SwHTMLFmtInfo *pFmtInfo;
1621 0 : const SwHTMLFmtInfo aFmtInfo( &rFmt );
1622 0 : SwHTMLFmtInfos::iterator it = rFmtInfos.find( aFmtInfo );
1623 0 : if( it != rFmtInfos.end() )
1624 : {
1625 0 : pFmtInfo = &*it;
1626 : }
1627 : else
1628 : {
1629 : pFmtInfo = new SwHTMLFmtInfo( &rFmt, pDoc, pTemplate,
1630 0 : bOutStyles );
1631 0 : rFmtInfos.insert( pFmtInfo );
1632 0 : String aName( rFmt.GetName() );
1633 0 : if( 0 != rScriptTxtStyles.count( aName ) )
1634 0 : ((SwHTMLFmtInfo *)pFmtInfo)->bScriptDependent = true;
1635 : }
1636 :
1637 0 : return pFmtInfo;
1638 : }
1639 :
1640 263 : HTMLEndPosLst::HTMLEndPosLst( SwDoc *pD, SwDoc* pTempl,
1641 : const Color* pDfltCol, sal_Bool bStyles,
1642 : sal_uLong nMode, const String& rText,
1643 : std::set<String>& rStyles ):
1644 : pDoc( pD ),
1645 : pTemplate( pTempl ),
1646 : pDfltColor( pDfltCol ),
1647 : rScriptTxtStyles( rStyles ),
1648 : nHTMLMode( nMode ),
1649 263 : bOutStyles( bStyles )
1650 : {
1651 263 : xub_StrLen nEndPos = rText.Len();
1652 263 : xub_StrLen nPos = 0;
1653 531 : while( nPos < nEndPos )
1654 : {
1655 5 : sal_uInt16 nScript = g_pBreakIt->GetBreakIter()->getScriptType( rText, nPos );
1656 5 : nPos = (xub_StrLen)g_pBreakIt->GetBreakIter()->endOfScript( rText, nPos, nScript );
1657 5 : aScriptChgLst.push_back( nPos );
1658 5 : aScriptLst.push_back( nScript );
1659 : }
1660 263 : }
1661 :
1662 263 : HTMLEndPosLst::~HTMLEndPosLst()
1663 : {
1664 : OSL_ENSURE(aStartLst.empty(), "Start List not empty in destructor");
1665 : OSL_ENSURE(aEndLst.empty(), "End List not empty in destructor");
1666 263 : }
1667 :
1668 :
1669 :
1670 838 : void HTMLEndPosLst::InsertNoScript( const SfxPoolItem& rItem,
1671 : xub_StrLen nStart, xub_StrLen nEnd,
1672 : SwHTMLFmtInfos& rFmtInfos, sal_Bool bParaAttrs )
1673 : {
1674 : // kein Bereich ?? dann nicht aufnehmen, wird nie wirksam !!
1675 838 : if( nStart != nEnd )
1676 : {
1677 41 : sal_Bool bSet = sal_False, bSplit = sal_False;
1678 41 : switch( GetHTMLItemState(rItem) )
1679 : {
1680 : case HTML_ON_VALUE:
1681 : // das Attribut wird ausgegeben, wenn es nicht sowieso
1682 : // schon an ist
1683 5 : if( !ExistsOnTagItem( rItem.Which(), nStart ) )
1684 5 : bSet = sal_True;
1685 5 : break;
1686 :
1687 : case HTML_OFF_VALUE:
1688 : // wenn das entsprechne Attribut an ist, wird es gesplittet,
1689 : // Zusaetlich wird es aber als Style ausgegeben, wenn es nicht
1690 : // am ganzen Absatz gesetzt ist, weil es dann ja schon mit dem
1691 : // ABsatz-Tag ausgegeben wurde.
1692 0 : if( ExistsOnTagItem( rItem.Which(), nStart ) )
1693 0 : bSplit = sal_True;
1694 0 : bSet = bOutStyles && !bParaAttrs &&
1695 0 : !ExistsOffTagItem( rItem.Which(), nStart, nEnd );
1696 0 : break;
1697 :
1698 : case HTML_REAL_VALUE:
1699 : // das Attribut kann immer ausgegeben werden
1700 6 : bSet = sal_True;
1701 6 : break;
1702 :
1703 : case HTML_STYLE_VALUE:
1704 : // Das Attribut kann nur als CSS1 ausgegeben werden. Wenn
1705 : // es am Absatz gesetzt ist, wurde es schon mit dem
1706 : // Absatz-Tag ausgegeben. Einzige Ausnahme ist das
1707 : // Zeichen-Hintergrund-Attribut. Es muss immer wie ein
1708 : // Hint behandelt werden.
1709 10 : bSet = bOutStyles &&
1710 : (!bParaAttrs
1711 0 : || rItem.Which()==RES_CHRATR_BACKGROUND
1712 5 : || rItem.Which()==RES_CHRATR_OVERLINE);
1713 5 : break;
1714 :
1715 : case HTML_CHRFMT_VALUE:
1716 : {
1717 : OSL_ENSURE( RES_TXTATR_CHARFMT == rItem.Which(),
1718 : "Doch keine Zeichen-Vorlage" );
1719 0 : const SwFmtCharFmt& rChrFmt = (const SwFmtCharFmt&)rItem;
1720 0 : const SwCharFmt* pFmt = rChrFmt.GetCharFmt();
1721 :
1722 0 : const SwHTMLFmtInfo *pFmtInfo = GetFmtInfo( *pFmt, rFmtInfos );
1723 0 : if( !pFmtInfo->aToken.isEmpty() )
1724 : {
1725 : // das Zeichenvorlagen-Tag muss vor den harten
1726 : // Attributen ausgegeben werden
1727 0 : InsertItem( rItem, nStart, nEnd );
1728 : }
1729 0 : if( pFmtInfo->pItemSet )
1730 : {
1731 : Insert( *pFmtInfo->pItemSet, nStart, nEnd,
1732 0 : rFmtInfos, sal_True, bParaAttrs );
1733 : }
1734 : }
1735 0 : break;
1736 :
1737 : case HTML_AUTOFMT_VALUE:
1738 : {
1739 5 : const SwFmtAutoFmt& rAutoFmt = (const SwFmtAutoFmt&)rItem;
1740 5 : const boost::shared_ptr<SfxItemSet> pSet = rAutoFmt.GetStyleHandle();
1741 5 : if( pSet.get() )
1742 5 : Insert( *pSet.get(), nStart, nEnd, rFmtInfos, sal_True, bParaAttrs );
1743 : }
1744 5 : break;
1745 :
1746 : case HTML_COLOR_VALUE:
1747 : // Eine Vordergrund-Farbe als Absatz-Attribut wird nur
1748 : // exportiert, wenn sie nicht der Default-Farbe entspricht.
1749 : {
1750 : OSL_ENSURE( RES_CHRATR_COLOR == rItem.Which(),
1751 : "Doch keine Vordergrund-Farbe" );
1752 5 : Color aColor( ((const SvxColorItem&)rItem).GetValue() );
1753 5 : if( COL_AUTO == aColor.GetColor() )
1754 0 : aColor.SetColor( COL_BLACK );
1755 5 : bSet = !bParaAttrs || !pDfltColor ||
1756 5 : !pDfltColor->IsRGBEqual( aColor );
1757 : }
1758 5 : break;
1759 :
1760 : case HTML_DROPCAP_VALUE:
1761 : {
1762 : OSL_ENSURE( RES_PARATR_DROP == rItem.Which(),
1763 : "Doch kein Drop-Cap" );
1764 0 : const SwFmtDrop& rDrop = (const SwFmtDrop&)rItem;
1765 0 : nEnd = nStart + rDrop.GetChars();
1766 0 : if( !bOutStyles )
1767 : {
1768 : // Zumindest die Attribute der Zeichenvorlage uebernehmen
1769 0 : const SwCharFmt *pCharFmt = rDrop.GetCharFmt();
1770 0 : if( pCharFmt )
1771 : {
1772 0 : Insert( pCharFmt->GetAttrSet(), nStart, nEnd,
1773 0 : rFmtInfos, sal_True, bParaAttrs );
1774 : }
1775 : }
1776 : else
1777 : {
1778 0 : bSet = sal_True;
1779 : }
1780 : }
1781 0 : break;
1782 : default:
1783 : ;
1784 : }
1785 :
1786 41 : if( bSet )
1787 21 : InsertItem( rItem, nStart, nEnd );
1788 41 : if( bSplit )
1789 0 : SplitItem( rItem, nStart, nEnd );
1790 : }
1791 838 : }
1792 :
1793 1923 : void HTMLEndPosLst::Insert( const SfxPoolItem& rItem,
1794 : xub_StrLen nStart, xub_StrLen nEnd,
1795 : SwHTMLFmtInfos& rFmtInfos, sal_Bool bParaAttrs )
1796 : {
1797 1923 : sal_Bool bDependsOnScript = sal_False, bDependsOnAnyScript = sal_False;
1798 1923 : sal_uInt16 nScript = i18n::ScriptType::LATIN;
1799 1923 : switch( rItem.Which() )
1800 : {
1801 : case RES_CHRATR_FONT:
1802 : case RES_CHRATR_FONTSIZE:
1803 : case RES_CHRATR_LANGUAGE:
1804 : case RES_CHRATR_POSTURE:
1805 : case RES_CHRATR_WEIGHT:
1806 156 : bDependsOnScript = sal_True;
1807 156 : nScript = i18n::ScriptType::LATIN;
1808 156 : break;
1809 :
1810 : case RES_CHRATR_CJK_FONT:
1811 : case RES_CHRATR_CJK_FONTSIZE:
1812 : case RES_CHRATR_CJK_LANGUAGE:
1813 : case RES_CHRATR_CJK_POSTURE:
1814 : case RES_CHRATR_CJK_WEIGHT:
1815 369 : bDependsOnScript = sal_True;
1816 369 : nScript = i18n::ScriptType::ASIAN;
1817 369 : break;
1818 :
1819 : case RES_CHRATR_CTL_FONT:
1820 : case RES_CHRATR_CTL_FONTSIZE:
1821 : case RES_CHRATR_CTL_LANGUAGE:
1822 : case RES_CHRATR_CTL_POSTURE:
1823 : case RES_CHRATR_CTL_WEIGHT:
1824 571 : bDependsOnScript = sal_True;
1825 571 : nScript = i18n::ScriptType::COMPLEX;
1826 571 : break;
1827 : case RES_TXTATR_CHARFMT:
1828 : {
1829 0 : const SwFmtCharFmt& rChrFmt = (const SwFmtCharFmt&)rItem;
1830 0 : const SwCharFmt* pFmt = rChrFmt.GetCharFmt();
1831 0 : const SwHTMLFmtInfo *pFmtInfo = GetFmtInfo( *pFmt, rFmtInfos );
1832 0 : if( pFmtInfo->bScriptDependent )
1833 : {
1834 0 : bDependsOnScript = sal_True;
1835 0 : bDependsOnAnyScript = sal_True;
1836 : }
1837 : }
1838 0 : break;
1839 : case RES_TXTATR_INETFMT:
1840 : {
1841 0 : if( GetFmtInfo( *pDoc->GetCharFmtFromPool(
1842 0 : RES_POOLCHR_INET_NORMAL), rFmtInfos )->bScriptDependent ||
1843 : GetFmtInfo( *pDoc->GetCharFmtFromPool(
1844 0 : RES_POOLCHR_INET_VISIT), rFmtInfos )->bScriptDependent )
1845 : {
1846 0 : bDependsOnScript = sal_True;
1847 0 : bDependsOnAnyScript = sal_True;
1848 : }
1849 : }
1850 0 : break;
1851 : }
1852 :
1853 1923 : if( bDependsOnScript )
1854 : {
1855 1096 : xub_StrLen nPos = nStart;
1856 1096 : for( size_t i=0; i < aScriptChgLst.size(); i++ )
1857 : {
1858 51 : xub_StrLen nChgPos = aScriptChgLst[i];
1859 51 : if( nPos >= nChgPos )
1860 : {
1861 : // the hint starts behind or at the next script change,
1862 : // so we may continue with this position.
1863 0 : continue;
1864 : }
1865 51 : if( nEnd <= nChgPos )
1866 : {
1867 : // the (rest of) the hint ends before or at the next script
1868 : // change, so we can insert it, but only if it belongs
1869 : // to the current script.
1870 51 : if( bDependsOnAnyScript || nScript == aScriptLst[i] )
1871 : InsertNoScript( rItem, nPos, nEnd, rFmtInfos,
1872 11 : bParaAttrs );
1873 51 : break;
1874 : }
1875 :
1876 : // the hint starts before the next script change and ends behind
1877 : // it, so we can insert a hint upto the next script change and
1878 : // continue with the rest of the hint.
1879 0 : if( bDependsOnAnyScript || nScript == aScriptLst[i] )
1880 0 : InsertNoScript( rItem, nPos, nChgPos, rFmtInfos, bParaAttrs );
1881 0 : nPos = nChgPos;
1882 : }
1883 : }
1884 : else
1885 : {
1886 827 : InsertNoScript( rItem, nStart, nEnd, rFmtInfos, bParaAttrs );
1887 : }
1888 1923 : }
1889 :
1890 268 : void HTMLEndPosLst::Insert( const SfxItemSet& rItemSet,
1891 : xub_StrLen nStart, xub_StrLen nEnd,
1892 : SwHTMLFmtInfos& rFmtInfos,
1893 : sal_Bool bDeep, sal_Bool bParaAttrs )
1894 : {
1895 268 : SfxWhichIter aIter( rItemSet );
1896 :
1897 268 : sal_uInt16 nWhich = aIter.FirstWhich();
1898 27572 : while( nWhich )
1899 : {
1900 : const SfxPoolItem *pItem;
1901 27036 : if( SFX_ITEM_SET == rItemSet.GetItemState( nWhich, bDeep, &pItem ) )
1902 : {
1903 1918 : Insert( *pItem, nStart, nEnd, rFmtInfos, bParaAttrs );
1904 : }
1905 :
1906 27036 : nWhich = aIter.NextWhich();
1907 268 : }
1908 268 : }
1909 :
1910 0 : void HTMLEndPosLst::Insert( const SwDrawFrmFmt& rFmt, xub_StrLen nPos,
1911 : SwHTMLFmtInfos& rFmtInfos )
1912 : {
1913 : // der Type-Cast ist nur noetig, um nicht seinetwegen
1914 : // svdrwobt.hxx zu includem
1915 : const SdrObject* pTextObj =
1916 0 : (const SdrObject *)SwHTMLWriter::GetMarqueeTextObj( rFmt );
1917 :
1918 0 : if( pTextObj )
1919 : {
1920 : // die Edit-Engine-Attribute des Objekts als SW-Attribute holen
1921 : // und als Hints einsortieren. Wegen der Menge der Hints werden
1922 : // Styles hierbei nicht beruecksichtigt!
1923 0 : const SfxItemSet& rFmtItemSet = rFmt.GetAttrSet();
1924 0 : SfxItemSet aItemSet( *rFmtItemSet.GetPool(), RES_CHRATR_BEGIN,
1925 0 : RES_CHRATR_END );
1926 0 : SwHTMLWriter::GetEEAttrsFromDrwObj( aItemSet, pTextObj, sal_True );
1927 0 : sal_Bool bOutStylesOld = bOutStyles;
1928 0 : bOutStyles = sal_False;
1929 0 : Insert( aItemSet, nPos, nPos+1, rFmtInfos, sal_False, sal_False );
1930 0 : bOutStyles = bOutStylesOld;
1931 : }
1932 0 : }
1933 :
1934 0 : sal_uInt16 HTMLEndPosLst::GetScriptAtPos( xub_StrLen nPos ,
1935 : sal_uInt16 nWeak )
1936 : {
1937 0 : sal_uInt16 nRet = CSS1_OUTMODE_ANY_SCRIPT;
1938 :
1939 0 : size_t nScriptChgs = aScriptChgLst.size();
1940 0 : size_t i=0;
1941 0 : while( i < nScriptChgs && nPos >= aScriptChgLst[i] )
1942 0 : i++;
1943 : OSL_ENSURE( i < nScriptChgs, "script list is to short" );
1944 0 : if( i < nScriptChgs )
1945 : {
1946 0 : if( i18n::ScriptType::WEAK == aScriptLst[i] )
1947 0 : nRet = nWeak;
1948 : else
1949 0 : nRet = SwHTMLWriter::GetCSS1ScriptForScriptType( aScriptLst[i] );
1950 : }
1951 :
1952 0 : return nRet;
1953 : }
1954 :
1955 24 : void HTMLEndPosLst::OutStartAttrs( SwHTMLWriter& rHWrt, xub_StrLen nPos,
1956 : HTMLOutContext *pContext )
1957 : {
1958 24 : rHWrt.bTagOn = sal_True;
1959 :
1960 : // die Attribute in der Start-Liste sind aufsteigend sortiert
1961 123 : for( sal_uInt16 i=0; i< aStartLst.size(); i++ )
1962 : {
1963 99 : HTMLSttEndPos *pPos = aStartLst[i];
1964 99 : xub_StrLen nStart = pPos->GetStart();
1965 99 : if( nStart > nPos )
1966 : {
1967 : // dieses und alle folgenden Attribute werden erst noch geoeffnet
1968 0 : break;
1969 : }
1970 99 : else if( nStart == nPos )
1971 : {
1972 : // das Attribut ausgeben
1973 21 : sal_uInt16 nCSS1Script = rHWrt.nCSS1Script;
1974 21 : sal_uInt16 nWhich = pPos->GetItem()->Which();
1975 21 : if( RES_TXTATR_CHARFMT == nWhich ||
1976 21 : RES_TXTATR_INETFMT == nWhich ||
1977 : RES_PARATR_DROP == nWhich )
1978 : {
1979 0 : rHWrt.nCSS1Script = GetScriptAtPos( nPos, nCSS1Script );
1980 : }
1981 21 : if( pContext )
1982 : {
1983 5 : HTMLOutFuncs::FlushToAscii( rHWrt.Strm(), *pContext );
1984 5 : pContext = 0; // one time ony
1985 : }
1986 21 : Out( aHTMLAttrFnTab, *pPos->GetItem(), rHWrt );
1987 21 : rHWrt.nCSS1Script = nCSS1Script;
1988 : }
1989 : }
1990 24 : }
1991 :
1992 311 : void HTMLEndPosLst::OutEndAttrs( SwHTMLWriter& rHWrt, xub_StrLen nPos,
1993 : HTMLOutContext *pContext )
1994 : {
1995 311 : rHWrt.bTagOn = sal_False;
1996 :
1997 : // die Attribute in der End-Liste sind aufsteigend sortiert
1998 311 : sal_uInt16 i=0;
1999 643 : while( i < aEndLst.size() )
2000 : {
2001 64 : HTMLSttEndPos *pPos = aEndLst[i];
2002 64 : xub_StrLen nEnd = pPos->GetEnd();
2003 :
2004 64 : if( STRING_MAXLEN==nPos || nEnd == nPos )
2005 : {
2006 21 : if( pContext )
2007 : {
2008 0 : HTMLOutFuncs::FlushToAscii( rHWrt.Strm(), *pContext );
2009 0 : pContext = 0; // one time ony
2010 : }
2011 21 : Out( aHTMLAttrFnTab, *pPos->GetItem(), rHWrt );
2012 21 : _RemoveItem( i );
2013 : }
2014 43 : else if( nEnd > nPos )
2015 : {
2016 : // dieses und alle folgenden Attribute werden erst spaeter beendet
2017 43 : break;
2018 : }
2019 : else
2020 : {
2021 : // Das Attribut wird vor der aktuellen Position beendet. Das
2022 : // darf nicht sein, aber wie koennen trotzdem damit umgehen
2023 : OSL_ENSURE( nEnd >= nPos,
2024 : "Das Attribut sollte schon laengst beendet sein" );
2025 0 : i++;
2026 : }
2027 : }
2028 311 : }
2029 :
2030 :
2031 : /* Ausgabe der Nodes */
2032 263 : Writer& OutHTML_SwTxtNode( Writer& rWrt, const SwCntntNode& rNode )
2033 : {
2034 263 : SwTxtNode * pNd = &((SwTxtNode&)rNode);
2035 263 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
2036 :
2037 263 : const String& rStr = pNd->GetTxt();
2038 263 : xub_StrLen nEnde = rStr.Len();
2039 :
2040 : // Besonderheit: leere Node und HR-Vorlage (horizontaler Strich)
2041 : // nur ein <HR> ausgeben
2042 263 : sal_uInt16 nPoolId = pNd->GetAnyFmtColl().GetPoolFmtId();
2043 :
2044 521 : if( !nEnde && (RES_POOLCOLL_HTML_HR==nPoolId ||
2045 258 : pNd->GetAnyFmtColl().GetName().EqualsAscii( OOO_STRING_SVTOOLS_HTML_horzrule) ) )
2046 : {
2047 : // dann die absatz-gebundenen Grafiken/OLE-Objekte im Absatz
2048 : // MIB 8.7.97: Ein <PRE> spannen wir um die Linie auf. Dann stimmen
2049 : // zwar die Abstaende nicht, aber sonst bekommen wir einen leeren
2050 : // Absatz hinter dem <HR> und das ist noch unschoener.
2051 0 : rHTMLWrt.ChangeParaToken( 0 );
2052 :
2053 : // Alle an dem Node verankerten Rahmen ausgeben
2054 0 : rHTMLWrt.OutFlyFrm( rNode.GetIndex(), 0, HTML_POS_ANY );
2055 :
2056 0 : if( rHTMLWrt.bLFPossible )
2057 0 : rHTMLWrt.OutNewLine(); // Absatz-Tag in eine neue Zeile
2058 :
2059 0 : rHTMLWrt.bLFPossible = sal_True;
2060 :
2061 0 : OStringBuffer sOut;
2062 0 : sOut.append('<').append(OOO_STRING_SVTOOLS_HTML_horzrule);
2063 :
2064 0 : const SfxItemSet* pItemSet = pNd->GetpSwAttrSet();
2065 0 : if( !pItemSet )
2066 : {
2067 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr() << '>';
2068 0 : return rHTMLWrt;
2069 : }
2070 : const SfxPoolItem* pItem;
2071 0 : if( SFX_ITEM_SET == pItemSet->GetItemState( RES_LR_SPACE, sal_False, &pItem ))
2072 : {
2073 0 : sal_Int32 nLeft = ((SvxLRSpaceItem*)pItem)->GetLeft();
2074 0 : sal_Int32 nRight = ((SvxLRSpaceItem*)pItem)->GetRight();
2075 0 : if( nLeft || nRight )
2076 : {
2077 : const SwFrmFmt& rPgFmt =
2078 : rHTMLWrt.pDoc->GetPageDescFromPool
2079 0 : ( RES_POOLPAGE_HTML, false )->GetMaster();
2080 0 : const SwFmtFrmSize& rSz = rPgFmt.GetFrmSize();
2081 0 : const SvxLRSpaceItem& rLR = rPgFmt.GetLRSpace();
2082 0 : const SwFmtCol& rCol = rPgFmt.GetCol();
2083 :
2084 0 : long nPageWidth = rSz.GetWidth() - rLR.GetLeft() - rLR.GetRight();
2085 :
2086 0 : if( 1 < rCol.GetNumCols() )
2087 0 : nPageWidth /= rCol.GetNumCols();
2088 :
2089 0 : const SwTableNode* pTblNd = pNd->FindTableNode();
2090 0 : if( pTblNd )
2091 : {
2092 0 : const SwTableBox* pBox = pTblNd->GetTable().GetTblBox(
2093 0 : pNd->StartOfSectionIndex() );
2094 0 : if( pBox )
2095 0 : nPageWidth = pBox->GetFrmFmt()->GetFrmSize().GetWidth();
2096 : }
2097 :
2098 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_width)
2099 0 : .append('=');
2100 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
2101 0 : rWrt.OutULong( rHTMLWrt.ToPixel(nPageWidth-nLeft-nRight) );
2102 :
2103 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_align)
2104 0 : .append('=');
2105 0 : if( !nLeft )
2106 0 : sOut.append(OOO_STRING_SVTOOLS_HTML_AL_left);
2107 0 : else if( !nRight )
2108 0 : sOut.append(OOO_STRING_SVTOOLS_HTML_AL_right);
2109 : else
2110 0 : sOut.append(OOO_STRING_SVTOOLS_HTML_AL_center);
2111 : }
2112 : }
2113 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
2114 0 : if( SFX_ITEM_SET == pItemSet->GetItemState( RES_BOX, sal_False, &pItem ))
2115 : {
2116 0 : const SvxBoxItem* pBoxItem = (const SvxBoxItem*)pItem;
2117 0 : const editeng::SvxBorderLine* pBorderLine = pBoxItem->GetBottom();
2118 0 : if( pBorderLine )
2119 : {
2120 0 : sal_uInt16 nWidth = pBorderLine->GetOutWidth() +
2121 0 : pBorderLine->GetInWidth() +
2122 0 : pBorderLine->GetDistance();
2123 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_size)
2124 0 : .append('=');
2125 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
2126 0 : rWrt.OutULong( rHTMLWrt.ToPixel(nWidth) );
2127 :
2128 0 : const Color& rBorderColor = pBorderLine->GetColor();
2129 0 : if( !rBorderColor.IsRGBEqual( Color(COL_GRAY) ) )
2130 : {
2131 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_color)
2132 0 : .append('=');
2133 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
2134 0 : HTMLOutFuncs::Out_Color( rWrt.Strm(), rBorderColor,
2135 0 : rHTMLWrt.eDestEnc );
2136 : }
2137 :
2138 0 : if( !pBorderLine->GetInWidth() )
2139 : {
2140 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_noshade);
2141 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
2142 : }
2143 : }
2144 : }
2145 0 : rWrt.Strm() << '>';
2146 0 : return rHTMLWrt;
2147 : }
2148 :
2149 : // Die leeren Nodes mit 2pt Font-Hoehe und der Stand-Vorlage, die
2150 : // vor Tabellen und Bereichen eingefuegt werden, nicht exportieren,
2151 : // Bookmarks oder absatzgebundene Grafiken aber schon.
2152 : // MIB 21.7.97: Ausserdem auch keine leeren Tabellen-Zellen exportieren.
2153 263 : if( !nEnde && (nPoolId == RES_POOLCOLL_STANDARD ||
2154 206 : nPoolId == RES_POOLCOLL_TABLE ||
2155 : nPoolId == RES_POOLCOLL_TABLE_HDLN) )
2156 : {
2157 : // Der aktuelle Node ist leer und enthaelt Standard-Vorlage ...
2158 : const SfxPoolItem* pItem;
2159 52 : const SfxItemSet *pItemSet = pNd->GetpSwAttrSet();
2160 156 : if( pItemSet && pItemSet->Count() &&
2161 104 : SFX_ITEM_SET == pItemSet->GetItemState( RES_CHRATR_FONTSIZE, sal_False, &pItem ) &&
2162 0 : 40 == ((const SvxFontHeightItem *)pItem)->GetHeight() )
2163 : {
2164 : // ... ausserdem ist die 2pt Schrift eingestellt ...
2165 0 : sal_uLong nNdPos = rWrt.pCurPam->GetPoint()->nNode.GetIndex();
2166 0 : const SwNode *pNextNd = rWrt.pDoc->GetNodes()[nNdPos+1];
2167 0 : const SwNode *pPrevNd = rWrt.pDoc->GetNodes()[nNdPos-1];
2168 0 : sal_Bool bStdColl = nPoolId == RES_POOLCOLL_STANDARD;
2169 0 : if( ( bStdColl && (pNextNd->IsTableNode() ||
2170 0 : pNextNd->IsSectionNode()) ) ||
2171 0 : ( !bStdColl && pNextNd->IsEndNode() &&
2172 0 : pPrevNd->IsStartNode() &&
2173 : SwTableBoxStartNode==
2174 0 : pPrevNd->GetStartNode()->GetStartNodeType() ) )
2175 : {
2176 : // ... und er steht vor einer Tabelle ohne einem Bereich
2177 0 : rHTMLWrt.OutBookmarks();
2178 0 : rHTMLWrt.bLFPossible = !rHTMLWrt.nLastParaToken;
2179 :
2180 : // Alle an dem Node verankerten Rahmen ausgeben
2181 0 : rHTMLWrt.OutFlyFrm( rNode.GetIndex(), 0, HTML_POS_ANY );
2182 0 : rHTMLWrt.bLFPossible = sal_False;
2183 :
2184 0 : return rWrt;
2185 : }
2186 : }
2187 : }
2188 :
2189 : // PagePreaks uns PagDescs abfangen
2190 263 : sal_Bool bPageBreakBehind = sal_False;
2191 263 : if( rHTMLWrt.bCfgFormFeed &&
2192 263 : !(rHTMLWrt.bOutTable || rHTMLWrt.bOutFlyFrame) &&
2193 0 : rHTMLWrt.pStartNdIdx->GetIndex() !=
2194 0 : rHTMLWrt.pCurPam->GetPoint()->nNode.GetIndex() )
2195 : {
2196 0 : sal_Bool bPageBreakBefore = sal_False;
2197 : const SfxPoolItem* pItem;
2198 0 : const SfxItemSet* pItemSet = pNd->GetpSwAttrSet();
2199 :
2200 0 : if( pItemSet )
2201 : {
2202 0 : if( SFX_ITEM_SET ==
2203 0 : pItemSet->GetItemState( RES_PAGEDESC, sal_True, &pItem ) &&
2204 0 : ((SwFmtPageDesc *)pItem)->GetPageDesc() )
2205 0 : bPageBreakBefore = sal_True;
2206 0 : else if( SFX_ITEM_SET ==
2207 0 : pItemSet->GetItemState( RES_BREAK, sal_True, &pItem ) )
2208 : {
2209 0 : switch( ((SvxFmtBreakItem *)pItem)->GetBreak() )
2210 : {
2211 : case SVX_BREAK_PAGE_BEFORE:
2212 0 : bPageBreakBefore = sal_True;
2213 0 : break;
2214 : case SVX_BREAK_PAGE_AFTER:
2215 0 : bPageBreakBehind = sal_True;
2216 0 : break;
2217 : case SVX_BREAK_PAGE_BOTH:
2218 0 : bPageBreakBefore = sal_True;
2219 0 : bPageBreakBehind = sal_True;
2220 0 : break;
2221 : default:
2222 : ;
2223 : }
2224 : }
2225 : }
2226 :
2227 0 : if( bPageBreakBefore )
2228 0 : rWrt.Strm() << '\f';
2229 : }
2230 :
2231 : // eventuell eine Form oeffnen
2232 263 : rHTMLWrt.OutForm();
2233 :
2234 : // An dem Node "verankerte" Seitenegebunde Rahmen ausgeben
2235 : sal_Bool bFlysLeft = rHTMLWrt.OutFlyFrm( rNode.GetIndex(),
2236 263 : 0, HTML_POS_PREFIX );
2237 : // An dem Node verankerte Rahmen ausgeben, die vor dem
2238 : // Absatz-Tag geschrieben werden sollen.
2239 263 : if( bFlysLeft )
2240 : bFlysLeft = rHTMLWrt.OutFlyFrm( rNode.GetIndex(),
2241 0 : 0, HTML_POS_BEFORE );
2242 :
2243 263 : if( rHTMLWrt.pCurPam->GetPoint()->nNode == rHTMLWrt.pCurPam->GetMark()->nNode )
2244 260 : nEnde = rHTMLWrt.pCurPam->GetMark()->nContent.GetIndex();
2245 :
2246 : // gibt es harte Attribute, die als Optionen geschrieben werden muessen?
2247 263 : rHTMLWrt.bTagOn = sal_True;
2248 :
2249 : // jetzt das Tag des Absatzes ausgeben
2250 263 : const SwFmt& rFmt = pNd->GetAnyFmtColl();
2251 263 : SwHTMLTxtCollOutputInfo aFmtInfo;
2252 263 : sal_Bool bOldLFPossible = rHTMLWrt.bLFPossible;
2253 263 : OutHTML_SwFmt( rWrt, rFmt, pNd->GetpSwAttrSet(), aFmtInfo );
2254 :
2255 : // Wenn vor dem Absatz-Tag keine neue Zeile aufgemacht wurde, dann
2256 : // tun wir das jetzt
2257 263 : rHTMLWrt.bLFPossible = !rHTMLWrt.nLastParaToken;
2258 263 : if( !bOldLFPossible && rHTMLWrt.bLFPossible )
2259 0 : rHTMLWrt.OutNewLine();
2260 :
2261 :
2262 : // dann die Bookmarks (inkl. End-Tag)
2263 263 : rHTMLWrt.bOutOpts = sal_False;
2264 263 : rHTMLWrt.OutBookmarks();
2265 :
2266 : // jetzt ist noch mal eine gute Gelegenheit fuer ein LF, sofern es noch
2267 : // erlaubt ist
2268 526 : if( rHTMLWrt.bLFPossible &&
2269 263 : rHTMLWrt.GetLineLen() >= rHTMLWrt.nWhishLineLen )
2270 : {
2271 1 : rHTMLWrt.OutNewLine();
2272 : }
2273 263 : rHTMLWrt.bLFPossible = sal_False;
2274 :
2275 : // Text, der aus einer Outline-Numerierung kommt ermitteln
2276 263 : xub_StrLen nOffset = 0;
2277 526 : String aOutlineTxt;
2278 526 : String aFullText;
2279 :
2280 : // export numbering string as plain text only for the outline numbering,
2281 : // because the outline numbering isn't exported as a numbering - see <SwHTMLNumRuleInfo::Set(..)>
2282 263 : if ( pNd->IsOutline() &&
2283 0 : pNd->GetNumRule() == pNd->GetDoc()->GetOutlineNumRule() )
2284 : {
2285 0 : aOutlineTxt = pNd->GetNumString();
2286 0 : nOffset = nOffset + aOutlineTxt.Len();
2287 0 : aFullText = aOutlineTxt;
2288 : }
2289 526 : String aFootEndNoteSym;
2290 263 : if( rHTMLWrt.pFmtFtn )
2291 : {
2292 0 : aFootEndNoteSym = rHTMLWrt.GetFootEndNoteSym( *rHTMLWrt.pFmtFtn );
2293 0 : nOffset = nOffset + aFootEndNoteSym.Len();
2294 0 : aFullText += aFootEndNoteSym;
2295 : }
2296 :
2297 : // gibt es harte Attribute, die als Tags geschrieben werden muessen?
2298 263 : aFullText += rStr;
2299 : HTMLEndPosLst aEndPosLst( rWrt.pDoc, rHTMLWrt.pTemplate,
2300 : rHTMLWrt.pDfltColor, rHTMLWrt.bCfgOutStyles,
2301 : rHTMLWrt.GetHTMLMode(), aFullText,
2302 526 : rHTMLWrt.aScriptTextStyles );
2303 263 : if( aFmtInfo.pItemSet )
2304 : {
2305 : aEndPosLst.Insert( *aFmtInfo.pItemSet, 0, nEnde + nOffset,
2306 263 : rHTMLWrt.aChrFmtInfos, sal_False, sal_True );
2307 : }
2308 :
2309 :
2310 263 : if( aOutlineTxt.Len() || rHTMLWrt.pFmtFtn )
2311 : {
2312 : // Absatz-Attribute ausgeben, damit der Text die Attribute des
2313 : // Absatzes bekommt.
2314 0 : aEndPosLst.OutStartAttrs( rHTMLWrt, 0 );
2315 :
2316 : // Theoretisch muesste man hier die Zeichen-Vorlage der Numerierung
2317 : // beachten. Da man die ueber die UI nicht setzen kann, ignorieren
2318 : // wir sie erstmal.
2319 :
2320 0 : if( aOutlineTxt.Len() )
2321 0 : HTMLOutFuncs::Out_String( rWrt.Strm(), aOutlineTxt,
2322 0 : rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters);
2323 :
2324 0 : if( rHTMLWrt.pFmtFtn )
2325 : {
2326 : rHTMLWrt.OutFootEndNoteSym( *rHTMLWrt.pFmtFtn, aFootEndNoteSym,
2327 0 : aEndPosLst.GetScriptAtPos( aOutlineTxt.Len(), rHTMLWrt.nCSS1Script ) );
2328 0 : rHTMLWrt.pFmtFtn = 0;
2329 : }
2330 : }
2331 :
2332 : // erstmal den Start berichtigen. D.h. wird nur ein Teil vom Satz
2333 : // ausgegeben, so muessen auch da die Attribute stimmen!!
2334 263 : rHTMLWrt.bTxtAttr = sal_True;
2335 :
2336 :
2337 263 : sal_uInt16 nAttrPos = 0;
2338 263 : xub_StrLen nStrPos = rHTMLWrt.pCurPam->GetPoint()->nContent.GetIndex();
2339 263 : const SwTxtAttr * pHt = 0;
2340 263 : sal_uInt16 nCntAttr = pNd->HasHints() ? pNd->GetSwpHints().Count() : 0;
2341 263 : if( nCntAttr && nStrPos > *( pHt = pNd->GetSwpHints()[ 0 ] )->GetStart() )
2342 : {
2343 : // Ok, es gibt vorher Attribute, die ausgegeben werden muessen
2344 0 : do {
2345 0 : aEndPosLst.OutEndAttrs( rHTMLWrt, nStrPos + nOffset );
2346 :
2347 0 : nAttrPos++;
2348 0 : if( RES_TXTATR_FIELD == pHt->Which() ) // Felder nicht
2349 0 : continue; // ausgeben
2350 :
2351 0 : if ( pHt->GetEnd() && !pHt->HasDummyChar() )
2352 : {
2353 0 : xub_StrLen nHtEnd = *pHt->GetEnd(),
2354 0 : nHtStt = *pHt->GetStart();
2355 0 : if( !rHTMLWrt.bWriteAll && nHtEnd <= nStrPos )
2356 0 : continue;
2357 :
2358 : // leere Hints am Anfang nicht beachten, oder ??
2359 0 : if( nHtEnd == nHtStt )
2360 0 : continue;
2361 :
2362 : // Attribut in die Liste aufnehemen
2363 0 : if( rHTMLWrt.bWriteAll )
2364 0 : aEndPosLst.Insert( pHt->GetAttr(), nHtStt + nOffset,
2365 : nHtEnd + nOffset,
2366 0 : rHTMLWrt.aChrFmtInfos );
2367 : else
2368 : {
2369 0 : xub_StrLen nTmpStt = nHtStt < nStrPos ? nStrPos : nHtStt;
2370 0 : xub_StrLen nTmpEnd = nHtEnd < nEnde ? nHtEnd : nEnde;
2371 0 : aEndPosLst.Insert( pHt->GetAttr(), nTmpStt + nOffset,
2372 : nTmpEnd + nOffset,
2373 0 : rHTMLWrt.aChrFmtInfos );
2374 : }
2375 0 : continue;
2376 : // aber nicht ausgeben, das erfolgt spaeter !!
2377 : }
2378 :
2379 0 : } while( nAttrPos < nCntAttr && nStrPos >
2380 0 : *( pHt = pNd->GetSwpHints()[ nAttrPos ] )->GetStart() );
2381 :
2382 : // dann gebe mal alle gesammelten Attribute von der String-Pos aus
2383 0 : aEndPosLst.OutEndAttrs( rHTMLWrt, nStrPos + nOffset );
2384 0 : aEndPosLst.OutStartAttrs( rHTMLWrt, nStrPos + nOffset );
2385 : }
2386 :
2387 263 : sal_Bool bWriteBreak = (HTML_PREFORMTXT_ON != rHTMLWrt.nLastParaToken);
2388 263 : if( bWriteBreak && pNd->GetNumRule() )
2389 0 : bWriteBreak = sal_False;
2390 :
2391 : {
2392 263 : HTMLOutContext aContext( rHTMLWrt.eDestEnc );
2393 :
2394 263 : xub_StrLen nPreSplitPos = 0;
2395 287 : for( ; nStrPos < nEnde; nStrPos++ )
2396 : {
2397 24 : aEndPosLst.OutEndAttrs( rHTMLWrt, nStrPos + nOffset, &aContext );
2398 :
2399 : // Die an der aktuellen Position verankerten Rahmen ausgeben
2400 24 : if( bFlysLeft )
2401 : bFlysLeft = rHTMLWrt.OutFlyFrm( rNode.GetIndex(),
2402 : nStrPos, HTML_POS_INSIDE,
2403 0 : &aContext );
2404 :
2405 24 : sal_Bool bOutChar = sal_True;
2406 24 : const SwTxtAttr * pTxtHt = 0;
2407 48 : if( nAttrPos < nCntAttr && *pHt->GetStart() == nStrPos
2408 29 : && nStrPos != nEnde )
2409 : {
2410 5 : do {
2411 5 : if ( pHt->GetEnd() && !pHt->HasDummyChar() )
2412 : {
2413 5 : if( *pHt->GetEnd() != nStrPos )
2414 : {
2415 : // Hints mit Ende einsortieren, wenn sie keinen
2416 : // leeren Bereich aufspannen (Hints, die keinen
2417 : // Bereich aufspannen werden ignoriert
2418 5 : aEndPosLst.Insert( pHt->GetAttr(), nStrPos + nOffset,
2419 5 : *pHt->GetEnd() + nOffset,
2420 15 : rHTMLWrt.aChrFmtInfos );
2421 : }
2422 : }
2423 : else
2424 : {
2425 : // Hints ohne-Ende werden als letztes ausgebeben
2426 : OSL_ENSURE( !pTxtHt,
2427 : "Wieso gibt es da schon ein Attribut ohne Ende?" );
2428 0 : if( rHTMLWrt.nTxtAttrsToIgnore>0 )
2429 : {
2430 0 : rHTMLWrt.nTxtAttrsToIgnore--;
2431 : }
2432 : else
2433 : {
2434 0 : pTxtHt = pHt;
2435 : sal_uInt16 nFldWhich;
2436 0 : if( RES_TXTATR_FIELD != pHt->Which() ||
2437 0 : ( RES_POSTITFLD != (nFldWhich = ((const SwFmtFld&)pHt->GetAttr()).GetFld()->Which()) &&
2438 : RES_SCRIPTFLD != nFldWhich ) )
2439 0 : bWriteBreak = sal_False;
2440 : }
2441 0 : bOutChar = sal_False; // keine 255 ausgeben
2442 : }
2443 15 : } while( ++nAttrPos < nCntAttr && nStrPos ==
2444 10 : *( pHt = pNd->GetSwpHints()[ nAttrPos ] )->GetStart() );
2445 : }
2446 :
2447 : // Manche Draw-Formate koennen auch noch Attribute mitbringen
2448 24 : if( pTxtHt && RES_TXTATR_FLYCNT == pTxtHt->Which() )
2449 : {
2450 : const SwFrmFmt* pFrmFmt =
2451 0 : ((const SwFmtFlyCnt &)pTxtHt->GetAttr()).GetFrmFmt();
2452 :
2453 0 : if( RES_DRAWFRMFMT == pFrmFmt->Which() )
2454 : aEndPosLst.Insert( *((const SwDrawFrmFmt *)pFrmFmt),
2455 : nStrPos + nOffset,
2456 0 : rHTMLWrt.aChrFmtInfos );
2457 : }
2458 :
2459 24 : aEndPosLst.OutEndAttrs( rHTMLWrt, nStrPos + nOffset, &aContext );
2460 24 : aEndPosLst.OutStartAttrs( rHTMLWrt, nStrPos + nOffset, &aContext );
2461 :
2462 24 : if( pTxtHt )
2463 : {
2464 0 : rHTMLWrt.bLFPossible = !rHTMLWrt.nLastParaToken && nStrPos > 0 &&
2465 0 : rStr.GetChar(nStrPos-1) == ' ';
2466 0 : sal_uInt16 nCSS1Script = rHTMLWrt.nCSS1Script;
2467 : rHTMLWrt.nCSS1Script = aEndPosLst.GetScriptAtPos(
2468 0 : nStrPos + nOffset, nCSS1Script );
2469 0 : HTMLOutFuncs::FlushToAscii( rWrt.Strm(), aContext );
2470 0 : Out( aHTMLAttrFnTab, pTxtHt->GetAttr(), rHTMLWrt );
2471 0 : rHTMLWrt.nCSS1Script = nCSS1Script;
2472 0 : rHTMLWrt.bLFPossible = sal_False;
2473 : }
2474 :
2475 24 : if( bOutChar )
2476 : {
2477 : // #i120442#: get the UTF-32 codepoint by converting an eventual UTF-16 unicode surrogate pair
2478 24 : sal_uInt64 c = rStr.GetChar( nStrPos );
2479 24 : if( nStrPos < nEnde - 1 )
2480 : {
2481 19 : const sal_Unicode d = rStr.GetChar( nStrPos + 1 );
2482 19 : if( (c >= 0xd800 && c <= 0xdbff) && (d >= 0xdc00 && d <= 0xdfff) )
2483 : {
2484 0 : sal_uInt64 templow = d&0x03ff;
2485 0 : sal_uInt64 temphi = ((c&0x03ff) + 0x0040)<<10;
2486 0 : c = temphi|templow;
2487 0 : nStrPos++;
2488 : }
2489 : }
2490 :
2491 : // try to split a line after about 255 characters
2492 : // at a space character unless in a PRE-context
2493 24 : if( ' '==c && !rHTMLWrt.nLastParaToken )
2494 : {
2495 : xub_StrLen nLineLen;
2496 0 : if( rHTMLWrt.nLastParaToken )
2497 0 : nLineLen = nStrPos - nPreSplitPos;
2498 : else
2499 0 : nLineLen = rHTMLWrt.GetLineLen();
2500 :
2501 0 : xub_StrLen nWordLen = rStr.Search( ' ', nStrPos+1 );
2502 0 : if( nWordLen == STRING_NOTFOUND )
2503 0 : nWordLen = nEnde;
2504 0 : nWordLen -= nStrPos;
2505 :
2506 0 : if( nLineLen >= rHTMLWrt.nWhishLineLen ||
2507 0 : (nLineLen+nWordLen) >= rHTMLWrt.nWhishLineLen )
2508 : {
2509 0 : HTMLOutFuncs::FlushToAscii( rWrt.Strm(), aContext );
2510 0 : rHTMLWrt.OutNewLine();
2511 0 : bOutChar = sal_False;
2512 0 : if( rHTMLWrt.nLastParaToken )
2513 0 : nPreSplitPos = nStrPos+1;
2514 : }
2515 : }
2516 :
2517 24 : if( bOutChar )
2518 : {
2519 24 : if( 0x0a == c )
2520 : {
2521 0 : HTMLOutFuncs::FlushToAscii( rWrt.Strm(), aContext );
2522 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_linebreak );
2523 : }
2524 : // #i120442#: if c is outside the unicode base plane output it as "&#******;"
2525 24 : else if( c > 0xffff)
2526 : {
2527 0 : OUString sOut("&#");
2528 0 : sOut += OUString::number( (sal_uInt64)c );
2529 0 : sOut += ";";
2530 0 : rWrt.Strm() << sOut.getStr();
2531 : }
2532 : else
2533 24 : HTMLOutFuncs::Out_Char( rWrt.Strm(), (sal_Unicode)c, aContext, &rHTMLWrt.aNonConvertableCharacters );
2534 :
2535 : // if a paragraph's last character is a hard line break
2536 : // then we need to add an extra <br>
2537 : // because browsers like Mozilla wouldn't add a line for the next paragraph
2538 24 : bWriteBreak = (0x0a == c) &&
2539 24 : (HTML_PREFORMTXT_ON != rHTMLWrt.nLastParaToken);
2540 : }
2541 : }
2542 : }
2543 263 : HTMLOutFuncs::FlushToAscii( rWrt.Strm(), aContext );
2544 : }
2545 :
2546 263 : aEndPosLst.OutEndAttrs( rHTMLWrt, STRING_MAXLEN );
2547 :
2548 : // Die an der letzten Position verankerten Rahmen ausgeben
2549 263 : if( bFlysLeft )
2550 : bFlysLeft = rHTMLWrt.OutFlyFrm( rNode.GetIndex(),
2551 0 : nEnde, HTML_POS_INSIDE );
2552 : OSL_ENSURE( !bFlysLeft, "Es wurden nicht alle Rahmen gespeichert!" );
2553 :
2554 263 : rHTMLWrt.bTxtAttr = sal_False;
2555 :
2556 263 : if( bWriteBreak )
2557 : {
2558 514 : sal_Bool bEndOfCell = rHTMLWrt.bOutTable &&
2559 256 : rWrt.pCurPam->GetPoint()->nNode.GetIndex() ==
2560 514 : rWrt.pCurPam->GetMark()->nNode.GetIndex();
2561 :
2562 514 : if( bEndOfCell && !nEnde &&
2563 256 : rHTMLWrt.IsHTMLMode(HTMLMODE_NBSP_IN_TABLES) )
2564 : {
2565 : // Wenn der letzte Absatz einer Tabellezelle leer ist und
2566 : // wir fuer den MS-IE exportieren, schreiben wir statt eines
2567 : // <BR> ein
2568 0 : rWrt.Strm() << '&' << OOO_STRING_SVTOOLS_HTML_S_nbsp << ';';
2569 : }
2570 : else
2571 : {
2572 258 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_linebreak );
2573 : const SvxULSpaceItem& rULSpace =
2574 258 : (const SvxULSpaceItem &)pNd->GetSwAttrSet().Get(RES_UL_SPACE);
2575 259 : if( rULSpace.GetLower() > 0 && !bEndOfCell &&
2576 1 : !rHTMLWrt.IsHTMLMode(HTMLMODE_NO_BR_AT_PAREND) )
2577 1 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_linebreak );
2578 258 : rHTMLWrt.bLFPossible = sal_True;
2579 : }
2580 : }
2581 :
2582 263 : if( rHTMLWrt.bClearLeft || rHTMLWrt.bClearRight )
2583 : {
2584 : const sal_Char *pStr;
2585 0 : if( rHTMLWrt.bClearLeft )
2586 : {
2587 0 : if( rHTMLWrt.bClearRight )
2588 0 : pStr = OOO_STRING_SVTOOLS_HTML_AL_all;
2589 : else
2590 0 : pStr = OOO_STRING_SVTOOLS_HTML_AL_left;
2591 : }
2592 : else
2593 0 : pStr = OOO_STRING_SVTOOLS_HTML_AL_right;
2594 :
2595 0 : OStringBuffer sOut(RTL_CONSTASCII_STRINGPARAM(OOO_STRING_SVTOOLS_HTML_linebreak));
2596 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_clear).append('=').append(pStr);
2597 0 : HTMLOutFuncs::Out_AsciiTag( rHTMLWrt.Strm(), sOut.getStr() );
2598 :
2599 0 : rHTMLWrt.bClearLeft = sal_False;
2600 0 : rHTMLWrt.bClearRight = sal_False;
2601 :
2602 0 : rHTMLWrt.bLFPossible = sal_True;
2603 : }
2604 :
2605 : // wenn ein LF nicht schon erlaubt ist wird es erlaubt, wenn der
2606 : // Absatz mit einem ' ' endet
2607 531 : if( !rHTMLWrt.bLFPossible && !rHTMLWrt.nLastParaToken &&
2608 268 : nEnde > 0 && ' ' == rStr.GetChar(nEnde-1) )
2609 0 : rHTMLWrt.bLFPossible = sal_True;
2610 :
2611 263 : rHTMLWrt.bTagOn = sal_False;
2612 263 : OutHTML_SwFmtOff( rWrt, aFmtInfo );
2613 :
2614 : // eventuell eine Form schliessen
2615 263 : rHTMLWrt.OutForm( sal_False );
2616 :
2617 263 : if( bPageBreakBehind )
2618 0 : rWrt.Strm() << '\f';
2619 :
2620 526 : return rHTMLWrt;
2621 : }
2622 :
2623 :
2624 2 : sal_uInt32 SwHTMLWriter::ToPixel( sal_uInt32 nVal ) const
2625 : {
2626 2 : if( Application::GetDefaultDevice() && nVal )
2627 : {
2628 : nVal = Application::GetDefaultDevice()->LogicToPixel(
2629 1 : Size( nVal, nVal ), MapMode( MAP_TWIP ) ).Width();
2630 1 : if( !nVal ) // wo ein Twip ist sollte auch ein Pixel sein
2631 0 : nVal = 1;
2632 : }
2633 2 : return nVal;
2634 : }
2635 :
2636 :
2637 10 : static Writer& OutHTML_CSS1Attr( Writer& rWrt, const SfxPoolItem& rHt )
2638 : {
2639 : // wenn gerade Hints geschrieben werden versuchen wir den Hint als
2640 : // CSS1-Attribut zu schreiben
2641 :
2642 10 : if( ((SwHTMLWriter&)rWrt).bCfgOutStyles && ((SwHTMLWriter&)rWrt).bTxtAttr )
2643 10 : OutCSS1_HintSpanTag( rWrt, rHt );
2644 :
2645 10 : return rWrt;
2646 : }
2647 :
2648 :
2649 : /* File CHRATR.HXX: */
2650 :
2651 10 : static Writer& OutHTML_SvxColor( Writer& rWrt, const SfxPoolItem& rHt )
2652 : {
2653 10 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2654 10 : if( rHTMLWrt.bOutOpts )
2655 0 : return rWrt;
2656 :
2657 10 : if( !rHTMLWrt.bTxtAttr && rHTMLWrt.bCfgOutStyles && rHTMLWrt.bCfgPreferStyles )
2658 : {
2659 : // Font-Farbe nicht als Tag schreiben, wenn Styles normalen Tags
2660 : // vorgezogen werden
2661 0 : return rWrt;
2662 : }
2663 :
2664 10 : if( rHTMLWrt.bTagOn )
2665 : {
2666 5 : Color aColor( ((const SvxColorItem&)rHt).GetValue() );
2667 5 : if( COL_AUTO == aColor.GetColor() )
2668 0 : aColor.SetColor( COL_BLACK );
2669 :
2670 5 : OStringBuffer sOut;
2671 5 : sOut.append('<').append(OOO_STRING_SVTOOLS_HTML_font).append(' ')
2672 5 : .append(OOO_STRING_SVTOOLS_HTML_O_color).append('=');
2673 5 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
2674 5 : HTMLOutFuncs::Out_Color( rWrt.Strm(), aColor, rHTMLWrt.eDestEnc ) << '>';
2675 : }
2676 : else
2677 5 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_font, sal_False );
2678 :
2679 10 : return rWrt;
2680 : }
2681 :
2682 :
2683 0 : static Writer& OutHTML_SwPosture( Writer& rWrt, const SfxPoolItem& rHt )
2684 : {
2685 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2686 0 : if( rHTMLWrt.bOutOpts )
2687 0 : return rWrt;
2688 :
2689 0 : const FontItalic nPosture = ((const SvxPostureItem&)rHt).GetPosture();
2690 0 : if( ITALIC_NORMAL == nPosture )
2691 : {
2692 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_italic, rHTMLWrt.bTagOn );
2693 : }
2694 0 : else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr )
2695 : {
2696 : // vielleicht als CSS1-Attribut ?
2697 0 : OutCSS1_HintSpanTag( rWrt, rHt );
2698 : }
2699 :
2700 0 : return rWrt;
2701 : }
2702 :
2703 2 : static Writer& OutHTML_SvxFont( Writer& rWrt, const SfxPoolItem& rHt )
2704 : {
2705 2 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2706 2 : if( rHTMLWrt.bOutOpts )
2707 0 : return rWrt;
2708 :
2709 2 : if( rHTMLWrt.bTagOn )
2710 : {
2711 1 : String aNames;
2712 : SwHTMLWriter::PrepareFontList( ((const SvxFontItem&)rHt), aNames, 0,
2713 1 : rHTMLWrt.IsHTMLMode(HTMLMODE_FONT_GENERIC) );
2714 2 : OStringBuffer sOut;
2715 1 : sOut.append('<').append(OOO_STRING_SVTOOLS_HTML_font).append(' ')
2716 1 : .append(OOO_STRING_SVTOOLS_HTML_O_face).append("=\"");
2717 1 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
2718 1 : HTMLOutFuncs::Out_String( rWrt.Strm(), aNames, rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters )
2719 2 : << "\">";
2720 : }
2721 : else
2722 1 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_font , sal_False );
2723 :
2724 2 : return rWrt;
2725 : }
2726 :
2727 10 : static Writer& OutHTML_SvxFontHeight( Writer& rWrt, const SfxPoolItem& rHt )
2728 : {
2729 10 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2730 10 : if( rHTMLWrt.bOutOpts )
2731 0 : return rWrt;
2732 :
2733 10 : if( rHTMLWrt.bTagOn )
2734 : {
2735 5 : OStringBuffer sOut;
2736 5 : sOut.append('<').append(OOO_STRING_SVTOOLS_HTML_font);
2737 :
2738 5 : sal_uInt32 nHeight = ((const SvxFontHeightItem&)rHt).GetHeight();
2739 5 : sal_uInt16 nSize = rHTMLWrt.GetHTMLFontSize( nHeight );
2740 5 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_size).append('=').
2741 10 : append(static_cast<sal_Int32>(nSize));
2742 5 : rWrt.Strm() << sOut.getStr();
2743 :
2744 10 : if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr &&
2745 5 : rHTMLWrt.aFontHeights[nSize-1] != nHeight )
2746 : {
2747 : // wenn die Groesse keiner HTML-Groesse entspricht,
2748 : // wird sie noch zusatzlich als Style-Option exportiert
2749 0 : OutCSS1_HintStyleOpt( rWrt, rHt );
2750 : }
2751 5 : rWrt.Strm() << '>';
2752 : }
2753 : else
2754 : {
2755 5 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_font, sal_False );
2756 : }
2757 :
2758 10 : return rWrt;
2759 : }
2760 :
2761 0 : static Writer& OutHTML_SvxLanguage( Writer& rWrt, const SfxPoolItem& rHt )
2762 : {
2763 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2764 0 : if( rHTMLWrt.bOutOpts )
2765 0 : return rWrt;
2766 :
2767 0 : LanguageType eLang = ((const SvxLanguageItem &)rHt).GetLanguage();
2768 0 : if( LANGUAGE_DONTKNOW == eLang )
2769 0 : return rWrt;
2770 :
2771 0 : if( rHTMLWrt.bTagOn )
2772 : {
2773 0 : OStringBuffer sOut;
2774 0 : sOut.append('<').append(OOO_STRING_SVTOOLS_HTML_span);
2775 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
2776 0 : rHTMLWrt.OutLanguage( ((const SvxLanguageItem &)rHt).GetLanguage() );
2777 0 : rWrt.Strm() << '>';
2778 : }
2779 : else
2780 : {
2781 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_span, sal_False );
2782 : }
2783 :
2784 0 : return rWrt;
2785 : }
2786 10 : static Writer& OutHTML_SwWeight( Writer& rWrt, const SfxPoolItem& rHt )
2787 : {
2788 10 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2789 10 : if( rHTMLWrt.bOutOpts )
2790 0 : return rWrt;
2791 :
2792 10 : const FontWeight nBold = ((const SvxWeightItem&)rHt).GetWeight();
2793 10 : if( WEIGHT_BOLD == nBold )
2794 : {
2795 10 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_bold, rHTMLWrt.bTagOn );
2796 : }
2797 0 : else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr )
2798 : {
2799 : // vielleicht als CSS1-Attribut ?
2800 0 : OutCSS1_HintSpanTag( rWrt, rHt );
2801 : }
2802 :
2803 10 : return rWrt;
2804 : }
2805 :
2806 :
2807 0 : static Writer& OutHTML_SwCrossedOut( Writer& rWrt, const SfxPoolItem& rHt )
2808 : {
2809 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2810 0 : if( rHTMLWrt.bOutOpts )
2811 0 : return rWrt;
2812 :
2813 : // Wegen Netscape schrieben wir hier STRIKE und nicht S raus!
2814 0 : const FontStrikeout nStrike = ((const SvxCrossedOutItem&)rHt).GetStrikeout();
2815 0 : if( STRIKEOUT_NONE != nStrike )
2816 : {
2817 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_strike, rHTMLWrt.bTagOn );
2818 : }
2819 0 : else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr )
2820 : {
2821 : // vielleicht als CSS1-Attribut ?
2822 0 : OutCSS1_HintSpanTag( rWrt, rHt );
2823 : }
2824 :
2825 0 : return rWrt;
2826 : }
2827 :
2828 :
2829 0 : static Writer& OutHTML_SvxEscapement( Writer& rWrt, const SfxPoolItem& rHt )
2830 : {
2831 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2832 0 : if( rHTMLWrt.bOutOpts )
2833 0 : return rWrt;
2834 :
2835 : const SvxEscapement eEscape =
2836 0 : (const SvxEscapement)((const SvxEscapementItem&)rHt).GetEnumValue();
2837 0 : const sal_Char *pStr = 0;
2838 0 : switch( eEscape )
2839 : {
2840 0 : case SVX_ESCAPEMENT_SUPERSCRIPT: pStr = OOO_STRING_SVTOOLS_HTML_superscript; break;
2841 0 : case SVX_ESCAPEMENT_SUBSCRIPT: pStr = OOO_STRING_SVTOOLS_HTML_subscript; break;
2842 : default:
2843 : ;
2844 : }
2845 :
2846 0 : if( pStr )
2847 : {
2848 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), pStr, rHTMLWrt.bTagOn );
2849 : }
2850 0 : else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr )
2851 : {
2852 : // vielleicht als CSS1-Attribut ?
2853 0 : OutCSS1_HintSpanTag( rWrt, rHt );
2854 : }
2855 :
2856 0 : return rWrt;
2857 : }
2858 :
2859 :
2860 :
2861 0 : static Writer& OutHTML_SwUnderline( Writer& rWrt, const SfxPoolItem& rHt )
2862 : {
2863 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2864 0 : if( rHTMLWrt.bOutOpts )
2865 0 : return rWrt;
2866 :
2867 0 : const FontUnderline eUnder = ((const SvxUnderlineItem&)rHt).GetLineStyle();
2868 0 : if( UNDERLINE_NONE != eUnder )
2869 : {
2870 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_underline, rHTMLWrt.bTagOn );
2871 : }
2872 0 : else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr )
2873 : {
2874 : // vielleicht als CSS1-Attribut ?
2875 0 : OutCSS1_HintSpanTag( rWrt, rHt );
2876 : }
2877 :
2878 0 : return rWrt;
2879 : }
2880 :
2881 :
2882 0 : static Writer& OutHTML_SwFlyCnt( Writer& rWrt, const SfxPoolItem& rHt )
2883 : {
2884 0 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
2885 0 : SwFmtFlyCnt& rFlyCnt = (SwFmtFlyCnt&)rHt;
2886 :
2887 0 : const SwFrmFmt& rFmt = *rFlyCnt.GetFrmFmt();
2888 0 : const SdrObject *pSdrObj = 0;
2889 :
2890 : SwHTMLFrmType eType =
2891 0 : (SwHTMLFrmType)rHTMLWrt.GuessFrmType( rFmt, pSdrObj );
2892 0 : sal_uInt8 nMode = aHTMLOutFrmAsCharTable[eType][rHTMLWrt.nExportMode];
2893 0 : rHTMLWrt.OutFrmFmt( nMode, rFmt, pSdrObj );
2894 0 : return rWrt;
2895 : }
2896 :
2897 :
2898 : // Das ist jetzt unser Blink-Item. Blinkend wird eingeschaltet, indem man
2899 : // das Item auf sal_True setzt!
2900 0 : static Writer& OutHTML_SwBlink( Writer& rWrt, const SfxPoolItem& rHt )
2901 : {
2902 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2903 0 : if( rHTMLWrt.bOutOpts )
2904 0 : return rWrt;
2905 :
2906 0 : if( ((const SvxBlinkItem&)rHt).GetValue() )
2907 : {
2908 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_blink, rHTMLWrt.bTagOn );
2909 : }
2910 0 : else if( rHTMLWrt.bCfgOutStyles && rHTMLWrt.bTxtAttr )
2911 : {
2912 : // vielleicht als CSS1-Attribut ?
2913 0 : OutCSS1_HintSpanTag( rWrt, rHt );
2914 : }
2915 :
2916 0 : return rWrt;
2917 : }
2918 :
2919 0 : Writer& OutHTML_INetFmt( Writer& rWrt, const SwFmtINetFmt& rINetFmt, sal_Bool bOn )
2920 : {
2921 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2922 :
2923 0 : String aURL( rINetFmt.GetValue() );
2924 0 : const SvxMacroTableDtor *pMacTable = rINetFmt.GetMacroTbl();
2925 0 : sal_Bool bEvents = pMacTable != 0 && !pMacTable->empty();
2926 :
2927 : // Gibt es ueberhaupt etwas auszugeben?
2928 0 : if( !aURL.Len() && !bEvents && !rINetFmt.GetName().Len() )
2929 0 : return rWrt;
2930 :
2931 : // Tag aus? Dann nur ein </A> ausgeben.
2932 0 : if( !bOn )
2933 : {
2934 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_anchor, sal_False );
2935 0 : return rWrt;
2936 : }
2937 :
2938 0 : OStringBuffer sOut;
2939 0 : sOut.append('<').append(OOO_STRING_SVTOOLS_HTML_anchor);
2940 :
2941 0 : bool bScriptDependent = false;
2942 : {
2943 : const SwCharFmt* pFmt = rWrt.pDoc->GetCharFmtFromPool(
2944 0 : RES_POOLCHR_INET_NORMAL );
2945 0 : SwHTMLFmtInfo aFmtInfo( pFmt );
2946 0 : SwHTMLFmtInfos::const_iterator it = rHTMLWrt.aChrFmtInfos.find( aFmtInfo );
2947 0 : if( it != rHTMLWrt.aChrFmtInfos.end() )
2948 : {
2949 0 : bScriptDependent = it->bScriptDependent;
2950 0 : }
2951 : }
2952 0 : if( !bScriptDependent )
2953 : {
2954 : const SwCharFmt* pFmt = rWrt.pDoc->GetCharFmtFromPool(
2955 0 : RES_POOLCHR_INET_VISIT );
2956 0 : SwHTMLFmtInfo aFmtInfo( pFmt );
2957 0 : SwHTMLFmtInfos::const_iterator it = rHTMLWrt.aChrFmtInfos.find( aFmtInfo );
2958 0 : if( it != rHTMLWrt.aChrFmtInfos.end() )
2959 : {
2960 0 : bScriptDependent = it->bScriptDependent;
2961 0 : }
2962 : }
2963 :
2964 0 : if( bScriptDependent )
2965 : {
2966 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_class).append("=\"");
2967 0 : switch( rHTMLWrt.nCSS1Script )
2968 : {
2969 : case CSS1_OUTMODE_WESTERN:
2970 0 : sOut.append("western");
2971 0 : break;
2972 : case CSS1_OUTMODE_CJK:
2973 0 : sOut.append("cjk");
2974 0 : break;
2975 : case CSS1_OUTMODE_CTL:
2976 0 : sOut.append("ctl");
2977 0 : break;
2978 : }
2979 0 : sOut.append('\"');
2980 : }
2981 :
2982 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
2983 :
2984 0 : String sRel;
2985 :
2986 0 : if( aURL.Len() || bEvents )
2987 : {
2988 0 : String sTmp( aURL );
2989 0 : sTmp.ToUpperAscii();
2990 0 : xub_StrLen nPos = sTmp.SearchAscii( "\" REL=" );
2991 0 : if( nPos!=STRING_NOTFOUND )
2992 : {
2993 0 : sRel = aURL.Copy( nPos+1 );
2994 0 : aURL.Erase( nPos );
2995 : }
2996 0 : aURL = comphelper::string::strip(aURL, ' ');
2997 :
2998 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_href).append("=\"");
2999 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
3000 0 : rHTMLWrt.OutHyperlinkHRefValue( aURL );
3001 0 : sOut.append('\"');
3002 : }
3003 :
3004 0 : if( rINetFmt.GetName().Len() )
3005 : {
3006 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_name).append("=\"");
3007 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
3008 0 : HTMLOutFuncs::Out_String( rWrt.Strm(), rINetFmt.GetName(),
3009 0 : rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters );
3010 0 : sOut.append('\"');
3011 : }
3012 :
3013 0 : const String& rTarget = rINetFmt.GetTargetFrame();
3014 0 : if( rTarget.Len() )
3015 : {
3016 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_target).append("=\"");
3017 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
3018 0 : HTMLOutFuncs::Out_String( rWrt.Strm(), rTarget, rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters );
3019 0 : sOut.append('\"');
3020 : }
3021 :
3022 0 : if( sRel.Len() )
3023 0 : sOut.append(OUStringToOString(sRel, RTL_TEXTENCODING_ASCII_US));
3024 :
3025 0 : if( !sOut.isEmpty() )
3026 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
3027 :
3028 0 : if( bEvents )
3029 0 : HTMLOutFuncs::Out_Events( rWrt.Strm(), *pMacTable, aAnchorEventTable,
3030 : rHTMLWrt.bCfgStarBasic, rHTMLWrt.eDestEnc,
3031 0 : &rHTMLWrt.aNonConvertableCharacters );
3032 0 : rWrt.Strm() << ">";
3033 :
3034 0 : return rWrt;
3035 : }
3036 :
3037 0 : static Writer& OutHTML_SwFmtINetFmt( Writer& rWrt, const SfxPoolItem& rHt )
3038 : {
3039 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
3040 :
3041 0 : if( rHTMLWrt.bOutOpts )
3042 0 : return rWrt;
3043 :
3044 0 : const SwFmtINetFmt& rINetFmt = (const SwFmtINetFmt&)rHt;
3045 :
3046 0 : if( rHTMLWrt.bTagOn )
3047 : {
3048 : // ggf. ein noch offenes Attribut voruebergehend beenden
3049 0 : if( rHTMLWrt.aINetFmts.size() )
3050 : {
3051 : SwFmtINetFmt *pINetFmt =
3052 0 : rHTMLWrt.aINetFmts.back();
3053 0 : OutHTML_INetFmt( rWrt, *pINetFmt, sal_False );
3054 : }
3055 :
3056 : // jetzt das neue aufmachen
3057 0 : OutHTML_INetFmt( rWrt, rINetFmt, sal_True );
3058 :
3059 : // und merken
3060 0 : SwFmtINetFmt *pINetFmt = new SwFmtINetFmt( rINetFmt );
3061 0 : rHTMLWrt.aINetFmts.push_back( pINetFmt );
3062 : }
3063 : else
3064 : {
3065 : // das
3066 0 : OutHTML_INetFmt( rWrt, rINetFmt, sal_False );
3067 :
3068 : OSL_ENSURE( rHTMLWrt.aINetFmts.size(), "da fehlt doch ein URL-Attribut" );
3069 0 : if( rHTMLWrt.aINetFmts.size() )
3070 : {
3071 : // das eigene Attribut vom Stack holen
3072 0 : SwFmtINetFmt *pINetFmt = rHTMLWrt.aINetFmts.back();
3073 0 : rHTMLWrt.aINetFmts.pop_back();
3074 0 : delete pINetFmt;
3075 : }
3076 :
3077 0 : if( !rHTMLWrt.aINetFmts.empty() )
3078 : {
3079 : // es ist noch ein Attribut auf dem Stack, das wieder geoeffnet
3080 : // werden muss
3081 0 : SwFmtINetFmt *pINetFmt = rHTMLWrt.aINetFmts.back();
3082 0 : OutHTML_INetFmt( rWrt, *pINetFmt, sal_True );
3083 : }
3084 : }
3085 :
3086 0 : return rWrt;
3087 : }
3088 :
3089 0 : static Writer& OutHTML_SwTxtCharFmt( Writer& rWrt, const SfxPoolItem& rHt )
3090 : {
3091 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
3092 0 : if( rHTMLWrt.bOutOpts )
3093 0 : return rWrt;
3094 :
3095 0 : const SwFmtCharFmt& rChrFmt = (const SwFmtCharFmt&)rHt;
3096 0 : const SwCharFmt* pFmt = rChrFmt.GetCharFmt();
3097 :
3098 0 : if( !pFmt )
3099 : {
3100 0 : return rWrt;
3101 : }
3102 :
3103 0 : SwHTMLFmtInfo aFmtInfo( pFmt );
3104 0 : SwHTMLFmtInfos::const_iterator it = rHTMLWrt.aChrFmtInfos.find( aFmtInfo );
3105 0 : if( it == rHTMLWrt.aChrFmtInfos.end())
3106 0 : return rWrt;
3107 :
3108 0 : const SwHTMLFmtInfo *pFmtInfo = &*it;
3109 : OSL_ENSURE( pFmtInfo, "Wieso gint es keine Infos ueber die Zeichenvorlage?" );
3110 :
3111 0 : if( rHTMLWrt.bTagOn )
3112 : {
3113 0 : OStringBuffer sOut;
3114 0 : sOut.append('<');
3115 0 : if( !pFmtInfo->aToken.isEmpty() )
3116 0 : sOut.append(pFmtInfo->aToken);
3117 : else
3118 0 : sOut.append(OOO_STRING_SVTOOLS_HTML_span);
3119 0 : if( rHTMLWrt.bCfgOutStyles &&
3120 0 : (pFmtInfo->aClass.Len() || pFmtInfo->bScriptDependent) )
3121 : {
3122 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_class)
3123 0 : .append("=\"");
3124 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
3125 0 : String aClass( pFmtInfo->aClass );
3126 0 : if( pFmtInfo->bScriptDependent )
3127 : {
3128 0 : if( aClass.Len() )
3129 0 : aClass += '-';
3130 0 : switch( rHTMLWrt.nCSS1Script )
3131 : {
3132 : case CSS1_OUTMODE_WESTERN:
3133 0 : aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("western") );
3134 0 : break;
3135 : case CSS1_OUTMODE_CJK:
3136 0 : aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("cjk") );
3137 0 : break;
3138 : case CSS1_OUTMODE_CTL:
3139 0 : aClass.AppendAscii( RTL_CONSTASCII_STRINGPARAM("ctl") );
3140 0 : break;
3141 : }
3142 : }
3143 0 : HTMLOutFuncs::Out_String( rWrt.Strm(), aClass,
3144 0 : rHTMLWrt.eDestEnc, &rHTMLWrt.aNonConvertableCharacters );
3145 0 : sOut.append('\"');
3146 : }
3147 0 : sOut.append('>');
3148 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
3149 : }
3150 : else
3151 : {
3152 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(),
3153 0 : !pFmtInfo->aToken.isEmpty() ? pFmtInfo->aToken.getStr()
3154 : : OOO_STRING_SVTOOLS_HTML_span,
3155 0 : sal_False );
3156 : }
3157 :
3158 0 : return rWrt;
3159 : }
3160 :
3161 0 : static Writer& OutHTML_SvxAdjust( Writer& rWrt, const SfxPoolItem& rHt )
3162 : {
3163 0 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
3164 0 : if( !rHTMLWrt.bOutOpts || !rHTMLWrt.bTagOn )
3165 0 : return rWrt;
3166 :
3167 0 : SvxAdjustItem& rAdjust = (SvxAdjustItem&)rHt;
3168 0 : const sal_Char* pStr = 0;
3169 0 : switch( rAdjust.GetAdjust() )
3170 : {
3171 0 : case SVX_ADJUST_CENTER: pStr = OOO_STRING_SVTOOLS_HTML_AL_center; break;
3172 0 : case SVX_ADJUST_LEFT: pStr = OOO_STRING_SVTOOLS_HTML_AL_left; break;
3173 0 : case SVX_ADJUST_RIGHT: pStr = OOO_STRING_SVTOOLS_HTML_AL_right; break;
3174 0 : case SVX_ADJUST_BLOCK: pStr = OOO_STRING_SVTOOLS_HTML_AL_justify; break;
3175 : default:
3176 : ;
3177 : }
3178 0 : if( pStr )
3179 : {
3180 0 : OStringBuffer sOut;
3181 0 : sOut.append(' ').append(OOO_STRING_SVTOOLS_HTML_O_align).append('=')
3182 0 : .append(pStr);
3183 0 : rWrt.Strm() << sOut.makeStringAndClear().getStr();
3184 : }
3185 :
3186 0 : return rWrt;
3187 : }
3188 :
3189 : /*
3190 : * lege hier die Tabellen fuer die HTML-Funktions-Pointer auf
3191 : * die Ausgabe-Funktionen an.
3192 : * Es sind lokale Strukturen, die nur innerhalb der HTML-DLL
3193 : * bekannt sein muessen.
3194 : */
3195 :
3196 :
3197 : SwAttrFnTab aHTMLAttrFnTab = {
3198 : /* RES_CHRATR_CASEMAP */ OutHTML_CSS1Attr,
3199 : /* RES_CHRATR_CHARSETCOLOR */ 0,
3200 : /* RES_CHRATR_COLOR */ OutHTML_SvxColor,
3201 : /* RES_CHRATR_CONTOUR */ 0,
3202 : /* RES_CHRATR_CROSSEDOUT */ OutHTML_SwCrossedOut,
3203 : /* RES_CHRATR_ESCAPEMENT */ OutHTML_SvxEscapement,
3204 : /* RES_CHRATR_FONT */ OutHTML_SvxFont,
3205 : /* RES_CHRATR_FONTSIZE */ OutHTML_SvxFontHeight,
3206 : /* RES_CHRATR_KERNING */ OutHTML_CSS1Attr,
3207 : /* RES_CHRATR_LANGUAGE */ OutHTML_SvxLanguage,
3208 : /* RES_CHRATR_POSTURE */ OutHTML_SwPosture,
3209 : /* RES_CHRATR_PROPORTIONALFONTSIZE*/0,
3210 : /* RES_CHRATR_SHADOWED */ 0,
3211 : /* RES_CHRATR_UNDERLINE */ OutHTML_SwUnderline,
3212 : /* RES_CHRATR_WEIGHT */ OutHTML_SwWeight,
3213 : /* RES_CHRATR_WORDLINEMODE */ 0,
3214 : /* RES_CHRATR_AUTOKERN */ 0,
3215 : /* RES_CHRATR_BLINK */ OutHTML_SwBlink,
3216 : /* RES_CHRATR_NOHYPHEN */ 0, // Neu: nicht trennen
3217 : /* RES_CHRATR_NOLINEBREAK */ 0, // Neu: nicht umbrechen
3218 : /* RES_CHRATR_BACKGROUND */ OutHTML_CSS1Attr, // Neu: Zeichenhintergrund
3219 : /* RES_CHRATR_CJK_FONT */ OutHTML_SvxFont,
3220 : /* RES_CHRATR_CJK_FONTSIZE */ OutHTML_SvxFontHeight,
3221 : /* RES_CHRATR_CJK_LANGUAGE */ OutHTML_SvxLanguage,
3222 : /* RES_CHRATR_CJK_POSTURE */ OutHTML_SwPosture,
3223 : /* RES_CHRATR_CJK_WEIGHT */ OutHTML_SwWeight,
3224 : /* RES_CHRATR_CTL_FONT */ OutHTML_SvxFont,
3225 : /* RES_CHRATR_CTL_FONTSIZE */ OutHTML_SvxFontHeight,
3226 : /* RES_CHRATR_CTL_LANGUAGE */ OutHTML_SvxLanguage,
3227 : /* RES_CHRATR_CTL_POSTURE */ OutHTML_SwPosture,
3228 : /* RES_CHRATR_CTL_WEIGHT */ OutHTML_SwWeight,
3229 : /* RES_CHRATR_ROTATE */ 0,
3230 : /* RES_CHRATR_EMPHASIS_MARK */ 0,
3231 : /* RES_CHRATR_TWO_LINES */ 0,
3232 : /* RES_CHRATR_SCALEW */ 0,
3233 : /* RES_CHRATR_RELIEF */ 0,
3234 : /* RES_CHRATR_HIDDEN */ OutHTML_CSS1Attr,
3235 : /* RES_CHRATR_OVERLINE */ OutHTML_CSS1Attr,
3236 : /* RES_CHRATR_RSID */ 0,
3237 : /* RES_CHRATR_DUMMY1 */ 0,
3238 :
3239 : /* RES_TXTATR_REFMARK */ 0,
3240 : /* RES_TXTATR_TOXMARK */ 0,
3241 : /* RES_TXTATR_META */ 0,
3242 : /* RES_TXTATR_METAFIELD */ 0,
3243 : /* RES_TXTATR_AUTOFMT */ 0,
3244 : /* RES_TXTATR_INETFMT */ OutHTML_SwFmtINetFmt,
3245 : /* RES_TXTATR_CHARFMT */ OutHTML_SwTxtCharFmt,
3246 : /* RES_TXTATR_CJK_RUBY */ 0,
3247 : /* RES_TXTATR_UNKNOWN_CONTAINER */ 0,
3248 : /* RES_TXTATR_DUMMY5 */ 0,
3249 :
3250 : /* RES_TXTATR_FIELD */ OutHTML_SwFmtFld,
3251 : /* RES_TXTATR_FLYCNT */ OutHTML_SwFlyCnt,
3252 : /* RES_TXTATR_FTN */ OutHTML_SwFmtFtn,
3253 : /* RES_TXTATR_DUMMY4 */ 0,
3254 : /* RES_TXTATR_DUMMY3 */ 0,
3255 : /* RES_TXTATR_DUMMY1 */ 0, // Dummy:
3256 : /* RES_TXTATR_DUMMY2 */ 0, // Dummy:
3257 :
3258 : /* RES_PARATR_LINESPACING */ 0,
3259 : /* RES_PARATR_ADJUST */ OutHTML_SvxAdjust,
3260 : /* RES_PARATR_SPLIT */ 0,
3261 : /* RES_PARATR_WIDOWS */ 0,
3262 : /* RES_PARATR_ORPHANS */ 0,
3263 : /* RES_PARATR_TABSTOP */ 0,
3264 : /* RES_PARATR_HYPHENZONE*/ 0,
3265 : /* RES_PARATR_DROP */ OutHTML_CSS1Attr,
3266 : /* RES_PARATR_REGISTER */ 0, // neu: Registerhaltigkeit
3267 : /* RES_PARATR_NUMRULE */ 0, // Dummy:
3268 : /* RES_PARATR_SCRIPTSPACE */ 0, // Dummy:
3269 : /* RES_PARATR_HANGINGPUNCTUATION */ 0, // Dummy:
3270 : /* RES_PARATR_FORBIDDEN_RULES */ 0, // new
3271 : /* RES_PARATR_VERTALIGN */ 0, // new
3272 : /* RES_PARATR_SNAPTOGRID*/ 0, // new
3273 : /* RES_PARATR_CONNECT_TO_BORDER */ 0, // new
3274 :
3275 : /* RES_PARATR_LIST_ID */ 0, // new
3276 : /* RES_PARATR_LIST_LEVEL */ 0, // new
3277 : /* RES_PARATR_LIST_ISRESTART */ 0, // new
3278 : /* RES_PARATR_LIST_RESTARTVALUE */ 0, // new
3279 : /* RES_PARATR_LIST_ISCOUNTED */ 0, // new
3280 :
3281 : /* RES_FILL_ORDER */ 0,
3282 : /* RES_FRM_SIZE */ 0,
3283 : /* RES_PAPER_BIN */ 0,
3284 : /* RES_LR_SPACE */ 0,
3285 : /* RES_UL_SPACE */ 0,
3286 : /* RES_PAGEDESC */ 0,
3287 : /* RES_BREAK */ 0,
3288 : /* RES_CNTNT */ 0,
3289 : /* RES_HEADER */ 0,
3290 : /* RES_FOOTER */ 0,
3291 : /* RES_PRINT */ 0,
3292 : /* RES_OPAQUE */ 0,
3293 : /* RES_PROTECT */ 0,
3294 : /* RES_SURROUND */ 0,
3295 : /* RES_VERT_ORIENT */ 0,
3296 : /* RES_HORI_ORIENT */ 0,
3297 : /* RES_ANCHOR */ 0,
3298 : /* RES_BACKGROUND */ 0,
3299 : /* RES_BOX */ 0,
3300 : /* RES_SHADOW */ 0,
3301 : /* RES_FRMMACRO */ 0,
3302 : /* RES_COL */ 0,
3303 : /* RES_KEEP */ 0,
3304 : /* RES_URL */ 0,
3305 : /* RES_EDIT_IN_READONLY */ 0,
3306 : /* RES_LAYOUT_SPLIT */ 0,
3307 : /* RES_FRMATR_DUMMY1 */ 0, // Dummy:
3308 : /* RES_FRMATR_DUMMY2 */ 0, // Dummy:
3309 : /* RES_AUTO_STYLE */ 0, // Dummy:
3310 : /* RES_FRMATR_DUMMY4 */ 0, // Dummy:
3311 : /* RES_FRMATR_DUMMY5 */ 0, // Dummy:
3312 : /* RES_FRMATR_DUMMY6 */ 0, // Dummy:
3313 : /* RES_FRMATR_DUMMY7 */ 0, // Dummy:
3314 : /* RES_FRMATR_DUMMY8 */ 0, // Dummy:
3315 : /* RES_FRMATR_DUMMY9 */ 0, // Dummy:
3316 : /* RES_FOLLOW_TEXT_FLOW */ 0,
3317 : /* RES_WRAP_INFLUENCE_ON_OBJPOS */ 0,
3318 : /* RES_FRMATR_DUMMY2 */ 0, // Dummy:
3319 : /* RES_AUTO_STYLE */ 0, // Dummy:
3320 : /* RES_FRMATR_DUMMY4 */ 0, // Dummy:
3321 : /* RES_FRMATR_DUMMY5 */ 0, // Dummy:
3322 :
3323 : /* RES_GRFATR_MIRRORGRF */ 0,
3324 : /* RES_GRFATR_CROPGRF */ 0,
3325 : /* RES_GRFATR_ROTATION */ 0,
3326 : /* RES_GRFATR_LUMINANCE */ 0,
3327 : /* RES_GRFATR_CONTRAST */ 0,
3328 : /* RES_GRFATR_CHANNELR */ 0,
3329 : /* RES_GRFATR_CHANNELG */ 0,
3330 : /* RES_GRFATR_CHANNELB */ 0,
3331 : /* RES_GRFATR_GAMMA */ 0,
3332 : /* RES_GRFATR_INVERT */ 0,
3333 : /* RES_GRFATR_TRANSPARENCY */ 0,
3334 : /* RES_GRFATR_DRWAMODE */ 0,
3335 : /* RES_GRFATR_DUMMY1 */ 0,
3336 : /* RES_GRFATR_DUMMY2 */ 0,
3337 : /* RES_GRFATR_DUMMY3 */ 0,
3338 : /* RES_GRFATR_DUMMY4 */ 0,
3339 : /* RES_GRFATR_DUMMY5 */ 0,
3340 :
3341 : /* RES_BOXATR_FORMAT */ 0,
3342 : /* RES_BOXATR_FORMULA */ 0,
3343 : /* RES_BOXATR_VALUE */ 0
3344 99 : };
3345 :
3346 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
