/*
 * (C) Copyright 1996-2016 ECMWF.
 *
 * This software is licensed under the terms of the Apache Licence Version 2.0
 * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
 * In applying this licence, ECMWF does not waive the privileges and immunities
 * granted to it by virtue of its status as an intergovernmental organisation nor
 * does it submit to any jurisdiction.
 */

/*!
    \file MgQSymbol.h
    \brief Definition of MgQSymbol.
    \author Graphics Section, ECMWF

    Started: Feb 2010
*/

#ifndef _MgQSymbol_H
#define _MgQSymbol_H

#include <QBrush>
#include <QGraphicsItem>
#include <QList>
#include <QPainterPath>
#include <QPen>
#include <QString>

#include "MgQ.h"

class MgQPainterPath : public QPainterPath {
public:
    MgQPainterPath(bool filled, bool defaultFill = false) :
        filled_(filled), defaultFill_(defaultFill), renderOnlyForOutline_(false){};
    bool isFilled() const { return filled_; }
    bool isDefaultFill() const { return defaultFill_; }
    void setRenderOnlyForOutline(bool b) { renderOnlyForOutline_ = b; }
    bool renderOnlyForOutline() const { return renderOnlyForOutline_; }

protected:
    bool filled_;
    bool defaultFill_;
    bool renderOnlyForOutline_;
};

class MgQSymbolItem {
public:
    MgQSymbolItem(QString id, float s) : id_(id), size_(s){};

    const QString& id() const { return id_; }
    float size() { return size_; };
    bool equal(const QString&, const float);
    const QList<MgQPainterPath>& paths() const { return paths_; }
    void addPath(MgQPainterPath& p) { paths_.push_back(p); }
    bool hasFilledPart();

protected:
    QString id_;
    float size_;
    QList<MgQPainterPath> paths_;
};

class MgQSymbolManager : public QList<MgQSymbolItem*> {
public:
    MgQSymbolManager(){};
    ~MgQSymbolManager();

    MgQSymbolItem* addSymbol(const QString&, const float);
    MgQSymbolItem* getSymbol(const QString&, const float);
    void deleteSymbol(const QString&, const float);

    int symbolNum() { return symbols_.count(); };

protected:
    QList<MgQSymbolItem*> symbols_;
};

class MgQSymbolSetItem : public QGraphicsItem {
public:
    enum
    {
        Type = MgQ::SymbolSetItemType
    };

    MgQSymbolSetItem(MgQSymbolItem* symbol, QRectF& boundingRect, QGraphicsItem* parent = 0) :
        QGraphicsItem(parent),
        symbol_(symbol),
        boundingRect_(boundingRect),
        keepSizeWhenScaling_(false),
        outline_(false),
        connectLine_(false){};

    QRectF boundingRect() const override;
    void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget* widget = 0) override;
    int type() const override { return Type; }

    void setColor(QColor);
    void setOutlineColor(QColor);
    void addPoint(double, double);
    void setKeepSizeWhenScaling(bool b) { keepSizeWhenScaling_ = b; }
    bool connectLine() { return connectLine_; }
    void setConnectLine(bool b) { connectLine_ = b; }
    void setConnectLinePen(QPen);

protected:
    QList<double> xp_;
    QList<double> yp_;
    MgQSymbolItem* symbol_;
    QPen pen_;
    QList<QBrush> brushes_;
    QRectF boundingRect_;
    bool keepSizeWhenScaling_;
    bool outline_;
    bool connectLine_;
    QPen connectLinePen_;
};


#endif
