#include <ThermometerFigure.h>

Inheritance diagram for ThermometerFigure:

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

virtual	~ThermometerFigure ()

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

const Rectangle &	getBounds () const

void	setBounds (const Rectangle &rect)

const Color &	getMercuryColor () const

void	setMercuryColor (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)

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	getContainerGeometry (double &x, double &y, double &width, double &height, double &offset)

void	setTickGeometry (cLineFigure *tick, int index)

void	setNumberGeometry (cTextFigure *number, int index)

void	setMercuryAndContainerGeometry ()

void	redrawTicks ()

void	layout ()

void	refresh ()

Protected Attributes
cFigure::Rectangle	bounds

cPathFigure *	mercuryFigure

cPathFigure *	containerFigure

cTextFigure *	labelFigure

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

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

                                                      : cGroupFigure(name)
 {
     addChildren();
 }

ThermometerFigure::~ThermometerFigure ( )

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 ThermometerFigure::addChildren ( )

protected

Referenced by ThermometerFigure().

 {
     mercuryFigure = new cPathFigure("mercury");
     containerFigure = new cPathFigure("container");
     labelFigure = new cTextFigure("label");
 
     mercuryFigure->setFilled(true);
     mercuryFigure->setFillColor("darkorange");
     mercuryFigure->setLineOpacity(0);
 
     labelFigure->setAnchor(cFigure::ANCHOR_N);
 
     addFigure(mercuryFigure);
     addFigure(containerFigure);
     addFigure(labelFigure);
 }

const char ** ThermometerFigure::getAllowedPropertyKeys ( ) const

overrideprotectedvirtual

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

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

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

 {
     return bounds;
 }

void ThermometerFigure::getContainerGeometry	(	double &	x,
		double &	y,
		double &	width,
		double &	height,
		double &	offset
	)

protected

Referenced by setMercuryAndContainerGeometry(), setNumberGeometry(), and setTickGeometry().

 {
     x = getBounds().x + getBounds().width * CONTAINER_POS_PERCENT;
     y = getBounds().y + getBounds().width * CONTAINER_POS_PERCENT;
     width = getBounds().width * CONTAINER_WIDTH_PERCENT;
     offset = getBounds().height * CONTAINER_OFFSET_PERCENT;
     height = getBounds().height - width * (1 + 2 * CONTAINER_POS_PERCENT) - getBounds().width * CONTAINER_POS_PERCENT - offset;
 }

const char * ThermometerFigure::getLabel ( ) const

 {
     return labelFigure->getText();
 }

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

 {
     return labelFigure->getColor();
 }

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

 {
     return labelFigure->getFont();
 }

const int ThermometerFigure::getLabelOffset ( ) const

 {
     return labelOffset;
 }

double ThermometerFigure::getMaxValue ( ) const

 {
     return max;
 }

const cFigure::Color & ThermometerFigure::getMercuryColor ( ) const

 {
     return mercuryFigure->getLineColor();
 }

double ThermometerFigure::getMinValue ( ) const

 {
     return min;
 }

double ThermometerFigure::getTickSize ( ) const

 {
     return tickSize;
 }

void ThermometerFigure::layout ( )

protected

Referenced by setBounds().

 {
     setMercuryAndContainerGeometry();
 
     for (int i = 0; i < numTicks; ++i) {
         setTickGeometry(tickFigures[i], i);
         setNumberGeometry(numberFigures[i], i);
     }
 
     labelFigure->setPosition(Point(getBounds().getCenter().x, getBounds().y + getBounds().height + labelOffset));
 }

void ThermometerFigure::parse ( cProperty * property )

overrideprotectedvirtual

 {
     cGroupFigure::parse(property);
 
 
     setBounds(parseBounds(property, getBounds()));
 
 
     // Set default
     redrawTicks();
 
 
     const char *s;
     if ((s = property->getValue(PKEY_MERCURY_COLOR)) != nullptr)
         setMercuryColor(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 initialized before min and max, because it is possible to have too many unnecessary ticks
     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_INITIAL_VALUE)) != nullptr)
         setValue(0, simTime(), utils::atod(s));
 }

void ThermometerFigure::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_W);
 
             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]);
         addFigure(numberFigures[i]);
     }
 
     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 ThermometerFigure::refresh ( )

protected

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

 {
     setMercuryAndContainerGeometry();
 }

void ThermometerFigure::setBounds ( const Rectangle & rect )

Referenced by parse().

 {
     bounds = rect;
     layout();
 }

void ThermometerFigure::setLabel ( const char * text )

Referenced by parse().

 {
     labelFigure->setText(text);
 }

void ThermometerFigure::setLabelColor ( const Color & color )

Referenced by parse().

 {
     labelFigure->setColor(color);
 }

void ThermometerFigure::setLabelFont ( const Font & font )

Referenced by parse().

 {
     labelFigure->setFont(font);
 }

void ThermometerFigure::setLabelOffset ( int offset )

Referenced by parse().

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

void ThermometerFigure::setMaxValue ( double value )

Referenced by parse().

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

void ThermometerFigure::setMercuryAndContainerGeometry ( )

protected

Referenced by layout(), and refresh().

 {
     containerFigure->clearPath();
     mercuryFigure->clearPath();
 
     containerFigure->setLineWidth(getBounds().width * CONTAINER_LINE_WIDTH_PERCENT);
 
     double x, y, width, height, offset;
     getContainerGeometry(x, y, width, height, offset);
 
     containerFigure->addMoveTo(x, y);
     containerFigure->addLineRel(0, height + 2 * offset);
     //TODO this does not work with Qtenv:
     //containerFigure->addCubicBezierCurveRel(0, width, width, width, width, 0);
     containerFigure->addArcRel(width / 2, width / 2, 0, true, false, width, 0);
     containerFigure->addLineRel(0, -height - 2 * offset);
     containerFigure->addArcRel(width / 2, width / 2, 0, true, false, -width, 0);
 
     double mercuryLevel;
     double overflow = 0;
     if (std::isnan(value))
         return;
     else if (value < min) {
         mercuryFigure->addMoveTo(x, y + 2 * offset + height);
         mercuryFigure->addArcRel(width / 2, width / 2, 0, true, false, width, 0);
         mercuryFigure->addClosePath();
         return;
     }
     else if (value > max) {
         mercuryLevel = 1;
         // value < max so the mercury will be overflow
         overflow = 2 * offset;
         offset = 0;
     }
     else
         mercuryLevel = (value - min) / (max - min);
 
     mercuryFigure->addMoveTo(x, y + offset + height * (1 - mercuryLevel));
     mercuryFigure->addLineRel(0, height * mercuryLevel + overflow + offset);
     //TODO this does not work with Qtenv:
     //mercuryFigure->addCubicBezierCurveRel(0, width, width, width, width, 0);
     mercuryFigure->addArcRel(width / 2, width / 2, 0, true, false, width, 0);
     mercuryFigure->addLineRel(0, -height * mercuryLevel - overflow - offset);
     if (overflow > 0)
         mercuryFigure->addArcRel(width / 2, width / 2, 0, true, false, -width, 0);
     mercuryFigure->addClosePath();
 }

void ThermometerFigure::setMercuryColor ( const Color & color )

Referenced by parse().

 {
     mercuryFigure->setFillColor(color);
 }

void ThermometerFigure::setMinValue ( double value )

Referenced by parse().

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

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

protected

Referenced by layout(), and redrawTicks().

 {
     if (numTicks - 1 == 0)
         return;
 
     double x, y, width, height, offset;
     getContainerGeometry(x, y, width, height, offset);
 
     double lineWidth = getBounds().height * TICK_LINE_WIDTH_PERCENT;
     x += width + lineWidth + getBounds().width * TICK_LENGTH_PERCENT;
     y += offset + height - height * (index * tickSize + shifting) / (max - min);
 
     double pointSize = getBounds().height * FONT_SIZE_PERCENT;
 
     number->setPosition(Point(x + pointSize * NUMBER_DISTANCE_FROM_TICK_PERCENT, y));
     number->setFont(cFigure::Font("", pointSize, 0));
 }

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

protected

Referenced by layout(), and redrawTicks().

 {
     if (numTicks - 1 == 0)
         return;
 
     double x, y, width, height, offset;
     getContainerGeometry(x, y, width, height, offset);
 
     double lineWidth = getBounds().height * TICK_LINE_WIDTH_PERCENT / 2;
     x += width + lineWidth;
     y += offset + height - height * (index * tickSize + shifting) / (max - min);
     tick->setStart(Point(x, y));
     tick->setEnd(Point(x + getBounds().width * TICK_LENGTH_PERCENT, y));
     tick->setLineWidth(lineWidth);
 }

void ThermometerFigure::setTickSize ( double value )

Referenced by parse().

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

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