/* -*- 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 .
*/
#ifndef INCLUDED_OOX_VML_VMLDRAWING_HXX
#define INCLUDED_OOX_VML_VMLDRAWING_HXX
#include <map>
#include <memory>
#include <vector>
#include <com/sun/star/uno/Reference.hxx>
#include <oox/dllapi.h>
#include <oox/ole/oleobjecthelper.hxx>
#include <rtl/ustring.hxx>
#include <sal/types.h>
namespace com::sun::star {
namespace awt {
struct Rectangle; }
namespace drawing {
class XDrawPage; }
namespace drawing {
class XShape; }
namespace drawing {
class XShapes; }
}
namespace oox {
namespace core {
class XmlFilterBase; }
namespace ole {
class EmbeddedControl; }
namespace ole {
class EmbeddedForm; }
namespace vml {
class ShapeContainer; }
}
namespace oox::vml {
class ShapeBase;
/** Enumerates different types of VML drawings. */
enum DrawingType
{
VMLDRAWING_WORD,
///< Word: One shape per drawing.
VMLDRAWING_EXCEL,
///< Excel: OLE objects are part of VML.
VMLDRAWING_POWERPOINT
///< PowerPoint: OLE objects are part of DrawingML.
};
/** Contains information about an OLE object embedded in a draw page. */
struct OOX_DLLPUBLIC OleObjectInfo :
public ::oox::ole::OleObjectInfo
{
OUString maShapeId;
///< Shape identifier for shape lookup.
OUString maName;
///< Programmatical name of the OLE object.
bool mbAutoLoad;
const bool mbDmlShape;
///< True = DrawingML shape (PowerPoint), false = VML shape (Excel/Word).
explicit OleObjectInfo(
bool bDmlShape =
false );
/** Sets the string representation of the passed numeric shape identifier. */
void setShapeId( sal_Int32 nShapeId );
};
// =========================================/===================================
/** Contains information about a form control embedded in a draw page. */
struct OOX_DLLPUBLIC ControlInfo
{
OUString maShapeId;
///< Shape identifier for shape lookup.
OUString maFragmentPath;
///< Path to the fragment describing the form control properties.
OUString maName;
///< Programmatical name of the form control.
bool mbTextContentShape;
///< Whether this control shape will be imported to Writer or not (has AnchorType property or not).
explicit ControlInfo();
/** Sets the string representation of the passed numeric shape identifier. */
void setShapeId( sal_Int32 nShapeId );
};
/** Represents the collection of VML shapes for a complete draw page. */
class OOX_DLLPUBLIC Drawing
{
public:
explicit Drawing(
::oox::core::XmlFilterBase& rFilter,
const css::uno::Reference< css::drawing::XDrawPage >& rxDrawPage,
DrawingType eType );
virtual ~Drawing();
/** Returns the filter object that imports/exports this VML drawing. */
::oox::core::XmlFilterBase& getFilter()
const {
return mrFilter; }
/** Returns the application type containing the drawing. */
DrawingType getType()
const {
return meType; }
/** Returns read/write access to the container of shapes and templates. */
ShapeContainer& getShapes() {
return *mxShapes; }
/** Returns read access to the container of shapes and templates. */
const ShapeContainer& getShapes()
const {
return *mxShapes; }
/** Returns the form object used to process ActiveX form controls. */
::oox::ole::EmbeddedForm& getControlForm()
const;
/** Registers a block of shape identifiers reserved by this drawing. Block
size is 1024, shape identifiers are one-based (block 1 => 1025-2048). */
void registerBlockId( sal_Int32 nBlockId );
/** Registers the passed embedded OLE object. The related shape will then
load the OLE object data from the specified fragment. */
void registerOleObject(
const OleObjectInfo& rOleObject );
/** Registers the passed embedded form control. The related shape will then
load the control properties from the specified fragment. */
void registerControl(
const ControlInfo& rControl );
/** Final processing after import of the fragment. */
void finalizeFragmentImport();
/** Creates and inserts all UNO shapes into the draw page. The virtual
function notifyXShapeInserted() will be called for each new shape. */
void convertAndInsert()
const;
/** Returns the local shape index from the passed global shape identifier. */
sal_Int32 getLocalShapeIndex( std::u16string_view rShapeId )
const;
/** Returns the registered info structure for an OLE object, if extant. */
const OleObjectInfo* getOleObjectInfo(
const OUString& rShapeId )
const;
/** Returns the registered info structure for a form control, if extant. */
const ControlInfo* getControlInfo(
const OUString& rShapeId )
const;
/** Creates a new UNO shape object, inserts it into the passed UNO shape
container, and sets the shape position and size. */
css::uno::Reference< css::drawing::XShape >
createAndInsertXShape(
const OUString& rService,
const css::uno::Reference< css::drawing::XShapes >& rxShapes,
const css::awt::Rectangle& rShapeRect )
const;
/** Creates a new UNO shape object for a form control, inserts the control
model into the form, and the shape into the passed UNO shape container. */
css::uno::Reference< css::drawing::XShape >
createAndInsertXControlShape(
const ::oox::ole::EmbeddedControl& rControl,
const css::uno::Reference< css::drawing::XShapes >& rxShapes,
const css::awt::Rectangle& rShapeRect,
sal_Int32& rnCtrlIndex )
const;
/** Derived classes may disable conversion of specific shapes. */
virtual bool isShapeSupported(
const ShapeBase& rShape )
const;
/** Derived classes may return additional base names for automatic shape
name creation. */
virtual OUString getShapeBaseName(
const ShapeBase& rShape )
const;
/** Derived classes may calculate the shape rectangle from a non-standard
anchor information string. */
virtual bool convertClientAnchor(
css::awt::Rectangle& orShapeRect,
const OUString& rShapeAnchor )
const;
/** Derived classes create a UNO shape according to the passed shape model.
Called for shape models that specify being under host control. */
virtual css::uno::Reference< css::drawing::XShape >
createAndInsertClientXShape(
const ShapeBase& rShape,
const css::uno::Reference< css::drawing::XShapes >& rxShapes,
const css::awt::Rectangle& rShapeRect )
const;
/** Derived classes may want to know that a UNO shape has been inserted.
Will be called from the convertAndInsert() implementation.
@param bGroupChild True = inserted into a group shape,
false = inserted directly into this drawing. */
virtual void notifyXShapeInserted(
const css::uno::Reference< css::drawing::XShape >& rxShape,
const css::awt::Rectangle& rShapeRect,
const ShapeBase& rShape,
bool bGroupChild );
private:
typedef ::std::vector< sal_Int32 > BlockIdVector;
typedef ::std::map< OUString, OleObjectInfo > OleObjectInfoMap;
typedef ::std::map< OUString, ControlInfo > ControlInfoMap;
::oox::core::XmlFilterBase& mrFilter;
///< Filter object that imports/exports the VML drawing.
css::uno::Reference< css::drawing::XDrawPage >
mxDrawPage;
///< UNO draw page used to insert the shapes.
mutable std::unique_ptr<::oox::ole::EmbeddedForm> mxCtrlForm;
///< The control form used to process embedded controls.
mutable BlockIdVector maBlockIds;
///< Block identifiers used by this drawing.
std::unique_ptr<ShapeContainer> mxShapes;
///< All shapes and shape templates.
OleObjectInfoMap maOleObjects;
///< Info about all embedded OLE objects, mapped by shape id.
ControlInfoMap maControls;
///< Info about all embedded form controls, mapped by control name.
const DrawingType meType;
///< Application type containing the drawing.
};
}
// namespace oox::vml
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
