Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include "hintids.hxx"
21 : #include <comphelper/string.hxx>
22 : #include <vcl/svapp.hxx>
23 : #include <vcl/wrkwin.hxx>
24 : #include <svl/whiter.hxx>
25 : #include <editeng/boxitem.hxx>
26 : #include <editeng/ulspitem.hxx>
27 : #include <editeng/udlnitem.hxx>
28 : #include <editeng/crossedoutitem.hxx>
29 : #include <editeng/blinkitem.hxx>
30 : #include <editeng/cmapitem.hxx>
31 : #include <editeng/colritem.hxx>
32 : #include <editeng/fontitem.hxx>
33 : #include <editeng/fhgtitem.hxx>
34 : #include <editeng/postitem.hxx>
35 : #include <editeng/kernitem.hxx>
36 : #include <editeng/wghtitem.hxx>
37 : #include <editeng/lspcitem.hxx>
38 : #include <editeng/adjustitem.hxx>
39 : #include <editeng/lrspitem.hxx>
40 : #include <editeng/brushitem.hxx>
41 : #include <editeng/formatbreakitem.hxx>
42 : #include <editeng/keepitem.hxx>
43 : #include <editeng/widwitem.hxx>
44 : #include <editeng/spltitem.hxx>
45 : #include <editeng/orphitem.hxx>
46 : #include <editeng/charhiddenitem.hxx>
47 : #include <svx/xoutbmp.hxx>
48 : #include <svx/svdobj.hxx>
49 : #include <editeng/langitem.hxx>
50 : #include <editeng/frmdiritem.hxx>
51 : #include <svtools/htmlout.hxx>
52 : #include <svtools/htmlkywd.hxx>
53 : #include <sfx2/htmlmode.hxx>
54 : #include <svl/urihelper.hxx>
55 : #include <tools/urlobj.hxx>
56 : #include <unotools/charclass.hxx>
57 : #include <i18nlangtag/languagetag.hxx>
58 : #include <charfmt.hxx>
59 : #include <fmtclds.hxx>
60 : #include <fmtcol.hxx>
61 : #include <fmtfsize.hxx>
62 : #include <fmtornt.hxx>
63 : #include <fmtpdsc.hxx>
64 : #include <fmtlsplt.hxx>
65 : #include <pagedesc.hxx>
66 : #include <fmtanchr.hxx>
67 : #include <docary.hxx>
68 : #include <pam.hxx>
69 : #include <viewsh.hxx>
70 : #include <viewopt.hxx>
71 : #include <swtable.hxx>
72 : // OTES
73 : #include <ftninfo.hxx>
74 : #include <ftnidx.hxx>
75 : #include <txtftn.hxx>
76 : #include <fmtftn.hxx>
77 : // FOOTNOTES
78 : #include "doc.hxx"
79 : #include <IDocumentSettingAccess.hxx>
80 : #include <IDocumentLayoutAccess.hxx>
81 : #include "swerror.h"
82 : #include "charatr.hxx"
83 : #include "paratr.hxx"
84 : #include "frmatr.hxx"
85 : #include "poolfmt.hxx"
86 : #include "fltini.hxx"
87 : #include "css1kywd.hxx"
88 : #include "wrthtml.hxx"
89 : #include "htmlnum.hxx"
90 : #include "css1atr.hxx"
91 :
92 : #include <IDocumentStylePoolAccess.hxx>
93 : #include <numrule.hxx>
94 :
95 : #include <rtl/strbuf.hxx>
96 :
97 : using namespace css;
98 : using editeng::SvxBorderLine;
99 :
100 : #define HTML_HEADSPACE (12*20)
101 :
102 : #define CSS1_BACKGROUND_ATTR 1
103 : #define CSS1_BACKGROUND_PAGE 2
104 : #define CSS1_BACKGROUND_TABLE 3
105 : #define CSS1_BACKGROUND_FLY 4
106 : #define CSS1_BACKGROUND_SECTION 5
107 :
108 : #define CSS1_FRMSIZE_WIDTH 0x01
109 : #define CSS1_FRMSIZE_VARHEIGHT 0x02
110 : #define CSS1_FRMSIZE_MINHEIGHT 0x04
111 : #define CSS1_FRMSIZE_FIXHEIGHT 0x08
112 : #define CSS1_FRMSIZE_ANYHEIGHT 0x0e
113 : #define CSS1_FRMSIZE_PIXEL 0x10
114 :
115 : extern SwAttrFnTab aCSS1AttrFnTab;
116 :
117 : static Writer& OutCSS1_SwFmt( Writer& rWrt, const SwFmt& rFmt,
118 : IDocumentStylePoolAccess /*SwDoc*/ *pDoc, SwDoc *pTemplate );
119 : static Writer& OutCSS1_SwPageDesc( Writer& rWrt, const SwPageDesc& rFmt,
120 : IDocumentStylePoolAccess /*SwDoc*/ *pDoc, SwDoc *pTemplate,
121 : sal_uInt16 nRefPoolId, bool bExtRef,
122 : bool bPseudo=true );
123 : static Writer& OutCSS1_SwFtnInfo( Writer& rWrt, const SwEndNoteInfo& rInfo,
124 : SwDoc *pDoc, sal_uInt16 nNotes, bool bEndNote );
125 : static void OutCSS1_SwFmtDropAttrs( SwHTMLWriter& rHWrt,
126 : const SwFmtDrop& rDrop,
127 : const SfxItemSet *pCharFmtItemSet=0 );
128 : static Writer& OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink( Writer& rWrt,
129 : const SvxUnderlineItem *pUItem,
130 : const SvxOverlineItem *pOItem,
131 : const SvxCrossedOutItem *pCOItem,
132 : const SvxBlinkItem *pBItem );
133 : static Writer& OutCSS1_SvxFontWeight( Writer& rWrt, const SfxPoolItem& rHt );
134 : static Writer& OutCSS1_SvxPosture( Writer& rWrt, const SfxPoolItem& rHt );
135 : static Writer& OutCSS1_SvxULSpace( Writer& rWrt, const SfxPoolItem& rHt );
136 : static Writer& OutCSS1_SvxLRSpace( Writer& rWrt, const SfxPoolItem& rHt );
137 : static Writer& OutCSS1_SvxULSpace_SvxLRSpace( Writer& rWrt,
138 : const SvxULSpaceItem *pULSpace,
139 : const SvxLRSpaceItem *pLRSpace );
140 : static Writer& OutCSS1_SvxULSpace_SvxLRSpace( Writer& rWrt,
141 : const SfxItemSet& rItemSet,
142 : bool bDeep );
143 : static Writer& OutCSS1_SvxBrush( Writer& rWrt, const SfxPoolItem& rHt,
144 : sal_uInt16 nMode );
145 : static Writer& OutCSS1_SvxBrush( Writer& rWrt, const SfxPoolItem& rHt );
146 : static Writer& OutCSS1_SwFmtFrmSize( Writer& rWrt, const SfxPoolItem& rHt,
147 : sal_uInt16 nMode );
148 : static Writer& OutCSS1_SvxFmtBreak_SwFmtPDesc_SvxFmtKeep( Writer& rWrt,
149 : const SfxItemSet& rItemSet,
150 : bool bDeep );
151 : static Writer& OutCSS1_SwFmtLayoutSplit( Writer& rWrt, const SfxPoolItem& rHt );
152 :
153 : namespace
154 : {
155 :
156 : const sal_Char* sCSS1_rule_end = " }";
157 : const sal_Char* sCSS1_span_tag_end = "\">";
158 : const sal_Char cCSS1_style_opt_end = '\"';
159 :
160 : const sal_Char* sHTML_FTN_fontheight = "57%";
161 :
162 1674 : OString lclConvToHex(sal_uInt16 nHex)
163 : {
164 1674 : sal_Char aNToABuf[] = "00";
165 :
166 : // set pointer to end of buffer
167 1674 : sal_Char *pStr = aNToABuf + (sizeof(aNToABuf)-1);
168 5022 : for( sal_uInt8 n = 0; n < 2; ++n )
169 : {
170 3348 : *(--pStr) = (sal_Char)(nHex & 0xf ) + 48;
171 3348 : if( *pStr > '9' )
172 74 : *pStr += 39;
173 3348 : nHex >>= 4;
174 : }
175 :
176 1674 : return OString(aNToABuf, 2);
177 : }
178 :
179 558 : static OString lclGetCSS1Color(const Color& rColor)
180 : {
181 558 : return "#" + lclConvToHex(rColor.GetRed()) + lclConvToHex(rColor.GetGreen()) + lclConvToHex(rColor.GetBlue());
182 : }
183 :
184 : }
185 :
186 : class SwCSS1OutMode
187 : {
188 : SwHTMLWriter& rWrt;
189 : sal_uInt16 nOldMode;
190 :
191 : public:
192 :
193 1778 : SwCSS1OutMode( SwHTMLWriter& rHWrt, sal_uInt16 nMode, bool bStartFirst=true,
194 : const OUString *pSelector=0 ) :
195 : rWrt( rHWrt ),
196 1778 : nOldMode( rHWrt.nCSS1OutMode )
197 : {
198 1778 : rWrt.nCSS1OutMode = nMode;
199 1778 : if( bStartFirst )
200 1778 : rWrt.bFirstCSS1Property = true;
201 1778 : if( pSelector )
202 96 : rWrt.aCSS1Selector = *pSelector;
203 1778 : }
204 :
205 1778 : ~SwCSS1OutMode()
206 : {
207 1778 : rWrt.nCSS1OutMode = nOldMode;
208 1778 : }
209 : };
210 :
211 3024 : void SwHTMLWriter::OutCSS1_Property( const sal_Char *pProp,
212 : const sal_Char *pVal,
213 : const OUString *pSVal )
214 : {
215 3024 : OStringBuffer sOut;
216 :
217 3024 : if( bFirstCSS1Rule && (nCSS1OutMode & CSS1_OUTMODE_RULE_ON)!=0 )
218 : {
219 20 : bFirstCSS1Rule = false;
220 20 : OutNewLine();
221 40 : sOut.append("<" + OString(OOO_STRING_SVTOOLS_HTML_style) + " " +
222 60 : OString(OOO_STRING_SVTOOLS_HTML_O_type) + "=\"text/css\">");
223 20 : Strm().WriteCharPtr( sOut.makeStringAndClear().getStr() );
224 :
225 20 : IncIndentLevel();
226 : }
227 :
228 3024 : if( bFirstCSS1Property )
229 : {
230 700 : switch( nCSS1OutMode & CSS1_OUTMODE_ANY_ON )
231 : {
232 : case CSS1_OUTMODE_SPAN_TAG_ON:
233 : case CSS1_OUTMODE_SPAN_TAG1_ON:
234 22 : if( bTagOn )
235 : {
236 24 : sOut.append("<" + OString(OOO_STRING_SVTOOLS_HTML_span) +
237 36 : " " + OString(OOO_STRING_SVTOOLS_HTML_O_style) + "=\"");
238 : }
239 : else
240 : {
241 10 : HTMLOutFuncs::Out_AsciiTag( Strm(), OOO_STRING_SVTOOLS_HTML_span, false );
242 3034 : return;
243 : }
244 12 : break;
245 :
246 : case CSS1_OUTMODE_RULE_ON:
247 : {
248 92 : OutNewLine();
249 92 : sOut.append(OUStringToOString(aCSS1Selector, eDestEnc) + " { ");
250 : }
251 92 : break;
252 :
253 : case CSS1_OUTMODE_STYLE_OPT_ON:
254 586 : sOut.append(" " + OString(OOO_STRING_SVTOOLS_HTML_O_style) + "=\"");
255 586 : break;
256 : }
257 690 : bFirstCSS1Property = false;
258 : }
259 : else
260 : {
261 2324 : sOut.append("; ");
262 : }
263 :
264 3014 : sOut.append(OString(pProp) + ": ");
265 3014 : if( nCSS1OutMode & CSS1_OUTMODE_ENCODE )
266 : {
267 : // for STYLE-Option encode string
268 2780 : Strm().WriteCharPtr( sOut.makeStringAndClear().getStr() );
269 2780 : if( pVal )
270 2764 : HTMLOutFuncs::Out_String( Strm(), OUString::createFromAscii(pVal),
271 5528 : eDestEnc, &aNonConvertableCharacters );
272 16 : else if( pSVal )
273 16 : HTMLOutFuncs::Out_String( Strm(), *pSVal, eDestEnc, &aNonConvertableCharacters );
274 : }
275 : else
276 : {
277 : // for STYLE-Tag print string directly
278 234 : if( pVal )
279 166 : sOut.append(pVal);
280 68 : else if( pSVal )
281 68 : sOut.append(OUStringToOString(*pSVal, eDestEnc));
282 : }
283 :
284 3014 : if (!sOut.isEmpty())
285 234 : Strm().WriteCharPtr( sOut.makeStringAndClear().getStr() );
286 : }
287 :
288 2222 : static void AddUnitPropertyValue(OStringBuffer &rOut, long nVal,
289 : FieldUnit eUnit)
290 : {
291 2222 : if( nVal < 0 )
292 : {
293 : // special-case sign symbol
294 0 : nVal = -nVal;
295 0 : rOut.append('-');
296 : }
297 :
298 : // the recalculated unit results from (x * nMul)/(nDiv*nFac*10)
299 2222 : long nMul = 1000;
300 2222 : long nDiv = 1;
301 2222 : long nFac = 100;
302 : const sal_Char *pUnit;
303 2222 : switch( eUnit )
304 : {
305 : case FUNIT_100TH_MM:
306 : OSL_ENSURE( FUNIT_MM == eUnit, "Measuring unit not supported" );
307 : //fall-through
308 : case FUNIT_MM:
309 : // 0.01mm = 0.57twip
310 0 : nMul = 25400; // 25.4 * 1000
311 0 : nDiv = 1440; // 72 * 20;
312 0 : nFac = 100;
313 0 : pUnit = sCSS1_UNIT_mm;
314 0 : break;
315 :
316 : case FUNIT_M:
317 : case FUNIT_KM:
318 : OSL_ENSURE( FUNIT_CM == eUnit, "Measuring unit not supported" );
319 : //fall-through
320 : case FUNIT_CM:
321 : // 0.01cm = 5.7twip (not exact, but the UI is also not exact)
322 18 : nMul = 2540; // 2.54 * 1000
323 18 : nDiv = 1440; // 72 * 20;
324 18 : nFac = 100;
325 18 : pUnit = sCSS1_UNIT_cm;
326 18 : break;
327 :
328 : case FUNIT_TWIP:
329 : OSL_ENSURE( FUNIT_POINT == eUnit, "Measuring unit not supported" );
330 : //fall-through
331 : case FUNIT_POINT:
332 : // 0.1pt = 2.0twip (not exact, but the UI is also not exact)
333 0 : nMul = 100;
334 0 : nDiv = 20;
335 0 : nFac = 10;
336 0 : pUnit = sCSS1_UNIT_pt;
337 0 : break;
338 :
339 : case FUNIT_PICA:
340 : // 0.01pc = 2.40twip (not exact, but the UI is also not exact)
341 0 : nMul = 1000;
342 0 : nDiv = 240; // 12 * 20;
343 0 : nFac = 100;
344 0 : pUnit = sCSS1_UNIT_pc;
345 0 : break;
346 :
347 : case FUNIT_NONE:
348 : case FUNIT_FOOT:
349 : case FUNIT_MILE:
350 : case FUNIT_CUSTOM:
351 : case FUNIT_PERCENT:
352 : case FUNIT_INCH:
353 : default:
354 : OSL_ENSURE( FUNIT_INCH == eUnit, "Measuring unit not supported" );
355 : // 0.01in = 14.4twip (not exact, but the UI is also not exact)
356 2204 : nMul = 1000;
357 2204 : nDiv = 1440; // 72 * 20;
358 2204 : nFac = 100;
359 2204 : pUnit = sCSS1_UNIT_inch;
360 2204 : break;
361 : }
362 :
363 2222 : long nLongVal = 0;
364 2222 : bool bOutLongVal = true;
365 2222 : if( nVal > LONG_MAX / nMul )
366 : {
367 0 : sal_Int64 nBigVal( nVal );
368 0 : nBigVal *= nMul;
369 0 : nBigVal /= nDiv;
370 0 : nBigVal += 5;
371 0 : nBigVal /= 10;
372 :
373 : if( nBigVal <= LONG_MAX )
374 : {
375 : // a long is sufficient
376 0 : nLongVal = (long)nBigVal;
377 : }
378 : else
379 : {
380 : rOut.append(nBigVal / (sal_Int64)nFac);
381 : if( (nBigVal % (sal_Int64)nFac) != 0 )
382 : {
383 : rOut.append('.');
384 : while( nFac > 1 && (nBigVal % (sal_Int64)nFac) != 0 )
385 : {
386 : nFac /= 10;
387 : rOut.append((nBigVal / (sal_Int64)nFac) % (sal_Int64)10);
388 : }
389 : }
390 : bOutLongVal = false;
391 : }
392 : }
393 : else
394 : {
395 2222 : nLongVal = nVal * nMul;
396 2222 : nLongVal /= nDiv;
397 2222 : nLongVal += 5;
398 2222 : nLongVal /= 10;
399 : }
400 :
401 2222 : if( bOutLongVal )
402 : {
403 2222 : rOut.append(OString::number(nLongVal/nFac));
404 2222 : if( (nLongVal % nFac) != 0 )
405 : {
406 2200 : rOut.append('.');
407 8786 : while( nFac > 1 && (nLongVal % nFac) != 0 )
408 : {
409 4386 : nFac /= 10;
410 4386 : rOut.append(OString::number((nLongVal / nFac) % 10));
411 : }
412 : }
413 : }
414 :
415 2222 : rOut.append(pUnit);
416 2222 : }
417 :
418 2202 : void SwHTMLWriter::OutCSS1_UnitProperty( const sal_Char *pProp, long nVal )
419 : {
420 2202 : OStringBuffer sOut;
421 2202 : AddUnitPropertyValue(sOut, nVal, eCSS1Unit);
422 2202 : OutCSS1_PropertyAscii(pProp, sOut.makeStringAndClear());
423 2202 : }
424 :
425 0 : void SwHTMLWriter::OutCSS1_PixelProperty( const sal_Char *pProp, long nVal,
426 : bool bVert )
427 : {
428 0 : OString sOut(OString::number(ToPixel(nVal,bVert)) + sCSS1_UNIT_px);
429 0 : OutCSS1_PropertyAscii(pProp, sOut);
430 0 : }
431 :
432 652 : void SwHTMLWriter::OutCSS1_SfxItemSet( const SfxItemSet& rItemSet,
433 : bool bDeep )
434 : {
435 : // print ItemSet, including all attributes
436 652 : Out_SfxItemSet( aCSS1AttrFnTab, *this, rItemSet, bDeep );
437 :
438 : // some Attributes require special treatment
439 652 : const SfxPoolItem *pItem = 0;
440 :
441 : // Underline, Overline, CrossedOut and Blink form together a CSS1-Property
442 : // (doesn't work of course for Hints)
443 652 : if( !IsCSS1Source(CSS1_OUTMODE_HINT) )
444 : {
445 652 : const SvxUnderlineItem *pUnderlineItem = 0;
446 652 : if( SfxItemState::SET==rItemSet.GetItemState( RES_CHRATR_UNDERLINE, bDeep, &pItem ))
447 16 : pUnderlineItem = (const SvxUnderlineItem *)pItem;
448 :
449 652 : const SvxOverlineItem *pOverlineItem = 0;
450 652 : if( SfxItemState::SET==rItemSet.GetItemState( RES_CHRATR_OVERLINE, bDeep, &pItem ))
451 0 : pOverlineItem = (const SvxOverlineItem *)pItem;
452 :
453 652 : const SvxCrossedOutItem *pCrossedOutItem = 0;
454 652 : if( SfxItemState::SET==rItemSet.GetItemState( RES_CHRATR_CROSSEDOUT, bDeep, &pItem ))
455 0 : pCrossedOutItem = (const SvxCrossedOutItem *)pItem;
456 :
457 652 : const SvxBlinkItem *pBlinkItem = 0;
458 652 : if( SfxItemState::SET==rItemSet.GetItemState( RES_CHRATR_BLINK, bDeep, &pItem ))
459 0 : pBlinkItem = (const SvxBlinkItem *)pItem;
460 :
461 652 : if( pUnderlineItem || pOverlineItem || pCrossedOutItem || pBlinkItem )
462 : OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink( *this, pUnderlineItem,
463 : pOverlineItem,
464 : pCrossedOutItem,
465 16 : pBlinkItem );
466 :
467 652 : OutCSS1_SvxFmtBreak_SwFmtPDesc_SvxFmtKeep( *this, rItemSet, bDeep );
468 : }
469 :
470 652 : if( !bFirstCSS1Property )
471 : {
472 : // if a Property was exported as part of a Style-Option,
473 : // the Option still needs to be finished
474 126 : OStringBuffer sOut;
475 126 : switch( nCSS1OutMode & CSS1_OUTMODE_ANY_OFF )
476 : {
477 : case CSS1_OUTMODE_SPAN_TAG_OFF:
478 0 : sOut.append(sCSS1_span_tag_end);
479 0 : break;
480 :
481 : case CSS1_OUTMODE_STYLE_OPT_OFF:
482 46 : sOut.append(cCSS1_style_opt_end);
483 46 : break;
484 :
485 : case CSS1_OUTMODE_RULE_OFF:
486 72 : sOut.append(sCSS1_rule_end);
487 72 : break;
488 : }
489 126 : if (!sOut.isEmpty())
490 118 : Strm().WriteCharPtr( sOut.makeStringAndClear().getStr() );
491 : }
492 652 : }
493 :
494 22 : void SwHTMLWriter::OutStyleSheet( const SwPageDesc& rPageDesc, bool bUsed )
495 : {
496 22 : bFirstCSS1Rule = true;
497 :
498 : // Feature: PrintExt
499 22 : if( IsHTMLMode(HTMLMODE_PRINT_EXT) )
500 : {
501 22 : const SwPageDesc *pFirstPageDesc = 0;
502 22 : sal_uInt16 nFirstRefPoolId = RES_POOLPAGE_HTML;
503 22 : bCSS1IgnoreFirstPageDesc = true;
504 :
505 : // First we try to guess how the document is constructed.
506 : // Allowed are only the templates: HTML, 1st page, left page, and right page.
507 : // A first page is only exported, if it matches the template "1st page".
508 : // Left and right pages are only exported, if their templates are linked.
509 : // If other templates are used, only very simple cases are exported.
510 22 : const SwPageDesc *pPageDesc = &rPageDesc;
511 22 : const SwPageDesc *pFollow = rPageDesc.GetFollow();
512 44 : if( RES_POOLPAGE_FIRST == pPageDesc->GetPoolFmtId() &&
513 22 : pFollow != pPageDesc &&
514 0 : !IsPoolUserFmt( pFollow->GetPoolFmtId() ) )
515 : {
516 : // the document has a first page
517 0 : pFirstPageDesc = pPageDesc;
518 0 : pPageDesc = pFollow;
519 0 : pFollow = pPageDesc->GetFollow();
520 : }
521 :
522 22 : IDocumentStylePoolAccess* pStylePoolAccess = getIDocumentStylePoolAccess();
523 22 : if( pPageDesc == pFollow )
524 : {
525 : // The document is one-sided; no matter what page, we do not create a 2-sided doc.
526 : // The attribute is exported relative to the HTML page template.
527 : OutCSS1_SwPageDesc( *this, *pPageDesc, pStylePoolAccess, pTemplate,
528 22 : RES_POOLPAGE_HTML, true, false );
529 22 : nFirstRefPoolId = pFollow->GetPoolFmtId();
530 : }
531 0 : else if( (RES_POOLPAGE_LEFT == pPageDesc->GetPoolFmtId() &&
532 0 : RES_POOLPAGE_RIGHT == pFollow->GetPoolFmtId()) ||
533 0 : (RES_POOLPAGE_RIGHT == pPageDesc->GetPoolFmtId() &&
534 0 : RES_POOLPAGE_LEFT == pFollow->GetPoolFmtId()) )
535 : {
536 : // the document is double-sided
537 : OutCSS1_SwPageDesc( *this, *pPageDesc, pStylePoolAccess, pTemplate,
538 0 : RES_POOLPAGE_HTML, true );
539 : OutCSS1_SwPageDesc( *this, *pFollow, pStylePoolAccess, pTemplate,
540 0 : RES_POOLPAGE_HTML, true );
541 0 : nFirstRefPoolId = RES_POOLPAGE_RIGHT;
542 0 : bCSS1IgnoreFirstPageDesc = false;
543 : }
544 : // other cases we miss
545 :
546 22 : if( pFirstPageDesc )
547 : OutCSS1_SwPageDesc( *this, *pFirstPageDesc, pStylePoolAccess, pTemplate,
548 0 : nFirstRefPoolId, false );
549 : }
550 : // /Feature: PrintExt
551 :
552 : // The text body style has to be exported always (if it is changed compared
553 : // to the template), because it is used as reference for any style
554 : // that maps to <P>, and that's especially the standard style
555 22 : getIDocumentStylePoolAccess()->GetTxtCollFromPool( RES_POOLCOLL_TEXT, false );
556 :
557 : // the Default-TextStyle is not also exported !!
558 : // 0-Style is the Default; is never exported !!
559 22 : sal_uInt16 nArrLen = pDoc->GetTxtFmtColls()->size();
560 : sal_uInt16 i;
561 :
562 240 : for( i = 1; i < nArrLen; i++ )
563 : {
564 218 : const SwTxtFmtColl* pColl = (*pDoc->GetTxtFmtColls())[i];
565 218 : sal_uInt16 nPoolId = pColl->GetPoolFmtId();
566 414 : if( !bUsed || nPoolId == RES_POOLCOLL_TEXT ||
567 196 : pDoc->IsUsed( *pColl ) )
568 48 : OutCSS1_SwFmt( *this, *pColl, &pDoc->getIDocumentStylePoolAccess(), pTemplate );
569 : }
570 :
571 : // the Default-TextStyle is not also exported !!
572 22 : nArrLen = pDoc->GetCharFmts()->size();
573 82 : for( i=1; i<nArrLen; i++ )
574 : {
575 60 : const SwCharFmt *pCFmt = (*pDoc->GetCharFmts())[i];
576 60 : sal_uInt16 nPoolId = pCFmt->GetPoolFmtId();
577 180 : if( !bUsed || nPoolId == RES_POOLCHR_INET_NORMAL ||
578 108 : nPoolId == RES_POOLCHR_INET_VISIT ||
579 48 : pDoc->IsUsed( *pCFmt ) )
580 12 : OutCSS1_SwFmt( *this, *pCFmt, &pDoc->getIDocumentStylePoolAccess(), pTemplate );
581 : }
582 :
583 22 : const SwFtnIdxs& rIdxs = pDoc->GetFtnIdxs();
584 22 : nArrLen = rIdxs.size();
585 22 : sal_uInt16 nEnd = 0, nFtn = 0;
586 22 : for( i=0; i < nArrLen; i++ )
587 : {
588 0 : if( rIdxs[i]->GetFtn().IsEndNote() )
589 0 : nEnd++;
590 : else
591 0 : nFtn++;
592 : }
593 22 : OutCSS1_SwFtnInfo( *this, pDoc->GetFtnInfo(), pDoc, nFtn, false );
594 22 : OutCSS1_SwFtnInfo( *this, pDoc->GetEndNoteInfo(), pDoc, nEnd, true );
595 :
596 22 : if( !bFirstCSS1Rule )
597 : {
598 20 : DecIndentLevel();
599 :
600 20 : OutNewLine();
601 20 : HTMLOutFuncs::Out_AsciiTag( Strm(), OOO_STRING_SVTOOLS_HTML_style, false );
602 : }
603 : else
604 : {
605 2 : bFirstCSS1Rule = false;
606 : }
607 :
608 22 : nDfltTopMargin = 0;
609 22 : nDfltBottomMargin = 0;
610 22 : }
611 :
612 : // if pPseudo is set, Styles-Sheets will be exported;
613 : // otherwise we only search for Token and Class for a Format
614 88 : sal_uInt16 SwHTMLWriter::GetCSS1Selector( const SwFmt *pFmt, OString& rToken,
615 : OUString& rClass, sal_uInt16& rRefPoolId,
616 : OUString *pPseudo )
617 : {
618 88 : sal_uInt16 nDeep = 0;
619 88 : rToken = OString();
620 88 : rClass = "";
621 88 : rRefPoolId = 0;
622 88 : if( pPseudo )
623 60 : *pPseudo = "";
624 :
625 88 : bool bChrFmt = RES_CHRFMT==pFmt->Which();
626 :
627 : // search formats above for the nearest standard or HTML-Tag template
628 88 : const SwFmt *pPFmt = pFmt;
629 188 : while( pPFmt && !pPFmt->IsDefault() )
630 : {
631 96 : bool bStop = false;
632 96 : sal_uInt16 nPoolId = pPFmt->GetPoolFmtId();
633 96 : if( USER_FMT & nPoolId )
634 : {
635 : // user templates
636 8 : const OUString aNm(pPFmt->GetName());
637 :
638 8 : if (!bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_blockquote)
639 : {
640 0 : rRefPoolId = RES_POOLCOLL_HTML_BLOCKQUOTE;
641 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_blockquote);
642 : }
643 8 : else if (bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_citiation)
644 : {
645 0 : rRefPoolId = RES_POOLCHR_HTML_CITIATION;
646 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_citiation);
647 : }
648 8 : else if (bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_code)
649 : {
650 0 : rRefPoolId = RES_POOLCHR_HTML_CODE;
651 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_code);
652 : }
653 8 : else if (bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_definstance)
654 : {
655 0 : rRefPoolId = RES_POOLCHR_HTML_DEFINSTANCE;
656 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_definstance);
657 : }
658 16 : else if (!bChrFmt && (aNm == OOO_STRING_SVTOOLS_HTML_dd ||
659 8 : aNm == OOO_STRING_SVTOOLS_HTML_dt))
660 : {
661 0 : sal_uInt16 nDefListLvl = GetDefListLvl(aNm, nPoolId);
662 : // Export the templates DD 1/DT 1,
663 : // but none of their derived templates,
664 : // also not DD 2/DT 2 etc.
665 0 : if (nDefListLvl)
666 : {
667 0 : if (pPseudo && (nDeep || (nDefListLvl & 0x0fff) > 1))
668 : {
669 0 : bStop = true;
670 : }
671 0 : else if (nDefListLvl & HTML_DLCOLL_DD)
672 : {
673 0 : rRefPoolId = RES_POOLCOLL_HTML_DD;
674 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_dd);
675 : }
676 : else
677 : {
678 0 : rRefPoolId = RES_POOLCOLL_HTML_DT;
679 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_dt);
680 : }
681 : }
682 : }
683 8 : else if (bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_emphasis)
684 : {
685 0 : rRefPoolId = RES_POOLCHR_HTML_EMPHASIS;
686 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_emphasis);
687 : }
688 8 : else if (!bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_horzrule)
689 : {
690 : // do not export HR !
691 0 : bStop = (nDeep==0);
692 : }
693 8 : else if (bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_keyboard)
694 : {
695 0 : rRefPoolId = RES_POOLCHR_HTML_KEYBOARD;
696 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_keyboard);
697 : }
698 8 : else if (!bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_listing)
699 : {
700 : // Export Listings as PRE or PRE-derived template
701 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_preformtxt);
702 0 : rRefPoolId = RES_POOLCOLL_HTML_PRE;
703 0 : nDeep = CSS1_FMT_CMPREF;
704 : }
705 8 : else if (!bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_preformtxt)
706 : {
707 0 : rRefPoolId = RES_POOLCOLL_HTML_PRE;
708 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_preformtxt);
709 : }
710 8 : else if (bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_sample)
711 : {
712 0 : rRefPoolId = RES_POOLCHR_HTML_SAMPLE;
713 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_sample);
714 : }
715 8 : else if (bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_strong)
716 : {
717 0 : rRefPoolId = RES_POOLCHR_HTML_STRONG;
718 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_strong);
719 : }
720 8 : else if (bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_teletype)
721 : {
722 0 : rRefPoolId = RES_POOLCHR_HTML_TELETYPE;
723 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_teletype);
724 : }
725 8 : else if (bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_variable)
726 : {
727 0 : rRefPoolId = RES_POOLCHR_HTML_VARIABLE;
728 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_variable);
729 : }
730 8 : else if (!bChrFmt && aNm == OOO_STRING_SVTOOLS_HTML_xmp)
731 : {
732 : // export XMP as PRE (but not the template as Style)
733 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_preformtxt);
734 0 : rRefPoolId = RES_POOLCOLL_HTML_PRE;
735 0 : nDeep = CSS1_FMT_CMPREF;
736 : }
737 :
738 : // if a PoolId is set, the Name of the template is that of the related Token
739 : OSL_ENSURE( (rRefPoolId != 0) == (!rToken.isEmpty()),
740 8 : "Token missing" );
741 : }
742 : else
743 : {
744 : // Pool templates
745 88 : switch( nPoolId )
746 : {
747 : // paragraph templates
748 : case RES_POOLCOLL_HEADLINE_BASE:
749 : case RES_POOLCOLL_STANDARD:
750 : // do not export this template
751 44 : bStop = (nDeep==0);
752 44 : break;
753 : case RES_POOLCOLL_TEXT:
754 32 : rToken = OString(OOO_STRING_SVTOOLS_HTML_parabreak);
755 32 : break;
756 : case RES_POOLCOLL_HEADLINE1:
757 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_head1);
758 0 : break;
759 : case RES_POOLCOLL_HEADLINE2:
760 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_head2);
761 0 : break;
762 : case RES_POOLCOLL_HEADLINE3:
763 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_head3);
764 0 : break;
765 : case RES_POOLCOLL_HEADLINE4:
766 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_head4);
767 0 : break;
768 : case RES_POOLCOLL_HEADLINE5:
769 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_head5);
770 0 : break;
771 : case RES_POOLCOLL_HEADLINE6:
772 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_head6);
773 0 : break;
774 : case RES_POOLCOLL_SENDADRESS:
775 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_address);
776 0 : break;
777 : case RES_POOLCOLL_HTML_BLOCKQUOTE:
778 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_blockquote);
779 0 : break;
780 : case RES_POOLCOLL_HTML_PRE:
781 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_preformtxt);
782 0 : break;
783 :
784 : case RES_POOLCOLL_HTML_DD:
785 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_dd);
786 0 : break;
787 : case RES_POOLCOLL_HTML_DT:
788 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_dt);
789 0 : break;
790 :
791 : case RES_POOLCOLL_TABLE:
792 0 : if( pPseudo )
793 : {
794 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_tabledata) + " " +
795 0 : OString(OOO_STRING_SVTOOLS_HTML_parabreak);
796 : }
797 : else
798 0 : rToken = OOO_STRING_SVTOOLS_HTML_parabreak;
799 0 : break;
800 : case RES_POOLCOLL_TABLE_HDLN:
801 0 : if( pPseudo )
802 : {
803 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_tableheader) + " " +
804 0 : OString(OOO_STRING_SVTOOLS_HTML_parabreak);
805 : }
806 : else
807 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_parabreak);
808 0 : break;
809 : case RES_POOLCOLL_HTML_HR:
810 : // do not exort HR !
811 0 : bStop = (nDeep==0);
812 0 : break;
813 : case RES_POOLCOLL_FOOTNOTE:
814 0 : if( !nDeep )
815 : {
816 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_parabreak);
817 0 : rClass = OOO_STRING_SVTOOLS_HTML_sdfootnote;
818 0 : rRefPoolId = RES_POOLCOLL_TEXT;
819 0 : nDeep = CSS1_FMT_CMPREF;
820 : }
821 0 : break;
822 : case RES_POOLCOLL_ENDNOTE:
823 0 : if( !nDeep )
824 : {
825 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_parabreak);
826 0 : rClass = OOO_STRING_SVTOOLS_HTML_sdendnote;
827 0 : rRefPoolId = RES_POOLCOLL_TEXT;
828 0 : nDeep = CSS1_FMT_CMPREF;
829 : }
830 0 : break;
831 :
832 : // character templates
833 : case RES_POOLCHR_HTML_EMPHASIS:
834 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_emphasis);
835 0 : break;
836 : case RES_POOLCHR_HTML_CITIATION:
837 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_citiation);
838 0 : break;
839 : case RES_POOLCHR_HTML_STRONG:
840 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_strong);
841 0 : break;
842 : case RES_POOLCHR_HTML_CODE:
843 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_code);
844 0 : break;
845 : case RES_POOLCHR_HTML_SAMPLE:
846 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_sample);
847 0 : break;
848 : case RES_POOLCHR_HTML_KEYBOARD:
849 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_keyboard);
850 0 : break;
851 : case RES_POOLCHR_HTML_VARIABLE:
852 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_variable);
853 0 : break;
854 : case RES_POOLCHR_HTML_DEFINSTANCE:
855 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_definstance);
856 0 : break;
857 : case RES_POOLCHR_HTML_TELETYPE:
858 0 : rToken = OString(OOO_STRING_SVTOOLS_HTML_teletype);
859 0 : break;
860 :
861 : case RES_POOLCHR_INET_NORMAL:
862 8 : if( pPseudo )
863 : {
864 8 : rToken = OString(OOO_STRING_SVTOOLS_HTML_anchor);
865 8 : *pPseudo = OStringToOUString( sCSS1_link, RTL_TEXTENCODING_ASCII_US );
866 : }
867 8 : break;
868 : case RES_POOLCHR_INET_VISIT:
869 4 : if( pPseudo )
870 : {
871 4 : rToken = OString(OOO_STRING_SVTOOLS_HTML_anchor);
872 4 : *pPseudo = OStringToOUString( sCSS1_visited, RTL_TEXTENCODING_ASCII_US );
873 : }
874 4 : break;
875 : }
876 :
877 : // if a token is set, PoolId contains the related template
878 88 : if( !rToken.isEmpty() && !rRefPoolId )
879 44 : rRefPoolId = nPoolId;
880 : }
881 :
882 96 : if( !rToken.isEmpty() || bStop )
883 : {
884 : // stop if a HTML-Tag template was found
885 84 : break;
886 : }
887 : else
888 : {
889 : // continue otherwise
890 12 : nDeep++;
891 12 : pPFmt = pPFmt->DerivedFrom();
892 : }
893 : }
894 :
895 88 : if( !rToken.isEmpty() )
896 : {
897 : // this is a HTML-Tag template
898 44 : if( !nDeep )
899 40 : nDeep = CSS1_FMT_ISTAG;
900 : }
901 : else
902 : {
903 : // this is not a HTML-Tag template nor derived from one
904 44 : nDeep = 0;
905 : }
906 88 : if( nDeep > 0 && nDeep < CSS1_FMT_SPECIAL )
907 : {
908 : // If the template is derived from a HTML template,
909 : // we export it as <TOKEN>.<CLASS>, otherwise as .<CLASS>.
910 : // <CLASS> is the name of the template after removing all characters
911 : // before and including the first '.'
912 4 : rClass = pFmt->GetName();
913 4 : sal_Int32 nPos = rClass.indexOf( '.' );
914 4 : if( nPos >= 0 && rClass.getLength() > nPos+1 )
915 : {
916 0 : rClass = rClass.replaceAt( 0, nPos+1, "" );
917 : }
918 :
919 4 : rClass = GetAppCharClass().lowercase( rClass );
920 4 : rClass = rClass.replaceAll( ".", "-" );
921 4 : rClass = rClass.replaceAll( " ", "-" );
922 4 : rClass = rClass.replaceAll( "_", "-" );
923 : }
924 :
925 88 : return nDeep;
926 : }
927 :
928 60 : static sal_uInt16 GetCSS1Selector( const SwFmt *pFmt, OUString& rSelector,
929 : sal_uInt16& rRefPoolId )
930 : {
931 60 : OString aToken;
932 120 : OUString aClass;
933 120 : OUString aPseudo;
934 :
935 : sal_uInt16 nDeep = SwHTMLWriter::GetCSS1Selector( pFmt, aToken, aClass,
936 60 : rRefPoolId, &aPseudo );
937 60 : if( nDeep )
938 : {
939 36 : if( !aToken.isEmpty() )
940 36 : rSelector = OStringToOUString(aToken, RTL_TEXTENCODING_ASCII_US);
941 : else
942 0 : rSelector = "";
943 :
944 36 : if( !aClass.isEmpty() )
945 2 : rSelector += "." + aClass;
946 36 : if( !aPseudo.isEmpty() )
947 12 : rSelector += ":" + aPseudo;
948 : }
949 :
950 120 : return nDeep;
951 : }
952 :
953 102 : const SwFmt *SwHTMLWriter::GetTemplateFmt( sal_uInt16 nPoolFmtId,
954 : IDocumentStylePoolAccess* pTemplate /*SwDoc *pTemplate*/)
955 : {
956 102 : const SwFmt *pRefFmt = 0;
957 :
958 102 : if( pTemplate )
959 : {
960 : OSL_ENSURE( !(USER_FMT & nPoolFmtId),
961 : "No user templates found" );
962 102 : if( POOLGRP_NOCOLLID & nPoolFmtId )
963 56 : pRefFmt = pTemplate->GetCharFmtFromPool( nPoolFmtId );
964 : else
965 46 : pRefFmt = pTemplate->GetTxtCollFromPool( nPoolFmtId, false );
966 : }
967 :
968 102 : return pRefFmt;
969 : }
970 :
971 2 : const SwFmt *SwHTMLWriter::GetParentFmt( const SwFmt& rFmt, sal_uInt16 nDeep )
972 : {
973 : OSL_ENSURE( nDeep != USHRT_MAX, "Called GetParent for HTML-template!" );
974 2 : const SwFmt *pRefFmt = 0;
975 :
976 2 : if( nDeep > 0 )
977 : {
978 : // get the pointer for the HTML-Tag template, from which the template is derived
979 2 : pRefFmt = &rFmt;
980 4 : for( sal_uInt16 i=nDeep; i>0; i-- )
981 2 : pRefFmt = pRefFmt->DerivedFrom();
982 :
983 2 : if( pRefFmt && pRefFmt->IsDefault() )
984 0 : pRefFmt = 0;
985 : }
986 :
987 2 : return pRefFmt;
988 : }
989 :
990 12 : bool swhtml_css1atr_equalFontItems( const SfxPoolItem& r1, const SfxPoolItem& r2 )
991 : {
992 12 : return ((const SvxFontItem &)r1).GetFamilyName() ==
993 28 : ((const SvxFontItem &)r2).GetFamilyName() &&
994 4 : ((const SvxFontItem &)r1).GetFamily() ==
995 16 : ((const SvxFontItem &)r2).GetFamily();
996 : }
997 :
998 122 : void SwHTMLWriter::SubtractItemSet( SfxItemSet& rItemSet,
999 : const SfxItemSet& rRefItemSet,
1000 : bool bSetDefaults,
1001 : bool bClearSame,
1002 : const SfxItemSet *pRefScriptItemSet )
1003 : {
1004 : OSL_ENSURE( bSetDefaults || bClearSame,
1005 : "SwHTMLWriter::SubtractItemSet: No action for this Flag" );
1006 122 : SfxItemSet aRefItemSet( *rRefItemSet.GetPool(), rRefItemSet.GetRanges() );
1007 122 : aRefItemSet.Set( rRefItemSet );
1008 :
1009 : // compare with the Attr-Set of the template
1010 244 : SfxWhichIter aIter( rItemSet );
1011 122 : sal_uInt16 nWhich = aIter.FirstWhich();
1012 8496 : while( nWhich )
1013 : {
1014 : const SfxPoolItem *pRefItem, *pItem;
1015 : bool bItemSet = ( SfxItemState::SET ==
1016 8252 : rItemSet.GetItemState( nWhich, false, &pItem) );
1017 : bool bRefItemSet;
1018 :
1019 8252 : if( pRefScriptItemSet )
1020 : {
1021 256 : switch( nWhich )
1022 : {
1023 : case RES_CHRATR_FONT:
1024 : case RES_CHRATR_FONTSIZE:
1025 : case RES_CHRATR_LANGUAGE:
1026 : case RES_CHRATR_POSTURE:
1027 : case RES_CHRATR_WEIGHT:
1028 : case RES_CHRATR_CJK_FONT:
1029 : case RES_CHRATR_CJK_FONTSIZE:
1030 : case RES_CHRATR_CJK_LANGUAGE:
1031 : case RES_CHRATR_CJK_POSTURE:
1032 : case RES_CHRATR_CJK_WEIGHT:
1033 : case RES_CHRATR_CTL_FONT:
1034 : case RES_CHRATR_CTL_FONTSIZE:
1035 : case RES_CHRATR_CTL_LANGUAGE:
1036 : case RES_CHRATR_CTL_POSTURE:
1037 : case RES_CHRATR_CTL_WEIGHT:
1038 : bRefItemSet = ( SfxItemState::SET ==
1039 30 : pRefScriptItemSet->GetItemState( nWhich, true, &pRefItem) );
1040 30 : break;
1041 : default:
1042 : bRefItemSet = ( SfxItemState::SET ==
1043 226 : aRefItemSet.GetItemState( nWhich, false, &pRefItem) );
1044 226 : break;
1045 : }
1046 : }
1047 : else
1048 : {
1049 : bRefItemSet = ( SfxItemState::SET ==
1050 7996 : aRefItemSet.GetItemState( nWhich, false, &pRefItem) );
1051 : }
1052 :
1053 8252 : if( bItemSet )
1054 : {
1055 1260 : if( (bClearSame || pRefScriptItemSet) && bRefItemSet &&
1056 444 : ( *pItem == *pRefItem ||
1057 66 : ((RES_CHRATR_FONT == nWhich ||
1058 66 : RES_CHRATR_CJK_FONT == nWhich ||
1059 0 : RES_CHRATR_CTL_FONT == nWhich) &&
1060 0 : swhtml_css1atr_equalFontItems( *pItem, *pRefItem )) ) )
1061 : {
1062 : // the Attribute is in both templates wit the same value
1063 : // and does not need to be exported
1064 312 : rItemSet.ClearItem( nWhich );
1065 : }
1066 : }
1067 : else
1068 : {
1069 7682 : if( (bSetDefaults || pRefScriptItemSet) && bRefItemSet )
1070 : {
1071 : // the Attribute exists only in the reference; the default
1072 : // might have to be exported
1073 32 : rItemSet.Put( rItemSet.GetPool()->GetDefaultItem(nWhich) );
1074 : }
1075 : }
1076 :
1077 8252 : nWhich = aIter.NextWhich();
1078 122 : }
1079 122 : }
1080 :
1081 42 : void SwHTMLWriter::PrepareFontList( const SvxFontItem& rFontItem,
1082 : OUString& rNames,
1083 : sal_Unicode cQuote, bool bGeneric )
1084 : {
1085 42 : rNames = aEmptyOUStr;
1086 42 : const OUString& rName = rFontItem.GetFamilyName();
1087 42 : bool bContainsKeyword = false;
1088 42 : if( !rName.isEmpty() )
1089 : {
1090 38 : sal_Int32 nStrPos = 0;
1091 114 : while( nStrPos != -1 )
1092 : {
1093 38 : OUString aName = rName.getToken( 0, ';', nStrPos );
1094 38 : aName = comphelper::string::strip(aName, ' ');
1095 38 : if( aName.isEmpty() )
1096 0 : continue;
1097 :
1098 38 : bool bIsKeyword = false;
1099 38 : switch( aName[0] )
1100 : {
1101 : case 'c':
1102 : case 'C':
1103 20 : bIsKeyword = aName.equalsIgnoreAsciiCaseAscii( sCSS1_PV_cursive );
1104 20 : break;
1105 :
1106 : case 'f':
1107 : case 'F':
1108 0 : bIsKeyword = aName.equalsIgnoreAsciiCaseAscii( sCSS1_PV_fantasy );
1109 0 : break;
1110 :
1111 : case 'm':
1112 : case 'M':
1113 0 : bIsKeyword = aName.equalsIgnoreAsciiCaseAscii( sCSS1_PV_monospace );
1114 0 : break;
1115 :
1116 : case 's':
1117 : case 'S':
1118 : bIsKeyword =
1119 0 : aName.equalsIgnoreAsciiCaseAscii( sCSS1_PV_serif ) ||
1120 0 : aName.equalsIgnoreAsciiCaseAscii( sCSS1_PV_sans_serif );
1121 0 : break;
1122 : }
1123 :
1124 38 : bContainsKeyword |= bIsKeyword;
1125 :
1126 38 : if( !rNames.isEmpty() )
1127 0 : rNames += ", ";
1128 38 : if( cQuote && !bIsKeyword )
1129 36 : rNames += OUString( cQuote );
1130 38 : rNames += aName;
1131 38 : if( cQuote && !bIsKeyword )
1132 36 : rNames += OUString( cQuote );
1133 38 : }
1134 : }
1135 :
1136 42 : if( !bContainsKeyword && bGeneric )
1137 : {
1138 42 : const sal_Char *pStr = 0;
1139 42 : switch( rFontItem.GetFamily() )
1140 : {
1141 10 : case FAMILY_ROMAN: pStr = sCSS1_PV_serif; break;
1142 8 : case FAMILY_SWISS: pStr = sCSS1_PV_sans_serif; break;
1143 0 : case FAMILY_SCRIPT: pStr = sCSS1_PV_cursive; break;
1144 0 : case FAMILY_DECORATIVE: pStr = sCSS1_PV_fantasy; break;
1145 0 : case FAMILY_MODERN: pStr = sCSS1_PV_monospace; break;
1146 : default:
1147 : ;
1148 : }
1149 :
1150 42 : if( pStr )
1151 : {
1152 18 : if( !rNames.isEmpty() )
1153 18 : rNames += ", ";
1154 18 : rNames += OStringToOUString( pStr, RTL_TEXTENCODING_ASCII_US );
1155 : }
1156 : }
1157 42 : }
1158 :
1159 22 : bool SwHTMLWriter::HasScriptDependentItems( const SfxItemSet& rItemSet,
1160 : bool bCheckDropCap )
1161 : {
1162 : static const sal_uInt16 aWhichIds[] =
1163 : {
1164 : RES_CHRATR_FONT, RES_CHRATR_CJK_FONT, RES_CHRATR_CTL_FONT,
1165 : RES_CHRATR_FONTSIZE, RES_CHRATR_CJK_FONTSIZE, RES_CHRATR_CTL_FONTSIZE,
1166 : RES_CHRATR_LANGUAGE, RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CTL_LANGUAGE,
1167 : RES_CHRATR_POSTURE, RES_CHRATR_CJK_POSTURE, RES_CHRATR_CTL_POSTURE,
1168 : RES_CHRATR_WEIGHT, RES_CHRATR_CJK_WEIGHT, RES_CHRATR_CTL_WEIGHT,
1169 : 0, 0, 0
1170 : };
1171 :
1172 92 : for( sal_uInt16 i=0; aWhichIds[i]; i += 3 )
1173 : {
1174 42 : const SfxPoolItem *pItem = 0, *pItemCJK = 0, *pItemCTL = 0, *pTmp;
1175 42 : sal_uInt16 nItemCount = 0;
1176 84 : if( SfxItemState::SET == rItemSet.GetItemState( aWhichIds[i], false,
1177 42 : &pTmp ) )
1178 : {
1179 18 : pItem = pTmp;
1180 18 : nItemCount++;
1181 : }
1182 84 : if( SfxItemState::SET == rItemSet.GetItemState( aWhichIds[i+1], false,
1183 42 : &pTmp ) )
1184 : {
1185 12 : pItemCJK = pTmp;
1186 12 : nItemCount++;
1187 : }
1188 84 : if( SfxItemState::SET == rItemSet.GetItemState( aWhichIds[i+2], false,
1189 42 : &pTmp ) )
1190 : {
1191 14 : pItemCTL = pTmp;
1192 14 : nItemCount++;
1193 : }
1194 :
1195 : // If some of the items are set, but not all, we need script dependent
1196 : // styles
1197 42 : if( nItemCount > 0 && nItemCount < 3 )
1198 26 : return true;
1199 :
1200 34 : if( 3 == nItemCount )
1201 : {
1202 : // If all items are set, but some of them have different values,
1203 : // we need script dependent styles, too. For font items, we have
1204 : // to take care about their special HTML/CSS1 representation.
1205 12 : if( RES_CHRATR_FONT == aWhichIds[i] )
1206 : {
1207 20 : if( !swhtml_css1atr_equalFontItems( *pItem, *pItemCJK ) ||
1208 8 : !swhtml_css1atr_equalFontItems( *pItem, *pItemCTL ) ||
1209 0 : !swhtml_css1atr_equalFontItems( *pItemCJK, *pItemCTL ) )
1210 8 : return true;
1211 : }
1212 : else
1213 : {
1214 12 : if( !( *pItem == *pItemCJK ) ||
1215 6 : !( *pItem == *pItemCTL ) ||
1216 2 : !( *pItemCJK == *pItemCTL ) )
1217 2 : return true;
1218 : }
1219 : }
1220 : }
1221 :
1222 : const SfxPoolItem *pItem;
1223 4 : if( bCheckDropCap &&
1224 : SfxItemState::SET == rItemSet.GetItemState( RES_PARATR_DROP, true,
1225 0 : &pItem ) )
1226 : {
1227 0 : const SwFmtDrop *pDrop = (const SwFmtDrop *)pItem;
1228 0 : const SwCharFmt *pDCCharFmt = pDrop->GetCharFmt();
1229 0 : if( pDCCharFmt )
1230 : {
1231 : //sequence of (start, end) property ranges we want to
1232 : //query
1233 0 : SfxItemSet aTstItemSet( *pDCCharFmt->GetAttrSet().GetPool(),
1234 : RES_CHRATR_FONT, RES_CHRATR_FONT,
1235 : RES_CHRATR_POSTURE, RES_CHRATR_POSTURE,
1236 : RES_CHRATR_WEIGHT, RES_CHRATR_WEIGHT,
1237 : RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_FONT,
1238 : RES_CHRATR_CJK_POSTURE, RES_CHRATR_CJK_WEIGHT,
1239 : RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_FONT,
1240 : RES_CHRATR_CTL_POSTURE, RES_CHRATR_CTL_WEIGHT,
1241 0 : 0 );
1242 0 : aTstItemSet.Set( pDCCharFmt->GetAttrSet(), true );
1243 0 : return HasScriptDependentItems( aTstItemSet, false );
1244 : }
1245 : }
1246 :
1247 4 : return false;
1248 : }
1249 :
1250 22 : static bool OutCSS1Rule( SwHTMLWriter& rHTMLWrt, const OUString& rSelector,
1251 : const SfxItemSet& rItemSet, bool bHasClass,
1252 : bool bCheckForPseudo )
1253 : {
1254 22 : bool bScriptDependent = false;
1255 22 : if( SwHTMLWriter::HasScriptDependentItems( rItemSet, bHasClass ) )
1256 : {
1257 18 : bScriptDependent = true;
1258 18 : OUString aSelector( rSelector );
1259 :
1260 36 : OUString aPseudo;
1261 18 : if( bCheckForPseudo )
1262 : {
1263 4 : sal_Int32 nPos = aSelector.lastIndexOf( ':' );
1264 4 : if( nPos >= 0 )
1265 : {
1266 4 : aPseudo = aSelector.copy( nPos );
1267 4 : aSelector =aSelector.copy( 0, nPos );
1268 : }
1269 : }
1270 :
1271 18 : if( !bHasClass )
1272 : {
1273 : // If we are exporting styles for a tag we have to export a tag
1274 : // rule for all properties that aren't style dependent and
1275 : // some class rule for the additional style dependen properties
1276 : {
1277 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_NO_SCRIPT|CSS1_OUTMODE_RULE|CSS1_OUTMODE_TEMPLATE,
1278 16 : true, &rSelector );
1279 16 : rHTMLWrt.OutCSS1_SfxItemSet( rItemSet, false );
1280 : }
1281 :
1282 : //sequence of (start, end) property ranges we want to
1283 : //query
1284 16 : SfxItemSet aScriptItemSet( *rItemSet.GetPool(),
1285 : RES_CHRATR_FONT, RES_CHRATR_FONTSIZE,
1286 : RES_CHRATR_LANGUAGE, RES_CHRATR_POSTURE,
1287 : RES_CHRATR_WEIGHT, RES_CHRATR_WEIGHT,
1288 : RES_CHRATR_CJK_FONT, RES_CHRATR_CTL_WEIGHT,
1289 16 : 0 );
1290 16 : aScriptItemSet.Put( rItemSet );
1291 :
1292 32 : OUString aNewSelector( aSelector );
1293 16 : aNewSelector += ".western" + aPseudo;
1294 : {
1295 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_WESTERN|CSS1_OUTMODE_RULE|CSS1_OUTMODE_TEMPLATE,
1296 16 : true, &aNewSelector );
1297 16 : rHTMLWrt.OutCSS1_SfxItemSet( aScriptItemSet, false );
1298 : }
1299 :
1300 16 : aNewSelector = aSelector + ".cjk" + aPseudo;
1301 : {
1302 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_CJK|CSS1_OUTMODE_RULE|CSS1_OUTMODE_TEMPLATE,
1303 16 : true, &aNewSelector );
1304 16 : rHTMLWrt.OutCSS1_SfxItemSet( aScriptItemSet, false );
1305 : }
1306 :
1307 16 : aNewSelector = aSelector + ".ctl" + aPseudo;
1308 : {
1309 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_CTL|CSS1_OUTMODE_RULE|CSS1_OUTMODE_TEMPLATE,
1310 16 : true, &aNewSelector );
1311 16 : rHTMLWrt.OutCSS1_SfxItemSet( aScriptItemSet, false );
1312 16 : }
1313 : }
1314 : else
1315 : {
1316 : // If ther are script dependencies and we are derived from a tag,
1317 : // when we have to export a style dependent class for all
1318 : // scripts
1319 2 : OUString aNewSelector( aSelector );
1320 2 : aNewSelector += "-western" + aPseudo;
1321 : {
1322 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_WESTERN|CSS1_OUTMODE_RULE|CSS1_OUTMODE_TEMPLATE,
1323 2 : true, &aNewSelector );
1324 2 : rHTMLWrt.OutCSS1_SfxItemSet( rItemSet, false );
1325 : }
1326 :
1327 2 : aNewSelector = aSelector + "-cjk" + aPseudo;
1328 : {
1329 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_CJK|CSS1_OUTMODE_RULE|CSS1_OUTMODE_TEMPLATE,
1330 2 : true, &aNewSelector );
1331 2 : rHTMLWrt.OutCSS1_SfxItemSet( rItemSet, false );
1332 : }
1333 :
1334 2 : aNewSelector = aSelector + "-ctl" + aPseudo;
1335 : {
1336 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_CTL|CSS1_OUTMODE_RULE|CSS1_OUTMODE_TEMPLATE,
1337 2 : true, &aNewSelector );
1338 2 : rHTMLWrt.OutCSS1_SfxItemSet( rItemSet, false );
1339 2 : }
1340 18 : }
1341 : }
1342 : else
1343 : {
1344 : // If there are no script dependencies, when all items are
1345 : // exported in one step. For hyperlinks only, a script information
1346 : // must be there, because these two chr formats don't support
1347 : // script dependencies by now.
1348 : SwCSS1OutMode aMode( rHTMLWrt,
1349 : rHTMLWrt.nCSS1Script|CSS1_OUTMODE_RULE|CSS1_OUTMODE_TEMPLATE,
1350 4 : true, &rSelector );
1351 4 : rHTMLWrt.OutCSS1_SfxItemSet( rItemSet, false );
1352 : }
1353 :
1354 22 : return bScriptDependent;
1355 : }
1356 :
1357 0 : static void OutCSS1DropCapRule(
1358 : SwHTMLWriter& rHTMLWrt, const OUString& rSelector,
1359 : const SwFmtDrop& rDrop, bool bHasClass,
1360 : bool bHasScriptDependencies )
1361 : {
1362 0 : const SwCharFmt *pDCCharFmt = rDrop.GetCharFmt();
1363 0 : if( (bHasScriptDependencies && bHasClass) ||
1364 0 : (pDCCharFmt && SwHTMLWriter::HasScriptDependentItems( pDCCharFmt->GetAttrSet(), false ) ) )
1365 : {
1366 0 : OUString aSelector( rSelector );
1367 :
1368 0 : OUString aPseudo;
1369 0 : sal_Int32 nPos = aSelector.lastIndexOf( ':' );
1370 0 : if( nPos >= 0 )
1371 : {
1372 0 : aPseudo = aSelector.copy( nPos );
1373 0 : aSelector = aSelector.copy( 0, nPos );
1374 : }
1375 :
1376 0 : if( !bHasClass )
1377 : {
1378 : // If we are exporting styles for a tag we have to export a tag
1379 : // rule for all properties that aren't style dependent and
1380 : // some class rule for the additional style dependen properties
1381 : {
1382 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_NO_SCRIPT|CSS1_OUTMODE_RULE|CSS1_OUTMODE_DROPCAP,
1383 0 : true, &rSelector );
1384 0 : OutCSS1_SwFmtDropAttrs( rHTMLWrt, rDrop );
1385 : }
1386 :
1387 0 : SfxItemSet aScriptItemSet( rHTMLWrt.pDoc->GetAttrPool(),
1388 : RES_CHRATR_FONT, RES_CHRATR_FONTSIZE,
1389 : RES_CHRATR_LANGUAGE, RES_CHRATR_POSTURE,
1390 : RES_CHRATR_WEIGHT, RES_CHRATR_WEIGHT,
1391 : RES_CHRATR_CJK_FONT, RES_CHRATR_CTL_WEIGHT,
1392 0 : 0 );
1393 0 : if( pDCCharFmt )
1394 0 : aScriptItemSet.Set( pDCCharFmt->GetAttrSet(), true );
1395 :
1396 0 : OUString aNewSelector( aSelector );
1397 0 : aNewSelector += ".western" + aPseudo;
1398 : {
1399 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_WESTERN|CSS1_OUTMODE_RULE|CSS1_OUTMODE_DROPCAP,
1400 0 : true, &aNewSelector );
1401 0 : OutCSS1_SwFmtDropAttrs( rHTMLWrt, rDrop, &aScriptItemSet );
1402 : }
1403 :
1404 0 : aNewSelector = aSelector + ".cjk" + aPseudo;
1405 : {
1406 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_CJK|CSS1_OUTMODE_RULE|CSS1_OUTMODE_DROPCAP,
1407 0 : true, &aNewSelector );
1408 0 : OutCSS1_SwFmtDropAttrs( rHTMLWrt, rDrop, &aScriptItemSet );
1409 : }
1410 :
1411 0 : aNewSelector = aSelector + ".ctl" + aPseudo;
1412 : {
1413 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_CTL|CSS1_OUTMODE_RULE|CSS1_OUTMODE_DROPCAP,
1414 0 : true, &aNewSelector );
1415 0 : OutCSS1_SwFmtDropAttrs( rHTMLWrt, rDrop, &aScriptItemSet );
1416 0 : }
1417 : }
1418 : else
1419 : {
1420 : // If ther are script dependencies and we are derived from a tag,
1421 : // when we have to export a style dependent class for all
1422 : // scripts
1423 0 : OUString aNewSelector( aSelector );
1424 0 : aNewSelector += "-western" + aPseudo;
1425 : {
1426 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_WESTERN|CSS1_OUTMODE_RULE|CSS1_OUTMODE_DROPCAP,
1427 0 : true, &aNewSelector );
1428 0 : OutCSS1_SwFmtDropAttrs( rHTMLWrt, rDrop );
1429 : }
1430 :
1431 0 : aNewSelector = aSelector + "-cjk" + aPseudo;
1432 : {
1433 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_CJK|CSS1_OUTMODE_RULE|CSS1_OUTMODE_DROPCAP,
1434 0 : true, &aNewSelector );
1435 0 : OutCSS1_SwFmtDropAttrs( rHTMLWrt, rDrop );
1436 : }
1437 :
1438 0 : aNewSelector = aSelector + "-ctl" + aPseudo;
1439 : {
1440 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_CTL|CSS1_OUTMODE_RULE|CSS1_OUTMODE_DROPCAP,
1441 0 : true, &aNewSelector );
1442 0 : OutCSS1_SwFmtDropAttrs( rHTMLWrt, rDrop );
1443 0 : }
1444 0 : }
1445 : }
1446 : else
1447 : {
1448 : // If there are no script dependencies, when all items are
1449 : // exported in one step. For hyperlinks only, a script information
1450 : // must be there, because these two chr formats don't support
1451 : // script dependencies by now.
1452 : SwCSS1OutMode aMode( rHTMLWrt,
1453 : rHTMLWrt.nCSS1Script|CSS1_OUTMODE_RULE|CSS1_OUTMODE_DROPCAP,
1454 0 : true, &rSelector );
1455 0 : OutCSS1_SwFmtDropAttrs( rHTMLWrt, rDrop );
1456 : }
1457 0 : }
1458 :
1459 60 : static Writer& OutCSS1_SwFmt( Writer& rWrt, const SwFmt& rFmt,
1460 : IDocumentStylePoolAccess/*SwDoc*/ *pDoc, SwDoc *pTemplate )
1461 : {
1462 60 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
1463 :
1464 60 : bool bCharFmt = false;
1465 60 : switch( rFmt.Which() )
1466 : {
1467 : case RES_CHRFMT:
1468 12 : bCharFmt = true;
1469 12 : break;
1470 :
1471 : case RES_TXTFMTCOLL:
1472 : case RES_CONDTXTFMTCOLL:
1473 : // these template-types can be exported
1474 48 : break;
1475 :
1476 : default:
1477 : // but not these
1478 0 : return rWrt;
1479 : }
1480 :
1481 : // determine Selector and the to-be-exported Attr-Set-depth
1482 60 : OUString aSelector;
1483 60 : sal_uInt16 nRefPoolId = 0;
1484 60 : sal_uInt16 nDeep = GetCSS1Selector( &rFmt, aSelector, nRefPoolId );
1485 60 : if( !nDeep )
1486 24 : return rWrt; // not derived from a HTML-template
1487 :
1488 36 : sal_uInt16 nPoolFmtId = rFmt.GetPoolFmtId();
1489 :
1490 : // Determine the to-be-exported Attr-Set. We have to distinguish 3 cases:
1491 : // - HTML-Tag templates (nDeep==USHRT_MAX):
1492 : // Export Attrs...
1493 : // - that are set in the template, but not in the original of the HTML template
1494 : // - the Default-Attrs for the Attrs, that are set in the Original of the
1495 : // HTML template, but not in the current template.
1496 : // - templates directly derived from HTML templates (nDeep==1):
1497 : // Export only Attributes of the template Item-Set w/o its parents.
1498 : // - templates in-directly derived from HTML templates (nDeep>1):
1499 : // Export Attributes of the template Item-Set incl. its Parents,
1500 : // but w/o Attributes that are set in the HTML-Tag template.
1501 :
1502 : // create Item-Set with all Attributes from the template
1503 : // (all but for nDeep==1)
1504 36 : const SfxItemSet& rFmtItemSet = rFmt.GetAttrSet();
1505 72 : SfxItemSet aItemSet( *rFmtItemSet.GetPool(), rFmtItemSet.GetRanges() );
1506 36 : aItemSet.Set( rFmtItemSet, true ); // Was nDeep!=1 that is not working
1507 : // for script dependent items buts should
1508 : // not make a difference for any other
1509 :
1510 36 : bool bSetDefaults = true, bClearSame = true;
1511 36 : const SwFmt *pRefFmt = 0;
1512 36 : const SwFmt *pRefFmtScript = 0;
1513 36 : switch( nDeep )
1514 : {
1515 : case CSS1_FMT_ISTAG:
1516 34 : pRefFmt = SwHTMLWriter::GetTemplateFmt( nRefPoolId, &pTemplate->getIDocumentStylePoolAccess() );
1517 34 : break;
1518 : case CSS1_FMT_CMPREF:
1519 0 : pRefFmt = SwHTMLWriter::GetTemplateFmt( nRefPoolId, pDoc );
1520 0 : pRefFmtScript = SwHTMLWriter::GetTemplateFmt( nRefPoolId, &pTemplate->getIDocumentStylePoolAccess() );
1521 0 : bClearSame = false;
1522 0 : break;
1523 : default:
1524 2 : pRefFmt = SwHTMLWriter::GetParentFmt( rFmt, nDeep );
1525 2 : pRefFmtScript = SwHTMLWriter::GetTemplateFmt( nRefPoolId, &pTemplate->getIDocumentStylePoolAccess() );
1526 2 : bSetDefaults = false;
1527 2 : break;
1528 : }
1529 :
1530 36 : if( pRefFmt )
1531 : {
1532 : // subtract Item-Set of the Reference template (incl. its Parents)
1533 36 : SwHTMLWriter::SubtractItemSet( aItemSet, pRefFmt->GetAttrSet(),
1534 : bSetDefaults, bClearSame,
1535 : pRefFmtScript
1536 : ? &pRefFmtScript->GetAttrSet()
1537 72 : : 0 );
1538 :
1539 36 : if( !bCharFmt )
1540 : {
1541 24 : const SvxULSpaceItem& rULItem = pRefFmt->GetULSpace();
1542 24 : rHTMLWrt.nDfltTopMargin = rULItem.GetUpper();
1543 24 : rHTMLWrt.nDfltBottomMargin = rULItem.GetLower();
1544 : }
1545 : }
1546 0 : else if( CSS1_FMT_ISTAG==nDeep && !bCharFmt )
1547 : {
1548 : // set Default-distance above and below (for the
1549 : // case that there is no reference template)
1550 0 : rHTMLWrt.nDfltTopMargin = 0;
1551 0 : rHTMLWrt.nDfltBottomMargin = HTML_PARSPACE;
1552 0 : if( USER_FMT & nPoolFmtId )
1553 : {
1554 : // user templates
1555 0 : const OUString aNm(rFmt.GetName());
1556 :
1557 0 : if (aNm == "DD 1" || aNm == "DT 1")
1558 0 : rHTMLWrt.nDfltBottomMargin = 0;
1559 0 : else if (aNm == OOO_STRING_SVTOOLS_HTML_listing)
1560 0 : rHTMLWrt.nDfltBottomMargin = 0;
1561 0 : else if (aNm == OOO_STRING_SVTOOLS_HTML_preformtxt)
1562 0 : rHTMLWrt.nDfltBottomMargin = 0;
1563 0 : else if (aNm == OOO_STRING_SVTOOLS_HTML_xmp)
1564 0 : rHTMLWrt.nDfltBottomMargin = 0;
1565 : }
1566 : else
1567 : {
1568 : // Pool templates
1569 0 : switch( nPoolFmtId )
1570 : {
1571 : case RES_POOLCOLL_HEADLINE1:
1572 : case RES_POOLCOLL_HEADLINE2:
1573 : case RES_POOLCOLL_HEADLINE3:
1574 : case RES_POOLCOLL_HEADLINE4:
1575 : case RES_POOLCOLL_HEADLINE5:
1576 : case RES_POOLCOLL_HEADLINE6:
1577 0 : rHTMLWrt.nDfltTopMargin = HTML_HEADSPACE;
1578 0 : break;
1579 : case RES_POOLCOLL_SENDADRESS:
1580 : case RES_POOLCOLL_HTML_DT:
1581 : case RES_POOLCOLL_HTML_DD:
1582 : case RES_POOLCOLL_HTML_PRE:
1583 0 : rHTMLWrt.nDfltBottomMargin = 0;
1584 0 : break;
1585 : }
1586 : }
1587 : }
1588 :
1589 : // if nothing is to be exported ...
1590 36 : if( !aItemSet.Count() )
1591 14 : return rWrt;
1592 :
1593 : // There is no support for script dependent hyperlinks by now.
1594 22 : bool bCheckForPseudo = false;
1595 26 : if( bCharFmt &&
1596 4 : (RES_POOLCHR_INET_NORMAL==nRefPoolId ||
1597 0 : RES_POOLCHR_INET_VISIT==nRefPoolId) )
1598 4 : bCheckForPseudo = true;
1599 :
1600 : // export now the Attributes (incl. Selektor)
1601 22 : bool bHasScriptDependencies = false;
1602 22 : if( OutCSS1Rule( rHTMLWrt, aSelector, aItemSet, CSS1_FMT_ISTAG != nDeep,
1603 22 : bCheckForPseudo ) )
1604 : {
1605 18 : if( bCharFmt )
1606 4 : rHTMLWrt.aScriptTextStyles.insert( rFmt.GetName() );
1607 : else
1608 : {
1609 14 : if( nPoolFmtId==RES_POOLCOLL_TEXT )
1610 12 : rHTMLWrt.aScriptParaStyles.insert( pDoc->GetTxtCollFromPool( RES_POOLCOLL_STANDARD, false )->GetName() );
1611 14 : rHTMLWrt.aScriptParaStyles.insert( rFmt.GetName() );
1612 : }
1613 18 : bHasScriptDependencies = true;
1614 : }
1615 :
1616 22 : if( nPoolFmtId==RES_POOLCOLL_TEXT && !rHTMLWrt.bFirstCSS1Property )
1617 14 : rHTMLWrt.bPoolCollTextModified = true;
1618 :
1619 : // export Drop-Caps
1620 : const SfxPoolItem *pItem;
1621 22 : if( SfxItemState::SET==aItemSet.GetItemState( RES_PARATR_DROP, false, &pItem ))
1622 : {
1623 0 : OUString sOut( aSelector );
1624 0 : sOut += ":" + OStringToOUString( sCSS1_first_letter, RTL_TEXTENCODING_ASCII_US );
1625 0 : const SwFmtDrop *pDrop = (const SwFmtDrop *)pItem;
1626 0 : OutCSS1DropCapRule( rHTMLWrt, sOut, *pDrop, CSS1_FMT_ISTAG != nDeep, bHasScriptDependencies );
1627 : }
1628 :
1629 82 : return rWrt;
1630 : }
1631 :
1632 22 : static Writer& OutCSS1_SwPageDesc( Writer& rWrt, const SwPageDesc& rPageDesc,
1633 : IDocumentStylePoolAccess/*SwDoc*/ *pDoc, SwDoc *pTemplate,
1634 : sal_uInt16 nRefPoolId, bool bExtRef,
1635 : bool bPseudo )
1636 : {
1637 22 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
1638 :
1639 22 : const SwPageDesc* pRefPageDesc = 0;
1640 22 : if( !bExtRef )
1641 0 : pRefPageDesc = pDoc->GetPageDescFromPool( nRefPoolId, false );
1642 22 : else if( pTemplate )
1643 22 : pRefPageDesc = pTemplate->getIDocumentStylePoolAccess().GetPageDescFromPool( nRefPoolId, false );
1644 :
1645 22 : OUString aSelector = "@" + OStringToOUString( sCSS1_page, RTL_TEXTENCODING_ASCII_US );
1646 :
1647 22 : if( bPseudo )
1648 : {
1649 0 : const sal_Char *pPseudo = 0;
1650 0 : switch( rPageDesc.GetPoolFmtId() )
1651 : {
1652 0 : case RES_POOLPAGE_FIRST: pPseudo = sCSS1_first; break;
1653 0 : case RES_POOLPAGE_LEFT: pPseudo = sCSS1_left; break;
1654 0 : case RES_POOLPAGE_RIGHT: pPseudo = sCSS1_right; break;
1655 : }
1656 0 : if( pPseudo )
1657 0 : aSelector += ":" + OStringToOUString( pPseudo, RTL_TEXTENCODING_ASCII_US );
1658 : }
1659 :
1660 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_RULE_ON|CSS1_OUTMODE_TEMPLATE,
1661 22 : true, &aSelector );
1662 :
1663 : // Size: If the only difference is the Landscape-Flag,
1664 : // only export Portrait oder Landscape. Otherwise export size.
1665 22 : bool bRefLandscape = pRefPageDesc ? pRefPageDesc->GetLandscape() : sal_False;
1666 22 : Size aRefSz;
1667 22 : const Size& rSz = rPageDesc.GetMaster().GetFrmSize().GetSize();
1668 22 : if( pRefPageDesc )
1669 : {
1670 22 : aRefSz = pRefPageDesc->GetMaster().GetFrmSize().GetSize();
1671 22 : if( bRefLandscape != rPageDesc.GetLandscape() )
1672 : {
1673 2 : long nTmp = aRefSz.Height();
1674 2 : aRefSz.Height() = aRefSz.Width();
1675 2 : aRefSz.Width() = nTmp;
1676 : }
1677 : }
1678 :
1679 : // TODO: Bad Hack: On the Page-Tabpage there are small rounding errors
1680 : // for the page size. Partially because of bug 25535, we stupidly still
1681 : // use the Size-Item from Dialog, even if nothing changed.
1682 : // Thus: once one visited the Page-Dialog and left it with OK, we get a
1683 : // new page size that then gets exported here. To avoid that, we allow
1684 : // here small deviations.
1685 36 : if( std::abs( rSz.Width() - aRefSz.Width() ) <= 2 &&
1686 14 : std::abs( rSz.Height() - aRefSz.Height() ) <= 2 )
1687 : {
1688 12 : if( bRefLandscape != rPageDesc.GetLandscape() )
1689 : {
1690 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_size,
1691 0 : rPageDesc.GetLandscape() ? sCSS1_PV_landscape
1692 0 : : sCSS1_PV_portrait );
1693 : }
1694 : }
1695 : else
1696 : {
1697 10 : OStringBuffer sVal;
1698 10 : AddUnitPropertyValue(sVal, rSz.Width(), rHTMLWrt.GetCSS1Unit());
1699 10 : sVal.append(' ');
1700 10 : AddUnitPropertyValue(sVal, rSz.Height(), rHTMLWrt.GetCSS1Unit());
1701 10 : rHTMLWrt.OutCSS1_PropertyAscii(sCSS1_P_size, sVal.makeStringAndClear());
1702 : }
1703 :
1704 : // Export the distance-Attributes as normally
1705 22 : const SwFrmFmt &rMaster = rPageDesc.GetMaster();
1706 22 : SfxItemSet aItemSet( *rMaster.GetAttrSet().GetPool(),
1707 44 : RES_LR_SPACE, RES_UL_SPACE );
1708 22 : aItemSet.Set( rMaster.GetAttrSet(), true );
1709 :
1710 22 : if( pRefPageDesc )
1711 : {
1712 : SwHTMLWriter::SubtractItemSet( aItemSet,
1713 22 : pRefPageDesc->GetMaster().GetAttrSet(),
1714 22 : true );
1715 : }
1716 :
1717 22 : OutCSS1_SvxULSpace_SvxLRSpace( rWrt, aItemSet, false );
1718 :
1719 : // If for a Pseudo-Selector no Property had been set, we still
1720 : // have to export something, so that the corresponding template is
1721 : // created on the next import.
1722 22 : if( rHTMLWrt.bFirstCSS1Property && bPseudo )
1723 : {
1724 0 : rHTMLWrt.OutNewLine();
1725 0 : OString sTmp(OUStringToOString(aSelector, rHTMLWrt.eDestEnc));
1726 0 : rWrt.Strm().WriteCharPtr( sTmp.getStr() ).WriteCharPtr( " {" );
1727 0 : rHTMLWrt.bFirstCSS1Property = false;
1728 : }
1729 :
1730 22 : if( !rHTMLWrt.bFirstCSS1Property )
1731 20 : rWrt.Strm().WriteCharPtr( sCSS1_rule_end );
1732 :
1733 44 : return rWrt;
1734 : }
1735 :
1736 44 : static Writer& OutCSS1_SwFtnInfo( Writer& rWrt, const SwEndNoteInfo& rInfo,
1737 : SwDoc *pDoc, sal_uInt16 nNotes, bool bEndNote )
1738 : {
1739 44 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
1740 :
1741 44 : OUString aSelector;
1742 :
1743 44 : if( nNotes > 0 )
1744 : {
1745 0 : aSelector = (OUString)OOO_STRING_SVTOOLS_HTML_anchor + "." +
1746 : OStringToOUString( bEndNote ? OOO_STRING_SVTOOLS_HTML_sdendnote_anc
1747 0 : : OOO_STRING_SVTOOLS_HTML_sdfootnote_anc, RTL_TEXTENCODING_ASCII_US );
1748 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_RULE|CSS1_OUTMODE_TEMPLATE,
1749 0 : true, &aSelector );
1750 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_font_size,
1751 0 : sHTML_FTN_fontheight );
1752 0 : rHTMLWrt.Strm().WriteCharPtr( sCSS1_rule_end );
1753 : }
1754 :
1755 44 : const SwCharFmt *pSymCharFmt = rInfo.GetCharFmt( *pDoc );
1756 44 : if( pSymCharFmt )
1757 : {
1758 44 : const SfxItemSet& rFmtItemSet = pSymCharFmt->GetAttrSet();
1759 44 : SfxItemSet aItemSet( *rFmtItemSet.GetPool(), rFmtItemSet.GetRanges() );
1760 44 : aItemSet.Set( rFmtItemSet, true );
1761 :
1762 : // If there are footnotes or endnotes, then all Attributes have to be
1763 : // exported, so that Netscape displays the document correctly.
1764 : // Otherwise it is sufficient, to export the differences to the
1765 : // footnote and endnote template.
1766 44 : if( nNotes == 0 && rHTMLWrt.pTemplate )
1767 : {
1768 44 : SwFmt *pRefFmt = rHTMLWrt.pTemplate->getIDocumentStylePoolAccess().GetCharFmtFromPool(
1769 44 : static_cast< sal_uInt16 >(bEndNote ? RES_POOLCHR_ENDNOTE : RES_POOLCHR_FOOTNOTE) );
1770 44 : if( pRefFmt )
1771 44 : SwHTMLWriter::SubtractItemSet( aItemSet, pRefFmt->GetAttrSet(),
1772 44 : true );
1773 : }
1774 44 : if( aItemSet.Count() )
1775 : {
1776 0 : aSelector = (OUString)OOO_STRING_SVTOOLS_HTML_anchor + "." +
1777 : OStringToOUString( bEndNote ? OOO_STRING_SVTOOLS_HTML_sdendnote_sym
1778 0 : : OOO_STRING_SVTOOLS_HTML_sdfootnote_sym, RTL_TEXTENCODING_ASCII_US );
1779 0 : if( OutCSS1Rule( rHTMLWrt, aSelector, aItemSet, true, false ))
1780 0 : rHTMLWrt.aScriptTextStyles.insert( pSymCharFmt->GetName() );
1781 44 : }
1782 : }
1783 :
1784 44 : return rWrt;
1785 : }
1786 :
1787 22 : Writer& OutCSS1_BodyTagStyleOpt( Writer& rWrt, const SfxItemSet& rItemSet )
1788 : {
1789 22 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
1790 :
1791 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_STYLE_OPT_ON |
1792 22 : CSS1_OUTMODE_ENCODE|CSS1_OUTMODE_BODY );
1793 :
1794 : // Only export the attributes of the page template.
1795 : // The attributes of the default paragraph template were
1796 : // considered already when exporting the paragraph template.
1797 :
1798 : const SfxPoolItem *pItem;
1799 22 : if( SfxItemState::SET == rItemSet.GetItemState( RES_BACKGROUND, false,
1800 22 : &pItem ) )
1801 : {
1802 0 : OutCSS1_SvxBrush( rWrt, *pItem, CSS1_BACKGROUND_PAGE );
1803 : }
1804 :
1805 22 : if( SfxItemState::SET == rItemSet.GetItemState( RES_BOX, false,
1806 22 : &pItem ))
1807 : {
1808 0 : OutCSS1_SvxBox( rWrt, *pItem );
1809 : }
1810 :
1811 22 : if( !rHTMLWrt.bFirstCSS1Property )
1812 : {
1813 : // if a Property was exported as part of a Style-Option,
1814 : // the Option still needs to be finished
1815 0 : rWrt.Strm().WriteChar( '\"' );
1816 : }
1817 :
1818 22 : return rWrt;
1819 : }
1820 :
1821 570 : Writer& OutCSS1_ParaTagStyleOpt( Writer& rWrt, const SfxItemSet& rItemSet )
1822 : {
1823 570 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
1824 :
1825 : SwCSS1OutMode aMode( rHTMLWrt, rHTMLWrt.nCSS1Script|CSS1_OUTMODE_STYLE_OPT |
1826 570 : CSS1_OUTMODE_ENCODE|CSS1_OUTMODE_PARA );
1827 570 : rHTMLWrt.OutCSS1_SfxItemSet( rItemSet, false );
1828 :
1829 570 : return rWrt;
1830 : }
1831 :
1832 24 : Writer& OutCSS1_HintSpanTag( Writer& rWrt, const SfxPoolItem& rHt )
1833 : {
1834 24 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
1835 :
1836 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_SPAN_TAG |
1837 24 : CSS1_OUTMODE_ENCODE|CSS1_OUTMODE_HINT );
1838 :
1839 24 : Out( aCSS1AttrFnTab, rHt, rWrt );
1840 :
1841 24 : if( !rHTMLWrt.bFirstCSS1Property && rHTMLWrt.bTagOn )
1842 12 : rWrt.Strm().WriteCharPtr( sCSS1_span_tag_end );
1843 :
1844 24 : return rWrt;
1845 : }
1846 :
1847 10 : Writer& OutCSS1_HintStyleOpt( Writer& rWrt, const SfxPoolItem& rHt )
1848 : {
1849 10 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
1850 :
1851 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_STYLE_OPT_ON |
1852 : CSS1_OUTMODE_ENCODE|
1853 10 : CSS1_OUTMODE_HINT );
1854 :
1855 10 : Out( aCSS1AttrFnTab, rHt, rWrt );
1856 :
1857 10 : if( !rHTMLWrt.bFirstCSS1Property )
1858 10 : rWrt.Strm().WriteChar( '\"' );
1859 :
1860 10 : return rWrt;
1861 : }
1862 :
1863 : // Wrapper for Table background
1864 520 : Writer& OutCSS1_TableBGStyleOpt( Writer& rWrt, const SfxPoolItem& rHt )
1865 : {
1866 520 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
1867 :
1868 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_STYLE_OPT_ON |
1869 : CSS1_OUTMODE_ENCODE|
1870 520 : CSS1_OUTMODE_TABLEBOX );
1871 520 : OutCSS1_SvxBrush( rWrt, rHt, CSS1_BACKGROUND_TABLE );
1872 :
1873 520 : if( !rHTMLWrt.bFirstCSS1Property )
1874 0 : rWrt.Strm().WriteChar( '\"' );
1875 :
1876 520 : return rWrt;
1877 : }
1878 :
1879 0 : Writer& OutCSS1_NumBulListStyleOpt( Writer& rWrt, const SwNumRule& rNumRule,
1880 : sal_uInt8 nLevel )
1881 : {
1882 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
1883 :
1884 : SwCSS1OutMode aMode( rHTMLWrt, CSS1_OUTMODE_STYLE_OPT |
1885 0 : CSS1_OUTMODE_ENCODE|CSS1_OUTMODE_PARA );
1886 :
1887 0 : const SwNumFmt& rNumFmt = rNumRule.Get( nLevel );
1888 :
1889 0 : long nLSpace = rNumFmt.GetAbsLSpace();
1890 0 : long nFirstLineOffset = rNumFmt.GetFirstLineOffset();
1891 0 : long nDfltFirstLineOffset = HTML_NUMBUL_INDENT;
1892 0 : if( nLevel > 0 )
1893 : {
1894 0 : const SwNumFmt& rPrevNumFmt = rNumRule.Get( nLevel-1 );
1895 0 : nLSpace -= rPrevNumFmt.GetAbsLSpace();
1896 0 : nDfltFirstLineOffset = rPrevNumFmt.GetFirstLineOffset();
1897 : }
1898 :
1899 0 : if( rHTMLWrt.IsHTMLMode(HTMLMODE_LSPACE_IN_NUMBUL) &&
1900 : nLSpace != HTML_NUMBUL_MARGINLEFT )
1901 0 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_margin_left, nLSpace );
1902 :
1903 0 : if( rHTMLWrt.IsHTMLMode(HTMLMODE_FRSTLINE_IN_NUMBUL) &&
1904 : nFirstLineOffset != nDfltFirstLineOffset )
1905 0 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_text_indent, nFirstLineOffset );
1906 :
1907 0 : if( !rHTMLWrt.bFirstCSS1Property )
1908 0 : rWrt.Strm().WriteChar( '\"' );
1909 :
1910 0 : return rWrt;
1911 : }
1912 :
1913 14 : void SwHTMLWriter::OutCSS1_FrmFmtOptions( const SwFrmFmt& rFrmFmt,
1914 : sal_uInt32 nFrmOpts,
1915 : const SdrObject *pSdrObj,
1916 : const SfxItemSet *pItemSet )
1917 : {
1918 : SwCSS1OutMode aMode( *this, CSS1_OUTMODE_STYLE_OPT_ON |
1919 : CSS1_OUTMODE_ENCODE|
1920 14 : CSS1_OUTMODE_FRAME );
1921 :
1922 14 : const SwFmtHoriOrient& rHoriOri = rFrmFmt.GetHoriOrient();
1923 28 : SvxLRSpaceItem aLRItem( rFrmFmt.GetLRSpace() );
1924 28 : SvxULSpaceItem aULItem( rFrmFmt.GetULSpace() );
1925 14 : if( nFrmOpts & HTML_FRMOPT_S_ALIGN )
1926 : {
1927 14 : const SwFmtAnchor& rAnchor = rFrmFmt.GetAnchor();
1928 14 : switch( rAnchor.GetAnchorId() )
1929 : {
1930 : case FLY_AT_PARA:
1931 : case FLY_AT_CHAR:
1932 4 : if( text::RelOrientation::FRAME == rHoriOri.GetRelationOrient() ||
1933 0 : text::RelOrientation::PRINT_AREA == rHoriOri.GetRelationOrient() )
1934 : {
1935 4 : if( !(nFrmOpts & HTML_FRMOPT_ALIGN) )
1936 : {
1937 : // float
1938 0 : const sal_Char *pStr = text::HoriOrientation::RIGHT==rHoriOri.GetHoriOrient()
1939 : ? sCSS1_PV_right
1940 0 : : sCSS1_PV_left;
1941 0 : OutCSS1_PropertyAscii( sCSS1_P_float, pStr );
1942 : }
1943 4 : break;
1944 : }
1945 :
1946 : case FLY_AT_PAGE:
1947 : case FLY_AT_FLY:
1948 : {
1949 : // position
1950 0 : OutCSS1_PropertyAscii( sCSS1_P_position, sCSS1_PV_absolute );
1951 :
1952 : // For top/left we need to subtract the distance to the frame
1953 : // from the position, as in CSS1 it is added to the position.
1954 : // This works also for automatically aligned frames, even that
1955 : // in this case Writer also adds the distance; because in this
1956 : // case the Orient-Attribute contains the correct position.
1957 :
1958 : // top
1959 0 : long nXPos=0, nYPos=0;
1960 0 : bool bOutXPos = false, bOutYPos = false;
1961 0 : if( RES_DRAWFRMFMT == rFrmFmt.Which() )
1962 : {
1963 : OSL_ENSURE( pSdrObj, "Do not pass a SdrObject. Inefficient" );
1964 0 : if( !pSdrObj )
1965 0 : pSdrObj = rFrmFmt.FindSdrObject();
1966 : OSL_ENSURE( pSdrObj, "Where is the SdrObject" );
1967 0 : if( pSdrObj )
1968 : {
1969 0 : Point aPos( pSdrObj->GetRelativePos() );
1970 0 : nXPos = aPos.A();
1971 0 : nYPos = aPos.B();
1972 : }
1973 0 : bOutXPos = bOutYPos = true;
1974 : }
1975 : else
1976 : {
1977 0 : bOutXPos = text::RelOrientation::CHAR != rHoriOri.GetRelationOrient();
1978 0 : nXPos = text::HoriOrientation::NONE == rHoriOri.GetHoriOrient()
1979 0 : ? rHoriOri.GetPos() : 0;
1980 :
1981 0 : const SwFmtVertOrient& rVertOri = rFrmFmt.GetVertOrient();
1982 0 : bOutYPos = text::RelOrientation::CHAR != rVertOri.GetRelationOrient();
1983 0 : nYPos = text::VertOrientation::NONE == rVertOri.GetVertOrient()
1984 0 : ? rVertOri.GetPos() : 0;
1985 : }
1986 :
1987 0 : if( bOutYPos )
1988 : {
1989 0 : if( IsHTMLMode( HTMLMODE_FLY_MARGINS) )
1990 : {
1991 0 : nYPos -= aULItem.GetUpper();
1992 0 : if( nYPos < 0 )
1993 : {
1994 0 : aULItem.SetUpper( (sal_uInt16)(aULItem.GetUpper() + nYPos) );
1995 0 : nYPos = 0;
1996 : }
1997 : }
1998 :
1999 0 : OutCSS1_UnitProperty( sCSS1_P_top, nYPos );
2000 : }
2001 :
2002 0 : if( bOutXPos )
2003 : {
2004 : // left
2005 0 : if( IsHTMLMode( HTMLMODE_FLY_MARGINS) )
2006 : {
2007 0 : nXPos -= aLRItem.GetLeft();
2008 0 : if( nXPos < 0 )
2009 : {
2010 0 : aLRItem.SetLeft( (sal_uInt16)(aLRItem.GetLeft() + nXPos) );
2011 0 : nXPos = 0;
2012 : }
2013 : }
2014 :
2015 0 : OutCSS1_UnitProperty( sCSS1_P_left, nXPos );
2016 : }
2017 : }
2018 0 : break;
2019 :
2020 : default:
2021 : ;
2022 : }
2023 : }
2024 :
2025 : // width/height
2026 14 : if( nFrmOpts & HTML_FRMOPT_S_SIZE )
2027 : {
2028 8 : if( RES_DRAWFRMFMT == rFrmFmt.Which() )
2029 : {
2030 : OSL_ENSURE( pSdrObj, "Do not pass a SdrObject. Inefficient" );
2031 8 : if( !pSdrObj )
2032 0 : pSdrObj = rFrmFmt.FindSdrObject();
2033 : OSL_ENSURE( pSdrObj, "Where is the SdrObject" );
2034 8 : if( pSdrObj )
2035 : {
2036 8 : Size aTwipSz( pSdrObj->GetLogicRect().GetSize() );
2037 8 : if( nFrmOpts & HTML_FRMOPT_S_WIDTH )
2038 : {
2039 8 : if( nFrmOpts & HTML_FRMOPT_S_PIXSIZE )
2040 0 : OutCSS1_PixelProperty( sCSS1_P_width, aTwipSz.Width(),
2041 0 : false );
2042 : else
2043 8 : OutCSS1_UnitProperty( sCSS1_P_width, aTwipSz.Width() );
2044 : }
2045 8 : if( nFrmOpts & HTML_FRMOPT_S_HEIGHT )
2046 : {
2047 8 : if( nFrmOpts & HTML_FRMOPT_S_PIXSIZE )
2048 0 : OutCSS1_PixelProperty( sCSS1_P_height, aTwipSz.Height(),
2049 0 : true );
2050 : else
2051 8 : OutCSS1_UnitProperty( sCSS1_P_height, aTwipSz.Height() );
2052 : }
2053 : }
2054 : }
2055 : else
2056 : {
2057 : OSL_ENSURE( HTML_FRMOPT_ABSSIZE & nFrmOpts,
2058 : "Export absolute size" );
2059 : OSL_ENSURE( HTML_FRMOPT_ANYSIZE & nFrmOpts,
2060 : "Export every size" );
2061 0 : sal_uInt16 nMode = 0;
2062 0 : if( nFrmOpts & HTML_FRMOPT_S_WIDTH )
2063 0 : nMode |= CSS1_FRMSIZE_WIDTH;
2064 0 : if( nFrmOpts & HTML_FRMOPT_S_HEIGHT )
2065 0 : nMode |= (CSS1_FRMSIZE_MINHEIGHT|CSS1_FRMSIZE_FIXHEIGHT);
2066 0 : if( nFrmOpts & HTML_FRMOPT_S_PIXSIZE )
2067 0 : nMode |= CSS1_FRMSIZE_PIXEL;
2068 :
2069 0 : OutCSS1_SwFmtFrmSize( *this, rFrmFmt.GetFrmSize(), nMode );
2070 : }
2071 : }
2072 :
2073 14 : const SfxItemSet& rItemSet = rFrmFmt.GetAttrSet();
2074 : // margin-*
2075 28 : if( (nFrmOpts & HTML_FRMOPT_S_SPACE) &&
2076 14 : IsHTMLMode( HTMLMODE_FLY_MARGINS) )
2077 : {
2078 0 : const SvxLRSpaceItem *pLRItem = 0;
2079 0 : const SvxULSpaceItem *pULItem = 0;
2080 0 : if( SfxItemState::SET == rItemSet.GetItemState( RES_LR_SPACE, true ) )
2081 0 : pLRItem = &aLRItem;
2082 0 : if( SfxItemState::SET == rItemSet.GetItemState( RES_UL_SPACE, true ) )
2083 0 : pULItem = &aULItem;
2084 0 : if( pLRItem || pULItem )
2085 0 : OutCSS1_SvxULSpace_SvxLRSpace( *this, pULItem, pLRItem );
2086 : }
2087 :
2088 : // border
2089 14 : if( nFrmOpts & HTML_FRMOPT_S_BORDER )
2090 : {
2091 : const SfxPoolItem* pItem;
2092 0 : if( nFrmOpts & HTML_FRMOPT_S_NOBORDER )
2093 0 : OutCSS1_SvxBox( *this, rFrmFmt.GetBox() );
2094 0 : else if( SfxItemState::SET==rItemSet.GetItemState( RES_BOX, true, &pItem ) )
2095 0 : OutCSS1_SvxBox( *this, *pItem );
2096 : }
2097 :
2098 : // background (if, then the color must be set also)
2099 14 : if( nFrmOpts & HTML_FRMOPT_S_BACKGROUND )
2100 0 : OutCSS1_FrmFmtBackground( rFrmFmt );
2101 :
2102 14 : if( pItemSet )
2103 8 : OutCSS1_SfxItemSet( *pItemSet, false );
2104 :
2105 14 : if( !bFirstCSS1Property )
2106 22 : Strm().WriteChar( '\"' );
2107 14 : }
2108 :
2109 2 : void SwHTMLWriter::OutCSS1_TableFrmFmtOptions( const SwFrmFmt& rFrmFmt )
2110 : {
2111 : SwCSS1OutMode aMode( *this, CSS1_OUTMODE_STYLE_OPT_ON |
2112 : CSS1_OUTMODE_ENCODE|
2113 2 : CSS1_OUTMODE_TABLE );
2114 :
2115 : const SfxPoolItem *pItem;
2116 2 : const SfxItemSet& rItemSet = rFrmFmt.GetAttrSet();
2117 2 : if( SfxItemState::SET==rItemSet.GetItemState( RES_BACKGROUND, false, &pItem ) )
2118 2 : OutCSS1_SvxBrush( *this, *pItem, CSS1_BACKGROUND_TABLE );
2119 :
2120 2 : if( IsHTMLMode( HTMLMODE_PRINT_EXT ) )
2121 2 : OutCSS1_SvxFmtBreak_SwFmtPDesc_SvxFmtKeep( *this, rItemSet, false );
2122 :
2123 2 : if( SfxItemState::SET==rItemSet.GetItemState( RES_LAYOUT_SPLIT, false, &pItem ) )
2124 0 : OutCSS1_SwFmtLayoutSplit( *this, *pItem );
2125 :
2126 2 : if( !bFirstCSS1Property )
2127 2 : Strm().WriteChar( '\"' );
2128 2 : }
2129 :
2130 520 : void SwHTMLWriter::OutCSS1_TableCellBorderHack(SwFrmFmt const& rFrmFmt)
2131 : {
2132 : SwCSS1OutMode const aMode( *this,
2133 520 : CSS1_OUTMODE_STYLE_OPT_ON|CSS1_OUTMODE_ENCODE|CSS1_OUTMODE_TABLEBOX );
2134 520 : OutCSS1_SvxBox(*this, rFrmFmt.GetBox());
2135 520 : if (!bFirstCSS1Property)
2136 : {
2137 520 : this->Strm().WriteChar( cCSS1_style_opt_end );
2138 520 : }
2139 520 : }
2140 :
2141 0 : void SwHTMLWriter::OutCSS1_SectionFmtOptions( const SwFrmFmt& rFrmFmt, const SwFmtCol *pCol )
2142 : {
2143 : SwCSS1OutMode aMode( *this, CSS1_OUTMODE_STYLE_OPT_ON |
2144 : CSS1_OUTMODE_ENCODE|
2145 0 : CSS1_OUTMODE_SECTION );
2146 :
2147 : const SfxPoolItem *pItem;
2148 0 : const SfxItemSet& rItemSet = rFrmFmt.GetAttrSet();
2149 0 : if( SfxItemState::SET==rItemSet.GetItemState( RES_BACKGROUND, false, &pItem ) )
2150 0 : OutCSS1_SvxBrush( *this, *pItem, CSS1_BACKGROUND_SECTION );
2151 :
2152 0 : if (pCol)
2153 : {
2154 0 : OString sColumnCount(OString::number(static_cast<sal_Int32>(pCol->GetNumCols())));
2155 0 : OutCSS1_PropertyAscii(sCSS1_P_column_count, sColumnCount);
2156 : }
2157 :
2158 0 : if( !bFirstCSS1Property )
2159 0 : Strm().WriteChar( '\"' );
2160 0 : }
2161 :
2162 0 : static bool OutCSS1_FrmFmtBrush( SwHTMLWriter& rWrt,
2163 : const SvxBrushItem& rBrushItem )
2164 : {
2165 0 : bool bWritten = false;
2166 : /// output brush of frame format, if its background color is not "no fill"/"auto fill"
2167 : /// or it has a background graphic.
2168 0 : if( rBrushItem.GetColor() != COL_TRANSPARENT ||
2169 0 : 0 != rBrushItem.GetGraphicLink() ||
2170 0 : 0 != rBrushItem.GetGraphicPos() )
2171 : {
2172 0 : OutCSS1_SvxBrush( rWrt, rBrushItem, CSS1_BACKGROUND_FLY );
2173 0 : bWritten = true;
2174 : }
2175 0 : return bWritten;
2176 : }
2177 :
2178 0 : void SwHTMLWriter::OutCSS1_FrmFmtBackground( const SwFrmFmt& rFrmFmt )
2179 : {
2180 : // If the frame itself has a background, then export.
2181 0 : if( OutCSS1_FrmFmtBrush( *this, rFrmFmt.makeBackgroundBrushItem() ) )
2182 0 : return;
2183 :
2184 : // If the frame is not linked to a page, we use the background of the anchor.
2185 0 : const SwFmtAnchor& rAnchor = rFrmFmt.GetAnchor();
2186 0 : RndStdIds eAnchorId = rAnchor.GetAnchorId();
2187 0 : const SwPosition *pAnchorPos = rAnchor.GetCntntAnchor();
2188 0 : if (FLY_AT_PAGE != eAnchorId && pAnchorPos)
2189 : {
2190 0 : const SwNode& rNode = pAnchorPos->nNode.GetNode();
2191 0 : if( rNode.IsCntntNode() )
2192 : {
2193 : // If the frame is linked to a content-node,
2194 : // we take the background of the content-node, if it has one.
2195 0 : if( OutCSS1_FrmFmtBrush( *this,
2196 0 : rNode.GetCntntNode()->GetSwAttrSet().GetBackground()) )
2197 0 : return;
2198 :
2199 : // Otherwise we also could be in a table
2200 0 : const SwTableNode *pTableNd = rNode.FindTableNode();
2201 0 : if( pTableNd )
2202 : {
2203 0 : const SwStartNode *pBoxSttNd = rNode.FindTableBoxStartNode();
2204 : const SwTableBox *pBox =
2205 0 : pTableNd->GetTable().GetTblBox( pBoxSttNd->GetIndex() );
2206 :
2207 : // If the box has a background, we take it.
2208 0 : if( OutCSS1_FrmFmtBrush( *this,
2209 0 : pBox->GetFrmFmt()->makeBackgroundBrushItem() ) )
2210 0 : return;
2211 :
2212 : // Otherwise we use that of the lines
2213 0 : const SwTableLine *pLine = pBox->GetUpper();
2214 0 : while( pLine )
2215 : {
2216 0 : if( OutCSS1_FrmFmtBrush( *this,
2217 0 : pLine->GetFrmFmt()->makeBackgroundBrushItem() ) )
2218 0 : return;
2219 0 : pBox = pLine->GetUpper();
2220 0 : pLine = pBox ? pBox->GetUpper() : 0;
2221 : }
2222 :
2223 : // If there was none either, we use the background of the table.
2224 0 : if( OutCSS1_FrmFmtBrush( *this,
2225 0 : pTableNd->GetTable().GetFrmFmt()->makeBackgroundBrushItem() ) )
2226 0 : return;
2227 : }
2228 :
2229 : }
2230 :
2231 : // If the anchor is again in a Fly-Frame, use the background of the Fly-Frame.
2232 0 : const SwFrmFmt *pFrmFmt = rNode.GetFlyFmt();
2233 0 : if( pFrmFmt )
2234 : {
2235 0 : OutCSS1_FrmFmtBackground( *pFrmFmt );
2236 0 : return;
2237 : }
2238 : }
2239 :
2240 : // At last there is the background of the page, and as the final rescue
2241 : // the value of the Config.
2242 : OSL_ENSURE( pCurrPageDesc, "no page template found" );
2243 0 : if( !OutCSS1_FrmFmtBrush( *this,
2244 0 : pCurrPageDesc->GetMaster().makeBackgroundBrushItem() ) )
2245 : {
2246 0 : Color aColor( COL_WHITE );
2247 :
2248 : // The background color is normally only used in Browse-Mode.
2249 : // We always use it for a HTML document, but for a text document
2250 : // only if viewed in Browse-Mode.
2251 0 : if( pDoc->getIDocumentSettingAccess().get(IDocumentSettingAccess::HTML_MODE) ||
2252 0 : pDoc->getIDocumentSettingAccess().get(IDocumentSettingAccess::BROWSE_MODE))
2253 : {
2254 0 : SwViewShell *pVSh = pDoc->getIDocumentLayoutAccess().GetCurrentViewShell();
2255 0 : if ( pVSh &&
2256 0 : COL_TRANSPARENT != pVSh->GetViewOptions()->GetRetoucheColor().GetColor())
2257 0 : aColor = pVSh->GetViewOptions()->GetRetoucheColor().GetColor();
2258 : }
2259 :
2260 0 : OutCSS1_PropertyAscii(sCSS1_P_background, lclGetCSS1Color(aColor));
2261 : }
2262 : }
2263 :
2264 16 : static Writer& OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink( Writer& rWrt,
2265 : const SvxUnderlineItem *pUItem,
2266 : const SvxOverlineItem *pOItem,
2267 : const SvxCrossedOutItem *pCOItem,
2268 : const SvxBlinkItem *pBItem )
2269 : {
2270 16 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2271 16 : bool bNone = false;
2272 :
2273 16 : const sal_Char *pUStr = 0;
2274 16 : if( pUItem )
2275 : {
2276 16 : switch( pUItem->GetLineStyle() )
2277 : {
2278 : case UNDERLINE_NONE:
2279 2 : bNone = true;
2280 2 : break;
2281 : case UNDERLINE_DONTKNOW:
2282 0 : break;
2283 : default:
2284 14 : if( !rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) )
2285 : {
2286 : // this also works in HTML does not need to be written as
2287 : // a STYLE-Options, and must not be written as Hint
2288 : OSL_ENSURE( !rHTMLWrt.IsCSS1Source(CSS1_OUTMODE_HINT),
2289 : "write underline as Hint?" );
2290 0 : pUStr = sCSS1_PV_underline;
2291 : }
2292 14 : break;
2293 : }
2294 : }
2295 :
2296 16 : const sal_Char *pOStr = 0;
2297 16 : if( pOItem )
2298 : {
2299 0 : switch( pOItem->GetLineStyle() )
2300 : {
2301 : case UNDERLINE_NONE:
2302 0 : bNone = true;
2303 0 : break;
2304 : case UNDERLINE_DONTKNOW:
2305 0 : break;
2306 : default:
2307 0 : if( !rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) )
2308 : {
2309 : // this also works in HTML does not need to be written as
2310 : // a STYLE-Options, and must not be written as Hint
2311 : OSL_ENSURE( !rHTMLWrt.IsCSS1Source(CSS1_OUTMODE_HINT),
2312 : "write overline as Hint?" );
2313 0 : pOStr = sCSS1_PV_overline;
2314 : }
2315 0 : break;
2316 : }
2317 : }
2318 :
2319 16 : const sal_Char *pCOStr = 0;
2320 16 : if( pCOItem )
2321 : {
2322 0 : switch( pCOItem->GetStrikeout() )
2323 : {
2324 : case STRIKEOUT_NONE:
2325 0 : bNone = true;
2326 0 : break;
2327 : case STRIKEOUT_DONTKNOW:
2328 0 : break;
2329 : default:
2330 0 : if( !rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) )
2331 : {
2332 : // this also works in HTML does not need to be written as
2333 : // a STYLE-Options, and must not be written as Hint
2334 : OSL_ENSURE( !rHTMLWrt.IsCSS1Source(CSS1_OUTMODE_HINT),
2335 : "write crossedOut as Hint?" );
2336 0 : pCOStr = sCSS1_PV_line_through;
2337 : }
2338 0 : break;
2339 : }
2340 : }
2341 :
2342 16 : const sal_Char *pBStr = 0;
2343 16 : if( pBItem )
2344 : {
2345 0 : if( !pBItem->GetValue() )
2346 : {
2347 0 : bNone = true;
2348 : }
2349 0 : else if( !rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) )
2350 : {
2351 : // this also works in HTML does not need to be written as
2352 : // a STYLE-Options, and must not be written as Hint
2353 : OSL_ENSURE( !rHTMLWrt.IsCSS1Source(CSS1_OUTMODE_HINT),
2354 : "write blink as Hint?" );
2355 0 : pBStr = sCSS1_PV_blink;
2356 : }
2357 : }
2358 :
2359 16 : OStringBuffer sOut;
2360 16 : if( pUStr )
2361 0 : sOut.append(pUStr);
2362 :
2363 16 : if( pOStr )
2364 : {
2365 0 : if (!sOut.isEmpty())
2366 0 : sOut.append(' ');
2367 0 : sOut.append(pOStr);
2368 : }
2369 :
2370 16 : if( pCOStr )
2371 : {
2372 0 : if (!sOut.isEmpty())
2373 0 : sOut.append(' ');
2374 0 : sOut.append(pCOStr);
2375 : }
2376 :
2377 16 : if( pBStr )
2378 : {
2379 0 : if (!sOut.isEmpty())
2380 0 : sOut.append(' ');
2381 0 : sOut.append(pBStr);
2382 : }
2383 :
2384 16 : if (!sOut.isEmpty())
2385 0 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_text_decoration, sOut.makeStringAndClear() );
2386 16 : else if( bNone )
2387 2 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_text_decoration, sCSS1_PV_none );
2388 :
2389 16 : return rWrt;
2390 : }
2391 :
2392 22 : static Writer& OutCSS1_SvxCaseMap( Writer& rWrt, const SfxPoolItem& rHt )
2393 : {
2394 22 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2395 :
2396 22 : switch( ((const SvxCaseMapItem&)rHt).GetCaseMap() )
2397 : {
2398 : case SVX_CASEMAP_NOT_MAPPED:
2399 0 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_font_variant, sCSS1_PV_normal );
2400 0 : break;
2401 : case SVX_CASEMAP_KAPITAELCHEN:
2402 22 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_font_variant, sCSS1_PV_small_caps );
2403 22 : break;
2404 : case SVX_CASEMAP_VERSALIEN:
2405 0 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_text_transform, sCSS1_PV_uppercase );
2406 0 : break;
2407 : case SVX_CASEMAP_GEMEINE:
2408 0 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_text_transform, sCSS1_PV_lowercase );
2409 0 : break;
2410 : case SVX_CASEMAP_TITEL:
2411 0 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_text_transform, sCSS1_PV_capitalize );
2412 0 : break;
2413 : default:
2414 : ;
2415 : }
2416 :
2417 22 : return rWrt;
2418 : }
2419 :
2420 50 : static Writer& OutCSS1_SvxColor( Writer& rWrt, const SfxPoolItem& rHt )
2421 : {
2422 50 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2423 :
2424 : // Colors do not need to be exported for Style-Option.
2425 78 : if( rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) &&
2426 28 : !rHTMLWrt.bCfgPreferStyles )
2427 28 : return rWrt;
2428 : OSL_ENSURE( !rHTMLWrt.IsCSS1Source(CSS1_OUTMODE_HINT),
2429 : "write color as Hint?" );
2430 :
2431 22 : Color aColor( ((const SvxColorItem&)rHt).GetValue() );
2432 22 : if( COL_AUTO == aColor.GetColor() )
2433 4 : aColor.SetColor( COL_BLACK );
2434 :
2435 22 : rHTMLWrt.OutCSS1_PropertyAscii(sCSS1_P_color, lclGetCSS1Color(aColor));
2436 :
2437 22 : return rWrt;
2438 : }
2439 :
2440 0 : static Writer& OutCSS1_SvxCrossedOut( Writer& rWrt, const SfxPoolItem& rHt )
2441 : {
2442 : // This function only exports Hints!
2443 : // Otherwise OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink() is called directly.
2444 :
2445 0 : if( ((SwHTMLWriter&)rWrt).IsCSS1Source(CSS1_OUTMODE_HINT) )
2446 : OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink( rWrt,
2447 0 : 0, 0, (const SvxCrossedOutItem *)&rHt, 0 );
2448 :
2449 0 : return rWrt;
2450 : }
2451 :
2452 1354 : static Writer& OutCSS1_SvxFont( Writer& rWrt, const SfxPoolItem& rHt )
2453 : {
2454 1354 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2455 :
2456 : // No need to export Fonts for the Style-Option.
2457 1354 : if( rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) )
2458 1220 : return rWrt;
2459 :
2460 134 : sal_uInt16 nScript = CSS1_OUTMODE_WESTERN;
2461 134 : switch( rHt.Which() )
2462 : {
2463 32 : case RES_CHRATR_CJK_FONT: nScript = CSS1_OUTMODE_CJK; break;
2464 40 : case RES_CHRATR_CTL_FONT: nScript = CSS1_OUTMODE_CTL; break;
2465 : }
2466 134 : if( !rHTMLWrt.IsCSS1Script( nScript ) )
2467 94 : return rWrt;
2468 :
2469 : OSL_ENSURE( !rHTMLWrt.IsCSS1Source(CSS1_OUTMODE_HINT),
2470 : "write Font as Hint?" );
2471 :
2472 40 : OUString sOut;
2473 : // MS IE3b1 has problems with single quotes
2474 40 : sal_uInt16 nMode = rHTMLWrt.nCSS1OutMode & CSS1_OUTMODE_ANY_ON;
2475 40 : sal_Unicode cQuote = nMode == CSS1_OUTMODE_RULE_ON ? '\"' : '\'';
2476 : SwHTMLWriter::PrepareFontList( ((const SvxFontItem&)rHt), sOut, cQuote,
2477 40 : true );
2478 :
2479 40 : rHTMLWrt.OutCSS1_Property( sCSS1_P_font_family, sOut );
2480 :
2481 40 : return rWrt;
2482 : }
2483 :
2484 220 : static Writer& OutCSS1_SvxFontHeight( Writer& rWrt, const SfxPoolItem& rHt )
2485 : {
2486 220 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2487 :
2488 : // Font-Height need not be exported in the Style-Option.
2489 : // For Drop-Caps another Font-Size is exported.
2490 400 : if( rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) ||
2491 180 : rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_DROPCAP ) )
2492 40 : return rWrt;
2493 :
2494 180 : sal_uInt16 nScript = CSS1_OUTMODE_WESTERN;
2495 180 : switch( rHt.Which() )
2496 : {
2497 64 : case RES_CHRATR_CJK_FONTSIZE: nScript = CSS1_OUTMODE_CJK; break;
2498 42 : case RES_CHRATR_CTL_FONTSIZE: nScript = CSS1_OUTMODE_CTL; break;
2499 : }
2500 180 : if( !rHTMLWrt.IsCSS1Script( nScript ) )
2501 120 : return rWrt;
2502 :
2503 60 : sal_uInt32 nHeight = ((const SvxFontHeightItem&)rHt).GetHeight();
2504 60 : OString sHeight(OString::number(nHeight/20) + OString(sCSS1_UNIT_pt));
2505 60 : rHTMLWrt.OutCSS1_PropertyAscii(sCSS1_P_font_size, sHeight);
2506 :
2507 60 : return rWrt;
2508 : }
2509 :
2510 0 : static Writer& OutCSS1_SvxPosture( Writer& rWrt, const SfxPoolItem& rHt )
2511 : {
2512 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2513 :
2514 0 : sal_uInt16 nScript = CSS1_OUTMODE_WESTERN;
2515 0 : switch( rHt.Which() )
2516 : {
2517 0 : case RES_CHRATR_CJK_POSTURE: nScript = CSS1_OUTMODE_CJK; break;
2518 0 : case RES_CHRATR_CTL_POSTURE: nScript = CSS1_OUTMODE_CTL; break;
2519 : }
2520 0 : if( !rHTMLWrt.IsCSS1Script( nScript ) )
2521 0 : return rWrt;
2522 :
2523 0 : const sal_Char *pStr = 0;
2524 0 : switch( ((const SvxPostureItem&)rHt).GetPosture() )
2525 : {
2526 0 : case ITALIC_NONE: pStr = sCSS1_PV_normal; break;
2527 0 : case ITALIC_OBLIQUE: pStr = sCSS1_PV_oblique; break;
2528 : case ITALIC_NORMAL:
2529 0 : if( !rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) )
2530 : {
2531 : // this also works in HTML does not need to be written as
2532 : // a STYLE-Options, and must not be written as Hint
2533 : OSL_ENSURE( !rHTMLWrt.IsCSS1Source(CSS1_OUTMODE_HINT),
2534 : "write italic as Hint?" );
2535 0 : pStr = sCSS1_PV_italic;
2536 : }
2537 0 : break;
2538 : default:
2539 : ;
2540 : }
2541 :
2542 0 : if( pStr )
2543 0 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_font_style, pStr );
2544 :
2545 0 : return rWrt;
2546 : }
2547 :
2548 0 : static Writer& OutCSS1_SvxKerning( Writer& rWrt, const SfxPoolItem& rHt )
2549 : {
2550 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2551 :
2552 0 : sal_Int16 nValue = ((const SvxKerningItem&)rHt).GetValue();
2553 0 : if( nValue )
2554 : {
2555 0 : OStringBuffer sOut;
2556 0 : if( nValue < 0 )
2557 : {
2558 0 : sOut.append('-');
2559 0 : nValue = -nValue;
2560 : }
2561 :
2562 : // Width as n.n pt
2563 0 : nValue = (nValue + 1) / 2; // 1/10pt
2564 0 : sOut.append(OString::number(nValue / 10) + "." + OString::number(nValue % 10) +
2565 0 : OString(sCSS1_UNIT_pt));
2566 :
2567 : rHTMLWrt.OutCSS1_PropertyAscii(sCSS1_P_letter_spacing,
2568 0 : sOut.makeStringAndClear());
2569 : }
2570 : else
2571 : {
2572 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_letter_spacing,
2573 0 : sCSS1_PV_normal );
2574 : }
2575 :
2576 0 : return rWrt;
2577 : }
2578 :
2579 750 : static Writer& OutCSS1_SvxLanguage( Writer& rWrt, const SfxPoolItem& rHt )
2580 : {
2581 750 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2582 :
2583 : // Only export Language rules
2584 750 : if( rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) )
2585 606 : return rWrt;
2586 :
2587 144 : sal_uInt16 nScript = CSS1_OUTMODE_WESTERN;
2588 144 : switch( rHt.Which() )
2589 : {
2590 40 : case RES_CHRATR_CJK_LANGUAGE: nScript = CSS1_OUTMODE_CJK; break;
2591 48 : case RES_CHRATR_CTL_LANGUAGE: nScript = CSS1_OUTMODE_CTL; break;
2592 : }
2593 144 : if( !rHTMLWrt.IsCSS1Script( nScript ) )
2594 108 : return rWrt;
2595 :
2596 : OSL_ENSURE( !rHTMLWrt.IsCSS1Source(CSS1_OUTMODE_HINT),
2597 : "write Language as Hint?" );
2598 :
2599 36 : LanguageType eLang = ((const SvxLanguageItem &)rHt).GetLanguage();
2600 36 : if( LANGUAGE_DONTKNOW == eLang )
2601 0 : return rWrt;
2602 :
2603 36 : OUString sOut = LanguageTag::convertToBcp47( eLang );
2604 :
2605 36 : rHTMLWrt.OutCSS1_Property( sCSS1_P_so_language, sOut );
2606 :
2607 36 : return rWrt;
2608 : }
2609 :
2610 16 : static Writer& OutCSS1_SvxUnderline( Writer& rWrt, const SfxPoolItem& rHt )
2611 : {
2612 : // This function only exports Hints!
2613 : // Otherwise OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink() is called directly.
2614 :
2615 16 : if( ((SwHTMLWriter&)rWrt).IsCSS1Source(CSS1_OUTMODE_HINT) )
2616 : OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink( rWrt,
2617 0 : (const SvxUnderlineItem *)&rHt, 0, 0, 0 );
2618 :
2619 16 : return rWrt;
2620 : }
2621 :
2622 0 : static Writer& OutCSS1_SvxOverline( Writer& rWrt, const SfxPoolItem& rHt )
2623 : {
2624 : // This function only exports Hints!
2625 : // Otherwise OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink() is called directly.
2626 :
2627 0 : if( ((SwHTMLWriter&)rWrt).IsCSS1Source(CSS1_OUTMODE_HINT) )
2628 : OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink( rWrt,
2629 0 : 0, (const SvxOverlineItem *)&rHt, 0, 0 );
2630 :
2631 0 : return rWrt;
2632 : }
2633 :
2634 0 : static Writer& OutCSS1_SvxHidden( Writer& rWrt, const SfxPoolItem& rHt )
2635 : {
2636 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2637 :
2638 0 : if ( ((const SvxCharHiddenItem&)rHt).GetValue() )
2639 0 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_display, sCSS1_PV_none );
2640 :
2641 0 : return rWrt;
2642 : }
2643 :
2644 406 : static Writer& OutCSS1_SvxFontWeight( Writer& rWrt, const SfxPoolItem& rHt )
2645 : {
2646 406 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2647 :
2648 406 : sal_uInt16 nScript = CSS1_OUTMODE_WESTERN;
2649 406 : switch( rHt.Which() )
2650 : {
2651 178 : case RES_CHRATR_CJK_WEIGHT: nScript = CSS1_OUTMODE_CJK; break;
2652 50 : case RES_CHRATR_CTL_WEIGHT: nScript = CSS1_OUTMODE_CTL; break;
2653 : }
2654 406 : if( !rHTMLWrt.IsCSS1Script( nScript ) )
2655 228 : return rWrt;
2656 :
2657 178 : const sal_Char *pStr = 0;
2658 178 : switch( ((const SvxWeightItem&)rHt).GetWeight() )
2659 : {
2660 0 : case WEIGHT_ULTRALIGHT: pStr = sCSS1_PV_extra_light; break;
2661 0 : case WEIGHT_LIGHT: pStr = sCSS1_PV_light; break;
2662 0 : case WEIGHT_SEMILIGHT: pStr = sCSS1_PV_demi_light; break;
2663 0 : case WEIGHT_NORMAL: pStr = sCSS1_PV_normal; break;
2664 0 : case WEIGHT_SEMIBOLD: pStr = sCSS1_PV_demi_bold; break;
2665 : case WEIGHT_BOLD:
2666 178 : if( !rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) )
2667 : {
2668 : // this also works in HTML does not need to be written as
2669 : // a STYLE-Options, and must not be written as Hint
2670 : OSL_ENSURE( !rHTMLWrt.IsCSS1Source(CSS1_OUTMODE_HINT),
2671 : "write bold as Hint?" );
2672 0 : pStr = sCSS1_PV_bold;
2673 : }
2674 178 : break;
2675 0 : case WEIGHT_ULTRABOLD: pStr = sCSS1_PV_extra_bold; break;
2676 : default:
2677 0 : pStr = sCSS1_PV_normal;;
2678 : }
2679 :
2680 178 : if( pStr )
2681 0 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_font_weight, pStr );
2682 :
2683 178 : return rWrt;
2684 : }
2685 :
2686 0 : static Writer& OutCSS1_SvxBlink( Writer& rWrt, const SfxPoolItem& rHt )
2687 : {
2688 : // This function only exports Hints!
2689 : // Otherwise OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink() is called directly.
2690 :
2691 0 : if( ((SwHTMLWriter&)rWrt).IsCSS1Source(CSS1_OUTMODE_HINT) )
2692 : OutCSS1_SvxTxtLn_SvxCrOut_SvxBlink( rWrt,
2693 0 : 0, 0, 0, (const SvxBlinkItem *)&rHt );
2694 :
2695 0 : return rWrt;
2696 : }
2697 :
2698 562 : static Writer& OutCSS1_SvxLineSpacing( Writer& rWrt, const SfxPoolItem& rHt )
2699 : {
2700 562 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2701 :
2702 : // Netscape4 has big problems with cell heights if the line spacing is
2703 : // changed within a table and the width of the table is not calculated
2704 : // automatically (== if there is a WIDTH-Option)
2705 562 : if( rHTMLWrt.bOutTable && rHTMLWrt.bCfgNetscape4 )
2706 522 : return rWrt;
2707 :
2708 40 : const SvxLineSpacingItem& rLSItem = (const SvxLineSpacingItem&)rHt;
2709 :
2710 40 : sal_uInt16 nHeight = 0;
2711 40 : sal_uInt16 nPrcHeight = 0;
2712 40 : SvxLineSpace eLineSpace = rLSItem.GetLineSpaceRule();
2713 40 : switch( rLSItem.GetInterLineSpaceRule() )
2714 : {
2715 : case SVX_INTER_LINE_SPACE_OFF:
2716 : case SVX_INTER_LINE_SPACE_FIX:
2717 : {
2718 10 : switch( eLineSpace )
2719 : {
2720 : case SVX_LINE_SPACE_MIN:
2721 : case SVX_LINE_SPACE_FIX:
2722 0 : nHeight = rLSItem.GetLineHeight();
2723 0 : break;
2724 : case SVX_LINE_SPACE_AUTO:
2725 10 : nPrcHeight = 100;
2726 10 : break;
2727 : default:
2728 : ;
2729 : }
2730 : }
2731 10 : break;
2732 : case SVX_INTER_LINE_SPACE_PROP:
2733 30 : nPrcHeight = rLSItem.GetPropLineSpace();
2734 30 : break;
2735 :
2736 : default:
2737 : ;
2738 : }
2739 :
2740 40 : if( nHeight )
2741 0 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_line_height, (long)nHeight );
2742 40 : else if( nPrcHeight )
2743 : {
2744 40 : OString sHeight(OString::number(nPrcHeight) + "%");
2745 40 : rHTMLWrt.OutCSS1_PropertyAscii(sCSS1_P_line_height, sHeight);
2746 : }
2747 :
2748 40 : return rWrt;
2749 : }
2750 :
2751 14 : static Writer& OutCSS1_SvxAdjust( Writer& rWrt, const SfxPoolItem& rHt )
2752 : {
2753 14 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
2754 :
2755 : // Export Alignment in Style-Option only if the Tag does not allow ALIGN=xxx
2756 18 : if( rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) &&
2757 4 : !rHTMLWrt.bNoAlign)
2758 4 : return rWrt;
2759 :
2760 10 : const sal_Char* pStr = 0;
2761 10 : switch( ((const SvxAdjustItem&)rHt).GetAdjust() )
2762 : {
2763 8 : case SVX_ADJUST_LEFT: pStr = sCSS1_PV_left; break;
2764 0 : case SVX_ADJUST_RIGHT: pStr = sCSS1_PV_right; break;
2765 2 : case SVX_ADJUST_BLOCK: pStr = sCSS1_PV_justify; break;
2766 0 : case SVX_ADJUST_CENTER: pStr = sCSS1_PV_center; break;
2767 : default:
2768 : ;
2769 : }
2770 :
2771 10 : if( pStr )
2772 10 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_text_align, pStr );
2773 :
2774 10 : return rWrt;
2775 : }
2776 :
2777 0 : static Writer& OutCSS1_SvxFmtSplit( Writer& rWrt, const SfxPoolItem& rHt )
2778 : {
2779 0 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
2780 :
2781 0 : const sal_Char *pStr = ((const SvxFmtSplitItem&)rHt).GetValue()
2782 : ? sCSS1_PV_auto
2783 0 : : sCSS1_PV_avoid;
2784 0 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_page_break_inside, pStr );
2785 :
2786 0 : return rWrt;
2787 : }
2788 :
2789 0 : static Writer& OutCSS1_SwFmtLayoutSplit( Writer& rWrt, const SfxPoolItem& rHt )
2790 : {
2791 0 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
2792 :
2793 0 : const sal_Char *pStr = ((const SwFmtLayoutSplit&)rHt).GetValue()
2794 : ? sCSS1_PV_auto
2795 0 : : sCSS1_PV_avoid;
2796 0 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_page_break_inside, pStr );
2797 :
2798 0 : return rWrt;
2799 : }
2800 :
2801 12 : static Writer& OutCSS1_SvxWidows( Writer& rWrt, const SfxPoolItem& rHt )
2802 : {
2803 12 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
2804 :
2805 12 : OString aStr(OString::number(((const SvxWidowsItem&)rHt).GetValue()));
2806 12 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_widows, aStr );
2807 :
2808 12 : return rWrt;
2809 : }
2810 :
2811 12 : static Writer& OutCSS1_SvxOrphans( Writer& rWrt, const SfxPoolItem& rHt )
2812 : {
2813 12 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
2814 :
2815 12 : OString aStr(OString::number(((const SvxOrphansItem&)rHt).GetValue()));
2816 12 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_orphans, aStr );
2817 :
2818 12 : return rWrt;
2819 : }
2820 :
2821 0 : static void OutCSS1_SwFmtDropAttrs( SwHTMLWriter& rHWrt,
2822 : const SwFmtDrop& rDrop,
2823 : const SfxItemSet *pCharFmtItemSet )
2824 : {
2825 : // Text flows around on right side
2826 0 : rHWrt.OutCSS1_PropertyAscii( sCSS1_P_float, sCSS1_PV_left );
2827 :
2828 : // number of lines -> use % for Font-Height!
2829 0 : OString sOut(OString::number(rDrop.GetLines()*100) + "%");
2830 0 : rHWrt.OutCSS1_PropertyAscii(sCSS1_P_font_size, sOut);
2831 :
2832 : // distance to Text = right margin
2833 0 : sal_uInt16 nDistance = rDrop.GetDistance();
2834 0 : if( nDistance > 0 )
2835 0 : rHWrt.OutCSS1_UnitProperty( sCSS1_P_margin_right, nDistance );
2836 :
2837 0 : const SwCharFmt *pDCCharFmt = rDrop.GetCharFmt();
2838 0 : if( pCharFmtItemSet )
2839 0 : rHWrt.OutCSS1_SfxItemSet( *pCharFmtItemSet );
2840 0 : else if( pDCCharFmt )
2841 0 : rHWrt.OutCSS1_SfxItemSet( pDCCharFmt->GetAttrSet() );
2842 0 : else if( (rHWrt.nCSS1OutMode & CSS1_OUTMODE_ANY_OFF) == CSS1_OUTMODE_RULE_OFF )
2843 0 : rHWrt.Strm().WriteCharPtr( sCSS1_rule_end );
2844 :
2845 0 : }
2846 :
2847 0 : static Writer& OutCSS1_SwFmtDrop( Writer& rWrt, const SfxPoolItem& rHt )
2848 : {
2849 0 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
2850 :
2851 : // never export as an Option of a paragraph, but only as Hints
2852 0 : if( !rHTMLWrt.IsCSS1Source(CSS1_OUTMODE_HINT) )
2853 0 : return rWrt;
2854 :
2855 0 : if( rHTMLWrt.bTagOn )
2856 : {
2857 : SwCSS1OutMode aMode( rHTMLWrt,
2858 : rHTMLWrt.nCSS1Script|CSS1_OUTMODE_SPAN_TAG1_ON|CSS1_OUTMODE_ENCODE|
2859 0 : CSS1_OUTMODE_DROPCAP );
2860 :
2861 0 : OutCSS1_SwFmtDropAttrs( rHTMLWrt, (const SwFmtDrop&)rHt );
2862 : // A "> is already printed by the calling OutCSS1_HintAsSpanTag.
2863 : }
2864 : else
2865 : {
2866 0 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_span, false );
2867 : }
2868 :
2869 0 : return rWrt;
2870 : }
2871 :
2872 0 : static Writer& OutCSS1_SwFmtFrmSize( Writer& rWrt, const SfxPoolItem& rHt,
2873 : sal_uInt16 nMode )
2874 : {
2875 0 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
2876 :
2877 0 : const SwFmtFrmSize& rFSItem = (const SwFmtFrmSize&)rHt;
2878 :
2879 0 : if( nMode & CSS1_FRMSIZE_WIDTH )
2880 : {
2881 0 : sal_uInt8 nPrcWidth = rFSItem.GetWidthPercent();
2882 0 : if( nPrcWidth )
2883 : {
2884 0 : OString sOut(OString::number(nPrcWidth) + "%");
2885 0 : rHTMLWrt.OutCSS1_PropertyAscii(sCSS1_P_width, sOut);
2886 : }
2887 0 : else if( nMode & CSS1_FRMSIZE_PIXEL )
2888 : {
2889 : rHTMLWrt.OutCSS1_PixelProperty( sCSS1_P_width,
2890 0 : rFSItem.GetSize().Width(), false );
2891 : }
2892 : else
2893 : {
2894 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_width,
2895 0 : rFSItem.GetSize().Width() );
2896 : }
2897 : }
2898 :
2899 0 : if( nMode & CSS1_FRMSIZE_ANYHEIGHT )
2900 : {
2901 0 : bool bOutHeight = false;
2902 0 : switch( rFSItem.GetHeightSizeType() )
2903 : {
2904 : case ATT_FIX_SIZE:
2905 0 : bOutHeight = (nMode & CSS1_FRMSIZE_FIXHEIGHT) != 0;
2906 0 : break;
2907 : case ATT_MIN_SIZE:
2908 0 : bOutHeight = (nMode & CSS1_FRMSIZE_MINHEIGHT) != 0;
2909 0 : break;
2910 : case ATT_VAR_SIZE:
2911 0 : bOutHeight = (nMode & CSS1_FRMSIZE_VARHEIGHT) != 0;
2912 0 : break;
2913 : default:
2914 : OSL_ENSURE( bOutHeight, "Hoehe wird nicht exportiert" );
2915 0 : break;
2916 : }
2917 :
2918 0 : if( bOutHeight )
2919 : {
2920 0 : sal_uInt8 nPrcHeight = rFSItem.GetHeightPercent();
2921 0 : if( nPrcHeight )
2922 : {
2923 0 : OString sOut(OString::number(nPrcHeight) + "%");
2924 0 : rHTMLWrt.OutCSS1_PropertyAscii(sCSS1_P_height, sOut);
2925 : }
2926 0 : else if( nMode & CSS1_FRMSIZE_PIXEL )
2927 : {
2928 : rHTMLWrt.OutCSS1_PixelProperty( sCSS1_P_height,
2929 0 : rFSItem.GetSize().Height(),
2930 0 : true );
2931 : }
2932 : else
2933 : {
2934 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_height,
2935 0 : rFSItem.GetSize().Height() );
2936 : }
2937 : }
2938 : }
2939 :
2940 0 : return rWrt;
2941 : }
2942 :
2943 14 : static Writer& OutCSS1_SvxLRSpace( Writer& rWrt, const SfxPoolItem& rHt )
2944 : {
2945 14 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
2946 :
2947 14 : const SvxLRSpaceItem& rLRItem = (const SvxLRSpaceItem&)rHt;
2948 :
2949 : // No Export of a firm attribute is needed if the new values
2950 : // match that of the current template
2951 :
2952 : // A left margin can exist because of a list nearby
2953 14 : long nLeftMargin = (long)rLRItem.GetTxtLeft() - rHTMLWrt.nLeftMargin;
2954 14 : if( rHTMLWrt.nDfltLeftMargin != nLeftMargin )
2955 : {
2956 14 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_margin_left, nLeftMargin );
2957 : }
2958 :
2959 14 : if( rHTMLWrt.nDfltRightMargin != rLRItem.GetRight() )
2960 : {
2961 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_margin_right,
2962 6 : (long)rLRItem.GetRight() );
2963 : }
2964 :
2965 : // The LineIndent of the first line might contain the room for numbering
2966 14 : long nFirstLineIndent = (long)rLRItem.GetTxtFirstLineOfst() -
2967 14 : rHTMLWrt.nFirstLineIndent;
2968 14 : if( rHTMLWrt.nDfltFirstLineIndent != nFirstLineIndent )
2969 : {
2970 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_text_indent,
2971 0 : nFirstLineIndent );
2972 : }
2973 :
2974 14 : return rWrt;
2975 : }
2976 :
2977 578 : static Writer& OutCSS1_SvxULSpace( Writer& rWrt, const SfxPoolItem& rHt )
2978 : {
2979 578 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
2980 :
2981 578 : const SvxULSpaceItem& rULItem = (const SvxULSpaceItem&)rHt;
2982 :
2983 578 : if( rHTMLWrt.nDfltTopMargin != rULItem.GetUpper() )
2984 : {
2985 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_margin_top,
2986 6 : (long)rULItem.GetUpper() );
2987 : }
2988 :
2989 578 : if( rHTMLWrt.nDfltBottomMargin != rULItem.GetLower() )
2990 : {
2991 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_margin_bottom,
2992 56 : (long)rULItem.GetLower() );
2993 : }
2994 :
2995 578 : return rWrt;
2996 : }
2997 :
2998 20 : static Writer& OutCSS1_SvxULSpace_SvxLRSpace( Writer& rWrt,
2999 : const SvxULSpaceItem *pULItem,
3000 : const SvxLRSpaceItem *pLRItem )
3001 : {
3002 20 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
3003 :
3004 60 : if( pLRItem && pULItem &&
3005 40 : pLRItem->GetLeft() == pLRItem->GetRight() &&
3006 36 : pLRItem->GetLeft() == pULItem->GetUpper() &&
3007 32 : pLRItem->GetLeft() == pULItem->GetLower() &&
3008 32 : pLRItem->GetLeft() != rHTMLWrt.nDfltLeftMargin &&
3009 32 : pLRItem->GetRight() != rHTMLWrt.nDfltRightMargin &&
3010 52 : pULItem->GetUpper() != rHTMLWrt.nDfltTopMargin &&
3011 16 : pULItem->GetLower() != rHTMLWrt.nDfltBottomMargin )
3012 : {
3013 16 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_margin, (long)pLRItem->GetLeft() );
3014 : }
3015 : else
3016 : {
3017 4 : if( pLRItem )
3018 4 : OutCSS1_SvxLRSpace( rWrt, *pLRItem );
3019 4 : if( pULItem )
3020 4 : OutCSS1_SvxULSpace( rWrt, *pULItem );
3021 : }
3022 :
3023 20 : return rWrt;
3024 : }
3025 :
3026 22 : static Writer& OutCSS1_SvxULSpace_SvxLRSpace( Writer& rWrt,
3027 : const SfxItemSet& rItemSet,
3028 : bool bDeep )
3029 : {
3030 22 : const SvxULSpaceItem *pULSpace = 0;
3031 22 : const SvxLRSpaceItem *pLRSpace = 0;
3032 : const SfxPoolItem *pItem;
3033 22 : if( SfxItemState::SET == rItemSet.GetItemState( RES_LR_SPACE, bDeep, &pItem ) )
3034 20 : pLRSpace = (const SvxLRSpaceItem *)pItem;
3035 :
3036 22 : if( SfxItemState::SET == rItemSet.GetItemState( RES_UL_SPACE, bDeep, &pItem ) )
3037 20 : pULSpace = (const SvxULSpaceItem *)pItem;
3038 :
3039 22 : if( pLRSpace || pULSpace )
3040 20 : OutCSS1_SvxULSpace_SvxLRSpace( rWrt, pULSpace, pLRSpace );
3041 :
3042 22 : return rWrt;
3043 : }
3044 :
3045 6 : static Writer& OutCSS1_SvxFmtBreak_SwFmtPDesc_SvxFmtKeep( Writer& rWrt,
3046 : const SvxFmtBreakItem *pBreakItem,
3047 : const SwFmtPageDesc *pPDescItem,
3048 : const SvxFmtKeepItem *pKeepItem )
3049 : {
3050 6 : SwHTMLWriter & rHTMLWrt = (SwHTMLWriter&)rWrt;
3051 :
3052 6 : if( !rHTMLWrt.IsHTMLMode(HTMLMODE_PRINT_EXT) )
3053 0 : return rWrt;
3054 :
3055 6 : const sal_Char *pBreakBefore = 0;
3056 6 : const sal_Char *pBreakAfter = 0;
3057 :
3058 6 : if( pKeepItem )
3059 : {
3060 0 : pBreakAfter = pKeepItem->GetValue() ? sCSS1_PV_avoid : sCSS1_PV_auto;
3061 : }
3062 6 : if( pBreakItem )
3063 : {
3064 0 : switch( pBreakItem->GetBreak() )
3065 : {
3066 : case SVX_BREAK_NONE:
3067 0 : pBreakBefore = sCSS1_PV_auto;
3068 0 : if( !pBreakAfter )
3069 0 : pBreakAfter = sCSS1_PV_auto;
3070 0 : break;
3071 :
3072 : case SVX_BREAK_PAGE_BEFORE:
3073 0 : pBreakBefore = sCSS1_PV_always;
3074 0 : break;
3075 :
3076 : case SVX_BREAK_PAGE_AFTER:
3077 0 : pBreakAfter= sCSS1_PV_always;
3078 0 : break;
3079 :
3080 : default:
3081 : ;
3082 : }
3083 : }
3084 6 : if( pPDescItem )
3085 : {
3086 6 : const SwPageDesc *pPDesc = pPDescItem->GetPageDesc();
3087 6 : if( pPDesc )
3088 : {
3089 4 : switch( pPDesc->GetPoolFmtId() )
3090 : {
3091 0 : case RES_POOLPAGE_LEFT: pBreakBefore = sCSS1_PV_left; break;
3092 0 : case RES_POOLPAGE_RIGHT: pBreakBefore = sCSS1_PV_right; break;
3093 4 : default: pBreakBefore = sCSS1_PV_always; break;
3094 : }
3095 : }
3096 2 : else if( !pBreakBefore )
3097 : {
3098 2 : pBreakBefore = sCSS1_PV_auto;
3099 : }
3100 : }
3101 :
3102 6 : if( pBreakBefore )
3103 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_page_break_before,
3104 6 : pBreakBefore );
3105 6 : if( pBreakAfter )
3106 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_page_break_after,
3107 0 : pBreakAfter );
3108 :
3109 6 : return rWrt;
3110 : }
3111 :
3112 654 : static Writer& OutCSS1_SvxFmtBreak_SwFmtPDesc_SvxFmtKeep( Writer& rWrt,
3113 : const SfxItemSet& rItemSet,
3114 : bool bDeep )
3115 : {
3116 654 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
3117 : const SfxPoolItem *pItem;
3118 654 : const SvxFmtBreakItem *pBreakItem = 0;
3119 654 : if( SfxItemState::SET==rItemSet.GetItemState( RES_BREAK, bDeep, &pItem ))
3120 0 : pBreakItem = (const SvxFmtBreakItem *)pItem;
3121 :
3122 654 : const SwFmtPageDesc *pPDescItem = 0;
3123 1878 : if( ( !rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) ||
3124 1138 : !rHTMLWrt.bCSS1IgnoreFirstPageDesc ||
3125 568 : rHTMLWrt.pStartNdIdx->GetIndex() !=
3126 1856 : rHTMLWrt.pCurPam->GetPoint()->nNode.GetIndex() ) &&
3127 634 : SfxItemState::SET==rItemSet.GetItemState( RES_PAGEDESC, bDeep, &pItem ))
3128 6 : pPDescItem = (const SwFmtPageDesc*)pItem;
3129 :
3130 654 : const SvxFmtKeepItem *pKeepItem = 0;
3131 654 : if( SfxItemState::SET==rItemSet.GetItemState( RES_KEEP, bDeep, &pItem ))
3132 0 : pKeepItem = (const SvxFmtKeepItem *)pItem;
3133 :
3134 654 : if( pBreakItem || pPDescItem || pKeepItem )
3135 : OutCSS1_SvxFmtBreak_SwFmtPDesc_SvxFmtKeep( rWrt, pBreakItem,
3136 6 : pPDescItem, pKeepItem );
3137 :
3138 654 : return rWrt;
3139 : }
3140 :
3141 : // Wrapper for OutCSS1_SfxItemSet etc.
3142 8 : static Writer& OutCSS1_SvxBrush( Writer& rWrt, const SfxPoolItem& rHt )
3143 : {
3144 8 : OutCSS1_SvxBrush( rWrt, rHt, CSS1_BACKGROUND_ATTR );
3145 8 : return rWrt;
3146 : }
3147 :
3148 530 : static Writer& OutCSS1_SvxBrush( Writer& rWrt, const SfxPoolItem& rHt,
3149 : sal_uInt16 nMode)
3150 : {
3151 530 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
3152 :
3153 : // The Character-Attribute is skipped, if we are about to
3154 : // exporting options
3155 538 : if( rHt.Which() < RES_CHRATR_END &&
3156 8 : rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) )
3157 0 : return rWrt;
3158 :
3159 : // start getting a few values
3160 : // const Brush &rBrush = ((const SvxBrushItem &)rHt).GetBrush();
3161 530 : const Color & rColor = ((const SvxBrushItem &)rHt).GetColor();
3162 530 : SvxGraphicPosition ePos = ((const SvxBrushItem &)rHt).GetGraphicPos();
3163 :
3164 : // get the color
3165 530 : bool bColor = false;
3166 : /// set <bTransparent> to sal_True, if color is "no fill"/"auto fill"
3167 530 : bool bTransparent = (rColor.GetColor() == COL_TRANSPARENT);
3168 530 : Color aColor;
3169 530 : if( !bTransparent )
3170 : {
3171 530 : aColor = rColor;
3172 530 : bColor = true;
3173 : }
3174 :
3175 : // and now the Graphic
3176 530 : OUString aGraphicInBase64;
3177 :
3178 : // Embedded Grafic -> export WriteEmbedded
3179 530 : const Graphic* pGrf = ((const SvxBrushItem &)rHt).GetGraphic();
3180 530 : if( pGrf )
3181 : {
3182 0 : sal_uLong nErr = XOutBitmap::GraphicToBase64(*pGrf, aGraphicInBase64);
3183 0 : if( nErr )
3184 : {
3185 0 : rHTMLWrt.nWarn = WARN_SWG_POOR_LOAD | WARN_SW_WRITE_BASE;
3186 : }
3187 : }
3188 :
3189 : // In tables we only export something if there is a Graphic
3190 530 : if( CSS1_BACKGROUND_TABLE==nMode && !pGrf )
3191 522 : return rWrt;
3192 :
3193 : // if necessary, add the orientation of the Graphic
3194 8 : const sal_Char *pRepeat = 0, *pHori = 0, *pVert = 0;
3195 8 : if( pGrf )
3196 : {
3197 0 : if( GPOS_TILED==ePos )
3198 : {
3199 0 : pRepeat = sCSS1_PV_repeat;
3200 : }
3201 : else
3202 : {
3203 0 : switch( ePos )
3204 : {
3205 : case GPOS_LT:
3206 : case GPOS_MT:
3207 : case GPOS_RT:
3208 0 : pHori = sCSS1_PV_top;
3209 0 : break;
3210 :
3211 : case GPOS_LM:
3212 : case GPOS_MM:
3213 : case GPOS_RM:
3214 0 : pHori = sCSS1_PV_middle;
3215 0 : break;
3216 :
3217 : case GPOS_LB:
3218 : case GPOS_MB:
3219 : case GPOS_RB:
3220 0 : pHori = sCSS1_PV_bottom;
3221 0 : break;
3222 :
3223 : default:
3224 : ;
3225 : }
3226 :
3227 0 : switch( ePos )
3228 : {
3229 : case GPOS_LT:
3230 : case GPOS_LM:
3231 : case GPOS_LB:
3232 0 : pVert = sCSS1_PV_left;
3233 0 : break;
3234 :
3235 : case GPOS_MT:
3236 : case GPOS_MM:
3237 : case GPOS_MB:
3238 0 : pVert = sCSS1_PV_center;
3239 0 : break;
3240 :
3241 : case GPOS_RT:
3242 : case GPOS_RM:
3243 : case GPOS_RB:
3244 0 : pVert = sCSS1_PV_right;
3245 0 : break;
3246 :
3247 : default:
3248 : ;
3249 : }
3250 :
3251 0 : if( pHori || pVert )
3252 0 : pRepeat = sCSS1_PV_no_repeat;
3253 : }
3254 : }
3255 :
3256 : // now build the string
3257 8 : OUString sOut;
3258 8 : if( !pGrf && !bColor )
3259 : {
3260 : // no color and no Link, but a transparent Brush
3261 0 : if( bTransparent && CSS1_BACKGROUND_FLY != nMode )
3262 0 : sOut += OStringToOUString(sCSS1_PV_transparent, RTL_TEXTENCODING_ASCII_US);
3263 : }
3264 : else
3265 : {
3266 8 : if( bColor )
3267 : {
3268 8 : OString sTmp(lclGetCSS1Color(aColor));
3269 8 : sOut += OStringToOUString(sTmp, RTL_TEXTENCODING_ASCII_US);
3270 : }
3271 :
3272 8 : if( pGrf )
3273 : {
3274 0 : if( bColor )
3275 0 : sOut += " ";
3276 :
3277 0 : sOut += OStringToOUString(sCSS1_url, RTL_TEXTENCODING_ASCII_US) +
3278 0 : "(\'" OOO_STRING_SVTOOLS_HTML_O_data ":" + aGraphicInBase64 + "\')";
3279 :
3280 0 : if( pRepeat )
3281 : {
3282 0 : sOut += " " + OStringToOUString(pRepeat, RTL_TEXTENCODING_ASCII_US);
3283 : }
3284 :
3285 0 : if( pHori )
3286 : {
3287 0 : sOut += " " + OStringToOUString(pHori, RTL_TEXTENCODING_ASCII_US);
3288 : }
3289 0 : if( pVert )
3290 : {
3291 0 : sOut += " " + OStringToOUString(pVert, RTL_TEXTENCODING_ASCII_US);
3292 : }
3293 :
3294 0 : sOut += " " + OStringToOUString(sCSS1_PV_scroll, RTL_TEXTENCODING_ASCII_US) + " ";
3295 : }
3296 : }
3297 :
3298 8 : if( !sOut.isEmpty() )
3299 8 : rHTMLWrt.OutCSS1_Property( sCSS1_P_background, sOut );
3300 :
3301 8 : return rWrt;
3302 : }
3303 :
3304 528 : static void OutCSS1_SvxBorderLine( SwHTMLWriter& rHTMLWrt,
3305 : const sal_Char *pProperty,
3306 : const SvxBorderLine *pLine )
3307 : {
3308 528 : if( !pLine || pLine->isEmpty() )
3309 : {
3310 0 : rHTMLWrt.OutCSS1_PropertyAscii( pProperty, sCSS1_PV_none );
3311 528 : return;
3312 : }
3313 :
3314 528 : sal_Int32 nWidth = pLine->GetWidth();
3315 :
3316 528 : OStringBuffer sOut;
3317 2112 : if( Application::GetDefaultDevice() &&
3318 1056 : nWidth <= Application::GetDefaultDevice()->PixelToLogic(
3319 2112 : Size( 1, 1 ), MapMode( MAP_TWIP) ).Width() )
3320 : {
3321 : // If the width is smaller than one pixel, then export as 1px
3322 : // so that Netscape and IE show the line.
3323 520 : sOut.append("1px");
3324 : }
3325 : else
3326 : {
3327 8 : nWidth *= 5; // 1/100pt
3328 :
3329 : // width in n.nn pt
3330 16 : sOut.append(OString::number(nWidth / 100) + "." + OString::number((nWidth/10) % 10) +
3331 24 : OString::number(nWidth % 10) + OString(sCSS1_UNIT_pt));
3332 : }
3333 :
3334 : // Line-Style: solid or double
3335 528 : sOut.append(' ');
3336 528 : switch (pLine->GetBorderLineStyle())
3337 : {
3338 : case table::BorderLineStyle::SOLID:
3339 522 : sOut.append(sCSS1_PV_solid);
3340 522 : break;
3341 : case table::BorderLineStyle::DOTTED:
3342 2 : sOut.append(sCSS1_PV_dotted);
3343 2 : break;
3344 : case table::BorderLineStyle::DASHED:
3345 2 : sOut.append(sCSS1_PV_dashed);
3346 2 : break;
3347 : case table::BorderLineStyle::DOUBLE:
3348 : case table::BorderLineStyle::THINTHICK_SMALLGAP:
3349 : case table::BorderLineStyle::THINTHICK_MEDIUMGAP:
3350 : case table::BorderLineStyle::THINTHICK_LARGEGAP:
3351 : case table::BorderLineStyle::THICKTHIN_SMALLGAP:
3352 : case table::BorderLineStyle::THICKTHIN_MEDIUMGAP:
3353 : case table::BorderLineStyle::THICKTHIN_LARGEGAP:
3354 2 : sOut.append(sCSS1_PV_double);
3355 2 : break;
3356 : case table::BorderLineStyle::EMBOSSED:
3357 0 : sOut.append(sCSS1_PV_ridge);
3358 0 : break;
3359 : case table::BorderLineStyle::ENGRAVED:
3360 0 : sOut.append(sCSS1_PV_groove);
3361 0 : break;
3362 : case table::BorderLineStyle::INSET:
3363 0 : sOut.append(sCSS1_PV_inset);
3364 0 : break;
3365 : case table::BorderLineStyle::OUTSET:
3366 0 : sOut.append(sCSS1_PV_outset);
3367 0 : break;
3368 : default:
3369 0 : sOut.append(sCSS1_PV_none);
3370 : }
3371 528 : sOut.append(' ');
3372 :
3373 : // and also the color
3374 528 : sOut.append(lclGetCSS1Color(pLine->GetColor()));
3375 :
3376 528 : rHTMLWrt.OutCSS1_PropertyAscii(pProperty, sOut.makeStringAndClear());
3377 : }
3378 :
3379 524 : Writer& OutCSS1_SvxBox( Writer& rWrt, const SfxPoolItem& rHt )
3380 : {
3381 524 : SwHTMLWriter& rHTMLWrt = (SwHTMLWriter&)rWrt;
3382 :
3383 : // Avoid interference between character and paragraph attributes
3384 528 : if( rHt.Which() < RES_CHRATR_END &&
3385 4 : rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_PARA ) )
3386 0 : return rWrt;
3387 :
3388 524 : if( rHt.Which() == RES_CHRATR_BOX )
3389 : {
3390 4 : if( rHTMLWrt.bTagOn )
3391 : {
3392 : // Inline-block to make the line height changing correspond to the character border
3393 2 : rHTMLWrt.OutCSS1_PropertyAscii(sCSS1_P_display, "inline-block");
3394 : }
3395 : else
3396 : {
3397 2 : HTMLOutFuncs::Out_AsciiTag( rWrt.Strm(), OOO_STRING_SVTOOLS_HTML_span, false );
3398 2 : return rWrt;
3399 : }
3400 : }
3401 :
3402 522 : const SvxBoxItem& rBoxItem = (const SvxBoxItem&)rHt;
3403 522 : const SvxBorderLine *pTop = rBoxItem.GetTop();
3404 522 : const SvxBorderLine *pBottom = rBoxItem.GetBottom();
3405 522 : const SvxBorderLine *pLeft = rBoxItem.GetLeft();
3406 522 : const SvxBorderLine *pRight = rBoxItem.GetRight();
3407 :
3408 1566 : if( (pTop && pBottom && pLeft && pRight &&
3409 2084 : *pTop == *pBottom && *pTop == *pLeft && *pTop == *pRight) ||
3410 0 : (!pTop && !pBottom && !pLeft && !pRight) )
3411 : {
3412 : // all Lines are set and equal, or all Lines are not set
3413 : // => border : ...
3414 520 : OutCSS1_SvxBorderLine( rHTMLWrt, sCSS1_P_border, pTop );
3415 : }
3416 : else
3417 : {
3418 : // otherwise export all Lines separately
3419 2 : OutCSS1_SvxBorderLine( rHTMLWrt, sCSS1_P_border_top, pTop );
3420 2 : OutCSS1_SvxBorderLine( rHTMLWrt, sCSS1_P_border_bottom, pBottom );
3421 2 : OutCSS1_SvxBorderLine( rHTMLWrt, sCSS1_P_border_left, pLeft );
3422 2 : OutCSS1_SvxBorderLine( rHTMLWrt, sCSS1_P_border_right, pRight );
3423 : }
3424 :
3425 522 : long nTopDist = pTop ? rBoxItem.GetDistance( BOX_LINE_TOP ) : 0;
3426 522 : long nBottomDist = pBottom ? rBoxItem.GetDistance( BOX_LINE_BOTTOM ) : 0;
3427 522 : long nLeftDist = pLeft ? rBoxItem.GetDistance( BOX_LINE_LEFT ) : 0;
3428 522 : long nRightDist = pRight ? rBoxItem.GetDistance( BOX_LINE_RIGHT ) : 0;
3429 :
3430 522 : if( nTopDist == nBottomDist && nLeftDist == nRightDist )
3431 : {
3432 0 : OStringBuffer sVal;
3433 0 : AddUnitPropertyValue(sVal, nTopDist, rHTMLWrt.GetCSS1Unit());
3434 0 : if( nTopDist != nLeftDist )
3435 : {
3436 0 : sVal.append(' ');
3437 0 : AddUnitPropertyValue(sVal, nLeftDist, rHTMLWrt.GetCSS1Unit());
3438 : }
3439 0 : rHTMLWrt.OutCSS1_PropertyAscii(sCSS1_P_padding, sVal.makeStringAndClear());
3440 : }
3441 : else
3442 : {
3443 522 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_padding_top, nTopDist );
3444 522 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_padding_bottom, nBottomDist );
3445 522 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_padding_left, nLeftDist );
3446 522 : rHTMLWrt.OutCSS1_UnitProperty( sCSS1_P_padding_right, nRightDist );
3447 : }
3448 :
3449 522 : return rWrt;
3450 : }
3451 :
3452 12 : static Writer& OutCSS1_SvxFrameDirection( Writer& rWrt, const SfxPoolItem& rHt )
3453 : {
3454 12 : SwHTMLWriter& rHTMLWrt = static_cast< SwHTMLWriter& >( rWrt );
3455 :
3456 : // Language will be exported rules only
3457 12 : if( !rHTMLWrt.IsCSS1Source( CSS1_OUTMODE_TEMPLATE ) )
3458 0 : return rWrt;
3459 :
3460 : sal_uInt16 nDir =
3461 12 : static_cast< const SvxFrameDirectionItem& >( rHt ).GetValue();
3462 12 : const sal_Char* pStr = NULL;
3463 12 : switch( nDir )
3464 : {
3465 : case FRMDIR_HORI_LEFT_TOP:
3466 : case FRMDIR_VERT_TOP_LEFT:
3467 12 : pStr = sCSS1_PV_ltr;
3468 12 : break;
3469 : case FRMDIR_HORI_RIGHT_TOP:
3470 : case FRMDIR_VERT_TOP_RIGHT:
3471 0 : pStr = sCSS1_PV_rtl;
3472 0 : break;
3473 : case FRMDIR_ENVIRONMENT:
3474 0 : pStr = sCSS1_PV_inherit;
3475 0 : break;
3476 : }
3477 :
3478 12 : if( pStr )
3479 12 : rHTMLWrt.OutCSS1_PropertyAscii( sCSS1_P_direction, pStr );
3480 :
3481 12 : return rWrt;
3482 : }
3483 :
3484 : /*
3485 : * Place here the table for the HTML-Function-Pointer to the
3486 : * Export-Functions.
3487 : * They are local structures, only needed within the HTML-DLL.
3488 : */
3489 :
3490 : SwAttrFnTab aCSS1AttrFnTab = {
3491 : /* RES_CHRATR_CASEMAP */ OutCSS1_SvxCaseMap,
3492 : /* RES_CHRATR_CHARSETCOLOR */ 0,
3493 : /* RES_CHRATR_COLOR */ OutCSS1_SvxColor,
3494 : /* RES_CHRATR_CONTOUR */ 0,
3495 : /* RES_CHRATR_CROSSEDOUT */ OutCSS1_SvxCrossedOut,
3496 : /* RES_CHRATR_ESCAPEMENT */ 0,
3497 : /* RES_CHRATR_FONT */ OutCSS1_SvxFont,
3498 : /* RES_CHRATR_FONTSIZE */ OutCSS1_SvxFontHeight,
3499 : /* RES_CHRATR_KERNING */ OutCSS1_SvxKerning,
3500 : /* RES_CHRATR_LANGUAGE */ OutCSS1_SvxLanguage,
3501 : /* RES_CHRATR_POSTURE */ OutCSS1_SvxPosture,
3502 : /* RES_CHRATR_PROPORTIONALFONTSIZE*/0,
3503 : /* RES_CHRATR_SHADOWED */ 0,
3504 : /* RES_CHRATR_UNDERLINE */ OutCSS1_SvxUnderline,
3505 : /* RES_CHRATR_WEIGHT */ OutCSS1_SvxFontWeight,
3506 : /* RES_CHRATR_WORDLINEMODE */ 0,
3507 : /* RES_CHRATR_AUTOKERN */ 0,
3508 : /* RES_CHRATR_BLINK */ OutCSS1_SvxBlink,
3509 : /* RES_CHRATR_NOHYPHEN */ 0, // Neu: nicht trennen
3510 : /* RES_CHRATR_NOLINEBREAK */ 0, // Neu: nicht umbrechen
3511 : /* RES_CHRATR_BACKGROUND */ OutCSS1_SvxBrush, // Neu: Zeichenhintergrund
3512 : /* RES_CHRATR_CJK_FONT */ OutCSS1_SvxFont,
3513 : /* RES_CHRATR_CJK_FONTSIZE */ OutCSS1_SvxFontHeight,
3514 : /* RES_CHRATR_CJK_LANGUAGE */ OutCSS1_SvxLanguage,
3515 : /* RES_CHRATR_CJK_POSTURE */ OutCSS1_SvxPosture,
3516 : /* RES_CHRATR_CJK_WEIGHT */ OutCSS1_SvxFontWeight,
3517 : /* RES_CHRATR_CTL_FONT */ OutCSS1_SvxFont,
3518 : /* RES_CHRATR_CTL_FONTSIZE */ OutCSS1_SvxFontHeight,
3519 : /* RES_CHRATR_CTL_LANGUAGE */ OutCSS1_SvxLanguage,
3520 : /* RES_CHRATR_CTL_POSTURE */ OutCSS1_SvxPosture,
3521 : /* RES_CHRATR_CTL_WEIGHT */ OutCSS1_SvxFontWeight,
3522 : /* RES_CHRATR_ROTATE */ 0,
3523 : /* RES_CHRATR_EMPHASIS_MARK */ 0,
3524 : /* RES_CHRATR_TWO_LINES */ 0,
3525 : /* RES_CHRATR_SCALEW */ 0,
3526 : /* RES_CHRATR_RELIEF */ 0,
3527 : /* RES_CHRATR_HIDDEN */ OutCSS1_SvxHidden,
3528 : /* RES_CHRATR_OVERLINE */ OutCSS1_SvxOverline,
3529 : /* RES_CHRATR_RSID */ 0,
3530 : /* RES_CHRATR_BOX */ OutCSS1_SvxBox,
3531 : /* RES_CHRATR_SHADOW */ 0,
3532 : /* RES_CHRATR_HIGHLIGHT */ 0,
3533 : /* RES_CHRATR_GRABBAG */ 0,
3534 : /* RES_CHRATR_BIDIRTL */ 0,
3535 : /* RES_CHRATR_IDCTHINT */ 0,
3536 :
3537 : /* RES_TXTATR_REFMARK */ 0,
3538 : /* RES_TXTATR_TOXMARK */ 0,
3539 : /* RES_TXTATR_META */ 0,
3540 : /* RES_TXTATR_METAFIELD */ 0,
3541 : /* RES_TXTATR_AUTOFMT */ 0,
3542 : /* RES_TXTATR_INETFMT */ 0,
3543 : /* RES_TXTATR_CHARFMT */ 0,
3544 : /* RES_TXTATR_CJK_RUBY */ 0,
3545 : /* RES_TXTATR_UNKNOWN_CONTAINER */ 0,
3546 : /* RES_TXTATR_INPUTFIELD */ 0,
3547 :
3548 : /* RES_TXTATR_FIELD */ 0,
3549 : /* RES_TXTATR_FLYCNT */ 0,
3550 : /* RES_TXTATR_FTN */ 0,
3551 : /* RES_TXTATR_ANNOTATION */ 0,
3552 : /* RES_TXTATR_DUMMY3 */ 0,
3553 : /* RES_TXTATR_DUMMY1 */ 0, // Dummy:
3554 : /* RES_TXTATR_DUMMY2 */ 0, // Dummy:
3555 :
3556 : /* RES_PARATR_LINESPACING */ OutCSS1_SvxLineSpacing,
3557 : /* RES_PARATR_ADJUST */ OutCSS1_SvxAdjust,
3558 : /* RES_PARATR_SPLIT */ OutCSS1_SvxFmtSplit,
3559 : /* RES_PARATR_ORPHANS */ OutCSS1_SvxOrphans,
3560 : /* RES_PARATR_WIDOWS */ OutCSS1_SvxWidows,
3561 : /* RES_PARATR_TABSTOP */ 0,
3562 : /* RES_PARATR_HYPHENZONE*/ 0,
3563 : /* RES_PARATR_DROP */ OutCSS1_SwFmtDrop,
3564 : /* RES_PARATR_REGISTER */ 0, // neu: Registerhaltigkeit
3565 : /* RES_PARATR_NUMRULE */ 0,
3566 : /* RES_PARATR_SCRIPTSPACE */ 0,
3567 : /* RES_PARATR_HANGINGPUNCTUATION */ 0,
3568 : /* RES_PARATR_FORBIDDEN_RULES */ 0, // new
3569 : /* RES_PARATR_VERTALIGN */ 0, // new
3570 : /* RES_PARATR_SNAPTOGRID*/ 0, // new
3571 : /* RES_PARATR_CONNECT_TO_BORDER */ 0, // new
3572 : /* RES_PARATR_OUTLINELEVEL */ 0, // new since cws outlinelevel
3573 : /* RES_PARATR_RSID */ 0, // new
3574 : /* RES_PARATR_GRABBAG */ 0,
3575 :
3576 : /* RES_PARATR_LIST_ID */ 0, // new
3577 : /* RES_PARATR_LIST_LEVEL */ 0, // new
3578 : /* RES_PARATR_LIST_ISRESTART */ 0, // new
3579 : /* RES_PARATR_LIST_RESTARTVALUE */ 0, // new
3580 : /* RES_PARATR_LIST_ISCOUNTED */ 0, // new
3581 :
3582 : /* RES_FILL_ORDER */ 0,
3583 : /* RES_FRM_SIZE */ 0,
3584 : /* RES_PAPER_BIN */ 0,
3585 : /* RES_LR_SPACE */ OutCSS1_SvxLRSpace,
3586 : /* RES_UL_SPACE */ OutCSS1_SvxULSpace,
3587 : /* RES_PAGEDESC */ 0,
3588 : /* RES_BREAK */ 0,
3589 : /* RES_CNTNT */ 0,
3590 : /* RES_HEADER */ 0,
3591 : /* RES_FOOTER */ 0,
3592 : /* RES_PRINT */ 0,
3593 : /* RES_OPAQUE */ 0,
3594 : /* RES_PROTECT */ 0,
3595 : /* RES_SURROUND */ 0,
3596 : /* RES_VERT_ORIENT */ 0,
3597 : /* RES_HORI_ORIENT */ 0,
3598 : /* RES_ANCHOR */ 0,
3599 : /* RES_BACKGROUND */ OutCSS1_SvxBrush,
3600 : /* RES_BOX */ OutCSS1_SvxBox,
3601 : /* RES_SHADOW */ 0,
3602 : /* RES_FRMMACRO */ 0,
3603 : /* RES_COL */ 0,
3604 : /* RES_KEEP */ 0,
3605 : /* RES_URL */ 0,
3606 : /* RES_EDIT_IN_READONLY */ 0,
3607 : /* RES_LAYOUT_SPLIT */ 0,
3608 : /* RES_CHAIN */ 0,
3609 : /* RES_TEXTGRID */ 0,
3610 : /* RES_LINENUMBER */ 0,
3611 : /* RES_FTN_AT_TXTEND */ 0,
3612 : /* RES_END_AT_TXTEND */ 0,
3613 : /* RES_COLUMNBALANCE */ 0,
3614 : /* RES_FRAMEDIR */ OutCSS1_SvxFrameDirection,
3615 : /* RES_HEADER_FOOTER_EAT_SPACING */ 0,
3616 : /* RES_ROW_SPLIT */ 0,
3617 : /* RES_FOLLOW_TEXT_FLOW */ 0,
3618 : /* RES_COLLAPSING_BORDERS */ 0,
3619 : /* RES_WRAP_INFLUENCE_ON_OBJPOS */ 0,
3620 : /* RES_AUTO_STYLE */ 0,
3621 : /* RES_FRMATR_STYLE_NAME */ 0,
3622 : /* RES_FRMATR_CONDITIONAL_STYLE_NAME */ 0,
3623 : /* RES_FRMATR_GRABBAG */ 0,
3624 : /* RES_TEXT_VERT_ADJUST */ 0,
3625 :
3626 : /* RES_GRFATR_MIRRORGRF */ 0,
3627 : /* RES_GRFATR_CROPGRF */ 0,
3628 : /* RES_GRFATR_ROTATION */ 0,
3629 : /* RES_GRFATR_LUMINANCE */ 0,
3630 : /* RES_GRFATR_CONTRAST */ 0,
3631 : /* RES_GRFATR_CHANNELR */ 0,
3632 : /* RES_GRFATR_CHANNELG */ 0,
3633 : /* RES_GRFATR_CHANNELB */ 0,
3634 : /* RES_GRFATR_GAMMA */ 0,
3635 : /* RES_GRFATR_INVERT */ 0,
3636 : /* RES_GRFATR_TRANSPARENCY */ 0,
3637 : /* RES_GRFATR_DRWAMODE */ 0,
3638 : /* RES_GRFATR_DUMMY1 */ 0,
3639 : /* RES_GRFATR_DUMMY2 */ 0,
3640 : /* RES_GRFATR_DUMMY3 */ 0,
3641 : /* RES_GRFATR_DUMMY4 */ 0,
3642 : /* RES_GRFATR_DUMMY5 */ 0,
3643 :
3644 : /* RES_BOXATR_FORMAT */ 0,
3645 : /* RES_BOXATR_FORMULA */ 0,
3646 : /* RES_BOXATR_VALUE */ 0
3647 270 : };
3648 :
3649 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
