917338c6a8
Change-Id: I1194441063047637adc20c8e37bb717fdb787714 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/108073 Tested-by: Jenkins Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
600 lines
21 KiB
C++
600 lines
21 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* 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 .
|
|
*/
|
|
|
|
#include <sal/config.h>
|
|
|
|
#include <com/sun/star/frame/XModel.hpp>
|
|
#include <com/sun/star/geometry/RealPoint2D.hpp>
|
|
#include <com/sun/star/text/XTextCursor.hpp>
|
|
#include <com/sun/star/util/DateTime.hpp>
|
|
#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
|
|
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
|
|
#include <cppuhelper/implbase.hxx>
|
|
#include <sax/tools/converter.hxx>
|
|
#include <XMLNumberStylesImport.hxx>
|
|
#include <xmloff/xmlstyle.hxx>
|
|
#include <xmloff/xmltoken.hxx>
|
|
#include <xmloff/xmlnamespace.hxx>
|
|
#include "ximppage.hxx"
|
|
#include <animimp.hxx>
|
|
#include <XMLStringBufferImportContext.hxx>
|
|
#include <xmloff/xmlictxt.hxx>
|
|
#include "ximpstyl.hxx"
|
|
#include <xmloff/prstylei.hxx>
|
|
#include <PropertySetMerger.hxx>
|
|
#include <sal/log.hxx>
|
|
#include <tools/diagnose_ex.h>
|
|
|
|
#include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
|
|
#include <xmloff/xmluconv.hxx>
|
|
|
|
using namespace ::com::sun::star;
|
|
using namespace ::xmloff::token;
|
|
using namespace ::com::sun::star::uno;
|
|
using namespace ::com::sun::star::lang;
|
|
using namespace ::com::sun::star::text;
|
|
using namespace ::com::sun::star::util;
|
|
using namespace ::com::sun::star::beans;
|
|
using namespace ::com::sun::star::drawing;
|
|
using namespace ::com::sun::star::container;
|
|
using namespace ::com::sun::star::office;
|
|
using namespace ::com::sun::star::xml::sax;
|
|
using namespace ::com::sun::star::geometry;
|
|
|
|
namespace {
|
|
|
|
class DrawAnnotationContext : public SvXMLImportContext
|
|
{
|
|
|
|
public:
|
|
DrawAnnotationContext( SvXMLImport& rImport, const Reference< xml::sax::XFastAttributeList>& xAttrList, const Reference< XAnnotationAccess >& xAnnotationAccess );
|
|
|
|
virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
|
|
sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
|
|
virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
|
|
|
|
private:
|
|
Reference< XAnnotation > mxAnnotation;
|
|
Reference< XTextCursor > mxCursor;
|
|
|
|
OUStringBuffer maAuthorBuffer;
|
|
OUStringBuffer maInitialsBuffer;
|
|
OUStringBuffer maDateBuffer;
|
|
};
|
|
|
|
}
|
|
|
|
DrawAnnotationContext::DrawAnnotationContext( SvXMLImport& rImport, const Reference< xml::sax::XFastAttributeList>& xAttrList, const Reference< XAnnotationAccess >& xAnnotationAccess )
|
|
: SvXMLImportContext( rImport )
|
|
, mxAnnotation( xAnnotationAccess->createAndInsertAnnotation() )
|
|
{
|
|
if( !mxAnnotation.is() )
|
|
return;
|
|
|
|
RealPoint2D aPosition;
|
|
RealSize2D aSize;
|
|
|
|
for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
|
|
{
|
|
switch( aIter.getToken() )
|
|
{
|
|
case XML_ELEMENT(SVG, XML_X):
|
|
case XML_ELEMENT(SVG_COMPAT, XML_X):
|
|
{
|
|
sal_Int32 x;
|
|
GetImport().GetMM100UnitConverter().convertMeasureToCore(
|
|
x, aIter.toView());
|
|
aPosition.X = static_cast<double>(x) / 100.0;
|
|
break;
|
|
}
|
|
case XML_ELEMENT(SVG, XML_Y):
|
|
case XML_ELEMENT(SVG_COMPAT, XML_Y):
|
|
{
|
|
sal_Int32 y;
|
|
GetImport().GetMM100UnitConverter().convertMeasureToCore(
|
|
y, aIter.toView());
|
|
aPosition.Y = static_cast<double>(y) / 100.0;
|
|
break;
|
|
}
|
|
case XML_ELEMENT(SVG, XML_WIDTH):
|
|
case XML_ELEMENT(SVG_COMPAT, XML_WIDTH):
|
|
{
|
|
sal_Int32 w;
|
|
GetImport().GetMM100UnitConverter().convertMeasureToCore(
|
|
w, aIter.toView());
|
|
aSize.Width = static_cast<double>(w) / 100.0;
|
|
break;
|
|
}
|
|
case XML_ELEMENT(SVG, XML_HEIGHT):
|
|
case XML_ELEMENT(SVG_COMPAT, XML_HEIGHT):
|
|
{
|
|
sal_Int32 h;
|
|
GetImport().GetMM100UnitConverter().convertMeasureToCore(
|
|
h, aIter.toView());
|
|
aSize.Height = static_cast<double>(h) / 100.0;
|
|
}
|
|
break;
|
|
default:
|
|
XMLOFF_WARN_UNKNOWN("xmloff", aIter);
|
|
}
|
|
}
|
|
|
|
mxAnnotation->setPosition( aPosition );
|
|
mxAnnotation->setSize( aSize );
|
|
}
|
|
|
|
css::uno::Reference< css::xml::sax::XFastContextHandler > DrawAnnotationContext::createFastChildContext(
|
|
sal_Int32 nElement,
|
|
const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
|
|
{
|
|
if( mxAnnotation.is() )
|
|
{
|
|
if (nElement == XML_ELEMENT(DC, XML_CREATOR) )
|
|
return new XMLStringBufferImportContext(GetImport(), maAuthorBuffer);
|
|
else if( nElement == XML_ELEMENT(DC, XML_DATE) )
|
|
return new XMLStringBufferImportContext(GetImport(), maDateBuffer);
|
|
else if ( nElement == XML_ELEMENT(TEXT, XML_SENDER_INITIALS)
|
|
|| nElement == XML_ELEMENT(LO_EXT, XML_SENDER_INITIALS)
|
|
|| nElement == XML_ELEMENT(META, XML_CREATOR_INITIALS))
|
|
{
|
|
return new XMLStringBufferImportContext(GetImport(), maInitialsBuffer);
|
|
}
|
|
else
|
|
{
|
|
// create text cursor on demand
|
|
if( !mxCursor.is() )
|
|
{
|
|
uno::Reference< text::XText > xText( mxAnnotation->getTextRange() );
|
|
if( xText.is() )
|
|
{
|
|
rtl::Reference < XMLTextImportHelper > xTxtImport = GetImport().GetTextImport();
|
|
mxCursor = xText->createTextCursor();
|
|
if( mxCursor.is() )
|
|
xTxtImport->SetCursor( mxCursor );
|
|
}
|
|
}
|
|
|
|
// if we have a text cursor, lets try to import some text
|
|
if( mxCursor.is() )
|
|
{
|
|
auto p = GetImport().GetTextImport()->CreateTextChildContext( GetImport(), nElement, xAttrList );
|
|
if (p)
|
|
return p;
|
|
}
|
|
}
|
|
}
|
|
XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
|
|
return nullptr;
|
|
}
|
|
|
|
void DrawAnnotationContext::endFastElement(sal_Int32)
|
|
{
|
|
if(mxCursor.is())
|
|
{
|
|
// delete addition newline
|
|
mxCursor->gotoEnd( false );
|
|
mxCursor->goLeft( 1, true );
|
|
mxCursor->setString( "" );
|
|
|
|
// reset cursor
|
|
GetImport().GetTextImport()->ResetCursor();
|
|
}
|
|
|
|
if( mxAnnotation.is() )
|
|
{
|
|
mxAnnotation->setAuthor( maAuthorBuffer.makeStringAndClear() );
|
|
mxAnnotation->setInitials( maInitialsBuffer.makeStringAndClear() );
|
|
|
|
util::DateTime aDateTime;
|
|
if (::sax::Converter::parseDateTime(aDateTime,
|
|
maDateBuffer.makeStringAndClear()))
|
|
{
|
|
mxAnnotation->setDateTime(aDateTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
SdXMLGenericPageContext::SdXMLGenericPageContext(
|
|
SvXMLImport& rImport,
|
|
const Reference< xml::sax::XFastAttributeList>& xAttrList,
|
|
Reference< drawing::XShapes > const & rShapes)
|
|
: SvXMLImportContext( rImport )
|
|
, mxShapes( rShapes )
|
|
, mxAnnotationAccess( rShapes, UNO_QUERY )
|
|
{
|
|
for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
|
|
{
|
|
if( aIter.getToken() == XML_ELEMENT(DRAW, XML_NAV_ORDER) )
|
|
{
|
|
msNavOrder = aIter.toString();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
SdXMLGenericPageContext::~SdXMLGenericPageContext()
|
|
{
|
|
}
|
|
|
|
void SdXMLGenericPageContext::startFastElement( sal_Int32 /*nElement*/, const Reference< css::xml::sax::XFastAttributeList >& )
|
|
{
|
|
GetImport().GetShapeImport()->pushGroupForPostProcessing( mxShapes );
|
|
|
|
if( GetImport().IsFormsSupported() )
|
|
GetImport().GetFormImport()->startPage( Reference< drawing::XDrawPage >::query( mxShapes ) );
|
|
}
|
|
|
|
css::uno::Reference< css::xml::sax::XFastContextHandler > SdXMLGenericPageContext::createFastChildContext(
|
|
sal_Int32 nElement,
|
|
const Reference< xml::sax::XFastAttributeList>& xAttrList )
|
|
{
|
|
if( nElement == XML_ELEMENT(PRESENTATION, XML_ANIMATIONS) )
|
|
{
|
|
return new XMLAnimationsContext( GetImport() );
|
|
}
|
|
else if( nElement == XML_ELEMENT(OFFICE, XML_FORMS) )
|
|
{
|
|
if( GetImport().IsFormsSupported() )
|
|
return xmloff::OFormLayerXMLImport::createOfficeFormsContext( GetImport() );
|
|
}
|
|
else if( nElement == XML_ELEMENT(OFFICE, XML_ANNOTATION) || nElement == XML_ELEMENT(OFFICE_EXT, XML_ANNOTATION) )
|
|
{
|
|
if( mxAnnotationAccess.is() )
|
|
return new DrawAnnotationContext( GetImport(), xAttrList, mxAnnotationAccess );
|
|
}
|
|
else
|
|
{
|
|
// call GroupChildContext function at common ShapeImport
|
|
auto p = XMLShapeImportHelper::CreateGroupChildContext(GetImport(), nElement, xAttrList, mxShapes);
|
|
if (p)
|
|
return p;
|
|
}
|
|
XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
|
|
return nullptr;
|
|
}
|
|
|
|
void SdXMLGenericPageContext::endFastElement(sal_Int32 )
|
|
{
|
|
GetImport().GetShapeImport()->popGroupAndPostProcess();
|
|
|
|
if( GetImport().IsFormsSupported() )
|
|
GetImport().GetFormImport()->endPage();
|
|
|
|
if( !maUseHeaderDeclName.isEmpty() || !maUseFooterDeclName.isEmpty() || !maUseDateTimeDeclName.isEmpty() )
|
|
{
|
|
try
|
|
{
|
|
Reference <beans::XPropertySet> xSet(mxShapes, uno::UNO_QUERY_THROW );
|
|
Reference< beans::XPropertySetInfo > xInfo( xSet->getPropertySetInfo() );
|
|
|
|
if( !maUseHeaderDeclName.isEmpty() )
|
|
{
|
|
const OUString aStrHeaderTextProp( "HeaderText" );
|
|
if( xInfo->hasPropertyByName( aStrHeaderTextProp ) )
|
|
xSet->setPropertyValue( aStrHeaderTextProp,
|
|
makeAny( GetSdImport().GetHeaderDecl( maUseHeaderDeclName ) ) );
|
|
}
|
|
|
|
if( !maUseFooterDeclName.isEmpty() )
|
|
{
|
|
const OUString aStrFooterTextProp( "FooterText" );
|
|
if( xInfo->hasPropertyByName( aStrFooterTextProp ) )
|
|
xSet->setPropertyValue( aStrFooterTextProp,
|
|
makeAny( GetSdImport().GetFooterDecl( maUseFooterDeclName ) ) );
|
|
}
|
|
|
|
if( !maUseDateTimeDeclName.isEmpty() )
|
|
{
|
|
const OUString aStrDateTimeTextProp( "DateTimeText" );
|
|
if( xInfo->hasPropertyByName( aStrDateTimeTextProp ) )
|
|
{
|
|
bool bFixed;
|
|
OUString aDateTimeFormat;
|
|
const OUString aText( GetSdImport().GetDateTimeDecl( maUseDateTimeDeclName, bFixed, aDateTimeFormat ) );
|
|
|
|
xSet->setPropertyValue("IsDateTimeFixed",
|
|
makeAny( bFixed ) );
|
|
|
|
if( bFixed )
|
|
{
|
|
xSet->setPropertyValue( aStrDateTimeTextProp, makeAny( aText ) );
|
|
}
|
|
else if( !aDateTimeFormat.isEmpty() )
|
|
{
|
|
const SdXMLStylesContext* pStyles = dynamic_cast< const SdXMLStylesContext* >( GetSdImport().GetShapeImport()->GetStylesContext() );
|
|
if( !pStyles )
|
|
pStyles = dynamic_cast< const SdXMLStylesContext* >( GetSdImport().GetShapeImport()->GetAutoStylesContext() );
|
|
|
|
if( pStyles )
|
|
{
|
|
const SdXMLNumberFormatImportContext* pSdNumStyle =
|
|
dynamic_cast< const SdXMLNumberFormatImportContext* >( pStyles->FindStyleChildContext( XmlStyleFamily::DATA_STYLE, aDateTimeFormat, true ) );
|
|
|
|
if( pSdNumStyle )
|
|
{
|
|
xSet->setPropertyValue("DateTimeFormat",
|
|
makeAny( pSdNumStyle->GetDrawKey() ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch(const uno::Exception&)
|
|
{
|
|
TOOLS_WARN_EXCEPTION("xmloff.draw", "");
|
|
}
|
|
}
|
|
|
|
SetNavigationOrder();
|
|
}
|
|
|
|
void SdXMLGenericPageContext::SetStyle( OUString const & rStyleName )
|
|
{
|
|
// set PageProperties?
|
|
if(rStyleName.isEmpty())
|
|
return;
|
|
|
|
try
|
|
{
|
|
const SvXMLImportContext* pContext = GetSdImport().GetShapeImport()->GetAutoStylesContext();
|
|
|
|
if (const SdXMLStylesContext* pStyles = dynamic_cast<const SdXMLStylesContext *>(pContext))
|
|
{
|
|
const SvXMLStyleContext* pStyle = pStyles->FindStyleChildContext(
|
|
XmlStyleFamily::SD_DRAWINGPAGE_ID, rStyleName);
|
|
|
|
if (const XMLPropStyleContext* pPropStyle = dynamic_cast<const XMLPropStyleContext*>(pStyle))
|
|
{
|
|
Reference <beans::XPropertySet> xPropSet1(mxShapes, uno::UNO_QUERY);
|
|
if(xPropSet1.is())
|
|
{
|
|
Reference< beans::XPropertySet > xPropSet( xPropSet1 );
|
|
Reference< beans::XPropertySet > xBackgroundSet;
|
|
|
|
const OUString aBackground("Background");
|
|
if( xPropSet1->getPropertySetInfo()->hasPropertyByName( aBackground ) )
|
|
{
|
|
Reference< beans::XPropertySetInfo > xInfo( xPropSet1->getPropertySetInfo() );
|
|
if( xInfo.is() && xInfo->hasPropertyByName( aBackground ) )
|
|
{
|
|
Reference< lang::XMultiServiceFactory > xServiceFact(GetSdImport().GetModel(), uno::UNO_QUERY);
|
|
if(xServiceFact.is())
|
|
{
|
|
xBackgroundSet.set(xServiceFact->createInstance("com.sun.star.drawing.Background"), UNO_QUERY);
|
|
}
|
|
}
|
|
|
|
if( xBackgroundSet.is() )
|
|
xPropSet = PropertySetMerger_CreateInstance( xPropSet1, xBackgroundSet );
|
|
}
|
|
|
|
if(xPropSet.is())
|
|
{
|
|
const_cast<XMLPropStyleContext*>(pPropStyle)->FillPropertySet(xPropSet);
|
|
|
|
if( xBackgroundSet.is() )
|
|
xPropSet1->setPropertyValue( aBackground, uno::makeAny( xBackgroundSet ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (const uno::Exception&)
|
|
{
|
|
TOOLS_WARN_EXCEPTION("xmloff.draw", "");
|
|
}
|
|
}
|
|
|
|
void SdXMLGenericPageContext::SetLayout()
|
|
{
|
|
// set PresentationPageLayout?
|
|
if(!GetSdImport().IsImpress() || maPageLayoutName.isEmpty())
|
|
return;
|
|
|
|
sal_Int32 nType = -1;
|
|
|
|
const SvXMLImportContext* pContext = GetSdImport().GetShapeImport()->GetStylesContext();
|
|
|
|
if (const SdXMLStylesContext* pStyles = dynamic_cast<const SdXMLStylesContext *>(pContext))
|
|
{
|
|
const SvXMLStyleContext* pStyle = pStyles->FindStyleChildContext( XmlStyleFamily::SD_PRESENTATIONPAGELAYOUT_ID, maPageLayoutName);
|
|
|
|
if (const SdXMLPresentationPageLayoutContext* pLayout = dynamic_cast<const SdXMLPresentationPageLayoutContext*>(pStyle))
|
|
{
|
|
nType = pLayout->GetTypeId();
|
|
}
|
|
}
|
|
|
|
if( -1 == nType )
|
|
{
|
|
Reference< container::XNameAccess > xPageLayouts( GetSdImport().getPageLayouts() );
|
|
if( xPageLayouts.is() )
|
|
{
|
|
if( xPageLayouts->hasByName( maPageLayoutName ) )
|
|
xPageLayouts->getByName( maPageLayoutName ) >>= nType;
|
|
}
|
|
|
|
}
|
|
|
|
if( -1 != nType )
|
|
{
|
|
Reference <beans::XPropertySet> xPropSet(mxShapes, uno::UNO_QUERY);
|
|
if(xPropSet.is())
|
|
{
|
|
OUString aPropName("Layout");
|
|
Reference< beans::XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
|
|
if( xInfo.is() && xInfo->hasPropertyByName( aPropName ) )
|
|
xPropSet->setPropertyValue(aPropName, uno::makeAny( static_cast<sal_Int16>(nType) ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
void SdXMLGenericPageContext::DeleteAllShapes()
|
|
{
|
|
// now delete all up-to-now contained shapes; they have been created
|
|
// when setting the presentation page layout.
|
|
while(mxShapes->getCount())
|
|
{
|
|
Reference< drawing::XShape > xShape;
|
|
uno::Any aAny(mxShapes->getByIndex(0));
|
|
|
|
aAny >>= xShape;
|
|
|
|
if(xShape.is())
|
|
{
|
|
mxShapes->remove(xShape);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SdXMLGenericPageContext::SetPageMaster( OUString const & rsPageMasterName )
|
|
{
|
|
if (!GetSdImport().GetShapeImport()->GetStylesContext())
|
|
return;
|
|
|
|
// look for PageMaster with this name
|
|
|
|
// #80012# GetStylesContext() replaced with GetAutoStylesContext()
|
|
const SvXMLStylesContext* pAutoStyles = GetSdImport().GetShapeImport()->GetAutoStylesContext();
|
|
|
|
const SvXMLStyleContext* pStyle = pAutoStyles ? pAutoStyles->FindStyleChildContext(XmlStyleFamily::SD_PAGEMASTERCONTEXT_ID, rsPageMasterName) : nullptr;
|
|
|
|
const SdXMLPageMasterContext* pPageMaster = dynamic_cast<const SdXMLPageMasterContext*>(pStyle);
|
|
if (!pPageMaster)
|
|
return;
|
|
|
|
const SdXMLPageMasterStyleContext* pPageMasterContext = pPageMaster->GetPageMasterStyle();
|
|
|
|
if (!pPageMasterContext)
|
|
return;
|
|
|
|
Reference< drawing::XDrawPage > xMasterPage(GetLocalShapesContext(), uno::UNO_QUERY);
|
|
if (!xMasterPage.is())
|
|
return;
|
|
|
|
// set sizes for this masterpage
|
|
Reference <beans::XPropertySet> xPropSet(xMasterPage, uno::UNO_QUERY);
|
|
if (xPropSet.is())
|
|
{
|
|
xPropSet->setPropertyValue("BorderBottom", Any(pPageMasterContext->GetBorderBottom()));
|
|
xPropSet->setPropertyValue("BorderLeft", Any(pPageMasterContext->GetBorderLeft()));
|
|
xPropSet->setPropertyValue("BorderRight", Any(pPageMasterContext->GetBorderRight()));
|
|
xPropSet->setPropertyValue("BorderTop", Any(pPageMasterContext->GetBorderTop()));
|
|
xPropSet->setPropertyValue("Width", Any(pPageMasterContext->GetWidth()));
|
|
xPropSet->setPropertyValue("Height", Any(pPageMasterContext->GetHeight()));
|
|
xPropSet->setPropertyValue("Orientation", Any(pPageMasterContext->GetOrientation()));
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
|
|
class XoNavigationOrderAccess : public ::cppu::WeakImplHelper< XIndexAccess >
|
|
{
|
|
public:
|
|
explicit XoNavigationOrderAccess( std::vector< Reference< XShape > >& rShapes );
|
|
|
|
// XIndexAccess
|
|
virtual sal_Int32 SAL_CALL getCount( ) override;
|
|
virtual Any SAL_CALL getByIndex( sal_Int32 Index ) override;
|
|
|
|
// XElementAccess
|
|
virtual Type SAL_CALL getElementType( ) override;
|
|
virtual sal_Bool SAL_CALL hasElements( ) override;
|
|
|
|
private:
|
|
std::vector< Reference< XShape > > maShapes;
|
|
};
|
|
|
|
}
|
|
|
|
XoNavigationOrderAccess::XoNavigationOrderAccess( std::vector< Reference< XShape > >& rShapes )
|
|
{
|
|
maShapes.swap( rShapes );
|
|
}
|
|
|
|
// XIndexAccess
|
|
sal_Int32 SAL_CALL XoNavigationOrderAccess::getCount( )
|
|
{
|
|
return static_cast< sal_Int32 >( maShapes.size() );
|
|
}
|
|
|
|
Any SAL_CALL XoNavigationOrderAccess::getByIndex( sal_Int32 Index )
|
|
{
|
|
if( (Index < 0) || (Index > getCount()) )
|
|
throw IndexOutOfBoundsException();
|
|
|
|
return Any( maShapes[Index] );
|
|
}
|
|
|
|
// XElementAccess
|
|
Type SAL_CALL XoNavigationOrderAccess::getElementType( )
|
|
{
|
|
return cppu::UnoType<XShape>::get();
|
|
}
|
|
|
|
sal_Bool SAL_CALL XoNavigationOrderAccess::hasElements( )
|
|
{
|
|
return !maShapes.empty();
|
|
}
|
|
|
|
void SdXMLGenericPageContext::SetNavigationOrder()
|
|
{
|
|
if( msNavOrder.isEmpty() )
|
|
return;
|
|
|
|
try
|
|
{
|
|
sal_uInt32 nIndex;
|
|
const sal_uInt32 nCount = static_cast< sal_uInt32 >( mxShapes->getCount() );
|
|
std::vector< Reference< XShape > > aShapes( nCount );
|
|
|
|
::comphelper::UnoInterfaceToUniqueIdentifierMapper& rIdMapper = GetSdImport().getInterfaceToIdentifierMapper();
|
|
SvXMLTokenEnumerator aEnumerator( msNavOrder );
|
|
std::u16string_view sId;
|
|
for( nIndex = 0; nIndex < nCount; ++nIndex )
|
|
{
|
|
if( !aEnumerator.getNextToken(sId) )
|
|
break;
|
|
|
|
aShapes[nIndex].set( rIdMapper.getReference( OUString(sId) ), UNO_QUERY );
|
|
}
|
|
|
|
for( nIndex = 0; nIndex < nCount; ++nIndex )
|
|
{
|
|
if( !aShapes[nIndex].is() )
|
|
{
|
|
OSL_FAIL("xmloff::SdXMLGenericPageContext::SetNavigationOrder(), draw:nav-order attribute incomplete!");
|
|
// todo: warning?
|
|
return;
|
|
}
|
|
}
|
|
|
|
Reference< XPropertySet > xSet( mxShapes, UNO_QUERY_THROW );
|
|
xSet->setPropertyValue("NavigationOrder", Any( Reference< XIndexAccess >( new XoNavigationOrderAccess( aShapes ) ) ) );
|
|
}
|
|
catch(const uno::Exception&)
|
|
{
|
|
TOOLS_WARN_EXCEPTION("xmloff.draw",
|
|
"unexpected exception caught while importing shape navigation order!");
|
|
}
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|