IndexedImageFigure Class Reference

#include <IndexedImageFigure.h>

Inheritance diagram for IndexedImageFigure:

Public Member Functions
	IndexedImageFigure (const char *name=nullptr)
virtual	~IndexedImageFigure ()
virtual void	setValue (int series, simtime_t timestamp, double value) override
const std::vector< std::string > &	getImages () const
void	setImages (const std::vector< std::string > &images)
double	getTintAmount () const
void	setTintAmount (double tintAmount)
const Color &	getTintColor () const
void	setTintColor (const Color &color)
double	getOpacity () const
void	setOpacity (double opacity)
Interpolation	getInterpolation () const
void	setInterpolation (Interpolation interpolation)
const char *	getLabel () const
void	setLabel (const char *text)
const Font &	getLabelFont () const
void	setLabelFont (const Font &font)
const Color &	getLabelColor () const
void	setLabelColor (const Color &color)
const Point	getLabelOffset () const
void	setLabelOffset (const Point &offset)
const Point	getSize () const
void	setSize (const Point &bounds)
const Point &	getPos () const
void	setPos (const Point &point)
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
void	addChildren ()
void	refresh ()

Private Attributes
std::vector< std::string >	images
cImageFigure *	image
cTextFigure *	labelFigure
double	value = NaN

Constructor & Destructor Documentation

IndexedImageFigure::IndexedImageFigure

(

const char *

name = nullptr

)

                                                       : cGroupFigure(name)
{
    addChildren();
}

virtual IndexedImageFigure::~IndexedImageFigure ( )

inlinevirtual

{};

Member Function Documentation

void IndexedImageFigure::addChildren ( )

protected

Referenced by IndexedImageFigure().

{
    labelFigure = new cTextFigure("label");
    image = new cImageFigure("image");

    labelFigure->setAnchor(ANCHOR_N);

    addFigure(image);
    addFigure(labelFigure);
}

const char ** IndexedImageFigure::getAllowedPropertyKeys ( ) const

overrideprotectedvirtual

{
    static const char *keys[32];
    if (!keys[0]) {
        const char *localKeys[] = {
            PKEY_IMAGES, PKEY_TINT_AMOUNT, PKEY_TINT_COLOR, PKEY_OPACITY,
            PKEY_INTERPOLATION, PKEY_LABEL, PKEY_LABEL_FONT, PKEY_LABEL_COLOR,
            PKEY_LABEL_OFFSET, PKEY_INITIAL_VALUE, PKEY_POS, PKEY_SIZE, PKEY_ANCHOR,
            PKEY_BOUNDS, nullptr
        };
        concatArrays(keys, cGroupFigure::getAllowedPropertyKeys(), localKeys);
    }
    return keys;
}

cFigure::Anchor IndexedImageFigure::getAnchor

(

)

const

{
    return image->getAnchor();
}

const std::vector< std::string > & IndexedImageFigure::getImages

(

)

const

Referenced by inet::visualizer::RadioCanvasVisualizer::setImageIndex().

{
    return images;
}

cFigure::Interpolation IndexedImageFigure::getInterpolation

(

)

const

{
    return image->getInterpolation();
}

const char * IndexedImageFigure::getLabel

(

)

const

{
    return labelFigure->getText();
}

const cFigure::Color & IndexedImageFigure::getLabelColor

(

)

const

{
    return labelFigure->getColor();
}

const cFigure::Font & IndexedImageFigure::getLabelFont

(

)

const

{
    return labelFigure->getFont();
}

const cFigure::Point IndexedImageFigure::getLabelOffset

(

)

const

Referenced by setPos().

{
    return labelFigure->getPosition() - image->getPosition();
}

double IndexedImageFigure::getOpacity

(

)

const

{
    return image->getOpacity();
}

const cFigure::Point & IndexedImageFigure::getPos

(

)

const

{
    return image->getPosition();
}

const cFigure::Point IndexedImageFigure::getSize

(

)

const

{
    return Point(image->getWidth(), image->getHeight());
}

double IndexedImageFigure::getTintAmount

(

)

const

{
    return image->getTintAmount();
}

const cFigure::Color & IndexedImageFigure::getTintColor

(

)

const

{
    return image->getTintColor();
}

void IndexedImageFigure::parse ( cProperty *  property )

overrideprotectedvirtual

{
    ASSERT(property->getNumValues(PKEY_IMAGES));
    cGroupFigure::parse(property);

    const char *s;

    std::vector<std::string> names;
    for (int i = 0; i < property->getNumValues(PKEY_IMAGES); ++i)
        names.push_back(property->getValue(PKEY_IMAGES, i));
    setImages(names);

    if (property->containsKey(PKEY_BOUNDS)) {
        if (property->containsKey(PKEY_POS) || property->containsKey(PKEY_SIZE) || property->containsKey(PKEY_ANCHOR))
            throw cRuntimeError("%s, %s and %s are not allowed when %s is present", PKEY_POS, PKEY_SIZE, PKEY_ANCHOR, PKEY_BOUNDS);
        if (property->getNumValues(PKEY_BOUNDS) != 4)
            throw cRuntimeError("%s: x, y, width, height expected", PKEY_BOUNDS);
        Point p = parsePoint(property, PKEY_BOUNDS, 0);
        Point size = parsePoint(property, PKEY_BOUNDS, 2);
        setPos(p);
        setSize(size);
        setAnchor(ANCHOR_NW);
    }
    else {
        setPos(parsePoint(property, PKEY_POS, 0));
        if ((s = property->getValue(PKEY_ANCHOR)) != nullptr)
            setAnchor(parseAnchor(s));
        if ((s = property->getValue(PKEY_SIZE)) != nullptr)
            setSize(parsePoint(property, PKEY_SIZE, 0));
    }
    if ((s = property->getValue(PKEY_TINT_AMOUNT)) != nullptr)
        setTintAmount(utils::atod(s));
    if ((s = property->getValue(PKEY_TINT_COLOR)) != nullptr)
        setTintColor(parseColor(s));
    if ((s = property->getValue(PKEY_OPACITY)) != nullptr)
        setOpacity(atof(s));
    if ((s = property->getValue(PKEY_INTERPOLATION)) != nullptr)
        setInterpolation(parseInterpolation(s));
    if ((s = property->getValue(PKEY_LABEL)) != nullptr)
        setLabel(s);
    if ((s = property->getValue(PKEY_LABEL_FONT)) != nullptr)
        setLabelFont(parseFont(s));
    if ((s = property->getValue(PKEY_LABEL_COLOR)) != nullptr)
        setLabelColor(parseColor(s));
    if (property->containsKey(PKEY_LABEL_OFFSET))
        setLabelOffset(parsePoint(property, PKEY_LABEL_OFFSET, 0));
    if ((s = property->getValue(PKEY_INITIAL_VALUE)) != nullptr)
        setValue(0, simTime(), utils::atod(s));
}

void IndexedImageFigure::refresh ( )

protected

Referenced by setImages(), and setValue().

{
    if (std::isnan(value)) {
        image->setVisible(false);
        return;
    }

    image->setVisible(true);
    int newValue = (int)value % images.size();
    image->setImageName(images[newValue].c_str());
}

void IndexedImageFigure::setAnchor

(

Anchor

anchor

)

Referenced by parse().

{
    image->setAnchor(anchor);
}

void IndexedImageFigure::setImages

(

const std::vector< std::string > &

images

)

Referenced by inet::visualizer::RadioCanvasVisualizer::createRadioVisualization(), and parse().

{
    ASSERT(images.size());
    this->images = images;
    refresh();
}

void IndexedImageFigure::setInterpolation

(

Interpolation

interpolation

)

Referenced by parse().

{
    image->setInterpolation(interpolation);
}

void IndexedImageFigure::setLabel

(

const char *

text

)

Referenced by parse().

{
    labelFigure->setText(text);
}

void IndexedImageFigure::setLabelColor

(

const Color &

color

)

Referenced by parse().

{
    labelFigure->setColor(color);
}

void IndexedImageFigure::setLabelFont

(

const Font &

font

)

Referenced by parse().

{
    labelFigure->setFont(font);
}

void IndexedImageFigure::setLabelOffset

(

const Point &

offset

)

Referenced by parse(), and setPos().

{
    labelFigure->setPosition(image->getPosition() + offset);
}

void IndexedImageFigure::setOpacity

(

double

opacity

)

Referenced by parse().

{
    image->setOpacity(opacity);
}

void IndexedImageFigure::setPos

(

const Point &

point

)

Referenced by parse().

{
    Point offset = getLabelOffset();
    image->setPosition(pos);
    setLabelOffset(offset);
}

void IndexedImageFigure::setSize

(

const Point &

bounds

)

Referenced by inet::visualizer::RadioCanvasVisualizer::createRadioVisualization(), and parse().

{
    image->setWidth(bounds.x);
    image->setHeight(bounds.y);
}

void IndexedImageFigure::setTintAmount

(

double

tintAmount

)

Referenced by parse().

{
    image->setTintAmount(tintAmount);
}

void IndexedImageFigure::setTintColor

(

const Color &

color

)

Referenced by parse().

{
    image->setTintColor(color);
}

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

overridevirtual

Implements inet::IIndicatorFigure.

Referenced by parse(), and inet::visualizer::RadioCanvasVisualizer::setImageIndex().

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

Member Data Documentation

cImageFigure* IndexedImageFigure::image

private

Referenced by addChildren(), getAnchor(), getInterpolation(), getLabelOffset(), getOpacity(), getPos(), getSize(), getTintAmount(), getTintColor(), refresh(), setAnchor(), setInterpolation(), setLabelOffset(), setOpacity(), setPos(), setSize(), setTintAmount(), and setTintColor().

std::vector<std::string> IndexedImageFigure::images

private

Referenced by getImages(), refresh(), and setImages().

cTextFigure* IndexedImageFigure::labelFigure

private

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

double IndexedImageFigure::value = NaN

private

Referenced by refresh(), and setValue().

---

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

• IndexedImageFigure.h
• IndexedImageFigure.cc