inet::ThermometerFigure Class Reference

#include <ThermometerFigure.h>

Inheritance diagram for inet::ThermometerFigure:

Public Member Functions
	ThermometerFigure (const char *name=nullptr)
virtual	~ThermometerFigure ()
virtual const Point	getSize () const override
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)
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()

inet::ThermometerFigure::ThermometerFigure

(

const char *

name = nullptr

)

                                                     : cGroupFigure(name)
{
    addChildren();
}

~ThermometerFigure()

inet::ThermometerFigure::~ThermometerFigure ( )

virtual

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

Member Function Documentation

addChildren()

void inet::ThermometerFigure::addChildren ( )

protected

{
    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);
}

Referenced by ThermometerFigure().

getAllowedPropertyKeys()

const char ** inet::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;
}

getBounds()

const cFigure::Rectangle & inet::ThermometerFigure::getBounds

(

)

const

{
    return bounds;
}

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

getContainerGeometry()

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

protected

{
    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;
}

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

getLabel()

const char * inet::ThermometerFigure::getLabel

(

)

const

{
    return labelFigure->getText();
}

getLabelColor()

const cFigure::Color & inet::ThermometerFigure::getLabelColor

(

)

const

{
    return labelFigure->getColor();
}

getLabelFont()

const cFigure::Font & inet::ThermometerFigure::getLabelFont

(

)

const

{
    return labelFigure->getFont();
}

getLabelOffset()

int inet::ThermometerFigure::getLabelOffset

(

)

const

{
    return labelOffset;
}

getMaxValue()

double inet::ThermometerFigure::getMaxValue

(

)

const

{
    return max;
}

getMercuryColor()

const cFigure::Color & inet::ThermometerFigure::getMercuryColor

(

)

const

{
    return mercuryFigure->getLineColor();
}

getMinValue()

double inet::ThermometerFigure::getMinValue

(

)

const

{
    return min;
}

getSize()

virtual const Point inet::ThermometerFigure::getSize ( ) const

inlineoverridevirtual

Implements inet::IIndicatorFigure.

{ return getBounds().getSize(); }

getTickSize()

double inet::ThermometerFigure::getTickSize

(

)

const

{
    return tickSize;
}

layout()

void inet::ThermometerFigure::layout ( )

protected

{
    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));
}

Referenced by setBounds().

parse()

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

redrawTicks()

void inet::ThermometerFigure::redrawTicks ( )

protected

{
    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 ((size_t)numTicks > tickFigures.size()) {
        while ((size_t)numTicks > tickFigures.size()) {
            cLineFigure *tick = new cLineFigure();
            cTextFigure *number = new cTextFigure();
            take(tick);
            take(number);
 
            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]);
        take(tickFigures[i]);
        take(numberFigures[i]);
    }
    for (int i = prevNumTicks; i < numTicks; ++i) {
        drop(tickFigures[i]);
        drop(numberFigures[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);
    }
}

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

refresh()

void inet::ThermometerFigure::refresh ( )

protected

{
    setMercuryAndContainerGeometry();
}

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

setBounds()

void inet::ThermometerFigure::setBounds

(

const Rectangle &

rect

)

{
    bounds = rect;
    layout();
}

Referenced by parse().

setLabel()

void inet::ThermometerFigure::setLabel

(

const char *

text

)

{
    labelFigure->setText(text);
}

Referenced by parse().

setLabelColor()

void inet::ThermometerFigure::setLabelColor

(

const Color &

color

)

{
    labelFigure->setColor(color);
}

Referenced by parse().

setLabelFont()

void inet::ThermometerFigure::setLabelFont

(

const Font &

font

)

{
    labelFigure->setFont(font);
}

Referenced by parse().

setLabelOffset()

void inet::ThermometerFigure::setLabelOffset

(

int

offset

)

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

Referenced by parse().

setMaxValue()

void inet::ThermometerFigure::setMaxValue

(

double

value

)

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

Referenced by parse().

setMercuryAndContainerGeometry()

void inet::ThermometerFigure::setMercuryAndContainerGeometry ( )

protected

{
    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();
}

Referenced by layout(), and refresh().

setMercuryColor()

void inet::ThermometerFigure::setMercuryColor

(

const Color &

color

)

{
    mercuryFigure->setFillColor(color);
}

Referenced by parse().

setMinValue()

void inet::ThermometerFigure::setMinValue

(

double

value

)

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

Referenced by parse().

setNumberGeometry()

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

protected

{
    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));
}

Referenced by layout(), and redrawTicks().

setTickGeometry()

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

protected

{
    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);
}

Referenced by layout(), and redrawTicks().

setTickSize()

void inet::ThermometerFigure::setTickSize

(

double

value

)

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

Referenced by parse().

setValue()

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

overridevirtual

Implements inet::IIndicatorFigure.

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

Referenced by parse().

Member Data Documentation

bounds

cFigure::Rectangle inet::ThermometerFigure::bounds

protected

Referenced by getBounds(), and setBounds().

containerFigure

cPathFigure* inet::ThermometerFigure::containerFigure

protected

Referenced by addChildren(), and setMercuryAndContainerGeometry().

labelFigure

cTextFigure* inet::ThermometerFigure::labelFigure

protected

Referenced by addChildren(), getLabel(), getLabelColor(), getLabelFont(), layout(), setLabel(), setLabelColor(), setLabelFont(), and setLabelOffset().

labelOffset

int inet::ThermometerFigure::labelOffset = 10

protected

Referenced by getLabelOffset(), layout(), and setLabelOffset().

max

double inet::ThermometerFigure::max = 100

protected

Referenced by getMaxValue(), redrawTicks(), setMaxValue(), setMercuryAndContainerGeometry(), setNumberGeometry(), and setTickGeometry().

mercuryFigure

cPathFigure* inet::ThermometerFigure::mercuryFigure

protected

Referenced by addChildren(), getMercuryColor(), setMercuryAndContainerGeometry(), and setMercuryColor().

min

double inet::ThermometerFigure::min = 0

protected

Referenced by getMinValue(), redrawTicks(), setMercuryAndContainerGeometry(), setMinValue(), setNumberGeometry(), and setTickGeometry().

numberFigures

std::vector<cTextFigure *> inet::ThermometerFigure::numberFigures

protected

Referenced by layout(), redrawTicks(), and ~ThermometerFigure().

numTicks

int inet::ThermometerFigure::numTicks = 0

protected

Referenced by layout(), redrawTicks(), setNumberGeometry(), setTickGeometry(), and ~ThermometerFigure().

shifting

double inet::ThermometerFigure::shifting = 0

protected

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

tickFigures

std::vector<cLineFigure *> inet::ThermometerFigure::tickFigures

protected

Referenced by layout(), redrawTicks(), and ~ThermometerFigure().

tickSize

double inet::ThermometerFigure::tickSize = 10

protected

Referenced by getTickSize(), redrawTicks(), setNumberGeometry(), setTickGeometry(), and setTickSize().

value

double inet::ThermometerFigure::value = NaN

protected

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

---

The documentation for this class was generated from the following files:

• ThermometerFigure.h
• ThermometerFigure.cc