ReactionView2D.hpp

Go to the documentation of this file.

/* 
 * ReactionView2D.hpp 
 *
 * This file is part of the Chemical Data Processing Toolkit
 *
 * Copyright (C) 2003 Thomas Seidel <thomas.seidel@univie.ac.at>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; see the file COPYING. If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
 
#ifndef CDPL_VIS_REACTIONVIEW2D_HPP
#define CDPL_VIS_REACTIONVIEW2D_HPP
 
#include <vector>
#include <map>
#include <memory>
#include <cstddef>
 
#include "CDPL/Vis/APIPrefix.hpp"
#include "CDPL/Vis/View2D.hpp"
#include "CDPL/Vis/Rectangle2D.hpp"
#include "CDPL/Vis/Color.hpp"
#include "CDPL/Vis/SizeSpecification.hpp"
#include "CDPL/Vis/StructureView2D.hpp"
#include "CDPL/Vis/PolygonPrimitive2D.hpp"
#include "CDPL/Vis/LineSegmentListPrimitive2D.hpp"
#include "CDPL/Math/Vector.hpp"
#include "CDPL/Util/ObjectStack.hpp"
 
 
namespace CDPL
{
 
    namespace Chem
    {
 
        class Reaction;
        class Molecule;
    } // namespace Chem
 
    namespace Vis
    {
 
        class ReactionView2DParameters;
 
        class CDPL_VIS_API ReactionView2D : public View2D
        {
 
          public:
            typedef std::shared_ptr<ReactionView2D> SharedPointer;
 
            ReactionView2D(const Chem::Reaction* rxn = 0);
 
            ReactionView2D(const ReactionView2D&) = delete;
            
            ~ReactionView2D();
 
            ReactionView2D& operator=(const ReactionView2D&) = delete;
 
            void render(Renderer2D& renderer);
 
            void setFontMetrics(FontMetrics* font_metrics);
 
            FontMetrics* getFontMetrics() const;
 
            void setReaction(const Chem::Reaction* rxn);
 
            const Chem::Reaction* getReaction() const;
 
            void getModelBounds(Rectangle2D& bounds);
 
          private:
            void paintBackground(Renderer2D&) const;
 
            void renderComponents(Renderer2D&) const;
            void renderGraphicsPrimitives(Renderer2D&) const;
 
            void init();
 
            void initComponentViews();
            void initComponentBoundsTable();
            void layoutReaction();
            void calcOutputTransforms();
            void initComponentViewViewports();
            void createPlusSignPrimitives();
            void createArrowPrimitives();
 
            void createStdReactionArrow(bool);
 
            void layoutComponents(unsigned int, std::size_t, std::size_t);
            void createPackedComponentLayout(unsigned int, std::size_t, std::size_t);
            void createLinearComponentLayout(unsigned int, std::size_t, std::size_t);
            void createHLinearComponentLayout(unsigned int, std::size_t, std::size_t);
            void createVLinearComponentLayout(unsigned int, std::size_t, std::size_t);
 
            unsigned int getComponentLayout(unsigned int) const;
            unsigned int getComponentLayoutDirection(unsigned int) const;
 
            void shiftComponentPositions(std::size_t, std::size_t, const Math::Vector2D&);
            void shiftPlusSignPositions(std::size_t, std::size_t, const Math::Vector2D&);
 
            void calcArrowDimensions();
            void calcPlusSignDimensions();
 
            void freeComponentViews();
            void freeGraphicsPrimitives();
 
            void initArrowStyle();
            void initArrowLength();
 
            const Color&             getArrowColor() const;
            const SizeSpecification& getArrowHeadLength() const;
            const SizeSpecification& getArrowHeadWidth() const;
            const SizeSpecification& getArrowShaftWidth() const;
            const SizeSpecification& getArrowLineWidth() const;
 
            void initComponentLayout();
            void initComponentLayoutDirection();
            void initComponentMargin();
            void initComponentVisibility();
            void initAgentAlignment();
            void initAgentLayout();
            void initAgentLayoutDirection();
 
            const Color&             getPlusSignColor() const;
            const SizeSpecification& getPlusSignSize() const;
            const SizeSpecification& getPlusSignLineWidth() const;
 
            void initPlusSignVisibility();
 
            StructureView2D*            allocComponentView(const Chem::Molecule&);
            PolygonPrimitive2D*         allocPolygonPrimitive();
            LineSegmentListPrimitive2D* allocLineSegListPrimitive();
 
            typedef std::vector<StructureView2D*>                      ComponentViewList;
            typedef std::vector<const GraphicsPrimitive2D*>            GraphicsPrimitiveList;
            typedef std::map<const Chem::MolecularGraph*, Rectangle2D> ComponentBoundsMap;
            typedef std::vector<Math::Vector2D>                        Vector2DArray;
            typedef Util::ObjectStack<StructureView2D>                 ComponentViewCache;
            typedef Util::ObjectStack<PolygonPrimitive2D>              PolygonPrimitiveCache;
            typedef Util::ObjectStack<LineSegmentListPrimitive2D>      LineSegListPrimitiveCache;
            typedef std::unique_ptr<ReactionView2DParameters>            ReactionView2DParametersPtr;
 
            const Chem::Reaction*       reaction;
            ReactionView2DParametersPtr parameters;
            FontMetrics*                fontMetrics;
            ComponentViewList           componentViews;
            GraphicsPrimitiveList       drawList;
            Rectangle2D                 totalComponentBounds;
            Rectangle2D                 totalReactionBounds;
            ComponentBoundsMap          componentBounds;
            Vector2DArray               componentPositions;
            Vector2DArray               plusSignPositions;
            Math::Vector2D              arrowPosition;
            double                      unscaledArrowLength;
            double                      unscaledArrowHeadLength;
            double                      unscaledArrowHeadWidth;
            double                      unscaledArrowShaftWidth;
            double                      unscaledArrowLineWidth;
            double                      maxUnscaledArrowWidth;
            double                      unscaledPlusSignSize;
            double                      unscaledPlusSignLineWidth;
            double                      outputScalingFactor;
            Math::Vector2D              outputTranslation;
            unsigned int                arrowStyle;
            SizeSpecification           arrowLength;
            unsigned int                componentLayout;
            unsigned int                componentLayoutDirection;
            SizeSpecification           componentMargin;
            unsigned int                agentAlignment;
            unsigned int                agentLayout;
            unsigned int                agentLayoutDirection;
            bool                        showReactants;
            bool                        showAgents;
            bool                        showProducts;
            bool                        plusSignsVisible;
            bool                        reactionChanged;
            bool                        fontMetricsChanged;
            ComponentViewCache          compViewCache;
            PolygonPrimitiveCache       polygonCache;
            LineSegListPrimitiveCache   lineSegListCache;
        };
    } // namespace Vis
} // namespace CDPL
 
#endif // CDPL_VIS_REACTIONVIEW2D_HPP