inet::CounterFigure Class Reference

#include <CounterFigure.h>

Inheritance diagram for inet::CounterFigure:

Classes
struct	Digit

Public Member Functions
	CounterFigure (const char *name=nullptr)
virtual	~CounterFigure ()
virtual void	setValue (int series, simtime_t timestamp, double value) override
virtual const Point	getSize () const override
const Color &	getBackgroundColor () const
void	setBackgroundColor (const Color &color)
int	getDecimalPlaces () const
void	setDecimalPlaces (int radius)
Color	getDigitBackgroundColor () const
void	setDigitBackgroundColor (const Color &color)
Color	getDigitBorderColor () const
void	setDigitBorderColor (const Color &color)
Font	getDigitFont () const
void	setDigitFont (const Font &font)
Color	getDigitColor () const
void	setDigitColor (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)
const Point &	getLabelPos () const
void	setLabelPos (const Point &pos)
Anchor	getLabelAnchor () const
void	setLabelAnchor (Anchor anchor)
Point	getPos () const
void	setPos (const Point &bounds)
Anchor	getAnchor () const
void	setAnchor (Anchor anchor)
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
Point	calculateRealPos (const Point &pos)
void	calculateBounds ()
void	addChildren ()
void	refresh ()
void	layout ()

Private Attributes
cRectangleFigure *	backgroundFigure
std::vector< Digit >	digits
cTextFigure *	labelFigure
double	value = NaN
int	labelOffset = 10
Anchor	anchor = ANCHOR_NW

Constructor & Destructor Documentation

CounterFigure()

inet::CounterFigure::CounterFigure

(

const char *

name = nullptr

)

                                             : cGroupFigure(name)
{
    addChildren();
}

~CounterFigure()

virtual inet::CounterFigure::~CounterFigure ( )

inlinevirtual

{}

Member Function Documentation

addChildren()

void inet::CounterFigure::addChildren ( )

protected

{
    backgroundFigure = new cRectangleFigure("background");
    labelFigure = new cTextFigure("label");
 
    backgroundFigure->setFilled(true);
    backgroundFigure->setFillColor(Color(INIT_BACKGROUND_COLOR));
    backgroundFigure->setZoomLineWidth(true);
 
    labelFigure->setAnchor(ANCHOR_N);
 
    addFigure(backgroundFigure);
    addFigure(labelFigure);
}

Referenced by CounterFigure().

calculateBounds()

void inet::CounterFigure::calculateBounds ( )

protected

{
    double rectWidth = getDigitFont().pointSize * DIGIT_WIDTH_PERCENT;
    double rectHeight = getDigitFont().pointSize * DIGIT_HEIGHT_PERCENT;
 
    Rectangle bounds = backgroundFigure->getBounds();
    backgroundFigure->setBounds(Rectangle(0, 0, 2 * PADDING + (rectWidth + DIGIT_PADDING) * digits.size(), rectHeight + 2 * PADDING));
    Point pos = calculateRealPos(Point(bounds.x, bounds.y));
    bounds = backgroundFigure->getBounds();
    bounds.x = pos.x;
    bounds.y = pos.y;
    backgroundFigure->setBounds(bounds);
}

Referenced by setAnchor(), setDecimalPlaces(), and setDigitFont().

calculateRealPos()

cFigure::Point inet::CounterFigure::calculateRealPos ( const Point &  pos )

protected

{
    Rectangle bounds = backgroundFigure->getBounds();
    Point position = pos;
    switch (anchor) {
        case cFigure::ANCHOR_CENTER:
            position.x -= bounds.width / 2;
            position.y -= bounds.height / 2;
            break;
 
        case cFigure::ANCHOR_N:
            position.x -= bounds.width / 2;
            break;
 
        case cFigure::ANCHOR_E:
            position.x -= bounds.width;
            position.y -= bounds.height / 2;
            break;
 
        case cFigure::ANCHOR_S:
        case cFigure::ANCHOR_BASELINE_MIDDLE:
            position.x -= bounds.width / 2;
            position.y -= bounds.height;
            break;
 
        case cFigure::ANCHOR_W:
            position.y -= bounds.height / 2;
            break;
 
        case cFigure::ANCHOR_NW:
            break;
 
        case cFigure::ANCHOR_NE:
            position.x -= bounds.width;
            break;
 
        case cFigure::ANCHOR_SE:
        case cFigure::ANCHOR_BASELINE_END:
            position.x -= bounds.width;
            position.y -= bounds.height;
            break;
 
        case cFigure::ANCHOR_SW:
        case cFigure::ANCHOR_BASELINE_START:
            position.y -= bounds.width;
            break;
    }
    return position;
}

Referenced by calculateBounds(), and setPos().

getAllowedPropertyKeys()

const char ** inet::CounterFigure::getAllowedPropertyKeys ( ) const

overrideprotectedvirtual

{
    static const char *keys[32];
    if (!keys[0]) {
        const char *localKeys[] = {
            PKEY_BACKGROUND_COLOR, PKEY_DECIMAL_PLACES, PKEY_DIGIT_BACKGROUND_COLOR,
            PKEY_DIGIT_BORDER_COLOR, PKEY_DIGIT_FONT, PKEY_DIGIT_COLOR, PKEY_LABEL, PKEY_LABEL_FONT,
            PKEY_LABEL_COLOR, PKEY_INITIAL_VALUE, PKEY_POS, PKEY_ANCHOR, PKEY_LABEL_OFFSET, nullptr
        };
        concatArrays(keys, cGroupFigure::getAllowedPropertyKeys(), localKeys);
    }
    return keys;
}

getAnchor()

cFigure::Anchor inet::CounterFigure::getAnchor

(

)

const

{
    return anchor;
}

getBackgroundColor()

const cFigure::Color & inet::CounterFigure::getBackgroundColor

(

)

const

{
    return backgroundFigure->getFillColor();
}

getDecimalPlaces()

int inet::CounterFigure::getDecimalPlaces

(

)

const

{
    return digits.size();
}

getDigitBackgroundColor()

cFigure::Color inet::CounterFigure::getDigitBackgroundColor

(

)

const

{
    return digits.size() ? digits[0].bounds->getFillColor() : Color(INIT_DIGIT_BACKGROUND_COLOR);
}

Referenced by setDecimalPlaces().

getDigitBorderColor()

cFigure::Color inet::CounterFigure::getDigitBorderColor

(

)

const

{
    return digits.size() ? digits[0].bounds->getLineColor() : Color(INIT_DIGIT_BORDER_COLOR);
}

getDigitColor()

cFigure::Color inet::CounterFigure::getDigitColor

(

)

const

{
    return digits.size() ? digits[0].text->getColor() : Color(INIT_DIGIT_TEXT_COLOR);
}

getDigitFont()

cFigure::Font inet::CounterFigure::getDigitFont

(

)

const

{
    return digits.size() ? digits[0].text->getFont() : Font(INIT_FONT_NAME, INIT_FONT_SIZE, cFigure::FONT_BOLD);
}

Referenced by calculateBounds(), layout(), and setDecimalPlaces().

getLabel()

const char * inet::CounterFigure::getLabel

(

)

const

{
    return labelFigure->getText();
}

getLabelAnchor()

Anchor inet::CounterFigure::getLabelAnchor

(

)

const

getLabelColor()

const cFigure::Color & inet::CounterFigure::getLabelColor

(

)

const

{
    return labelFigure->getColor();
}

getLabelFont()

const cFigure::Font & inet::CounterFigure::getLabelFont

(

)

const

{
    return labelFigure->getFont();
}

getLabelOffset()

int inet::CounterFigure::getLabelOffset

(

)

const

{
    return labelOffset;
}

getLabelPos()

const Point& inet::CounterFigure::getLabelPos

(

)

const

getPos()

cFigure::Point inet::CounterFigure::getPos

(

)

const

{
    Rectangle bounds = backgroundFigure->getBounds();
    switch (anchor) {
        case cFigure::ANCHOR_CENTER:
            bounds.x += bounds.width / 2;
            bounds.y += bounds.height / 2;
            break;
 
        case cFigure::ANCHOR_N:
            bounds.x += bounds.width / 2;
            break;
 
        case cFigure::ANCHOR_E:
            bounds.x += bounds.width;
            bounds.y += bounds.height / 2;
            break;
 
        case cFigure::ANCHOR_S:
        case cFigure::ANCHOR_BASELINE_MIDDLE:
            bounds.x += bounds.width / 2;
            bounds.y += bounds.height;
            break;
 
        case cFigure::ANCHOR_W:
            bounds.y += bounds.height / 2;
            break;
 
        case cFigure::ANCHOR_NW:
            break;
 
        case cFigure::ANCHOR_NE:
            bounds.x += bounds.width;
            break;
 
        case cFigure::ANCHOR_SE:
        case cFigure::ANCHOR_BASELINE_END:
            bounds.x += bounds.width;
            bounds.y += bounds.height;
            break;
 
        case cFigure::ANCHOR_SW:
        case cFigure::ANCHOR_BASELINE_START:
            bounds.y += bounds.width;
            break;
    }
    return Point(bounds.x, bounds.y);
}

getSize()

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

inlineoverridevirtual

Implements inet::IIndicatorFigure.

{ return backgroundFigure->getBounds().getSize(); }

layout()

void inet::CounterFigure::layout ( )

protected

{
    Rectangle bounds = backgroundFigure->getBounds();
 
    // Add frame
    bounds.x += PADDING + DIGIT_PADDING / 2;
 
    for (uint32_t i = 0; i < digits.size(); ++i) {
        double rectWidth = getDigitFont().pointSize * DIGIT_WIDTH_PERCENT;
        double rectHeight = getDigitFont().pointSize * DIGIT_HEIGHT_PERCENT;
        double x = bounds.x + (rectWidth + DIGIT_PADDING) * i;
        double y = bounds.y + PADDING;
 
        digits[i].bounds->setBounds(Rectangle(x, y, rectWidth, rectHeight));
        digits[i].text->setPosition(digits[i].bounds->getBounds().getCenter());
    }
 
    labelFigure->setPosition(Point(bounds.x + bounds.width / 2, bounds.y + bounds.height + labelOffset));
}

Referenced by setAnchor(), setDecimalPlaces(), setDigitFont(), and setPos().

parse()

void inet::CounterFigure::parse ( cProperty *  property )

overrideprotectedvirtual

{
    cGroupFigure::parse(property);
 
    const char *s;
 
    setPos(parsePoint(property, PKEY_POS, 0));
 
    if ((s = property->getValue(PKEY_BACKGROUND_COLOR)) != nullptr)
        setBackgroundColor(parseColor(s));
    if ((s = property->getValue(PKEY_ANCHOR)) != nullptr)
        setAnchor(parseAnchor(s));
    if ((s = property->getValue(PKEY_DECIMAL_PLACES)) != nullptr)
        setDecimalPlaces(utils::atod(s));
    else
        setDecimalPlaces(INIT_DECIMAL_PLACES);
    if ((s = property->getValue(PKEY_DIGIT_FONT)) != nullptr)
        setDigitFont(parseFont(s));
    if ((s = property->getValue(PKEY_DIGIT_BACKGROUND_COLOR)) != nullptr)
        setDigitBackgroundColor(parseColor(s));
    if ((s = property->getValue(PKEY_DIGIT_BORDER_COLOR)) != nullptr)
        setDigitBorderColor(Color(parseColor(s)));
    if ((s = property->getValue(PKEY_DIGIT_COLOR)) != nullptr)
        setDigitColor(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));
    if ((s = property->getValue(PKEY_INITIAL_VALUE)) != nullptr)
        setValue(0, simTime(), utils::atod(s));
 
    refresh();
}

refresh()

void inet::CounterFigure::refresh ( )

protected

{
    // update displayed number
    int max = std::pow(10, digits.size());
    if (std::isnan(value))
        for (Digit digit : digits)
            digit.text->setText("");
 
    else if (value >= max || value < 0)
        for (Digit digit : digits)
            digit.text->setText("*");
 
    else {
        int pow = 1;
        for (int i = digits.size() - 1; i >= 0; --i) {
            char buf[32];
            pow *= 10;
            int actValue = ((int)value % pow) / (pow / 10);
            sprintf(buf, "%d", actValue);
            digits[i].text->setText(buf);
        }
    }
}

Referenced by parse(), and setValue().

setAnchor()

void inet::CounterFigure::setAnchor

(

Anchor

anchor

)

{
    if (anchor != this->anchor) {
        this->anchor = anchor;
 
        calculateBounds();
        layout();
    }
}

Referenced by parse().

setBackgroundColor()

void inet::CounterFigure::setBackgroundColor

(

const Color &

color

)

{
    backgroundFigure->setFillColor(color);
}

Referenced by parse().

setDecimalPlaces()

void inet::CounterFigure::setDecimalPlaces

(

int

radius

)

{
    ASSERT(number > 0);
    if (digits.size() != (unsigned int)number) {
        if (digits.size() > (unsigned int)number)
            // Remove unnecessary figures from canvas
            for (int i = digits.size() - 1; i > number - 1; --i) {
                delete removeFigure(digits[i].bounds);
                delete removeFigure(digits[i].text);
                digits.pop_back();
            }
        else
            // Add figure to canvas if it's necessary
            while (digits.size() < (unsigned int)number) {
                Digit digit(new cRectangleFigure(), new cTextFigure());
                digit.bounds->setFilled(true);
                digit.bounds->setFillColor(getDigitBackgroundColor());
                digit.bounds->setZoomLineWidth(true);
                digit.text->setAnchor(ANCHOR_CENTER);
                digit.text->setFont(getDigitFont());
 
                addFigure(digit.bounds);
                addFigure(digit.text);
 
                digits.push_back(digit);
            }
 
        calculateBounds();
        layout();
    }
}

Referenced by parse().

setDigitBackgroundColor()

void inet::CounterFigure::setDigitBackgroundColor

(

const Color &

color

)

{
    for (Digit digit : digits)
        digit.bounds->setFillColor(color);
}

Referenced by parse().

setDigitBorderColor()

void inet::CounterFigure::setDigitBorderColor

(

const Color &

color

)

{
    for (Digit digit : digits)
        digit.bounds->setLineColor(color);
}

Referenced by parse().

setDigitColor()

void inet::CounterFigure::setDigitColor

(

const Color &

color

)

{
    for (Digit digit : digits)
        digit.text->setColor(color);
}

Referenced by parse().

setDigitFont()

void inet::CounterFigure::setDigitFont

(

const Font &

font

)

{
    for (Digit digit : digits)
        digit.text->setFont(font);
 
    calculateBounds();
    layout();
}

Referenced by parse().

setLabel()

void inet::CounterFigure::setLabel

(

const char *

text

)

{
    labelFigure->setText(text);
}

Referenced by parse().

setLabelAnchor()

void inet::CounterFigure::setLabelAnchor

(

Anchor

anchor

)

setLabelColor()

void inet::CounterFigure::setLabelColor

(

const Color &

color

)

{
    labelFigure->setColor(color);
}

Referenced by parse().

setLabelFont()

void inet::CounterFigure::setLabelFont

(

const Font &

font

)

{
    labelFigure->setFont(font);
}

Referenced by parse().

setLabelOffset()

void inet::CounterFigure::setLabelOffset

(

int

offset

)

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

Referenced by parse().

setLabelPos()

void inet::CounterFigure::setLabelPos

(

const Point &

pos

)

setPos()

void inet::CounterFigure::setPos

(

const Point &

bounds

)

{
    Rectangle bounds = backgroundFigure->getBounds();
    Point backgroundPos = calculateRealPos(pos);
    bounds.x = backgroundPos.x;
    bounds.y = backgroundPos.y;
 
    backgroundFigure->setBounds(bounds);
    layout();
}

Referenced by parse().

setValue()

void inet::CounterFigure::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

anchor

Anchor inet::CounterFigure::anchor = ANCHOR_NW

private

Referenced by calculateRealPos(), getAnchor(), getPos(), and setAnchor().

backgroundFigure

cRectangleFigure* inet::CounterFigure::backgroundFigure

private

Referenced by addChildren(), calculateBounds(), calculateRealPos(), getBackgroundColor(), getPos(), layout(), setBackgroundColor(), setLabelOffset(), and setPos().

digits

std::vector<Digit> inet::CounterFigure::digits

private

Referenced by calculateBounds(), getDecimalPlaces(), getDigitBackgroundColor(), getDigitBorderColor(), getDigitColor(), getDigitFont(), layout(), refresh(), setDecimalPlaces(), setDigitBackgroundColor(), setDigitBorderColor(), setDigitColor(), and setDigitFont().

labelFigure

cTextFigure* inet::CounterFigure::labelFigure

private

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

labelOffset

int inet::CounterFigure::labelOffset = 10

private

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

value

double inet::CounterFigure::value = NaN

private

Referenced by refresh(), and setValue().

---

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

• CounterFigure.h
• CounterFigure.cc