ClusterGraphAttributes.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/GraphAttributes.h>
#include <ogdf/cluster/ClusterArray.h>
 
namespace ogdf {
 
 
class OGDF_EXPORT ClusterGraphAttributes : public GraphAttributes {
protected:
    const ClusterGraph* m_pClusterGraph; 
 
    ClusterArray<double> m_x; 
    ClusterArray<double> m_y; 
    ClusterArray<double> m_width; 
    ClusterArray<double> m_height; 
    ClusterArray<string> m_label; 
    ClusterArray<Stroke> m_stroke; 
    ClusterArray<Fill> m_fill; 
    ClusterArray<string> m_clusterTemplate; 
 
public:
    static const long clusterGraphics;
 
    static const long clusterStyle;
 
    static const long clusterLabel;
 
    static const long clusterTemplate;
 
    static const long all;
 
 
    // Don't hide these inherited methods by overloading.
    using GraphAttributes::height;
    using GraphAttributes::width;
    using GraphAttributes::x;
    using GraphAttributes::y;
 
    using GraphAttributes::label;
 
    using GraphAttributes::strokeColor;
    using GraphAttributes::strokeType;
    using GraphAttributes::strokeWidth;
 
    using GraphAttributes::fillBgColor;
    using GraphAttributes::fillColor;
    using GraphAttributes::fillPattern;
 
    ClusterGraphAttributes() : GraphAttributes(), m_pClusterGraph(nullptr) { }
 
    explicit ClusterGraphAttributes(const ClusterGraph& cg,
            long initAttributes = nodeGraphics | edgeGraphics | clusterGraphics);
 
private:
    using GraphAttributes::init;
 
 
    void addClusterAttributes(long attr);
 
 
    void destroyClusterAttributes(long attr);
 
public:
 
    void init(ClusterGraph& cg, long attr = 0);
 
    void init(long attr = 0);
 
    void addAttributes(long attr);
 
    void destroyAttributes(long attr);
 
    const ClusterGraph& constClusterGraph() const { return *m_pClusterGraph; }
 
 
    double x(cluster c) const {
        OGDF_ASSERT(has(clusterGraphics));
        return m_x[c];
    }
 
 
    double& x(cluster c) {
        OGDF_ASSERT(has(clusterGraphics));
        return m_x[c];
    }
 
 
    double y(cluster c) const {
        OGDF_ASSERT(has(clusterGraphics));
        return m_y[c];
    }
 
 
    double& y(cluster c) {
        OGDF_ASSERT(has(clusterGraphics));
        return m_y[c];
    }
 
 
    double width(cluster c) const {
        OGDF_ASSERT(has(clusterGraphics));
        return m_width[c];
    }
 
 
    double& width(cluster c) {
        OGDF_ASSERT(has(clusterGraphics));
        return m_width[c];
    }
 
 
    double height(cluster c) const {
        OGDF_ASSERT(has(clusterGraphics));
        return m_height[c];
    }
 
 
    double& height(cluster c) {
        OGDF_ASSERT(has(clusterGraphics));
        return m_height[c];
    }
 
 
    const StrokeType& strokeType(cluster c) const {
        OGDF_ASSERT(has(clusterStyle));
        return m_stroke[c].m_type;
    }
 
 
    StrokeType& strokeType(cluster c) {
        OGDF_ASSERT(has(clusterStyle));
        return m_stroke[c].m_type;
    }
 
 
    const Color& strokeColor(cluster c) const {
        OGDF_ASSERT(has(clusterStyle));
        return m_stroke[c].m_color;
    }
 
 
    Color& strokeColor(cluster c) {
        OGDF_ASSERT(has(clusterStyle));
        return m_stroke[c].m_color;
    }
 
 
    const float& strokeWidth(cluster c) const {
        OGDF_ASSERT(has(clusterStyle));
        return m_stroke[c].m_width;
    }
 
 
    float& strokeWidth(cluster c) {
        OGDF_ASSERT(has(clusterStyle));
        return m_stroke[c].m_width;
    }
 
 
    const FillPattern& fillPattern(cluster c) const {
        OGDF_ASSERT(has(clusterStyle));
        return m_fill[c].m_pattern;
    }
 
 
    FillPattern& fillPattern(cluster c) {
        OGDF_ASSERT(has(clusterStyle));
        return m_fill[c].m_pattern;
    }
 
 
    const Color& fillColor(cluster c) const {
        OGDF_ASSERT(has(clusterStyle));
        return m_fill[c].m_color;
    }
 
 
    Color& fillColor(cluster c) {
        OGDF_ASSERT(has(clusterStyle));
        return m_fill[c].m_color;
    }
 
 
    const Color& fillBgColor(cluster c) const {
        OGDF_ASSERT(has(clusterStyle));
        return m_fill[c].m_bgColor;
    }
 
 
    Color& fillBgColor(cluster c) {
        OGDF_ASSERT(has(clusterStyle));
        return m_fill[c].m_bgColor;
    }
 
 
    const string& label(cluster c) const {
        OGDF_ASSERT(has(clusterLabel));
        return m_label[c];
    }
 
 
    string& label(cluster c) {
        OGDF_ASSERT(has(clusterLabel));
        return m_label[c];
    }
 
 
    const string& templateCluster(cluster c) const {
        OGDF_ASSERT(has(clusterTemplate));
        return m_clusterTemplate[c];
    }
 
 
    string& templateCluster(cluster c) {
        OGDF_ASSERT(has(clusterTemplate));
        return m_clusterTemplate[c];
    }
 
    using GraphAttributes::flipHorizontal;
    using GraphAttributes::flipVertical;
    using GraphAttributes::scale;
 
 
    virtual void scale(double sx, double sy, bool scaleNodes = true) override;
 
 
    virtual void translate(double dx, double dy) override;
 
 
    virtual void flipVertical(const DRect& box) override;
 
 
    virtual void flipHorizontal(const DRect& box) override;
 
 
 
    virtual DRect boundingBox() const override;
 
    void updateClusterPositions(double boundaryDist = 1.0);
 
    cluster clusterOf(node v) { return m_pClusterGraph->clusterOf(v); }
 
};
 
}