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