#include <LinearGaugeFigure.h>

Inheritance diagram for LinearGaugeFigure:

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

virtual	~LinearGaugeFigure ()

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)

double	getCornerRadius () const

void	setCornerRadius (double radius)

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	setTickGeometry (cLineFigure *tick, int index)

void	setNumberGeometry (cTextFigure *number, int index)

void	setNeedleGeometry ()

void	redrawTicks ()

void	layout ()

void	refresh ()

Private Attributes
cLineFigure *	needle

cTextFigure *	labelFigure

cRectangleFigure *	backgroundFigure

cLineFigure *	axisFigure

std::vector< cLineFigure * >	tickFigures

std::vector< cTextFigure * >	numberFigures

double	min = 0

double	max = 100

double	tickSize = 10

double	value = NaN

int	numTicks = 0

double	shifting = 0

int	labelOffset = 10

Constructor & Destructor Documentation

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

                                                      : cGroupFigure(name)
 {
     addChildren();
 }

LinearGaugeFigure::~LinearGaugeFigure ( )

virtual

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

Member Function Documentation

void LinearGaugeFigure::addChildren ( )

protected

Referenced by LinearGaugeFigure().

 {
     backgroundFigure = new cRectangleFigure("background");
     needle = new cLineFigure("needle");
     labelFigure = new cTextFigure("label");
     axisFigure = new cLineFigure("axis");
 
     backgroundFigure->setFilled(true);
     backgroundFigure->setFillColor(Color("#b8afa6"));
 
     needle->setLineColor("red");
     labelFigure->setAnchor(cFigure::ANCHOR_N);
 
     addFigure(backgroundFigure);
     addFigure(axisFigure);
     addFigure(needle);
     addFigure(labelFigure);
 }

const char ** LinearGaugeFigure::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_CORNER_RADIUS, 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 & LinearGaugeFigure::getBackgroundColor ( ) const

 {
     return backgroundFigure->getFillColor();
 }

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

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

 {
     return backgroundFigure->getBounds();
 }

double LinearGaugeFigure::getCornerRadius ( ) const

 {
     return backgroundFigure->getCornerRx();
 }

const char * LinearGaugeFigure::getLabel ( ) const

 {
     return labelFigure->getText();
 }

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

 {
     return labelFigure->getColor();
 }

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

 {
     return labelFigure->getFont();
 }

const int LinearGaugeFigure::getLabelOffset ( ) const

 {
     return labelOffset;
 }

double LinearGaugeFigure::getMaxValue ( ) const

 {
     return max;
 }

double LinearGaugeFigure::getMinValue ( ) const

 {
     return min;
 }

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

 {
     return needle->getLineColor();
 }

double LinearGaugeFigure::getTickSize ( ) const

 {
     return tickSize;
 }

void LinearGaugeFigure::layout ( )

protected

Referenced by setBounds().

 {
     backgroundFigure->setLineWidth(getBounds().height * BORDER_WIDTH_PERCENT);
 
     double y = getBounds().getCenter().y;
     axisFigure->setLineWidth(getBounds().height * AXIS_WIDTH_PERCENT);
     axisFigure->setStart(Point(getBounds().x + getBounds().width * FRAME_PERCENT + axisFigure->getLineWidth() / 2, y));
     axisFigure->setEnd(Point(getBounds().x + getBounds().width * (1 - FRAME_PERCENT) + axisFigure->getLineWidth() / 2, y));
 
     for (int i = 0; i < numTicks; ++i) {
         setTickGeometry(tickFigures[i], i);
         setNumberGeometry(numberFigures[i], i);
     }
 
     setNeedleGeometry();
     labelFigure->setPosition(Point(getBounds().getCenter().x, getBounds().y + getBounds().height + labelOffset));
 }

void LinearGaugeFigure::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(utils::atod(s));
     if ((s = property->getValue(PKEY_MIN_VALUE)) != nullptr)
         setMinValue(utils::atod(s));
     if ((s = property->getValue(PKEY_MAX_VALUE)) != nullptr)
         setMaxValue(utils::atod(s));
     if ((s = property->getValue(PKEY_CORNER_RADIUS)) != nullptr)
         setCornerRadius(utils::atod(s));
     if ((s = property->getValue(PKEY_INITIAL_VALUE)) != nullptr)
         setValue(0, simTime(), utils::atod(s));
 }

void LinearGaugeFigure::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_N);
 
             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) {
         tickFigures[i]->insertBelow(needle);
         numberFigures[i]->insertBelow(needle);
     }
 
     for (int i = 0; i < numTicks; ++i) {
         setTickGeometry(tickFigures[i], i);
 
         double number = min + i * tickSize + shifting;
         if (std::abs(number) < tickSize / 2)
             number = 0;
 
         char buf[32];
         sprintf(buf, "%g", number);
         numberFigures[i]->setText(buf);
         setNumberGeometry(numberFigures[i], i);
     }
 }

void LinearGaugeFigure::refresh ( )

protected

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

 {
     setNeedleGeometry();
 }

void LinearGaugeFigure::setBackgroundColor ( const Color & color )

Referenced by parse().

 {
     backgroundFigure->setFillColor(color);
 }

void LinearGaugeFigure::setBounds ( const Rectangle & rect )

Referenced by parse().

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

void LinearGaugeFigure::setCornerRadius ( double radius )

Referenced by parse().

 {
     backgroundFigure->setCornerRadius(radius);
 }

void LinearGaugeFigure::setLabel ( const char * text )

Referenced by parse().

 {
     labelFigure->setText(text);
 }

void LinearGaugeFigure::setLabelColor ( const Color & color )

Referenced by parse().

 {
     labelFigure->setColor(color);
 }

void LinearGaugeFigure::setLabelFont ( const Font & font )

Referenced by parse().

 {
     labelFigure->setFont(font);
 }

void LinearGaugeFigure::setLabelOffset ( int offset )

Referenced by parse().

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

void LinearGaugeFigure::setMaxValue ( double value )

Referenced by parse().

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

void LinearGaugeFigure::setMinValue ( double value )

Referenced by parse().

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

void LinearGaugeFigure::setNeedleColor ( const Color & color )

Referenced by parse().

 {
     needle->setLineColor(color);
 }

void LinearGaugeFigure::setNeedleGeometry ( )

protected

Referenced by layout(), and refresh().

 {
     needle->setLineWidth(getBounds().height * NEEDLE_WIDTH_PERCENT);
 
     double x = axisFigure->getStart().x + axisFigure->getLineWidth() / 2;
     double axisWidth = axisFigure->getEnd().x - axisFigure->getStart().x - axisFigure->getLineWidth();
 
     needle->setVisible(true);
     if (std::isnan(value)) {
         needle->setVisible(false);
         return;
     }
     else if (value < min)
         x -= getBounds().width * NEEDLE_OFFSET_PERCENT;
     else if (value > max)
         x = axisFigure->getEnd().x + getBounds().width * NEEDLE_OFFSET_PERCENT;
     else
         x += (value - min) * axisWidth / (max - min);
 
     needle->setStart(Point(x, axisFigure->getStart().y - getBounds().height * NEEDLE_HEIGHT_PERCENT / 2));
     needle->setEnd(Point(x, axisFigure->getStart().y + getBounds().height * NEEDLE_HEIGHT_PERCENT / 2));
 }

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

protected

Referenced by layout(), and redrawTicks().

 {
     double axisWidth = axisFigure->getEnd().x - axisFigure->getStart().x - axisFigure->getLineWidth() / 2;
     double x = axisFigure->getStart().x + axisFigure->getLineWidth() / 2
         + axisWidth * (index * tickSize + shifting) / (max - min);
     Point textPos = Point(x, axisFigure->getStart().y + getBounds().height * NUMBER_Y_PERCENT);
     number->setPosition(textPos);
     number->setFont(cFigure::Font("", getBounds().height * NUMBER_FONTSIZE_PERCENT, 0));
 }

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

protected

Referenced by layout(), and redrawTicks().

 {
     double axisWidth = axisFigure->getEnd().x - axisFigure->getStart().x - axisFigure->getLineWidth();
     double x = axisFigure->getStart().x + axisFigure->getLineWidth() / 2
         + axisWidth * (index * tickSize + shifting) / (max - min);
     tick->setStart(Point(x, getBounds().getCenter().y));
 
     Point endPos = tick->getStart();
     endPos.y -= !(index % 3) ? getBounds().height * TICK_SMALL_LENGTH_PERCENT :
         getBounds().height * TICK_BIG_LENGTH_PERCENT;
     tick->setEnd(endPos);
     tick->setLineWidth(getBounds().height * AXIS_WIDTH_PERCENT);
 }

void LinearGaugeFigure::setTickSize ( double value )

Referenced by parse().

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

void LinearGaugeFigure::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();
     }
 }