baseprimitive3d.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_DRAWINGLAYER_PRIMITIVE3D_BASEPRIMITIVE3D_HXX
#define INCLUDED_DRAWINGLAYER_PRIMITIVE3D_BASEPRIMITIVE3D_HXX
 
#include <drawinglayer/drawinglayerdllapi.h>
 
#include <comphelper/compbase.hxx>
#include <cppuhelper/basemutex.hxx>
#include <com/sun/star/graphic/XPrimitive3D.hpp>
#include <basegfx/range/b3drange.hxx>
#include <deque>
 
 
#define DeclPrimitive3DIDBlock() \
    virtual sal_uInt32 getPrimitive3DID() const override;
 
#define ImplPrimitive3DIDBlock(TheClass, TheID) \
    sal_uInt32 TheClass::getPrimitive3DID() const { return TheID; }
 
 
// predefines
 
namespace drawinglayer::geometry {
    class ViewInformation3D;
}
 
namespace drawinglayer::primitive3d {
    typedef comphelper::WeakComponentImplHelper< css::graphic::XPrimitive3D > BasePrimitive3DImplBase;
    typedef css::uno::Reference< css::graphic::XPrimitive3D > Primitive3DReference;
 
    class SAL_WARN_UNUSED DRAWINGLAYER_DLLPUBLIC Primitive3DContainer : public std::deque< Primitive3DReference >
    {
    public:
        explicit Primitive3DContainer() {}
        explicit Primitive3DContainer( size_type count ) : deque(count) {}
        Primitive3DContainer( const Primitive3DContainer& other ) : deque(other) {}
        Primitive3DContainer( Primitive3DContainer&& other ) noexcept : deque(std::move(other)) {}
        Primitive3DContainer( std::initializer_list<Primitive3DReference> init ) : deque(init) {}
        template <class Iter>
        Primitive3DContainer(Iter first, Iter last) : deque(first, last) {}
 
        void append(const Primitive3DContainer& rSource);
        Primitive3DContainer& operator=(const Primitive3DContainer& r) { deque::operator=(r); return *this; }
        Primitive3DContainer& operator=(Primitive3DContainer&& r) noexcept { deque::operator=(std::move(r)); return *this; }
        bool operator==(const Primitive3DContainer& rB) const;
        bool operator!=(const Primitive3DContainer& rB) const { return !operator==(rB); }
        basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& aViewInformation) const;
    };
}
 
 
// basePrimitive3D class
 
namespace drawinglayer::primitive3d
    {
        class DRAWINGLAYER_DLLPUBLIC BasePrimitive3D
        :   public BasePrimitive3DImplBase
        {
            BasePrimitive3D(const BasePrimitive3D&) = delete;
            BasePrimitive3D& operator=( const BasePrimitive3D& ) = delete;
        public:
            // constructor/destructor
            BasePrimitive3D();
            virtual ~BasePrimitive3D() override;
 
            virtual bool operator==( const BasePrimitive3D& rPrimitive ) const;
            bool operator!=( const BasePrimitive3D& rPrimitive ) const { return !operator==(rPrimitive); }
 
            virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const;
 
            virtual sal_uInt32 getPrimitive3DID() const = 0;
 
            virtual Primitive3DContainer get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
 
            // Methods from XPrimitive3D
 
 
            virtual css::uno::Sequence< ::css::uno::Reference< ::css::graphic::XPrimitive3D > > SAL_CALL getDecomposition( const css::uno::Sequence< css::beans::PropertyValue >& rViewParameters ) override;
 
            virtual css::geometry::RealRectangle3D SAL_CALL getRange( const css::uno::Sequence< css::beans::PropertyValue >& rViewParameters ) override;
        };
 
} // end of namespace drawinglayer::primitive2d
 
 
// BufferedDecompositionPrimitive3D class
 
namespace drawinglayer::primitive3d
    {
        class DRAWINGLAYER_DLLPUBLIC BufferedDecompositionPrimitive3D
        :   public BasePrimitive3D
        {
        private:
            Primitive3DContainer                             maBuffered3DDecomposition;
 
        protected:
            const Primitive3DContainer& getBuffered3DDecomposition() const { return maBuffered3DDecomposition; }
            void setBuffered3DDecomposition(const Primitive3DContainer& rNew) { maBuffered3DDecomposition = rNew; }
 
            virtual Primitive3DContainer create3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const;
 
        public:
            // constructor
            BufferedDecompositionPrimitive3D();
 
            virtual Primitive3DContainer get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const override;
        };
 
} // end of namespace drawinglayer::primitive3d
 
 
// tooling
 
namespace drawinglayer::primitive3d
    {
        basegfx::B3DRange DRAWINGLAYER_DLLPUBLIC getB3DRangeFromPrimitive3DReference(const Primitive3DReference& rCandidate, const geometry::ViewInformation3D& aViewInformation);
 
        bool DRAWINGLAYER_DLLPUBLIC arePrimitive3DReferencesEqual(const Primitive3DReference& rA, const Primitive3DReference& rB);
 
} // end of namespace drawinglayer::primitive3d
 
 
#endif //INCLUDED_DRAWINGLAYER_PRIMITIVE3D_BASEPRIMITIVE3D_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */