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 <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 <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, SwPosition aPos);
        Frame(const Graphic&, 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.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)
        {
            assert(dynamic_cast<const T *>(&rItem) && "bad type cast");
            return static_cast<const T &>(rItem);
        }
 
        template<class T> const T * item_cast(const SfxPoolItem *pItem)
        {
            return dynamic_cast<const T *>(pItem);
        }
 
        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 );
 
        void DeduplicateItems(ww8::PoolItems &rItems);
 
        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: */