writerhelper.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 .
 */

#ifndef INCLUDED_SW_SOURCE_FILTER_WW8_WRITERHELPER_HXX
#define INCLUDED_SW_SOURCE_FILTER_WW8_WRITERHELPER_HXX

#include <typeinfo>
#include <vector>
#include <map>
#include <com/sun/star/embed/XEmbeddedObject.hpp>

#include <sfx2/objsh.hxx>
#include <svl/itempool.hxx>
#include <svl/itemset.hxx>
#include <svx/svdtypes.hxx>
#include <format.hxx>
#include <node.hxx>
#include <pam.hxx>
#include <tools/poly.hxx>
#include <doc.hxx>
#include <vcl/graph.hxx>

class SwTextFormatColl;
class SwCharFormat;
class SdrObject;
class SdrOle2Obj;
class OutlinerParaObject;
class SwNumFormat;
class SwTextNode;
class SwNoTextNode;
class SwFormatCharFormat;
class SwDoc;
class SwNumRule;

namespace sw
{
    namespace util
    {
        class ItemSort
        {
        public:
            bool operator()(sal_uInt16 nA, sal_uInt16 nB) const;
        };
    }
}

namespace ww8
{
    typedef std::vector<SwTextFormatColl *> ParaStyles;
    typedef std::map<sal_uInt16, const SfxPoolItem *, sw::util::ItemSort> PoolItems;

    class Frame
    {
    public:
        enum WriterSource {eTextBox, eGraphic, eOle, eDrawing, eFormControl,eBulletGrf};
    private:
        const SwFrameFormat* mpFlyFrame;
        SwPosition maPos;
        Size maSize;
        // #i43447# - Size of the frame in the layout.
        // Especially needed for graphics, whose layout size can differ from its
        // size, because it is scaled into its environment.
        Size maLayoutSize;

        WriterSource meWriterType;
        const SwNode *mpStartFrameContent;
        bool mbIsInline;
        bool mbForBullet:1;
        Graphic maGrf;
    public:
        Frame(const SwFrameFormat &rFlyFrame, const SwPosition &rPos);
        Frame(const Graphic&, const SwPosition &);

        const SwFrameFormat &GetFrameFormat() const { return *mpFlyFrame; }

        const SwPosition &GetPosition() const { return maPos; }
        void SetPosition(SwPosition const& rPos) { maPos = rPos; }

        const SwContentNode *GetContentNode() const
            { return maPos.nNode.GetNode().GetContentNode(); }

        WriterSource GetWriterType() const { return meWriterType; }

        bool IsInline() const { return mbIsInline; }

        void ForceTreatAsInline();

        const SwNode *GetContent() const { return mpStartFrameContent; }
        const Graphic &GetGraphic() const { return maGrf; }
        bool HasGraphic() const { return mbForBullet; }

        bool RefersToSameFrameAs(const Frame &rOther) const
        {
            if (mbForBullet && rOther.mbForBullet)
                return (maGrf == rOther.maGrf);
            else if ((!mbForBullet) && (!rOther.mbForBullet))
                return (mpFlyFrame == rOther.mpFlyFrame);

            return false;
        }

        const Size& GetSize() const { return maSize; }

        const Size& GetLayoutSize() const
        {
            return maLayoutSize;
        }
    };

    typedef std::vector<Frame> Frames;
    typedef std::vector<Frame>::iterator FrameIter;
}

namespace sw
{
    namespace util
    {
        template<class T> const T & item_cast(const SfxPoolItem &rItem)
        {
            if (dynamic_cast<const T *>(&rItem) == nullptr)
                throw std::bad_cast();
            return static_cast<const T &>(rItem);
        }

        template<class T> const T * item_cast(const SfxPoolItem *pItem)
        {
            return dynamic_cast<const T *>(pItem);
        }

        template<class T> const T & ItemGet(const SwContentNode &rNode,
            sal_uInt16 eType)
        {
            return item_cast<T>(rNode.GetAttr(eType));
        }

        template<class T> const T & ItemGet(const SwFormat &rFormat,
            sal_uInt16 eType)
        {
            return item_cast<T>(rFormat.GetFormatAttr(eType));
        }

        template<class T> const T & ItemGet(const SfxItemSet &rSet,
            sal_uInt16 eType)
        {
            return item_cast<T>(rSet.Get(eType));
        }

        template<class T> const T & DefaultItemGet(const SfxItemPool &rPool,
            sal_uInt16 eType)
        {
            return item_cast<T>(rPool.GetDefaultItem(eType));
        }

        template<class T> const T & DefaultItemGet(const SwDoc &rDoc,
            sal_uInt16 eType)
        {
            return DefaultItemGet<T>(rDoc.GetAttrPool(), eType);
        }

        ww8::ParaStyles GetParaStyles(const SwDoc &rDoc);

        SwTextFormatColl* GetParaStyle(SwDoc &rDoc, const OUString& rName);

        SwCharFormat* GetCharStyle(SwDoc &rDoc, const OUString& rName);

        void SortByAssignedOutlineStyleListLevel(ww8::ParaStyles &rStyles);

        void GetPoolItems(const SfxItemSet &rSet, ww8::PoolItems &rItems, bool bExportParentItemSet );

        const SfxPoolItem *SearchPoolItems(const ww8::PoolItems &rItems,
            sal_uInt16 eType);

        template<class T> const T* HasItem(const ww8::PoolItems &rItems,
            sal_uInt16 eType)
        {
            return item_cast<T>(SearchPoolItems(rItems, eType));
        }

        void ClearOverridesFromSet(const SwFormatCharFormat &rFormat, SfxItemSet &rSet);

        ww8::Frames GetFrames(const SwDoc &rDoc, SwPaM const *pPaM);

        void UpdateFramePositions(ww8::Frames & rFrames);

        ww8::Frames GetFramesInNode(const ww8::Frames &rFrames, const SwNode &rNode);

        const SwNumFormat* GetNumFormatFromTextNode(const SwTextNode &rTextNode);

        const SwNumFormat* GetNumFormatFromSwNumRuleLevel(const SwNumRule &rRule,
            int nLevel);

        const SwNumRule* GetNumRuleFromTextNode(const SwTextNode &rTextNd);
        const SwNumRule* GetNormalNumRuleFromTextNode(const SwTextNode &rTextNd);

        SwNoTextNode *GetNoTextNodeFromSwFrameFormat(const SwFrameFormat &rFormat);

        bool HasPageBreak(const SwNode &rNode);

        tools::Polygon PolygonFromPolyPolygon(const tools::PolyPolygon &rPolyPoly);

        tools::Polygon CorrectWordWrapPolygonForExport(const tools::PolyPolygon& rPolyPoly, const SwNoTextNode* pNd, bool bCorrectCrop);

        class SetLayer
        {
        private:
            SdrLayerID mnHeavenLayer, mnHellLayer, mnFormLayer;
            enum Layer {eHeaven, eHell};
            void SetObjectLayer(SdrObject &rObject, Layer eLayer) const;
        public:

            void SendObjectToHell(SdrObject &rObject) const;

            void SendObjectToHeaven(SdrObject &rObject) const;

            explicit SetLayer(const SwDoc &rDoc);
        };

        const SwCharFormat* GetSwCharFormat(const SwFormatINetFormat& rINet, SwDoc& rDoc);
    }

    namespace hack
    {
        sal_uInt16 TransformWhichBetweenPools(const SfxItemPool &rDestPool,
            const SfxItemPool &rSrcPool, sal_uInt16 nWhich);

        sal_uInt16 GetSetWhichFromSwDocWhich(const SfxItemSet &rSet,
            const SwDoc &rDoc, sal_uInt16 nWhich);

        class DrawingOLEAdaptor
        {
        private:
            css::uno::Reference < css::embed::XEmbeddedObject > mxIPRef;
            SfxObjectShell& mrPers;
            const Graphic* mpGraphic;
        public:
            DrawingOLEAdaptor(SdrOle2Obj &rObj, SfxObjectShell &rPers);

            ~DrawingOLEAdaptor();

            bool TransferToDoc(OUString &rName);
        private:
            DrawingOLEAdaptor& operator=(const DrawingOLEAdaptor&) = delete;
            DrawingOLEAdaptor(const DrawingOLEAdaptor &rDoc) = delete;
        };
    }
}

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */