xiescher.hxx

Go to the documentation of this file.

/* -*- 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 .
 */
 
#pragma once
 
#include <filter/msfilter/msdffimp.hxx>
#include <vcl/graph.hxx>
#include "xlescher.hxx"
#include "xiroot.hxx"
#include <oox/ole/olehelper.hxx>
#include <rtl/ustring.hxx>
#include <svx/svdobj.hxx>
#include <map>
#include <memory>
#include <vector>
 
namespace com::sun::star {
    namespace drawing { class XShape; }
    namespace form { class XForm; }
}
 
namespace com::sun::star::container { class XNameContainer; }
 
class SdrObjList;
class ScfProgressBar;
class ScfPropertySet;
class ScRangeList;
class XclImpChart;
class XclImpDffConverter;
class XclImpDrawing;
 
// Drawing objects ============================================================
 
class XclImpDrawObjBase;
typedef std::shared_ptr< XclImpDrawObjBase > XclImpDrawObjRef;
 
class XclImpDrawObjBase : protected XclImpRoot
{
public:
    explicit            XclImpDrawObjBase( const XclImpRoot& rRoot );
    virtual             ~XclImpDrawObjBase() override;
 
    static XclImpDrawObjRef ReadObj3( const XclImpRoot& rRoot, XclImpStream& rStrm );
    static XclImpDrawObjRef ReadObj4( const XclImpRoot& rRoot, XclImpStream& rStrm );
    static XclImpDrawObjRef ReadObj5( const XclImpRoot& rRoot, XclImpStream& rStrm );
    static XclImpDrawObjRef ReadObj8( const XclImpRoot& rRoot, XclImpStream& rStrm );
 
    void         SetAreaObj( bool bAreaObj ) { mbAreaObj = bAreaObj; }
    void         SetSimpleMacro( bool bMacro ) { mbSimpleMacro = bMacro; }
 
    void                SetAnchor( const XclObjAnchor& rAnchor );
    void                SetDffData(
        const DffObjData& rDffObjData, const OUString& rObjName, const OUString& rHyperlink,
        bool bVisible, bool bAutoMargin );
 
    void         SetProcessSdrObj( bool bProcess ) { mbProcessSdr = bProcess; }
    void         SetInsertSdrObj( bool bInsert ) { mbInsertSdr = bInsert; }
    void         SetCustomDffObj( bool bCustom ) { mbCustomDff = bCustom; }
 
    sal_uInt16   GetObjId() const { return mnObjId; }
    sal_uInt16   GetObjType() const { return mnObjType; }
    virtual OUString GetObjName() const;
    const OUString& GetMacroName() const { return maMacroName; }
 
    sal_uInt32   GetDffShapeId() const { return mnDffShapeId; }
    ShapeFlag    GetDffFlags() const { return mnDffFlags; }
    const tools::Rectangle& GetDffRect() const;
 
    bool         IsHidden() const { return mbHidden; }
    bool         IsVisible() const { return mbVisible; }
    bool         IsPrintable() const { return mbPrintable; }
 
    const XclObjAnchor* GetAnchor() const;
    bool                IsValidSize( const tools::Rectangle& rAnchorRect ) const;
    ScRange             GetUsedArea( SCTAB nScTab ) const;
 
    bool         IsProcessSdrObj() const { return mbProcessSdr && !mbHidden; }
    bool         IsInsertSdrObj() const { return mbInsertSdr; }
 
    std::size_t         GetProgressSize() const;
    rtl::Reference<SdrObject>        CreateSdrObject( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect, bool bIsDff ) const;
    void                PreProcessSdrObject( XclImpDffConverter& rDffConv, SdrObject& rSdrObj );
    void                PostProcessSdrObject( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const;
    SCTAB               GetTab() const { return mnTab; }
 
protected:
    void                ReadName5( XclImpStream& rStrm, sal_uInt16 nNameLen );
    void                ReadMacro3( XclImpStream& rStrm, sal_uInt16 nMacroSize );
    void                ReadMacro4( XclImpStream& rStrm, sal_uInt16 nMacroSize );
    void                ReadMacro5( XclImpStream& rStrm, sal_uInt16 nMacroSize );
    void                ReadMacro8( XclImpStream& rStrm );
 
    void                ConvertLineStyle( SdrObject& rSdrObj, const XclObjLineData& rLineData ) const;
    void                ConvertFillStyle( SdrObject& rSdrObj, const XclObjFillData& rFillData ) const;
    void                ConvertFrameStyle( SdrObject& rSdrObj, sal_uInt16 nFrameFlags ) const;
 
    Color               GetSolidLineColor( const XclObjLineData& rLineData ) const;
    Color               GetSolidFillColor( const XclObjFillData& rFillData ) const;
 
    virtual void        DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize );
    virtual void        DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize );
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize );
    virtual void        DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize );
 
    virtual std::size_t DoGetProgressSize() const;
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const;
    virtual void        DoPreProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const;
    virtual void        DoPostProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const;
 
    void NotifyMacroEventRead();
private:
    void                ImplReadObj3( XclImpStream& rStrm );
    void                ImplReadObj4( XclImpStream& rStrm );
    void                ImplReadObj5( XclImpStream& rStrm );
    void                ImplReadObj8( XclImpStream& rStrm );
 
private:
    XclObjAnchor        maAnchor;       
    sal_uInt16          mnObjId;        
    SCTAB               mnTab;          
    sal_uInt16          mnObjType;      
    sal_uInt32          mnDffShapeId;   
    ShapeFlag           mnDffFlags;     
    tools::Rectangle maDffRect;
    OUString       maObjName;      
    OUString       maMacroName;    
    OUString       maHyperlink;    
    bool                mbHasAnchor;    
    bool                mbHidden;       
    bool                mbVisible;      
    bool                mbPrintable;    
    bool                mbAreaObj;      
    bool                mbAutoMargin;   
    bool                mbSimpleMacro;  
    bool                mbProcessSdr;   
    bool                mbInsertSdr;    
    bool                mbCustomDff;    
    bool                mbNotifyMacroEventRead; 
};
 
class XclImpDrawObjVector
{
private:
    std::vector< XclImpDrawObjRef > mObjs;
 
public:
    explicit     XclImpDrawObjVector() : mObjs() {}
 
    std::vector< XclImpDrawObjRef >::const_iterator begin() const { return mObjs.begin(); }
    std::vector< XclImpDrawObjRef >::const_iterator end() const { return mObjs.end(); }
    void push_back(const XclImpDrawObjRef& rObj) { mObjs.push_back(rObj); }
 
    void                InsertGrouped( XclImpDrawObjRef const & xDrawObj );
 
    std::size_t         GetProgressSize() const;
};
 
class XclImpPhObj : public XclImpDrawObjBase
{
public:
    explicit            XclImpPhObj( const XclImpRoot& rRoot );
};
 
class XclImpGroupObj final : public XclImpDrawObjBase
{
public:
    explicit            XclImpGroupObj( const XclImpRoot& rRoot );
 
    bool                TryInsert( XclImpDrawObjRef const & xDrawObj );
 
private:
    virtual void        DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual std::size_t DoGetProgressSize() const override;
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const override;
 
    XclImpDrawObjVector maChildren;         
    sal_uInt16          mnFirstUngrouped;   
};
 
class XclImpLineObj final : public XclImpDrawObjBase
{
public:
    explicit            XclImpLineObj( const XclImpRoot& rRoot );
 
private:
    virtual void        DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const override;
 
    XclObjLineData      maLineData;     
    sal_uInt16          mnArrows;       
    sal_uInt8           mnStartPoint;   
};
 
class XclImpRectObj : public XclImpDrawObjBase
{
public:
    explicit            XclImpRectObj( const XclImpRoot& rRoot );
 
protected:
    void                ReadFrameData( XclImpStream& rStrm );
 
    void                ConvertRectStyle( SdrObject& rSdrObj ) const;
 
    virtual void        DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const override;
 
protected:
    XclObjFillData      maFillData;     
    XclObjLineData      maLineData;     
    sal_uInt16          mnFrameFlags;   
};
 
class XclImpOvalObj : public XclImpRectObj
{
public:
    explicit            XclImpOvalObj( const XclImpRoot& rRoot );
 
protected:
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const override;
};
 
class XclImpArcObj final : public XclImpDrawObjBase
{
public:
    explicit            XclImpArcObj( const XclImpRoot& rRoot );
 
private:
    virtual void        DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const override;
 
    XclObjFillData      maFillData;     
    XclObjLineData      maLineData;     
    sal_uInt8           mnQuadrant;     
};
 
class XclImpPolygonObj final : public XclImpRectObj
{
public:
    explicit            XclImpPolygonObj( const XclImpRoot& rRoot );
 
private:
    void                ReadCoordList( XclImpStream& rStrm );
 
    virtual void        DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const override;
 
    typedef std::vector< Point > PointVector;
    PointVector         maCoords;       
    sal_uInt16          mnPolyFlags;    
    sal_uInt16          mnPointCount;   
};
 
struct XclImpObjTextData
{
    XclObjTextData      maData;         
    XclImpStringRef     mxString;       
 
    void                ReadByteString( XclImpStream& rStrm );
    void                ReadFormats( XclImpStream& rStrm );
};
 
class XclImpTextObj : public XclImpRectObj
{
public:
    explicit            XclImpTextObj( const XclImpRoot& rRoot );
 
    void         SetTextData( const XclImpObjTextData& rTextData ) { maTextData = rTextData; }
 
protected:
    virtual void        DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const override;
    virtual void        DoPreProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const override;
 
protected:
    XclImpObjTextData   maTextData;     
};
 
class XclImpChartObj : public XclImpRectObj
{
public:
    explicit            XclImpChartObj( const XclImpRoot& rRoot, bool bOwnTab = false );
 
    void                ReadChartSubStream( XclImpStream& rStrm );
 
protected:
    virtual void        DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize ) override;
    virtual std::size_t DoGetProgressSize() const override;
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const override;
    virtual void        DoPostProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const override;
 
private:
    void                FinalizeTabChart();
 
private:
    typedef std::shared_ptr< XclImpChart > XclImpChartRef;
 
    XclImpChartRef      mxChart;        
    bool                mbOwnTab;       
};
 
class XclImpNoteObj : public XclImpTextObj
{
public:
    explicit            XclImpNoteObj( const XclImpRoot& rRoot );
 
    void                SetNoteData( const ScAddress& rScPos, sal_uInt16 nNoteFlags );
 
protected:
    virtual void        DoPreProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const override;
 
private:
    ScAddress           maScPos;        
    sal_uInt16          mnNoteFlags;    
};
 
class XclImpControlHelper
{
public:
    explicit            XclImpControlHelper( const XclImpRoot& rRoot, XclCtrlBindMode eBindMode );
    virtual             ~XclImpControlHelper();
 
    bool         HasCellLink() const { return mxCellLink != nullptr; }
 
    rtl::Reference<SdrObject>        CreateSdrObjectFromShape(
                            const css::uno::Reference< css::drawing::XShape >& rxShape,
                            const tools::Rectangle& rAnchorRect ) const;
 
    void                ProcessControl( const XclImpDrawObjBase& rDrawObj ) const;
    void SetStringProperty(const OUString& sName, const OUString& sVal);
 
protected:
    void                ReadCellLinkFormula( XclImpStream& rStrm, bool bWithBoundSize );
    void                ReadSourceRangeFormula( XclImpStream& rStrm, bool bWithBoundSize );
 
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const;
 
    void ApplySheetLinkProps() const;
    mutable css::uno::Reference< css::drawing::XShape >
                                   mxShape;        
    std::shared_ptr< ScAddress > mxCellLink;     
private:
    void                ReadRangeList( ScRangeList& rScRanges, XclImpStream& rStrm );
    void                ReadRangeList( ScRangeList& rScRanges, XclImpStream& rStrm, bool bWithBoundSize );
 
private:
    const XclImpRoot&            mrRoot;     
    std::shared_ptr< ScRange >   mxSrcRange; 
    XclCtrlBindMode              meBindMode; 
};
 
class XclImpTbxObjBase : public XclImpTextObj, public XclImpControlHelper
{
public:
    explicit            XclImpTbxObjBase( const XclImpRoot& rRoot );
 
    void                SetDffProperties( const DffPropSet& rDffPropSet );
 
    OUString GetServiceName() const { return DoGetServiceName(); }
    bool                FillMacroDescriptor(
                            css::script::ScriptEventDescriptor& rDescriptor ) const;
 
protected:
    void                ConvertFont( ScfPropertySet& rPropSet ) const;
    void                ConvertLabel( ScfPropertySet& rPropSet ) const;
 
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const override;
    virtual void        DoPreProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const override;
 
    virtual OUString DoGetServiceName() const = 0;
    virtual XclTbxEventType DoGetEventType() const = 0;
};
 
class XclImpButtonObj : public XclImpTbxObjBase
{
public:
    explicit            XclImpButtonObj( const XclImpRoot& rRoot );
 
protected:
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
};
 
class XclImpCheckBoxObj : public XclImpTbxObjBase
{
public:
    explicit            XclImpCheckBoxObj( const XclImpRoot& rRoot );
 
protected:
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize ) override;
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
 
protected:
    sal_uInt16          mnState;
    sal_uInt16          mnCheckBoxFlags;
};
 
class XclImpOptionButtonObj final : public XclImpCheckBoxObj
{
public:
    explicit            XclImpOptionButtonObj( const XclImpRoot& rRoot );
    bool IsInGroup() const;
 
private:
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize ) override;
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
 
    sal_uInt16          mnNextInGroup;      
    sal_uInt16          mnFirstInGroup;     
};
 
class XclImpLabelObj : public XclImpTbxObjBase
{
public:
    explicit            XclImpLabelObj( const XclImpRoot& rRoot );
 
protected:
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
};
 
class XclImpGroupBoxObj final : public XclImpTbxObjBase
{
public:
    explicit            XclImpGroupBoxObj( const XclImpRoot& rRoot );
 
private:
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize ) override;
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
 
    sal_uInt16          mnGroupBoxFlags;
};
 
class XclImpDialogObj : public XclImpTbxObjBase
{
public:
    explicit            XclImpDialogObj( const XclImpRoot& rRoot );
 
protected:
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
};
 
class XclImpEditObj final : public XclImpTbxObjBase
{
public:
    explicit            XclImpEditObj( const XclImpRoot& rRoot );
 
private:
    bool                IsNumeric() const;
 
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize ) override;
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
 
    sal_uInt16          mnContentType;
    sal_uInt16          mnMultiLine;
    sal_uInt16          mnScrollBar;
    sal_uInt16          mnListBoxObjId;
};
 
class XclImpTbxObjScrollableBase : public XclImpTbxObjBase
{
public:
    explicit            XclImpTbxObjScrollableBase( const XclImpRoot& rRoot );
 
protected:
    void                ReadSbs( XclImpStream& rStrm );
 
    virtual void        DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize ) override;
 
protected:
    sal_uInt16          mnValue;
    sal_uInt16          mnMin;
    sal_uInt16          mnMax;
    sal_uInt16          mnStep;
    sal_uInt16          mnPageStep;
    sal_uInt16          mnOrient;
    sal_uInt16          mnThumbWidth;
    sal_uInt16          mnScrollFlags;
};
 
class XclImpSpinButtonObj : public XclImpTbxObjScrollableBase
{
public:
    explicit            XclImpSpinButtonObj( const XclImpRoot& rRoot );
 
protected:
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
};
 
class XclImpScrollBarObj : public XclImpTbxObjScrollableBase
{
public:
    explicit            XclImpScrollBarObj( const XclImpRoot& rRoot );
 
protected:
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
};
 
class XclImpTbxObjListBase : public XclImpTbxObjScrollableBase
{
public:
    explicit            XclImpTbxObjListBase( const XclImpRoot& rRoot );
 
protected:
    void                ReadLbsData( XclImpStream& rStrm );
    void                SetBoxFormatting( ScfPropertySet& rPropSet ) const;
 
protected:
    sal_uInt16          mnEntryCount;
    sal_uInt16          mnSelEntry;
    sal_uInt16          mnListFlags;
    sal_uInt16          mnEditObjId;
    bool                mbHasDefFontIdx;
};
 
class XclImpListBoxObj final : public XclImpTbxObjListBase
{
public:
    explicit            XclImpListBoxObj( const XclImpRoot& rRoot );
 
private:
    void                ReadFullLbsData( XclImpStream& rStrm, std::size_t nRecLeft );
 
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize ) override;
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
 
    ScfUInt8Vec         maSelection;
};
 
class XclImpDropDownObj final : public XclImpTbxObjListBase
{
public:
    explicit            XclImpDropDownObj( const XclImpRoot& rRoot );
 
private:
    sal_uInt16          GetDropDownType() const;
 
    void                ReadFullLbsData( XclImpStream& rStrm );
 
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize ) override;
    virtual void        DoProcessControl( ScfPropertySet& rPropSet ) const override;
    virtual OUString DoGetServiceName() const override;
    virtual XclTbxEventType DoGetEventType() const override;
 
    sal_uInt16          mnLeft;
    sal_uInt16          mnTop;
    sal_uInt16          mnRight;
    sal_uInt16          mnBottom;
    sal_uInt16          mnDropDownFlags;
    sal_uInt16          mnLineCount;
    sal_uInt16          mnMinWidth;
};
 
class XclImpPictureObj : public XclImpRectObj, public XclImpControlHelper
{
public:
    explicit            XclImpPictureObj( const XclImpRoot& rRoot );
    virtual OUString GetObjName() const override;
    const Graphic& GetGraphic() const { return maGraphic; }
 
    bool         IsSymbol() const { return mbSymbol; }
    OUString            GetOleStorageName() const;
 
    bool         IsOcxControl() const { return mbEmbedded && mbControl && mbUseCtlsStrm; }
    std::size_t  GetCtlsStreamPos() const { return mnCtlsStrmPos; }
    std::size_t  GetCtlsStreamSize() const { return mnCtlsStrmSize; }
 
protected:
    virtual void        DoReadObj3( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj4( XclImpStream& rStrm, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj5( XclImpStream& rStrm, sal_uInt16 nNameLen, sal_uInt16 nMacroSize ) override;
    virtual void        DoReadObj8SubRec( XclImpStream& rStrm, sal_uInt16 nSubRecId, sal_uInt16 nSubRecSize ) override;
    virtual rtl::Reference<SdrObject> DoCreateSdrObj( XclImpDffConverter& rDffConv, const tools::Rectangle& rAnchorRect ) const override;
    virtual void        DoPreProcessSdrObj( XclImpDffConverter& rDffConv, SdrObject& rSdrObj ) const override;
 
private:
    void                ReadFlags3( XclImpStream& rStrm );
    void                ReadFlags8( XclImpStream& rStrm );
    void                ReadPictFmla( XclImpStream& rStrm, sal_uInt16 nLinkSize );
 
private:
    Graphic             maGraphic;      
    OUString            maClassName;    
    sal_uInt32          mnStorageId;    
    std::size_t         mnCtlsStrmPos;  
    std::size_t         mnCtlsStrmSize; 
    bool                mbEmbedded;     
    bool                mbLinked;       
    bool                mbSymbol;       
    bool                mbControl;      
    bool                mbUseCtlsStrm;  
};
 
// DFF stream conversion ======================================================
 
class XclImpSolverContainer : public SvxMSDffSolverContainer
{
public:
 
    void                InsertSdrObjectInfo( SdrObject& rSdrObj, sal_uInt32 nDffShapeId, ShapeFlag nDffFlags );
    void                RemoveSdrObjectInfo( SdrObject& rSdrObj );
 
    void                UpdateConnectorRules();
    void                RemoveConnectorRules();
 
private:
    void                UpdateConnection( sal_uInt32 nDffShapeId, SdrObject*& rpSdrObj, ShapeFlag* pnDffFlags = nullptr );
 
private:
    struct XclImpSdrInfo
    {
        SdrObject*          mpSdrObj;       
        ShapeFlag           mnDffFlags;     
        explicit     XclImpSdrInfo() : mpSdrObj( nullptr ), mnDffFlags( ShapeFlag::NONE ) {}
        void         Set( SdrObject* pSdrObj, ShapeFlag nDffFlags )
                                { mpSdrObj = pSdrObj; mnDffFlags = nDffFlags; }
    };
    typedef std::map< sal_uInt32, XclImpSdrInfo > XclImpSdrInfoMap;
    typedef std::map< SdrObject*, sal_uInt32 >    XclImpSdrObjMap;
 
    XclImpSdrInfoMap    maSdrInfoMap;   
    XclImpSdrObjMap     maSdrObjMap;    
};
 
class XclImpSimpleDffConverter : public SvxMSDffManager, protected XclImpRoot
{
public:
    explicit            XclImpSimpleDffConverter( const XclImpRoot& rRoot, SvStream& rDffStrm );
    virtual             ~XclImpSimpleDffConverter() override;
 
protected:
    virtual bool        GetColorFromPalette( sal_uInt16 nIndex, Color& rColor ) const override;
};
 
class XclImpDffConverter : public XclImpSimpleDffConverter, private oox::ole::MSConvertOCXControls
{
public:
    explicit            XclImpDffConverter( const XclImpRoot& rRoot, SvStream& rDffStrm );
    virtual             ~XclImpDffConverter() override;
 
    void                StartProgressBar( std::size_t nProgressSize );
    void                Progress( std::size_t nDelta = 1 );
 
    void                InitializeDrawing( XclImpDrawing& rDrawing, SdrModel& rSdrModel, SdrPage& rSdrPage );
    void                ProcessObject( SdrObjList& rObjList, XclImpDrawObjBase& rDrawObj );
    void                ProcessDrawing( const XclImpDrawObjVector& rDrawObjs );
    void                ProcessDrawing( SvStream& rDffStrm );
    void                FinalizeDrawing();
 
    rtl::Reference<SdrObject>        CreateSdrObject( const XclImpTbxObjBase& rTbxObj, const tools::Rectangle& rAnchorRect );
    rtl::Reference<SdrObject>        CreateSdrObject( const XclImpPictureObj& rPicObj, const tools::Rectangle& rAnchorRect );
 
    bool                SupportsOleObjects() const;
    sal_Int32    GetDefaultTextMargin() const { return mnDefTextMargin; }
 
private:
    // virtual functions of SvxMSDffManager
 
    virtual void        ProcessClientAnchor2(
                            SvStream& rDffStrm,
                            DffRecordHeader& rHeader,
                            DffObjData& rObjData ) override;
    virtual rtl::Reference<SdrObject>  ProcessObj(
                            SvStream& rDffStrm,
                            DffObjData& rDffObjData,
                            SvxMSDffClientData& rClientData,
                            tools::Rectangle& rTextRect,
                            SdrObject* pOldSdrObj ) override;
 
    virtual SdrObject*  FinalizeObj(
                            DffObjData& rDffObjData,
                            SdrObject* pOldSdrObj ) override;
 
    // virtual functions of SvxMSConvertOCXControls
 
    virtual bool    InsertControl(
                            const css::uno::Reference<
                                css::form::XFormComponent >& rxFormComp,
                            const css::awt::Size& rSize,
                            css::uno::Reference<
                                css::drawing::XShape >* pxShape,
                            bool bFloatingCtrl ) override;
 
private:
    struct XclImpDffConvData
    {
        XclImpDrawing&      mrDrawing;          
        SdrModel&           mrSdrModel;         
        SdrPage&            mrSdrPage;          
        XclImpSolverContainer maSolverCont;     
        css::uno::Reference< css::form::XForm >
                            mxCtrlForm;         
        sal_Int32           mnLastCtrlIndex;    
        bool                mbHasCtrlForm;      
 
        explicit            XclImpDffConvData( XclImpDrawing& rDrawing,
                                SdrModel& rSdrModel, SdrPage& rSdrPage );
    };
 
    XclImpDffConvData&      GetConvData();
    const XclImpDffConvData& GetConvData() const;
 
    OUString            ReadHlinkProperty( SvStream& rDffStrm ) const;
 
    bool                ProcessDgContainer( SvStream& rDffStrm, const DffRecordHeader& rDgHeader );
    bool                ProcessShGrContainer( SvStream& rDffStrm, const DffRecordHeader& rShGrHeader );
    bool                ProcessSolverContainer( SvStream& rDffStrm, const DffRecordHeader& rSolverHeader );
    bool                ProcessShContainer( SvStream& rDffStrm, const DffRecordHeader& rShHeader );
 
    void                InsertSdrObject( SdrObjList& rObjList, const XclImpDrawObjBase& rDrawObj, SdrObject* pSdrObj );
    void                InitControlForm();
    void                NotifyMacroEventRead();
 
private:
    typedef std::shared_ptr< ScfProgressBar >     ScfProgressBarRef;
    typedef std::shared_ptr< XclImpDffConvData >  XclImpDffConvDataRef;
 
    tools::SvRef<SotStorageStream> mxCtlsStrm;         
    ScfProgressBarRef   mxProgress;         
    std::vector< XclImpDffConvDataRef >
                        maDataStack;     
    sal_uInt32          mnOleImpFlags;      
    sal_Int32           mnDefTextMargin;    
    bool mbNotifyMacroEventRead;            
};
 
// Drawing manager ============================================================
 
class XclImpDrawing : protected XclImpRoot
{
public:
    explicit            XclImpDrawing( const XclImpRoot& rRoot, bool bOleObjects );
    virtual             ~XclImpDrawing() override;
 
    static Graphic      ReadImgData( const XclImpRoot& rRoot, XclImpStream& rStrm );
 
    void                ReadObj( XclImpStream& rStrm );
    void                ReadMsoDrawing( XclImpStream& rStrm );
 
    bool         SupportsOleObjects() const { return mbOleObjs; }
    XclImpDrawObjRef    FindDrawObj( const DffRecordHeader& rHeader ) const;
    XclImpDrawObjRef    FindDrawObj( sal_uInt16 nObjId ) const;
    const XclImpObjTextData* FindTextData( const DffRecordHeader& rHeader ) const;
 
    void ApplyGroupBoxes();
 
    void                SetSkipObj( sal_uInt16 nObjId );
    std::size_t         GetProgressSize() const;
 
    virtual tools::Rectangle   CalcAnchorRect( const XclObjAnchor& rAnchor, bool bDffAnchor ) const = 0;
    virtual void        OnObjectInserted( const XclImpDrawObjBase& rDrawObj ) = 0;
 
protected:
    void                AppendRawObject( const XclImpDrawObjRef& rxDrawObj );
    void                ImplConvertObjects( XclImpDffConverter& rDffConv, SdrModel& rSdrModel, SdrPage& rSdrPage );
 
private:
    static void         ReadWmf( Graphic& rGraphic, XclImpStream& rStrm );
    static void         ReadBmp( Graphic& rGraphic, const XclImpRoot& rRoot, XclImpStream& rStrm );
 
    void                ReadDffRecord( XclImpStream& rStrm );
    void                ReadObj8( XclImpStream& rStrm );
    void                ReadTxo( XclImpStream& rStrm );
 
private:
    typedef std::map< std::size_t, XclImpDrawObjRef > XclImpObjMap;
    typedef std::map< sal_uInt16, XclImpDrawObjRef >  XclImpObjMapById;
    typedef std::shared_ptr< XclImpObjTextData >      XclImpObjTextRef;
    typedef std::map< std::size_t, XclImpObjTextRef > XclImpObjTextMap;
 
    XclImpDrawObjVector maRawObjs;          
    SvMemoryStream      maDffStrm;          
    XclImpObjMap        maObjMap;           
    XclImpObjMapById    maObjMapId;         
    XclImpObjTextMap    maTextMap;          
    ScfUInt16Vec        maSkipObjs;         
    bool                mbOleObjs;          
};
 
class XclImpSheetDrawing : public XclImpDrawing
{
public:
    explicit            XclImpSheetDrawing( const XclImpRoot& rRoot, SCTAB nScTab );
 
    void                ReadNote( XclImpStream& rStrm );
    void                ReadTabChart( XclImpStream& rStrm );
 
    const ScRange& GetUsedArea() const { return maScUsedArea; }
    void                ConvertObjects( XclImpDffConverter& rDffConv );
 
    virtual tools::Rectangle   CalcAnchorRect( const XclObjAnchor& rAnchor, bool bDffAnchor ) const override;
    virtual void        OnObjectInserted( const XclImpDrawObjBase& rDrawObj ) override;
 
private:
    void                ReadNote3( XclImpStream& rStrm );
    void                ReadNote8( XclImpStream& rStrm );
 
private:
    ScRange             maScUsedArea;       
};
 
// The object manager =========================================================
 
class XclImpObjectManager : protected XclImpRoot
{
public:
    explicit            XclImpObjectManager( const XclImpRoot& rRoot );
    virtual             ~XclImpObjectManager() override;
 
    void                ReadMsoDrawingGroup( XclImpStream& rStrm );
 
    XclImpSheetDrawing& GetSheetDrawing( SCTAB nScTab );
    void                ConvertObjects();
 
    OUString       GetDefaultObjName( const XclImpDrawObjBase& rDrawObj ) const;
    ScRange             GetUsedArea( SCTAB nScTab ) const;
    void SetOleNameOverrideInfo( const css::uno::Reference< css::container::XNameContainer >& rxOverrideInfo ) {  mxOleCtrlNameOverride = rxOverrideInfo; }
    OUString GetOleNameOverride( SCTAB nTab, sal_uInt16 nObjId );
 
private:
    typedef std::map< sal_uInt16, OUString >          DefObjNameMap;
    typedef std::shared_ptr< XclImpSheetDrawing >     XclImpSheetDrawingRef;
    typedef std::map< SCTAB, XclImpSheetDrawingRef >  XclImpSheetDrawingMap;
 
    css::uno::Reference< css::container::XNameContainer > mxOleCtrlNameOverride;
    DefObjNameMap       maDefObjNames;      
    SvMemoryStream      maDggStrm;          
    XclImpSheetDrawingMap maSheetDrawings;  
};
 
// DFF property set helper ====================================================
 
class XclImpDffPropSet : protected XclImpRoot
{
public:
    explicit            XclImpDffPropSet( const XclImpRoot& rRoot );
 
    void                Read( XclImpStream& rStrm );
 
    sal_uInt32          GetPropertyValue( sal_uInt16 nPropId ) const;
 
    void                FillToItemSet( SfxItemSet& rItemSet ) const;
 
private:
    typedef std::unique_ptr<SvMemoryStream> SvMemoryStreamPtr;
 
    SvMemoryStream      maDummyStrm;    
    XclImpSimpleDffConverter maDffConv; 
    SvMemoryStreamPtr   mxMemStrm;      
};
 
XclImpStream& operator>>( XclImpStream& rStrm, XclImpDffPropSet& rPropSet );
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */