#include <GaugeFigure.h>

Inheritance diagram for GaugeFigure:

Public Member Functions
	GaugeFigure (const char *name=nullptr)

virtual	~GaugeFigure ()

virtual void	setValue (int series, simtime_t timestamp, double value) override

const Rectangle &	getBounds () const

void	setBounds (const Rectangle &rect)

const Color &	getBackgroundColor () const

void	setBackgroundColor (const Color &color)

const Color &	getNeedleColor () const

void	setNeedleColor (const Color &color)

const char *	getLabel () const

void	setLabel (const char *text)

const int	getLabelOffset () const

void	setLabelOffset (int offset)

const Font &	getLabelFont () const

void	setLabelFont (const Font &font)

const Color &	getLabelColor () const

void	setLabelColor (const Color &color)

double	getMinValue () const

void	setMinValue (double value)

double	getMaxValue () const

void	setMaxValue (double value)

double	getTickSize () const

void	setTickSize (double value)

const char *	getColorStrip () const

void	setColorStrip (const char *colorStrip)

Public Member Functions inherited from inet::IIndicatorFigure
virtual	~IIndicatorFigure ()

virtual int	getNumSeries () const

virtual void	refreshDisplay ()

Protected Member Functions
virtual void	parse (cProperty *property) override

virtual const char **	getAllowedPropertyKeys () const override

void	addChildren ()

void	setColorCurve (const cFigure::Color &curveColor, double startAngle, double endAngle, cArcFigure *arc)

void	setCurveGeometry (cArcFigure *curve)

void	setTickGeometry (cLineFigure *tick, int index)

void	setNumberGeometry (cTextFigure *number, int index)

void	setNeedleGeometry ()

void	setNeedleTransform ()

void	redrawTicks ()

void	redrawCurves ()

void	layout ()

void	refresh ()

Private Attributes
cPathFigure *	needle

cTextFigure *	valueFigure

cTextFigure *	labelFigure

cOvalFigure *	backgroundFigure

std::vector< cArcFigure * >	curveFigures

std::vector< cLineFigure * >	tickFigures

std::vector< cTextFigure * >	numberFigures

const char *	colorStrip = ""

double	min = 0

double	max = 100

double	tickSize = 10

double	value = NaN

int	numTicks = 0

double	shifting = 0

int	curvesOnCanvas = 0

int	labelOffset = 10

Constructor & Destructor Documentation

GaugeFigure::GaugeFigure ( const char * name = nullptr )

                                          : cGroupFigure(name)
 {
     addChildren();
 }

GaugeFigure::~GaugeFigure ( )

virtual

 {
     // delete figures which is not in canvas
     for (int i = curvesOnCanvas; i < curveFigures.size(); ++i)
         delete curveFigures[i];
 
     for (int i = numTicks; i < tickFigures.size(); ++i) {
         delete tickFigures[i];
         delete numberFigures[i];
     }
 }

Member Function Documentation

void GaugeFigure::addChildren ( )

protected

Referenced by GaugeFigure().

 {
     backgroundFigure = new cOvalFigure("background");
     needle = new cPathFigure("needle");
     valueFigure = new cTextFigure("value");
     labelFigure = new cTextFigure("label");
 
     backgroundFigure->setFilled(true);
     backgroundFigure->setFillColor(Color("#b8afa6"));
 
     needle->setFilled(true);
     needle->setFillColor(cFigure::Color("#dba672"));
 
     valueFigure->setAnchor(cFigure::ANCHOR_CENTER);
     labelFigure->setAnchor(cFigure::ANCHOR_N);
 
     addFigure(backgroundFigure);
     addFigure(needle);
     addFigure(valueFigure);
     addFigure(labelFigure);
 }

const char ** GaugeFigure::getAllowedPropertyKeys ( ) const

overrideprotectedvirtual

 {
     static const char *keys[32];
     if (!keys[0]) {
         const char *localKeys[] = {
             PKEY_BACKGROUND_COLOR, PKEY_NEEDLE_COLOR, PKEY_LABEL, PKEY_LABEL_FONT,
             PKEY_LABEL_COLOR, PKEY_MIN_VALUE, PKEY_MAX_VALUE, PKEY_TICK_SIZE,
             PKEY_COLOR_STRIP, PKEY_INITIAL_VALUE, PKEY_POS, PKEY_SIZE, PKEY_ANCHOR,
             PKEY_BOUNDS, PKEY_LABEL_OFFSET, nullptr
         };
         concatArrays(keys, cGroupFigure::getAllowedPropertyKeys(), localKeys);
     }
     return keys;
 }

const cFigure::Color & GaugeFigure::getBackgroundColor ( ) const

 {
     return backgroundFigure->getFillColor();
 }

const cFigure::Rectangle & GaugeFigure::getBounds ( ) const

Referenced by layout(), parse(), setCurveGeometry(), setLabelOffset(), setNeedleGeometry(), setNeedleTransform(), setNumberGeometry(), and setTickGeometry().

 {
     return backgroundFigure->getBounds();
 }

const char * GaugeFigure::getColorStrip ( ) const

 {
     return colorStrip;
 }

const char * GaugeFigure::getLabel ( ) const

 {
     return labelFigure->getText();
 }

const cFigure::Color & GaugeFigure::getLabelColor ( ) const

 {
     return labelFigure->getColor();
 }

const cFigure::Font & GaugeFigure::getLabelFont ( ) const

 {
     return labelFigure->getFont();
 }

const int GaugeFigure::getLabelOffset ( ) const

 {
     return labelOffset;
 }

double GaugeFigure::getMaxValue ( ) const

 {
     return max;
 }

double GaugeFigure::getMinValue ( ) const

 {
     return min;
 }

const cFigure::Color & GaugeFigure::getNeedleColor ( ) const

 {
     return needle->getFillColor();
 }

double GaugeFigure::getTickSize ( ) const

 {
     return tickSize;
 }

void GaugeFigure::layout ( )

protected

Referenced by setBounds().

 {
     backgroundFigure->setLineWidth(zeroToOne(getBounds().width * BORDER_WIDTH_PERCENT));
 
     for (cArcFigure *item : curveFigures)
         setCurveGeometry(item);
 
     for (int i = 0; i < numTicks; ++i) {
         setTickGeometry(tickFigures[i], i);
         setNumberGeometry(numberFigures[i], i);
     }
 
     setNeedleGeometry();
 
     valueFigure->setFont(Font("", getBounds().width * FONT_SIZE_PERCENT, 0));
     valueFigure->setPosition(Point(getBounds().getCenter().x, getBounds().y + getBounds().height * VALUE_Y_PERCENT));
 
     labelFigure->setPosition(Point(getBounds().getCenter().x, getBounds().y + getBounds().height + labelOffset));
 }

void GaugeFigure::parse ( cProperty * property )

overrideprotectedvirtual

 {
     cGroupFigure::parse(property);
 
     const char *s;
 
     setBounds(parseBounds(property, getBounds()));
 
     // Set default
     redrawTicks();
     if ((s = property->getValue(PKEY_BACKGROUND_COLOR)) != nullptr)
         setBackgroundColor(parseColor(s));
     if ((s = property->getValue(PKEY_NEEDLE_COLOR)) != nullptr)
         setNeedleColor(parseColor(s));
     if ((s = property->getValue(PKEY_LABEL)) != nullptr)
         setLabel(s);
     if ((s = property->getValue(PKEY_LABEL_OFFSET)) != nullptr)
         setLabelOffset(atoi(s));
     if ((s = property->getValue(PKEY_LABEL_FONT)) != nullptr)
         setLabelFont(parseFont(s));
     if ((s = property->getValue(PKEY_LABEL_COLOR)) != nullptr)
         setLabelColor(parseColor(s));
     // This must be initialize before min and max because it is possible to be too much unnecessary tick and number
     if ((s = property->getValue(PKEY_TICK_SIZE)) != nullptr)
         setTickSize(atof(s));
     if ((s = property->getValue(PKEY_MIN_VALUE)) != nullptr)
         setMinValue(atof(s));
     if ((s = property->getValue(PKEY_MAX_VALUE)) != nullptr)
         setMaxValue(atof(s));
     if ((s = property->getValue(PKEY_COLOR_STRIP)) != nullptr)
         setColorStrip(s);
     if ((s = property->getValue(PKEY_INITIAL_VALUE)) != nullptr)
         setValue(0, simTime(), utils::atod(s));
 
 }

void GaugeFigure::redrawCurves ( )

protected

Referenced by setColorStrip().

 {
     // create color strips
     cStringTokenizer signalTokenizer(colorStrip, " ,");
 
     double lastStop = 0.0;
     double newStop = 0.0;
     Color color;
     int index = 0;
     const double deg270InRad = 6 * M_PI / 4;
     while (signalTokenizer.hasMoreTokens()) {
         const char *token = signalTokenizer.nextToken();
         newStop = atof(token);
         if (newStop > lastStop) {
             if (index == curveFigures.size()) {
                 cArcFigure *arc = new cArcFigure("colorStrip");
                 arc->setZoomLineWidth(true);
                 curveFigures.push_back(arc);
             }
 
             setColorCurve(color, M_PI - (deg270InRad * newStop), M_PI - (deg270InRad * lastStop), curveFigures[index]);
 
             ++index;
             lastStop = newStop;
         }
         if (newStop == 0.0)
             color = Color(token);
     }
     if (lastStop < 1.0) {
         if (index == curveFigures.size()) {
             cArcFigure *arc = new cArcFigure("colorStrip");
             arc->setZoomLineWidth(true);
             curveFigures.push_back(arc);
         }
         setColorCurve(color, M_PI - deg270InRad, M_PI - (deg270InRad * lastStop), curveFigures[index]);
         ++index;
     }
 
     int prevCurvesOnCanvas = curvesOnCanvas;
     curvesOnCanvas = index;
 
     // Add or remove figures from canvas according to previous number of curves
     for (int i = prevCurvesOnCanvas; i < curvesOnCanvas; ++i) {
         curveFigures[i]->insertBelow(needle);
     }
     for (int i = curvesOnCanvas; i < prevCurvesOnCanvas; ++i)
         removeFigure(curveFigures[index]);
 }

void GaugeFigure::redrawTicks ( )

protected

Referenced by parse(), setMaxValue(), setMinValue(), and setTickSize().

 {
     ASSERT(tickFigures.size() == numberFigures.size());
 
     double fraction = std::abs(fmod(min / tickSize, 1));
     shifting = tickSize * (min < 0 ? fraction : 1 - fraction);
     // if fraction == 0 then shifting == tickSize therefore don't have to shift the ticks
     if (shifting == tickSize)
         shifting = 0;
 
     int prevNumTicks = numTicks;
     numTicks = std::max(0.0, std::abs(max - min - shifting) / tickSize + 1);
 
     // Allocate ticks and numbers if needed
     if (numTicks > tickFigures.size())
         while (numTicks > tickFigures.size()) {
             cLineFigure *tick = new cLineFigure();
             cTextFigure *number = new cTextFigure();
 
             number->setAnchor(cFigure::ANCHOR_CENTER);
 
             tickFigures.push_back(tick);
             numberFigures.push_back(number);
         }
 
     // Add or remove figures from canvas according to previous number of ticks
     for (int i = numTicks; i < prevNumTicks; ++i) {
         removeFigure(tickFigures[i]);
         removeFigure(numberFigures[i]);
     }
     for (int i = prevNumTicks; i < numTicks; ++i) {
         addFigure(tickFigures[i]);
         numberFigures[i]->insertBelow(needle);
     }
 
     for (int i = 0; i < numTicks; ++i) {
         setTickGeometry(tickFigures[i], i);
 
         char buf[32];
 
         double number = min + i * tickSize + shifting;
         if (std::abs(number) < tickSize / 2)
             number = 0;
 
         sprintf(buf, "%g", number);
         numberFigures[i]->setText(buf);
         setNumberGeometry(numberFigures[i], i);
     }
 }

void GaugeFigure::refresh ( )

protected

Referenced by setMaxValue(), setMinValue(), setTickSize(), and setValue().

 {
     setNeedleTransform();
 
     // update displayed number
     if (std::isnan(value))
         valueFigure->setText("");
     else {
         char buf[32];
         sprintf(buf, "%g", value);
         valueFigure->setText(buf);
     }
 }

void GaugeFigure::setBackgroundColor ( const Color & color )

Referenced by parse().

 {
     backgroundFigure->setFillColor(color);
 }

void GaugeFigure::setBounds ( const Rectangle & rect )

Referenced by parse().

 {
     backgroundFigure->setBounds(rect);
     layout();
 }

void GaugeFigure::setColorCurve	(	const cFigure::Color &	curveColor,
		double	startAngle,
		double	endAngle,
		cArcFigure *	arc
	)

protected

Referenced by redrawCurves().

 {
     arc->setLineColor(curveColor);
     arc->setStartAngle(startAngle);
     arc->setEndAngle(endAngle);
     setCurveGeometry(arc);
 }

void GaugeFigure::setColorStrip ( const char * colorStrip )

Referenced by parse().

 {
     if (strcmp(this->colorStrip, colorStrip) != 0) {
         this->colorStrip = colorStrip;
         redrawCurves();
     }
 }

void GaugeFigure::setCurveGeometry ( cArcFigure * curve )

protected

Referenced by layout(), and setColorCurve().

 {
     double lineWidth = getBounds().width * CURVE_WIDTH_PERCENT;
     Rectangle arcBounds = getBounds();
     double offset = lineWidth + backgroundFigure->getLineWidth();
 
     arcBounds.height -= offset;
     arcBounds.width -= offset;
     arcBounds.x += offset / 2;
     arcBounds.y += offset / 2;
 
     curve->setBounds(arcBounds);
     curve->setLineWidth(lineWidth);
 
     Transform trans;
     trans.rotate(-M_PI / 4, getBounds().getCenter());
     curve->setTransform(trans);
 }

void GaugeFigure::setLabel ( const char * text )

Referenced by parse().

 {
     labelFigure->setText(text);
 }

void GaugeFigure::setLabelColor ( const Color & color )

Referenced by parse().

 {
     labelFigure->setColor(color);
 }

void GaugeFigure::setLabelFont ( const Font & font )

Referenced by parse().

 {
     labelFigure->setFont(font);
 }

void GaugeFigure::setLabelOffset ( int offset )

Referenced by parse().

 {
     if (labelOffset != offset) {
         labelOffset = offset;
         labelFigure->setPosition(Point(getBounds().getCenter().x, getBounds().y + getBounds().height + labelOffset));
     }
 }

void GaugeFigure::setMaxValue ( double value )

Referenced by parse().

 {
     if (max != value) {
         max = value;
         redrawTicks();
         refresh();
     }
 }

void GaugeFigure::setMinValue ( double value )

Referenced by parse().

 {
     if (min != value) {
         min = value;
         redrawTicks();
         refresh();
     }
 }

void GaugeFigure::setNeedleColor ( const Color & color )

Referenced by parse().

 {
     needle->setFillColor(color);
 }

void GaugeFigure::setNeedleGeometry ( )

protected

Referenced by layout().

 {
     double cx = getBounds().getCenter().x;
     double cy = getBounds().getCenter().y;
     double w = getBounds().width;
 
     // draw needle in horizontal position, pointing 9:00 hours
     double needleHalfWidth = w * NEEDLE_WIDTH_PERCENT / 2;
     double needleLength = w * NEEDLE_HEIGHT_PERCENT;
     needle->clearPath();
     needle->addMoveTo(cx + needleHalfWidth, cy);
     needle->addLineTo(cx, cy - needleHalfWidth);
     needle->addLineTo(cx - needleLength, cy);
     needle->addLineTo(cx, cy + needleHalfWidth);
     needle->addClosePath();
 
     setNeedleTransform();
 }

void GaugeFigure::setNeedleTransform ( )

protected

Referenced by refresh(), and setNeedleGeometry().

 {
     double angle;
     const double offset = NEEDLE_OFFSET_IN_DEGREE * M_PI / 180;
     needle->setVisible(true);
     if (value < min)
         angle = -offset;
     else if (value > max)
         angle = (END_ANGLE - START_ANGLE) + offset;
     else if (std::isnan(value)) {
         needle->setVisible(false);
         return;
     }
     else
         angle = (value - min) / (max - min) * (END_ANGLE - START_ANGLE);
 
     cFigure::Transform t;
     t.rotate(angle, getBounds().getCenter()).rotate(-M_PI / 4, getBounds().getCenter());
     needle->setTransform(t);
 }

void GaugeFigure::setNumberGeometry	(	cTextFigure *	number,
		int	index
	)

protected

Referenced by layout(), and redrawTicks().

 {
     ASSERT(tickFigures.size() > 0);
 
     double distanceToBorder = tickFigures[0]->getStart().distanceTo(tickFigures[0]->getEnd());
     number->setFont(cFigure::Font("", getBounds().width * FONT_SIZE_PERCENT, 0));
     Point textPos = Point(getBounds().x + distanceToBorder + number->getFont().pointSize, getBounds().getCenter().y);
     number->setPosition(textPos);
 
     Transform trans;
     trans.rotate(-(M_PI + M_PI / 2) * (index * tickSize + shifting) / (max - min), textPos).
             rotate(M_PI / 4, textPos).
             rotate((M_PI + M_PI / 2) * (index * tickSize + shifting) / (max - min), getBounds().getCenter()).
             rotate(-M_PI / 4, getBounds().getCenter());
     number->setTransform(trans);
 }

void GaugeFigure::setTickGeometry	(	cLineFigure *	tick,
		int	index
	)

protected

Referenced by layout(), and redrawTicks().

 {
     tick->setStart(Point(getBounds().x, getBounds().getCenter().y));
 
     Point endPos = getBounds().getCenter();
     endPos.x -= !(index % 3) ? getBounds().width * TICK_BIG_LENGTH_PERCENT :
         getBounds().width * TICK_SMALL_LENGTH_PERCENT;
     tick->setEnd(endPos);
     tick->setLineWidth(zeroToOne(getBounds().width * TICK_LINE_WIDTH_PERCENT));
 
     Transform trans;
     trans.rotate((M_PI + M_PI / 2) * (index * tickSize + shifting) / (max - min), getBounds().getCenter()).
             rotate(-M_PI / 4, getBounds().getCenter());
     tick->setTransform(trans);
 }

void GaugeFigure::setTickSize ( double value )

Referenced by parse().

 {
     if (tickSize != value) {
         tickSize = value;
         redrawTicks();
         refresh();
     }
 }

void GaugeFigure::setValue	(	int	series,
		simtime_t	timestamp,
		double	value
	)

overridevirtual

Implements inet::IIndicatorFigure.

Referenced by parse().

 {
     ASSERT(series == 0);
     // Note: we currently ignore timestamp
     if (value != newValue) {
         value = newValue;
         refresh();
     }
 }