Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / filter / xml / xmltble.cxx
blob: e7f8016becb9ee8e043650ae648ff9bf267ab7d4 [file] [log] [blame]
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"
#include <com/sun/star/text/XTextTable.hpp>
#include <com/sun/star/text/XTextSection.hpp>
#include <hintids.hxx>
#include <rtl/ustrbuf.hxx>
#include <xmloff/xmlnmspe.hxx>
#include <xmloff/xmltoken.hxx>
#include <xmloff/xmluconv.hxx>
#include <xmloff/numehelp.hxx>
#include <svl/cntnrsrt.hxx>
#include <svl/zforlist.hxx>
#include <editeng/brshitem.hxx>
#include <editeng/boxitem.hxx>
#include <fmtrowsplt.hxx>
#include <editeng/frmdiritem.hxx>
#include <list>
#include "swtable.hxx"
#include "doc.hxx"
#include "pam.hxx"
#include "frmfmt.hxx"
#include "wrtswtbl.hxx"
#include "fmtfsize.hxx"
#include "fmtornt.hxx"
#include "cellatr.hxx"
#include "ddefld.hxx"
#include "swddetbl.hxx"
#include <ndole.hxx>
#include <xmloff/nmspmap.hxx>
#include <sfx2/linkmgr.hxx> // for cTokenSeperator
#include "unotbl.hxx"
#include "xmltexte.hxx"
#include "xmlexp.hxx"
using ::rtl::OUString;
using ::rtl::OUStringBuffer;
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::text;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::container;
using namespace ::xmloff::token;
using table::XCell;
class SwXMLTableColumn_Impl : public SwWriteTableCol
{
OUString sStyleName;
sal_uInt32 nRelWidth;
public:
SwXMLTableColumn_Impl( sal_uInt32 nPosition ) :
SwWriteTableCol( nPosition ),
nRelWidth( 0UL )
{};
void SetStyleName( const OUString& rName ) { sStyleName = rName; }
const OUString& GetStyleName() const { return sStyleName; }
void SetRelWidth( sal_uInt32 nSet ) { nRelWidth = nSet; }
sal_uInt32 GetRelWidth() const { return nRelWidth; }
};
sal_Int32 SwXMLTableColumnCmpWidth_Impl( const SwXMLTableColumn_Impl& r1,
const SwXMLTableColumn_Impl& r2 )
{
sal_Int32 n = (sal_Int32)r1.GetWidthOpt() - (sal_Int32)r2.GetWidthOpt();
if( !n )
n = (sal_Int32)r1.GetRelWidth() - (sal_Int32)r2.GetRelWidth();
return n;
}
// ---------------------------------------------------------------------
typedef SwXMLTableColumn_Impl *SwXMLTableColumnPtr;
SV_DECL_PTRARR_SORT_DEL( SwXMLTableColumns_Impl, SwXMLTableColumnPtr, 5, 5 )
SV_IMPL_OP_PTRARR_SORT( SwXMLTableColumns_Impl, SwXMLTableColumnPtr )
DECLARE_CONTAINER_SORT( SwXMLTableColumnsSortByWidth_Impl,
SwXMLTableColumn_Impl )
IMPL_CONTAINER_SORT( SwXMLTableColumnsSortByWidth_Impl, SwXMLTableColumn_Impl,
SwXMLTableColumnCmpWidth_Impl )
class SwXMLTableLines_Impl
{
SwXMLTableColumns_Impl aCols;
const SwTableLines *pLines;
sal_uInt32 nWidth;
public:
SwXMLTableLines_Impl( const SwTableLines& rLines );
~SwXMLTableLines_Impl() {}
sal_uInt32 GetWidth() const { return nWidth; }
const SwTableLines *GetLines() const { return pLines; }
const SwXMLTableColumns_Impl& GetColumns() const { return aCols; }
};
SwXMLTableLines_Impl::SwXMLTableLines_Impl( const SwTableLines& rLines ) :
pLines( &rLines ),
nWidth( 0UL )
{
#ifdef DBG_UTIL
sal_uInt32 nEndCPos = 0U;
#endif
sal_uInt16 nLines = rLines.Count();
sal_uInt16 nLine;
for( nLine=0U; nLine<nLines; nLine++ )
{
const SwTableLine *pLine = rLines[nLine];
const SwTableBoxes& rBoxes = pLine->GetTabBoxes();
sal_uInt16 nBoxes = rBoxes.Count();
sal_uInt32 nCPos = 0U;
for( sal_uInt16 nBox=0U; nBox<nBoxes; nBox++ )
{
const SwTableBox *pBox = rBoxes[nBox];
if( nBox < nBoxes-1U || nWidth==0UL )
{
nCPos = nCPos + SwWriteTable::GetBoxWidth( pBox );
SwXMLTableColumn_Impl *pCol =
new SwXMLTableColumn_Impl( nCPos );
if( !aCols.Insert( pCol ) )
delete pCol;
if( nBox==nBoxes-1U )
{
ASSERT( nLine==0U && nWidth==0UL,
"parent width will be lost" );
nWidth = nCPos;
}
}
else
{
#ifdef DBG_UTIL
sal_uInt32 nCheckPos =
nCPos + SwWriteTable::GetBoxWidth( pBox );
if( !nEndCPos )
{
nEndCPos = nCheckPos;
}
else
{
/*
ASSERT( SwXMLTableColumn_impl(nCheckPos) ==
SwXMLTableColumn_Impl(nEndCPos),
"rows have different total widths" );
*/
}
#endif
nCPos = nWidth;
#ifdef DBG_UTIL
SwXMLTableColumn_Impl aCol( nWidth );
ASSERT( aCols.Seek_Entry(&aCol), "couldn't find last column" );
ASSERT( SwXMLTableColumn_Impl(nCheckPos) ==
SwXMLTableColumn_Impl(nCPos),
"rows have different total widths" );
#endif
}
}
}
}
typedef SwXMLTableLines_Impl *SwXMLTableLinesPtr;
DECLARE_LIST( SwXMLTableLinesCache_Impl, SwXMLTableLinesPtr )
// ---------------------------------------------------------------------
typedef SwFrmFmt *SwFrmFmtPtr;
DECLARE_LIST( SwXMLFrmFmts_Impl, SwFrmFmtPtr )
class SwXMLTableFrmFmtsSort_Impl : public SwXMLFrmFmts_Impl
{
public:
SwXMLTableFrmFmtsSort_Impl ( sal_uInt16 nInit, sal_uInt16 nGrow ) :
SwXMLFrmFmts_Impl( nInit, nGrow )
{}
sal_Bool AddRow( SwFrmFmt& rFrmFmt, const OUString& rNamePrefix, sal_uInt32 nLine );
sal_Bool AddCell( SwFrmFmt& rFrmFmt, const OUString& rNamePrefix,
sal_uInt32 nCol, sal_uInt32 nRow, sal_Bool bTop );
};
sal_Bool SwXMLTableFrmFmtsSort_Impl::AddRow( SwFrmFmt& rFrmFmt,
const OUString& rNamePrefix,
sal_uInt32 nLine )
{
const SwFmtFrmSize *pFrmSize = 0;
const SwFmtRowSplit* pRowSplit = 0;
const SvxBrushItem *pBrush = 0;
const SfxItemSet& rItemSet = rFrmFmt.GetAttrSet();
const SfxPoolItem *pItem;
if( SFX_ITEM_SET == rItemSet.GetItemState( RES_FRM_SIZE, sal_False, &pItem ) )
pFrmSize = (const SwFmtFrmSize *)pItem;
if( SFX_ITEM_SET == rItemSet.GetItemState( RES_ROW_SPLIT, sal_False, &pItem ) )
pRowSplit = (const SwFmtRowSplit *)pItem;
if( SFX_ITEM_SET == rItemSet.GetItemState( RES_BACKGROUND, sal_False, &pItem ) )
pBrush = (const SvxBrushItem *)pItem;
// empty styles have not to be exported
if( !pFrmSize && !pBrush && !pRowSplit )
return sal_False;
// order is: -/brush, size/-, size/brush
sal_uInt32 nCount2 = Count();
sal_Bool bInsert = sal_True;
sal_uInt32 i;
for( i = 0; i < nCount2; ++i )
{
const SwFmtFrmSize *pTestFrmSize = 0;
const SwFmtRowSplit* pTestRowSplit = 0;
const SvxBrushItem *pTestBrush = 0;
const SwFrmFmt *pTestFmt = GetObject(i);
const SfxItemSet& rTestSet = pTestFmt->GetAttrSet();
if( SFX_ITEM_SET == rTestSet.GetItemState( RES_FRM_SIZE, sal_False,
&pItem ) )
{
if( !pFrmSize )
break;
pTestFrmSize = (const SwFmtFrmSize *)pItem;
}
else
{
if( pFrmSize )
continue;
}
if( SFX_ITEM_SET == rTestSet.GetItemState( RES_BACKGROUND, sal_False,
&pItem ) )
{
if( !pBrush )
break;
pTestBrush = (const SvxBrushItem *)pItem;
}
else
{
if( pBrush )
continue;
}
if( SFX_ITEM_SET == rTestSet.GetItemState( RES_ROW_SPLIT, sal_False,
&pItem ) )
{
if( !pRowSplit )
break;
pTestRowSplit = (const SwFmtRowSplit *)pItem;
}
else
{
if( pRowSplit )
continue;
}
if( pFrmSize &&
( pFrmSize->GetHeightSizeType() != pTestFrmSize->GetHeightSizeType() ||
pFrmSize->GetHeight() != pTestFrmSize->GetHeight() ) )
continue;
if( pBrush && (*pBrush != *pTestBrush) )
continue;
if( pRowSplit && (!pRowSplit->GetValue() != !pTestRowSplit->GetValue()) )
continue;
// found!
const String& rFmtName = pTestFmt->GetName();
rFrmFmt.SetName( rFmtName );
bInsert = sal_False;
break;
}
if( bInsert )
{
OUStringBuffer sBuffer( rNamePrefix.getLength() + 4UL );
sBuffer.append( rNamePrefix );
sBuffer.append( (sal_Unicode)'.' );
sBuffer.append( (sal_Int32)(nLine+1UL) );
rFrmFmt.SetName( sBuffer.makeStringAndClear() );
Insert( &rFrmFmt, i );
}
return bInsert;
}
void lcl_GetTblBoxColStr( sal_uInt16 nCol, String& rNm );
void lcl_xmltble_appendBoxPrefix( OUStringBuffer& rBuffer,
const OUString& rNamePrefix,
sal_uInt32 nCol, sal_uInt32 nRow, sal_Bool bTop )
{
rBuffer.append( rNamePrefix );
rBuffer.append( (sal_Unicode)'.' );
if( bTop )
{
String sTmp;
lcl_GetTblBoxColStr( (sal_uInt16)nCol, sTmp );
rBuffer.append( sTmp );
}
else
{
rBuffer.append( (sal_Int32)(nCol + 1));
rBuffer.append( (sal_Unicode)'.' );
}
rBuffer.append( (sal_Int32)(nRow + 1));
}
sal_Bool SwXMLTableFrmFmtsSort_Impl::AddCell( SwFrmFmt& rFrmFmt,
const OUString& rNamePrefix,
sal_uInt32 nCol, sal_uInt32 nRow, sal_Bool bTop )
{
const SwFmtVertOrient *pVertOrient = 0;
const SvxBrushItem *pBrush = 0;
const SvxBoxItem *pBox = 0;
const SwTblBoxNumFormat *pNumFmt = 0;
const SvxFrameDirectionItem *pFrameDir = 0;
const SfxItemSet& rItemSet = rFrmFmt.GetAttrSet();
const SfxPoolItem *pItem;
if( SFX_ITEM_SET == rItemSet.GetItemState( RES_VERT_ORIENT, sal_False,
&pItem ) )
pVertOrient = (const SwFmtVertOrient *)pItem;
if( SFX_ITEM_SET == rItemSet.GetItemState( RES_BACKGROUND, sal_False, &pItem ) )
pBrush = (const SvxBrushItem *)pItem;
if( SFX_ITEM_SET == rItemSet.GetItemState( RES_BOX, sal_False, &pItem ) )
pBox = (const SvxBoxItem *)pItem;
if ( SFX_ITEM_SET == rItemSet.GetItemState( RES_BOXATR_FORMAT,
sal_False, &pItem ) )
pNumFmt = (const SwTblBoxNumFormat *)pItem;
if ( SFX_ITEM_SET == rItemSet.GetItemState( RES_FRAMEDIR,
sal_False, &pItem ) )
pFrameDir = (const SvxFrameDirectionItem *)pItem;
// empty styles have not to be exported
if( !pVertOrient && !pBrush && !pBox && !pNumFmt && !pFrameDir )
return sal_False;
// order is: -/-/-/num,
// -/-/box/-, --/-/box/num,
// -/brush/-/-, -/brush/-/num, -/brush/box/-, -/brush/box/num,
// vert/-/-/-, vert/-/-/num, vert/-/box/-, ver/-/box/num,
// vert/brush/-/-, vert/brush/-/num, vert/brush/box/-,
// vert/brush/box/num
sal_uInt32 nCount2 = Count();
sal_Bool bInsert = sal_True;
sal_uInt32 i;
for( i = 0; i < nCount2; ++i )
{
const SwFmtVertOrient *pTestVertOrient = 0;
const SvxBrushItem *pTestBrush = 0;
const SvxBoxItem *pTestBox = 0;
const SwTblBoxNumFormat *pTestNumFmt = 0;
const SvxFrameDirectionItem *pTestFrameDir = 0;
const SwFrmFmt *pTestFmt = GetObject(i);
const SfxItemSet& rTestSet = pTestFmt->GetAttrSet();
if( SFX_ITEM_SET == rTestSet.GetItemState( RES_VERT_ORIENT, sal_False,
&pItem ) )
{
if( !pVertOrient )
break;
pTestVertOrient = (const SwFmtVertOrient *)pItem;
}
else
{
if( pVertOrient )
continue;
}
if( SFX_ITEM_SET == rTestSet.GetItemState( RES_BACKGROUND, sal_False,
&pItem ) )
{
if( !pBrush )
break;
pTestBrush = (const SvxBrushItem *)pItem;
}
else
{
if( pBrush )
continue;
}
if( SFX_ITEM_SET == rTestSet.GetItemState( RES_BOX, sal_False, &pItem ) )
{
if( !pBox )
break;
pTestBox = (const SvxBoxItem *)pItem;
}
else
{
if( pBox )
continue;
}
if ( SFX_ITEM_SET == rTestSet.GetItemState( RES_BOXATR_FORMAT,
sal_False, &pItem ) )
{
if( !pNumFmt )
break;
pTestNumFmt = (const SwTblBoxNumFormat *)pItem;
}
else
{
if( pNumFmt )
continue;
}
if ( SFX_ITEM_SET == rTestSet.GetItemState( RES_FRAMEDIR,
sal_False, &pItem ) )
{
if( !pFrameDir )
break;
pTestFrameDir = (const SvxFrameDirectionItem *)pItem;
}
else
{
if( pFrameDir )
continue;
}
if( pVertOrient &&
pVertOrient->GetVertOrient() != pTestVertOrient->GetVertOrient() )
continue;
if( pBrush && ( *pBrush != *pTestBrush ) )
continue;
if( pBox && ( *pBox != *pTestBox ) )
continue;
if( pNumFmt && pNumFmt->GetValue() != pTestNumFmt->GetValue() )
continue;
if( pFrameDir && pFrameDir->GetValue() != pTestFrameDir->GetValue() )
continue;
// found!
const String& rFmtName = pTestFmt->GetName();
rFrmFmt.SetName( rFmtName );
bInsert = sal_False;
break;
}
if( bInsert )
{
OUStringBuffer sBuffer( rNamePrefix.getLength() + 8UL );
lcl_xmltble_appendBoxPrefix( sBuffer, rNamePrefix, nCol, nRow, bTop );
rFrmFmt.SetName( sBuffer.makeStringAndClear() );
Insert( &rFrmFmt, i );
}
return bInsert;
}
// ---------------------------------------------------------------------
class SwXMLTableInfo_Impl
{
const SwTable *pTable;
Reference < XTextSection > xBaseSection;
sal_Bool bBaseSectionValid;
public:
inline SwXMLTableInfo_Impl( const SwTable *pTbl );
const SwTable *GetTable() const { return pTable; }
const SwFrmFmt *GetTblFmt() const { return pTable->GetFrmFmt(); }
sal_Bool IsBaseSectionValid() const { return bBaseSectionValid; }
const Reference < XTextSection >& GetBaseSection() const { return xBaseSection; }
inline void SetBaseSection( const Reference < XTextSection >& rBase );
};
inline SwXMLTableInfo_Impl::SwXMLTableInfo_Impl( const SwTable *pTbl ) :
pTable( pTbl ),
bBaseSectionValid( sal_False )
{
}
inline void SwXMLTableInfo_Impl::SetBaseSection(
const Reference < XTextSection >& rBaseSection )
{
xBaseSection = rBaseSection;
bBaseSectionValid = sal_True;
}
// ---------------------------------------------------------------------
void SwXMLExport::ExportTableColumnStyle( const SwXMLTableColumn_Impl& rCol )
{
// <style:style ...>
CheckAttrList();
// style:name="..."
sal_Bool bEncoded = sal_False;
AddAttribute( XML_NAMESPACE_STYLE, XML_NAME,
EncodeStyleName( rCol.GetStyleName(), &bEncoded ) );
if( bEncoded )
AddAttribute( XML_NAMESPACE_STYLE, XML_DISPLAY_NAME, rCol.GetStyleName() );
// style:family="table-column"
AddAttribute( XML_NAMESPACE_STYLE, XML_FAMILY, XML_TABLE_COLUMN );
{
SvXMLElementExport aElem( *this, XML_NAMESPACE_STYLE, XML_STYLE, sal_True,
sal_True );
OUStringBuffer sValue;
if( rCol.GetWidthOpt() )
{
GetTwipUnitConverter().convertMeasure( sValue, rCol.GetWidthOpt() );
AddAttribute( XML_NAMESPACE_STYLE, XML_COLUMN_WIDTH,
sValue.makeStringAndClear() );
}
if( rCol.GetRelWidth() )
{
sValue.append( (sal_Int32)rCol.GetRelWidth() );
sValue.append( (sal_Unicode)'*' );
AddAttribute( XML_NAMESPACE_STYLE, XML_REL_COLUMN_WIDTH,
sValue.makeStringAndClear() );
}
{
SvXMLElementExport aElemExport( *this, XML_NAMESPACE_STYLE,
XML_TABLE_COLUMN_PROPERTIES,
sal_True, sal_True );
}
}
}
void SwXMLExport::ExportTableLinesAutoStyles( const SwTableLines& rLines,
sal_uInt32 nAbsWidth, sal_uInt32 nBaseWidth,
const OUString& rNamePrefix,
SwXMLTableColumnsSortByWidth_Impl& rExpCols,
SwXMLTableFrmFmtsSort_Impl& rExpRows,
SwXMLTableFrmFmtsSort_Impl& rExpCells,
SwXMLTableInfo_Impl& rTblInfo,
sal_Bool bTop )
{
// pass 1: calculate columns
SwXMLTableLines_Impl *pLines =
new SwXMLTableLines_Impl( rLines );
if( !pTableLines )
pTableLines = new SwXMLTableLinesCache_Impl( 5, 5 );
pTableLines->Insert( pLines, pTableLines->Count() );
OUStringBuffer sBuffer( rNamePrefix.getLength() + 8L );
// pass 2: export column styles
{
const SwXMLTableColumns_Impl& rCols = pLines->GetColumns();
sal_uInt32 nCPos = 0U;
sal_uInt16 nColumns = rCols.Count();
for( sal_uInt16 nColumn=0U; nColumn<nColumns; nColumn++ )
{
SwXMLTableColumn_Impl *pColumn = rCols[nColumn];
sal_uInt32 nOldCPos = nCPos;
nCPos = pColumn->GetPos();
sal_uInt32 nWidth = nCPos - nOldCPos;
// If a base width is given, the table has either an automatic
// or margin alignment, or an percentage width. In either case,
// relative widths should be exported.
if( nBaseWidth )
{
pColumn->SetRelWidth( nWidth );
}
// If an absolute width is given, the table either has a fixed
// width, or the current width is known from the layout. In the
// later case, a base width is set in addition and must be used
// to "absoultize" the relative column width.
if( nAbsWidth )
{
sal_uInt32 nColAbsWidth = nWidth;
if( nBaseWidth )
{
nColAbsWidth *= nAbsWidth;
nColAbsWidth += (nBaseWidth/2UL);
nColAbsWidth /= nBaseWidth;
}
pColumn->SetWidthOpt( nColAbsWidth, sal_False );
}
sal_uLong nExpPos = 0;
if( rExpCols.Seek_Entry( pColumn, &nExpPos ) )
{
pColumn->SetStyleName(
rExpCols.GetObject(nExpPos)->GetStyleName() );
}
else
{
sBuffer.append( rNamePrefix );
sBuffer.append( (sal_Unicode)'.' );
if( bTop )
{
String sTmp;
lcl_GetTblBoxColStr( nColumn, sTmp );
sBuffer.append( sTmp );
}
else
{
sBuffer.append( (sal_Int32)(nColumn + 1U) );
}
pColumn->SetStyleName( sBuffer.makeStringAndClear() );
ExportTableColumnStyle( *pColumn );
rExpCols.Insert( pColumn );
}
}
}
// pass 3: export line/rows
sal_uInt16 nLines = rLines.Count();
for( sal_uInt16 nLine=0U; nLine<nLines; nLine++ )
{
SwTableLine *pLine = rLines[nLine];
SwFrmFmt *pFrmFmt = pLine->GetFrmFmt();
if( rExpRows.AddRow( *pFrmFmt, rNamePrefix, nLine ) )
ExportFmt( *pFrmFmt, XML_TABLE_ROW );
const SwTableBoxes& rBoxes = pLine->GetTabBoxes();
sal_uInt16 nBoxes = rBoxes.Count();
sal_uInt32 nCPos = 0U;
sal_uInt16 nCol = 0U;
for( sal_uInt16 nBox=0U; nBox<nBoxes; nBox++ )
{
SwTableBox *pBox = rBoxes[nBox];
if( nBox < nBoxes-1U )
nCPos = nCPos + SwWriteTable::GetBoxWidth( pBox );
else
nCPos = pLines->GetWidth();
// Und ihren Index
sal_uInt16 nOldCol = nCol;
SwXMLTableColumn_Impl aCol( nCPos );
#ifdef DBG_UTIL
sal_Bool bFound =
#endif
pLines->GetColumns().Seek_Entry( &aCol, &nCol );
ASSERT( bFound, "couldn't find column" );
const SwStartNode *pBoxSttNd = pBox->GetSttNd();
if( pBoxSttNd )
{
SwFrmFmt *pFrmFmt2 = pBox->GetFrmFmt();
if( rExpCells.AddCell( *pFrmFmt2, rNamePrefix, nOldCol, nLine,
bTop) )
ExportFmt( *pFrmFmt2, XML_TABLE_CELL );
Reference < XCell > xCell = SwXCell::CreateXCell(
(SwFrmFmt *)rTblInfo.GetTblFmt(),
pBox,
(SwTable *)rTblInfo.GetTable() );
if (xCell.is())
{
Reference < XText > xText( xCell, UNO_QUERY );
if( !rTblInfo.IsBaseSectionValid() )
{
Reference<XPropertySet> xCellPropertySet( xCell,
UNO_QUERY );
OUString sTextSection( RTL_CONSTASCII_USTRINGPARAM("TextSection") );
Any aAny = xCellPropertySet->getPropertyValue(sTextSection);
Reference < XTextSection > xTextSection;
aAny >>= xTextSection;
rTblInfo.SetBaseSection( xTextSection );
}
const bool bExportContent = (getExportFlags() & EXPORT_CONTENT ) != 0;
if ( !bExportContent )
{
// AUTOSTYLES - not needed anymore if we are currently exporting content.xml
GetTextParagraphExport()->collectTextAutoStyles(
xText, rTblInfo.GetBaseSection(), IsShowProgress() );
}
}
else {
DBG_ERROR("here should be a XCell");
}
}
else
{
lcl_xmltble_appendBoxPrefix( sBuffer, rNamePrefix, nOldCol,
nLine, bTop );
ExportTableLinesAutoStyles( pBox->GetTabLines(),
nAbsWidth, nBaseWidth,
sBuffer.makeStringAndClear(),
rExpCols, rExpRows, rExpCells,
rTblInfo );
}
nCol++;
}
}
}
void SwXMLExport::ExportTableAutoStyles( const SwTableNode& rTblNd )
{
const SwTable& rTbl = rTblNd.GetTable();
const SwFrmFmt *pTblFmt = rTbl.GetFrmFmt();
if( pTblFmt )
{
sal_Int16 eTabHoriOri = pTblFmt->GetHoriOrient().GetHoriOrient();
const SwFmtFrmSize& rFrmSize = pTblFmt->GetFrmSize();
sal_uInt32 nAbsWidth = rFrmSize.GetSize().Width();
sal_uInt32 nBaseWidth = 0UL;
sal_Int8 nPrcWidth = rFrmSize.GetWidthPercent();
sal_Bool bFixAbsWidth = nPrcWidth != 0 || /*text::*/HoriOrientation::NONE == eTabHoriOri
|| /*text::*/HoriOrientation::FULL == eTabHoriOri;
if( bFixAbsWidth )
{
nBaseWidth = nAbsWidth;
nAbsWidth = pTblFmt->FindLayoutRect(sal_True).Width();
if( !nAbsWidth )
{
// TODO???
}
}
ExportTableFmt( *pTblFmt, nAbsWidth );
OUString sName( pTblFmt->GetName() );
SwXMLTableColumnsSortByWidth_Impl aExpCols( 10, 10 );
SwXMLTableFrmFmtsSort_Impl aExpRows( 10, 10 );
SwXMLTableFrmFmtsSort_Impl aExpCells( 10, 10 );
SwXMLTableInfo_Impl aTblInfo( &rTbl );
ExportTableLinesAutoStyles( rTbl.GetTabLines(), nAbsWidth, nBaseWidth,
sName, aExpCols, aExpRows, aExpCells,
aTblInfo, sal_True);
}
}
// ---------------------------------------------------------------------
void SwXMLExport::ExportTableBox( const SwTableBox& rBox,
sal_uInt16 nColSpan,
sal_uInt16 nRowSpan,
SwXMLTableInfo_Impl& rTblInfo )
{
const SwStartNode *pBoxSttNd = rBox.GetSttNd();
if( pBoxSttNd )
{
const SwFrmFmt *pFrmFmt = rBox.GetFrmFmt();
if( pFrmFmt )
{
const String& rName = pFrmFmt->GetName();
if( rName.Len() )
{
AddAttribute( XML_NAMESPACE_TABLE, XML_STYLE_NAME, EncodeStyleName(rName) );
}
}
}
if( nRowSpan != 1 )
{
OUStringBuffer sTmp;
sTmp.append( (sal_Int32)nRowSpan );
AddAttribute( XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_SPANNED,
sTmp.makeStringAndClear() );
}
if( nColSpan != 1 )
{
OUStringBuffer sTmp;
sTmp.append( (sal_Int32)nColSpan );
AddAttribute( XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_SPANNED,
sTmp.makeStringAndClear() );
}
{
if( pBoxSttNd )
{
// start node -> normal cell
// get cell range for table
Reference<XCell> xCell = SwXCell::CreateXCell( (SwFrmFmt *)rTblInfo.GetTblFmt(),
(SwTableBox *)&rBox,
(SwTable *)rTblInfo.GetTable() );
if (xCell.is())
{
Reference<XText> xText( xCell, UNO_QUERY );
// get formula (and protection)
OUString sCellFormula = xCell->getFormula();
// if this cell has a formula, export it
// (with value and number format)
if (sCellFormula.getLength()>0)
{
OUString sQValue =
GetNamespaceMap().GetQNameByKey(
XML_NAMESPACE_OOOW, sCellFormula, sal_False );
// formula
AddAttribute(XML_NAMESPACE_TABLE, XML_FORMULA, sQValue );
}
// value and format (if NumberFormat != -1)
Reference<XPropertySet> xCellPropertySet(xCell,
UNO_QUERY);
if (xCellPropertySet.is())
{
sal_Int32 nNumberFormat = 0;
Any aAny = xCellPropertySet->getPropertyValue(sNumberFormat);
aAny >>= nNumberFormat;
if (NUMBERFORMAT_TEXT == nNumberFormat)
{
// text format
AddAttribute( XML_NAMESPACE_OFFICE,
XML_VALUE_TYPE, XML_STRING );
}
else if ( (-1 != nNumberFormat) && (xText->getString().getLength() > 0) )
{
// number format key:
// (export values only if cell contains text;
// cf. #83755#)
XMLNumberFormatAttributesExportHelper::
SetNumberFormatAttributes(
*this, nNumberFormat, xCell->getValue(),
sal_True );
}
// else: invalid key; ignore
// cell protection
aAny = xCellPropertySet->getPropertyValue(sIsProtected);
if (*(sal_Bool*)aAny.getValue())
{
AddAttribute( XML_NAMESPACE_TABLE, XML_PROTECTED,
XML_TRUE );
}
if( !rTblInfo.IsBaseSectionValid() )
{
OUString sTextSection( RTL_CONSTASCII_USTRINGPARAM("TextSection") );
aAny = xCellPropertySet->getPropertyValue(sTextSection);
Reference < XTextSection > xTextSection;
aAny >>= xTextSection;
rTblInfo.SetBaseSection( xTextSection );
}
}
// export cell element
SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE,
XML_TABLE_CELL, sal_True, sal_True );
// export cell content
GetTextParagraphExport()->exportText( xText,
rTblInfo.GetBaseSection(),
IsShowProgress() );
}
else
{
DBG_ERROR("here should be a XCell");
ClearAttrList();
}
}
else
{
// no start node -> merged cells: export subtable in cell
SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE,
XML_TABLE_CELL, sal_True, sal_True );
{
AddAttribute( XML_NAMESPACE_TABLE, XML_IS_SUB_TABLE,
GetXMLToken( XML_TRUE ) );
SvXMLElementExport aElemExport( *this, XML_NAMESPACE_TABLE,
XML_TABLE, sal_True, sal_True );
ExportTableLines( rBox.GetTabLines(), rTblInfo );
}
}
}
}
void SwXMLExport::ExportTableLine( const SwTableLine& rLine,
const SwXMLTableLines_Impl& rLines,
SwXMLTableInfo_Impl& rTblInfo )
{
if( rLine.hasSoftPageBreak() )
{
SvXMLElementExport aElem( *this, XML_NAMESPACE_TEXT,
XML_SOFT_PAGE_BREAK, sal_True, sal_True );
}
const SwFrmFmt *pFrmFmt = rLine.GetFrmFmt();
if( pFrmFmt )
{
const String& rName = pFrmFmt->GetName();
if( rName.Len() )
{
AddAttribute( XML_NAMESPACE_TABLE, XML_STYLE_NAME, EncodeStyleName(rName) );
}
}
{
SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE,
XML_TABLE_ROW, sal_True, sal_True );
const SwTableBoxes& rBoxes = rLine.GetTabBoxes();
sal_uInt16 nBoxes = rBoxes.Count();
sal_uInt32 nCPos = 0U;
sal_uInt16 nCol = 0U;
for( sal_uInt16 nBox=0U; nBox<nBoxes; nBox++ )
{
const SwTableBox *pBox = rBoxes[nBox];
// NEW TABLES
const long nRowSpan = pBox->getRowSpan();
if( nRowSpan < 1 )
{
SvXMLElementExport aElem2( *this, XML_NAMESPACE_TABLE,
XML_COVERED_TABLE_CELL, sal_True,
sal_False );
}
if( nBox < nBoxes-1U )
nCPos = nCPos + SwWriteTable::GetBoxWidth( pBox );
else
nCPos = rLines.GetWidth();
// Und ihren Index
const sal_uInt16 nOldCol = nCol;
{
SwXMLTableColumn_Impl aCol( nCPos );
#ifdef DBG_UTIL
const sal_Bool bFound =
#endif
rLines.GetColumns().Seek_Entry( &aCol, &nCol );
ASSERT( bFound, "couldn't find column" );
}
// --> OD 2009-03-19 #i95726#
// Some fault tolerance, if table is somehow corrupted.
if ( nCol < nOldCol )
{
ASSERT( false, "table and/or table information seems to be corrupted." );
if ( nBox == nBoxes - 1 )
{
nCol = rLines.GetColumns().Count() - 1;
}
else
{
nCol = nOldCol;
}
}
// <--
sal_uInt16 nColSpan = nCol - nOldCol + 1U;
if ( nRowSpan >= 1 )
ExportTableBox( *pBox, nColSpan, static_cast< sal_uInt16 >(nRowSpan), rTblInfo );
for( sal_uInt16 i=nOldCol; i<nCol; i++ )
{
SvXMLElementExport aElemExport( *this, XML_NAMESPACE_TABLE,
XML_COVERED_TABLE_CELL, sal_True,
sal_False );
}
nCol++;
}
}
}
void SwXMLExport::ExportTableLines( const SwTableLines& rLines,
SwXMLTableInfo_Impl& rTblInfo,
sal_uInt16 nHeaderRows )
{
ASSERT( pTableLines && pTableLines->Count(),
"SwXMLExport::ExportTableLines: table columns infos missing" );
if( !pTableLines || 0 == pTableLines->Count() )
return;
SwXMLTableLines_Impl *pLines = 0;
sal_uInt16 nInfoPos;
for( nInfoPos=0; nInfoPos < pTableLines->Count(); nInfoPos++ )
{
if( pTableLines->GetObject( nInfoPos )->GetLines() == &rLines )
{
pLines = pTableLines->GetObject( nInfoPos );
break;
}
}
ASSERT( pLines,
"SwXMLExport::ExportTableLines: table columns info missing" );
ASSERT( 0==nInfoPos,
"SwXMLExport::ExportTableLines: table columns infos are unsorted" );
if( !pLines )
return;
pTableLines->Remove( nInfoPos );
if( 0 == pTableLines->Count() )
{
delete pTableLines ;
pTableLines = 0;
}
// pass 2: export columns
const SwXMLTableColumns_Impl& rCols = pLines->GetColumns();
sal_uInt16 nColumn = 0U;
sal_uInt16 nColumns = rCols.Count();
sal_uInt16 nColRep = 1U;
SwXMLTableColumn_Impl *pColumn = (nColumns > 0) ? rCols[0U] : 0;
while( pColumn )
{
nColumn++;
SwXMLTableColumn_Impl *pNextColumn =
(nColumn < nColumns) ? rCols[nColumn] : 0;
if( pNextColumn &&
pNextColumn->GetStyleName() == pColumn->GetStyleName() )
{
nColRep++;
}
else
{
AddAttribute( XML_NAMESPACE_TABLE, XML_STYLE_NAME,
EncodeStyleName(pColumn->GetStyleName()) );
if( nColRep > 1U )
{
OUStringBuffer sTmp(4);
sTmp.append( (sal_Int32)nColRep );
AddAttribute( XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED,
sTmp.makeStringAndClear() );
}
{
SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE,
XML_TABLE_COLUMN, sal_True, sal_True );
}
nColRep = 1U;
}
pColumn = pNextColumn;
}
// pass 3: export line/rows
sal_uInt16 nLines = rLines.Count();
// export header rows, if present
if( nHeaderRows > 0 )
{
SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE,
XML_TABLE_HEADER_ROWS, sal_True, sal_True );
DBG_ASSERT( nHeaderRows <= nLines, "more headers then lines?" );
for( sal_uInt16 nLine = 0U; nLine < nHeaderRows; nLine++ )
ExportTableLine( *(rLines[nLine]), *pLines, rTblInfo );
}
// export remaining rows
for( sal_uInt16 nLine = nHeaderRows; nLine < nLines; nLine++ )
{
ExportTableLine( *(rLines[nLine]), *pLines, rTblInfo );
}
delete pLines;
}
sal_Bool lcl_xmltble_ClearName_Line( const SwTableLine*& rpLine, void* );
sal_Bool lcl_xmltble_ClearName_Box( const SwTableBox*& rpBox, void* )
{
if( !rpBox->GetSttNd() )
{
((SwTableBox *)rpBox)->GetTabLines().ForEach(
&lcl_xmltble_ClearName_Line, 0 );
}
else
{
SwFrmFmt *pFrmFmt = ((SwTableBox *)rpBox)->GetFrmFmt();
if( pFrmFmt && pFrmFmt->GetName().Len() )
pFrmFmt->SetName( aEmptyStr );
}
return sal_True;
}
sal_Bool lcl_xmltble_ClearName_Line( const SwTableLine*& rpLine, void* )
{
((SwTableLine *)rpLine)->GetTabBoxes().ForEach(
&lcl_xmltble_ClearName_Box, 0 );
return sal_True;
}
void SwXMLExport::ExportTable( const SwTableNode& rTblNd )
{
const SwTable& rTbl = rTblNd.GetTable();
const SwFrmFmt *pTblFmt = rTbl.GetFrmFmt();
if( pTblFmt && pTblFmt->GetName().Len() )
{
AddAttribute( XML_NAMESPACE_TABLE, XML_NAME, pTblFmt->GetName() );
AddAttribute( XML_NAMESPACE_TABLE, XML_STYLE_NAME,
EncodeStyleName( pTblFmt->GetName() ) );
}
{
SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE, XML_TABLE,
sal_True, sal_True );
// export DDE source (if this is a DDE table)
if ( rTbl.ISA(SwDDETable) )
{
// get DDE Field Type (contains the DDE connection)
const SwDDEFieldType* pDDEFldType =
((SwDDETable&)rTbl).GetDDEFldType();
// connection name
AddAttribute( XML_NAMESPACE_OFFICE, XML_NAME,
pDDEFldType->GetName() );
// DDE command
const String sCmd = pDDEFldType->GetCmd();
AddAttribute( XML_NAMESPACE_OFFICE, XML_DDE_APPLICATION,
sCmd.GetToken(0, sfx2::cTokenSeperator) );
AddAttribute( XML_NAMESPACE_OFFICE, XML_DDE_ITEM,
sCmd.GetToken(1, sfx2::cTokenSeperator) );
AddAttribute( XML_NAMESPACE_OFFICE, XML_DDE_TOPIC,
sCmd.GetToken(2, sfx2::cTokenSeperator) );
// auto update
if (pDDEFldType->GetType() == sfx2::LINKUPDATE_ALWAYS)
{
AddAttribute( XML_NAMESPACE_OFFICE,
XML_AUTOMATIC_UPDATE, XML_TRUE );
}
// DDE source element (always empty)
SvXMLElementExport aSource(*this, XML_NAMESPACE_OFFICE,
XML_DDE_SOURCE, sal_True, sal_False);
}
SwXMLTableInfo_Impl aTblInfo( &rTbl );
ExportTableLines( rTbl.GetTabLines(), aTblInfo, rTbl.GetRowsToRepeat() );
((SwTable &)rTbl).GetTabLines().ForEach( &lcl_xmltble_ClearName_Line,
0 );
}
}
void SwXMLTextParagraphExport::exportTable(
const Reference < XTextContent > & rTextContent,
sal_Bool bAutoStyles, sal_Bool _bProgress )
{
sal_Bool bOldShowProgress = ((SwXMLExport&)GetExport()).IsShowProgress();
((SwXMLExport&)GetExport()).SetShowProgress( _bProgress );
Reference < XTextTable > xTxtTbl( rTextContent, UNO_QUERY );
DBG_ASSERT( xTxtTbl.is(), "text table missing" );
if( xTxtTbl.is() )
{
const SwXTextTable *pXTable = 0;
Reference<XUnoTunnel> xTableTunnel( rTextContent, UNO_QUERY);
if( xTableTunnel.is() )
{
pXTable = reinterpret_cast< SwXTextTable * >(
sal::static_int_cast< sal_IntPtr >( xTableTunnel->getSomething( SwXTextTable::getUnoTunnelId() )));
ASSERT( pXTable, "SwXTextTable missing" );
}
if( pXTable )
{
SwFrmFmt *pFmt = pXTable->GetFrmFmt();
ASSERT( pFmt, "table format missing" );
const SwTable *pTbl = SwTable::FindTable( pFmt );
ASSERT( pTbl, "table missing" );
const SwTableNode *pTblNd = pTbl->GetTableNode();
ASSERT( pTblNd, "table node missing" );
if( bAutoStyles )
{
SwNodeIndex aIdx( *pTblNd );
// AUTOSTYLES: Optimization: Do not export table autostyle if
// we are currently exporting the content.xml stuff and
// the table is located in header/footer:
// #144704: During the flat XML export (used e.g. by .sdw-export)
// ALL flags are set at the same time.
const bool bExportStyles = ( GetExport().getExportFlags() & EXPORT_STYLES ) != 0;
if ( bExportStyles || !pFmt->GetDoc()->IsInHeaderFooter( aIdx ) )
((SwXMLExport&)GetExport()).ExportTableAutoStyles( *pTblNd );
}
else
{
((SwXMLExport&)GetExport()).ExportTable( *pTblNd );
}
}
}
((SwXMLExport&)GetExport()).SetShowProgress( bOldShowProgress );
}