1 /*************************************************************************
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 * Copyright 2008 by Sun Microsystems, Inc.
7 * OpenOffice.org - a multi-platform office productivity suite
12 * This file is part of OpenOffice.org.
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
29 ************************************************************************/
31 #include "docxattributeoutput.hxx"
32 #include "docxexport.hxx"
33 #include "docxfootnotes.hxx"
34 #include "writerwordglue.hxx"
38 #include <oox/core/tokens.hxx>
39 #include <oox/export/drawingml.hxx>
40 #include <oox/export/utils.hxx>
41 #include <oox/export/vmlexport.hxx>
43 #include <i18npool/mslangid.hxx>
45 #include <hintids.hxx>
47 #include <svtools/poolitem.hxx>
49 #include <svx/fontitem.hxx>
50 #include <svx/tstpitem.hxx>
51 #include <svx/adjitem.hxx>
52 #include <svx/spltitem.hxx>
53 #include <svx/widwitem.hxx>
54 #include <svx/lspcitem.hxx>
55 #include <svx/keepitem.hxx>
56 #include <svx/shaditem.hxx>
57 #include <svx/brshitem.hxx>
58 #include <svx/postitem.hxx>
59 #include <svx/wghtitem.hxx>
60 #include <svx/kernitem.hxx>
61 #include <svx/crsditem.hxx>
62 #include <svx/cmapitem.hxx>
63 #include <svx/wrlmitem.hxx>
64 #include <svx/udlnitem.hxx>
65 #include <svx/langitem.hxx>
66 #include <svx/escpitem.hxx>
67 #include <svx/fhgtitem.hxx>
68 #include <svx/colritem.hxx>
69 #include <svx/hyznitem.hxx>
70 #include <svx/brkitem.hxx>
71 #include <svx/lrspitem.hxx>
72 #include <svx/ulspitem.hxx>
73 #include <svx/boxitem.hxx>
74 #include <svx/cntritem.hxx>
75 #include <svx/shdditem.hxx>
76 #include <svx/akrnitem.hxx>
77 #include <svx/pbinitem.hxx>
78 #include <svx/emphitem.hxx>
79 #include <svx/twolinesitem.hxx>
80 #include <svx/charscaleitem.hxx>
81 #include <svx/charrotateitem.hxx>
82 #include <svx/charreliefitem.hxx>
83 #include <svx/paravertalignitem.hxx>
84 #include <svx/pgrditem.hxx>
85 #include <svx/frmdiritem.hxx>
86 #include <svx/blnkitem.hxx>
87 #include <svx/charhiddenitem.hxx>
88 #include <svx/svdmodel.hxx>
89 #include <svx/svdobj.hxx>
91 #include <docufld.hxx>
92 #include <flddropdown.hxx>
94 #include <fmtclds.hxx>
95 #include <fmtinfmt.hxx>
97 #include <fmtfsize.hxx>
99 #include <fmtrowsplt.hxx>
100 #include <fmtline.hxx>
101 #include <frmfmt.hxx>
102 #include <frmatr.hxx>
103 #include <ftninfo.hxx>
104 #include <htmltbl.hxx>
108 #include <pagedesc.hxx>
109 #include <paratr.hxx>
110 #include <swmodule.hxx>
111 #include <swtable.hxx>
112 #include <txtftn.hxx>
113 #include <txtinet.hxx>
114 #include <numrule.hxx>
116 #include <rtl/strbuf.hxx>
117 #include <rtl/ustrbuf.hxx>
118 #include <rtl/ustring.hxx>
120 #include <tools/color.hxx>
122 #include <com/sun/star/i18n/ScriptType.hdl>
124 #if OSL_DEBUG_LEVEL > 0
129 using rtl::OStringBuffer
;
131 using rtl::OUStringBuffer
;
132 using rtl::OUStringToOString
;
134 using namespace docx
;
135 using namespace sax_fastparser
;
136 using namespace nsSwDocInfoSubType
;
137 using namespace nsFieldFlags
;
138 using namespace sw::util
;
140 void DocxAttributeOutput::RTLAndCJKState( bool bIsRTL
, sal_uInt16
/*nScript*/ )
143 m_pSerializer
->singleElementNS( XML_w
, XML_rtl
, FSNS( XML_w
, XML_val
), "true", FSEND
);
146 void DocxAttributeOutput::StartParagraph( ww8::WW8TableNodeInfo::Pointer_t pTextNodeInfo
)
148 if ( m_nColBreakStatus
== COLBRK_POSTPONE
)
149 m_nColBreakStatus
= COLBRK_WRITE
;
151 // Output table/table row/table cell starts if needed
152 if ( pTextNodeInfo
.get() )
154 sal_uInt32 nRow
= pTextNodeInfo
->getRow();
155 sal_uInt32 nCell
= pTextNodeInfo
->getCell();
158 if ( m_nTableDepth
> 0 && !m_bTableCellOpen
)
160 ww8::WW8TableNodeInfoInner::Pointer_t
pDeepInner( pTextNodeInfo
->getInnerForDepth( m_nTableDepth
) );
161 if ( pDeepInner
->getCell() == 0 )
162 StartTableRow( pDeepInner
);
164 StartTableCell( pDeepInner
);
167 if ( nRow
== 0 && nCell
== 0 )
169 // Do we have to start the table?
170 // [If we are at the rigth depth already, it means that we
171 // continue the table cell]
172 sal_uInt32 nCurrentDepth
= pTextNodeInfo
->getDepth();
174 if ( nCurrentDepth
> m_nTableDepth
)
176 // Start all the tables that begin here
177 for ( sal_uInt32 nDepth
= m_nTableDepth
+ 1; nDepth
<= pTextNodeInfo
->getDepth(); ++nDepth
)
179 ww8::WW8TableNodeInfoInner::Pointer_t
pInner( pTextNodeInfo
->getInnerForDepth( nDepth
) );
181 StartTable( pInner
);
182 StartTableRow( pInner
);
183 StartTableCell( pInner
);
186 m_nTableDepth
= nCurrentDepth
;
191 m_pSerializer
->startElementNS( XML_w
, XML_p
, FSEND
);
193 // postpone the output of the run (we get it before the paragraph
194 // properties, but must write it after them)
195 m_pSerializer
->mark();
197 // no section break in this paragraph yet; can be set in SectionBreak()
198 m_pSectionInfo
= NULL
;
200 m_bParagraphOpened
= true;
203 void DocxAttributeOutput::EndParagraph( ww8::WW8TableNodeInfoInner::Pointer_t pTextNodeInfoInner
)
205 // write the paragraph properties + the run, already in the correct order
206 m_pSerializer
->mergeTopMarks();
207 m_pSerializer
->endElementNS( XML_w
, XML_p
);
209 // Check for end of cell, rows, tables here
210 FinishTableRowCell( pTextNodeInfoInner
);
212 m_bParagraphOpened
= false;
215 void DocxAttributeOutput::FinishTableRowCell( ww8::WW8TableNodeInfoInner::Pointer_t pInner
, bool bForceEmptyParagraph
)
219 // Where are we in the table
220 sal_uInt32 nRow
= pInner
->getRow( );
222 const SwTable
*pTable
= pInner
->getTable( );
223 const SwTableLines
& rLines
= pTable
->GetTabLines( );
224 USHORT nLinesCount
= rLines
.Count( );
226 if ( pInner
->isEndOfCell() )
228 if ( bForceEmptyParagraph
)
229 m_pSerializer
->singleElementNS( XML_w
, XML_p
, FSEND
);
234 // This is a line end
235 if ( pInner
->isEndOfLine() )
238 // This is the end of the table
239 if ( pInner
->isEndOfLine( ) && ( nRow
+ 1 ) == nLinesCount
)
244 void DocxAttributeOutput::EmptyParagraph()
246 m_pSerializer
->singleElementNS( XML_w
, XML_p
, FSEND
);
249 void DocxAttributeOutput::StartParagraphProperties( const SwTxtNode
& rNode
)
251 // output page/section breaks
252 // Writer can have them at the beginning of a paragraph, or at the end, but
253 // in docx, we have to output them in the paragraph properties of the last
254 // paragraph in a section. To get it right, we have to switch to the next
255 // paragraph, and detect the section breaks there.
256 SwNodeIndex
aNextIndex( rNode
, 1 );
257 if ( aNextIndex
.GetNode().IsTxtNode() )
259 const SwTxtNode
* pTxtNode
= static_cast< SwTxtNode
* >( &aNextIndex
.GetNode() );
260 m_rExport
.OutputSectionBreaks( pTxtNode
->GetpSwAttrSet(), *pTxtNode
);
262 else if ( aNextIndex
.GetNode().IsTableNode() )
264 const SwTableNode
* pTableNode
= static_cast< SwTableNode
* >( &aNextIndex
.GetNode() );
265 const SwFrmFmt
*pFmt
= pTableNode
->GetTable().GetFrmFmt();
266 m_rExport
.OutputSectionBreaks( &(pFmt
->GetAttrSet()), *pTableNode
);
269 // postpone the output so that we can later [in EndParagraphProperties()]
270 // prepend the properties before the run
271 m_pSerializer
->mark();
273 m_pSerializer
->startElementNS( XML_w
, XML_pPr
, FSEND
);
275 // and output the section break now (if it appeared)
276 if ( m_pSectionInfo
)
278 m_rExport
.SectionProperties( *m_pSectionInfo
);
279 m_pSectionInfo
= NULL
;
282 InitCollectedParagraphProperties();
285 void DocxAttributeOutput::InitCollectedParagraphProperties()
287 m_pSpacingAttrList
= NULL
;
290 void DocxAttributeOutput::WriteCollectedParagraphProperties()
292 if ( m_pSpacingAttrList
)
294 XFastAttributeListRef
xAttrList( m_pSpacingAttrList
);
295 m_pSpacingAttrList
= NULL
;
297 m_pSerializer
->singleElementNS( XML_w
, XML_spacing
, xAttrList
);
301 void DocxAttributeOutput::EndParagraphProperties()
303 WriteCollectedParagraphProperties();
305 m_pSerializer
->endElementNS( XML_w
, XML_pPr
);
307 if ( m_nColBreakStatus
== COLBRK_WRITE
)
309 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
310 m_pSerializer
->singleElementNS( XML_w
, XML_br
,
311 FSNS( XML_w
, XML_type
), "column", FSEND
);
312 m_pSerializer
->endElementNS( XML_w
, XML_r
);
314 m_nColBreakStatus
= COLBRK_NONE
;
317 // merge the properties _before_ the run (strictly speaking, just
318 // after the start of the paragraph)
319 m_pSerializer
->mergeTopMarks( sax_fastparser::MERGE_MARKS_PREPEND
);
322 void DocxAttributeOutput::StartRun( const SwRedlineData
* pRedlineData
)
324 // if there is some redlining in the document, output it
325 StartRedline( pRedlineData
);
327 // postpone the output of the start of a run (there are elements that need
328 // to be written before the start of the run, but we learn which they are
329 // _inside_ of the run)
330 m_pSerializer
->mark(); // let's call it "postponed run start"
332 // postpone the output of the text (we get it before the run properties,
333 // but must write it after them)
334 m_pSerializer
->mark(); // let's call it "postponed text"
337 void DocxAttributeOutput::EndRun()
339 // Write field starts
340 for ( std::vector
<FieldInfos
>::iterator pIt
= m_Fields
.begin(); pIt
!= m_Fields
.end(); ++pIt
)
342 // Add the fields starts for all but hyperlinks and TOCs
343 if ( pIt
->bOpen
&& pIt
->pField
)
345 StartField_Impl( *pIt
);
347 // Remove the field from the stack if only the start has to be written
348 // Unknown fields sould be removed too
349 if ( !pIt
->bClose
|| ( pIt
->eType
== ww::eUNKNOWN
) )
351 m_Fields
.erase( pIt
);
358 // write the run properties + the text, already in the correct order
359 m_pSerializer
->mergeTopMarks(); // merges with "postponed text", see above
361 // level down, to be able to prepend the actual run start attribute (just
362 // before "postponed run start")
363 m_pSerializer
->mark(); // let's call it "actual run start"
365 // prepend the actual run start
366 if ( m_pHyperlinkAttrList
)
368 XFastAttributeListRef
xAttrList ( m_pHyperlinkAttrList
);
370 m_pSerializer
->startElementNS( XML_w
, XML_hyperlink
, xAttrList
);
373 // Write the hyperlink and toc fields starts
374 for ( std::vector
<FieldInfos
>::iterator pIt
= m_Fields
.begin(); pIt
!= m_Fields
.end(); ++pIt
)
376 // Add the fields starts for hyperlinks, TOCs and index marks
379 StartField_Impl( *pIt
, sal_True
);
381 // Remove the field if no end needs to be written
382 if ( !pIt
->bClose
) {
383 m_Fields
.erase( pIt
);
391 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
392 m_pSerializer
->mergeTopMarks( sax_fastparser::MERGE_MARKS_PREPEND
); // merges with "postponed run start", see above
394 // write the run start + the run content
395 m_pSerializer
->mergeTopMarks(); // merges the "actual run start"
397 // append the actual run end
398 m_pSerializer
->endElementNS( XML_w
, XML_r
);
400 if ( m_pHyperlinkAttrList
)
402 m_pSerializer
->endElementNS( XML_w
, XML_hyperlink
);
403 m_pHyperlinkAttrList
= NULL
;
406 while ( m_Fields
.begin() != m_Fields
.end() )
408 EndField_Impl( m_Fields
.front( ) );
409 m_Fields
.erase( m_Fields
.begin( ) );
412 // if there is some redlining in the document, output it
416 void DocxAttributeOutput::DoWriteBookmarks()
418 // Write the start bookmarks
419 for ( std::vector
< OString
>::const_iterator it
= m_rMarksStart
.begin(), end
= m_rMarksStart
.end();
422 const OString
& rName
= *it
;
424 // Output the bookmark
425 USHORT nId
= m_nNextMarkId
++;
426 m_rOpenedMarksIds
[rName
] = nId
;
427 m_pSerializer
->singleElementNS( XML_w
, XML_bookmarkStart
,
428 FSNS( XML_w
, XML_id
), OString::valueOf( sal_Int32( nId
) ).getStr( ),
429 FSNS( XML_w
, XML_name
), rName
.getStr(),
432 m_rMarksStart
.clear();
434 // export the end bookmarks
435 for ( std::vector
< OString
>::const_iterator it
= m_rMarksEnd
.begin(), end
= m_rMarksEnd
.end();
438 const OString
& rName
= *it
;
440 // Get the id of the bookmark
441 std::map
< OString
, USHORT
>::iterator pPos
= m_rOpenedMarksIds
.find( rName
);
442 if ( pPos
!= m_rOpenedMarksIds
.end( ) )
444 USHORT nId
= ( *pPos
).second
;
445 m_pSerializer
->singleElementNS( XML_w
, XML_bookmarkEnd
,
446 FSNS( XML_w
, XML_id
), OString::valueOf( sal_Int32( nId
) ).getStr( ),
448 m_rOpenedMarksIds
.erase( rName
);
454 void DocxAttributeOutput::StartField_Impl( FieldInfos
& rInfos
, sal_Bool bWriteRun
)
456 if ( rInfos
.pField
&& rInfos
.eType
== ww::eUNKNOWN
)
458 // Expand unsupported fields
459 RunText( rInfos
.pField
->Expand( ) );
461 else if ( rInfos
.eType
!= ww::eNONE
) // HYPERLINK fields are just commands
464 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
466 if ( rInfos
.eType
== ww::eFORMDROPDOWN
)
468 m_pSerializer
->startElementNS( XML_w
, XML_fldChar
,
469 FSNS( XML_w
, XML_fldCharType
), "begin",
472 const SwDropDownField
& rFld2
= *(SwDropDownField
*)rInfos
.pField
;
473 uno::Sequence
<rtl::OUString
> aItems
=
474 rFld2
.GetItemSequence();
475 GetExport().DoComboBox(rFld2
.GetName(),
478 rFld2
.GetSelectedItem(), aItems
);
480 m_pSerializer
->endElementNS( XML_w
, XML_fldChar
);
483 m_pSerializer
->endElementNS( XML_w
, XML_r
);
488 // Write the field start
489 m_pSerializer
->singleElementNS( XML_w
, XML_fldChar
,
490 FSNS( XML_w
, XML_fldCharType
), "begin",
494 m_pSerializer
->endElementNS( XML_w
, XML_r
);
496 // The hyperlinks fields can't be expanded: the value is
497 // normally in the text run
498 if ( !rInfos
.pField
)
499 CmdField_Impl( rInfos
);
504 void DocxAttributeOutput::DoWriteCmd( String
& rCmd
)
506 // Write the Field command
507 m_pSerializer
->startElementNS( XML_w
, XML_instrText
, FSEND
);
508 m_pSerializer
->writeEscaped( OUString( rCmd
) );
509 m_pSerializer
->endElementNS( XML_w
, XML_instrText
);
513 void DocxAttributeOutput::CmdField_Impl( FieldInfos
& rInfos
)
515 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
516 xub_StrLen nNbToken
= rInfos
.sCmd
.GetTokenCount( '\t' );
518 for ( xub_StrLen i
= 0; i
< nNbToken
; i
++ )
520 String sToken
= rInfos
.sCmd
.GetToken( i
, '\t' );
521 // Write the Field command
522 DoWriteCmd( sToken
);
524 // Replace tabs by </instrText><tab/><instrText>
525 if ( i
< ( nNbToken
- 1 ) )
526 RunText( String::CreateFromAscii( "\t" ) );
529 m_pSerializer
->endElementNS( XML_w
, XML_r
);
532 // Write the Field separator
533 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
534 m_pSerializer
->singleElementNS( XML_w
, XML_fldChar
,
535 FSNS( XML_w
, XML_fldCharType
), "separate",
537 m_pSerializer
->endElementNS( XML_w
, XML_r
);
540 void DocxAttributeOutput::EndField_Impl( FieldInfos
& rInfos
)
542 // The command has to be written before for the hyperlinks
545 CmdField_Impl( rInfos
);
548 // Write the bookmark start if any
549 OUString
aBkmName( m_sFieldBkm
);
550 if ( aBkmName
.getLength( ) > 0 )
552 m_pSerializer
->singleElementNS( XML_w
, XML_bookmarkStart
,
553 FSNS( XML_w
, XML_id
), OString::valueOf( sal_Int32( m_nNextMarkId
) ).getStr( ),
554 FSNS( XML_w
, XML_name
), OUStringToOString( aBkmName
, RTL_TEXTENCODING_UTF8
).getStr( ),
558 if (rInfos
.pField
) // For hyperlinks and TOX
560 // Write the Field latest value
561 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
563 // Find another way for hyperlinks
564 RunText( rInfos
.pField
->Expand( ) );
565 m_pSerializer
->endElementNS( XML_w
, XML_r
);
568 // Write the bookmark end if any
569 if ( aBkmName
.getLength( ) > 0 )
571 m_pSerializer
->singleElementNS( XML_w
, XML_bookmarkEnd
,
572 FSNS( XML_w
, XML_id
), OString::valueOf( sal_Int32( m_nNextMarkId
) ).getStr( ),
578 // Write the Field end
579 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
580 m_pSerializer
->singleElementNS( XML_w
, XML_fldChar
,
581 FSNS( XML_w
, XML_fldCharType
), "end",
583 m_pSerializer
->endElementNS( XML_w
, XML_r
);
586 // Write the ref field if a bookmark had to be set and the field
590 USHORT nSubType
= rInfos
.pField
->GetSubType( );
591 bool bIsSetField
= rInfos
.pField
->GetTyp( )->Which( ) == RES_SETEXPFLD
;
592 bool bShowRef
= ( !bIsSetField
|| ( nSubType
& nsSwExtendedSubType::SUB_INVISIBLE
) ) ? false : true;
594 if ( ( m_sFieldBkm
.Len( ) > 0 ) && bShowRef
)
596 // Write the field beginning
597 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
598 m_pSerializer
->singleElementNS( XML_w
, XML_fldChar
,
599 FSNS( XML_w
, XML_fldCharType
), "begin",
601 m_pSerializer
->endElementNS( XML_w
, XML_r
);
603 rInfos
.sCmd
= FieldString( ww::eREF
);
604 rInfos
.sCmd
.APPEND_CONST_ASC( "\"" );
605 rInfos
.sCmd
+= m_sFieldBkm
;
606 rInfos
.sCmd
.APPEND_CONST_ASC( "\" " );
608 // Clean the field bookmark data to avoid infinite loop
609 m_sFieldBkm
= String( );
611 // Write the end of the field
612 EndField_Impl( rInfos
);
617 void DocxAttributeOutput::StartRunProperties()
619 // postpone the output so that we can later [in EndRunProperties()]
620 // prepend the properties before the text
621 m_pSerializer
->mark();
623 m_pSerializer
->startElementNS( XML_w
, XML_rPr
, FSEND
);
625 InitCollectedRunProperties();
628 void DocxAttributeOutput::InitCollectedRunProperties()
630 m_pFontsAttrList
= NULL
;
631 m_pEastAsianLayoutAttrList
= NULL
;
632 m_pCharLangAttrList
= NULL
;
635 void DocxAttributeOutput::WriteCollectedRunProperties()
637 // Write all differed properties
638 if ( m_pFontsAttrList
)
640 XFastAttributeListRef
xAttrList( m_pFontsAttrList
);
641 m_pFontsAttrList
= NULL
;
643 m_pSerializer
->singleElementNS( XML_w
, XML_rFonts
, xAttrList
);
646 if ( m_pEastAsianLayoutAttrList
)
648 XFastAttributeListRef
xAttrList( m_pEastAsianLayoutAttrList
);
649 m_pEastAsianLayoutAttrList
= NULL
;
651 m_pSerializer
->singleElementNS( XML_w
, XML_eastAsianLayout
, xAttrList
);
654 if ( m_pCharLangAttrList
)
656 XFastAttributeListRef
xAttrList( m_pCharLangAttrList
);
657 m_pCharLangAttrList
= NULL
;
659 m_pSerializer
->singleElementNS( XML_w
, XML_lang
, xAttrList
);
663 void DocxAttributeOutput::EndRunProperties( const SwRedlineData
* /*pRedlineData*/ )
665 WriteCollectedRunProperties();
667 m_pSerializer
->endElementNS( XML_w
, XML_rPr
);
669 // write footnotes/endnotes if we have any
670 FootnoteEndnoteReference();
672 // merge the properties _before_ the run text (strictly speaking, just
673 // after the start of the run)
674 m_pSerializer
->mergeTopMarks( sax_fastparser::MERGE_MARKS_PREPEND
);
677 /** Output sal_Unicode* as a run text (<t>the text</t>).
679 When bMove is true, update rBegin to point _after_ the end of the text +
680 1, meaning that it skips one character after the text. This is to make
681 the switch in DocxAttributeOutput::RunText() nicer ;-)
683 static void impl_WriteRunText( FSHelperPtr pSerializer
, sal_Int32 nTextToken
,
684 const sal_Unicode
* &rBegin
, const sal_Unicode
* pEnd
, bool bMove
= true )
686 const sal_Unicode
*pBegin
= rBegin
;
688 // skip one character after the end
692 if ( pBegin
>= pEnd
)
693 return; // we want to write at least one character
695 // we have to add 'preserve' when starting/ending with space
696 if ( *pBegin
== sal_Unicode( ' ' ) || *( pEnd
- 1 ) == sal_Unicode( ' ' ) )
698 pSerializer
->startElementNS( XML_w
, nTextToken
, FSNS( XML_xml
, XML_space
), "preserve", FSEND
);
701 pSerializer
->startElementNS( XML_w
, nTextToken
, FSEND
);
703 pSerializer
->writeEscaped( OUString( pBegin
, pEnd
- pBegin
) );
705 pSerializer
->endElementNS( XML_w
, nTextToken
);
708 void DocxAttributeOutput::RunText( const String
& rText
, rtl_TextEncoding
/*eCharSet*/ )
710 OUString
aText( rText
);
712 // one text can be split into more <w:t>blah</w:t>'s by line breaks etc.
713 const sal_Unicode
*pBegin
= aText
.getStr();
714 const sal_Unicode
*pEnd
= pBegin
+ aText
.getLength();
716 // the text run is usually XML_t, with the exception of the deleted text
717 sal_Int32 nTextToken
= XML_t
;
718 if ( m_pRedlineData
&& m_pRedlineData
->GetType() == nsRedlineType_t::REDLINE_DELETE
)
719 nTextToken
= XML_delText
;
721 for ( const sal_Unicode
*pIt
= pBegin
; pIt
< pEnd
; ++pIt
)
726 impl_WriteRunText( m_pSerializer
, nTextToken
, pBegin
, pIt
);
727 m_pSerializer
->singleElementNS( XML_w
, XML_tab
, FSEND
);
729 case 0x0b: // line break
730 impl_WriteRunText( m_pSerializer
, nTextToken
, pBegin
, pIt
);
731 m_pSerializer
->singleElementNS( XML_w
, XML_br
, FSEND
);
734 if ( *pIt
< 0x0020 ) // filter out the control codes
736 impl_WriteRunText( m_pSerializer
, nTextToken
, pBegin
, pIt
);
737 #if OSL_DEBUG_LEVEL > 0
738 fprintf( stderr
, "Ignored control code %x in a text run.", *pIt
);
745 impl_WriteRunText( m_pSerializer
, nTextToken
, pBegin
, pEnd
, false );
748 void DocxAttributeOutput::RawText( const String
& /*rText*/, bool /*bForceUnicode*/, rtl_TextEncoding
/*eCharSet*/ )
750 #if OSL_DEBUG_LEVEL > 0
751 fprintf( stderr
, "TODO DocxAttributeOutput::RawText( const String& rText, bool bForceUnicode, rtl_TextEncoding eCharSet )\n" );
755 void DocxAttributeOutput::StartRuby( const SwTxtNode
& /*rNode*/, const SwFmtRuby
& /*rRuby*/ )
757 #if OSL_DEBUG_LEVEL > 0
758 fprintf( stderr
, "TODO DocxAttributeOutput::StartRuby( const SwTxtNode& rNode, const SwFmtRuby& rRuby )\n" );
762 void DocxAttributeOutput::EndRuby()
764 #if OSL_DEBUG_LEVEL > 0
765 fprintf( stderr
, "TODO DocxAttributeOutput::EndRuby()\n" );
769 bool DocxAttributeOutput::AnalyzeURL( const String
& rUrl
, const String
& rTarget
, String
* pLinkURL
, String
* pMark
)
771 bool bBookMarkOnly
= AttributeOutputBase::AnalyzeURL( rUrl
, rTarget
, pLinkURL
, pMark
);
773 String sURL
= *pLinkURL
;
774 String sMark
= *pMark
;
776 bool bOutputField
= sMark
.Len();
781 sURL
= FieldString( ww::eHYPERLINK
);
784 String
sFld( FieldString( ww::eHYPERLINK
) );
785 sFld
.APPEND_CONST_ASC( "\"" );
786 sURL
.Insert( sFld
, 0 );
791 ( ( sURL
.APPEND_CONST_ASC( " \\l \"" ) ) += sMark
) += '\"';
794 ( sURL
.APPEND_CONST_ASC( " \\n " ) ) += rTarget
;
800 return bBookMarkOnly
;
803 bool DocxAttributeOutput::StartURL( const String
& rUrl
, const String
& rTarget
)
808 bool bBookmarkOnly
= AnalyzeURL( rUrl
, rTarget
, &sUrl
, &sMark
);
810 if ( sMark
.Len() && !bBookmarkOnly
)
812 m_rExport
.OutputField( NULL
, ww::eHYPERLINK
, sUrl
);
816 // Output a hyperlink XML element
818 m_pHyperlinkAttrList
= m_pSerializer
->createAttrList();
819 if ( !bBookmarkOnly
)
821 OUString
osUrl( sUrl
);
823 ::rtl::OString sId
= m_rExport
.AddRelation(
824 S( "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" ),
825 osUrl
, S("External") );
826 m_pHyperlinkAttrList
->add( FSNS( XML_r
, XML_id
), sId
.getStr());
829 m_pHyperlinkAttrList
->add( FSNS( XML_w
, XML_anchor
),
830 OUStringToOString( OUString( sMark
), RTL_TEXTENCODING_UTF8
).getStr( ) );
832 OUString
sTarget( rTarget
);
833 if ( sTarget
.getLength( ) > 0 )
835 OString soTarget
= OUStringToOString( sTarget
, RTL_TEXTENCODING_UTF8
);
836 m_pHyperlinkAttrList
->add(FSNS( XML_w
, XML_tgtFrame
), soTarget
.getStr());
843 bool DocxAttributeOutput::EndURL()
848 void DocxAttributeOutput::FieldVanish( const String
& rTxt
, ww::eField eType
)
850 WriteField_Impl( NULL
, eType
, rTxt
, WRITEFIELD_ALL
);
853 void DocxAttributeOutput::Redline( const SwRedlineData
* /*pRedline*/ )
855 #if OSL_DEBUG_LEVEL > 0
856 fprintf( stderr
, "TODO DocxAttributeOutput::Redline( const SwRedlineData* pRedline )\n" );
860 /// Append the number as 2-digit when less than 10.
861 static void impl_AppendTwoDigits( OStringBuffer
&rBuffer
, sal_Int32 nNum
)
863 if ( nNum
< 0 || nNum
> 99 )
865 rBuffer
.append( "00" );
870 rBuffer
.append( '0' );
872 rBuffer
.append( nNum
);
875 /** Convert DateTime to xsd::dateTime string.
877 I guess there must be an implementation of this somewhere in OOo, but I failed
878 to find it, unfortunately :-(
880 static OString
impl_DateTimeToOString( const DateTime
& rDateTime
)
882 DateTime
aInUTC( rDateTime
);
883 aInUTC
.ConvertToUTC();
885 OStringBuffer
aBuffer( 25 );
886 aBuffer
.append( sal_Int32( aInUTC
.GetYear() ) );
887 aBuffer
.append( '-' );
889 impl_AppendTwoDigits( aBuffer
, aInUTC
.GetMonth() );
890 aBuffer
.append( '-' );
892 impl_AppendTwoDigits( aBuffer
, aInUTC
.GetDay() );
893 aBuffer
.append( 'T' );
895 impl_AppendTwoDigits( aBuffer
, aInUTC
.GetHour() );
896 aBuffer
.append( ':' );
898 impl_AppendTwoDigits( aBuffer
, aInUTC
.GetMin() );
899 aBuffer
.append( ':' );
901 impl_AppendTwoDigits( aBuffer
, aInUTC
.GetSec() );
902 aBuffer
.append( 'Z' ); // we are in UTC
904 return aBuffer
.makeStringAndClear();
907 void DocxAttributeOutput::StartRedline( const SwRedlineData
* pRedlineData
)
909 m_pRedlineData
= pRedlineData
;
911 if ( !m_pRedlineData
)
914 // FIXME check if it's necessary to travel over the Next()'s in pRedlineData
916 OString
aId( OString::valueOf( m_nRedlineId
++ ) );
918 const String
&rAuthor( SW_MOD()->GetRedlineAuthor( pRedlineData
->GetAuthor() ) );
919 OString
aAuthor( OUStringToOString( rAuthor
, RTL_TEXTENCODING_UTF8
) );
921 OString
aDate( impl_DateTimeToOString( pRedlineData
->GetTimeStamp() ) );
923 switch ( pRedlineData
->GetType() )
925 case nsRedlineType_t::REDLINE_INSERT
:
926 m_pSerializer
->startElementNS( XML_w
, XML_ins
,
927 FSNS( XML_w
, XML_id
), aId
.getStr(),
928 FSNS( XML_w
, XML_author
), aAuthor
.getStr(),
929 FSNS( XML_w
, XML_date
), aDate
.getStr(),
933 case nsRedlineType_t::REDLINE_DELETE
:
934 m_pSerializer
->startElementNS( XML_w
, XML_del
,
935 FSNS( XML_w
, XML_id
), aId
.getStr(),
936 FSNS( XML_w
, XML_author
), aAuthor
.getStr(),
937 FSNS( XML_w
, XML_date
), aDate
.getStr(),
941 case nsRedlineType_t::REDLINE_FORMAT
:
942 #if OSL_DEBUG_LEVEL > 0
943 fprintf( stderr
, "TODO DocxAttributeOutput::StartRedline()\n" );
950 void DocxAttributeOutput::EndRedline()
952 if ( !m_pRedlineData
)
955 switch ( m_pRedlineData
->GetType() )
957 case nsRedlineType_t::REDLINE_INSERT
:
958 m_pSerializer
->endElementNS( XML_w
, XML_ins
);
961 case nsRedlineType_t::REDLINE_DELETE
:
962 m_pSerializer
->endElementNS( XML_w
, XML_del
);
965 case nsRedlineType_t::REDLINE_FORMAT
:
966 #if OSL_DEBUG_LEVEL > 0
967 fprintf( stderr
, "TODO DocxAttributeOutput::EndRedline()\n" );
974 m_pRedlineData
= NULL
;
977 void DocxAttributeOutput::FormatDrop( const SwTxtNode
& /*rNode*/, const SwFmtDrop
& /*rSwFmtDrop*/, USHORT
/*nStyle*/, ww8::WW8TableNodeInfo::Pointer_t
/*pTextNodeInfo*/, ww8::WW8TableNodeInfoInner::Pointer_t
)
979 #if OSL_DEBUG_LEVEL > 0
980 fprintf( stderr
, "TODO DocxAttributeOutput::FormatDrop( const SwTxtNode& rNode, const SwFmtDrop& rSwFmtDrop, USHORT nStyle )\n" );
984 void DocxAttributeOutput::ParagraphStyle( USHORT nStyle
)
986 OString
aStyleId( "style" );
987 aStyleId
+= OString::valueOf( sal_Int32( nStyle
) );
989 m_pSerializer
->singleElementNS( XML_w
, XML_pStyle
, FSNS( XML_w
, XML_val
), aStyleId
.getStr(), FSEND
);
993 void DocxAttributeOutput::InTable()
995 #if OSL_DEBUG_LEVEL > 0
996 fprintf( stderr
, "TODO DocxAttributeOutput::InTable()\n" );
1001 void DocxAttributeOutput::TableRowProperties( bool /*bHeader*/, long /*nCellHeight*/, bool /*bCannotSplit*/, bool /*bRightToLeft*/ )
1003 #if OSL_DEBUG_LEVEL > 0
1004 fprintf( stderr
, "TODO DocxAttributeOutput::TableRowProperties()\n" );
1009 static OString
impl_ConvertColor( const Color
&rColor
)
1011 OString
color( "auto" );
1012 if ( rColor
.GetColor() != COL_AUTO
)
1014 const char pHexDigits
[] = "0123456789ABCDEF";
1015 char pBuffer
[] = "000000";
1017 pBuffer
[0] = pHexDigits
[ ( rColor
.GetRed() >> 4 ) & 0x0F ];
1018 pBuffer
[1] = pHexDigits
[ rColor
.GetRed() & 0x0F ];
1019 pBuffer
[2] = pHexDigits
[ ( rColor
.GetGreen() >> 4 ) & 0x0F ];
1020 pBuffer
[3] = pHexDigits
[ rColor
.GetGreen() & 0x0F ];
1021 pBuffer
[4] = pHexDigits
[ ( rColor
.GetBlue() >> 4 ) & 0x0F ];
1022 pBuffer
[5] = pHexDigits
[ rColor
.GetBlue() & 0x0F ];
1024 color
= OString( pBuffer
);
1029 static void impl_borderLine( FSHelperPtr pSerializer
, sal_Int32 elementToken
, const SvxBorderLine
* pBorderLine
, USHORT nDist
)
1031 FastAttributeList
* pAttr
= pSerializer
->createAttrList();
1033 USHORT inW
= pBorderLine
->GetInWidth();
1034 USHORT outW
= pBorderLine
->GetOutWidth();
1035 USHORT nWidth
= inW
+ outW
;
1037 // Compute val attribute value
1040 // basicWideOutline, basicWideInline
1041 // OOXml also supports those types of borders, but we'll try to play with the first ones.
1042 // thickThinMediumGap, thickThinLargeGap, thickThinSmallGap
1043 // thinThickLargeGap, thinThickMediumGap, thinThickSmallGap
1044 const char* pVal
= "single";
1045 if ( pBorderLine
->isDouble() )
1048 pVal
= ( sal_Char
* )"double";
1049 else if ( inW
> outW
)
1051 pVal
= ( sal_Char
* )"thinThickMediumGap";
1053 else if ( inW
< outW
)
1055 pVal
= ( sal_Char
* )"thickThinMediumGap";
1059 pAttr
->add( FSNS( XML_w
, XML_val
), OString( pVal
) );
1061 // Compute the sz attribute
1063 // The unit is the 8th of point
1064 nWidth
= sal_Int32( nWidth
/ 2.5 );
1065 USHORT nMinWidth
= 2;
1066 USHORT nMaxWidth
= 96;
1068 if ( nWidth
> nMaxWidth
)
1070 else if ( nWidth
< nMinWidth
)
1073 pAttr
->add( FSNS( XML_w
, XML_sz
), OString::valueOf( sal_Int32( nWidth
) ) );
1075 // Get the distance (in pt)
1076 pAttr
->add( FSNS( XML_w
, XML_space
), OString::valueOf( sal_Int32( nDist
/ 20 ) ) );
1078 // Get the color code as an RRGGBB hex value
1079 OString
sColor( impl_ConvertColor( pBorderLine
->GetColor( ) ) );
1080 pAttr
->add( FSNS( XML_w
, XML_color
), sColor
);
1082 XFastAttributeListRef
xAttrs( pAttr
);
1083 pSerializer
->singleElementNS( XML_w
, elementToken
, xAttrs
);
1086 static void impl_pageBorders( FSHelperPtr pSerializer
, const SvxBoxItem
& rBox
)
1088 static const USHORT aBorders
[] =
1090 BOX_LINE_TOP
, BOX_LINE_LEFT
, BOX_LINE_BOTTOM
, BOX_LINE_RIGHT
1093 static const USHORT aXmlElements
[] =
1095 XML_top
, XML_left
, XML_bottom
, XML_right
1097 const USHORT
* pBrd
= aBorders
;
1098 for( int i
= 0; i
< 4; ++i
, ++pBrd
)
1100 const SvxBorderLine
* pLn
= rBox
.GetLine( *pBrd
);
1102 impl_borderLine( pSerializer
, aXmlElements
[i
], pLn
, 0 );
1106 void DocxAttributeOutput::TableCellProperties( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1108 m_pSerializer
->startElementNS( XML_w
, XML_tcPr
, FSEND
);
1110 const SwTableBox
*pTblBox
= pTableTextNodeInfoInner
->getTableBox( );
1113 m_pSerializer
->startElementNS( XML_w
, XML_tcBorders
, FSEND
);
1114 SwFrmFmt
*pFmt
= pTblBox
->GetFrmFmt( );
1115 impl_pageBorders( m_pSerializer
, pFmt
->GetBox( ) );
1116 m_pSerializer
->endElementNS( XML_w
, XML_tcBorders
);
1119 long vSpan
= pTblBox
->getRowSpan( );
1122 m_pSerializer
->singleElementNS( XML_w
, XML_vMerge
,
1123 FSNS( XML_w
, XML_val
), "restart",
1126 else if ( vSpan
< 0 )
1128 m_pSerializer
->singleElementNS( XML_w
, XML_vMerge
,
1129 FSNS( XML_w
, XML_val
), "continue",
1134 const SwWriteTableRows
& aRows
= m_pTableWrt
->GetRows( );
1135 SwWriteTableRow
*pRow
= aRows
[ pTableTextNodeInfoInner
->getRow( ) ];
1136 SwWriteTableCell
*pCell
= pRow
->GetCells( )[ pTableTextNodeInfoInner
->getCell( ) ];
1138 USHORT nColSpan
= pCell
->GetColSpan();
1140 m_pSerializer
->singleElementNS( XML_w
, XML_gridSpan
,
1141 FSNS( XML_w
, XML_val
), OString::valueOf( sal_Int32( nColSpan
) ).getStr(),
1144 TableBackgrounds( pTableTextNodeInfoInner
);
1146 // Cell prefered width
1147 SwTwips nWidth
= GetGridCols( pTableTextNodeInfoInner
)[ pTableTextNodeInfoInner
->getCell() ];
1148 m_pSerializer
->singleElementNS( XML_w
, XML_tcW
,
1149 FSNS( XML_w
, XML_w
), OString::valueOf( sal_Int32( nWidth
) ).getStr( ),
1150 FSNS( XML_w
, XML_type
), "dxa",
1154 m_pSerializer
->startElementNS( XML_w
, XML_tcMar
, FSEND
);
1155 const SvxBoxItem
& rBox
= pFmt
->GetBox( );
1156 static const USHORT aBorders
[] =
1158 BOX_LINE_TOP
, BOX_LINE_LEFT
, BOX_LINE_BOTTOM
, BOX_LINE_RIGHT
1161 static const USHORT aXmlElements
[] =
1163 XML_top
, XML_left
, XML_bottom
, XML_right
1165 const USHORT
* pBrd
= aBorders
;
1166 for( int i
= 0; i
< 4; ++i
, ++pBrd
)
1168 sal_Int32 nDist
= sal_Int32( rBox
.GetDistance( *pBrd
) );
1169 m_pSerializer
->singleElementNS( XML_w
, aXmlElements
[i
],
1170 FSNS( XML_w
, XML_w
), OString::valueOf( nDist
).getStr( ),
1171 FSNS( XML_w
, XML_type
), "dxa",
1175 m_pSerializer
->endElementNS( XML_w
, XML_tcMar
);
1177 TableVerticalCell( pTableTextNodeInfoInner
);
1179 m_pSerializer
->endElementNS( XML_w
, XML_tcPr
);
1182 void DocxAttributeOutput::InitTableHelper( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1184 sal_uInt32 nPageSize
= 0;
1185 bool bRelBoxSize
= false;
1187 // Create the SwWriteTable instance to use col spans (and maybe other infos)
1188 GetTablePageSize( pTableTextNodeInfoInner
, nPageSize
, bRelBoxSize
);
1190 const SwTable
* pTable
= pTableTextNodeInfoInner
->getTable( );
1191 const SwFrmFmt
*pFmt
= pTable
->GetFrmFmt( );
1192 SwTwips nTblSz
= pFmt
->GetFrmSize( ).GetWidth( );
1194 const SwHTMLTableLayout
*pLayout
= pTable
->GetHTMLTableLayout();
1195 if( pLayout
&& pLayout
->IsExportable() )
1196 m_pTableWrt
= new SwWriteTable( pLayout
);
1198 m_pTableWrt
= new SwWriteTable( pTable
->GetTabLines(), (USHORT
)nPageSize
,
1199 (USHORT
)nTblSz
, false);
1202 void DocxAttributeOutput::StartTable( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1204 m_pSerializer
->startElementNS( XML_w
, XML_tbl
, FSEND
);
1206 InitTableHelper( pTableTextNodeInfoInner
);
1207 TableDefinition( pTableTextNodeInfoInner
);
1210 void DocxAttributeOutput::EndTable()
1212 m_pSerializer
->endElementNS( XML_w
, XML_tbl
);
1214 if ( m_nTableDepth
> 0 )
1217 // We closed the table; if it is a nested table, the cell that contains it
1219 m_bTableCellOpen
= true;
1221 // Cleans the table helper
1222 delete m_pTableWrt
, m_pTableWrt
= NULL
;
1225 void DocxAttributeOutput::StartTableRow( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1227 m_pSerializer
->startElementNS( XML_w
, XML_tr
, FSEND
);
1229 // Output the row properties
1230 m_pSerializer
->startElementNS( XML_w
, XML_trPr
, FSEND
);
1232 // Header row: tblHeader
1233 const SwTable
*pTable
= pTableTextNodeInfoInner
->getTable( );
1234 if ( pTable
->GetRowsToRepeat( ) > pTableTextNodeInfoInner
->getRow( ) )
1235 m_pSerializer
->singleElementNS( XML_w
, XML_tblHeader
,
1236 FSNS( XML_w
, XML_val
), "true",
1239 TableHeight( pTableTextNodeInfoInner
);
1240 TableCanSplit( pTableTextNodeInfoInner
);
1242 m_pSerializer
->endElementNS( XML_w
, XML_trPr
);
1245 void DocxAttributeOutput::EndTableRow( )
1247 m_pSerializer
->endElementNS( XML_w
, XML_tr
);
1251 void DocxAttributeOutput::StartTableCell( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1254 InitTableHelper( pTableTextNodeInfoInner
);
1256 m_pSerializer
->startElementNS( XML_w
, XML_tc
, FSEND
);
1258 // Write the cell properties here
1259 TableCellProperties( pTableTextNodeInfoInner
);
1261 m_bTableCellOpen
= true;
1264 void DocxAttributeOutput::EndTableCell( )
1266 m_pSerializer
->endElementNS( XML_w
, XML_tc
);
1268 m_bTableCellOpen
= false;
1271 void DocxAttributeOutput::TableInfoCell( ww8::WW8TableNodeInfoInner::Pointer_t
/*pTableTextNodeInfoInner*/ )
1275 void DocxAttributeOutput::TableInfoRow( ww8::WW8TableNodeInfoInner::Pointer_t
/*pTableTextNodeInfo*/ )
1279 void DocxAttributeOutput::TableDefinition( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1281 // Write the table properties
1282 m_pSerializer
->startElementNS( XML_w
, XML_tblPr
, FSEND
);
1284 sal_uInt32 nPageSize
= 0;
1285 bool bRelBoxSize
= false;
1287 // Create the SwWriteTable instance to use col spans (and maybe other infos)
1288 GetTablePageSize( pTableTextNodeInfoInner
, nPageSize
, bRelBoxSize
);
1290 // Output the table prefered width
1291 if ( nPageSize
!= 0 )
1292 m_pSerializer
->singleElementNS( XML_w
, XML_tblW
,
1293 FSNS( XML_w
, XML_w
), OString::valueOf( sal_Int32( nPageSize
) ).getStr( ),
1294 FSNS( XML_w
, XML_type
), "dxa",
1297 // Output the table borders
1298 TableDefaultBorders( pTableTextNodeInfoInner
);
1299 TableBidi( pTableTextNodeInfoInner
);
1301 // Output the table alignement
1302 const SwTable
*pTable
= pTableTextNodeInfoInner
->getTable();
1303 SwFrmFmt
*pTblFmt
= pTable
->GetFrmFmt( );
1305 sal_Int32 nIndent
= 0;
1306 switch ( pTblFmt
->GetHoriOrient( ).GetHoriOrient( ) )
1308 case text::HoriOrientation::CENTER
:
1311 case text::HoriOrientation::RIGHT
:
1315 case text::HoriOrientation::NONE
:
1316 case text::HoriOrientation::LEFT_AND_WIDTH
:
1319 nIndent
= sal_Int32( pTblFmt
->GetLRSpace( ).GetLeft( ) );
1323 m_pSerializer
->singleElementNS( XML_w
, XML_jc
,
1324 FSNS( XML_w
, XML_val
), pJcVal
,
1329 m_pSerializer
->singleElementNS( XML_w
, XML_tblInd
,
1330 FSNS( XML_w
, XML_w
), OString::valueOf( nIndent
).getStr( ),
1331 FSNS( XML_w
, XML_type
), "dxa",
1334 m_pSerializer
->endElementNS( XML_w
, XML_tblPr
);
1337 // Write the table grid infos
1338 m_pSerializer
->startElementNS( XML_w
, XML_tblGrid
, FSEND
);
1340 std::vector
<SwTwips
> gridCols
= GetGridCols( pTableTextNodeInfoInner
);
1341 for ( std::vector
<SwTwips
>::const_iterator it
= gridCols
.begin(); it
!= gridCols
.end(); ++it
)
1342 m_pSerializer
->singleElementNS( XML_w
, XML_gridCol
,
1343 FSNS( XML_w
, XML_w
), OString::valueOf( sal_Int32( *it
) ).getStr( ),
1346 m_pSerializer
->endElementNS( XML_w
, XML_tblGrid
);
1349 void DocxAttributeOutput::TableDefaultBorders( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1351 const SwTableBox
* pTabBox
= pTableTextNodeInfoInner
->getTableBox();
1352 const SwFrmFmt
* pFrmFmt
= pTabBox
->GetFrmFmt();
1354 // the defaults of the table are taken from the top-left cell
1355 m_pSerializer
->startElementNS( XML_w
, XML_tblBorders
, FSEND
);
1356 impl_pageBorders( m_pSerializer
, pFrmFmt
->GetBox( ) );
1357 m_pSerializer
->endElementNS( XML_w
, XML_tblBorders
);
1360 void DocxAttributeOutput::TableBackgrounds( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1362 const SwTableBox
*pTblBox
= pTableTextNodeInfoInner
->getTableBox( );
1363 const SwFrmFmt
*pFmt
= pTblBox
->GetFrmFmt( );
1364 const SfxPoolItem
*pI
= NULL
;
1367 if ( SFX_ITEM_ON
== pFmt
->GetAttrSet().GetItemState( RES_BACKGROUND
, false, &pI
) )
1368 aColor
= dynamic_cast<const SvxBrushItem
*>(pI
)->GetColor();
1372 OString sColor
= impl_ConvertColor( aColor
);
1373 m_pSerializer
->singleElementNS( XML_w
, XML_shd
,
1374 FSNS( XML_w
, XML_fill
), sColor
.getStr( ),
1378 void DocxAttributeOutput::TableHeight( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1380 const SwTableBox
* pTabBox
= pTableTextNodeInfoInner
->getTableBox();
1381 const SwTableLine
* pTabLine
= pTabBox
->GetUpper();
1382 const SwFrmFmt
* pLineFmt
= pTabLine
->GetFrmFmt();
1384 const SwFmtFrmSize
& rLSz
= pLineFmt
->GetFrmSize();
1385 if ( ATT_VAR_SIZE
!= rLSz
.GetHeightSizeType() && rLSz
.GetHeight() )
1387 sal_Int32 nHeight
= rLSz
.GetHeight();
1388 const char *pRule
= NULL
;
1390 switch ( rLSz
.GetHeightSizeType() )
1392 case ATT_FIX_SIZE
: pRule
= "exact"; break;
1393 case ATT_MIN_SIZE
: pRule
= "atLeast"; break;
1398 m_pSerializer
->singleElementNS( XML_w
, XML_trHeight
,
1399 FSNS( XML_w
, XML_val
), OString::valueOf( nHeight
).getStr( ),
1400 FSNS( XML_w
, XML_hRule
), pRule
,
1405 void DocxAttributeOutput::TableCanSplit( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1407 const SwTableBox
* pTabBox
= pTableTextNodeInfoInner
->getTableBox();
1408 const SwTableLine
* pTabLine
= pTabBox
->GetUpper();
1409 const SwFrmFmt
* pLineFmt
= pTabLine
->GetFrmFmt();
1411 const SwFmtRowSplit
& rSplittable
= pLineFmt
->GetRowSplit( );
1412 const char* pCantSplit
= ( !rSplittable
.GetValue( ) ) ? "on" : "off";
1414 m_pSerializer
->singleElementNS( XML_w
, XML_cantSplit
,
1415 FSNS( XML_w
, XML_val
), pCantSplit
,
1419 void DocxAttributeOutput::TableBidi( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1421 const SwTable
* pTable
= pTableTextNodeInfoInner
->getTable();
1422 const SwFrmFmt
* pFrmFmt
= pTable
->GetFrmFmt();
1424 if ( m_rExport
.TrueFrameDirection( *pFrmFmt
) == FRMDIR_HORI_RIGHT_TOP
)
1426 m_pSerializer
->singleElementNS( XML_w
, XML_bidiVisual
,
1427 FSNS( XML_w
, XML_val
), "on",
1432 void DocxAttributeOutput::TableVerticalCell( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner
)
1434 const SwTableBox
* pTabBox
= pTableTextNodeInfoInner
->getTableBox();
1435 const SwFrmFmt
*pFrmFmt
= pTabBox
->GetFrmFmt( );
1437 if ( FRMDIR_VERT_TOP_RIGHT
== m_rExport
.TrueFrameDirection( *pFrmFmt
) )
1438 m_pSerializer
->singleElementNS( XML_w
, XML_textDirection
,
1439 FSNS( XML_w
, XML_val
), "tbRl",
1443 void DocxAttributeOutput::TableNodeInfo( ww8::WW8TableNodeInfo::Pointer_t
/*pNodeInfo*/ )
1445 #if OSL_DEBUG_LEVEL > 0
1446 fprintf( stderr
, "TODO: DocxAttributeOutput::TableNodeInfo( ww8::WW8TableNodeInfo::Pointer_t pNodeInfo )\n" );
1450 void DocxAttributeOutput::TableNodeInfoInner( ww8::WW8TableNodeInfoInner::Pointer_t pNodeInfoInner
)
1452 // This is called when the nested table ends in a cell, and there's no
1453 // paragraph benhind that; so we must check for the ends of cell, rows,
1455 // ['true' to write an empty paragraph, MS Word insists on that]
1456 FinishTableRowCell( pNodeInfoInner
, true );
1459 void DocxAttributeOutput::TableOrientation( ww8::WW8TableNodeInfoInner::Pointer_t
/*pTableTextNodeInfoInner*/ )
1461 #if OSL_DEBUG_LEVEL > 0
1462 fprintf( stderr
, "TODO: DocxAttributeOutput::TableOrientation( ww8::WW8TableNodeInfoInner::Pointer_t pTableTextNodeInfoInner )\n" );
1466 void DocxAttributeOutput::TableRowEnd( sal_uInt32
/*nDepth*/ )
1468 #if OSL_DEBUG_LEVEL > 0
1469 fprintf( stderr
, "TODO: DocxAttributeOutput::TableRowEnd( sal_uInt32 nDepth = 1 )\n" );
1473 void DocxAttributeOutput::StartStyles()
1475 m_pSerializer
->startElementNS( XML_w
, XML_styles
,
1476 FSNS( XML_xmlns
, XML_w
), "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
1480 void DocxAttributeOutput::EndStyles( USHORT
/*nNumberOfStyles*/ )
1482 m_pSerializer
->endElementNS( XML_w
, XML_styles
);
1485 void DocxAttributeOutput::DefaultStyle( USHORT nStyle
)
1487 // are these the values of enum ww::sti (see ../inc/wwstyles.hxx)?
1488 #if OSL_DEBUG_LEVEL > 0
1489 fprintf( stderr
, "TODO DocxAttributeOutput::DefaultStyle( USHORT nStyle )- %d\n", nStyle
);
1491 (void) nStyle
; // to quiet the warning
1495 void DocxAttributeOutput::FlyFrameGraphic( const SwGrfNode
& rGrfNode
, const Size
& rSize
)
1497 #if OSL_DEBUG_LEVEL > 0
1498 fprintf( stderr
, "TODO DocxAttributeOutput::FlyFrameGraphic( const SwGrfNode& rGrfNode, const Size& rSize ) - some stuff still missing\n" );
1500 // create the relation ID
1502 sal_Int32 nImageType
;
1503 if ( rGrfNode
.IsLinkedFile() )
1505 // linked image, just create the relation
1507 rGrfNode
.GetFileFilterNms( &aFileName
, 0 );
1509 // TODO Convert the file name to relative for better interoperability
1511 aRelId
= m_rExport
.AddRelation(
1512 S( "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" ),
1513 OUString( aFileName
),
1516 nImageType
= XML_link
;
1520 // inline, we also have to write the image itself
1521 Graphic
& rGraphic
= const_cast< Graphic
& >( rGrfNode
.GetGrf() );
1523 m_rDrawingML
.SetFS( m_pSerializer
); // to be sure that we write to the right stream
1524 OUString aImageId
= m_rDrawingML
.WriteImage( rGraphic
);
1526 aRelId
= OUStringToOString( aImageId
, RTL_TEXTENCODING_UTF8
);
1528 nImageType
= XML_embed
;
1531 if ( aRelId
.getLength() == 0 )
1534 m_pSerializer
->startElementNS( XML_w
, XML_drawing
,
1536 m_pSerializer
->startElementNS( XML_wp
, XML_inline
,
1537 XML_distT
, "0", XML_distB
, "0", XML_distL
, "0", XML_distR
, "0",
1540 // extent of the image
1541 OString
aWidth( OString::valueOf( TwipsToEMU( rSize
.Width() ) ) );
1542 OString
aHeight( OString::valueOf( TwipsToEMU( rSize
.Height() ) ) );
1543 m_pSerializer
->singleElementNS( XML_wp
, XML_extent
,
1544 XML_cx
, aWidth
.getStr(),
1545 XML_cy
, aHeight
.getStr(),
1547 // TODO - the right effectExtent, extent including the effect
1548 m_pSerializer
->singleElementNS( XML_wp
, XML_effectExtent
,
1549 XML_l
, "0", XML_t
, "0", XML_r
, "0", XML_b
, "0",
1552 // picture description
1553 // TODO the right image description
1554 m_pSerializer
->startElementNS( XML_wp
, XML_docPr
,
1556 XML_name
, "Picture",
1557 XML_descr
, "A description...",
1560 // m_pSerializer->singleElementNS( XML_a, XML_hlinkClick,
1561 // FSNS( XML_xmlns, XML_a ), "http://schemas.openxmlformats.org/drawingml/2006/main",
1562 // FSNS( XML_r, XML_id ), "rId4",
1564 m_pSerializer
->endElementNS( XML_wp
, XML_docPr
);
1566 m_pSerializer
->startElementNS( XML_wp
, XML_cNvGraphicFramePr
,
1568 // TODO change aspect?
1569 m_pSerializer
->singleElementNS( XML_a
, XML_graphicFrameLocks
,
1570 FSNS( XML_xmlns
, XML_a
), "http://schemas.openxmlformats.org/drawingml/2006/main",
1571 XML_noChangeAspect
, "1",
1573 m_pSerializer
->endElementNS( XML_wp
, XML_cNvGraphicFramePr
);
1575 m_pSerializer
->startElementNS( XML_a
, XML_graphic
,
1576 FSNS( XML_xmlns
, XML_a
), "http://schemas.openxmlformats.org/drawingml/2006/main",
1578 m_pSerializer
->startElementNS( XML_a
, XML_graphicData
,
1579 XML_uri
, "http://schemas.openxmlformats.org/drawingml/2006/picture",
1582 m_pSerializer
->startElementNS( XML_pic
, XML_pic
,
1583 FSNS( XML_xmlns
, XML_pic
), "http://schemas.openxmlformats.org/drawingml/2006/picture",
1586 m_pSerializer
->startElementNS( XML_pic
, XML_nvPicPr
,
1588 // TODO the right image description
1589 m_pSerializer
->startElementNS( XML_pic
, XML_cNvPr
,
1591 XML_name
, "Picture",
1592 XML_descr
, "A description...",
1595 // m_pSerializer->singleElementNS( XML_a, XML_hlinkClick,
1596 // FSNS( XML_r, XML_id ), "rId4",
1598 m_pSerializer
->endElementNS( XML_pic
, XML_cNvPr
);
1600 m_pSerializer
->startElementNS( XML_pic
, XML_cNvPicPr
,
1602 // TODO change aspect?
1603 m_pSerializer
->singleElementNS( XML_a
, XML_picLocks
,
1604 XML_noChangeAspect
, "1", XML_noChangeArrowheads
, "1",
1606 m_pSerializer
->endElementNS( XML_pic
, XML_cNvPicPr
);
1607 m_pSerializer
->endElementNS( XML_pic
, XML_nvPicPr
);
1609 // the actual picture
1610 m_pSerializer
->startElementNS( XML_pic
, XML_blipFill
,
1612 m_pSerializer
->singleElementNS( XML_a
, XML_blip
,
1613 FSNS( XML_r
, nImageType
), aRelId
.getStr(),
1615 m_pSerializer
->singleElementNS( XML_a
, XML_srcRect
,
1617 m_pSerializer
->startElementNS( XML_a
, XML_stretch
,
1619 m_pSerializer
->singleElementNS( XML_a
, XML_fillRect
,
1621 m_pSerializer
->endElementNS( XML_a
, XML_stretch
);
1622 m_pSerializer
->endElementNS( XML_pic
, XML_blipFill
);
1624 // TODO setup the right values below
1625 m_pSerializer
->startElementNS( XML_pic
, XML_spPr
,
1628 m_pSerializer
->startElementNS( XML_a
, XML_xfrm
,
1630 m_pSerializer
->singleElementNS( XML_a
, XML_off
,
1631 XML_x
, "0", XML_y
, "0",
1633 m_pSerializer
->singleElementNS( XML_a
, XML_ext
,
1634 XML_cx
, aWidth
.getStr(),
1635 XML_cy
, aHeight
.getStr(),
1637 m_pSerializer
->endElementNS( XML_a
, XML_xfrm
);
1638 m_pSerializer
->startElementNS( XML_a
, XML_prstGeom
,
1641 m_pSerializer
->singleElementNS( XML_a
, XML_avLst
,
1643 m_pSerializer
->endElementNS( XML_a
, XML_prstGeom
);
1644 m_pSerializer
->singleElementNS( XML_a
, XML_noFill
,
1646 m_pSerializer
->startElementNS( XML_a
, XML_ln
,
1649 m_pSerializer
->singleElementNS( XML_a
, XML_noFill
,
1651 m_pSerializer
->singleElementNS( XML_a
, XML_miter
,
1654 m_pSerializer
->singleElementNS( XML_a
, XML_headEnd
,
1656 m_pSerializer
->singleElementNS( XML_a
, XML_tailEnd
,
1658 m_pSerializer
->endElementNS( XML_a
, XML_ln
);
1659 m_pSerializer
->endElementNS( XML_pic
, XML_spPr
);
1661 m_pSerializer
->endElementNS( XML_pic
, XML_pic
);
1663 m_pSerializer
->endElementNS( XML_a
, XML_graphicData
);
1664 m_pSerializer
->endElementNS( XML_a
, XML_graphic
);
1665 m_pSerializer
->endElementNS( XML_wp
, XML_inline
);
1667 m_pSerializer
->endElementNS( XML_w
, XML_drawing
);
1670 void DocxAttributeOutput::OutputFlyFrame_Impl( const sw::Frame
&rFrame
, const Point
& /*rNdTopLeft*/ )
1672 m_pSerializer
->mark();
1674 switch ( rFrame
.GetWriterType() )
1676 case sw::Frame::eGraphic
:
1678 const SwNode
*pNode
= rFrame
.GetContent();
1679 const SwGrfNode
*pGrfNode
= pNode
? pNode
->GetGrfNode() : 0;
1681 FlyFrameGraphic( *pGrfNode
, rFrame
.GetLayoutSize() );
1684 case sw::Frame::eDrawing
:
1686 const SdrObject
* pSdrObj
= rFrame
.GetFrmFmt().FindRealSdrObject();
1689 bool bSwapInPage
= false;
1690 if ( !pSdrObj
->GetPage() )
1692 if ( SdrModel
* pModel
= m_rExport
.pDoc
->GetDrawModel() )
1694 if ( SdrPage
*pPage
= pModel
->GetPage( 0 ) )
1697 const_cast< SdrObject
* >( pSdrObj
)->SetPage( pPage
);
1702 m_pSerializer
->startElementNS( XML_w
, XML_pict
,
1705 m_rExport
.VMLExporter().AddSdrObject( *pSdrObj
);
1707 m_pSerializer
->endElementNS( XML_w
, XML_pict
);
1710 const_cast< SdrObject
* >( pSdrObj
)->SetPage( 0 );
1715 #if OSL_DEBUG_LEVEL > 0
1716 fprintf( stderr
, "TODO DocxAttributeOutput::OutputFlyFrame_Impl( const sw::Frame& rFrame, const Point& rNdTopLeft ) - frame type '%s'\n",
1717 rFrame
.GetWriterType() == sw::Frame::eTxtBox
? "eTxtBox":
1718 ( rFrame
.GetWriterType() == sw::Frame::eOle
? "eOle":
1719 ( rFrame
.GetWriterType() == sw::Frame::eFormControl
? "eFormControl": "???" ) ) );
1724 m_pSerializer
->mergeTopMarks( sax_fastparser::MERGE_MARKS_POSTPONE
);
1727 void DocxAttributeOutput::StartStyle( const String
& rName
, bool bPapFmt
,
1728 USHORT nBase
, USHORT nNext
, USHORT
/*nWwId*/, USHORT nId
)
1730 OString
aStyle( "style" );
1732 m_pSerializer
->startElementNS( XML_w
, XML_style
,
1733 FSNS( XML_w
, XML_type
), bPapFmt
? "paragraph": "character", // FIXME is this correct?
1734 FSNS( XML_w
, XML_styleId
), ( aStyle
+ OString::valueOf( sal_Int32( nId
) ) ).getStr(),
1737 m_pSerializer
->singleElementNS( XML_w
, XML_name
,
1738 FSNS( XML_w
, XML_val
), OUStringToOString( OUString( rName
), RTL_TEXTENCODING_UTF8
).getStr(),
1741 if ( nBase
!= 0x0FFF )
1743 m_pSerializer
->singleElementNS( XML_w
, XML_basedOn
,
1744 FSNS( XML_w
, XML_val
), ( aStyle
+ OString::valueOf( sal_Int32( nBase
) ) ).getStr(),
1748 m_pSerializer
->singleElementNS( XML_w
, XML_next
,
1749 FSNS( XML_w
, XML_val
), ( aStyle
+ OString::valueOf( sal_Int32( nNext
) ) ).getStr(),
1753 void DocxAttributeOutput::EndStyle()
1755 m_pSerializer
->endElementNS( XML_w
, XML_style
);
1758 void DocxAttributeOutput::StartStyleProperties( bool bParProp
, USHORT
/*nStyle*/ )
1762 m_pSerializer
->startElementNS( XML_w
, XML_pPr
, FSEND
);
1763 InitCollectedParagraphProperties();
1767 m_pSerializer
->startElementNS( XML_w
, XML_rPr
, FSEND
);
1768 InitCollectedRunProperties();
1772 void DocxAttributeOutput::EndStyleProperties( bool bParProp
)
1776 WriteCollectedParagraphProperties();
1777 m_pSerializer
->endElementNS( XML_w
, XML_pPr
);
1781 WriteCollectedRunProperties();
1782 m_pSerializer
->endElementNS( XML_w
, XML_rPr
);
1786 void DocxAttributeOutput::OutlineNumbering( BYTE nLvl
, const SwNumFmt
& /*rNFmt*/, const SwFmt
& /*rFmt*/ )
1788 if ( nLvl
>= WW8ListManager::nMaxLevel
)
1789 nLvl
= WW8ListManager::nMaxLevel
- 1;
1791 m_pSerializer
->singleElementNS( XML_w
, XML_outlineLvl
,
1792 FSNS( XML_w
, XML_val
), OString::valueOf( sal_Int32( nLvl
) ).getStr( ),
1796 void DocxAttributeOutput::PageBreakBefore( bool bBreak
)
1799 m_pSerializer
->singleElementNS( XML_w
, XML_pageBreakBefore
, FSEND
);
1801 m_pSerializer
->singleElementNS( XML_w
, XML_pageBreakBefore
,
1802 FSNS( XML_w
, XML_val
), "off",
1806 void DocxAttributeOutput::SectionBreak( BYTE nC
, const WW8_SepInfo
* pSectionInfo
)
1810 case msword::ColumnBreak
:
1811 // The column break should be output in the next paragraph...
1812 m_nColBreakStatus
= COLBRK_POSTPONE
;
1814 case msword::PageBreak
:
1817 if ( !m_bParagraphOpened
)
1819 // Create a dummy paragraph if needed
1820 m_pSerializer
->startElementNS( XML_w
, XML_p
, FSEND
);
1821 m_pSerializer
->startElementNS( XML_w
, XML_pPr
, FSEND
);
1823 m_rExport
.SectionProperties( *pSectionInfo
);
1825 m_pSerializer
->endElementNS( XML_w
, XML_pPr
);
1826 m_pSerializer
->endElementNS( XML_w
, XML_p
);
1830 // postpone the output of this; it has to be done inside the
1831 // paragraph properties, so remember it until then
1832 m_pSectionInfo
= pSectionInfo
;
1837 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
1838 m_pSerializer
->singleElementNS( XML_w
, XML_br
,
1839 FSNS( XML_w
, XML_type
), "page", FSEND
);
1840 m_pSerializer
->endElementNS( XML_w
, XML_r
);
1844 #if OSL_DEBUG_LEVEL > 0
1845 fprintf( stderr
, "Unknown section break to write: %d\n", nC
);
1851 void DocxAttributeOutput::StartSection()
1853 m_pSerializer
->startElementNS( XML_w
, XML_sectPr
, FSEND
);
1854 m_bOpenedSectPr
= true;
1857 void DocxAttributeOutput::EndSection()
1859 // Write the section properties
1860 if ( m_pSpacingAttrList
)
1862 XFastAttributeListRef
xAttrList( m_pSpacingAttrList
);
1863 m_pSpacingAttrList
= NULL
;
1865 m_pSerializer
->singleElementNS( XML_w
, XML_pgMar
, xAttrList
);
1868 m_pSerializer
->endElementNS( XML_w
, XML_sectPr
);
1869 m_bOpenedSectPr
= false;
1872 void DocxAttributeOutput::SectionFormProtection( bool bProtected
)
1875 m_pSerializer
->singleElementNS( XML_w
, XML_formProt
, FSEND
);
1877 m_pSerializer
->singleElementNS( XML_w
, XML_formProt
,
1878 FSNS( XML_w
, XML_val
), "off", FSEND
);
1881 void DocxAttributeOutput::SectionLineNumbering( ULONG
/*nRestartNo*/, const SwLineNumberInfo
& /*rLnNumInfo*/ )
1883 // see 2.6.8 lnNumType (Line Numbering Settings)
1884 #if OSL_DEBUG_LEVEL > 0
1885 fprintf( stderr
, "TODO DocxAttributeOutput::SectionLineNumbering()\n" );
1889 void DocxAttributeOutput::SectionTitlePage()
1891 m_pSerializer
->singleElementNS( XML_w
, XML_titlePg
, FSEND
);
1894 void DocxAttributeOutput::SectionPageBorders( const SwFrmFmt
* pFmt
, const SwFrmFmt
* /*pFirstPageFmt*/ )
1896 // Output the margins
1899 const SvxBoxItem
& rBox
= pFmt
->GetBox( );
1901 const SvxBorderLine
* pBottom
= rBox
.GetBottom( );
1902 const SvxBorderLine
* pTop
= rBox
.GetTop( );
1903 const SvxBorderLine
* pLeft
= rBox
.GetLeft( );
1904 const SvxBorderLine
* pRight
= rBox
.GetRight( );
1906 if ( pBottom
|| pTop
|| pLeft
|| pRight
)
1908 // All distances are relative to the text margins
1909 m_pSerializer
->startElementNS( XML_w
, XML_pgBorders
,
1910 FSNS( XML_w
, XML_display
), "allPages",
1911 FSNS( XML_w
, XML_offsetFrom
), "text",
1914 m_pSerializer
->mark();
1916 m_pSerializer
->endElementNS( XML_w
, XML_pgBorders
);
1917 m_pSerializer
->mark();
1921 void DocxAttributeOutput::SectionBiDi( bool bBiDi
)
1924 m_pSerializer
->singleElementNS( XML_w
, XML_bidi
, FSEND
);
1927 static OString
impl_NumberingType( USHORT nNumberingType
)
1931 switch ( nNumberingType
)
1933 case SVX_NUM_CHARS_UPPER_LETTER
:
1934 case SVX_NUM_CHARS_UPPER_LETTER_N
: aType
= "upperLetter"; break;
1935 case SVX_NUM_CHARS_LOWER_LETTER
:
1936 case SVX_NUM_CHARS_LOWER_LETTER_N
: aType
= "lowerLetter"; break;
1937 case SVX_NUM_ROMAN_UPPER
: aType
= "upperRoman"; break;
1938 case SVX_NUM_ROMAN_LOWER
: aType
= "lowerRoman"; break;
1940 case SVX_NUM_ARABIC
: aType
= "decimal"; break;
1942 case SVX_NUM_BITMAP
:
1943 case SVX_NUM_CHAR_SPECIAL
: aType
= "bullet"; break;
1945 default: aType
= "none"; break;
1951 void DocxAttributeOutput::SectionPageNumbering( USHORT nNumType
, USHORT nPageRestartNumber
)
1953 // FIXME Not called properly with page styles like "First Page"
1955 FastAttributeList
* pAttr
= m_pSerializer
->createAttrList();
1957 // 0 means no restart: then don't output that attribute if 0
1958 if ( nPageRestartNumber
> 0 )
1959 pAttr
->add( FSNS( XML_w
, XML_start
), OString::valueOf( sal_Int32( nPageRestartNumber
) ) );
1961 // nNumType corresponds to w:fmt. See WW8Export::GetNumId() for more precisions
1962 OString
aFmt( impl_NumberingType( nNumType
) );
1963 if ( aFmt
.getLength() )
1964 pAttr
->add( FSNS( XML_w
, XML_fmt
), aFmt
.getStr() );
1966 XFastAttributeListRef
xAttrs( pAttr
);
1967 m_pSerializer
->singleElementNS( XML_w
, XML_pgNumType
, xAttrs
);
1969 // see 2.6.12 pgNumType (Page Numbering Settings)
1970 #if OSL_DEBUG_LEVEL > 0
1971 fprintf( stderr
, "TODO DocxAttributeOutput::SectionPageNumbering()\n" );
1975 void DocxAttributeOutput::SectionType( BYTE nBreakCode
)
1977 /* break code: 0 No break, 1 New column
1978 2 New page, 3 Even page, 4 Odd page
1980 const char* pType
= NULL
;
1981 switch ( nBreakCode
)
1983 case 1: pType
= "nextColumn"; break;
1984 case 2: pType
= "nextPage"; break;
1985 case 3: pType
= "evenPage"; break;
1986 case 4: pType
= "oddPage"; break;
1987 default: pType
= "continuous"; break;
1991 m_pSerializer
->singleElementNS( XML_w
, XML_type
,
1992 FSNS( XML_w
, XML_val
), pType
,
1996 void DocxAttributeOutput::StartFont( const String
& rFamilyName
) const
1998 m_pSerializer
->startElementNS( XML_w
, XML_font
,
1999 FSNS( XML_w
, XML_name
), OUStringToOString( OUString( rFamilyName
), RTL_TEXTENCODING_UTF8
).getStr(),
2003 void DocxAttributeOutput::EndFont() const
2005 m_pSerializer
->endElementNS( XML_w
, XML_font
);
2008 void DocxAttributeOutput::FontAlternateName( const String
& rName
) const
2010 m_pSerializer
->singleElementNS( XML_w
, XML_altName
,
2011 FSNS( XML_w
, XML_val
), OUStringToOString( OUString( rName
), RTL_TEXTENCODING_UTF8
).getStr(),
2015 void DocxAttributeOutput::FontCharset( sal_uInt8 nCharSet
) const
2017 OString
aCharSet( OString::valueOf( sal_Int32( nCharSet
), 16 ) );
2018 if ( aCharSet
.getLength() == 1 )
2019 aCharSet
= OString( "0" ) + aCharSet
;
2021 m_pSerializer
->singleElementNS( XML_w
, XML_charset
,
2022 FSNS( XML_w
, XML_val
), aCharSet
.getStr(),
2026 void DocxAttributeOutput::FontFamilyType( FontFamily eFamily
) const
2028 const char *pFamily
= NULL
;
2031 case FAMILY_ROMAN
: pFamily
= "roman"; break;
2032 case FAMILY_SWISS
: pFamily
= "swiss"; break;
2033 case FAMILY_MODERN
: pFamily
= "modern"; break;
2034 case FAMILY_SCRIPT
: pFamily
= "script"; break;
2035 case FAMILY_DECORATIVE
: pFamily
= "decorative"; break;
2036 default: pFamily
= "auto"; break; // no font family
2040 m_pSerializer
->singleElementNS( XML_w
, XML_family
,
2041 FSNS( XML_w
, XML_val
), pFamily
,
2045 void DocxAttributeOutput::FontPitchType( FontPitch ePitch
) const
2047 const char *pPitch
= NULL
;
2050 case PITCH_VARIABLE
: pPitch
= "variable"; break;
2051 case PITCH_FIXED
: pPitch
= "fixed"; break;
2052 default: pPitch
= "default"; break; // no info about the pitch
2056 m_pSerializer
->singleElementNS( XML_w
, XML_pitch
,
2057 FSNS( XML_w
, XML_val
), pPitch
,
2061 void DocxAttributeOutput::NumberingDefinition( USHORT nId
, const SwNumRule
&rRule
)
2063 // nId is the same both for abstract numbering definition as well as the
2064 // numbering definition itself
2065 // TODO check that this is actually true & fix if not ;-)
2066 OString
aId( OString::valueOf( sal_Int32( nId
) ) );
2068 m_pSerializer
->startElementNS( XML_w
, XML_num
,
2069 FSNS( XML_w
, XML_numId
), aId
.getStr(),
2072 m_pSerializer
->singleElementNS( XML_w
, XML_abstractNumId
,
2073 FSNS( XML_w
, XML_val
), aId
.getStr(),
2076 #if OSL_DEBUG_LEVEL > 0
2077 // TODO ww8 version writes this, anything to do about it here?
2078 if ( rRule
.IsContinusNum() )
2079 fprintf( stderr
, "TODO DocxAttributeOutput::NumberingDefinition()\n" );
2081 (void) rRule
; // to quiet the warning...
2084 m_pSerializer
->endElementNS( XML_w
, XML_num
);
2087 void DocxAttributeOutput::StartAbstractNumbering( USHORT nId
)
2089 m_pSerializer
->startElementNS( XML_w
, XML_abstractNum
,
2090 FSNS( XML_w
, XML_abstractNumId
), OString::valueOf( sal_Int32( nId
) ).getStr(),
2094 void DocxAttributeOutput::EndAbstractNumbering()
2096 m_pSerializer
->endElementNS( XML_w
, XML_abstractNum
);
2099 void DocxAttributeOutput::NumberingLevel( BYTE nLevel
,
2101 USHORT nNumberingType
,
2103 const BYTE
* /*pNumLvlPos*/,
2105 const wwFont
*pFont
,
2106 const SfxItemSet
*pOutSet
,
2107 sal_Int16 nIndentAt
,
2108 sal_Int16 nFirstLineIndex
,
2109 sal_Int16
/*nListTabPos*/,
2110 const String
&rNumberingString
)
2112 m_pSerializer
->startElementNS( XML_w
, XML_lvl
,
2113 FSNS( XML_w
, XML_ilvl
), OString::valueOf( sal_Int32( nLevel
) ).getStr(),
2116 // start with the nStart value
2117 m_pSerializer
->singleElementNS( XML_w
, XML_start
,
2118 FSNS( XML_w
, XML_val
), OString::valueOf( sal_Int32( nStart
) ).getStr(),
2122 OString
aFmt( impl_NumberingType( nNumberingType
) );
2124 if ( aFmt
.getLength() )
2125 m_pSerializer
->singleElementNS( XML_w
, XML_numFmt
,
2126 FSNS( XML_w
, XML_val
), aFmt
.getStr(),
2133 case SVX_ADJUST_CENTER
: pJc
= "center"; break;
2134 case SVX_ADJUST_RIGHT
: pJc
= "right"; break;
2135 default: pJc
= "left"; break;
2137 m_pSerializer
->singleElementNS( XML_w
, XML_lvlJc
,
2138 FSNS( XML_w
, XML_val
), pJc
,
2142 const char *pSuffix
= NULL
;
2145 case 1: pSuffix
= "space"; break;
2146 case 2: pSuffix
= "nothing"; break;
2147 default: /*pSuffix = "tab";*/ break;
2150 m_pSerializer
->singleElementNS( XML_w
, XML_suff
,
2151 FSNS( XML_w
, XML_val
), pSuffix
,
2155 OUString
aText( rNumberingString
);
2156 OUStringBuffer
aBuffer( aText
.getLength() + WW8ListManager::nMaxLevel
);
2158 const sal_Unicode
*pPrev
= aText
.getStr();
2159 const sal_Unicode
*pIt
= aText
.getStr();
2160 while ( pIt
< aText
.getStr() + aText
.getLength() )
2162 // convert the level values to %NUMBER form
2163 // (we don't use pNumLvlPos at all)
2164 // FIXME so far we support the ww8 limit of levels only
2165 if ( *pIt
< sal_Unicode( WW8ListManager::nMaxLevel
) )
2167 aBuffer
.append( pPrev
, pIt
- pPrev
);
2168 aBuffer
.appendAscii( "%" );
2169 aBuffer
.append( OUString::valueOf( sal_Int32( *pIt
) + 1 ) );
2176 aBuffer
.append( pPrev
, pIt
- pPrev
);
2178 m_pSerializer
->singleElementNS( XML_w
, XML_lvlText
,
2179 FSNS( XML_w
, XML_val
), OUStringToOString( aBuffer
.makeStringAndClear(), RTL_TEXTENCODING_UTF8
).getStr(),
2183 m_pSerializer
->startElementNS( XML_w
, XML_pPr
, FSEND
);
2184 m_pSerializer
->singleElementNS( XML_w
, XML_ind
,
2185 FSNS( XML_w
, XML_left
), OString::valueOf( sal_Int32( nIndentAt
) ).getStr(),
2186 FSNS( XML_w
, XML_hanging
), OString::valueOf( sal_Int32( -nFirstLineIndex
) ).getStr(),
2188 m_pSerializer
->endElementNS( XML_w
, XML_pPr
);
2193 m_pSerializer
->startElementNS( XML_w
, XML_rPr
, FSEND
);
2197 OString
aFamilyName( OUStringToOString( OUString( pFont
->GetFamilyName() ), RTL_TEXTENCODING_UTF8
) );
2198 m_pSerializer
->singleElementNS( XML_w
, XML_rFonts
,
2199 FSNS( XML_w
, XML_ascii
), aFamilyName
.getStr(),
2200 FSNS( XML_w
, XML_hAnsi
), aFamilyName
.getStr(),
2201 FSNS( XML_w
, XML_cs
), aFamilyName
.getStr(),
2202 FSNS( XML_w
, XML_hint
), "default",
2205 m_rExport
.OutputItemSet( *pOutSet
, false, true, i18n::ScriptType::LATIN
);
2207 m_pSerializer
->endElementNS( XML_w
, XML_rPr
);
2210 // TODO anything to do about nListTabPos?
2212 m_pSerializer
->endElementNS( XML_w
, XML_lvl
);
2215 void DocxAttributeOutput::CharCaseMap( const SvxCaseMapItem
& rCaseMap
)
2217 switch ( rCaseMap
.GetValue() )
2219 case SVX_CASEMAP_KAPITAELCHEN
:
2220 m_pSerializer
->singleElementNS( XML_w
, XML_smallCaps
, FSEND
);
2222 case SVX_CASEMAP_VERSALIEN
:
2223 m_pSerializer
->singleElementNS( XML_w
, XML_caps
, FSEND
);
2225 default: // Something that ooxml does not support
2226 m_pSerializer
->singleElementNS( XML_w
, XML_smallCaps
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2227 m_pSerializer
->singleElementNS( XML_w
, XML_caps
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2232 void DocxAttributeOutput::CharColor( const SvxColorItem
& rColor
)
2234 const Color
aColor( rColor
.GetValue() );
2235 OString aColorString
;
2237 aColorString
= impl_ConvertColor( aColor
);
2239 m_pSerializer
->singleElementNS( XML_w
, XML_color
,
2240 FSNS( XML_w
, XML_val
), aColorString
.getStr(), FSEND
);
2243 void DocxAttributeOutput::CharContour( const SvxContourItem
& rContour
)
2245 if ( rContour
.GetValue() )
2246 m_pSerializer
->singleElementNS( XML_w
, XML_outline
, FSEND
);
2248 m_pSerializer
->singleElementNS( XML_w
, XML_outline
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2251 void DocxAttributeOutput::CharCrossedOut( const SvxCrossedOutItem
& rCrossedOut
)
2253 switch ( rCrossedOut
.GetStrikeout() )
2255 case STRIKEOUT_DOUBLE
:
2256 m_pSerializer
->singleElementNS( XML_w
, XML_dstrike
, FSEND
);
2258 case STRIKEOUT_NONE
:
2259 m_pSerializer
->singleElementNS( XML_w
, XML_dstrike
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2260 m_pSerializer
->singleElementNS( XML_w
, XML_strike
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2263 m_pSerializer
->singleElementNS( XML_w
, XML_strike
, FSEND
);
2268 void DocxAttributeOutput::CharEscapement( const SvxEscapementItem
& /*rEscapement*/ )
2270 #if OSL_DEBUG_LEVEL > 0
2271 fprintf( stderr
, "TODO DocxAttributeOutput::CharEscapement()\n" );
2275 void DocxAttributeOutput::CharFont( const SvxFontItem
& rFont
)
2277 if (!m_pFontsAttrList
)
2278 m_pFontsAttrList
= m_pSerializer
->createAttrList();
2279 OUString
sFontName(rFont
.GetFamilyName());
2280 OString sFontNameUtf8
= OUStringToOString(sFontName
, RTL_TEXTENCODING_UTF8
);
2281 m_pFontsAttrList
->add(FSNS(XML_w
, XML_ascii
), sFontNameUtf8
);
2282 m_pFontsAttrList
->add(FSNS(XML_w
, XML_hAnsi
), sFontNameUtf8
);
2285 void DocxAttributeOutput::CharFontSize( const SvxFontHeightItem
& rFontSize
)
2287 OString fontSize
= OString::valueOf( sal_Int32( ( rFontSize
.GetHeight() + 5 ) / 10 ) );
2289 switch ( rFontSize
.Which() )
2291 case RES_CHRATR_FONTSIZE
:
2292 case RES_CHRATR_CJK_FONTSIZE
:
2293 m_pSerializer
->singleElementNS( XML_w
, XML_sz
, FSNS( XML_w
, XML_val
), fontSize
.getStr(), FSEND
);
2295 case RES_CHRATR_CTL_FONTSIZE
:
2296 m_pSerializer
->singleElementNS( XML_w
, XML_szCs
, FSNS( XML_w
, XML_val
), fontSize
.getStr(), FSEND
);
2301 void DocxAttributeOutput::CharKerning( const SvxKerningItem
& rKerning
)
2303 OString aKerning
= OString::valueOf( ( sal_Int32
) rKerning
.GetValue() );
2304 m_pSerializer
->singleElementNS( XML_w
, XML_kern
, FSNS(XML_w
, XML_val
), aKerning
.getStr(), FSEND
);
2307 void DocxAttributeOutput::CharLanguage( const SvxLanguageItem
& rLanguage
)
2309 if (!m_pCharLangAttrList
)
2310 m_pCharLangAttrList
= m_pSerializer
->createAttrList();
2312 ::com::sun::star::lang::Locale xLocale
= MsLangId::convertLanguageToLocale( rLanguage
.GetLanguage( ) );
2313 OString sLanguage
= OUStringToOString(xLocale
.Language
, RTL_TEXTENCODING_UTF8
);
2314 OString sCountry
= OUStringToOString(xLocale
.Country
, RTL_TEXTENCODING_UTF8
);
2316 OString aLanguageCode
= sLanguage
+ "-" + sCountry
;
2318 switch ( rLanguage
.Which() )
2320 case RES_CHRATR_LANGUAGE
:
2321 m_pCharLangAttrList
->add(FSNS(XML_w
, XML_val
), aLanguageCode
);
2323 case RES_CHRATR_CJK_LANGUAGE
:
2324 m_pCharLangAttrList
->add(FSNS(XML_w
, XML_eastAsia
), aLanguageCode
);
2326 case RES_CHRATR_CTL_LANGUAGE
:
2327 m_pCharLangAttrList
->add(FSNS(XML_w
, XML_bidi
), aLanguageCode
);
2332 void DocxAttributeOutput::CharPosture( const SvxPostureItem
& rPosture
)
2334 if ( rPosture
.GetPosture() != ITALIC_NONE
)
2335 m_pSerializer
->singleElementNS( XML_w
, XML_i
, FSEND
);
2337 m_pSerializer
->singleElementNS( XML_w
, XML_i
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2340 void DocxAttributeOutput::CharShadow( const SvxShadowedItem
& rShadow
)
2342 if ( rShadow
.GetValue() )
2343 m_pSerializer
->singleElementNS( XML_w
, XML_shadow
, FSEND
);
2345 m_pSerializer
->singleElementNS( XML_w
, XML_shadow
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2348 void DocxAttributeOutput::CharUnderline( const SvxUnderlineItem
& rUnderline
)
2350 const char *pUnderline
;
2352 switch ( rUnderline
.GetLineStyle() )
2354 case UNDERLINE_SINGLE
: pUnderline
= "single"; break;
2355 case UNDERLINE_BOLD
: pUnderline
= "thick"; break;
2356 case UNDERLINE_DOUBLE
: pUnderline
= "double"; break;
2357 case UNDERLINE_DOTTED
: pUnderline
= "dotted"; break;
2358 case UNDERLINE_DASH
: pUnderline
= "dash"; break;
2359 case UNDERLINE_DASHDOT
: pUnderline
= "dotDash"; break;
2360 case UNDERLINE_DASHDOTDOT
: pUnderline
= "dotDotDash"; break;
2361 case UNDERLINE_WAVE
: pUnderline
= "wave"; break;
2362 case UNDERLINE_BOLDDOTTED
: pUnderline
= "dottedHeavy"; break;
2363 case UNDERLINE_BOLDDASH
: pUnderline
= "dashedHeavy"; break;
2364 case UNDERLINE_LONGDASH
: pUnderline
= "dashLongHeavy"; break;
2365 case UNDERLINE_BOLDLONGDASH
: pUnderline
= "dashLongHeavy"; break;
2366 case UNDERLINE_BOLDDASHDOT
: pUnderline
= "dashDotHeavy"; break;
2367 case UNDERLINE_BOLDDASHDOTDOT
: pUnderline
= "dashDotDotHeavy"; break;
2368 case UNDERLINE_BOLDWAVE
: pUnderline
= "wavyHeavy"; break;
2369 case UNDERLINE_DOUBLEWAVE
: pUnderline
= "wavyDouble"; break;
2370 case UNDERLINE_NONE
: // fall through
2371 default: pUnderline
= "none"; break;
2374 m_pSerializer
->singleElementNS( XML_w
, XML_u
, FSNS( XML_w
, XML_val
), pUnderline
, FSEND
);
2377 void DocxAttributeOutput::CharWeight( const SvxWeightItem
& rWeight
)
2379 if ( rWeight
.GetWeight() == WEIGHT_BOLD
)
2380 m_pSerializer
->singleElementNS( XML_w
, XML_b
, FSEND
);
2382 m_pSerializer
->singleElementNS( XML_w
, XML_b
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2385 void DocxAttributeOutput::CharAutoKern( const SvxAutoKernItem
& )
2387 #if OSL_DEBUG_LEVEL > 0
2388 fprintf( stderr
, "TODO DocxAttributeOutput::CharAutoKern()\n" );
2392 void DocxAttributeOutput::CharAnimatedText( const SvxBlinkItem
& rBlink
)
2394 if ( rBlink
.GetValue() )
2395 m_pSerializer
->singleElementNS(XML_w
, XML_effect
, FSNS( XML_w
, XML_val
), "blinkBackground", FSEND
);
2397 m_pSerializer
->singleElementNS(XML_w
, XML_effect
, FSNS( XML_w
, XML_val
), "none", FSEND
);
2400 void DocxAttributeOutput::CharBackground( const SvxBrushItem
& rBrush
)
2402 m_pSerializer
->singleElementNS( XML_w
, XML_shd
,
2403 FSNS( XML_w
, XML_fill
), impl_ConvertColor( rBrush
.GetColor() ).getStr(), FSEND
);
2406 void DocxAttributeOutput::CharFontCJK( const SvxFontItem
& rFont
)
2408 if (!m_pFontsAttrList
)
2409 m_pFontsAttrList
= m_pSerializer
->createAttrList();
2410 OUString
sFontName(rFont
.GetFamilyName());
2411 OString sFontNameUtf8
= OUStringToOString(sFontName
, RTL_TEXTENCODING_UTF8
);
2412 m_pFontsAttrList
->add(FSNS(XML_w
, XML_eastAsia
), sFontNameUtf8
);
2415 void DocxAttributeOutput::CharPostureCJK( const SvxPostureItem
& rPosture
)
2417 if ( rPosture
.GetPosture() != ITALIC_NONE
)
2418 m_pSerializer
->singleElementNS( XML_w
, XML_i
, FSEND
);
2420 m_pSerializer
->singleElementNS( XML_w
, XML_i
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2423 void DocxAttributeOutput::CharWeightCJK( const SvxWeightItem
& rWeight
)
2425 if ( rWeight
.GetWeight() == WEIGHT_BOLD
)
2426 m_pSerializer
->singleElementNS( XML_w
, XML_b
, FSEND
);
2428 m_pSerializer
->singleElementNS( XML_w
, XML_b
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2431 void DocxAttributeOutput::CharFontCTL( const SvxFontItem
& rFont
)
2433 if (!m_pFontsAttrList
)
2434 m_pFontsAttrList
= m_pSerializer
->createAttrList();
2435 OUString
sFontName(rFont
.GetFamilyName());
2436 OString sFontNameUtf8
= OUStringToOString(sFontName
, RTL_TEXTENCODING_UTF8
);
2437 m_pFontsAttrList
->add(FSNS(XML_w
, XML_cs
), sFontNameUtf8
);
2441 void DocxAttributeOutput::CharPostureCTL( const SvxPostureItem
& rPosture
)
2443 if ( rPosture
.GetPosture() != ITALIC_NONE
)
2444 m_pSerializer
->singleElementNS( XML_w
, XML_iCs
, FSEND
);
2446 m_pSerializer
->singleElementNS( XML_w
, XML_iCs
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2449 void DocxAttributeOutput::CharWeightCTL( const SvxWeightItem
& rWeight
)
2451 if ( rWeight
.GetWeight() == WEIGHT_BOLD
)
2452 m_pSerializer
->singleElementNS( XML_w
, XML_bCs
, FSEND
);
2454 m_pSerializer
->singleElementNS( XML_w
, XML_bCs
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2457 void DocxAttributeOutput::CharRotate( const SvxCharRotateItem
& rRotate
)
2459 if ( !rRotate
.GetValue() )
2462 if (!m_pEastAsianLayoutAttrList
)
2463 m_pEastAsianLayoutAttrList
= m_pSerializer
->createAttrList();
2464 OString
sTrue((sal_Char
*)"true");
2465 m_pEastAsianLayoutAttrList
->add(FSNS(XML_w
, XML_vert
), sTrue
);
2467 if (rRotate
.IsFitToLine())
2468 m_pEastAsianLayoutAttrList
->add(FSNS(XML_w
, XML_vertCompress
), sTrue
);
2471 void DocxAttributeOutput::CharEmphasisMark( const SvxEmphasisMarkItem
& rEmphasisMark
)
2473 const char *pEmphasis
;
2475 switch ( rEmphasisMark
.GetValue() )
2477 case EMPHASISMARK_NONE
: pEmphasis
= "none"; break;
2478 case EMPHASISMARK_SIDE_DOTS
: pEmphasis
= "dot"; break;
2479 case EMPHASISMARK_CIRCLE_ABOVE
: pEmphasis
= "circle"; break;
2480 case EMPHASISMARK_DOTS_BELOW
: pEmphasis
= "underDot"; break;
2481 default: pEmphasis
= "comma"; break;
2484 m_pSerializer
->singleElementNS( XML_w
, XML_em
, FSNS( XML_w
, XML_val
), pEmphasis
, FSEND
);
2487 void DocxAttributeOutput::CharTwoLines( const SvxTwoLinesItem
& rTwoLines
)
2489 if ( !rTwoLines
.GetValue() )
2492 if (!m_pEastAsianLayoutAttrList
)
2493 m_pEastAsianLayoutAttrList
= m_pSerializer
->createAttrList();
2494 OString
sTrue((sal_Char
*)"true");
2495 m_pEastAsianLayoutAttrList
->add(FSNS(XML_w
, XML_combine
), sTrue
);
2497 sal_Unicode cStart
= rTwoLines
.GetStartBracket();
2498 sal_Unicode cEnd
= rTwoLines
.GetEndBracket();
2500 if (!cStart
&& !cEnd
)
2504 if ((cStart
== '{') || (cEnd
== '}'))
2505 sBracket
= (sal_Char
*)"curly";
2506 else if ((cStart
== '<') || (cEnd
== '>'))
2507 sBracket
= (sal_Char
*)"angle";
2508 else if ((cStart
== '[') || (cEnd
== ']'))
2509 sBracket
= (sal_Char
*)"square";
2511 sBracket
= (sal_Char
*)"round";
2512 m_pEastAsianLayoutAttrList
->add(FSNS(XML_w
, XML_combineBrackets
), sBracket
);
2515 void DocxAttributeOutput::CharScaleWidth( const SvxCharScaleWidthItem
& rScaleWidth
)
2517 m_pSerializer
->singleElementNS( XML_w
, XML_w
,
2518 FSNS( XML_w
, XML_val
), rtl::OString::valueOf( sal_Int32( rScaleWidth
.GetValue() ) ).getStr(), FSEND
);
2521 void DocxAttributeOutput::CharRelief( const SvxCharReliefItem
& rRelief
)
2523 switch ( rRelief
.GetValue() )
2525 case RELIEF_EMBOSSED
:
2526 m_pSerializer
->singleElementNS( XML_w
, XML_emboss
, FSEND
);
2528 case RELIEF_ENGRAVED
:
2529 m_pSerializer
->singleElementNS( XML_w
, XML_imprint
, FSEND
);
2532 m_pSerializer
->singleElementNS( XML_w
, XML_emboss
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2533 m_pSerializer
->singleElementNS( XML_w
, XML_imprint
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2538 void DocxAttributeOutput::CharHidden( const SvxCharHiddenItem
& rHidden
)
2540 if ( rHidden
.GetValue() )
2541 m_pSerializer
->singleElementNS( XML_w
, XML_vanish
, FSEND
);
2543 m_pSerializer
->singleElementNS( XML_w
, XML_vanish
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2546 void DocxAttributeOutput::TextINetFormat( const SwFmtINetFmt
& rLink
)
2548 const SwTxtINetFmt
* pINetFmt
= rLink
.GetTxtINetFmt();
2549 const SwCharFmt
* pCharFmt
= pINetFmt
->GetCharFmt();
2551 OString
aStyleId( "style" );
2552 aStyleId
+= OString::valueOf( sal_Int32( m_rExport
.GetId( *pCharFmt
) ) );
2554 m_pSerializer
->singleElementNS( XML_w
, XML_rStyle
, FSNS( XML_w
, XML_val
), aStyleId
.getStr(), FSEND
);
2557 void DocxAttributeOutput::TextCharFormat( const SwFmtCharFmt
& )
2559 #if OSL_DEBUG_LEVEL > 0
2560 fprintf( stderr
, "TODO DocxAttributeOutput::TextCharFormat()\n" );
2564 void DocxAttributeOutput::RefField( const SwField
& rFld
, const String
& rRef
)
2566 USHORT nType
= rFld
.GetTyp( )->Which( );
2567 if ( nType
== RES_GETEXPFLD
)
2569 String sCmd
= FieldString( ww::eREF
);
2570 sCmd
.APPEND_CONST_ASC( "\"" );
2572 sCmd
.APPEND_CONST_ASC( "\" " );
2574 m_rExport
.OutputField( &rFld
, ww::eREF
, sCmd
);
2577 // There is nothing to do here for the set fields
2580 void DocxAttributeOutput::HiddenField( const SwField
& /*rFld*/ )
2582 #if OSL_DEBUG_LEVEL > 0
2583 fprintf( stderr
, "TODO DocxAttributeOutput::HiddenField()\n" );
2587 void DocxAttributeOutput::PostitField( const SwField
* /* pFld*/ )
2589 #if OSL_DEBUG_LEVEL > 0
2590 fprintf( stderr
, "TODO DocxAttributeOutput::PostitField()\n" );
2594 bool DocxAttributeOutput::DropdownField( const SwField
* pFld
)
2596 bool bExpand
= false;
2598 ww::eField eType
= ww::eFORMDROPDOWN
;
2599 String sCmd
= FieldString( eType
);
2600 GetExport( ).OutputField( pFld
, eType
, sCmd
);
2605 void DocxAttributeOutput::SetField( const SwField
& rFld
, ww::eField eType
, const String
& rCmd
)
2607 // field bookmarks are handled in the EndRun method
2608 GetExport().OutputField(&rFld
, eType
, rCmd
);
2611 void DocxAttributeOutput::WriteExpand( const SwField
* pFld
)
2613 // Will be written in the next End Run
2615 m_rExport
.OutputField( pFld
, ww::eUNKNOWN
, sCmd
);
2618 void DocxAttributeOutput::WriteField_Impl( const SwField
* pFld
, ww::eField eType
, const String
& rFldCmd
, BYTE nMode
)
2620 struct FieldInfos infos
;
2621 infos
.pField
= pFld
;
2622 infos
.sCmd
= rFldCmd
;
2623 infos
.eType
= eType
;
2624 infos
.bClose
= WRITEFIELD_CLOSE
& nMode
;
2625 infos
.bOpen
= WRITEFIELD_START
& nMode
;
2627 m_Fields
.push_back( infos
);
2631 USHORT nType
= pFld
->GetTyp( )->Which( );
2632 USHORT nSubType
= pFld
->GetSubType();
2634 // TODO Any other field types here ?
2635 if ( ( nType
== RES_SETEXPFLD
) && ( nSubType
& nsSwGetSetExpType::GSE_STRING
) )
2637 const SwSetExpField
*pSet
= ( const SwSetExpField
* )( pFld
);
2638 m_sFieldBkm
= pSet
->GetPar1( );
2640 else if ( nType
== RES_DROPDOWN
)
2642 const SwDropDownField
* pDropDown
= ( const SwDropDownField
* )( pFld
);
2643 m_sFieldBkm
= pDropDown
->GetName( );
2648 void DocxAttributeOutput::WriteBookmarks_Impl( std::vector
< OUString
>& rStarts
,
2649 std::vector
< OUString
>& rEnds
)
2651 for ( std::vector
< OUString
>::const_iterator it
= rStarts
.begin(), end
= rStarts
.end(); it
< end
; ++it
)
2653 OString rName
= OUStringToOString( *it
, RTL_TEXTENCODING_UTF8
).getStr( );
2654 m_rMarksStart
.push_back( rName
);
2658 for ( std::vector
< OUString
>::const_iterator it
= rEnds
.begin(), end
= rEnds
.end(); it
< end
; ++it
)
2660 OString rName
= OUStringToOString( *it
, RTL_TEXTENCODING_UTF8
).getStr( );
2661 m_rMarksEnd
.push_back( rName
);
2666 void DocxAttributeOutput::TextFootnote_Impl( const SwFmtFtn
& rFootnote
)
2668 const SwEndNoteInfo
& rInfo
= rFootnote
.IsEndNote()?
2669 m_rExport
.pDoc
->GetEndNoteInfo(): m_rExport
.pDoc
->GetFtnInfo();
2671 // footnote/endnote run properties
2672 const SwCharFmt
* pCharFmt
= rInfo
.GetAnchorCharFmt( *m_rExport
.pDoc
);
2674 OString
aStyleId( "style" );
2675 aStyleId
+= OString::valueOf( sal_Int32( m_rExport
.GetId( *pCharFmt
) ) );
2677 m_pSerializer
->singleElementNS( XML_w
, XML_rStyle
, FSNS( XML_w
, XML_val
), aStyleId
.getStr(), FSEND
);
2679 // remember the footnote/endnote to
2680 // 1) write the footnoteReference/endnoteReference in EndRunProperties()
2681 // 2) be able to dump them all to footnotes.xml/endnotes.xml
2682 if ( !rFootnote
.IsEndNote() )
2683 m_pFootnotesList
->add( rFootnote
);
2685 m_pEndnotesList
->add( rFootnote
);
2688 void DocxAttributeOutput::FootnoteEndnoteReference()
2691 const SwFmtFtn
*pFootnote
= m_pFootnotesList
->getCurrent( nId
);
2693 // both cannot be set at the same time - if they are, it's a bug
2695 pFootnote
= m_pEndnotesList
->getCurrent( nId
);
2700 sal_Int32 nToken
= pFootnote
->IsEndNote()? XML_endnoteReference
: XML_footnoteReference
;
2703 if ( pFootnote
->GetNumStr().Len() == 0 )
2706 m_pSerializer
->singleElementNS( XML_w
, nToken
,
2707 FSNS( XML_w
, XML_id
), ::rtl::OString::valueOf( nId
).getStr(),
2713 m_pSerializer
->singleElementNS( XML_w
, nToken
,
2714 FSNS( XML_w
, XML_customMarkFollows
), "1",
2715 FSNS( XML_w
, XML_id
), ::rtl::OString::valueOf( nId
).getStr(),
2718 RunText( pFootnote
->GetNumStr() );
2722 void DocxAttributeOutput::FootnotesEndnotes( bool bFootnotes
)
2724 const FootnotesVector
& rVector
= bFootnotes
? m_pFootnotesList
->getVector(): m_pEndnotesList
->getVector();
2726 sal_Int32 nBody
= bFootnotes
? XML_footnotes
: XML_endnotes
;
2727 sal_Int32 nItem
= bFootnotes
? XML_footnote
: XML_endnote
;
2729 m_pSerializer
->startElementNS( XML_w
, nBody
,
2730 FSNS( XML_xmlns
, XML_w
), "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
2733 sal_Int32 nIndex
= 0;
2736 m_pSerializer
->startElementNS( XML_w
, nItem
,
2737 FSNS( XML_w
, XML_id
), OString::valueOf( nIndex
++ ).getStr(),
2738 FSNS( XML_w
, XML_type
), "separator",
2740 m_pSerializer
->startElementNS( XML_w
, XML_p
, FSEND
);
2741 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
2742 m_pSerializer
->singleElementNS( XML_w
, XML_separator
, FSEND
);
2743 m_pSerializer
->endElementNS( XML_w
, XML_r
);
2744 m_pSerializer
->endElementNS( XML_w
, XML_p
);
2745 m_pSerializer
->endElementNS( XML_w
, nItem
);
2748 m_pSerializer
->startElementNS( XML_w
, nItem
,
2749 FSNS( XML_w
, XML_id
), OString::valueOf( nIndex
++ ).getStr(),
2750 FSNS( XML_w
, XML_type
), "continuationSeparator",
2752 m_pSerializer
->startElementNS( XML_w
, XML_p
, FSEND
);
2753 m_pSerializer
->startElementNS( XML_w
, XML_r
, FSEND
);
2754 m_pSerializer
->singleElementNS( XML_w
, XML_continuationSeparator
, FSEND
);
2755 m_pSerializer
->endElementNS( XML_w
, XML_r
);
2756 m_pSerializer
->endElementNS( XML_w
, XML_p
);
2757 m_pSerializer
->endElementNS( XML_w
, nItem
);
2759 // footnotes/endnotes themselves
2760 for ( FootnotesVector::const_iterator i
= rVector
.begin(); i
!= rVector
.end(); ++i
, ++nIndex
)
2762 m_pSerializer
->startElementNS( XML_w
, nItem
,
2763 FSNS( XML_w
, XML_id
), OString::valueOf( nIndex
).getStr(),
2766 const SwNodeIndex
* pIndex
= (*i
)->GetTxtFtn()->GetStartNode();
2768 m_rExport
.WriteSpecialText( pIndex
->GetIndex() + 1,
2769 pIndex
->GetNode().EndOfSectionIndex(),
2770 bFootnotes
? TXT_FTN
: TXT_EDN
);
2772 m_pSerializer
->endElementNS( XML_w
, nItem
);
2775 m_pSerializer
->endElementNS( XML_w
, nBody
);
2779 void DocxAttributeOutput::TextHardBlank( const SwFmtHardBlank
& )
2781 #if OSL_DEBUG_LEVEL > 0
2782 fprintf( stderr
, "TODO DocxAttributeOutput::TextHardBlank()\n" );
2786 void DocxAttributeOutput::ParaLineSpacing_Impl( short nSpace
, short /*nMulti*/ )
2788 if ( !m_pSpacingAttrList
)
2789 m_pSpacingAttrList
= m_pSerializer
->createAttrList();
2793 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_lineRule
), "exact" );
2794 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_line
), OString::valueOf( sal_Int32( -nSpace
) ) );
2796 else if ( nSpace
> 0 )
2798 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_lineRule
), "atLeast" );
2799 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_line
), OString::valueOf( sal_Int32( nSpace
) ) );
2802 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_lineRule
), "auto" );
2805 void DocxAttributeOutput::ParaAdjust( const SvxAdjustItem
& rAdjust
)
2807 const char *pAdjustString
;
2809 switch ( rAdjust
.GetAdjust() )
2811 case SVX_ADJUST_LEFT
:
2812 pAdjustString
= "left";
2814 case SVX_ADJUST_RIGHT
:
2815 pAdjustString
= "right";
2817 case SVX_ADJUST_BLOCKLINE
:
2818 case SVX_ADJUST_BLOCK
:
2819 pAdjustString
= "both";
2821 case SVX_ADJUST_CENTER
:
2822 pAdjustString
= "center";
2825 return; // not supported attribute
2827 m_pSerializer
->singleElementNS( XML_w
, XML_jc
, FSNS( XML_w
, XML_val
), pAdjustString
, FSEND
);
2830 void DocxAttributeOutput::ParaSplit( const SvxFmtSplitItem
& rSplit
)
2832 if (rSplit
.GetValue())
2833 m_pSerializer
->singleElementNS( XML_w
, XML_keepLines
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2835 m_pSerializer
->singleElementNS( XML_w
, XML_keepLines
, FSEND
);
2838 void DocxAttributeOutput::ParaWidows( const SvxWidowsItem
& rWidows
)
2840 if (rWidows
.GetValue())
2841 m_pSerializer
->singleElementNS( XML_w
, XML_widowControl
, FSEND
);
2843 m_pSerializer
->singleElementNS( XML_w
, XML_widowControl
, FSNS( XML_w
, XML_val
), "off", FSEND
);
2846 static void impl_WriteTabElement( FSHelperPtr pSerializer
,
2847 const SvxTabStop
& rTab
, long nCurrentLeft
)
2849 FastAttributeList
*pTabElementAttrList
= pSerializer
->createAttrList();
2851 switch (rTab
.GetAdjustment())
2853 case SVX_TAB_ADJUST_RIGHT
:
2854 pTabElementAttrList
->add( FSNS( XML_w
, XML_val
), OString( (sal_Char
*)"right") );
2856 case SVX_TAB_ADJUST_DECIMAL
:
2857 pTabElementAttrList
->add( FSNS( XML_w
, XML_val
), OString( (sal_Char
*)"decimal") );
2859 case SVX_TAB_ADJUST_CENTER
:
2860 pTabElementAttrList
->add( FSNS( XML_w
, XML_val
), OString( (sal_Char
*)"center") );
2862 case SVX_TAB_ADJUST_DEFAULT
:
2863 case SVX_TAB_ADJUST_LEFT
:
2865 pTabElementAttrList
->add( FSNS( XML_w
, XML_val
), OString( (sal_Char
*)"left") );
2869 pTabElementAttrList
->add( FSNS( XML_w
, XML_pos
), OString::valueOf( rTab
.GetTabPos() + nCurrentLeft
) );
2871 sal_Unicode cFillChar
= rTab
.GetFill();
2873 if (sal_Unicode('.') == cFillChar
)
2874 pTabElementAttrList
->add( FSNS( XML_w
, XML_leader
), OString( (sal_Char
*) "dot" ) );
2875 else if ( sal_Unicode('-') == cFillChar
)
2876 pTabElementAttrList
->add( FSNS( XML_w
, XML_leader
), OString( (sal_Char
*) "hyphen" ) );
2877 else if ( sal_Unicode(0xB7) == cFillChar
) // middle dot
2878 pTabElementAttrList
->add( FSNS( XML_w
, XML_leader
), OString( (sal_Char
*) "middleDot" ) );
2879 else if ( sal_Unicode('_') == cFillChar
)
2880 pTabElementAttrList
->add( FSNS( XML_w
, XML_leader
), OString( (sal_Char
*) "underscore" ) );
2882 pTabElementAttrList
->add( FSNS( XML_w
, XML_leader
), OString( (sal_Char
*) "none" ) );
2884 pSerializer
->singleElementNS( XML_w
, XML_tab
, pTabElementAttrList
);
2887 void DocxAttributeOutput::ParaTabStop( const SvxTabStopItem
& rTabStop
)
2889 const SfxPoolItem
* pLR
= m_rExport
.HasItem( RES_LR_SPACE
);
2890 long nCurrentLeft
= pLR
? ((const SvxLRSpaceItem
*)pLR
)->GetTxtLeft() : 0;
2892 m_pSerializer
->startElementNS( XML_w
, XML_tabs
, FSEND
);
2894 sal_uInt16 nCount
= rTabStop
.Count();
2895 for (sal_uInt16 i
= 0; i
< nCount
; i
++ )
2896 impl_WriteTabElement( m_pSerializer
, rTabStop
[i
], nCurrentLeft
);
2898 m_pSerializer
->endElementNS( XML_w
, XML_tabs
);
2901 void DocxAttributeOutput::ParaHyphenZone( const SvxHyphenZoneItem
& rHyphenZone
)
2903 m_pSerializer
->singleElementNS( XML_w
, XML_suppressAutoHyphens
,
2904 FSNS( XML_w
, XML_val
), rHyphenZone
.IsHyphen( ) ? "false" : "true" ,
2908 void DocxAttributeOutput::ParaNumRule_Impl( const SwTxtNode
* /*pTxtNd*/, sal_Int32 nLvl
, sal_Int32 nNumId
)
2910 if ( USHRT_MAX
!= nNumId
&& 0 != nNumId
)
2912 m_pSerializer
->startElementNS( XML_w
, XML_numPr
, FSEND
);
2913 m_pSerializer
->singleElementNS( XML_w
, XML_ilvl
, FSNS( XML_w
, XML_val
), OString::valueOf( sal_Int32( nLvl
)).getStr(), FSEND
);
2914 m_pSerializer
->singleElementNS( XML_w
, XML_numId
, FSNS( XML_w
, XML_val
), OString::valueOf( sal_Int32( nNumId
)).getStr(), FSEND
);
2915 m_pSerializer
->endElementNS( XML_w
, XML_numPr
);
2919 void DocxAttributeOutput::ParaScriptSpace( const SfxBoolItem
& rScriptSpace
)
2921 USHORT nXmlElement
= 0;
2923 switch ( rScriptSpace
.Which( ) )
2925 case RES_PARATR_SCRIPTSPACE
:
2926 nXmlElement
= XML_autoSpaceDE
;
2928 case RES_PARATR_HANGINGPUNCTUATION
:
2929 nXmlElement
= XML_overflowPunct
;
2931 case RES_PARATR_FORBIDDEN_RULES
:
2932 nXmlElement
= XML_kinsoku
;
2938 m_pSerializer
->singleElementNS( XML_w
, nXmlElement
,
2939 FSNS( XML_w
, XML_val
), rScriptSpace
.GetValue( ) ? "true": "false",
2944 void DocxAttributeOutput::ParaVerticalAlign( const SvxParaVertAlignItem
& rAlign
)
2946 const char *pAlignString
;
2948 switch ( rAlign
.GetValue() )
2950 case SvxParaVertAlignItem::BASELINE
:
2951 pAlignString
= "baseline";
2953 case SvxParaVertAlignItem::TOP
:
2954 pAlignString
= "top";
2956 case SvxParaVertAlignItem::CENTER
:
2957 pAlignString
= "center";
2959 case SvxParaVertAlignItem::BOTTOM
:
2960 pAlignString
= "bottom";
2962 case SvxParaVertAlignItem::AUTOMATIC
:
2963 pAlignString
= "auto";
2966 return; // not supported attribute
2968 m_pSerializer
->singleElementNS( XML_w
, XML_textAlignment
, FSNS( XML_w
, XML_val
), pAlignString
, FSEND
);
2971 void DocxAttributeOutput::ParaSnapToGrid( const SvxParaGridItem
& rGrid
)
2973 m_pSerializer
->singleElementNS( XML_w
, XML_snapToGrid
,
2974 FSNS( XML_w
, XML_val
), rGrid
.GetValue( ) ? "true": "false",
2978 void DocxAttributeOutput::FormatFrameSize( const SwFmtFrmSize
& rSize
)
2980 if ( m_rExport
.bOutFlyFrmAttrs
)
2982 #if OSL_DEBUG_LEVEL > 0
2983 fprintf( stderr
, "TODO DocxAttributeOutput::FormatFrameSize() - Fly frames\n" );
2986 else if ( m_rExport
.bOutPageDescs
)
2988 FastAttributeList
*attrList
= m_pSerializer
->createAttrList( );
2989 if ( m_rExport
.pAktPageDesc
->GetLandscape( ) )
2990 attrList
->add( FSNS( XML_w
, XML_orient
), "landscape" );
2993 attrList
->add( FSNS( XML_w
, XML_w
), OString::valueOf( rSize
.GetWidth( ) ) );
2994 attrList
->add( FSNS( XML_w
, XML_h
), OString::valueOf( rSize
.GetHeight( ) ) );
2996 XFastAttributeListRef
xAttrList( attrList
);
2999 m_pSerializer
->singleElementNS( XML_w
, XML_pgSz
, xAttrList
);
3003 void DocxAttributeOutput::FormatPaperBin( const SvxPaperBinItem
& )
3005 #if OSL_DEBUG_LEVEL > 0
3006 fprintf( stderr
, "TODO DocxAttributeOutput::FormatPaperBin()\n" );
3010 void DocxAttributeOutput::FormatLRSpace( const SvxLRSpaceItem
& rLRSpace
)
3012 if ( m_rExport
.bOutFlyFrmAttrs
)
3014 #if OSL_DEBUG_LEVEL > 0
3015 fprintf( stderr
, "DocxAttributeOutput::FormatLRSpace() - Fly frames\n" );
3018 else if ( m_rExport
.bOutPageDescs
)
3020 if ( !m_pSpacingAttrList
)
3021 m_pSpacingAttrList
= m_pSerializer
->createAttrList();
3024 USHORT nLDist
, nRDist
;
3025 const SfxPoolItem
* pItem
= m_rExport
.HasItem( RES_BOX
);
3028 nRDist
= ((SvxBoxItem
*)pItem
)->CalcLineSpace( BOX_LINE_LEFT
);
3029 nLDist
= ((SvxBoxItem
*)pItem
)->CalcLineSpace( BOX_LINE_RIGHT
);
3032 nLDist
= nRDist
= 0;
3033 nLDist
= nLDist
+ (USHORT
)rLRSpace
.GetLeft();
3034 nRDist
= nRDist
+ (USHORT
)rLRSpace
.GetRight();
3036 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_left
), OString::valueOf( sal_Int32( nLDist
) ) );
3037 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_right
), OString::valueOf( sal_Int32( nRDist
) ) );
3041 FastAttributeList
*pLRSpaceAttrList
= m_pSerializer
->createAttrList();
3043 pLRSpaceAttrList
->add( FSNS( XML_w
, XML_left
), OString::valueOf( (sal_Int32
) rLRSpace
.GetTxtLeft() ) );
3044 pLRSpaceAttrList
->add( FSNS( XML_w
, XML_right
), OString::valueOf( (sal_Int32
) rLRSpace
.GetRight() ) );
3046 sal_Int32 nFirstLineAdjustment
= rLRSpace
.GetTxtFirstLineOfst();
3047 if (nFirstLineAdjustment
> 0)
3048 pLRSpaceAttrList
->add( FSNS( XML_w
, XML_firstLine
), OString::valueOf( nFirstLineAdjustment
) );
3050 pLRSpaceAttrList
->add( FSNS( XML_w
, XML_hanging
), OString::valueOf( - nFirstLineAdjustment
) );
3051 m_pSerializer
->singleElementNS( XML_w
, XML_ind
, pLRSpaceAttrList
);
3055 void DocxAttributeOutput::FormatULSpace( const SvxULSpaceItem
& rULSpace
)
3057 if (!m_pSpacingAttrList
)
3058 m_pSpacingAttrList
= m_pSerializer
->createAttrList();
3060 if ( m_rExport
.bOutFlyFrmAttrs
)
3063 else if (m_rExport
.bOutPageDescs
)
3065 ASSERT( m_rExport
.GetCurItemSet(), "Impossible" );
3066 if ( !m_rExport
.GetCurItemSet() )
3069 HdFtDistanceGlue
aDistances( *m_rExport
.GetCurItemSet() );
3071 if ( aDistances
.HasHeader() )
3074 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_header
),
3075 OString::valueOf( sal_Int32( aDistances
.dyaHdrTop
) ) );
3079 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_top
),
3080 OString::valueOf( sal_Int32( aDistances
.dyaTop
) ) );
3082 if ( aDistances
.HasFooter() )
3085 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_footer
),
3086 OString::valueOf( sal_Int32( aDistances
.dyaHdrBottom
) ) );
3090 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_bottom
),
3091 OString::valueOf( sal_Int32( aDistances
.dyaBottom
) ) );
3096 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_before
),
3097 OString::valueOf( (sal_Int32
)rULSpace
.GetUpper() ) );
3098 m_pSpacingAttrList
->add( FSNS( XML_w
, XML_after
),
3099 OString::valueOf( (sal_Int32
)rULSpace
.GetLower() ) );
3103 void DocxAttributeOutput::FormatSurround( const SwFmtSurround
& )
3105 #if OSL_DEBUG_LEVEL > 0
3106 fprintf( stderr
, "TODO DocxAttributeOutput::FormatSurround()\n" );
3110 void DocxAttributeOutput::FormatVertOrientation( const SwFmtVertOrient
& )
3112 #if OSL_DEBUG_LEVEL > 0
3113 fprintf( stderr
, "TODO DocxAttributeOutput::FormatVertOrientation()\n" );
3117 void DocxAttributeOutput::FormatHorizOrientation( const SwFmtHoriOrient
& )
3119 #if OSL_DEBUG_LEVEL > 0
3120 fprintf( stderr
, "TODO DocxAttributeOutput::FormatHorizOrientation()\n" );
3124 void DocxAttributeOutput::FormatAnchor( const SwFmtAnchor
& )
3126 #if OSL_DEBUG_LEVEL > 0
3127 fprintf( stderr
, "TODO DocxAttributeOutput::FormatAnchor()\n" );
3131 void DocxAttributeOutput::FormatBackground( const SvxBrushItem
& rBrush
)
3133 if ( !m_rExport
.bOutPageDescs
)
3135 OString sColor
= impl_ConvertColor( rBrush
.GetColor( ) );
3136 m_pSerializer
->singleElementNS( XML_w
, XML_shd
,
3137 FSNS( XML_w
, XML_fill
), sColor
.getStr( ),
3141 #if OSL_DEBUG_LEVEL > 0
3142 fprintf( stderr
, "TODO DocxAttributeOutput::FormatBackground()\n" );
3146 void DocxAttributeOutput::FormatBox( const SvxBoxItem
& rBox
)
3149 if ( !m_bOpenedSectPr
)
3151 // Normally open the borders tag for paragraphs
3152 m_pSerializer
->startElementNS( XML_w
, XML_pBdr
, FSEND
);
3155 impl_pageBorders( m_pSerializer
, rBox
);
3157 if ( m_bOpenedSectPr
)
3159 // Special handling for pgBorder
3160 m_pSerializer
->mergeTopMarks( sax_fastparser::MERGE_MARKS_PREPEND
);
3161 m_pSerializer
->mergeTopMarks( );
3165 // Normally close the borders tag for paragraphs
3166 m_pSerializer
->endElementNS( XML_w
, XML_pBdr
);
3170 void DocxAttributeOutput::FormatColumns_Impl( USHORT nCols
, const SwFmtCol
& rCol
, bool bEven
, SwTwips nPageSize
)
3172 // Get the columns attributes
3173 FastAttributeList
*pColsAttrList
= m_pSerializer
->createAttrList();
3175 pColsAttrList
->add( FSNS( XML_w
, XML_num
),
3176 OString::valueOf( sal_Int32( nCols
) ). getStr( ) );
3178 const char* pEquals
= "false";
3181 USHORT nWidth
= rCol
.GetGutterWidth( true );
3182 pColsAttrList
->add( FSNS( XML_w
, XML_space
),
3183 OString::valueOf( sal_Int32( nWidth
) ).getStr( ) );
3188 pColsAttrList
->add( FSNS( XML_w
, XML_equalWidth
), pEquals
);
3190 bool bHasSep
= COLADJ_NONE
== rCol
.GetLineAdj( );
3191 pColsAttrList
->add( FSNS( XML_w
, XML_sep
), bHasSep
? "true" : "false" );
3193 // Write the element
3194 m_pSerializer
->startElementNS( XML_w
, XML_cols
, pColsAttrList
);
3196 // Write the columns width if non-equals
3197 const SwColumns
& rColumns
= rCol
.GetColumns( );
3200 for ( USHORT n
= 0; n
< nCols
; ++n
)
3202 FastAttributeList
*pColAttrList
= m_pSerializer
->createAttrList();
3203 USHORT nWidth
= rCol
.CalcPrtColWidth( n
, ( USHORT
) nPageSize
);
3204 pColAttrList
->add( FSNS( XML_w
, XML_w
),
3205 OString::valueOf( sal_Int32( nWidth
) ).getStr( ) );
3207 if ( n
+ 1 != nCols
)
3209 USHORT nSpacing
= rColumns
[n
]->GetRight( ) + rColumns
[n
+ 1]->GetLeft( );
3210 pColAttrList
->add( FSNS( XML_w
, XML_space
),
3211 OString::valueOf( sal_Int32( nSpacing
) ).getStr( ) );
3214 m_pSerializer
->singleElementNS( XML_w
, XML_col
, pColAttrList
);
3218 m_pSerializer
->endElementNS( XML_w
, XML_cols
);
3221 void DocxAttributeOutput::FormatKeep( const SvxFmtKeepItem
& )
3223 m_pSerializer
->singleElementNS( XML_w
, XML_keepNext
, FSEND
);
3226 void DocxAttributeOutput::FormatTextGrid( const SwTextGridItem
& )
3228 #if OSL_DEBUG_LEVEL > 0
3229 fprintf( stderr
, "TODO DocxAttributeOutput::FormatTextGrid()\n" );
3233 void DocxAttributeOutput::FormatLineNumbering( const SwFmtLineNumber
& rNumbering
)
3235 if ( !rNumbering
.IsCount( ) )
3236 m_pSerializer
->singleElementNS( XML_w
, XML_suppressLineNumbers
, FSEND
);
3239 void DocxAttributeOutput::FormatFrameDirection( const SvxFrameDirectionItem
& rDirection
)
3243 short nDir
= rDirection
.GetValue();
3245 if ( nDir
== FRMDIR_ENVIRONMENT
)
3246 nDir
= GetExport( ).GetDefaultFrameDirection( );
3251 case FRMDIR_HORI_LEFT_TOP
:
3252 sTextFlow
= OString( "lrTb" );
3254 case FRMDIR_HORI_RIGHT_TOP
:
3255 sTextFlow
= OString( "lrTb" );
3258 case FRMDIR_VERT_TOP_LEFT
: // many things but not this one
3259 case FRMDIR_VERT_TOP_RIGHT
:
3260 sTextFlow
= OString( "tbRl" );
3264 if ( m_rExport
.bOutPageDescs
)
3266 m_pSerializer
->singleElementNS( XML_w
, XML_textDirection
,
3267 FSNS( XML_w
, XML_val
), sTextFlow
.getStr( ),
3270 m_pSerializer
->singleElementNS( XML_w
, XML_bidi
, FSEND
);
3272 else if ( !m_rExport
.bOutFlyFrmAttrs
)
3275 m_pSerializer
->singleElementNS( XML_w
, XML_bidi
, FSEND
);
3279 DocxAttributeOutput::DocxAttributeOutput( DocxExport
&rExport
, FSHelperPtr pSerializer
, oox::drawingml::DrawingML
* pDrawingML
)
3280 : m_rExport( rExport
),
3281 m_pSerializer( pSerializer
),
3282 m_rDrawingML( *pDrawingML
),
3283 m_pFontsAttrList( NULL
),
3284 m_pEastAsianLayoutAttrList( NULL
),
3285 m_pCharLangAttrList( NULL
),
3286 m_pSpacingAttrList( NULL
),
3287 m_pHyperlinkAttrList( NULL
),
3288 m_pFootnotesList( new ::docx::FootnotesList() ),
3289 m_pEndnotesList( new ::docx::FootnotesList() ),
3290 m_pSectionInfo( NULL
),
3291 m_pRedlineData( NULL
),
3293 m_bOpenedSectPr( false ),
3296 m_pTableWrt( NULL
),
3297 m_bTableCellOpen( false ),
3299 m_bParagraphOpened( false ),
3300 m_nColBreakStatus( COLBRK_NONE
)
3304 DocxAttributeOutput::~DocxAttributeOutput()
3306 delete m_pFontsAttrList
, m_pFontsAttrList
= NULL
;
3307 delete m_pEastAsianLayoutAttrList
, m_pEastAsianLayoutAttrList
= NULL
;
3308 delete m_pCharLangAttrList
, m_pCharLangAttrList
= NULL
;
3309 delete m_pSpacingAttrList
, m_pSpacingAttrList
= NULL
;
3310 delete m_pHyperlinkAttrList
, m_pHyperlinkAttrList
= NULL
;
3312 delete m_pFootnotesList
, m_pFootnotesList
= NULL
;
3313 delete m_pEndnotesList
, m_pEndnotesList
= NULL
;
3315 delete m_pTableWrt
, m_pTableWrt
= NULL
;
3318 MSWordExportBase
& DocxAttributeOutput::GetExport()
3323 bool DocxAttributeOutput::HasFootnotes()
3325 return !m_pFootnotesList
->isEmpty();
3328 bool DocxAttributeOutput::HasEndnotes()
3330 return !m_pEndnotesList
->isEmpty();