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