Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sc / source / filter / xml / xmlexprt.cxx
blob: 6289d6fddcbcc50b4eea0598c8221c824fa46b3b [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_sc.hxx"
// INCLUDE ---------------------------------------------------------------
#include <editeng/eeitem.hxx>
#include "xmlexprt.hxx"
#include "XMLConverter.hxx"
#include "xmlstyle.hxx"
#include "unonames.hxx"
#include "document.hxx"
#include "olinetab.hxx"
#include "cellsuno.hxx"
#include "cell.hxx"
#include "rangenam.hxx"
#include "XMLTableMasterPageExport.hxx"
#include "drwlayer.hxx"
#include "XMLExportDataPilot.hxx"
#include "XMLExportDatabaseRanges.hxx"
#include "XMLExportDDELinks.hxx"
#include "XMLExportIterator.hxx"
#include "XMLColumnRowGroupExport.hxx"
#include "XMLStylesExportHelper.hxx"
#include "XMLChangeTrackingExportHelper.hxx"
#include "sheetdata.hxx"
#include "docoptio.hxx"
#include "XMLExportSharedData.hxx"
#include "chgviset.hxx"
#include "docuno.hxx"
#include "textuno.hxx"
#include "chartlis.hxx"
#include "unoguard.hxx"
#include "scitems.hxx"
#include "docpool.hxx"
#include "userdat.hxx"
#include "dociter.hxx"
#include "chgtrack.hxx"
#include "rangeutl.hxx"
#include "convuno.hxx"
#include "postit.hxx"
#include "externalrefmgr.hxx"
#include "editutil.hxx"
#include "tabprotection.hxx"
#include <xmloff/xmltoken.hxx>
#include <xmloff/xmlnmspe.hxx>
#include <xmloff/xmluconv.hxx>
#include <xmloff/nmspmap.hxx>
#include <xmloff/families.hxx>
#include <xmloff/numehelp.hxx>
#include <xmloff/xmluconv.hxx>
#include <xmloff/txtparae.hxx>
#include <xmloff/xmlcnitm.hxx>
#include <xmloff/xmlerror.hxx>
#include <xmloff/XMLEventExport.hxx>
#include <rtl/ustring.hxx>
#include <tools/debug.hxx>
#include "tools/color.hxx"
#include <rtl/math.hxx>
#include <svl/zforlist.hxx>
#include <svx/unoshape.hxx>
#include <comphelper/extract.hxx>
#include <editeng/eeitem.hxx>
#include <toolkit/helper/convert.hxx>
#include <svx/svdobj.hxx>
#include <svx/svdocapt.hxx>
#include <editeng/outlobj.hxx>
#include <svx/svditer.hxx>
#include <svx/svdpage.hxx>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/sheet/XUsedAreaCursor.hpp>
#include <com/sun/star/sheet/XCellRangeAddressable.hpp>
#include <com/sun/star/sheet/XAreaLinks.hpp>
#include <com/sun/star/sheet/XAreaLink.hpp>
#include <com/sun/star/drawing/XDrawPageSupplier.hpp>
#include <com/sun/star/table/XColumnRowRange.hpp>
#include <com/sun/star/sheet/XPrintAreas.hpp>
#include <com/sun/star/container/XNamed.hpp>
#include <com/sun/star/util/XProtectable.hpp>
#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
#include <com/sun/star/sheet/XUniqueCellFormatRangesSupplier.hpp>
#include <com/sun/star/sheet/XCellRangesQuery.hpp>
#include <com/sun/star/sheet/CellFlags.hpp>
#include <com/sun/star/util/XMergeable.hpp>
#include <com/sun/star/sheet/XArrayFormulaRange.hpp>
#include <com/sun/star/text/XText.hpp>
#include <com/sun/star/sheet/XLabelRanges.hpp>
#include <com/sun/star/sheet/XLabelRange.hpp>
#include <com/sun/star/sheet/XNamedRanges2.hpp>
#include <com/sun/star/sheet/XNamedRange2.hpp>
#include <com/sun/star/sheet/XCellRangeReferrer.hpp>
#include <com/sun/star/sheet/NamedRangeFlag.hpp>
#include <com/sun/star/container/XNamed.hpp>
#include <com/sun/star/sheet/XSheetLinkable.hpp>
#include <com/sun/star/form/XFormsSupplier2.hpp>
#include <com/sun/star/io/XActiveDataSource.hpp>
#include <com/sun/star/io/XSeekable.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/chart2/XChartDocument.hpp>
#include <com/sun/star/chart2/data/XRangeXMLConversion.hpp>
#include <com/sun/star/chart2/data/XDataReceiver.hpp>
#include <com/sun/star/document/XDocumentProperties.hpp>
#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
#include "XMLCodeNameProvider.hxx"
#include <sfx2/objsh.hxx>
#include <vector>
//! not found in unonames.hxx
#define SC_STANDARDFORMAT "StandardFormat"
#define SC_LAYERID "LayerID"
#define SC_DEFAULT_TABLE_COUNT 3
#define SC_VIEWCHANGES_COUNT 13
#define SC_SHOW_CHANGES 0
#define SC_SHOW_ACCEPTED_CHANGES 1
#define SC_SHOW_REJECTED_CHANGES 2
#define SC_SHOW_CHANGES_BY_DATETIME 3
#define SC_SHOW_CHANGES_BY_DATETIME_MODE 4
#define SC_SHOW_CHANGES_BY_DATETIME_FIRST_DATETIME 5
#define SC_SHOW_CHANGES_BY_DATETIME_SECOND_DATETIME 6
#define SC_SHOW_CHANGES_BY_AUTHOR 7
#define SC_SHOW_CHANGES_BY_AUTHOR_NAME 8
#define SC_SHOW_CHANGES_BY_COMMENT 9
#define SC_SHOW_CHANGES_BY_COMMENT_TEXT 10
#define SC_SHOW_CHANGES_BY_RANGES 11
#define SC_SHOW_CHANGES_BY_RANGES_LIST 12
using namespace rtl;
using namespace formula;
using namespace com::sun::star;
using namespace xmloff::token;
using ::std::vector;
using ::com::sun::star::uno::UNO_QUERY;
//----------------------------------------------------------------------------
namespace
{
OUString lcl_RangeSequenceToString(
const uno::Sequence< OUString > & rRanges,
const uno::Reference< chart2::data::XRangeXMLConversion > & xFormatConverter )
{
OUStringBuffer aResult;
const sal_Int32 nMaxIndex( rRanges.getLength() - 1 );
const sal_Unicode cSep( sal_Char(' '));
for( sal_Int32 i=0; i<=nMaxIndex; ++i )
{
OUString aRange( rRanges[i] );
if( xFormatConverter.is())
aRange = xFormatConverter->convertRangeToXML( aRange );
aResult.append( aRange );
if( i < nMaxIndex )
aResult.append( cSep );
}
return aResult.makeStringAndClear();
}
OUString lcl_GetRawString( ScDocument* pDoc, const ScAddress& rPos )
{
// return text/edit cell string content, with line feeds in edit cells
String aVal; // document uses tools-strings
if (pDoc)
{
ScBaseCell* pCell = pDoc->GetCell( rPos );
if (pCell)
{
CellType eType = pCell->GetCellType();
if ( eType == CELLTYPE_STRING )
static_cast<ScStringCell*>(pCell)->GetString(aVal); // string cell: content
else if ( eType == CELLTYPE_EDIT )
{
// edit cell: text with line breaks
const EditTextObject* pData = static_cast<ScEditCell*>(pCell)->GetData();
if (pData)
{
EditEngine& rEngine = pDoc->GetEditEngine();
rEngine.SetText( *pData );
aVal = rEngine.GetText( LINEEND_LF );
}
}
}
}
return aVal;
}
} // anonymous namespace
//----------------------------------------------------------------------------
OUString SAL_CALL ScXMLOOoExport_getImplementationName() throw()
{
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLExporter" ) );
}
uno::Sequence< rtl::OUString > SAL_CALL ScXMLOOoExport_getSupportedServiceNames() throw()
{
const rtl::OUString aServiceName( ScXMLOOoExport_getImplementationName() );
return uno::Sequence< rtl::OUString >( &aServiceName, 1 );
}
uno::Reference< uno::XInterface > SAL_CALL ScXMLOOoExport_createInstance(
const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
{
// #110680#
// return (cppu::OWeakObject*)new ScXMLExport(EXPORT_ALL);
return (cppu::OWeakObject*)new ScXMLExport( rSMgr, EXPORT_ALL );
}
OUString SAL_CALL ScXMLOOoExport_Meta_getImplementationName() throw()
{
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLMetaExporter" ) );
}
uno::Sequence< rtl::OUString > SAL_CALL ScXMLOOoExport_Meta_getSupportedServiceNames() throw()
{
const rtl::OUString aServiceName( ScXMLOOoExport_Meta_getImplementationName() );
return uno::Sequence< rtl::OUString > ( &aServiceName, 1 );
}
uno::Reference< uno::XInterface > SAL_CALL ScXMLOOoExport_Meta_createInstance(
const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
{
// #110680#
// return (cppu::OWeakObject*)new ScXMLExport(EXPORT_META);
return (cppu::OWeakObject*)new ScXMLExport( rSMgr, EXPORT_META );
}
OUString SAL_CALL ScXMLOOoExport_Styles_getImplementationName() throw()
{
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLStylesExporter" ) );
}
uno::Sequence< rtl::OUString > SAL_CALL ScXMLOOoExport_Styles_getSupportedServiceNames() throw()
{
const rtl::OUString aServiceName( ScXMLOOoExport_Styles_getImplementationName() );
return uno::Sequence< rtl::OUString > ( &aServiceName, 1 );
}
uno::Reference< uno::XInterface > SAL_CALL ScXMLOOoExport_Styles_createInstance(
const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
{
// #110680#
// return (cppu::OWeakObject*)new ScXMLExport(EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_FONTDECLS);
return (cppu::OWeakObject*)new ScXMLExport( rSMgr, EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_FONTDECLS);
}
OUString SAL_CALL ScXMLOOoExport_Content_getImplementationName() throw()
{
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLContentExporter" ) );
}
uno::Sequence< rtl::OUString > SAL_CALL ScXMLOOoExport_Content_getSupportedServiceNames() throw()
{
const rtl::OUString aServiceName( ScXMLOOoExport_Content_getImplementationName() );
return uno::Sequence< rtl::OUString > ( &aServiceName, 1 );
}
uno::Reference< uno::XInterface > SAL_CALL ScXMLOOoExport_Content_createInstance(
const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
{
// #110680#
// return (cppu::OWeakObject*)new ScXMLExport(EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_SCRIPTS|EXPORT_FONTDECLS);
return (cppu::OWeakObject*)new ScXMLExport( rSMgr, EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_SCRIPTS|EXPORT_FONTDECLS);
}
OUString SAL_CALL ScXMLOOoExport_Settings_getImplementationName() throw()
{
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLSettingsExporter" ) );
}
uno::Sequence< rtl::OUString > SAL_CALL ScXMLOOoExport_Settings_getSupportedServiceNames() throw()
{
const rtl::OUString aServiceName( ScXMLOOoExport_Settings_getImplementationName() );
return uno::Sequence< rtl::OUString > ( &aServiceName, 1 );
}
uno::Reference< uno::XInterface > SAL_CALL ScXMLOOoExport_Settings_createInstance(
const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
{
// #110680#
// return (cppu::OWeakObject*)new ScXMLExport(EXPORT_SETTINGS);
return (cppu::OWeakObject*)new ScXMLExport( rSMgr, EXPORT_SETTINGS );
}
// Oasis Filter
OUString SAL_CALL ScXMLOasisExport_getImplementationName() throw()
{
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLOasisExporter" ) );
}
uno::Sequence< rtl::OUString > SAL_CALL ScXMLOasisExport_getSupportedServiceNames() throw()
{
const rtl::OUString aServiceName( ScXMLOasisExport_getImplementationName() );
const uno::Sequence< rtl::OUString > aSeq( &aServiceName, 1 );
return aSeq;
}
uno::Reference< uno::XInterface > SAL_CALL ScXMLOasisExport_createInstance(
const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
{
return (cppu::OWeakObject*)new ScXMLExport(rSMgr, EXPORT_ALL|EXPORT_OASIS);
}
OUString SAL_CALL ScXMLOasisExport_Meta_getImplementationName() throw()
{
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLOasisMetaExporter" ) );
}
uno::Sequence< rtl::OUString > SAL_CALL ScXMLOasisExport_Meta_getSupportedServiceNames() throw()
{
const rtl::OUString aServiceName( ScXMLOasisExport_Meta_getImplementationName() );
const uno::Sequence< rtl::OUString > aSeq( &aServiceName, 1 );
return aSeq;
}
uno::Reference< uno::XInterface > SAL_CALL ScXMLOasisExport_Meta_createInstance(
const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
{
return (cppu::OWeakObject*)new ScXMLExport(rSMgr, EXPORT_META|EXPORT_OASIS);
}
OUString SAL_CALL ScXMLOasisExport_Styles_getImplementationName() throw()
{
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLOasisStylesExporter" ) );
}
uno::Sequence< rtl::OUString > SAL_CALL ScXMLOasisExport_Styles_getSupportedServiceNames() throw()
{
const rtl::OUString aServiceName( ScXMLOasisExport_Styles_getImplementationName() );
const uno::Sequence< rtl::OUString > aSeq( &aServiceName, 1 );
return aSeq;
}
uno::Reference< uno::XInterface > SAL_CALL ScXMLOasisExport_Styles_createInstance(
const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
{
return (cppu::OWeakObject*)new ScXMLExport(rSMgr, EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_FONTDECLS|EXPORT_OASIS);
}
OUString SAL_CALL ScXMLOasisExport_Content_getImplementationName() throw()
{
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLOasisContentExporter" ) );
}
uno::Sequence< rtl::OUString > SAL_CALL ScXMLOasisExport_Content_getSupportedServiceNames() throw()
{
const rtl::OUString aServiceName( ScXMLOasisExport_Content_getImplementationName() );
const uno::Sequence< rtl::OUString > aSeq( &aServiceName, 1 );
return aSeq;
}
uno::Reference< uno::XInterface > SAL_CALL ScXMLOasisExport_Content_createInstance(
const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
{
return (cppu::OWeakObject*)new ScXMLExport(rSMgr, EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_SCRIPTS|EXPORT_FONTDECLS|EXPORT_OASIS);
}
OUString SAL_CALL ScXMLOasisExport_Settings_getImplementationName() throw()
{
return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.Calc.XMLOasisSettingsExporter" ) );
}
uno::Sequence< rtl::OUString > SAL_CALL ScXMLOasisExport_Settings_getSupportedServiceNames() throw()
{
const rtl::OUString aServiceName( ScXMLOasisExport_Settings_getImplementationName() );
const uno::Sequence< rtl::OUString > aSeq( &aServiceName, 1 );
return aSeq;
}
uno::Reference< uno::XInterface > SAL_CALL ScXMLOasisExport_Settings_createInstance(
const uno::Reference< lang::XMultiServiceFactory > & rSMgr ) throw( uno::Exception )
{
return (cppu::OWeakObject*)new ScXMLExport(rSMgr, EXPORT_SETTINGS|EXPORT_OASIS);
}
//----------------------------------------------------------------------------
class ScXMLShapeExport : public XMLShapeExport
{
public:
ScXMLShapeExport(SvXMLExport& rExp) : XMLShapeExport(rExp) {}
~ScXMLShapeExport();
/** is called before a shape element for the given XShape is exported */
virtual void onExport( const uno::Reference < drawing::XShape >& xShape );
};
ScXMLShapeExport::~ScXMLShapeExport()
{
}
void ScXMLShapeExport::onExport( const uno::Reference < drawing::XShape >& xShape )
{
uno::Reference< beans::XPropertySet > xShapeProp( xShape, uno::UNO_QUERY );
if( xShapeProp.is() )
{
sal_Int16 nLayerID = 0;
if( (xShapeProp->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( SC_LAYERID ))) >>= nLayerID) && (nLayerID == SC_LAYER_BACK) )
GetExport().AddAttribute(XML_NAMESPACE_TABLE, XML_TABLE_BACKGROUND, XML_TRUE);
}
}
//----------------------------------------------------------------------------
sal_Int16 ScXMLExport::GetFieldUnit()
{
com::sun::star::uno::Reference<com::sun::star::beans::XPropertySet> xProperties(
comphelper::getProcessServiceFactory()->createInstance(
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sheet.GlobalSheetSettings" )) ),
com::sun::star::uno::UNO_QUERY);
if (xProperties.is())
{
sal_Int16 nFieldUnit = 0;
if (xProperties->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Metric"))) >>= nFieldUnit)
return nFieldUnit;
}
return 0;
}
// #110680#
ScXMLExport::ScXMLExport(
const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xServiceFactory,
const sal_uInt16 nExportFlag)
: SvXMLExport( xServiceFactory, SvXMLUnitConverter::GetMapUnit(GetFieldUnit()), XML_SPREADSHEET, nExportFlag ),
pDoc(NULL),
nSourceStreamPos(0),
pNumberFormatAttributesExportHelper(NULL),
pSharedData(NULL),
pColumnStyles(NULL),
pRowStyles(NULL),
pCellStyles(NULL),
pRowFormatRanges(NULL),
aTableStyles(),
pGroupColumns (NULL),
pGroupRows (NULL),
pDefaults(NULL),
pChartListener(NULL),
pCurrentCell(NULL),
pMergedRangesContainer(NULL),
pValidationsContainer(NULL),
pCellsItr(NULL),
pChangeTrackingExportHelper(NULL),
sLayerID(RTL_CONSTASCII_USTRINGPARAM( SC_LAYERID )),
sCaptionShape(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.CaptionShape")),
nOpenRow(-1),
nProgressCount(0),
nCurrentTable(0),
bHasRowHeader(sal_False),
bRowHeaderOpen(sal_False),
mbShowProgress( sal_False )
{
if (getExportFlags() & EXPORT_CONTENT)
{
pGroupColumns = new ScMyOpenCloseColumnRowGroup(*this, XML_TABLE_COLUMN_GROUP);
pGroupRows = new ScMyOpenCloseColumnRowGroup(*this, XML_TABLE_ROW_GROUP);
pColumnStyles = new ScColumnStyles();
pRowStyles = new ScRowStyles();
pRowFormatRanges = new ScRowFormatRanges();
pMergedRangesContainer = new ScMyMergedRangesContainer();
pValidationsContainer = new ScMyValidationsContainer();
pCellsItr = new ScMyNotEmptyCellsIterator(*this);
pDefaults = new ScMyDefaultStyles();
}
pCellStyles = new ScFormatRangeStyles();
// document is not set here - create ScChangeTrackingExportHelper later
xScPropHdlFactory = new XMLScPropHdlFactory;
xCellStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScCellStylesProperties, xScPropHdlFactory);
xColumnStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScColumnStylesProperties, xScPropHdlFactory);
xRowStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScRowStylesProperties, xScPropHdlFactory);
xTableStylesPropertySetMapper = new XMLPropertySetMapper((XMLPropertyMapEntry*)aXMLScTableStylesProperties, xScPropHdlFactory);
xCellStylesExportPropertySetMapper = new ScXMLCellExportPropertyMapper(xCellStylesPropertySetMapper);
xCellStylesExportPropertySetMapper->ChainExportMapper(XMLTextParagraphExport::CreateParaExtPropMapper(*this));
xColumnStylesExportPropertySetMapper = new ScXMLColumnExportPropertyMapper(xColumnStylesPropertySetMapper);
xRowStylesExportPropertySetMapper = new ScXMLRowExportPropertyMapper(xRowStylesPropertySetMapper);
xTableStylesExportPropertySetMapper = new ScXMLTableExportPropertyMapper(xTableStylesPropertySetMapper);
GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_CELL, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_NAME)),
xCellStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_PREFIX)));
GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_COLUMN, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_NAME)),
xColumnStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_PREFIX)));
GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_ROW, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_ROW_STYLES_NAME)),
xRowStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_ROW_STYLES_PREFIX)));
GetAutoStylePool()->AddFamily(XML_STYLE_FAMILY_TABLE_TABLE, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_TABLE_STYLES_NAME)),
xTableStylesExportPropertySetMapper, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_TABLE_STYLES_PREFIX)));
if( (getExportFlags() & (EXPORT_STYLES|EXPORT_AUTOSTYLES|EXPORT_MASTERSTYLES|EXPORT_CONTENT) ) != 0 )
{
// This name is reserved for the external ref cache tables. This
// should not conflict with user-defined styles since this name is
// used for a table style which is not available in the UI.
sExternalRefTabStyleName = rtl::OUString::createFromAscii("ta_extref");
GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TABLE_TABLE, sExternalRefTabStyleName);
sAttrName = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_NAME));
sAttrStyleName = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_STYLE_NAME));
sAttrColumnsRepeated = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_NUMBER_COLUMNS_REPEATED));
sAttrFormula = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_FORMULA));
sAttrStringValue = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_STRING_VALUE));
sAttrValueType = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_VALUE_TYPE));
sElemCell = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_TABLE_CELL));
sElemCoveredCell = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_COVERED_TABLE_CELL));
sElemCol = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_TABLE_COLUMN));
sElemRow = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_TABLE_ROW));
sElemTab = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TABLE, GetXMLToken(XML_TABLE));
sElemP = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_TEXT, GetXMLToken(XML_P));
}
}
ScXMLExport::~ScXMLExport()
{
if (pGroupColumns)
delete pGroupColumns;
if (pGroupRows)
delete pGroupRows;
if (pColumnStyles)
delete pColumnStyles;
if (pRowStyles)
delete pRowStyles;
if (pCellStyles)
delete pCellStyles;
if (pRowFormatRanges)
delete pRowFormatRanges;
if (pMergedRangesContainer)
delete pMergedRangesContainer;
if (pValidationsContainer)
delete pValidationsContainer;
if (pChangeTrackingExportHelper)
delete pChangeTrackingExportHelper;
if (pChartListener)
delete pChartListener;
if (pCellsItr)
delete pCellsItr;
if (pDefaults)
delete pDefaults;
if (pNumberFormatAttributesExportHelper)
delete pNumberFormatAttributesExportHelper;
}
void ScXMLExport::SetSourceStream( const uno::Reference<io::XInputStream>& xNewStream )
{
xSourceStream = xNewStream;
if ( xSourceStream.is() )
{
// make sure it's a plain UTF-8 stream as written by OOo itself
const sal_Char pXmlHeader[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
sal_Int32 nLen = strlen(pXmlHeader);
uno::Sequence<sal_Int8> aFileStart(nLen);
sal_Int32 nRead = xSourceStream->readBytes( aFileStart, nLen );
if ( nRead != nLen || rtl_compareMemory( aFileStart.getConstArray(), pXmlHeader, nLen ) != 0 )
{
// invalid - ignore stream, save normally
xSourceStream.clear();
}
else
{
// keep track of the bytes already read
nSourceStreamPos = nRead;
const ScSheetSaveData* pSheetData = ScModelObj::getImplementation(GetModel())->GetSheetSaveData();
if (pSheetData)
{
// add the loaded namespaces to the name space map
if ( !pSheetData->AddLoadedNamespaces( _GetNamespaceMap() ) )
{
// conflicts in the namespaces - ignore the stream, save normally
xSourceStream.clear();
}
}
}
}
}
sal_Int32 ScXMLExport::GetNumberFormatStyleIndex(sal_Int32 nNumFmt) const
{
NumberFormatIndexMap::const_iterator itr = aNumFmtIndexMap.find(nNumFmt);
if (itr == aNumFmtIndexMap.end())
return -1;
return itr->second;
}
sal_Bool ScXMLExport::HasDrawPages(uno::Reference <sheet::XSpreadsheetDocument>& xDoc)
{
uno::Reference <beans::XPropertySet> xDocProps( xDoc, uno::UNO_QUERY );
return (xDocProps.is() && ::cppu::any2bool( xDocProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_HASDRAWPAGES))) ));
}
void ScXMLExport::CollectSharedData(sal_Int32& nTableCount, sal_Int32& nShapesCount, const sal_Int32 nCellCount)
{
if (GetModel().is())
{
uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( GetModel(), uno::UNO_QUERY );
if ( xSpreadDoc.is())
{
uno::Reference<container::XIndexAccess> xIndex( xSpreadDoc->getSheets(), uno::UNO_QUERY );
if ( xIndex.is() )
{
nTableCount = xIndex->getCount();
if (!pSharedData)
CreateSharedData(nTableCount);
pCellStyles->AddNewTable(nTableCount - 1);
pDoc->InitializeAllNoteCaptions( true );
if (HasDrawPages(xSpreadDoc))
{
rtl::OUString sCaptionPoint( RTL_CONSTASCII_USTRINGPARAM( "CaptionPoint" ));
for (SCTAB nTable = 0; nTable < nTableCount; ++nTable)
{
nCurrentTable = sal::static_int_cast<sal_uInt16>( nTable );
uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier(xIndex->getByIndex(nTable), uno::UNO_QUERY);
if (xDrawPageSupplier.is())
{
uno::Reference<drawing::XDrawPage> xDrawPage(xDrawPageSupplier->getDrawPage());
ScMyDrawPage aDrawPage;
aDrawPage.bHasForms = sal_False;
aDrawPage.xDrawPage.set(xDrawPage);
pSharedData->AddDrawPage(aDrawPage, nTable);
uno::Reference<container::XIndexAccess> xShapesIndex (xDrawPage, uno::UNO_QUERY);
if (xShapesIndex.is())
{
sal_Int32 nShapes(xShapesIndex->getCount());
for (sal_Int32 nShape = 0; nShape < nShapes; ++nShape)
{
uno::Reference<drawing::XShape> xShape(xShapesIndex->getByIndex(nShape), uno::UNO_QUERY);
if (xShape.is())
{
uno::Reference< beans::XPropertySet > xShapeProp( xShape, uno::UNO_QUERY );
if( xShapeProp.is() )
{
sal_Int16 nLayerID = 0;
if( xShapeProp->getPropertyValue(sLayerID) >>= nLayerID )
{
if( (nLayerID == SC_LAYER_INTERN) || (nLayerID == SC_LAYER_HIDDEN) )
CollectInternalShape( xShape );
else
{
++nShapesCount;
SvxShape* pShapeImp(SvxShape::getImplementation(xShape));
if (pShapeImp)
{
SdrObject *pSdrObj(pShapeImp->GetSdrObject());
if (pSdrObj)
{
if (ScDrawLayer::GetAnchor(pSdrObj) == SCA_CELL)
{
if (pDoc)
{
awt::Point aPoint(xShape->getPosition());
awt::Size aSize(xShape->getSize());
rtl::OUString sType(xShape->getShapeType());
Rectangle aRectangle(aPoint.X, aPoint.Y, aPoint.X + aSize.Width, aPoint.Y + aSize.Height);
if ( sType.equals(sCaptionShape) )
{
awt::Point aRelativeCaptionPoint;
xShapeProp->getPropertyValue( sCaptionPoint ) >>= aRelativeCaptionPoint;
Point aCoreRelativeCaptionPoint(aRelativeCaptionPoint.X, aRelativeCaptionPoint.Y);
Point aCoreAbsoluteCaptionPoint(aPoint.X, aPoint.Y);
aCoreAbsoluteCaptionPoint += aCoreRelativeCaptionPoint;
aRectangle.Union(Rectangle(aCoreAbsoluteCaptionPoint, aCoreAbsoluteCaptionPoint));
}
ScRange aRange(pDoc->GetRange(static_cast<SCTAB>(nTable), aRectangle));
ScMyShape aMyShape;
aMyShape.aAddress = aRange.aStart;
aMyShape.aEndAddress = aRange.aEnd;
aMyShape.xShape = xShape;
pSharedData->AddNewShape(aMyShape);
pSharedData->SetLastColumn(nTable, aRange.aStart.Col());
pSharedData->SetLastRow(nTable, aRange.aStart.Row());
}
}
else
pSharedData->AddTableShape(nTable, xShape);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
sal_Int32 nRef(nCellCount + (2 * nTableCount) + (2 * nShapesCount));
GetProgressBarHelper()->SetReference(nRef);
GetProgressBarHelper()->SetValue(0);
}
void ScXMLExport::CollectShapesAutoStyles(const sal_Int32 nTableCount)
{
// #i84077# To avoid compiler warnings about uninitialized aShapeItr,
// it's initialized using this dummy list. The iterator contains shapes
// from all sheets, so it can't be declared inside the nTable loop where
// it is used.
ScMyShapeList aDummyInitList;
pSharedData->SortShapesContainer();
pSharedData->SortNoteShapes();
const ScMyShapeList* pShapeList(NULL);
ScMyShapeList::const_iterator aShapeItr = aDummyInitList.end();
if (pSharedData->GetShapesContainer())
{
pShapeList = pSharedData->GetShapesContainer()->GetShapes();
aShapeItr = pShapeList->begin();
}
if (pSharedData->HasDrawPage())
{
for (SCTAB nTable = 0; nTable < nTableCount; ++nTable)
{
uno::Reference<drawing::XDrawPage> xDrawPage(pSharedData->GetDrawPage(nTable));
uno::Reference<drawing::XShapes> xShapes (xDrawPage, uno::UNO_QUERY);
if (xShapes.is())
{
GetShapeExport()->seekShapes(xShapes);
uno::Reference< form::XFormsSupplier2 > xFormsSupplier( xDrawPage, uno::UNO_QUERY );
if( xFormsSupplier.is() && xFormsSupplier->hasForms() )
{
GetFormExport()->examineForms(xDrawPage);
pSharedData->SetDrawPageHasForms(nTable, sal_True);
}
ScMyTableShapes* pTableShapes(pSharedData->GetTableShapes());
if (pTableShapes)
{
ScMyTableXShapes::iterator aItr((*pTableShapes)[nTable].begin());
ScMyTableXShapes::iterator aEndItr((*pTableShapes)[nTable].end());
while (aItr != aEndItr)
{
GetShapeExport()->collectShapeAutoStyles(*aItr);
IncrementProgressBar(sal_False);
++aItr;
}
}
if (pShapeList)
{
ScMyShapeList::const_iterator aEndItr(pShapeList->end());
while (aShapeItr != aEndItr && (static_cast<sal_Int32>(aShapeItr->aAddress.Tab()) == nTable))
{
GetShapeExport()->collectShapeAutoStyles(aShapeItr->xShape);
IncrementProgressBar(sal_False);
++aShapeItr;
}
}
const ScMyNoteShapeList* pNoteShapes = NULL;
ScMyNoteShapeList::const_iterator aNoteShapeItr;
ScMyNoteShapeList::const_iterator aNoteShapeEndItr;
if (pSharedData->GetNoteShapes())
{
pNoteShapes = pSharedData->GetNoteShapes()->GetNotes();
if (pNoteShapes)
{
aNoteShapeItr = pNoteShapes->begin();
aNoteShapeEndItr = pNoteShapes->end();
}
}
if (pNoteShapes)
{
while (aNoteShapeItr != aNoteShapeEndItr)
{
if (static_cast<sal_Int32>(aNoteShapeItr->aPos.Tab()) == nTable)
GetShapeExport()->collectShapeAutoStyles(aNoteShapeItr->xShape);
++aNoteShapeItr;
}
}
}
}
}
pSharedData->SortNoteShapes(); // sort twice, because some more shapes are added
}
void ScXMLExport::_ExportMeta()
{
sal_Int32 nCellCount(pDoc ? pDoc->GetCellCount() : 0);
sal_Int32 nTableCount(0);
sal_Int32 nShapesCount(0);
GetAutoStylePool()->ClearEntries();
CollectSharedData(nTableCount, nShapesCount, nCellCount);
uno::Sequence<beans::NamedValue> stats(3);
stats[0] = beans::NamedValue(::rtl::OUString::createFromAscii("TableCount"),
uno::makeAny(nTableCount));
stats[1] = beans::NamedValue(::rtl::OUString::createFromAscii("CellCount"),
uno::makeAny(nCellCount));
stats[2] = beans::NamedValue(::rtl::OUString::createFromAscii("ObjectCount"),
uno::makeAny(nShapesCount));
// update document statistics at the model
uno::Reference<document::XDocumentPropertiesSupplier> xPropSup(GetModel(),
uno::UNO_QUERY_THROW);
uno::Reference<document::XDocumentProperties> xDocProps(
xPropSup->getDocumentProperties());
if (xDocProps.is()) {
xDocProps->setDocumentStatistics(stats);
}
// export document properties
SvXMLExport::_ExportMeta();
}
void ScXMLExport::_ExportFontDecls()
{
GetFontAutoStylePool(); // make sure the pool is created
SvXMLExport::_ExportFontDecls();
}
table::CellRangeAddress ScXMLExport::GetEndAddress(const uno::Reference<sheet::XSpreadsheet>& xTable, const sal_Int32 /* nTable */)
{
table::CellRangeAddress aCellAddress;
uno::Reference<sheet::XSheetCellCursor> xCursor(xTable->createCursor());
uno::Reference<sheet::XUsedAreaCursor> xUsedArea (xCursor, uno::UNO_QUERY);
uno::Reference<sheet::XCellRangeAddressable> xCellAddress (xCursor, uno::UNO_QUERY);
if (xUsedArea.is() && xCellAddress.is())
{
xUsedArea->gotoEndOfUsedArea(sal_True);
aCellAddress = xCellAddress->getRangeAddress();
}
return aCellAddress;
}
void ScXMLExport::GetAreaLinks( uno::Reference< sheet::XSpreadsheetDocument>& xSpreadDoc,
ScMyAreaLinksContainer& rAreaLinks )
{
uno::Reference< beans::XPropertySet > xPropSet( xSpreadDoc, uno::UNO_QUERY );
if( !xPropSet.is() ) return;
uno::Reference< container::XIndexAccess > xLinksIAccess( xPropSet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNO_AREALINKS ) ) ), uno::UNO_QUERY);
if( xLinksIAccess.is() )
{
const OUString sFilter( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_FILTER ) );
const OUString sFilterOpt( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_FILTOPT ) );
const OUString sURL( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_LINKURL ) );
const OUString sRefresh( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_REFDELAY ) );
sal_Int32 nCount(xLinksIAccess->getCount());
for( sal_Int32 nIndex = 0; nIndex < nCount; ++nIndex )
{
uno::Reference< sheet::XAreaLink > xAreaLink(xLinksIAccess->getByIndex( nIndex ), uno::UNO_QUERY);
if( xAreaLink.is() )
{
ScMyAreaLink aAreaLink;
aAreaLink.aDestRange = xAreaLink->getDestArea();
aAreaLink.sSourceStr = xAreaLink->getSourceArea();
uno::Reference< beans::XPropertySet > xLinkProp( xAreaLink, uno::UNO_QUERY );
if( xLinkProp.is() )
{
xLinkProp->getPropertyValue( sFilter ) >>= aAreaLink.sFilter;
xLinkProp->getPropertyValue( sFilterOpt ) >>= aAreaLink.sFilterOptions;
xLinkProp->getPropertyValue( sURL ) >>= aAreaLink.sURL;
xLinkProp->getPropertyValue( sRefresh ) >>= aAreaLink.nRefresh;
}
rAreaLinks.AddNewAreaLink( aAreaLink );
}
}
}
rAreaLinks.Sort();
}
// core implementation
void ScXMLExport::GetDetectiveOpList( ScMyDetectiveOpContainer& rDetOp )
{
if (pDoc)
{
ScDetOpList* pOpList(pDoc->GetDetOpList());
if( pOpList )
{
sal_uInt32 nCount(pOpList->Count());
for( sal_uInt32 nIndex = 0; nIndex < nCount; ++nIndex )
{
ScDetOpData* pDetData(pOpList->GetObject( static_cast<sal_uInt16>(nIndex) ));
if( pDetData )
{
const ScAddress& rDetPos = pDetData->GetPos();
SCTAB nTab = rDetPos.Tab();
if ( nTab < pDoc->GetTableCount() )
{
rDetOp.AddOperation( pDetData->GetOperation(), rDetPos, nIndex );
// #123981# cells with detective operations are written even if empty
pSharedData->SetLastColumn( nTab, rDetPos.Col() );
pSharedData->SetLastRow( nTab, rDetPos.Row() );
}
}
}
rDetOp.Sort();
}
}
}
void ScXMLExport::WriteSingleColumn(const sal_Int32 nRepeatColumns, const sal_Int32 nStyleIndex,
const sal_Int32 nIndex, const sal_Bool bIsAutoStyle, const sal_Bool bIsVisible)
{
CheckAttrList();
AddAttribute(sAttrStyleName, *pColumnStyles->GetStyleNameByIndex(nStyleIndex));
if (!bIsVisible)
AddAttribute(XML_NAMESPACE_TABLE, XML_VISIBILITY, XML_COLLAPSE);
if (nRepeatColumns > 1)
{
OUString sOUEndCol(OUString::valueOf(static_cast <sal_Int32> (nRepeatColumns)));
AddAttribute(sAttrColumnsRepeated, sOUEndCol);
}
if (nIndex != -1)
AddAttribute(XML_NAMESPACE_TABLE, XML_DEFAULT_CELL_STYLE_NAME, *pCellStyles->GetStyleNameByIndex(nIndex, bIsAutoStyle));
SvXMLElementExport aElemC(*this, sElemCol, sal_True, sal_True);
}
void ScXMLExport::WriteColumn(const sal_Int32 nColumn, const sal_Int32 nRepeatColumns,
const sal_Int32 nStyleIndex, const sal_Bool bIsVisible)
{
sal_Int32 nRepeat(1);
sal_Int32 nPrevIndex((*pDefaults->GetColDefaults())[nColumn].nIndex);
sal_Bool bPrevAutoStyle((*pDefaults->GetColDefaults())[nColumn].bIsAutoStyle);
for (sal_Int32 i = nColumn + 1; i < nColumn + nRepeatColumns; ++i)
{
if (((*pDefaults->GetColDefaults())[i].nIndex != nPrevIndex) ||
((*pDefaults->GetColDefaults())[i].bIsAutoStyle != bPrevAutoStyle))
{
WriteSingleColumn(nRepeat, nStyleIndex, nPrevIndex, bPrevAutoStyle, bIsVisible);
nPrevIndex = (*pDefaults->GetColDefaults())[i].nIndex;
bPrevAutoStyle = (*pDefaults->GetColDefaults())[i].bIsAutoStyle;
nRepeat = 1;
}
else
++nRepeat;
}
WriteSingleColumn(nRepeat, nStyleIndex, nPrevIndex, bPrevAutoStyle, bIsVisible);
}
void ScXMLExport::OpenHeaderColumn()
{
StartElement( XML_NAMESPACE_TABLE, XML_TABLE_HEADER_COLUMNS, sal_True );
}
void ScXMLExport::CloseHeaderColumn()
{
EndElement(XML_NAMESPACE_TABLE, XML_TABLE_HEADER_COLUMNS, sal_True);
}
void ScXMLExport::ExportColumns(const sal_Int32 nTable, const table::CellRangeAddress& aColumnHeaderRange, const sal_Bool bHasColumnHeader)
{
sal_Int32 nColsRepeated (1);
rtl::OUString sParent;
sal_Int32 nIndex;
sal_Int32 nPrevColumn(0);
sal_Bool bPrevIsVisible (sal_True);
sal_Bool bWasHeader (sal_False);
sal_Bool bIsHeader (sal_False);
sal_Bool bIsClosed (sal_True);
sal_Bool bIsFirst (sal_False);
sal_Int32 nPrevIndex (-1);
sal_Int32 nColumn;
for (nColumn = 0; nColumn <= pSharedData->GetLastColumn(nTable); ++nColumn)
{
CheckAttrList();
sal_Bool bIsVisible(sal_True);
nIndex = pColumnStyles->GetStyleNameIndex(nTable, nColumn, bIsVisible);
bIsHeader = bHasColumnHeader && (aColumnHeaderRange.StartColumn <= nColumn) && (nColumn <= aColumnHeaderRange.EndColumn);
if (bIsHeader != bWasHeader)
{
if (bIsHeader)
{
bIsFirst = sal_False;
if (nColumn > 0)
{
WriteColumn(nPrevColumn, nColsRepeated, nPrevIndex, bPrevIsVisible);
if (pGroupColumns->IsGroupEnd(nColumn - 1))
pGroupColumns->CloseGroups(nColumn - 1);
}
bPrevIsVisible = bIsVisible;
nPrevIndex = nIndex;
nPrevColumn = nColumn;
nColsRepeated = 1;
bIsFirst = sal_True;
if(pGroupColumns->IsGroupStart(nColumn))
pGroupColumns->OpenGroups(nColumn);
OpenHeaderColumn();
bWasHeader = sal_True;
bIsClosed = sal_False;
}
else
{
WriteColumn(nPrevColumn, nColsRepeated, nPrevIndex, bPrevIsVisible);
CloseHeaderColumn();
if (pGroupColumns->IsGroupEnd(nColumn - 1))
pGroupColumns->CloseGroups(nColumn - 1);
if(pGroupColumns->IsGroupStart(nColumn))
pGroupColumns->OpenGroups(nColumn);
bPrevIsVisible = bIsVisible;
nPrevIndex = nIndex;
nPrevColumn = nColumn;
nColsRepeated = 1;
bWasHeader = sal_False;
bIsClosed = sal_True;
}
}
else if (nColumn == 0)
{
if (pGroupColumns->IsGroupStart(nColumn))
pGroupColumns->OpenGroups(nColumn);
bPrevIsVisible = bIsVisible;
nPrevIndex = nIndex;
bIsFirst = sal_True;
}
else if ((bIsVisible == bPrevIsVisible) && (nIndex == nPrevIndex) &&
!pGroupColumns->IsGroupStart(nColumn) && !pGroupColumns->IsGroupEnd(nColumn - 1))
++nColsRepeated;
else
{
bIsFirst = sal_False;
WriteColumn(nPrevColumn, nColsRepeated, nPrevIndex, bPrevIsVisible);
if (pGroupColumns->IsGroupEnd(nColumn - 1))
{
if (bIsHeader)
CloseHeaderColumn();
pGroupColumns->CloseGroups(nColumn - 1);
if (bIsHeader)
OpenHeaderColumn();
}
if (pGroupColumns->IsGroupStart(nColumn))
{
if (bIsHeader)
CloseHeaderColumn();
pGroupColumns->OpenGroups(nColumn);
if (bIsHeader)
OpenHeaderColumn();
}
bPrevIsVisible = bIsVisible;
nPrevIndex = nIndex;
nPrevColumn = nColumn;
nColsRepeated = 1;
}
}
//if (nColsRepeated > 1 || bIsFirst)
WriteColumn(nPrevColumn, nColsRepeated, nPrevIndex, bPrevIsVisible);
if (!bIsClosed)
CloseHeaderColumn();
if (pGroupColumns->IsGroupEnd(nColumn - 1))
pGroupColumns->CloseGroups(nColumn - 1);
}
void ScXMLExport::ExportExternalRefCacheStyles()
{
sal_Int32 nEntryIndex = GetCellStylesPropertySetMapper()->FindEntryIndex(
"NumberFormat", XML_NAMESPACE_STYLE, OUString::createFromAscii("data-style-name"));
if (nEntryIndex < 0)
// No entry index for the number format is found.
return;
ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
if (!pRefMgr->hasExternalData())
// No external reference data cached.
return;
// Export each unique number format used in the external ref cache.
vector<sal_uInt32> aNumFmts;
pRefMgr->getAllCachedNumberFormats(aNumFmts);
const OUString aDefaultStyle = OUString::createFromAscii("Default").intern();
for (vector<sal_uInt32>::const_iterator itr = aNumFmts.begin(), itrEnd = aNumFmts.end();
itr != itrEnd; ++itr)
{
sal_Int32 nNumFmt = static_cast<sal_Int32>(*itr);
addDataStyle(nNumFmt);
uno::Any aVal;
aVal <<= nNumFmt;
vector<XMLPropertyState> aProps;
aProps.push_back(XMLPropertyState(nEntryIndex, aVal));
aVal <<= aDefaultStyle;
aProps.push_back(XMLPropertyState(nEntryIndex, aVal));
OUString aName;
sal_Int32 nIndex;
if (GetAutoStylePool()->Add(aName, XML_STYLE_FAMILY_TABLE_CELL, aDefaultStyle, aProps))
{
OUString* pTemp(new OUString(aName));
if (!pCellStyles->AddStyleName(pTemp, nIndex, true))
delete pTemp;
}
else
{
sal_Bool bIsAuto;
nIndex = pCellStyles->GetIndexOfStyleName(
aName, OUString::createFromAscii(XML_STYLE_FAMILY_TABLE_CELL_STYLES_PREFIX), bIsAuto);
}
// store the number format to index mapping for later use.
aNumFmtIndexMap.insert(NumberFormatIndexMap::value_type(nNumFmt, nIndex));
}
}
void ScXMLExport::WriteRowContent()
{
ScMyRowFormatRange aRange;
sal_Int32 nIndex(-1);
#ifdef DBG_UTIL
sal_Int32 nPrevCol(0);
#endif
sal_Int32 nCols(0);
sal_Int32 nPrevValidationIndex(-1);
sal_Bool bIsAutoStyle(sal_True);
sal_Bool bIsFirst(sal_True);
while (pRowFormatRanges->GetNext(aRange))
{
#ifdef DBG_UTIL
DBG_ASSERT(bIsFirst || (!bIsFirst && (nPrevCol + nCols == aRange.nStartColumn)), "here are some columns missing");
#endif
if (bIsFirst)
{
nIndex = aRange.nIndex;
nPrevValidationIndex = aRange.nValidationIndex;
bIsAutoStyle = aRange.bIsAutoStyle;
nCols = aRange.nRepeatColumns;
bIsFirst = sal_False;
#ifdef DBG_UTIL
nPrevCol = aRange.nStartColumn;
#endif
}
else
{
if (((aRange.nIndex == nIndex && aRange.bIsAutoStyle == bIsAutoStyle) ||
(aRange.nIndex == nIndex && nIndex == -1)) &&
nPrevValidationIndex == aRange.nValidationIndex)
nCols += aRange.nRepeatColumns;
else
{
if (nIndex != -1)
AddAttribute(sAttrStyleName, *pCellStyles->GetStyleNameByIndex(nIndex, bIsAutoStyle));
if (nPrevValidationIndex > -1)
AddAttribute(XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION_NAME, pValidationsContainer->GetValidationName(nPrevValidationIndex));
if (nCols > 1)
{
rtl::OUStringBuffer aBuf;
GetMM100UnitConverter().convertNumber(aBuf, nCols);
AddAttribute(sAttrColumnsRepeated, aBuf.makeStringAndClear());
}
SvXMLElementExport aElemC(*this, sElemCell, sal_True, sal_True);
nIndex = aRange.nIndex;
bIsAutoStyle = aRange.bIsAutoStyle;
nCols = aRange.nRepeatColumns;
nPrevValidationIndex = aRange.nValidationIndex;
#ifdef DBG_UTIL
nPrevCol = aRange.nStartColumn;
#endif
}
}
}
if (!bIsFirst)
{
table::CellAddress aCellAddress;
if (nIndex != -1)
AddAttribute(sAttrStyleName, *pCellStyles->GetStyleNameByIndex(nIndex, bIsAutoStyle));
if (nPrevValidationIndex > -1)
AddAttribute(XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION_NAME, pValidationsContainer->GetValidationName(nPrevValidationIndex));
if (nCols > 1)
{
rtl::OUStringBuffer aBuf;
GetMM100UnitConverter().convertNumber(aBuf, nCols);
AddAttribute(sAttrColumnsRepeated, aBuf.makeStringAndClear());
}
SvXMLElementExport aElemC(*this, sElemCell, sal_True, sal_True);
}
}
void ScXMLExport::WriteRowStartTag(sal_Int32 nRow, const sal_Int32 nIndex,
const sal_Int8 nFlag, const sal_Int32 nEqualRows)
{
AddAttribute(sAttrStyleName, *pRowStyles->GetStyleNameByIndex(nIndex));
if (nFlag)
if (nFlag & CR_HIDDEN)
{
if (nFlag & CR_FILTERED)
AddAttribute(XML_NAMESPACE_TABLE, XML_VISIBILITY, XML_FILTER);
else
AddAttribute(XML_NAMESPACE_TABLE, XML_VISIBILITY, XML_COLLAPSE);
}
if (nEqualRows > 1)
{
rtl::OUStringBuffer aBuf;
GetMM100UnitConverter().convertNumber(aBuf, nEqualRows);
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_REPEATED, aBuf.makeStringAndClear());
}
const ScMyDefaultStyleList& rRowDefaults = *pDefaults->GetRowDefaults();
if ( nRow >= sal::static_int_cast<sal_Int32>( rRowDefaults.size() ) )
{
// #123981# used to happen with detective operations - if there are more cases, use the last row's style
DBG_ERRORFILE("WriteRowStartTag: not enough defaults");
nRow = rRowDefaults.size() - 1;
}
sal_Int32 nCellStyleIndex(rRowDefaults[nRow].nIndex);
if (nCellStyleIndex != -1)
AddAttribute(XML_NAMESPACE_TABLE, XML_DEFAULT_CELL_STYLE_NAME,
*pCellStyles->GetStyleNameByIndex(nCellStyleIndex,
(*pDefaults->GetRowDefaults())[nRow].bIsAutoStyle));
StartElement( sElemRow, sal_True);
}
void ScXMLExport::OpenHeaderRows()
{
StartElement( XML_NAMESPACE_TABLE, XML_TABLE_HEADER_ROWS, sal_True);
bRowHeaderOpen = sal_True;
}
void ScXMLExport::CloseHeaderRows()
{
EndElement(XML_NAMESPACE_TABLE, XML_TABLE_HEADER_ROWS, sal_True);
}
void ScXMLExport::OpenNewRow(const sal_Int32 nIndex, const sal_Int8 nFlag, const sal_Int32 nStartRow, const sal_Int32 nEqualRows)
{
nOpenRow = nStartRow;
if (pGroupRows->IsGroupStart(nStartRow))
{
if (bHasRowHeader && bRowHeaderOpen)
CloseHeaderRows();
pGroupRows->OpenGroups(nStartRow);
if (bHasRowHeader && bRowHeaderOpen)
OpenHeaderRows();
}
if (bHasRowHeader && !bRowHeaderOpen && nStartRow >= aRowHeaderRange.StartRow && nStartRow <= aRowHeaderRange.EndRow)
{
if (nStartRow == aRowHeaderRange.StartRow)
OpenHeaderRows();
sal_Int32 nEquals;
if (aRowHeaderRange.EndRow < nStartRow + nEqualRows - 1)
nEquals = aRowHeaderRange.EndRow - nStartRow + 1;
else
nEquals = nEqualRows;
WriteRowStartTag(nStartRow, nIndex, nFlag, nEquals);
nOpenRow = nStartRow + nEquals - 1;
if (nEquals < nEqualRows)
{
CloseRow(nStartRow + nEquals - 1);
WriteRowStartTag(nStartRow, nIndex, nFlag, nEqualRows - nEquals);
nOpenRow = nStartRow + nEqualRows - 1;
}
}
else
WriteRowStartTag(nStartRow, nIndex, nFlag, nEqualRows);
}
void ScXMLExport::OpenAndCloseRow(const sal_Int32 nIndex, const sal_Int8 nFlag,
const sal_Int32 nStartRow, const sal_Int32 nEqualRows)
{
OpenNewRow(nIndex, nFlag, nStartRow, nEqualRows);
WriteRowContent();
CloseRow(nStartRow + nEqualRows - 1);
pRowFormatRanges->Clear();
}
void ScXMLExport::OpenRow(const sal_Int32 nTable, const sal_Int32 nStartRow, const sal_Int32 nRepeatRow)
{
if (nRepeatRow > 1)
{
sal_Int32 nPrevIndex(0), nIndex;
sal_Int8 nPrevFlag(0);
sal_Int8 nFlag(0);
sal_Int32 nEqualRows(1);
sal_Int32 nEndRow(nStartRow + nRepeatRow);
sal_Int32 nRow;
for (nRow = nStartRow; nRow < nEndRow; ++nRow)
{
if (nRow == nStartRow)
{
nPrevIndex = pRowStyles->GetStyleNameIndex(nTable, nRow);
if (pDoc)
nPrevFlag = (pDoc->GetRowFlags(static_cast<SCROW>(nRow), static_cast<SCTAB>(nTable))) & (CR_HIDDEN | CR_FILTERED);
}
else
{
nIndex = pRowStyles->GetStyleNameIndex(nTable, nRow);
if (pDoc)
nFlag = (pDoc->GetRowFlags(static_cast<SCROW>(nRow), static_cast<SCTAB>(nTable))) & (CR_HIDDEN | CR_FILTERED);
if (nIndex == nPrevIndex && nFlag == nPrevFlag &&
!(bHasRowHeader && ((nRow == aRowHeaderRange.StartRow) || (nRow - 1 == aRowHeaderRange.EndRow))) &&
!(pGroupRows->IsGroupStart(nRow)) &&
!(pGroupRows->IsGroupEnd(nRow - 1)))
++nEqualRows;
else
{
if (nRow < nEndRow)
{
ScRowFormatRanges* pTempRowFormatRanges = new ScRowFormatRanges(pRowFormatRanges);
OpenAndCloseRow(nPrevIndex, nPrevFlag, nRow - nEqualRows, nEqualRows);
delete pRowFormatRanges;
pRowFormatRanges = pTempRowFormatRanges;
}
else
OpenAndCloseRow(nPrevIndex, nPrevFlag, nRow - nEqualRows, nEqualRows);
nEqualRows = 1;
nPrevIndex = nIndex;
nPrevFlag = nFlag;
}
}
}
OpenNewRow(nPrevIndex, nPrevFlag, nRow - nEqualRows, nEqualRows);
}
else
{
sal_Int32 nIndex = pRowStyles->GetStyleNameIndex(nTable, nStartRow);
sal_Int8 nFlag(0);
if (pDoc)
nFlag = (pDoc->GetRowFlags(static_cast<SCROW>(nStartRow), static_cast<SCTAB>(nTable))) & (CR_HIDDEN | CR_FILTERED);
OpenNewRow(nIndex, nFlag, nStartRow, 1);
}
nOpenRow = nStartRow + nRepeatRow - 1;
}
void ScXMLExport::CloseRow(const sal_Int32 nRow)
{
if (nOpenRow > -1)
{
EndElement(sElemRow, sal_True);
if (bHasRowHeader && nRow == aRowHeaderRange.EndRow)
{
CloseHeaderRows();
bRowHeaderOpen = sal_False;
}
if (pGroupRows->IsGroupEnd(nRow))
{
if (bHasRowHeader && bRowHeaderOpen)
CloseHeaderRows();
pGroupRows->CloseGroups(nRow);
if (bHasRowHeader && bRowHeaderOpen)
OpenHeaderRows();
}
}
nOpenRow = -1;
}
void ScXMLExport::ExportFormatRanges(const sal_Int32 nStartCol, const sal_Int32 nStartRow,
const sal_Int32 nEndCol, const sal_Int32 nEndRow, const sal_Int32 nSheet)
{
pRowFormatRanges->Clear();
if (nStartRow == nEndRow)
{
pCellStyles->GetFormatRanges(nStartCol, nEndCol, nStartRow, nSheet, pRowFormatRanges);
if (nOpenRow == - 1)
OpenRow(nSheet, nStartRow, 1);
WriteRowContent();
pRowFormatRanges->Clear();
}
else
{
if (nOpenRow > -1)
{
pCellStyles->GetFormatRanges(nStartCol, pSharedData->GetLastColumn(nSheet), nStartRow, nSheet, pRowFormatRanges);
WriteRowContent();
CloseRow(nStartRow);
sal_Int32 nRows(1);
sal_Int32 nTotalRows(nEndRow - nStartRow + 1 - 1);
while (nRows < nTotalRows)
{
pRowFormatRanges->Clear();
pCellStyles->GetFormatRanges(0, pSharedData->GetLastColumn(nSheet), nStartRow + nRows, nSheet, pRowFormatRanges);
sal_Int32 nMaxRows = pRowFormatRanges->GetMaxRows();
DBG_ASSERT(nMaxRows, "something wents wrong");
if (nMaxRows >= nTotalRows - nRows)
{
OpenRow(nSheet, nStartRow + nRows, nTotalRows - nRows);
nRows += nTotalRows - nRows;
}
else
{
OpenRow(nSheet, nStartRow + nRows, nMaxRows);
nRows += nMaxRows;
}
if (!pRowFormatRanges->GetSize())
pCellStyles->GetFormatRanges(0, pSharedData->GetLastColumn(nSheet), nStartRow + nRows, nSheet, pRowFormatRanges);
WriteRowContent();
CloseRow(nStartRow + nRows - 1);
}
if (nTotalRows == 1)
CloseRow(nStartRow);
OpenRow(nSheet, nEndRow, 1);
pRowFormatRanges->Clear();
pCellStyles->GetFormatRanges(0, nEndCol, nEndRow, nSheet, pRowFormatRanges);
WriteRowContent();
}
else
{
sal_Int32 nRows(0);
sal_Int32 nTotalRows(nEndRow - nStartRow + 1 - 1);
while (nRows < nTotalRows)
{
pCellStyles->GetFormatRanges(0, pSharedData->GetLastColumn(nSheet), nStartRow + nRows, nSheet, pRowFormatRanges);
sal_Int32 nMaxRows = pRowFormatRanges->GetMaxRows();
if (nMaxRows >= nTotalRows - nRows)
{
OpenRow(nSheet, nStartRow + nRows, nTotalRows - nRows);
nRows += nTotalRows - nRows;
}
else
{
OpenRow(nSheet, nStartRow + nRows, nMaxRows);
nRows += nMaxRows;
}
if (!pRowFormatRanges->GetSize())
pCellStyles->GetFormatRanges(0, pSharedData->GetLastColumn(nSheet), nStartRow + nRows, nSheet, pRowFormatRanges);
WriteRowContent();
CloseRow(nStartRow + nRows - 1);
}
OpenRow(nSheet, nEndRow, 1);
pRowFormatRanges->Clear();
pCellStyles->GetFormatRanges(0, nEndCol, nEndRow, nSheet, pRowFormatRanges);
WriteRowContent();
}
}
}
void ScXMLExport::GetColumnRowHeader(sal_Bool& rHasColumnHeader, table::CellRangeAddress& rColumnHeaderRange,
sal_Bool& rHasRowHeader, table::CellRangeAddress& rRowHeaderRange,
rtl::OUString& rPrintRanges) const
{
uno::Reference <sheet::XPrintAreas> xPrintAreas (xCurrentTable, uno::UNO_QUERY);
if (xPrintAreas.is())
{
rHasRowHeader = xPrintAreas->getPrintTitleRows();
rHasColumnHeader = xPrintAreas->getPrintTitleColumns();
rRowHeaderRange = xPrintAreas->getTitleRows();
rColumnHeaderRange = xPrintAreas->getTitleColumns();
uno::Sequence< table::CellRangeAddress > aRangeList( xPrintAreas->getPrintAreas() );
ScRangeStringConverter::GetStringFromRangeList( rPrintRanges, aRangeList, pDoc, FormulaGrammar::CONV_OOO );
}
}
void ScXMLExport::FillFieldGroup(ScOutlineArray* pFields, ScMyOpenCloseColumnRowGroup* pGroups)
{
sal_Int32 nDepth(pFields->GetDepth());
for(sal_Int32 i = 0; i < nDepth; ++i)
{
sal_Int32 nFields = pFields->GetCount(static_cast<sal_uInt16>(i));
for (sal_Int32 j = 0; j < nFields; ++j)
{
ScMyColumnRowGroup aGroup;
ScOutlineEntry* pEntry(pFields->GetEntry(static_cast<sal_uInt16>(i), static_cast<sal_uInt16>(j)));
aGroup.nField = pEntry->GetStart();
aGroup.nLevel = static_cast<sal_Int16>(i);
aGroup.bDisplay = !(pEntry->IsHidden());
pGroups->AddGroup(aGroup, pEntry->GetEnd());
}
}
if (nDepth)
pGroups->Sort();
}
void ScXMLExport::FillColumnRowGroups()
{
if (pDoc)
{
ScOutlineTable* pOutlineTable = pDoc->GetOutlineTable( static_cast<SCTAB>(nCurrentTable), sal_False );
if(pOutlineTable)
{
ScOutlineArray* pCols(pOutlineTable->GetColArray());
ScOutlineArray* pRows(pOutlineTable->GetRowArray());
if (pCols)
FillFieldGroup(pCols, pGroupColumns);
if (pRows)
FillFieldGroup(pRows, pGroupRows);
pSharedData->SetLastColumn(nCurrentTable, pGroupColumns->GetLast());
pSharedData->SetLastRow(nCurrentTable, pGroupRows->GetLast());
}
}
}
void ScXMLExport::SetBodyAttributes()
{
if (pDoc && pDoc->IsDocProtected())
{
AddAttribute(XML_NAMESPACE_TABLE, XML_STRUCTURE_PROTECTED, XML_TRUE);
rtl::OUStringBuffer aBuffer;
uno::Sequence<sal_Int8> aPassHash;
const ScDocProtection* p = pDoc->GetDocProtection();
if (p)
aPassHash = p->getPasswordHash(PASSHASH_OOO);
SvXMLUnitConverter::encodeBase64(aBuffer, aPassHash);
if (aBuffer.getLength())
AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTION_KEY, aBuffer.makeStringAndClear());
}
}
static bool lcl_CopyStreamElement( const uno::Reference< io::XInputStream >& xInput,
const uno::Reference< io::XOutputStream >& xOutput,
sal_Int32 nCount )
{
const sal_Int32 nBufSize = 16*1024;
uno::Sequence<sal_Int8> aSequence(nBufSize);
sal_Int32 nRemaining = nCount;
bool bFirst = true;
while ( nRemaining > 0 )
{
sal_Int32 nRead = xInput->readBytes( aSequence, std::min( nRemaining, nBufSize ) );
if (bFirst)
{
// safety check: Make sure the copied part actually points to the start of an element
if ( nRead < 1 || aSequence[0] != static_cast<sal_Int8>('<') )
{
return false; // abort and set an error
}
bFirst = false;
}
if (nRead == nRemaining)
{
// safety check: Make sure the copied part also ends at the end of an element
if ( aSequence[nRead-1] != static_cast<sal_Int8>('>') )
{
return false; // abort and set an error
}
}
if ( nRead == nBufSize )
{
xOutput->writeBytes( aSequence );
nRemaining -= nRead;
}
else
{
if ( nRead > 0 )
{
uno::Sequence<sal_Int8> aTempBuf( aSequence.getConstArray(), nRead );
xOutput->writeBytes( aTempBuf );
}
nRemaining = 0;
}
}
return true; // successful
}
static void lcl_SkipBytesInBlocks( const uno::Reference< io::XInputStream >& xInput, sal_Int32 nBytesToSkip )
{
// skipBytes in zip stream is implemented as reading.
// For now, split into several calls to avoid allocating a large buffer.
// Later, skipBytes should be changed.
const sal_Int32 nMaxSize = 32*1024;
if ( nBytesToSkip > 0 )
{
sal_Int32 nRemaining = nBytesToSkip;
while ( nRemaining > 0 )
{
sal_Int32 nSkip = std::min( nRemaining, nMaxSize );
xInput->skipBytes( nSkip );
nRemaining -= nSkip;
}
}
}
void ScXMLExport::CopySourceStream( sal_Int32 nStartOffset, sal_Int32 nEndOffset, sal_Int32& rNewStart, sal_Int32& rNewEnd )
{
uno::Reference<xml::sax::XDocumentHandler> xHandler = GetDocHandler();
uno::Reference<io::XActiveDataSource> xDestSource( xHandler, uno::UNO_QUERY );
if ( xDestSource.is() )
{
uno::Reference<io::XOutputStream> xDestStream = xDestSource->getOutputStream();
uno::Reference<io::XSeekable> xDestSeek( xDestStream, uno::UNO_QUERY );
if ( xDestSeek.is() )
{
// temporary: set same stream again to clear buffer
xDestSource->setOutputStream( xDestStream );
if ( getExportFlags() & EXPORT_PRETTY )
{
ByteString aOutStr("\n ");
uno::Sequence<sal_Int8> aOutSeq( (sal_Int8*)aOutStr.GetBuffer(), aOutStr.Len() );
xDestStream->writeBytes( aOutSeq );
}
rNewStart = (sal_Int32)xDestSeek->getPosition();
if ( nStartOffset > nSourceStreamPos )
lcl_SkipBytesInBlocks( xSourceStream, nStartOffset - nSourceStreamPos );
if ( !lcl_CopyStreamElement( xSourceStream, xDestStream, nEndOffset - nStartOffset ) )
{
// If copying went wrong, set an error.
// ScXMLImportWrapper then resets all stream flags, so the next save attempt will use normal saving.
uno::Sequence<OUString> aEmptySeq;
SetError(XMLERROR_CANCEL|XMLERROR_FLAG_SEVERE, aEmptySeq);
}
nSourceStreamPos = nEndOffset;
rNewEnd = (sal_Int32)xDestSeek->getPosition();
}
}
}
void ScXMLExport::_ExportContent()
{
nCurrentTable = 0;
if (!pSharedData)
{
sal_Int32 nTableCount(0);
sal_Int32 nShapesCount(0);
sal_Int32 nCellCount(pDoc ? pDoc->GetCellCount() : 0);
CollectSharedData(nTableCount, nShapesCount, nCellCount);
DBG_ERROR("no shared data setted");
}
ScXMLExportDatabaseRanges aExportDatabaseRanges(*this);
if (!GetModel().is())
return;
uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( GetModel(), uno::UNO_QUERY );
if ( !xSpreadDoc.is() )
return;
ScSheetSaveData* pSheetData = ScModelObj::getImplementation(xSpreadDoc)->GetSheetSaveData();
if (pSheetData)
pSheetData->ResetSaveEntries();
uno::Reference<container::XIndexAccess> xIndex( xSpreadDoc->getSheets(), uno::UNO_QUERY );
if ( xIndex.is() )
{
//_GetNamespaceMap().ClearQNamesCache();
pChangeTrackingExportHelper->CollectAndWriteChanges();
WriteCalculationSettings(xSpreadDoc);
sal_Int32 nTableCount(xIndex->getCount());
ScMyAreaLinksContainer aAreaLinks;
GetAreaLinks( xSpreadDoc, aAreaLinks );
ScMyEmptyDatabaseRangesContainer aEmptyRanges(aExportDatabaseRanges.GetEmptyDatabaseRanges());
ScMyDetectiveOpContainer aDetectiveOpContainer;
GetDetectiveOpList( aDetectiveOpContainer );
pCellStyles->Sort();
pMergedRangesContainer->Sort();
pSharedData->GetDetectiveObjContainer()->Sort();
pCellsItr->Clear();
pCellsItr->SetShapes( pSharedData->GetShapesContainer() );
pCellsItr->SetNoteShapes( pSharedData->GetNoteShapes() );
pCellsItr->SetMergedRanges( pMergedRangesContainer );
pCellsItr->SetAreaLinks( &aAreaLinks );
pCellsItr->SetEmptyDatabaseRanges( &aEmptyRanges );
pCellsItr->SetDetectiveObj( pSharedData->GetDetectiveObjContainer() );
pCellsItr->SetDetectiveOp( &aDetectiveOpContainer );
if (nTableCount > 0)
pValidationsContainer->WriteValidations(*this);
WriteTheLabelRanges( xSpreadDoc );
for (sal_Int32 nTable = 0; nTable < nTableCount; ++nTable)
{
sal_Int32 nStartOffset = -1;
sal_Int32 nEndOffset = -1;
if (pSheetData && pDoc && pDoc->IsStreamValid((SCTAB)nTable))
pSheetData->GetStreamPos( nTable, nStartOffset, nEndOffset );
if ( nStartOffset >= 0 && nEndOffset >= 0 && xSourceStream.is() )
{
sal_Int32 nNewStart = -1;
sal_Int32 nNewEnd = -1;
CopySourceStream( nStartOffset, nEndOffset, nNewStart, nNewEnd );
// store position of copied sheet in output
pSheetData->AddSavePos( nTable, nNewStart, nNewEnd );
// skip iterator entries for this sheet
pCellsItr->SkipTable(static_cast<SCTAB>(nTable));
}
else
{
uno::Reference<sheet::XSpreadsheet> xTable(xIndex->getByIndex(nTable), uno::UNO_QUERY);
if (xTable.is())
{
xCurrentTable.set(xTable);
xCurrentTableCellRange.set(xTable, uno::UNO_QUERY);
uno::Reference<container::XNamed> xName (xTable, uno::UNO_QUERY );
if ( xName.is() )
{
nCurrentTable = sal::static_int_cast<sal_uInt16>( nTable );
rtl::OUString sOUTableName(xName->getName());
AddAttribute(sAttrName, sOUTableName);
AddAttribute(sAttrStyleName, aTableStyles[nTable]);
uno::Reference<util::XProtectable> xProtectable (xTable, uno::UNO_QUERY);
if (xProtectable.is() && xProtectable->isProtected())
{
AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTED, XML_TRUE);
rtl::OUStringBuffer aBuffer;
if (pDoc)
{
ScTableProtection* pProtect = pDoc->GetTabProtection(static_cast<SCTAB>(nTable));
if (pProtect)
SvXMLUnitConverter::encodeBase64(aBuffer, pProtect->getPasswordHash(PASSHASH_OOO));
}
if (aBuffer.getLength())
AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTION_KEY, aBuffer.makeStringAndClear());
}
rtl::OUString sPrintRanges;
table::CellRangeAddress aColumnHeaderRange;
sal_Bool bHasColumnHeader;
GetColumnRowHeader(bHasColumnHeader, aColumnHeaderRange, bHasRowHeader, aRowHeaderRange, sPrintRanges);
if( sPrintRanges.getLength() )
AddAttribute( XML_NAMESPACE_TABLE, XML_PRINT_RANGES, sPrintRanges );
else if (!pDoc->IsPrintEntireSheet(static_cast<SCTAB>(nTable)))
AddAttribute( XML_NAMESPACE_TABLE, XML_PRINT, XML_FALSE);
SvXMLElementExport aElemT(*this, sElemTab, sal_True, sal_True);
CheckAttrList();
if ( pDoc && pDoc->GetSheetEvents( static_cast<SCTAB>(nTable) ) &&
getDefaultVersion() == SvtSaveOptions::ODFVER_LATEST )
{
// store sheet events
uno::Reference<document::XEventsSupplier> xSupplier(xTable, uno::UNO_QUERY);
uno::Reference<container::XNameAccess> xEvents(xSupplier->getEvents(), uno::UNO_QUERY);
GetEventExport().ExportExt( xEvents );
}
WriteTableSource();
WriteScenario();
uno::Reference<drawing::XDrawPage> xDrawPage;
if (pSharedData->HasForm(nTable, xDrawPage) && xDrawPage.is())
{
::xmloff::OOfficeFormsExport aForms(*this);
GetFormExport()->exportForms( xDrawPage );
sal_Bool bRet(GetFormExport()->seekPage( xDrawPage ));
DBG_ASSERT( bRet, "OFormLayerXMLExport::seekPage failed!" );
(void)bRet; // avoid warning in product version
}
if (pSharedData->HasDrawPage())
{
GetShapeExport()->seekShapes(uno::Reference<drawing::XShapes>(pSharedData->GetDrawPage(nTable), uno::UNO_QUERY));
WriteTableShapes();
}
table::CellRangeAddress aRange(GetEndAddress(xTable, nTable));
pSharedData->SetLastColumn(nTable, aRange.EndColumn);
pSharedData->SetLastRow(nTable, aRange.EndRow);
pCellsItr->SetCurrentTable(static_cast<SCTAB>(nTable), xCurrentTable);
pGroupColumns->NewTable();
pGroupRows->NewTable();
FillColumnRowGroups();
if (bHasColumnHeader)
pSharedData->SetLastColumn(nTable, aColumnHeaderRange.EndColumn);
bRowHeaderOpen = sal_False;
if (bHasRowHeader)
pSharedData->SetLastRow(nTable, aRowHeaderRange.EndRow);
pDefaults->FillDefaultStyles(nTable, pSharedData->GetLastRow(nTable),
pSharedData->GetLastColumn(nTable), pCellStyles, pDoc);
pRowFormatRanges->SetRowDefaults(pDefaults->GetRowDefaults());
pRowFormatRanges->SetColDefaults(pDefaults->GetColDefaults());
pCellStyles->SetRowDefaults(pDefaults->GetRowDefaults());
pCellStyles->SetColDefaults(pDefaults->GetColDefaults());
ExportColumns(nTable, aColumnHeaderRange, bHasColumnHeader);
sal_Bool bIsFirst(sal_True);
sal_Int32 nEqualCells(0);
ScMyCell aCell;
ScMyCell aPrevCell;
while(pCellsItr->GetNext(aCell, pCellStyles))
{
if (bIsFirst)
{
ExportFormatRanges(0, 0, aCell.aCellAddress.Column - 1, aCell.aCellAddress.Row, nTable);
aPrevCell = aCell;
bIsFirst = sal_False;
}
else
{
if ((aPrevCell.aCellAddress.Row == aCell.aCellAddress.Row) &&
(aPrevCell.aCellAddress.Column + nEqualCells + 1 == aCell.aCellAddress.Column))
{
if(IsCellEqual(aPrevCell, aCell))
++nEqualCells;
else
{
WriteCell(aPrevCell, nEqualCells);
nEqualCells = 0;
aPrevCell = aCell;
}
}
else
{
WriteCell(aPrevCell, nEqualCells);
ExportFormatRanges(aPrevCell.aCellAddress.Column + nEqualCells + 1, aPrevCell.aCellAddress.Row,
aCell.aCellAddress.Column - 1, aCell.aCellAddress.Row, nTable);
nEqualCells = 0;
aPrevCell = aCell;
}
}
}
if (!bIsFirst)
{
WriteCell(aPrevCell, nEqualCells);
ExportFormatRanges(aPrevCell.aCellAddress.Column + nEqualCells + 1, aPrevCell.aCellAddress.Row,
pSharedData->GetLastColumn(nTable), pSharedData->GetLastRow(nTable), nTable);
}
else
ExportFormatRanges(0, 0, pSharedData->GetLastColumn(nTable), pSharedData->GetLastRow(nTable), nTable);
CloseRow(pSharedData->GetLastRow(nTable));
WriteNamedExpressions(xSpreadDoc, nTable);
nEqualCells = 0;
}
}
}
IncrementProgressBar(sal_False);
}
}
WriteExternalRefCaches();
WriteNamedExpressions(xSpreadDoc, MAXTABCOUNT);
aExportDatabaseRanges.WriteDatabaseRanges(xSpreadDoc);
ScXMLExportDataPilot aExportDataPilot(*this);
aExportDataPilot.WriteDataPilots(xSpreadDoc);
WriteConsolidation();
ScXMLExportDDELinks aExportDDELinks(*this);
aExportDDELinks.WriteDDELinks(xSpreadDoc);
IncrementProgressBar(sal_True, 0);
GetProgressBarHelper()->SetValue(GetProgressBarHelper()->GetReference());
}
void ScXMLExport::_ExportStyles( sal_Bool bUsed )
{
if (!pSharedData)
{
sal_Int32 nTableCount(0);
sal_Int32 nShapesCount(0);
sal_Int32 nCellCount(pDoc ? pDoc->GetCellCount() : 0);
CollectSharedData(nTableCount, nShapesCount, nCellCount);
//DBG_ERROR("no shared data setted");
}
ScXMLStyleExport aStylesExp(*this, rtl::OUString(), GetAutoStylePool().get());
if (GetModel().is())
{
uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
if (xMultiServiceFactory.is())
{
uno::Reference <beans::XPropertySet> xProperties(xMultiServiceFactory->createInstance(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.Defaults"))), uno::UNO_QUERY);
if (xProperties.is())
aStylesExp.exportDefaultStyle(xProperties, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_NAME)), xCellStylesExportPropertySetMapper);
if (pSharedData->HasShapes())
{
GetShapeExport()->ExportGraphicDefaults();
/* xInterface = xMultiServiceFactory->createInstance(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.Defaults")));
uno::Reference <beans::XPropertySet> xDrawProperties(xInterface, uno::UNO_QUERY);
if (xDrawProperties.is())
aStylesExp.exportDefaultStyle(xDrawProperties, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_SD_GRAPHICS_NAME)), GetShapeExport()->CreateShapePropMapper(*this));*/
}
}
uno::Reference <style::XStyleFamiliesSupplier> xStyleFamiliesSupplier (GetModel(), uno::UNO_QUERY);
if (xStyleFamiliesSupplier.is())
{
uno::Reference <container::XNameAccess> xStylesFamilies(xStyleFamiliesSupplier->getStyleFamilies());
if (xStylesFamilies.is())
{
uno::Reference <container::XIndexAccess> xCellStyles(xStylesFamilies->getByName(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CellStyles"))), uno::UNO_QUERY);
if (xCellStyles.is())
{
sal_Int32 nCount(xCellStyles->getCount());
rtl::OUString sNumberFormat(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_NUMFMT));
for (sal_Int32 i = 0; i < nCount; ++i)
{
uno::Reference <beans::XPropertySet> xCellProperties(xCellStyles->getByIndex(i), uno::UNO_QUERY);
if (xCellProperties.is())
{
sal_Int32 nNumberFormat = 0;
if (xCellProperties->getPropertyValue(sNumberFormat) >>= nNumberFormat)
addDataStyle(nNumberFormat);
}
}
}
}
}
}
exportDataStyles();
aStylesExp.exportStyleFamily(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CellStyles")),
rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_NAME)), xCellStylesExportPropertySetMapper, sal_False, XML_STYLE_FAMILY_TABLE_CELL);
SvXMLExport::_ExportStyles(bUsed);
}
void ScXMLExport::AddStyleFromCells(const uno::Reference<beans::XPropertySet>& xProperties,
const uno::Reference<sheet::XSpreadsheet>& xTable,
sal_Int32 nTable, const rtl::OUString* pOldName)
{
//! pass xCellRanges instead
uno::Reference<sheet::XSheetCellRanges> xCellRanges( xProperties, uno::UNO_QUERY );
rtl::OUString SC_SCELLPREFIX(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_CELL_STYLES_PREFIX));
rtl::OUString SC_NUMBERFORMAT(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_NUMFMT));
rtl::OUString sStyleName;
sal_Int32 nNumberFormat(-1);
sal_Int32 nValidationIndex(-1);
std::vector< XMLPropertyState > xPropStates(xCellStylesExportPropertySetMapper->Filter( xProperties ));
std::vector< XMLPropertyState >::iterator aItr(xPropStates.begin());
std::vector< XMLPropertyState >::iterator aEndItr(xPropStates.end());
sal_Int32 nCount(0);
while (aItr != aEndItr)
{
if (aItr->mnIndex != -1)
{
switch (xCellStylesPropertySetMapper->GetEntryContextId(aItr->mnIndex))
{
case CTF_SC_VALIDATION :
{
pValidationsContainer->AddValidation(aItr->maValue, nValidationIndex);
// this is not very slow, because it is most the last property or
// if it is not the last property it is the property before the last property,
// so in the worst case only one property has to be copied, but in the best case no
// property has to be copied
aItr = xPropStates.erase(aItr);
aEndItr = xPropStates.end(); // #120346# old aEndItr is invalidated!
}
break;
case CTF_SC_CELLSTYLE :
{
aItr->maValue >>= sStyleName;
aItr->mnIndex = -1;
++aItr;
++nCount;
}
break;
case CTF_SC_NUMBERFORMAT :
{
if (aItr->maValue >>= nNumberFormat)
addDataStyle(nNumberFormat);
++aItr;
++nCount;
}
break;
default:
{
++aItr;
++nCount;
}
break;
}
}
else
{
++aItr;
++nCount;
}
}
if (nCount == 1) // this is the CellStyle and should be removed if alone
xPropStates.clear();
if (nNumberFormat == -1)
xProperties->getPropertyValue(SC_NUMBERFORMAT) >>= nNumberFormat;
if (sStyleName.getLength())
{
if (xPropStates.size())
{
sal_Int32 nIndex;
if (pOldName)
{
if (GetAutoStylePool()->AddNamed(*pOldName, XML_STYLE_FAMILY_TABLE_CELL, sStyleName, xPropStates))
{
GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TABLE_CELL, *pOldName);
// add to pCellStyles, so the name is found for normal sheets
rtl::OUString* pTemp(new rtl::OUString(*pOldName));
if (!pCellStyles->AddStyleName(pTemp, nIndex))
delete pTemp;
}
}
else
{
rtl::OUString sName;
sal_Bool bIsAutoStyle(sal_True);
if (GetAutoStylePool()->Add(sName, XML_STYLE_FAMILY_TABLE_CELL, sStyleName, xPropStates))
{
rtl::OUString* pTemp(new rtl::OUString(sName));
if (!pCellStyles->AddStyleName(pTemp, nIndex))
delete pTemp;
}
else
nIndex = pCellStyles->GetIndexOfStyleName(sName, SC_SCELLPREFIX, bIsAutoStyle);
uno::Sequence<table::CellRangeAddress> aAddresses(xCellRanges->getRangeAddresses());
table::CellRangeAddress* pAddresses(aAddresses.getArray());
sal_Bool bGetMerge(sal_True);
for (sal_Int32 i = 0; i < aAddresses.getLength(); ++i, ++pAddresses)
{
pSharedData->SetLastColumn(nTable, pAddresses->EndColumn);
pSharedData->SetLastRow(nTable, pAddresses->EndRow);
pCellStyles->AddRangeStyleName(*pAddresses, nIndex, bIsAutoStyle, nValidationIndex, nNumberFormat);
if (bGetMerge)
bGetMerge = GetMerged(pAddresses, xTable);
}
}
}
else
{
rtl::OUString* pTemp(new rtl::OUString(EncodeStyleName(sStyleName)));
sal_Int32 nIndex(0);
if (!pCellStyles->AddStyleName(pTemp, nIndex, sal_False))
{
delete pTemp;
pTemp = NULL;
}
if ( !pOldName )
{
uno::Sequence<table::CellRangeAddress> aAddresses(xCellRanges->getRangeAddresses());
table::CellRangeAddress* pAddresses(aAddresses.getArray());
sal_Bool bGetMerge(sal_True);
for (sal_Int32 i = 0; i < aAddresses.getLength(); ++i, ++pAddresses)
{
if (bGetMerge)
bGetMerge = GetMerged(pAddresses, xTable);
pCellStyles->AddRangeStyleName(*pAddresses, nIndex, sal_False, nValidationIndex, nNumberFormat);
if (!sStyleName.equalsAsciiL("Default", 7) || nValidationIndex != -1)
{
pSharedData->SetLastColumn(nTable, pAddresses->EndColumn);
pSharedData->SetLastRow(nTable, pAddresses->EndRow);
}
}
}
}
}
}
void ScXMLExport::AddStyleFromColumn(const uno::Reference<beans::XPropertySet>& xColumnProperties,
const rtl::OUString* pOldName, sal_Int32& rIndex, sal_Bool& rIsVisible)
{
rtl::OUString SC_SCOLUMNPREFIX(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_PREFIX));
std::vector<XMLPropertyState> xPropStates(xColumnStylesExportPropertySetMapper->Filter(xColumnProperties));
if(xPropStates.size())
{
std::vector< XMLPropertyState >::iterator aItr(xPropStates.begin());
std::vector< XMLPropertyState >::iterator aEndItr(xPropStates.end());
while (aItr != aEndItr)
{
if (xColumnStylesPropertySetMapper->GetEntryContextId(aItr->mnIndex) == CTF_SC_ISVISIBLE)
{
aItr->maValue >>= rIsVisible;
break;
}
++aItr;
}
rtl::OUString sParent;
if (pOldName)
{
if (GetAutoStylePool()->AddNamed(*pOldName, XML_STYLE_FAMILY_TABLE_COLUMN, sParent, xPropStates))
{
GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TABLE_COLUMN, *pOldName);
// add to pColumnStyles, so the name is found for normal sheets
rtl::OUString* pTemp(new rtl::OUString(*pOldName));
rIndex = pColumnStyles->AddStyleName(pTemp);
}
}
else
{
rtl::OUString sName;
if (GetAutoStylePool()->Add(sName, XML_STYLE_FAMILY_TABLE_COLUMN, sParent, xPropStates))
{
rtl::OUString* pTemp(new rtl::OUString(sName));
rIndex = pColumnStyles->AddStyleName(pTemp);
}
else
rIndex = pColumnStyles->GetIndexOfStyleName(sName, SC_SCOLUMNPREFIX);
}
}
}
void ScXMLExport::AddStyleFromRow(const uno::Reference<beans::XPropertySet>& xRowProperties,
const rtl::OUString* pOldName, sal_Int32& rIndex)
{
rtl::OUString SC_SROWPREFIX(RTL_CONSTASCII_USTRINGPARAM(XML_STYLE_FAMILY_TABLE_ROW_STYLES_PREFIX));
std::vector<XMLPropertyState> xPropStates(xRowStylesExportPropertySetMapper->Filter(xRowProperties));
if(xPropStates.size())
{
rtl::OUString sParent;
if (pOldName)
{
if (GetAutoStylePool()->AddNamed(*pOldName, XML_STYLE_FAMILY_TABLE_ROW, sParent, xPropStates))
{
GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TABLE_ROW, *pOldName);
// add to pRowStyles, so the name is found for normal sheets
rtl::OUString* pTemp(new rtl::OUString(*pOldName));
rIndex = pRowStyles->AddStyleName(pTemp);
}
}
else
{
rtl::OUString sName;
if (GetAutoStylePool()->Add(sName, XML_STYLE_FAMILY_TABLE_ROW, sParent, xPropStates))
{
rtl::OUString* pTemp(new rtl::OUString(sName));
rIndex = pRowStyles->AddStyleName(pTemp);
}
else
rIndex = pRowStyles->GetIndexOfStyleName(sName, SC_SROWPREFIX);
}
}
}
uno::Any lcl_GetEnumerated( uno::Reference<container::XEnumerationAccess> xEnumAccess, sal_Int32 nIndex )
{
uno::Any aRet;
uno::Reference<container::XEnumeration> xEnum( xEnumAccess->createEnumeration() );
try
{
sal_Int32 nSkip = nIndex;
while ( nSkip > 0 )
{
(void) xEnum->nextElement();
--nSkip;
}
aRet = xEnum->nextElement();
}
catch (container::NoSuchElementException&)
{
// leave aRet empty
}
return aRet;
}
void ScXMLExport::_ExportAutoStyles()
{
if (!GetModel().is())
return;
uno::Reference <sheet::XSpreadsheetDocument> xSpreadDoc( GetModel(), uno::UNO_QUERY );
if (!xSpreadDoc.is())
return;
uno::Reference<container::XIndexAccess> xIndex( xSpreadDoc->getSheets(), uno::UNO_QUERY );
if (!xIndex.is())
return;
if (getExportFlags() & EXPORT_CONTENT)
{
// re-create automatic styles with old names from stored data
ScSheetSaveData* pSheetData = ScModelObj::getImplementation(xSpreadDoc)->GetSheetSaveData();
if (pSheetData && pDoc)
{
// formulas have to be calculated now, to detect changed results
// (during normal save, they will be calculated anyway)
SCTAB nTabCount = pDoc->GetTableCount();
for (SCTAB nTab=0; nTab<nTabCount; ++nTab)
if (pDoc->IsStreamValid(nTab))
{
ScCellIterator aIter( pDoc, 0,0,nTab, MAXCOL,MAXROW,nTab );
ScBaseCell* pCell = aIter.GetFirst();
while (pCell)
{
if (pCell->GetCellType() == CELLTYPE_FORMULA)
static_cast<ScFormulaCell*>(pCell)->IsValue(); // interpret if dirty
pCell = aIter.GetNext();
}
}
// stored cell styles
const std::vector<ScCellStyleEntry>& rCellEntries = pSheetData->GetCellStyles();
std::vector<ScCellStyleEntry>::const_iterator aCellIter = rCellEntries.begin();
std::vector<ScCellStyleEntry>::const_iterator aCellEnd = rCellEntries.end();
while (aCellIter != aCellEnd)
{
ScAddress aPos = aCellIter->maCellPos;
sal_Int32 nTable = aPos.Tab();
bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
if (bCopySheet)
{
uno::Reference <sheet::XSpreadsheet> xTable(xIndex->getByIndex(nTable), uno::UNO_QUERY);
uno::Reference <beans::XPropertySet> xProperties(
xTable->getCellByPosition( aPos.Col(), aPos.Row() ), uno::UNO_QUERY );
AddStyleFromCells(xProperties, xTable, nTable, &aCellIter->maName);
}
++aCellIter;
}
// stored column styles
const std::vector<ScCellStyleEntry>& rColumnEntries = pSheetData->GetColumnStyles();
std::vector<ScCellStyleEntry>::const_iterator aColumnIter = rColumnEntries.begin();
std::vector<ScCellStyleEntry>::const_iterator aColumnEnd = rColumnEntries.end();
while (aColumnIter != aColumnEnd)
{
ScAddress aPos = aColumnIter->maCellPos;
sal_Int32 nTable = aPos.Tab();
bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
if (bCopySheet)
{
uno::Reference<table::XColumnRowRange> xColumnRowRange(xIndex->getByIndex(nTable), uno::UNO_QUERY);
uno::Reference<table::XTableColumns> xTableColumns(xColumnRowRange->getColumns());
uno::Reference<beans::XPropertySet> xColumnProperties(xTableColumns->getByIndex( aPos.Col() ), uno::UNO_QUERY);
sal_Int32 nIndex(-1);
sal_Bool bIsVisible(sal_True);
AddStyleFromColumn( xColumnProperties, &aColumnIter->maName, nIndex, bIsVisible );
}
++aColumnIter;
}
// stored row styles
const std::vector<ScCellStyleEntry>& rRowEntries = pSheetData->GetRowStyles();
std::vector<ScCellStyleEntry>::const_iterator aRowIter = rRowEntries.begin();
std::vector<ScCellStyleEntry>::const_iterator aRowEnd = rRowEntries.end();
while (aRowIter != aRowEnd)
{
ScAddress aPos = aRowIter->maCellPos;
sal_Int32 nTable = aPos.Tab();
bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
if (bCopySheet)
{
uno::Reference<table::XColumnRowRange> xColumnRowRange(xIndex->getByIndex(nTable), uno::UNO_QUERY);
uno::Reference<table::XTableRows> xTableRows(xColumnRowRange->getRows());
uno::Reference<beans::XPropertySet> xRowProperties(xTableRows->getByIndex( aPos.Row() ), uno::UNO_QUERY);
sal_Int32 nIndex(-1);
AddStyleFromRow( xRowProperties, &aRowIter->maName, nIndex );
}
++aRowIter;
}
// stored table styles
const std::vector<ScCellStyleEntry>& rTableEntries = pSheetData->GetTableStyles();
std::vector<ScCellStyleEntry>::const_iterator aTableIter = rTableEntries.begin();
std::vector<ScCellStyleEntry>::const_iterator aTableEnd = rTableEntries.end();
while (aTableIter != aTableEnd)
{
ScAddress aPos = aTableIter->maCellPos;
sal_Int32 nTable = aPos.Tab();
bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
if (bCopySheet)
{
//! separate method AddStyleFromTable needed?
uno::Reference<beans::XPropertySet> xTableProperties(xIndex->getByIndex(nTable), uno::UNO_QUERY);
if (xTableProperties.is())
{
std::vector<XMLPropertyState> xPropStates(xTableStylesExportPropertySetMapper->Filter(xTableProperties));
rtl::OUString sParent;
rtl::OUString sName( aTableIter->maName );
GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_TABLE_TABLE, sParent, xPropStates);
GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TABLE_TABLE, sName);
}
}
++aTableIter;
}
// stored styles for notes
UniReference<SvXMLExportPropertyMapper> xShapeMapper = XMLShapeExport::CreateShapePropMapper( *this );
GetShapeExport(); // make sure the graphics styles family is added
const std::vector<ScNoteStyleEntry>& rNoteEntries = pSheetData->GetNoteStyles();
std::vector<ScNoteStyleEntry>::const_iterator aNoteIter = rNoteEntries.begin();
std::vector<ScNoteStyleEntry>::const_iterator aNoteEnd = rNoteEntries.end();
while (aNoteIter != aNoteEnd)
{
ScAddress aPos = aNoteIter->maCellPos;
sal_Int32 nTable = aPos.Tab();
bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
if (bCopySheet)
{
//! separate method AddStyleFromNote needed?
ScPostIt* pNote = pDoc->GetNote( aPos );
DBG_ASSERT( pNote, "note not found" );
if (pNote)
{
SdrCaptionObj* pDrawObj = pNote->GetOrCreateCaption( aPos );
// all uno shapes are created anyway in CollectSharedData
uno::Reference<beans::XPropertySet> xShapeProperties( pDrawObj->getUnoShape(), uno::UNO_QUERY );
if (xShapeProperties.is())
{
if ( aNoteIter->maStyleName.getLength() )
{
std::vector<XMLPropertyState> xPropStates(xShapeMapper->Filter(xShapeProperties));
rtl::OUString sParent;
rtl::OUString sName( aNoteIter->maStyleName );
GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_SD_GRAPHICS_ID, sParent, xPropStates);
GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_SD_GRAPHICS_ID, sName);
}
if ( aNoteIter->maTextStyle.getLength() )
{
std::vector<XMLPropertyState> xPropStates(
GetTextParagraphExport()->GetParagraphPropertyMapper()->Filter(xShapeProperties));
rtl::OUString sParent;
rtl::OUString sName( aNoteIter->maTextStyle );
GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_TEXT_PARAGRAPH, sParent, xPropStates);
GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TEXT_PARAGRAPH, sName);
}
}
}
}
++aNoteIter;
}
// note paragraph styles
//UniReference<SvXMLExportPropertyMapper> xParaPropMapper = XMLTextParagraphExport::CreateParaExtPropMapper( *this );
UniReference<SvXMLExportPropertyMapper> xParaPropMapper = GetTextParagraphExport()->GetParagraphPropertyMapper();
const std::vector<ScTextStyleEntry>& rNoteParaEntries = pSheetData->GetNoteParaStyles();
std::vector<ScTextStyleEntry>::const_iterator aNoteParaIter = rNoteParaEntries.begin();
std::vector<ScTextStyleEntry>::const_iterator aNoteParaEnd = rNoteParaEntries.end();
while (aNoteParaIter != aNoteParaEnd)
{
ScAddress aPos = aNoteParaIter->maCellPos;
sal_Int32 nTable = aPos.Tab();
bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
if (bCopySheet)
{
ScPostIt* pNote = pDoc->GetNote( aPos );
DBG_ASSERT( pNote, "note not found" );
if (pNote)
{
SdrCaptionObj* pDrawObj = pNote->GetOrCreateCaption( aPos );
uno::Reference<container::XEnumerationAccess> xCellText(pDrawObj->getUnoShape(), uno::UNO_QUERY);
uno::Reference<beans::XPropertySet> xParaProp(
lcl_GetEnumerated( xCellText, aNoteParaIter->maSelection.nStartPara ), uno::UNO_QUERY );
if ( xParaProp.is() )
{
std::vector<XMLPropertyState> xPropStates(xParaPropMapper->Filter(xParaProp));
rtl::OUString sParent;
rtl::OUString sName( aNoteParaIter->maName );
GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_TEXT_PARAGRAPH, sParent, xPropStates);
GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TEXT_PARAGRAPH, sName);
}
}
}
++aNoteParaIter;
}
// note text styles
UniReference<SvXMLExportPropertyMapper> xTextPropMapper = XMLTextParagraphExport::CreateCharExtPropMapper( *this );
const std::vector<ScTextStyleEntry>& rNoteTextEntries = pSheetData->GetNoteTextStyles();
std::vector<ScTextStyleEntry>::const_iterator aNoteTextIter = rNoteTextEntries.begin();
std::vector<ScTextStyleEntry>::const_iterator aNoteTextEnd = rNoteTextEntries.end();
while (aNoteTextIter != aNoteTextEnd)
{
ScAddress aPos = aNoteTextIter->maCellPos;
sal_Int32 nTable = aPos.Tab();
bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
if (bCopySheet)
{
ScPostIt* pNote = pDoc->GetNote( aPos );
DBG_ASSERT( pNote, "note not found" );
if (pNote)
{
SdrCaptionObj* pDrawObj = pNote->GetOrCreateCaption( aPos );
uno::Reference<text::XSimpleText> xCellText(pDrawObj->getUnoShape(), uno::UNO_QUERY);
uno::Reference<beans::XPropertySet> xCursorProp(xCellText->createTextCursor(), uno::UNO_QUERY);
ScDrawTextCursor* pCursor = ScDrawTextCursor::getImplementation( xCursorProp );
if (pCursor)
{
pCursor->SetSelection( aNoteTextIter->maSelection );
std::vector<XMLPropertyState> xPropStates(xTextPropMapper->Filter(xCursorProp));
rtl::OUString sParent;
rtl::OUString sName( aNoteTextIter->maName );
GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_TEXT_TEXT, sParent, xPropStates);
GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TEXT_TEXT, sName);
}
}
}
++aNoteTextIter;
}
// stored text styles
//UniReference<SvXMLExportPropertyMapper> xTextPropMapper = XMLTextParagraphExport::CreateCharExtPropMapper( *this );
const std::vector<ScTextStyleEntry>& rTextEntries = pSheetData->GetTextStyles();
std::vector<ScTextStyleEntry>::const_iterator aTextIter = rTextEntries.begin();
std::vector<ScTextStyleEntry>::const_iterator aTextEnd = rTextEntries.end();
while (aTextIter != aTextEnd)
{
ScAddress aPos = aTextIter->maCellPos;
sal_Int32 nTable = aPos.Tab();
bool bCopySheet = pDoc->IsStreamValid( static_cast<SCTAB>(nTable) );
if (bCopySheet)
{
//! separate method AddStyleFromText needed?
//! cache sheet object
uno::Reference<table::XCellRange> xCellRange(xIndex->getByIndex(nTable), uno::UNO_QUERY);
uno::Reference<text::XSimpleText> xCellText(xCellRange->getCellByPosition(aPos.Col(), aPos.Row()), uno::UNO_QUERY);
uno::Reference<beans::XPropertySet> xCursorProp(xCellText->createTextCursor(), uno::UNO_QUERY);
ScCellTextCursor* pCursor = ScCellTextCursor::getImplementation( xCursorProp );
if (pCursor)
{
pCursor->SetSelection( aTextIter->maSelection );
std::vector<XMLPropertyState> xPropStates(xTextPropMapper->Filter(xCursorProp));
rtl::OUString sParent;
rtl::OUString sName( aTextIter->maName );
GetAutoStylePool()->AddNamed(sName, XML_STYLE_FAMILY_TEXT_TEXT, sParent, xPropStates);
GetAutoStylePool()->RegisterName(XML_STYLE_FAMILY_TEXT_TEXT, sName);
}
}
++aTextIter;
}
}
ExportExternalRefCacheStyles();
if (!pSharedData)
{
sal_Int32 nTableCount(0);
sal_Int32 nShapesCount(0);
sal_Int32 nCellCount(pDoc ? pDoc->GetCellCount() : 0);
CollectSharedData(nTableCount, nShapesCount, nCellCount);
//DBG_ERROR("no shared data setted");
}
sal_Int32 nTableCount(xIndex->getCount());
pCellStyles->AddNewTable(nTableCount - 1);
CollectShapesAutoStyles(nTableCount);
for (sal_Int32 nTable = 0; nTable < nTableCount; ++nTable)
{
bool bUseStream = pSheetData && pDoc && pDoc->IsStreamValid((SCTAB)nTable) &&
pSheetData->HasStreamPos(nTable) && xSourceStream.is();
uno::Reference <sheet::XSpreadsheet> xTable(xIndex->getByIndex(nTable), uno::UNO_QUERY);
if (xTable.is())
{
// table styles array must be complete, including copied tables - Add should find the stored style
uno::Reference<beans::XPropertySet> xTableProperties(xTable, uno::UNO_QUERY);
if (xTableProperties.is())
{
std::vector<XMLPropertyState> xPropStates(xTableStylesExportPropertySetMapper->Filter(xTableProperties));
if(xPropStates.size())
{
rtl::OUString sParent;
rtl::OUString sName;
GetAutoStylePool()->Add(sName, XML_STYLE_FAMILY_TABLE_TABLE, sParent, xPropStates);
aTableStyles.push_back(sName);
}
}
}
// collect other auto-styles only for non-copied sheets
if (xTable.is() && !bUseStream)
{
uno::Reference<sheet::XUniqueCellFormatRangesSupplier> xCellFormatRanges ( xTable, uno::UNO_QUERY );
if ( xCellFormatRanges.is() )
{
uno::Reference<container::XIndexAccess> xFormatRangesIndex(xCellFormatRanges->getUniqueCellFormatRanges());
if (xFormatRangesIndex.is())
{
sal_Int32 nFormatRangesCount(xFormatRangesIndex->getCount());
GetProgressBarHelper()->ChangeReference(GetProgressBarHelper()->GetReference() + nFormatRangesCount);
for (sal_Int32 nFormatRange = 0; nFormatRange < nFormatRangesCount; ++nFormatRange)
{
uno::Reference< sheet::XSheetCellRanges> xCellRanges(xFormatRangesIndex->getByIndex(nFormatRange), uno::UNO_QUERY);
if (xCellRanges.is())
{
uno::Reference <beans::XPropertySet> xProperties (xCellRanges, uno::UNO_QUERY);
if (xProperties.is())
{
AddStyleFromCells(xProperties, xTable, nTable, NULL);
IncrementProgressBar(sal_False);
}
}
}
}
}
uno::Reference<table::XColumnRowRange> xColumnRowRange (xTable, uno::UNO_QUERY);
if (xColumnRowRange.is())
{
if (pDoc)
{
pDoc->SyncColRowFlags();
uno::Reference<table::XTableColumns> xTableColumns(xColumnRowRange->getColumns());
if (xTableColumns.is())
{
sal_Int32 nColumns(pDoc->GetLastChangedCol(sal::static_int_cast<SCTAB>(nTable)));
pSharedData->SetLastColumn(nTable, nColumns);
table::CellRangeAddress aCellAddress(GetEndAddress(xTable, nTable));
if (aCellAddress.EndColumn > nColumns)
{
++nColumns;
pColumnStyles->AddNewTable(nTable, aCellAddress.EndColumn);
}
// else if (nColumns < MAXCOL)
// pColumnStyles->AddNewTable(nTable, ++nColumns);
else
pColumnStyles->AddNewTable(nTable, nColumns);
sal_Int32 nColumn = 0;
while (/*nColumn <= nColumns && */nColumn <= MAXCOL)
{
sal_Int32 nIndex(-1);
sal_Bool bIsVisible(sal_True);
uno::Reference <beans::XPropertySet> xColumnProperties(xTableColumns->getByIndex(nColumn), uno::UNO_QUERY);
if (xColumnProperties.is())
{
AddStyleFromColumn( xColumnProperties, NULL, nIndex, bIsVisible );
//if(xPropStates.size())
pColumnStyles->AddFieldStyleName(nTable, nColumn, nIndex, bIsVisible);
}
sal_Int32 nOld(nColumn);
nColumn = pDoc->GetNextDifferentChangedCol(sal::static_int_cast<SCTAB>(nTable), static_cast<SCCOL>(nColumn));
for (sal_Int32 i = nOld + 1; i < nColumn; ++i)
pColumnStyles->AddFieldStyleName(nTable, i, nIndex, bIsVisible);
}
if (aCellAddress.EndColumn > nColumns)
{
sal_Bool bIsVisible(sal_True);
sal_Int32 nIndex(pColumnStyles->GetStyleNameIndex(nTable, nColumns, bIsVisible));
for (sal_Int32 i = nColumns + 1; i <= aCellAddress.EndColumn; ++i)
pColumnStyles->AddFieldStyleName(nTable, i, nIndex, bIsVisible);
}
}
uno::Reference<table::XTableRows> xTableRows(xColumnRowRange->getRows());
if (xTableRows.is())
{
sal_Int32 nRows(pDoc->GetLastChangedRow(sal::static_int_cast<SCTAB>(nTable)));
pSharedData->SetLastRow(nTable, nRows);
table::CellRangeAddress aCellAddress(GetEndAddress(xTable, nTable));
if (aCellAddress.EndRow > nRows)
{
++nRows;
pRowStyles->AddNewTable(nTable, aCellAddress.EndRow);
}
// else if (nRows < MAXROW)
// pRowStyles->AddNewTable(nTable, ++nRows);
else
pRowStyles->AddNewTable(nTable, nRows);
sal_Int32 nRow = 0;
while (nRow <= nRows && nRow <= MAXROW)
{
sal_Int32 nIndex = 0;
uno::Reference <beans::XPropertySet> xRowProperties(xTableRows->getByIndex(nRow), uno::UNO_QUERY);
if(xRowProperties.is())
{
AddStyleFromRow( xRowProperties, NULL, nIndex );
//if(xPropStates.size())
pRowStyles->AddFieldStyleName(nTable, nRow, nIndex);
}
sal_Int32 nOld(nRow);
nRow = pDoc->GetNextDifferentChangedRow(sal::static_int_cast<SCTAB>(nTable), static_cast<SCROW>(nRow), false);
if (nRow > nOld + 1)
pRowStyles->AddFieldStyleName(nTable, nOld + 1, nIndex, nRow - 1);
}
if (aCellAddress.EndRow > nRows)
{
sal_Int32 nIndex(pRowStyles->GetStyleNameIndex(nTable, nRows));
pRowStyles->AddFieldStyleName(nTable, nRows + 1, nIndex, aCellAddress.EndRow);
}
}
}
}
uno::Reference<sheet::XCellRangesQuery> xCellRangesQuery (xTable, uno::UNO_QUERY);
if (xCellRangesQuery.is())
{
uno::Reference<sheet::XSheetCellRanges> xSheetCellRanges(xCellRangesQuery->queryContentCells(sheet::CellFlags::FORMATTED));
uno::Reference<sheet::XSheetOperation> xSheetOperation(xSheetCellRanges, uno::UNO_QUERY);
if (xSheetCellRanges.is() && xSheetOperation.is())
{
sal_uInt32 nCount(sal_uInt32(xSheetOperation->computeFunction(sheet::GeneralFunction_COUNT)));
uno::Reference<container::XEnumerationAccess> xCellsAccess(xSheetCellRanges->getCells());
if (xCellsAccess.is())
{
GetProgressBarHelper()->ChangeReference(GetProgressBarHelper()->GetReference() + nCount);
uno::Reference<container::XEnumeration> xCells(xCellsAccess->createEnumeration());
if (xCells.is())
{
sal_uInt32 nCount2(0);
while (xCells->hasMoreElements())
{
uno::Reference<text::XText> xText(xCells->nextElement(), uno::UNO_QUERY);
if (xText.is())
GetTextParagraphExport()->collectTextAutoStyles(xText, sal_False, sal_False);
++nCount2;
IncrementProgressBar(sal_False);
}
if(nCount2 > nCount)
GetProgressBarHelper()->SetReference(GetProgressBarHelper()->GetReference() + nCount2 - nCount);
}
}
}
}
}
IncrementProgressBar(sal_False);
}
pChangeTrackingExportHelper->CollectAutoStyles();
GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_COLUMN,
GetDocHandler(), GetMM100UnitConverter(), GetNamespaceMap());
GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_ROW,
GetDocHandler(), GetMM100UnitConverter(), GetNamespaceMap());
GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_TABLE,
GetDocHandler(), GetMM100UnitConverter(), GetNamespaceMap());
exportAutoDataStyles();
GetAutoStylePool()->exportXML(XML_STYLE_FAMILY_TABLE_CELL,
GetDocHandler(), GetMM100UnitConverter(), GetNamespaceMap());
GetShapeExport()->exportAutoStyles();
GetFormExport()->exportAutoStyles( );
if (pDoc)
{
ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
// #i100879# write the table style for cached tables only if there are cached tables
// (same logic as in ExportExternalRefCacheStyles)
if (pRefMgr->hasExternalData())
{
// Special table style for the external ref cache tables.
AddAttribute(XML_NAMESPACE_STYLE, XML_NAME, sExternalRefTabStyleName);
AddAttribute(XML_NAMESPACE_STYLE, XML_FAMILY, XML_TABLE);
SvXMLElementExport aElemStyle(*this, XML_NAMESPACE_STYLE, XML_STYLE, sal_True, sal_True);
AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY, XML_FALSE);
SvXMLElementExport aElemStyleTabProps(*this, XML_NAMESPACE_STYLE, XML_TABLE_PROPERTIES, sal_True, sal_True);
}
}
}
if (getExportFlags() & EXPORT_MASTERSTYLES)
{
GetPageExport()->collectAutoStyles(sal_True);
GetPageExport()->exportAutoStyles();
}
// #i30251#; only write Text Styles once
if ((getExportFlags() & EXPORT_CONTENT) || (getExportFlags() & EXPORT_MASTERSTYLES))
GetTextParagraphExport()->exportTextAutoStyles();
}
void ScXMLExport::_ExportMasterStyles()
{
GetPageExport()->exportMasterStyles( sal_True );
}
void ScXMLExport::CollectInternalShape( uno::Reference< drawing::XShape > xShape )
{
// detective objects and notes
if( SvxShape* pShapeImp = SvxShape::getImplementation( xShape ) )
{
if( SdrObject* pObject = pShapeImp->GetSdrObject() )
{
// collect note caption objects from all layers (internal or hidden)
if( ScDrawObjData* pCaptData = ScDrawLayer::GetNoteCaptionData( pObject, static_cast< SCTAB >( nCurrentTable ) ) )
{
pSharedData->AddNoteObj( xShape, pCaptData->maStart );
// #i60851# When the file is saved while editing a new note,
// the cell is still empty -> last column/row must be updated
DBG_ASSERT( pCaptData->maStart.Tab() == nCurrentTable, "invalid table in object data" );
pSharedData->SetLastColumn( nCurrentTable, pCaptData->maStart.Col() );
pSharedData->SetLastRow( nCurrentTable, pCaptData->maStart.Row() );
}
// other objects from internal layer only (detective)
else if( pObject->GetLayer() == SC_LAYER_INTERN )
{
ScDetectiveFunc aDetFunc( pDoc, static_cast<SCTAB>(nCurrentTable) );
ScAddress aPosition;
ScRange aSourceRange;
sal_Bool bRedLine;
ScDetectiveObjType eObjType = aDetFunc.GetDetectiveObjectType(
pObject, nCurrentTable, aPosition, aSourceRange, bRedLine );
pSharedData->GetDetectiveObjContainer()->AddObject( eObjType, static_cast<SCTAB>(nCurrentTable), aPosition, aSourceRange, bRedLine );
}
}
}
}
//UNUSED2008-05 sal_Bool ScXMLExport::GetMerge (const uno::Reference <sheet::XSpreadsheet>& xTable,
//UNUSED2008-05 const sal_Int32 nCol, const sal_Int32 nRow,
//UNUSED2008-05 table::CellRangeAddress& aCellAddress)
//UNUSED2008-05 {
//UNUSED2008-05 uno::Reference<sheet::XSheetCellRange> xSheetCellRange(xTable->getCellRangeByPosition(nCol, nRow, nCol, nRow), uno::UNO_QUERY);
//UNUSED2008-05 if (xSheetCellRange.is())
//UNUSED2008-05 {
//UNUSED2008-05 uno::Reference<sheet::XSheetCellCursor> xCursor(xTable->createCursorByRange(xSheetCellRange));
//UNUSED2008-05 if (xCursor.is())
//UNUSED2008-05 {
//UNUSED2008-05 uno::Reference<sheet::XCellRangeAddressable> xCellAddress (xCursor, uno::UNO_QUERY);
//UNUSED2008-05 xCursor->collapseToMergedArea();
//UNUSED2008-05 aCellAddress = xCellAddress->getRangeAddress();
//UNUSED2008-05 return sal_True;
//UNUSED2008-05 }
//UNUSED2008-05 }
//UNUSED2008-05 return sal_False;
//UNUSED2008-05 }
sal_Bool ScXMLExport::GetMerged (const table::CellRangeAddress* pCellAddress,
const uno::Reference <sheet::XSpreadsheet>& xTable)
{
sal_Bool bReady(sal_False);
sal_Int32 nRow(pCellAddress->StartRow);
sal_Int32 nCol(pCellAddress->StartColumn);
sal_Int32 nEndRow(pCellAddress->EndRow);
sal_Int32 nEndCol(pCellAddress->EndColumn);
sal_Bool bRowInc(nEndRow > nRow);
while(!bReady && nRow <= nEndRow && nCol <= nEndCol)
{
uno::Reference<sheet::XSheetCellRange> xSheetCellRange(xTable->getCellRangeByPosition(nCol, nRow, nCol, nRow), uno::UNO_QUERY);
if (xSheetCellRange.is())
{
uno::Reference<sheet::XSheetCellCursor> xCursor(xTable->createCursorByRange(xSheetCellRange));
if(xCursor.is())
{
uno::Reference<sheet::XCellRangeAddressable> xCellAddress (xCursor, uno::UNO_QUERY);
xCursor->collapseToMergedArea();
table::CellRangeAddress aCellAddress2(xCellAddress->getRangeAddress());
if ((aCellAddress2.EndRow > nRow ||
aCellAddress2.EndColumn > nCol) &&
aCellAddress2.StartRow == nRow &&
aCellAddress2.StartColumn == nCol)
{
pMergedRangesContainer->AddRange(aCellAddress2);
pSharedData->SetLastColumn(aCellAddress2.Sheet, aCellAddress2.EndColumn);
pSharedData->SetLastRow(aCellAddress2.Sheet, aCellAddress2.EndRow);
}
else
bReady = sal_True;
}
}
if (!bReady)
{
if (bRowInc)
++nRow;
else
++nCol;
}
}
DBG_ASSERT(!(!bReady && nEndRow > nRow && nEndCol > nCol), "should not be possible");
return !bReady;
}
//UNUSED2008-05 sal_Bool ScXMLExport::IsMatrix (const uno::Reference <table::XCellRange>& xCellRange,
//UNUSED2008-05 const uno::Reference <sheet::XSpreadsheet>& xTable,
//UNUSED2008-05 const sal_Int32 nCol, const sal_Int32 nRow,
//UNUSED2008-05 table::CellRangeAddress& aCellAddress, sal_Bool& bIsFirst) const
//UNUSED2008-05 {
//UNUSED2008-05 bIsFirst = sal_False;
//UNUSED2008-05 uno::Reference <sheet::XArrayFormulaRange> xArrayFormulaRange (xCellRange->getCellRangeByPosition(nCol,nRow,nCol,nRow), uno::UNO_QUERY);
//UNUSED2008-05 if (xArrayFormulaRange.is())
//UNUSED2008-05 {
//UNUSED2008-05 rtl::OUString sArrayFormula(xArrayFormulaRange->getArrayFormula());
//UNUSED2008-05 if (sArrayFormula.getLength())
//UNUSED2008-05 {
//UNUSED2008-05 uno::Reference<sheet::XSheetCellRange> xMatrixSheetCellRange (xArrayFormulaRange, uno::UNO_QUERY);
//UNUSED2008-05 if (xMatrixSheetCellRange.is())
//UNUSED2008-05 {
//UNUSED2008-05 uno::Reference<sheet::XSheetCellCursor> xMatrixSheetCursor(xTable->createCursorByRange(xMatrixSheetCellRange));
//UNUSED2008-05 if (xMatrixSheetCursor.is())
//UNUSED2008-05 {
//UNUSED2008-05 xMatrixSheetCursor->collapseToCurrentArray();
//UNUSED2008-05 uno::Reference<sheet::XCellRangeAddressable> xMatrixCellAddress (xMatrixSheetCursor, uno::UNO_QUERY);
//UNUSED2008-05 if (xMatrixCellAddress.is())
//UNUSED2008-05 {
//UNUSED2008-05 aCellAddress = xMatrixCellAddress->getRangeAddress();
//UNUSED2008-05 if ((aCellAddress.StartColumn == nCol && aCellAddress.StartRow == nRow) &&
//UNUSED2008-05 (aCellAddress.EndColumn > nCol || aCellAddress.EndRow > nRow))
//UNUSED2008-05 {
//UNUSED2008-05 bIsFirst = sal_True;
//UNUSED2008-05 return sal_True;
//UNUSED2008-05 }
//UNUSED2008-05 else if (aCellAddress.StartColumn != nCol || aCellAddress.StartRow != nRow ||
//UNUSED2008-05 aCellAddress.EndColumn != nCol || aCellAddress.EndRow != nRow)
//UNUSED2008-05 return sal_True;
//UNUSED2008-05 else
//UNUSED2008-05 {
//UNUSED2008-05 bIsFirst = sal_True;
//UNUSED2008-05 return sal_True;
//UNUSED2008-05 }
//UNUSED2008-05 }
//UNUSED2008-05 }
//UNUSED2008-05 }
//UNUSED2008-05 }
//UNUSED2008-05 }
//UNUSED2008-05 return sal_False;
//UNUSED2008-05 }
sal_Bool ScXMLExport::IsMatrix (const ScAddress& aCell,
table::CellRangeAddress& aCellAddress, sal_Bool& bIsFirst) const
{
bIsFirst = sal_False;
ScRange aMatrixRange;
if (pDoc && pDoc->GetMatrixFormulaRange(aCell, aMatrixRange))
{
ScUnoConversion::FillApiRange( aCellAddress, aMatrixRange );
if ((aCellAddress.StartColumn == aCell.Col() && aCellAddress.StartRow == aCell.Row()) &&
(aCellAddress.EndColumn > aCell.Col() || aCellAddress.EndRow > aCell.Row()))
{
bIsFirst = sal_True;
return sal_True;
}
else if (aCellAddress.StartColumn != aCell.Col() || aCellAddress.StartRow != aCell.Row() ||
aCellAddress.EndColumn != aCell.Col() || aCellAddress.EndRow != aCell.Row())
return sal_True;
else
{
bIsFirst = sal_True;
return sal_True;
}
}
return sal_False;
/* uno::Reference <sheet::XArrayFormulaRange> xArrayFormulaRange (xCell, uno::UNO_QUERY);
if (xArrayFormulaRange.is())
{
rtl::OUString sArrayFormula(xArrayFormulaRange->getArrayFormula());
if (sArrayFormula.getLength())
{
uno::Reference<sheet::XSheetCellRange> xMatrixSheetCellRange (xCell, uno::UNO_QUERY);
if (xMatrixSheetCellRange.is())
{
uno::Reference<sheet::XSheetCellCursor> xMatrixSheetCursor(xTable->createCursorByRange(xMatrixSheetCellRange));
if (xMatrixSheetCursor.is())
{
xMatrixSheetCursor->collapseToCurrentArray();
uno::Reference<sheet::XCellRangeAddressable> xMatrixCellAddress (xMatrixSheetCursor, uno::UNO_QUERY);
if (xMatrixCellAddress.is())
{
aCellAddress = xMatrixCellAddress->getRangeAddress();
if ((aCellAddress.StartColumn == nCol && aCellAddress.StartRow == nRow) &&
(aCellAddress.EndColumn > nCol || aCellAddress.EndRow > nRow))
{
bIsFirst = sal_True;
return sal_True;
}
else if (aCellAddress.StartColumn != nCol || aCellAddress.StartRow != nRow ||
aCellAddress.EndColumn != nCol || aCellAddress.EndRow != nRow)
return sal_True;
else
{
bIsFirst = sal_True;
return sal_True;
}
}
}
}
}
}
return sal_False;*/
}
sal_Bool ScXMLExport::GetCellText (ScMyCell& rMyCell, const ScAddress& aPos) const
{
if (rMyCell.bHasStringValue)
return sal_True;
else
{
/* if (!rMyCell.bHasXText)
{
rMyCell.xText.set(xCurrentTableCellRange->getCellByPosition(rMyCell.aCellAddress.Column, rMyCell.aCellAddress.Row), uno::UNO_QUERY);
rMyCell.bHasXText = sal_True;
}*/
// if (rMyCell.xText.is())
// {
rMyCell.sStringValue = ScCellObj::GetOutputString_Impl(pDoc, aPos);
rMyCell.bHasStringValue = sal_True;
return sal_True;
// }
}
}
void ScXMLExport::WriteCell(ScMyCell& aCell, sal_Int32 nEqualCellCount)
{
// nEqualCellCount is the number of additional cells
SetRepeatAttribute(nEqualCellCount, (aCell.nType != table::CellContentType_EMPTY));
ScAddress aCellPos;
ScUnoConversion::FillScAddress( aCellPos, aCell.aCellAddress );
if (aCell.nStyleIndex != -1)
AddAttribute(sAttrStyleName, *pCellStyles->GetStyleNameByIndex(aCell.nStyleIndex, aCell.bIsAutoStyle));
if (aCell.nValidationIndex > -1)
AddAttribute(XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION_NAME, pValidationsContainer->GetValidationName(aCell.nValidationIndex));
sal_Bool bIsMatrix(aCell.bIsMatrixBase || aCell.bIsMatrixCovered);
sal_Bool bIsFirstMatrixCell(aCell.bIsMatrixBase);
if (bIsFirstMatrixCell)
{
sal_Int32 nColumns(aCell.aMatrixRange.EndColumn - aCell.aMatrixRange.StartColumn + 1);
sal_Int32 nRows(aCell.aMatrixRange.EndRow - aCell.aMatrixRange.StartRow + 1);
rtl::OUStringBuffer sColumns;
rtl::OUStringBuffer sRows;
SvXMLUnitConverter::convertNumber(sColumns, nColumns);
SvXMLUnitConverter::convertNumber(sRows, nRows);
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_MATRIX_COLUMNS_SPANNED, sColumns.makeStringAndClear());
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_MATRIX_ROWS_SPANNED, sRows.makeStringAndClear());
}
sal_Bool bIsEmpty(sal_False);
switch (aCell.nType)
{
case table::CellContentType_EMPTY :
{
bIsEmpty = sal_True;
}
break;
case table::CellContentType_VALUE :
{
if (!aCell.bHasDoubleValue)
{
aCell.fValue = pDoc->GetValue( aCellPos );
aCell.bHasDoubleValue = sal_True;
}
GetNumberFormatAttributesExportHelper()->SetNumberFormatAttributes(
aCell.nNumberFormat, aCell.fValue);
}
break;
case table::CellContentType_TEXT :
{
if (GetCellText(aCell, aCellPos))
{
rtl::OUString sFormula(lcl_GetRawString(pDoc, aCellPos));
GetNumberFormatAttributesExportHelper()->SetNumberFormatAttributes(
sFormula, aCell.sStringValue, sal_True, sal_True);
}
}
break;
case table::CellContentType_FORMULA :
{
ScBaseCell* pBaseCell = pDoc ? pDoc->GetCell(aCellPos) : NULL;
if (pBaseCell && pBaseCell->GetCellType() == CELLTYPE_FORMULA)
{
rtl::OUStringBuffer sFormula;
ScFormulaCell* pFormulaCell((ScFormulaCell*) pBaseCell);
if (!bIsMatrix || (bIsMatrix && bIsFirstMatrixCell))
{
const formula::FormulaGrammar::Grammar eGrammar = pDoc->GetStorageGrammar();
sal_uInt16 nNamespacePrefix = (eGrammar == formula::FormulaGrammar::GRAM_ODFF ? XML_NAMESPACE_OF : XML_NAMESPACE_OOOC);
pFormulaCell->GetFormula(sFormula, eGrammar);//ange scope name support
rtl::OUString sOUFormula(sFormula.makeStringAndClear());
if (!bIsMatrix)
{
AddAttribute(sAttrFormula, GetNamespaceMap().GetQNameByKey( nNamespacePrefix, sOUFormula, sal_False ));
}
else
{
AddAttribute(sAttrFormula, GetNamespaceMap().GetQNameByKey( nNamespacePrefix, sOUFormula.copy(1, sOUFormula.getLength() - 2), sal_False ));
}
}
if (pFormulaCell->IsValue())
{
sal_Bool bIsStandard;
rtl::OUString sCurrency;
GetNumberFormatAttributesExportHelper()->GetCellType(aCell.nNumberFormat, sCurrency, bIsStandard);
if (bIsStandard)
{
if (pDoc)
GetNumberFormatAttributesExportHelper()->SetNumberFormatAttributes(
pFormulaCell->GetStandardFormat(*pDoc->GetFormatTable(), 0),
pDoc->GetValue( aCellPos ));
}
else
GetNumberFormatAttributesExportHelper()->SetNumberFormatAttributes(
aCell.nNumberFormat, pDoc->GetValue( aCellPos ));
}
else
{
if (GetCellText(aCell, aCellPos))
if (aCell.sStringValue.getLength())
{
AddAttribute(sAttrValueType, XML_STRING);
AddAttribute(sAttrStringValue, aCell.sStringValue);
}
}
}
}
break;
default:
{
// added to avoid warnings
}
}
rtl::OUString* pCellString(&sElemCell);
if (aCell.bIsCovered)
{
pCellString = &sElemCoveredCell;
}
else
{
if (aCell.bIsMergedBase)
{
sal_Int32 nColumns(aCell.aMergeRange.EndColumn - aCell.aMergeRange.StartColumn + 1);
sal_Int32 nRows(aCell.aMergeRange.EndRow - aCell.aMergeRange.StartRow + 1);
rtl::OUStringBuffer sColumns;
rtl::OUStringBuffer sRows;
SvXMLUnitConverter::convertNumber(sColumns, nColumns);
SvXMLUnitConverter::convertNumber(sRows, nRows);
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_SPANNED, sColumns.makeStringAndClear());
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_SPANNED, sRows.makeStringAndClear());
}
}
SvXMLElementExport aElemC(*this, *pCellString, sal_True, sal_True);
CheckAttrList();
WriteAreaLink(aCell);
WriteAnnotation(aCell);
WriteDetective(aCell);
sal_Bool bEditCell = sal_False;
if (!bIsEmpty)
{
if ((aCell.nType == table::CellContentType_TEXT && IsEditCell(aCell)) ||
(aCell.nType == table::CellContentType_FORMULA && IsMultiLineFormulaCell(aCell)))
{
bEditCell = sal_True;
uno::Reference<text::XText> xText(xCurrentTableCellRange->getCellByPosition(aCell.aCellAddress.Column, aCell.aCellAddress.Row), uno::UNO_QUERY);
if ( xText.is())
GetTextParagraphExport()->exportText(xText, sal_False, sal_False);
}
else
{
SvXMLElementExport aElemP(*this, sElemP, sal_True, sal_False);
sal_Bool bPrevCharWasSpace(sal_True);
if (GetCellText(aCell, aCellPos))
GetTextParagraphExport()->exportText(aCell.sStringValue, bPrevCharWasSpace);
}
}
WriteShapes(aCell);
if (!bIsEmpty)
IncrementProgressBar(bEditCell);
}
void ScXMLExport::ExportShape(const uno::Reference < drawing::XShape >& xShape, awt::Point* pPoint)
{
uno::Reference < beans::XPropertySet > xShapeProps ( xShape, uno::UNO_QUERY );
//BM sal_Bool bMemChart(sal_False); // das muss man jetzt umbenennen :-)
bool bIsChart( false );
rtl::OUString sPropCLSID (RTL_CONSTASCII_USTRINGPARAM("CLSID"));
rtl::OUString sPropModel (RTL_CONSTASCII_USTRINGPARAM("Model"));
rtl::OUString sPersistName (RTL_CONSTASCII_USTRINGPARAM("PersistName"));
if (xShapeProps.is())
{
sal_Int32 nZOrder = 0;
if (xShapeProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ZOrder"))) >>= nZOrder)
{
rtl::OUStringBuffer sBuffer;
GetMM100UnitConverter().convertNumber(sBuffer, nZOrder);
AddAttribute(XML_NAMESPACE_DRAW, XML_ZINDEX, sBuffer.makeStringAndClear());
}
uno::Reference< beans::XPropertySetInfo > xPropSetInfo = xShapeProps->getPropertySetInfo();
if( xPropSetInfo->hasPropertyByName( sPropCLSID ) )
{
rtl::OUString sCLSID;
if (xShapeProps->getPropertyValue( sPropCLSID ) >>= sCLSID)
{
if ( sCLSID.equalsIgnoreAsciiCase(GetChartExport()->getChartCLSID()) )
{
// we have a chart
::rtl::OUString sRanges;
if ( pDoc )
{
::rtl::OUString aChartName;
xShapeProps->getPropertyValue( sPersistName ) >>= aChartName;
ScRange aEmptyRange;
ScChartListener aSearcher( aChartName, pDoc, aEmptyRange );
sal_uInt16 nIndex = 0;
ScChartListenerCollection* pCollection = pDoc->GetChartListenerCollection();
if ( pCollection && pCollection->Search( &aSearcher, nIndex ) )
{
ScChartListener* pListener = static_cast< ScChartListener* >( pCollection->At( nIndex ) );
if ( pListener )
{
const ScRangeListRef& rRangeList = pListener->GetRangeList();
if ( rRangeList.Is() )
{
ScRangeStringConverter::GetStringFromRangeList( sRanges, rRangeList, pDoc, FormulaGrammar::CONV_OOO );
if ( sRanges.getLength() > 0 )
{
bIsChart = true;
SvXMLAttributeList* pAttrList = new SvXMLAttributeList();
if ( pAttrList )
{
pAttrList->AddAttribute(
GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_DRAW, GetXMLToken( XML_NOTIFY_ON_UPDATE_OF_RANGES ) ), sRanges );
}
GetShapeExport()->exportShape( xShape, SEF_EXPORT_NO_CHART_DATA | SEF_DEFAULT, pPoint, pAttrList );
}
}
}
}
}
if ( sRanges.getLength() == 0 )
{
uno::Reference< frame::XModel > xChartModel;
if( ( xShapeProps->getPropertyValue( sPropModel ) >>= xChartModel ) &&
xChartModel.is())
{
uno::Reference< chart2::XChartDocument > xChartDoc( xChartModel, uno::UNO_QUERY );
uno::Reference< chart2::data::XDataReceiver > xReceiver( xChartModel, uno::UNO_QUERY );
if( xChartDoc.is() && xReceiver.is() &&
! xChartDoc->hasInternalDataProvider())
{
// we have a chart that gets its data from Calc
bIsChart = true;
uno::Sequence< ::rtl::OUString > aRepresentations(
xReceiver->getUsedRangeRepresentations());
SvXMLAttributeList* pAttrList = 0;
if(aRepresentations.getLength())
{
// add the ranges used by the chart to the shape
// element to be able to start listening after
// load (when the chart is not yet loaded)
uno::Reference< chart2::data::XRangeXMLConversion > xRangeConverter( xChartDoc->getDataProvider(), uno::UNO_QUERY );
sRanges = lcl_RangeSequenceToString( aRepresentations, xRangeConverter );
pAttrList = new SvXMLAttributeList();
pAttrList->AddAttribute(
GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_DRAW, GetXMLToken(XML_NOTIFY_ON_UPDATE_OF_RANGES) ), sRanges );
}
GetShapeExport()->exportShape(xShape, SEF_EXPORT_NO_CHART_DATA | SEF_DEFAULT, pPoint, pAttrList);
}
}
}
//BM rtl::OUString sOUName;
//BM xShapeProps->getPropertyValue(sPersistName) >>= sOUName;
//BM String sName(sOUName);
//BM if (!pChartListener)
//BM {
//BM String aEmptyString;
//BM ScRange aRange;
//BM pChartListener = new ScChartListener ( aEmptyString, GetDocument(), aRange );
//BM }
//BM if(pChartListener)
//BM {
//BM sal_uInt16 nIndex(0);
//BM pChartListener->SetString( sName );
//BM if ( GetDocument() && GetDocument()->GetChartListenerCollection()->Search( pChartListener, nIndex ) )
//BM {
//BM const ScRangeListRef& rRangeListRef(((ScChartListener*)
//BM (GetDocument()->GetChartListenerCollection()->
//BM At( nIndex )))->GetRangeList());
//BM if (rRangeListRef.Is())
//BM {
//BM bMemChart = sal_True;
//BM rtl::OUString sRanges;
//BM ScRangeStringConverter::GetStringFromRangeList(sRanges, rRangeListRef, GetDocument());
//BM SvXMLAttributeList* pAttrList = NULL;
//BM if (sRanges.getLength())
//BM {
//BM pAttrList = new SvXMLAttributeList();
//BM pAttrList->AddAttribute(
//BM GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_DRAW, GetXMLToken(XML_NOTIFY_ON_UPDATE_OF_RANGES) ), sRanges );
//BM }
//BM GetShapeExport()->exportShape(xShape, SEF_EXPORT_NO_CHART_DATA | SEF_DEFAULT, pPoint, pAttrList);
//BM }
//BM }
//BM else
//BM {
//BM bMemChart = sal_True;
//BM SvXMLAttributeList* pAttrList = new SvXMLAttributeList();
//BM pAttrList->AddAttribute(
//BM GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_DRAW, GetXMLToken(XML_NOTIFY_ON_UPDATE_OF_RANGES) ), rtl::OUString() );
//BM GetShapeExport()->exportShape(xShape, SEF_EXPORT_NO_CHART_DATA | SEF_DEFAULT, pPoint, pAttrList);
//BM }
//BM }
/* SchMemChart* pMemChart = pDoc->FindChartData(sName);
if (pMemChart && pMemChart->GetSeriesAddresses().getLength())
{
bMemChart = sal_True;
rtl::OUString sRanges(pMemChart->getXMLStringForChartRange());
if (sRanges.getLength())
AddAttribute(XML_NAMESPACE_DRAW, XML_NOTIFY_ON_UPDATE_OF_RANGES, sRanges);
GetShapeExport()->exportShape(xShape, SEF_EXPORT_NO_CHART_DATA | SEF_DEFAULT, pPoint);
}*/
}
}
}
}
if (!bIsChart)
GetShapeExport()->exportShape(xShape, SEF_DEFAULT, pPoint);
IncrementProgressBar(sal_False);
}
void ScXMLExport::WriteShapes(const ScMyCell& rMyCell)
{
if( rMyCell.bHasShape && !rMyCell.aShapeList.empty() && pDoc )
{
awt::Point aPoint;
Rectangle aRec = pDoc->GetMMRect(static_cast<SCCOL>(rMyCell.aCellAddress.Column), static_cast<SCROW>(rMyCell.aCellAddress.Row),
static_cast<SCCOL>(rMyCell.aCellAddress.Column), static_cast<SCROW>(rMyCell.aCellAddress.Row), static_cast<SCTAB>(rMyCell.aCellAddress.Sheet));
sal_Bool bNegativePage(pDoc->IsNegativePage(rMyCell.aCellAddress.Sheet));
if (bNegativePage)
aPoint.X = aRec.Right();
else
aPoint.X = aRec.Left();
aPoint.Y = aRec.Top();
ScMyShapeList::const_iterator aItr = rMyCell.aShapeList.begin();
ScMyShapeList::const_iterator aEndItr(rMyCell.aShapeList.end());
while (aItr != aEndItr)
{
if (aItr->xShape.is())
{
if (bNegativePage)
aPoint.X = 2 * aItr->xShape->getPosition().X + aItr->xShape->getSize().Width - aPoint.X;
if ( !aItr->xShape->getShapeType().equals(sCaptionShape) )
{
awt::Point aEndPoint;
Rectangle aEndRec(pDoc->GetMMRect(aItr->aEndAddress.Col(), aItr->aEndAddress.Row(),
aItr->aEndAddress.Col(), aItr->aEndAddress.Row(), aItr->aEndAddress.Tab()));
rtl::OUString sEndAddress;
ScRangeStringConverter::GetStringFromAddress(sEndAddress, aItr->aEndAddress, pDoc, FormulaGrammar::CONV_OOO);
AddAttribute(XML_NAMESPACE_TABLE, XML_END_CELL_ADDRESS, sEndAddress);
if (bNegativePage)
aEndPoint.X = -aEndRec.Right();
else
aEndPoint.X = aEndRec.Left();
aEndPoint.Y = aEndRec.Top();
awt::Point aStartPoint(aItr->xShape->getPosition());
awt::Size aSize(aItr->xShape->getSize());
sal_Int32 nEndX;
if (bNegativePage)
nEndX = -aStartPoint.X - aEndPoint.X;
else
nEndX = aStartPoint.X + aSize.Width - aEndPoint.X;
sal_Int32 nEndY(aStartPoint.Y + aSize.Height - aEndPoint.Y);
rtl::OUStringBuffer sBuffer;
GetMM100UnitConverter().convertMeasure(sBuffer, nEndX);
AddAttribute(XML_NAMESPACE_TABLE, XML_END_X, sBuffer.makeStringAndClear());
GetMM100UnitConverter().convertMeasure(sBuffer, nEndY);
AddAttribute(XML_NAMESPACE_TABLE, XML_END_Y, sBuffer.makeStringAndClear());
}
ExportShape(aItr->xShape, &aPoint);
// if there's an error in ExportShape, the attributes from above must be removed
CheckAttrList(); // asserts in non pro if we have attributes left
ClearAttrList(); // clears the attributes
}
++aItr;
}
}
}
void ScXMLExport::WriteTableShapes()
{
ScMyTableShapes* pTableShapes(pSharedData->GetTableShapes());
if (pTableShapes && !(*pTableShapes)[nCurrentTable].empty())
{
DBG_ASSERT(pTableShapes->size() > static_cast<size_t>(nCurrentTable), "wrong Table");
SvXMLElementExport aShapesElem(*this, XML_NAMESPACE_TABLE, XML_SHAPES, sal_True, sal_False);
ScMyTableXShapes::iterator aItr((*pTableShapes)[nCurrentTable].begin());
ScMyTableXShapes::iterator aEndItr((*pTableShapes)[nCurrentTable].end());
while (aItr != aEndItr)
{
if (aItr->is())
{
if (pDoc->IsNegativePage(static_cast<SCTAB>(nCurrentTable)))
{
awt::Point aPoint((*aItr)->getPosition());
awt::Size aSize((*aItr)->getSize());
aPoint.X += aPoint.X + aSize.Width;
aPoint.Y = 0;
ExportShape(*aItr, &aPoint);
}
else
ExportShape(*aItr, NULL);
}
aItr = (*pTableShapes)[nCurrentTable].erase(aItr);
}
}
}
void ScXMLExport::WriteAreaLink( const ScMyCell& rMyCell )
{
if( rMyCell.bHasAreaLink )
{
const ScMyAreaLink& rAreaLink = rMyCell.aAreaLink;
AddAttribute( XML_NAMESPACE_TABLE, XML_NAME, rAreaLink.sSourceStr );
AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, GetRelativeReference(rAreaLink.sURL) );
AddAttribute( XML_NAMESPACE_TABLE, XML_FILTER_NAME, rAreaLink.sFilter );
if( rAreaLink.sFilterOptions.getLength() )
AddAttribute( XML_NAMESPACE_TABLE, XML_FILTER_OPTIONS, rAreaLink.sFilterOptions );
OUStringBuffer sValue;
SvXMLUnitConverter::convertNumber( sValue, rAreaLink.GetColCount() );
AddAttribute( XML_NAMESPACE_TABLE, XML_LAST_COLUMN_SPANNED, sValue.makeStringAndClear() );
SvXMLUnitConverter::convertNumber( sValue, rAreaLink.GetRowCount() );
AddAttribute( XML_NAMESPACE_TABLE, XML_LAST_ROW_SPANNED, sValue.makeStringAndClear() );
if( rAreaLink.nRefresh )
{
SvXMLUnitConverter::convertTime( sValue, (double)rAreaLink.nRefresh / 86400 );
AddAttribute( XML_NAMESPACE_TABLE, XML_REFRESH_DELAY, sValue.makeStringAndClear() );
}
SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE, XML_CELL_RANGE_SOURCE, sal_True, sal_True );
}
}
void ScXMLExport::exportAnnotationMeta( const uno::Reference < drawing::XShape >& xShape)
{
if (pCurrentCell && pCurrentCell->xNoteShape.is() && pCurrentCell->xNoteShape.get() == xShape.get() && pCurrentCell->xAnnotation.is())
{
rtl::OUString sAuthor(pCurrentCell->xAnnotation->getAuthor());
if (sAuthor.getLength())
{
SvXMLElementExport aCreatorElem( *this, XML_NAMESPACE_DC,
XML_CREATOR, sal_True,
sal_False );
Characters(sAuthor);
}
String aDate(pCurrentCell->xAnnotation->getDate());
if (pDoc)
{
SvNumberFormatter* pNumForm = pDoc->GetFormatTable();
double fDate;
sal_uInt32 nfIndex = pNumForm->GetFormatIndex(NF_DATE_SYS_DDMMYYYY, LANGUAGE_SYSTEM);
if (pNumForm->IsNumberFormat(aDate, nfIndex, fDate))
{
rtl::OUStringBuffer sBuf;
GetMM100UnitConverter().convertDateTime(sBuf, fDate,sal_True);
SvXMLElementExport aDateElem( *this, XML_NAMESPACE_DC,
XML_DATE, sal_True,
sal_False );
Characters(sBuf.makeStringAndClear());
}
else
{
SvXMLElementExport aDateElem( *this, XML_NAMESPACE_META,
XML_DATE_STRING, sal_True,
sal_False );
Characters(rtl::OUString(aDate));
}
}
else
{
SvXMLElementExport aDateElem( *this, XML_NAMESPACE_META,
XML_DATE_STRING, sal_True,
sal_False );
Characters(rtl::OUString(aDate));
}
}
}
void ScXMLExport::WriteAnnotation(ScMyCell& rMyCell)
{
if( rMyCell.bHasAnnotation && rMyCell.xAnnotation.is())
{
/* rtl::OUString sAuthor(rMyCell.xAnnotation->getAuthor());
if (sAuthor.getLength())
{
SvXMLElementExport aCreatorElem( *this, XML_NAMESPACE_DC,
XML_CREATOR, sal_True,
sal_False );
rtl::OUString sAuthor(sAuthor);
Characters(sAuthor);
}
String aDate(rMyCell.xAnnotation->getDate());
if (pDoc)
{
SvNumberFormatter* pNumForm(pDoc->GetFormatTable());
double fDate;
sal_uInt32 nfIndex = pNumForm->GetFormatIndex(NF_DATE_SYS_DDMMYYYY, LANGUAGE_SYSTEM);
if (pNumForm->IsNumberFormat(aDate, nfIndex, fDate))
{
rtl::OUStringBuffer sBuf;
GetMM100UnitConverter().convertDateTime(sBuf, fDate);
SvXMLElementExport aDateElem( *this, XML_NAMESPACE_DC,
XML_DATE, sal_True,
sal_False );
Characters(sBuf.makeStringAndClear());
}
else
{
SvXMLElementExport aDateElem( *this, XML_NAMESPACE_META,
XML_DATE_STRING, sal_True,
sal_False );
Characters(rtl::OUString(aDate));
}
}
else
{
SvXMLElementExport aDateElem( *this, XML_NAMESPACE_META,
XML_DATE_STRING, sal_True,
sal_False );
Characters(rtl::OUString(aDate));
}*/
if (rMyCell.xAnnotation->getIsVisible())
AddAttribute(XML_NAMESPACE_OFFICE, XML_DISPLAY, XML_TRUE);
pCurrentCell = &rMyCell;
if(rMyCell.xNoteShape.is())
GetShapeExport()->exportShape(rMyCell.xNoteShape, SEF_DEFAULT|SEF_EXPORT_ANNOTATION, NULL);
pCurrentCell = NULL;
rMyCell.xNoteShape.clear();
}
}
void ScXMLExport::WriteDetective( const ScMyCell& rMyCell )
{
if( rMyCell.bHasDetectiveObj || rMyCell.bHasDetectiveOp )
{
const ScMyDetectiveObjVec& rObjVec = rMyCell.aDetectiveObjVec;
const ScMyDetectiveOpVec& rOpVec = rMyCell.aDetectiveOpVec;
sal_Int32 nObjCount(rObjVec.size());
sal_Int32 nOpCount(rOpVec.size());
if( nObjCount || nOpCount )
{
SvXMLElementExport aDetElem( *this, XML_NAMESPACE_TABLE, XML_DETECTIVE, sal_True, sal_True );
OUString sString;
ScMyDetectiveObjVec::const_iterator aObjItr(rObjVec.begin());
ScMyDetectiveObjVec::const_iterator aEndObjItr(rObjVec.end());
while(aObjItr != aEndObjItr)
{
if (aObjItr->eObjType != SC_DETOBJ_CIRCLE)
{
if( (aObjItr->eObjType == SC_DETOBJ_ARROW) || (aObjItr->eObjType == SC_DETOBJ_TOOTHERTAB))
{
ScRangeStringConverter::GetStringFromRange( sString, aObjItr->aSourceRange, pDoc, FormulaGrammar::CONV_OOO );
AddAttribute( XML_NAMESPACE_TABLE, XML_CELL_RANGE_ADDRESS, sString );
}
ScXMLConverter::GetStringFromDetObjType( sString, aObjItr->eObjType );
AddAttribute( XML_NAMESPACE_TABLE, XML_DIRECTION, sString );
if( aObjItr->bHasError )
AddAttribute( XML_NAMESPACE_TABLE, XML_CONTAINS_ERROR, XML_TRUE );
}
else
AddAttribute( XML_NAMESPACE_TABLE, XML_MARKED_INVALID, XML_TRUE );
SvXMLElementExport aRangeElem( *this, XML_NAMESPACE_TABLE, XML_HIGHLIGHTED_RANGE, sal_True, sal_True );
++aObjItr;
}
OUStringBuffer aBuffer;
ScMyDetectiveOpVec::const_iterator aOpItr(rOpVec.begin());
ScMyDetectiveOpVec::const_iterator aEndOpItr(rOpVec.end());
while(aOpItr != aEndOpItr)
{
OUString sOpString;
ScXMLConverter::GetStringFromDetOpType( sOpString, aOpItr->eOpType );
AddAttribute( XML_NAMESPACE_TABLE, XML_NAME, sOpString );
SvXMLUnitConverter::convertNumber( aBuffer, aOpItr->nIndex );
AddAttribute( XML_NAMESPACE_TABLE, XML_INDEX, aBuffer.makeStringAndClear() );
SvXMLElementExport aRangeElem( *this, XML_NAMESPACE_TABLE, XML_OPERATION, sal_True, sal_True );
++aOpItr;
}
}
}
}
void ScXMLExport::SetRepeatAttribute(sal_Int32 nEqualCellCount, bool bIncProgress)
{
// nEqualCellCount is additional cells, so the attribute value is nEqualCellCount+1
if (nEqualCellCount > 0)
{
sal_Int32 nTemp(nEqualCellCount + 1);
OUString sOUEqualCellCount(OUString::valueOf(nTemp));
AddAttribute(sAttrColumnsRepeated, sOUEqualCellCount);
if (bIncProgress)
IncrementProgressBar(sal_False, nEqualCellCount);
}
}
sal_Bool ScXMLExport::IsCellTypeEqual (const ScMyCell& aCell1, const ScMyCell& aCell2) const
{
return (aCell1.nType == aCell2.nType);
}
sal_Bool ScXMLExport::IsEditCell(const com::sun::star::table::CellAddress& aAddress, ScMyCell* pMyCell) const
{
ScAddress aCoreAddress(static_cast<SCCOL>(aAddress.Column),
static_cast<SCROW>(aAddress.Row),
static_cast<SCTAB>(aAddress.Sheet));
ScBaseCell* pBaseCell = GetDocument() ? GetDocument()->GetCell(aCoreAddress) : NULL;
if (pMyCell)
pMyCell->pBaseCell = pBaseCell;
if (pBaseCell)
return (pBaseCell->GetCellType() == CELLTYPE_EDIT);
return sal_False;
}
//UNUSED2008-05 sal_Bool ScXMLExport::IsEditCell(const com::sun::star::uno::Reference <com::sun::star::table::XCell>& xCell) const
//UNUSED2008-05 {
//UNUSED2008-05 uno::Reference<sheet::XCellAddressable> xAddressable (xCell, uno::UNO_QUERY);
//UNUSED2008-05 if ( xAddressable.is() )
//UNUSED2008-05 return IsEditCell(xAddressable->getCellAddress());
//UNUSED2008-05 return sal_False;
//UNUSED2008-05 }
sal_Bool ScXMLExport::IsEditCell(ScMyCell& rCell) const
{
if (rCell.bKnowWhetherIsEditCell)
return rCell.bIsEditCell;
else
{
rCell.bIsEditCell = IsEditCell(rCell.aCellAddress, &rCell);
rCell.bKnowWhetherIsEditCell = sal_True;
return rCell.bIsEditCell;
}
}
sal_Bool ScXMLExport::IsMultiLineFormulaCell(ScMyCell& rCell) const
{
if (rCell.pBaseCell)
{
if (rCell.pBaseCell->GetCellType() != CELLTYPE_FORMULA)
return false;
return static_cast<ScFormulaCell*>(rCell.pBaseCell)->IsMultilineResult();
}
ScAddress aAddr(static_cast<SCCOL>(rCell.aCellAddress.Column),
static_cast<SCROW>(rCell.aCellAddress.Row),
static_cast<SCTAB>(rCell.aCellAddress.Sheet));
ScBaseCell* pBaseCell = pDoc ? pDoc->GetCell(aAddr) : NULL;
if (!pBaseCell)
return false;
rCell.pBaseCell = pBaseCell;
if (rCell.pBaseCell->GetCellType() != CELLTYPE_FORMULA)
return false;
return static_cast<ScFormulaCell*>(rCell.pBaseCell)->IsMultilineResult();
}
//UNUSED2008-05 sal_Bool ScXMLExport::IsAnnotationEqual(const uno::Reference<table::XCell>& /* xCell1 */,
//UNUSED2008-05 const uno::Reference<table::XCell>& /* xCell2 */)
//UNUSED2008-05 {
//UNUSED2008-05 // no longer compareable, because the position and size and other attributes can also differ
//UNUSED2008-05
//UNUSED2008-05 /* uno::Reference<sheet::XSheetAnnotationAnchor> xSheetAnnotationAnchor1(xCell1, uno::UNO_QUERY);
//UNUSED2008-05 uno::Reference<sheet::XSheetAnnotationAnchor> xSheetAnnotationAnchor2(xCell2, uno::UNO_QUERY);
//UNUSED2008-05 if (xSheetAnnotationAnchor1.is() && xSheetAnnotationAnchor2.is())
//UNUSED2008-05 {
//UNUSED2008-05 uno::Reference <sheet::XSheetAnnotation> xSheetAnnotation1(xSheetAnnotationAnchor1->getAnnotation());
//UNUSED2008-05 uno::Reference <sheet::XSheetAnnotation> xSheetAnnotation2(xSheetAnnotationAnchor2->getAnnotation());
//UNUSED2008-05 uno::Reference<text::XSimpleText> xSimpleText1(xSheetAnnotation1, uno::UNO_QUERY);
//UNUSED2008-05 uno::Reference<text::XSimpleText> xSimpleText2(xSheetAnnotation2, uno::UNO_QUERY);
//UNUSED2008-05 if (xSheetAnnotation1.is() && xSimpleText1.is() &&
//UNUSED2008-05 xSheetAnnotation2.is() && xSimpleText2.is())
//UNUSED2008-05 {
//UNUSED2008-05 rtl::OUString sText1(xSimpleText1->getString());
//UNUSED2008-05 rtl::OUString sText2(xSimpleText2->getString());
//UNUSED2008-05 sal_Int32 nLength1(sText1.getLength());
//UNUSED2008-05 sal_Int32 nLength2(sText2.getLength());
//UNUSED2008-05 if (nLength1 && nLength2)
//UNUSED2008-05 if (sText1 == sText2 &&
//UNUSED2008-05 xSheetAnnotation1->getAuthor() == xSheetAnnotation2->getAuthor() &&
//UNUSED2008-05 xSheetAnnotation1->getDate() == xSheetAnnotation2->getDate() &&
//UNUSED2008-05 xSheetAnnotation1->getIsVisible() == xSheetAnnotation2->getIsVisible())
//UNUSED2008-05 return sal_True;
//UNUSED2008-05 else
//UNUSED2008-05 return sal_False;
//UNUSED2008-05 else
//UNUSED2008-05 if (nLength1 || nLength2)
//UNUSED2008-05 return sal_False;
//UNUSED2008-05 else
//UNUSED2008-05 return sal_True;
//UNUSED2008-05 }
//UNUSED2008-05 }*/
//UNUSED2008-05 return sal_False;
//UNUSED2008-05 }
sal_Bool ScXMLExport::IsCellEqual (ScMyCell& aCell1, ScMyCell& aCell2)
{
ScAddress aCellPos1;
ScUnoConversion::FillScAddress( aCellPos1, aCell1.aCellAddress );
ScAddress aCellPos2;
ScUnoConversion::FillScAddress( aCellPos2, aCell2.aCellAddress );
sal_Bool bIsEqual = sal_False;
if( !aCell1.bIsMergedBase && !aCell2.bIsMergedBase &&
aCell1.bIsCovered == aCell2.bIsCovered &&
!aCell1.bIsMatrixBase && !aCell2.bIsMatrixBase &&
aCell1.bIsMatrixCovered == aCell2.bIsMatrixCovered &&
aCell1.bHasAnnotation == aCell2.bHasAnnotation &&
!aCell1.bHasShape && !aCell2.bHasShape &&
aCell1.bHasAreaLink == aCell2.bHasAreaLink &&
!aCell1.bHasDetectiveObj && !aCell2.bHasDetectiveObj)
{
if( (aCell1.bHasAreaLink &&
(aCell1.aAreaLink.GetColCount() == 1) &&
(aCell2.aAreaLink.GetColCount() == 1) &&
aCell1.aAreaLink.Compare( aCell2.aAreaLink ) ) ||
!aCell1.bHasAreaLink )
{
if (!aCell1.bHasAnnotation || (aCell1.bHasAnnotation && sal_False/*IsAnnotationEqual(aCell1.xCell, aCell2.xCell)*/)) // no longer compareable
{
if ((((aCell1.nStyleIndex == aCell2.nStyleIndex) && (aCell1.bIsAutoStyle == aCell2.bIsAutoStyle)) ||
((aCell1.nStyleIndex == aCell2.nStyleIndex) && (aCell1.nStyleIndex == -1))) &&
(aCell1.nValidationIndex == aCell2.nValidationIndex) &&
IsCellTypeEqual(aCell1, aCell2))
{
switch ( aCell1.nType )
{
case table::CellContentType_EMPTY :
{
bIsEqual = sal_True;
}
break;
case table::CellContentType_VALUE :
{
if(!aCell1.bHasDoubleValue)
{
aCell1.fValue = pDoc->GetValue( aCellPos1 );
aCell1.bHasDoubleValue = sal_True;
}
if (!aCell2.bHasDoubleValue)
{
aCell2.fValue = pDoc->GetValue( aCellPos2 );
aCell2.bHasDoubleValue = sal_True;
}
// #i29101# number format may be different from column default styles,
// but can lead to different value types, so it must also be compared
bIsEqual = (aCell1.nNumberFormat == aCell2.nNumberFormat) &&
(aCell1.fValue == aCell2.fValue);
}
break;
case table::CellContentType_TEXT :
{
if (IsEditCell(aCell1) || IsEditCell(aCell2))
bIsEqual = sal_False;
else
{
if (GetCellText(aCell1, aCellPos1) && GetCellText(aCell2, aCellPos2))
{
bIsEqual = (aCell1.sStringValue == aCell2.sStringValue) &&
(lcl_GetRawString(pDoc, aCellPos1) == lcl_GetRawString(pDoc, aCellPos2));
}
else
bIsEqual = sal_False;
}
}
break;
case table::CellContentType_FORMULA :
{
bIsEqual = sal_False;
}
break;
default :
{
bIsEqual = sal_False;
}
break;
}
}
}
}
}
return bIsEqual;
}
void ScXMLExport::WriteCalculationSettings(const uno::Reference <sheet::XSpreadsheetDocument>& xSpreadDoc)
{
uno::Reference<beans::XPropertySet> xPropertySet(xSpreadDoc, uno::UNO_QUERY);
if (xPropertySet.is())
{
sal_Bool bCalcAsShown (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_CALCASSHOWN))) ));
sal_Bool bIgnoreCase (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_IGNORECASE))) ));
sal_Bool bLookUpLabels (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_LOOKUPLABELS))) ));
sal_Bool bMatchWholeCell (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_MATCHWHOLE))) ));
sal_Bool bUseRegularExpressions (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_REGEXENABLED))) ));
sal_Bool bIsIterationEnabled (::cppu::any2bool( xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_ITERENABLED))) ));
sal_uInt16 nYear2000 (pDoc ? pDoc->GetDocOptions().GetYear2000() : 0);
sal_Int32 nIterationCount(100);
xPropertySet->getPropertyValue( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_ITERCOUNT))) >>= nIterationCount;
double fIterationEpsilon = 0;
xPropertySet->getPropertyValue( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_ITEREPSILON))) >>= fIterationEpsilon;
util::Date aNullDate;
xPropertySet->getPropertyValue( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_NULLDATE))) >>= aNullDate;
if (bCalcAsShown || bIgnoreCase || !bLookUpLabels || !bMatchWholeCell || !bUseRegularExpressions ||
bIsIterationEnabled || nIterationCount != 100 || !::rtl::math::approxEqual(fIterationEpsilon, 0.001) ||
aNullDate.Day != 30 || aNullDate.Month != 12 || aNullDate.Year != 1899 || nYear2000 != 1930)
{
if (bIgnoreCase)
AddAttribute(XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_FALSE);
if (bCalcAsShown)
AddAttribute(XML_NAMESPACE_TABLE, XML_PRECISION_AS_SHOWN, XML_TRUE);
if (!bMatchWholeCell)
AddAttribute(XML_NAMESPACE_TABLE, XML_SEARCH_CRITERIA_MUST_APPLY_TO_WHOLE_CELL, XML_FALSE);
if (!bLookUpLabels)
AddAttribute(XML_NAMESPACE_TABLE, XML_AUTOMATIC_FIND_LABELS, XML_FALSE);
if (!bUseRegularExpressions)
AddAttribute(XML_NAMESPACE_TABLE, XML_USE_REGULAR_EXPRESSIONS, XML_FALSE);
if (nYear2000 != 1930)
{
rtl::OUStringBuffer sBuffer;
GetMM100UnitConverter().convertNumber(sBuffer, nYear2000);
AddAttribute(XML_NAMESPACE_TABLE, XML_NULL_YEAR, sBuffer.makeStringAndClear());
}
SvXMLElementExport aCalcSettings(*this, XML_NAMESPACE_TABLE, XML_CALCULATION_SETTINGS, sal_True, sal_True);
{
if (aNullDate.Day != 30 || aNullDate.Month != 12 || aNullDate.Year != 1899)
{
rtl::OUStringBuffer sDate;
GetMM100UnitConverter().convertDateTime(sDate, 0.0, aNullDate);
AddAttribute(XML_NAMESPACE_TABLE, XML_DATE_VALUE, sDate.makeStringAndClear());
SvXMLElementExport aElemNullDate(*this, XML_NAMESPACE_TABLE, XML_NULL_DATE, sal_True, sal_True);
}
if (bIsIterationEnabled || nIterationCount != 100 || !::rtl::math::approxEqual(fIterationEpsilon, 0.001))
{
rtl::OUStringBuffer sBuffer;
if (bIsIterationEnabled)
AddAttribute(XML_NAMESPACE_TABLE, XML_STATUS, XML_ENABLE);
if (nIterationCount != 100)
{
GetMM100UnitConverter().convertNumber(sBuffer, nIterationCount);
AddAttribute(XML_NAMESPACE_TABLE, XML_STEPS, sBuffer.makeStringAndClear());
}
if (!::rtl::math::approxEqual(fIterationEpsilon, 0.001))
{
GetMM100UnitConverter().convertDouble(sBuffer, fIterationEpsilon);
AddAttribute(XML_NAMESPACE_TABLE, XML_MAXIMUM_DIFFERENCE, sBuffer.makeStringAndClear());
}
SvXMLElementExport aElemIteration(*this, XML_NAMESPACE_TABLE, XML_ITERATION, sal_True, sal_True);
}
}
}
}
}
void ScXMLExport::WriteTableSource()
{
uno::Reference <sheet::XSheetLinkable> xLinkable (xCurrentTable, uno::UNO_QUERY);
if (xLinkable.is() && GetModel().is())
{
sheet::SheetLinkMode nMode (xLinkable->getLinkMode());
if (nMode != sheet::SheetLinkMode_NONE)
{
rtl::OUString sLink (xLinkable->getLinkUrl());
uno::Reference <beans::XPropertySet> xProps (GetModel(), uno::UNO_QUERY);
if (xProps.is())
{
uno::Reference <container::XIndexAccess> xIndex(xProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_SHEETLINKS))), uno::UNO_QUERY);
if (xIndex.is())
{
sal_Int32 nCount(xIndex->getCount());
if (nCount)
{
sal_Bool bFound(sal_False);
uno::Reference <beans::XPropertySet> xLinkProps;
for (sal_Int32 i = 0; (i < nCount) && !bFound; ++i)
{
xLinkProps.set(xIndex->getByIndex(i), uno::UNO_QUERY);
if (xLinkProps.is())
{
rtl::OUString sNewLink;
if (xLinkProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_LINKURL))) >>= sNewLink)
bFound = sLink.equals(sNewLink);
}
}
if (bFound && xLinkProps.is())
{
rtl::OUString sFilter;
rtl::OUString sFilterOptions;
rtl::OUString sTableName (xLinkable->getLinkSheetName());
sal_Int32 nRefresh(0);
xLinkProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_FILTER))) >>= sFilter;
xLinkProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_FILTOPT))) >>= sFilterOptions;
xLinkProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_REFDELAY))) >>= nRefresh;
if (sLink.getLength())
{
AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE);
AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, GetRelativeReference(sLink));
if (sTableName.getLength())
AddAttribute(XML_NAMESPACE_TABLE, XML_TABLE_NAME, sTableName);
if (sFilter.getLength())
AddAttribute(XML_NAMESPACE_TABLE, XML_FILTER_NAME, sFilter);
if (sFilterOptions.getLength())
AddAttribute(XML_NAMESPACE_TABLE, XML_FILTER_OPTIONS, sFilterOptions);
if (nMode != sheet::SheetLinkMode_NORMAL)
AddAttribute(XML_NAMESPACE_TABLE, XML_MODE, XML_COPY_RESULTS_ONLY);
if( nRefresh )
{
rtl::OUStringBuffer sBuffer;
SvXMLUnitConverter::convertTime( sBuffer, (double)nRefresh / 86400 );
AddAttribute( XML_NAMESPACE_TABLE, XML_REFRESH_DELAY, sBuffer.makeStringAndClear() );
}
SvXMLElementExport aSourceElem(*this, XML_NAMESPACE_TABLE, XML_TABLE_SOURCE, sal_True, sal_True);
}
}
}
}
}
}
}
}
// core implementation
void ScXMLExport::WriteScenario()
{
if (pDoc && pDoc->IsScenario(static_cast<SCTAB>(nCurrentTable)))
{
String sComment;
Color aColor;
sal_uInt16 nFlags;
pDoc->GetScenarioData(static_cast<SCTAB>(nCurrentTable), sComment, aColor, nFlags);
if (!(nFlags & SC_SCENARIO_SHOWFRAME))
AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY_BORDER, XML_FALSE);
rtl::OUStringBuffer aBuffer;
SvXMLUnitConverter::convertColor(aBuffer, aColor);
AddAttribute(XML_NAMESPACE_TABLE, XML_BORDER_COLOR, aBuffer.makeStringAndClear());
if (!(nFlags & SC_SCENARIO_TWOWAY))
AddAttribute(XML_NAMESPACE_TABLE, XML_COPY_BACK, XML_FALSE);
if (!(nFlags & SC_SCENARIO_ATTRIB))
AddAttribute(XML_NAMESPACE_TABLE, XML_COPY_STYLES, XML_FALSE);
if (nFlags & SC_SCENARIO_VALUE)
AddAttribute(XML_NAMESPACE_TABLE, XML_COPY_FORMULAS, XML_FALSE);
if (nFlags & SC_SCENARIO_PROTECT)
AddAttribute(XML_NAMESPACE_TABLE, XML_PROTECTED, XML_TRUE);
SvXMLUnitConverter::convertBool(aBuffer, pDoc->IsActiveScenario(static_cast<SCTAB>(nCurrentTable)));
AddAttribute(XML_NAMESPACE_TABLE, XML_IS_ACTIVE, aBuffer.makeStringAndClear());
const ScRangeList* pRangeList = pDoc->GetScenarioRanges(static_cast<SCTAB>(nCurrentTable));
rtl::OUString sRangeListStr;
ScRangeStringConverter::GetStringFromRangeList( sRangeListStr, pRangeList, pDoc, FormulaGrammar::CONV_OOO );
AddAttribute(XML_NAMESPACE_TABLE, XML_SCENARIO_RANGES, sRangeListStr);
if (sComment.Len())
AddAttribute(XML_NAMESPACE_TABLE, XML_COMMENT, rtl::OUString(sComment));
SvXMLElementExport aElem(*this, XML_NAMESPACE_TABLE, XML_SCENARIO, sal_True, sal_True);
}
}
void ScXMLExport::WriteTheLabelRanges( const uno::Reference< sheet::XSpreadsheetDocument >& xSpreadDoc )
{
uno::Reference< beans::XPropertySet > xDocProp( xSpreadDoc, uno::UNO_QUERY );
if( !xDocProp.is() ) return;
sal_Int32 nCount(0);
uno::Reference< container::XIndexAccess > xColRangesIAccess(xDocProp->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNO_COLLABELRNG ) ) ), uno::UNO_QUERY);
if( xColRangesIAccess.is() )
nCount += xColRangesIAccess->getCount();
uno::Reference< container::XIndexAccess > xRowRangesIAccess(xDocProp->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNO_ROWLABELRNG ) ) ), uno::UNO_QUERY);
if( xRowRangesIAccess.is() )
nCount += xRowRangesIAccess->getCount();
if( nCount )
{
SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE, XML_LABEL_RANGES, sal_True, sal_True );
WriteLabelRanges( xColRangesIAccess, sal_True );
WriteLabelRanges( xRowRangesIAccess, sal_False );
}
}
void ScXMLExport::WriteLabelRanges( const uno::Reference< container::XIndexAccess >& xRangesIAccess, sal_Bool bColumn )
{
if( !xRangesIAccess.is() ) return;
sal_Int32 nCount(xRangesIAccess->getCount());
for( sal_Int32 nIndex = 0; nIndex < nCount; ++nIndex )
{
uno::Reference< sheet::XLabelRange > xRange(xRangesIAccess->getByIndex( nIndex ), uno::UNO_QUERY);
if( xRange.is() )
{
OUString sRangeStr;
table::CellRangeAddress aCellRange( xRange->getLabelArea() );
ScRangeStringConverter::GetStringFromRange( sRangeStr, aCellRange, pDoc, FormulaGrammar::CONV_OOO );
AddAttribute( XML_NAMESPACE_TABLE, XML_LABEL_CELL_RANGE_ADDRESS, sRangeStr );
aCellRange = xRange->getDataArea();
ScRangeStringConverter::GetStringFromRange( sRangeStr, aCellRange, pDoc, FormulaGrammar::CONV_OOO );
AddAttribute( XML_NAMESPACE_TABLE, XML_DATA_CELL_RANGE_ADDRESS, sRangeStr );
AddAttribute( XML_NAMESPACE_TABLE, XML_ORIENTATION, bColumn ? XML_COLUMN : XML_ROW );
SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE, XML_LABEL_RANGE, sal_True, sal_True );
}
}
}
void ScXMLExport::WriteNamedExpressions(const com::sun::star::uno::Reference <com::sun::star::sheet::XSpreadsheetDocument>& xSpreadDoc, sal_Int16 nWhichTable)
{
uno::Reference <beans::XPropertySet> xPropertySet (xSpreadDoc, uno::UNO_QUERY);
if (xPropertySet.is())
{
uno::Reference <sheet::XNamedRanges2> xNamedRanges(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_NAMEDRANGES))), uno::UNO_QUERY);
CheckAttrList();
if (xNamedRanges.is())
{
uno::Sequence <sheet::RangeScopeName> aRangesNames(xNamedRanges->getElementScopeNames());//modified 20091211, range scope name support
sal_Int32 nNamedRangesCount(aRangesNames.getLength());
if (nNamedRangesCount > 0)
{
if (pDoc)
{
ScRangeName* pNamedRanges(pDoc->GetRangeName());
SvXMLElementExport aElemNEs(*this, XML_NAMESPACE_TABLE, XML_NAMED_EXPRESSIONS, sal_True, sal_True);
for (sal_Int32 i = 0; i < nNamedRangesCount; ++i)
{
CheckAttrList();
//range scope name support -start
rtl::OUString sNamedRange(aRangesNames[i].RangeName);
rtl::OUString sRangeScope(aRangesNames[i].ScopeName);
SCTAB nScopeNumber = MAXTABCOUNT;
String sScopeStr(sRangeScope);
if(sScopeStr !=EMPTY_STRING)
{
pDoc->GetTable(sScopeStr,nScopeNumber);
if( nWhichTable != nScopeNumber || nScopeNumber ==MAXTABCOUNT)
continue;
}
else if( nWhichTable !=MAXTABCOUNT)
continue;
uno::Reference <sheet::XNamedRange2> xNamedRange(xNamedRanges->getByScopeName(sRangeScope,sNamedRange), uno::UNO_QUERY);
//range scope name support
if (xNamedRange.is())
{
uno::Reference <container::XNamed> xNamed (xNamedRange, uno::UNO_QUERY);
uno::Reference <sheet::XCellRangeReferrer> xCellRangeReferrer (xNamedRange, uno::UNO_QUERY);
if (xNamed.is() && xCellRangeReferrer.is())
{
rtl::OUString sOUName(xNamed->getName());
AddAttribute(sAttrName, sOUName);
OUString sOUBaseCellAddress;
ScRangeStringConverter::GetStringFromAddress( sOUBaseCellAddress,
xNamedRange->getReferencePosition(), pDoc, FormulaGrammar::CONV_OOO, ' ', sal_False, SCA_ABS_3D );
AddAttribute(XML_NAMESPACE_TABLE, XML_BASE_CELL_ADDRESS, sOUBaseCellAddress);
sal_uInt16 nRangeIndex;
String sName(sOUName);
//range scope name support -start
SCTAB nScopeName = MAXTABCOUNT;
String sScopeName(sRangeScope);
if(sScopeName !=EMPTY_STRING)
{
pDoc->GetTable(sScopeName,nScopeName);
}
pNamedRanges->SearchName(sName, nRangeIndex,nScopeName);
//range scope name support - end
ScRangeData* pNamedRange((*pNamedRanges)[nRangeIndex]); //should get directly and not with ScDocument
String sContent;
pNamedRange->GetSymbol(sContent, pDoc->GetStorageGrammar());
rtl::OUString sOUTempContent(sContent);
uno::Reference <table::XCellRange> xCellRange(xCellRangeReferrer->getReferredCells());
if(xCellRange.is())
{
rtl::OUString sOUContent(sOUTempContent.copy(1, sOUTempContent.getLength() - 2));
AddAttribute(XML_NAMESPACE_TABLE, XML_CELL_RANGE_ADDRESS, sOUContent);
sal_Int32 nRangeType(xNamedRange->getType());
rtl::OUStringBuffer sBufferRangeType;
if ((nRangeType & sheet::NamedRangeFlag::COLUMN_HEADER) == sheet::NamedRangeFlag::COLUMN_HEADER)
sBufferRangeType.append(GetXMLToken(XML_REPEAT_COLUMN));
if ((nRangeType & sheet::NamedRangeFlag::ROW_HEADER) == sheet::NamedRangeFlag::ROW_HEADER)
{
if (sBufferRangeType.getLength() > 0)
sBufferRangeType.appendAscii(" ");
sBufferRangeType.append(GetXMLToken(XML_REPEAT_ROW));
}
if ((nRangeType & sheet::NamedRangeFlag::FILTER_CRITERIA) == sheet::NamedRangeFlag::FILTER_CRITERIA)
{
if (sBufferRangeType.getLength() > 0)
sBufferRangeType.appendAscii(" ");
sBufferRangeType.append(GetXMLToken(XML_FILTER));
}
if ((nRangeType & sheet::NamedRangeFlag::PRINT_AREA) == sheet::NamedRangeFlag::PRINT_AREA)
{
if (sBufferRangeType.getLength() > 0)
sBufferRangeType.appendAscii(" ");
sBufferRangeType.append(GetXMLToken(XML_PRINT_RANGE));
}
rtl::OUString sRangeType = sBufferRangeType.makeStringAndClear();
if (sRangeType.getLength())
AddAttribute(XML_NAMESPACE_TABLE, XML_RANGE_USABLE_AS, sRangeType);
SvXMLElementExport aElemNR(*this, XML_NAMESPACE_TABLE, XML_NAMED_RANGE, sal_True, sal_True);
}
else
{
AddAttribute(XML_NAMESPACE_TABLE, XML_EXPRESSION, sOUTempContent);
SvXMLElementExport aElemNE(*this, XML_NAMESPACE_TABLE, XML_NAMED_EXPRESSION, sal_True, sal_True);
}
}
}
}
}
}
}
}
}
void ScXMLExport::WriteExternalRefCaches()
{
if (!pDoc)
return;
ScExternalRefManager* pRefMgr = pDoc->GetExternalRefManager();
pRefMgr->resetSrcFileData(GetOrigFileName());
sal_uInt16 nCount = pRefMgr->getExternalFileCount();
for (sal_uInt16 nFileId = 0; nFileId < nCount; ++nFileId)
{
const String* pUrl = pRefMgr->getExternalFileName(nFileId);
if (!pUrl)
continue;
vector<String> aTabNames;
pRefMgr->getAllCachedTableNames(nFileId, aTabNames);
if (aTabNames.empty())
continue;
for (vector<String>::const_iterator itr = aTabNames.begin(), itrEnd = aTabNames.end();
itr != itrEnd; ++itr)
{
ScExternalRefCache::TableTypeRef pTable = pRefMgr->getCacheTable(nFileId, *itr, false);
if (!pTable.get() || !pTable->isReferenced())
continue;
OUStringBuffer aBuf;
aBuf.append(sal_Unicode('\''));
aBuf.append(*pUrl);
aBuf.append(sal_Unicode('\''));
aBuf.append(sal_Unicode('#'));
aBuf.append(*itr);
AddAttribute(XML_NAMESPACE_TABLE, XML_NAME, aBuf.makeStringAndClear());
AddAttribute(XML_NAMESPACE_TABLE, XML_PRINT, GetXMLToken(XML_FALSE));
AddAttribute(XML_NAMESPACE_TABLE, XML_STYLE_NAME, sExternalRefTabStyleName);
SvXMLElementExport aElemTable(*this, XML_NAMESPACE_TABLE, XML_TABLE, sal_True, sal_True);
{
const ScExternalRefManager::SrcFileData* pExtFileData = pRefMgr->getExternalFileData(nFileId);
if (pExtFileData)
{
String aRelUrl;
if (pExtFileData->maRelativeName.Len())
aRelUrl = pExtFileData->maRelativeName;
else
aRelUrl = GetRelativeReference(pExtFileData->maRelativeName);
AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE);
AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, aRelUrl);
AddAttribute(XML_NAMESPACE_TABLE, XML_TABLE_NAME, *itr);
if (pExtFileData->maFilterName.Len())
AddAttribute(XML_NAMESPACE_TABLE, XML_FILTER_NAME, pExtFileData->maFilterName);
if (pExtFileData->maFilterOptions.Len())
AddAttribute(XML_NAMESPACE_TABLE, XML_FILTER_OPTIONS, pExtFileData->maFilterOptions);
AddAttribute(XML_NAMESPACE_TABLE, XML_MODE, XML_COPY_RESULTS_ONLY);
}
SvXMLElementExport aElemTableSource(*this, XML_NAMESPACE_TABLE, XML_TABLE_SOURCE, sal_True, sal_True);
}
// Determine maximum column count of used area, for repeated cells.
SCCOL nMaxColsUsed = 1; // assume that there is at least one cell somewhere..
vector<SCROW> aRows;
pTable->getAllRows(aRows);
for (vector<SCROW>::const_iterator itrRow = aRows.begin(), itrRowEnd = aRows.end();
itrRow != itrRowEnd; ++itrRow)
{
SCROW nRow = *itrRow;
vector<SCCOL> aCols;
pTable->getAllCols(nRow, aCols);
if (!aCols.empty())
{
SCCOL nCol = aCols.back();
if (nMaxColsUsed <= nCol)
nMaxColsUsed = nCol + 1;
}
}
// Column definitions have to be present to make a valid file
{
if (nMaxColsUsed > 1)
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED,
OUString::valueOf(static_cast<sal_Int32>(nMaxColsUsed)));
SvXMLElementExport aElemColumn(*this, XML_NAMESPACE_TABLE, XML_TABLE_COLUMN, sal_True, sal_True);
}
// Write cache content for this table.
SCROW nLastRow = 0;
bool bFirstRow = true;
for (vector<SCROW>::const_iterator itrRow = aRows.begin(), itrRowEnd = aRows.end();
itrRow != itrRowEnd; ++itrRow)
{
SCROW nRow = *itrRow;
if (bFirstRow)
{
if (nRow > 0)
{
if (nRow > 1)
{
OUStringBuffer aVal;
aVal.append(nRow);
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_REPEATED, aVal.makeStringAndClear());
}
SvXMLElementExport aElemRow(*this, XML_NAMESPACE_TABLE, XML_TABLE_ROW, sal_True, sal_True);
OUStringBuffer aVal;
aVal.append(static_cast<sal_Int32>(nMaxColsUsed));
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, aVal.makeStringAndClear());
SvXMLElementExport aElemCell(*this, XML_NAMESPACE_TABLE, XML_TABLE_CELL, sal_True, sal_True);
}
}
else
{
SCROW nRowGap = nRow - nLastRow;
if (nRowGap > 1)
{
if (nRowGap > 2)
{
OUStringBuffer aVal;
aVal.append(static_cast<sal_Int32>(nRowGap-1));
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_REPEATED, aVal.makeStringAndClear());
}
SvXMLElementExport aElemRow(*this, XML_NAMESPACE_TABLE, XML_TABLE_ROW, sal_True, sal_True);
OUStringBuffer aVal;
aVal.append(static_cast<sal_Int32>(nMaxColsUsed));
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, aVal.makeStringAndClear());
SvXMLElementExport aElemCell(*this, XML_NAMESPACE_TABLE, XML_TABLE_CELL, sal_True, sal_True);
}
}
SvXMLElementExport aElemRow(*this, XML_NAMESPACE_TABLE, XML_TABLE_ROW, sal_True, sal_True);
vector<SCCOL> aCols;
pTable->getAllCols(nRow, aCols);
SCCOL nLastCol = 0;
bool bFirstCol = true;
for (vector<SCCOL>::const_iterator itrCol = aCols.begin(), itrColEnd = aCols.end();
itrCol != itrColEnd; ++itrCol)
{
SCCOL nCol = *itrCol;
if (bFirstCol)
{
if (nCol > 0)
{
if (nCol > 1)
{
OUStringBuffer aVal;
aVal.append(static_cast<sal_Int32>(nCol));
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, aVal.makeStringAndClear());
}
SvXMLElementExport aElemCell(*this, XML_NAMESPACE_TABLE, XML_TABLE_CELL, sal_True, sal_True);
}
}
else
{
SCCOL nColGap = nCol - nLastCol;
if (nColGap > 1)
{
if (nColGap > 2)
{
OUStringBuffer aVal;
aVal.append(static_cast<sal_Int32>(nColGap-1));
AddAttribute(XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED, aVal.makeStringAndClear());
}
SvXMLElementExport aElemCell(*this, XML_NAMESPACE_TABLE, XML_TABLE_CELL, sal_True, sal_True);
}
}
// Write out this cell.
sal_uInt32 nNumFmt = 0;
ScExternalRefCache::TokenRef pToken = pTable->getCell(nCol, nRow, &nNumFmt);
OUString aStrVal;
if (pToken.get())
{
sal_Int32 nIndex = GetNumberFormatStyleIndex(nNumFmt);
if (nIndex >= 0)
{
const OUString aStyleName = *pCellStyles->GetStyleNameByIndex(nIndex, true);
AddAttribute(XML_NAMESPACE_TABLE, XML_STYLE_NAME, aStyleName);
}
switch(pToken->GetType())
{
case svDouble:
{
AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
OUStringBuffer aVal;
aVal.append(pToken->GetDouble());
aStrVal = aVal.makeStringAndClear();
AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, aStrVal);
}
break;
case svString:
{
AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_STRING);
aStrVal = pToken->GetString();
}
break;
default:
;
}
}
SvXMLElementExport aElemCell(*this, XML_NAMESPACE_TABLE, XML_TABLE_CELL, sal_True, sal_True);
SvXMLElementExport aElemText(*this, XML_NAMESPACE_TEXT, XML_P, sal_True, sal_False);
Characters(aStrVal);
nLastCol = nCol;
bFirstCol = false;
}
nLastRow = nRow;
bFirstRow = false;
}
}
}
}
// core implementation
void ScXMLExport::WriteConsolidation()
{
if (pDoc)
{
const ScConsolidateParam* pCons(pDoc->GetConsolidateDlgData());
if( pCons )
{
OUString sStrData;
ScXMLConverter::GetStringFromFunction( sStrData, pCons->eFunction );
AddAttribute( XML_NAMESPACE_TABLE, XML_FUNCTION, sStrData );
sStrData = OUString();
for( sal_Int32 nIndex = 0; nIndex < pCons->nDataAreaCount; ++nIndex )
ScRangeStringConverter::GetStringFromArea( sStrData, *pCons->ppDataAreas[ nIndex ], pDoc, FormulaGrammar::CONV_OOO, sal_True );
AddAttribute( XML_NAMESPACE_TABLE, XML_SOURCE_CELL_RANGE_ADDRESSES, sStrData );
ScRangeStringConverter::GetStringFromAddress( sStrData, ScAddress( pCons->nCol, pCons->nRow, pCons->nTab ), pDoc, FormulaGrammar::CONV_OOO );
AddAttribute( XML_NAMESPACE_TABLE, XML_TARGET_CELL_ADDRESS, sStrData );
if( pCons->bByCol && !pCons->bByRow )
AddAttribute( XML_NAMESPACE_TABLE, XML_USE_LABEL, XML_COLUMN );
else if( !pCons->bByCol && pCons->bByRow )
AddAttribute( XML_NAMESPACE_TABLE, XML_USE_LABEL, XML_ROW );
else if( pCons->bByCol && pCons->bByRow )
AddAttribute( XML_NAMESPACE_TABLE, XML_USE_LABEL, XML_BOTH );
if( pCons->bReferenceData )
AddAttribute( XML_NAMESPACE_TABLE, XML_LINK_TO_SOURCE_DATA, XML_TRUE );
SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE, XML_CONSOLIDATION, sal_True, sal_True );
}
}
}
SvXMLAutoStylePoolP* ScXMLExport::CreateAutoStylePool()
{
return new ScXMLAutoStylePoolP(*this);
}
XMLPageExport* ScXMLExport::CreatePageExport()
{
return new XMLTableMasterPageExport( *this );
}
void ScXMLExport::GetChangeTrackViewSettings(uno::Sequence<beans::PropertyValue>& rProps)
{
ScChangeViewSettings* pViewSettings(GetDocument() ? GetDocument()->GetChangeViewSettings() : NULL);
if (pViewSettings)
{
sal_Int32 nChangePos(rProps.getLength());
rProps.realloc(nChangePos + 1);
beans::PropertyValue* pProps(rProps.getArray());
if (pProps)
{
uno::Sequence<beans::PropertyValue> aChangeProps(SC_VIEWCHANGES_COUNT);
beans::PropertyValue* pChangeProps(aChangeProps.getArray());
if (pChangeProps)
{
pChangeProps[SC_SHOW_CHANGES].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChanges"));
pChangeProps[SC_SHOW_CHANGES].Value <<= pViewSettings->ShowChanges();
pChangeProps[SC_SHOW_ACCEPTED_CHANGES].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowAcceptedChanges"));
pChangeProps[SC_SHOW_ACCEPTED_CHANGES].Value <<= pViewSettings->IsShowAccepted();
pChangeProps[SC_SHOW_REJECTED_CHANGES].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowRejectedChanges"));
pChangeProps[SC_SHOW_REJECTED_CHANGES].Value <<= pViewSettings->IsShowRejected();
pChangeProps[SC_SHOW_CHANGES_BY_DATETIME].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByDatetime"));
pChangeProps[SC_SHOW_CHANGES_BY_DATETIME].Value <<= pViewSettings->HasDate();
pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_MODE].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByDatetimeMode"));
pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_MODE].Value <<= static_cast<sal_Int16>(pViewSettings->GetTheDateMode());
util::DateTime aDateTime;
ScXMLConverter::ConvertCoreToAPIDateTime(pViewSettings->GetTheFirstDateTime(), aDateTime);
pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_FIRST_DATETIME].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByDatetimeFirstDatetime"));
pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_FIRST_DATETIME].Value <<= aDateTime;
ScXMLConverter::ConvertCoreToAPIDateTime(pViewSettings->GetTheLastDateTime(), aDateTime);
pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_SECOND_DATETIME].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByDatetimeSecondDatetime"));
pChangeProps[SC_SHOW_CHANGES_BY_DATETIME_SECOND_DATETIME].Value <<= aDateTime;
pChangeProps[SC_SHOW_CHANGES_BY_AUTHOR].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByAuthor"));
pChangeProps[SC_SHOW_CHANGES_BY_AUTHOR].Value <<= pViewSettings->HasAuthor();
pChangeProps[SC_SHOW_CHANGES_BY_AUTHOR_NAME].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByAuthorName"));
pChangeProps[SC_SHOW_CHANGES_BY_AUTHOR_NAME].Value <<= rtl::OUString (pViewSettings->GetTheAuthorToShow());
pChangeProps[SC_SHOW_CHANGES_BY_COMMENT].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByComment"));
pChangeProps[SC_SHOW_CHANGES_BY_COMMENT].Value <<= pViewSettings->HasComment();
pChangeProps[SC_SHOW_CHANGES_BY_COMMENT_TEXT].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByCommentText"));
pChangeProps[SC_SHOW_CHANGES_BY_COMMENT_TEXT].Value <<= rtl::OUString (pViewSettings->GetTheComment());
pChangeProps[SC_SHOW_CHANGES_BY_RANGES].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByRanges"));
pChangeProps[SC_SHOW_CHANGES_BY_RANGES].Value <<= pViewSettings->HasRange();
rtl::OUString sRangeList;
ScRangeStringConverter::GetStringFromRangeList(sRangeList, &(pViewSettings->GetTheRangeList()), GetDocument(), FormulaGrammar::CONV_OOO);
pChangeProps[SC_SHOW_CHANGES_BY_RANGES_LIST].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowChangesByRangesList"));
pChangeProps[SC_SHOW_CHANGES_BY_RANGES_LIST].Value <<= sRangeList;
pProps[nChangePos].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TrackedChangesViewSettings"));
pProps[nChangePos].Value <<= aChangeProps;
}
}
}
}
void ScXMLExport::GetViewSettings(uno::Sequence<beans::PropertyValue>& rProps)
{
rProps.realloc(4);
beans::PropertyValue* pProps(rProps.getArray());
if(pProps)
{
if (GetModel().is())
{
ScModelObj* pDocObj(ScModelObj::getImplementation( GetModel() ));
if (pDocObj)
{
SfxObjectShell* pEmbeddedObj = pDocObj->GetEmbeddedObject();
if (pEmbeddedObj)
{
Rectangle aRect(pEmbeddedObj->GetVisArea());
sal_uInt16 i(0);
pProps[i].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VisibleAreaTop"));
pProps[i].Value <<= static_cast<sal_Int32>(aRect.getY());
pProps[++i].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VisibleAreaLeft"));
pProps[i].Value <<= static_cast<sal_Int32>(aRect.getX());
pProps[++i].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VisibleAreaWidth"));
pProps[i].Value <<= static_cast<sal_Int32>(aRect.getWidth());
pProps[++i].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VisibleAreaHeight"));
pProps[i].Value <<= static_cast<sal_Int32>(aRect.getHeight());
}
}
}
}
GetChangeTrackViewSettings(rProps);
}
void ScXMLExport::GetConfigurationSettings(uno::Sequence<beans::PropertyValue>& rProps)
{
if (GetModel().is())
{
uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
if (xMultiServiceFactory.is())
{
uno::Reference <beans::XPropertySet> xProperties(xMultiServiceFactory->createInstance(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.SpreadsheetSettings"))), uno::UNO_QUERY);
if (xProperties.is())
SvXMLUnitConverter::convertPropertySet(rProps, xProperties);
sal_Int32 nPropsToAdd = 0;
rtl::OUStringBuffer aTrackedChangesKey;
if (GetDocument() && GetDocument()->GetChangeTrack() && GetDocument()->GetChangeTrack()->IsProtected())
{
SvXMLUnitConverter::encodeBase64(aTrackedChangesKey, GetDocument()->GetChangeTrack()->GetProtection());
if (aTrackedChangesKey.getLength())
++nPropsToAdd;
}
bool bVBACompat = false;
uno::Reference <container::XNameAccess> xCodeNameAccess;
DBG_ASSERT( pDoc, "ScXMLExport::GetConfigurationSettings - no ScDocument!" );
if( pDoc && pDoc->IsInVBAMode() )
{
// VBA compatibility mode
bVBACompat = true;
++nPropsToAdd;
// code names
xCodeNameAccess = new XMLCodeNameProvider( pDoc );
if( xCodeNameAccess->hasElements() )
++nPropsToAdd;
else
xCodeNameAccess.clear();
}
if( nPropsToAdd > 0 )
{
sal_Int32 nCount(rProps.getLength());
rProps.realloc(nCount + nPropsToAdd);
if (aTrackedChangesKey.getLength())
{
rProps[nCount].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TrackedChangesProtectionKey"));
rProps[nCount].Value <<= aTrackedChangesKey.makeStringAndClear();
++nCount;
}
if( bVBACompat )
{
rProps[nCount].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VBACompatibilityMode"));
rProps[nCount].Value <<= bVBACompat;
++nCount;
}
if( xCodeNameAccess.is() )
{
rProps[nCount].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ScriptConfiguration"));
rProps[nCount].Value <<= xCodeNameAccess;
++nCount;
}
}
}
}
}
XMLShapeExport* ScXMLExport::CreateShapeExport()
{
return new ScXMLShapeExport(*this);
}
void ScXMLExport::CreateSharedData(const sal_Int32 nTableCount)
{
pSharedData = new ScMySharedData(nTableCount);
}
XMLNumberFormatAttributesExportHelper* ScXMLExport::GetNumberFormatAttributesExportHelper()
{
if (!pNumberFormatAttributesExportHelper)
pNumberFormatAttributesExportHelper = new XMLNumberFormatAttributesExportHelper(GetNumberFormatsSupplier(), *this );
return pNumberFormatAttributesExportHelper;
}
void ScXMLExport::CollectUserDefinedNamespaces(const SfxItemPool* pPool, sal_uInt16 nAttrib)
{
const SfxPoolItem* pItem;
sal_uInt32 nItems(pPool->GetItemCount2( nAttrib ));
for( sal_uInt32 i = 0; i < nItems; ++i )
{
if( 0 != (pItem = pPool->GetItem2( nAttrib, i ) ) )
{
const SvXMLAttrContainerItem *pUnknown((const SvXMLAttrContainerItem *)pItem);
if( (pUnknown->GetAttrCount() > 0) )
{
sal_uInt16 nIdx(pUnknown->GetFirstNamespaceIndex());
while( USHRT_MAX != nIdx )
{
if( (XML_NAMESPACE_UNKNOWN_FLAG & nIdx) != 0 )
{
const OUString& rPrefix = pUnknown->GetPrefix( nIdx );
// Add namespace declaration for unknown attributes if
// there aren't existing ones for the prefix used by the
// attibutes
_GetNamespaceMap().Add( rPrefix,
pUnknown->GetNamespace( nIdx ),
XML_NAMESPACE_UNKNOWN );
}
nIdx = pUnknown->GetNextNamespaceIndex( nIdx );
}
}
}
}
// #i66550# needed for 'presentation:event-listener' element for URLs in shapes
_GetNamespaceMap().Add(
GetXMLToken( XML_NP_PRESENTATION ),
GetXMLToken( XML_N_PRESENTATION ),
XML_NAMESPACE_PRESENTATION );
}
void ScXMLExport::IncrementProgressBar(sal_Bool bEditCell, sal_Int32 nInc)
{
nProgressCount += nInc;
if (bEditCell || nProgressCount > 100)
{
GetProgressBarHelper()->Increment(nProgressCount);
nProgressCount = 0;
}
}
sal_uInt32 ScXMLExport::exportDoc( enum XMLTokenEnum eClass )
{
if( (getExportFlags() & (EXPORT_FONTDECLS|EXPORT_STYLES|
EXPORT_MASTERSTYLES|EXPORT_CONTENT)) != 0 )
{
if (GetDocument())
{
CollectUserDefinedNamespaces(GetDocument()->GetPool(), ATTR_USERDEF);
CollectUserDefinedNamespaces(GetDocument()->GetEditPool(), EE_PARA_XMLATTRIBS);
CollectUserDefinedNamespaces(GetDocument()->GetEditPool(), EE_CHAR_XMLATTRIBS);
ScDrawLayer* pDrawLayer = GetDocument()->GetDrawLayer();
if (pDrawLayer)
{
CollectUserDefinedNamespaces(&pDrawLayer->GetItemPool(), EE_PARA_XMLATTRIBS);
CollectUserDefinedNamespaces(&pDrawLayer->GetItemPool(), EE_CHAR_XMLATTRIBS);
CollectUserDefinedNamespaces(&pDrawLayer->GetItemPool(), SDRATTR_XMLATTRIBUTES);
}
// sheet events use officeooo namespace
if( (getExportFlags() & EXPORT_CONTENT) != 0 &&
getDefaultVersion() == SvtSaveOptions::ODFVER_LATEST )
{
bool bAnySheetEvents = false;
SCTAB nTabCount = pDoc->GetTableCount();
for (SCTAB nTab=0; nTab<nTabCount; ++nTab)
if (pDoc->GetSheetEvents(nTab))
bAnySheetEvents = true;
if (bAnySheetEvents)
_GetNamespaceMap().Add(
GetXMLToken( XML_NP_OFFICE_EXT ),
GetXMLToken( XML_N_OFFICE_EXT ),
XML_NAMESPACE_OFFICE_EXT );
}
}
}
return SvXMLExport::exportDoc( eClass );
}
// XExporter
void SAL_CALL ScXMLExport::setSourceDocument( const uno::Reference<lang::XComponent>& xComponent )
throw(lang::IllegalArgumentException, uno::RuntimeException)
{
ScUnoGuard aGuard;
SvXMLExport::setSourceDocument( xComponent );
pDoc = ScXMLConverter::GetScDocument( GetModel() );
DBG_ASSERT( pDoc, "ScXMLExport::setSourceDocument - no ScDocument!" );
if (!pDoc)
throw lang::IllegalArgumentException();
// create ScChangeTrackingExportHelper after document is known
pChangeTrackingExportHelper = new ScChangeTrackingExportHelper(*this);
// Set the document's storage grammar corresponding to the ODF version that
// is to be written.
SvtSaveOptions::ODFDefaultVersion meODFDefaultVersion = getDefaultVersion();
switch (meODFDefaultVersion)
{
// ODF 1.0 and 1.1 use GRAM_PODF, everything later or unspecified GRAM_ODFF
case SvtSaveOptions::ODFVER_010:
case SvtSaveOptions::ODFVER_011:
pDoc->SetStorageGrammar( formula::FormulaGrammar::GRAM_PODF);
break;
default:
pDoc->SetStorageGrammar( formula::FormulaGrammar::GRAM_ODFF);
}
}
// XFilter
sal_Bool SAL_CALL ScXMLExport::filter( const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >& aDescriptor )
throw(::com::sun::star::uno::RuntimeException)
{
ScUnoGuard aGuard;
if (pDoc)
pDoc->DisableIdle(sal_True);
sal_Bool bReturn(SvXMLExport::filter(aDescriptor));
if (pDoc)
pDoc->DisableIdle(sal_False);
return bReturn;
}
void SAL_CALL ScXMLExport::cancel()
throw(::com::sun::star::uno::RuntimeException)
{
ScUnoGuard aGuard;
if (pDoc)
pDoc->DisableIdle(sal_False);
SvXMLExport::cancel();
}
// XInitialization
void SAL_CALL ScXMLExport::initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments )
throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
{
ScUnoGuard aGuard;
SvXMLExport::initialize(aArguments);
}
// XServiceInfo
::rtl::OUString SAL_CALL ScXMLExport::getImplementationName( )
throw(::com::sun::star::uno::RuntimeException)
{
ScUnoGuard aGuard;
sal_uInt16 nFlags = getExportFlags();
if (nFlags & EXPORT_OASIS)
{
nFlags |= EXPORT_OASIS;
switch( nFlags )
{
case EXPORT_ALL:
return ScXMLOasisExport_getImplementationName();
case (EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_FONTDECLS):
return ScXMLOasisExport_Styles_getImplementationName();
case (EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_SCRIPTS|EXPORT_FONTDECLS):
return ScXMLOasisExport_Content_getImplementationName();
case EXPORT_META:
return ScXMLOasisExport_Meta_getImplementationName();
case EXPORT_SETTINGS:
return ScXMLOasisExport_Settings_getImplementationName();
default:
// generic name for 'unknown' cases
return ScXMLOasisExport_getImplementationName();
}
}
else
{
switch( nFlags )
{
case EXPORT_ALL:
return ScXMLOOoExport_getImplementationName();
case (EXPORT_STYLES|EXPORT_MASTERSTYLES|EXPORT_AUTOSTYLES|EXPORT_FONTDECLS):
return ScXMLOOoExport_Styles_getImplementationName();
case (EXPORT_AUTOSTYLES|EXPORT_CONTENT|EXPORT_SCRIPTS|EXPORT_FONTDECLS):
return ScXMLOOoExport_Content_getImplementationName();
case EXPORT_META:
return ScXMLOOoExport_Meta_getImplementationName();
case EXPORT_SETTINGS:
return ScXMLOOoExport_Settings_getImplementationName();
default:
// generic name for 'unknown' cases
return ScXMLOOoExport_getImplementationName();
}
}
return SvXMLExport::getImplementationName();
}
sal_Bool SAL_CALL ScXMLExport::supportsService( const ::rtl::OUString& ServiceName )
throw(::com::sun::star::uno::RuntimeException)
{
ScUnoGuard aGuard;
return SvXMLExport::supportsService( ServiceName );
}
::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL ScXMLExport::getSupportedServiceNames( )
throw(::com::sun::star::uno::RuntimeException)
{
ScUnoGuard aGuard;
return SvXMLExport::getSupportedServiceNames();
}
// XUnoTunnel
sal_Int64 SAL_CALL ScXMLExport::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& aIdentifier )
throw(::com::sun::star::uno::RuntimeException)
{
ScUnoGuard aGuard;
return SvXMLExport::getSomething(aIdentifier);
}
void ScXMLExport::DisposingModel()
{
SvXMLExport::DisposingModel();
pDoc = NULL;
xCurrentTable = 0;
}