StructureGridView2D.hpp

Go to the documentation of this file.

/* 
 * StructureGridView2D.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_STRUCTUREGRIDVIEW2D_HPP
#define CDPL_VIS_STRUCTUREGRIDVIEW2D_HPP
 
#include <memory>
#include <utility>
#include <cstddef>
#include <iosfwd>
#include <iterator>
 
#include <boost/unordered_map.hpp>
 
#include "CDPL/Config.hpp"
#include "CDPL/Vis/APIPrefix.hpp"
#include "CDPL/Vis/StructureView2D.hpp"
#include "CDPL/Vis/TextBlockPrimitive2D.hpp"
#include "CDPL/Vis/Alignment.hpp"
#include "CDPL/Chem/BasicMolecule.hpp"
#include "CDPL/Math/Vector.hpp"
#include "CDPL/Util/ObjectPool.hpp"
 
 
namespace CDPL
{
 
    namespace Base
    {
 
        class DataFormat;
    }
    
    namespace Vis
    {
 
        class CDPL_VIS_API StructureGridView2D : public View2D
        {
 
          public:
            static constexpr double DEF_CELL_WIDTH  = 250.0;
 
            static constexpr double DEF_CELL_HEIGHT = 250.0;
            
            typedef std::shared_ptr<StructureGridView2D> SharedPointer;
 
            class CDPL_VIS_API Cell : public Base::ControlParameterContainer
            {
 
              public:
                typedef std::shared_ptr<Cell> SharedPointer;
 
                static constexpr unsigned int DEF_TEXT_POSITION = Alignment::BOTTOM | Alignment::H_CENTER;
                
                Cell(const Cell&) = delete;
 
                void setStructure(const Chem::MolecularGraph& molgraph);
 
                const Chem::MolecularGraph& getStructure() const;
 
                void clearStructure();
 
                bool hasStructure() const;
 
                void setText(const std::string& text, unsigned int pos = DEF_TEXT_POSITION,
                             unsigned int line_almnt = Alignment::NONE);
 
                const std::string& getText(unsigned int pos = DEF_TEXT_POSITION) const;
 
                void clearText(unsigned int pos = DEF_TEXT_POSITION);
 
                bool hasText(unsigned int pos = DEF_TEXT_POSITION) const;
 
                void clearAllText();
 
                bool hasAnyText() const;
 
                Cell& operator=(const Cell& cell);
                
              private:
                friend class StructureGridView2D;
                
                Cell();
                ~Cell();
                
                void setFontMetrics(FontMetrics* font_metrics);
 
                void setSize(double width, double height);
                
                void parameterChanged(const Base::LookupKey& key, const Base::Any& value);
                void parameterRemoved(const Base::LookupKey& key);
                void parentChanged();
                
                void layout();
                void render(Renderer2D& renderer);
 
                static std::size_t posToArrayIndex(unsigned int pos);
                    
                StructureView2D      structView;
                TextBlockPrimitive2D textBlocks[9];
                Chem::BasicMolecule  molecule;
                FontMetrics*         fontMetrics;
                double               width;
                double               height;
                bool                 layoutValid;
            };
            
            StructureGridView2D();
 
            StructureGridView2D(const StructureGridView2D& grid_view);
            
            ~StructureGridView2D();
 
            void render(Renderer2D& renderer);
 
#ifdef HAVE_CAIRO
 
            bool write(const std::string& file_name);
 
            bool write(const std::string& file_name, const std::string& fmt);
 
            bool write(const std::string& file_name, const Base::DataFormat& fmt);
 
            bool write(std::ostream& os, const std::string& fmt);
 
            bool write(std::ostream& os, const Base::DataFormat& fmt);
 
#endif // HAVE_CAIRO
            
            void setFontMetrics(FontMetrics* font_metrics);
 
            FontMetrics* getFontMetrics() const;
 
            void getModelBounds(Rectangle2D& bounds);
 
            Cell& operator()(std::size_t row, std::size_t col);
 
            const Cell& operator()(std::size_t row, std::size_t col) const;
 
            void setCellSize(double width, double height);
 
            double getCellWidth() const;
 
            double getCellHeight() const;
 
            void resize(std::size_t num_rows, std::size_t num_cols);
 
            std::size_t getNumRows() const;
 
            std::size_t getNumColumns() const;
 
            void clearStructures();
 
            void clearAllText();
 
            StructureGridView2D& operator=(const StructureGridView2D& grid_view);
            
          private:
            typedef Util::ObjectPool<Cell>         CellCache;
            typedef CellCache::SharedObjectPointer CellPointer;
 
            void copy(const StructureGridView2D& grid_view);
 
            void getGridPosition(Math::Vector2D& pos);
            
            CellPointer allocCell();
                
            static Cell* newCell();
            static void deleteCell(Cell* cell);
            static void cleanupCell(Cell& cell);
 
            typedef std::pair<std::size_t, std::size_t>               CellID;
            typedef boost::unordered_map<CellID, Cell::SharedPointer> CellMap;
 
            CellCache    cellCache;
            FontMetrics* fontMetrics;
            CellMap      cells;
            double       cellWidth;
            double       cellHeight;
            std::size_t  numRows;
            std::size_t  numColumns;
        };
    } // namespace Vis
} // namespace CDPL
 
#endif // CDPL_VIS_STRUCTUREGRIDVIEW2D_HPP