inet::PlotFigure Class Reference

#include <PlotFigure.h>

Inheritance diagram for inet::PlotFigure:

Classes
struct	Tick

Public Member Functions
	PlotFigure (const char *name=nullptr)
virtual	~PlotFigure ()
virtual void	parse (cProperty *property) override
const char **	getAllowedPropertyKeys () const override
virtual void	refreshDisplay () override
virtual void	setNumSeries (int numSeries)
virtual int	getNumSeries () const override
virtual void	setValue (int series, simtime_t timestamp, double value) override
virtual void	setValue (int series, double x, double y)
virtual void	clearValues (int series)
const Point	getPlotSize () const
void	setPlotSize (const Point &p)
virtual const Point	getSize () const override
const Rectangle &	getBounds () const
void	setBounds (const Rectangle &rect)
const Color &	getBackgrouncColor () const
void	setBackgroundColor (const Color &color)
double	getXTickSize () const
void	setXTickSize (double size)
void	setXTickCount (int count)
double	getYTickSize () const
void	setYTickSize (double size)
void	setYTickCount (int count)
double	getTimeWindow () const
void	setTimeWindow (double timeWindow)
const Color &	getLineColor (int series) const
void	setLineColor (int series, const Color &color)
double	getMinX () const
void	setMinX (double value)
double	getMaxX () const
void	setMaxX (double value)
double	getMinY () const
void	setMinY (double value)
double	getMaxY () const
void	setMaxY (double value)
void	setXValueFormat (const char *format)
void	setYValueFormat (const char *format)
const char *	getXAxisLabel () const
void	setXAxisLabel (const char *text)
const char *	getYAxisLabel () const
void	setYAxisLabel (const char *text)
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)
Public Member Functions inherited from inet::IIndicatorFigure
virtual	~IIndicatorFigure ()

Protected Member Functions
void	redrawYTicks ()
void	redrawXTicks ()
void	addChildren ()
void	layout ()
void	plot ()

Private Attributes
std::vector< cPathFigure * >	seriesPlotFigures
cLabelFigure *	labelFigure
cLabelFigure *	xAxisLabelFigure
cLabelFigure *	yAxisLabelFigure
cRectangleFigure *	backgroundFigure
std::vector< Tick >	xTicks
std::vector< Tick >	yTicks
Rectangle	bounds
int	numSeries = -1
double	timeWindow = NaN
double	yTickSize = INFINITY
double	xTickSize = INFINITY
int	labelOffset = 0
double	minX = 0
double	maxX = 1
double	minY = 0
double	maxY = 1
const char *	xValueFormat = "%g"
const char *	yValueFormat = "%g"
bool	invalidLayout = true
bool	invalidPlot = true
std::vector< std::list< std::pair< double, double > > >	seriesValues

Constructor & Destructor Documentation

PlotFigure()

inet::PlotFigure::PlotFigure

(

const char *

name = nullptr

)

                                       : cGroupFigure(name)
{
    addChildren();
    setNumSeries(1);
}

~PlotFigure()

virtual inet::PlotFigure::~PlotFigure ( )

inlinevirtual

{}

Member Function Documentation

addChildren()

void inet::PlotFigure::addChildren ( )

protected

{
    labelFigure = new cLabelFigure("label");
    labelFigure->setAnchor(ANCHOR_N);
    xAxisLabelFigure = new cLabelFigure("X axis label");
    xAxisLabelFigure->setAnchor(ANCHOR_S);
    yAxisLabelFigure = new cLabelFigure("Y axis label");
    yAxisLabelFigure->setAnchor(ANCHOR_S);
    yAxisLabelFigure->setAngle(M_PI / 2);
    backgroundFigure = new cRectangleFigure("bounds");
 
    backgroundFigure->setFilled(true);
    backgroundFigure->setFillColor(INIT_BACKGROUND_COLOR);
 
    addFigure(backgroundFigure);
    addFigure(labelFigure);
    addFigure(xAxisLabelFigure);
    addFigure(yAxisLabelFigure);
}

Referenced by PlotFigure().

clearValues()

virtual void inet::PlotFigure::clearValues ( int  series )

inlinevirtual

{ seriesValues[series].clear(); invalidPlot = true; }

getAllowedPropertyKeys()

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

override

{
    static const char *keys[32];
    if (!keys[0]) {
        const char *localKeys[] = {
            PKEY_Y_TICK_SIZE, PKEY_TIME_WINDOW, PKEY_X_TICK_SIZE,
            PKEY_LINE_COLOR, PKEY_MIN_X, PKEY_MAX_X, PKEY_MIN_Y, PKEY_MAX_Y, PKEY_BACKGROUND_COLOR,
            PKEY_LABEL, PKEY_LABEL_OFFSET, PKEY_LABEL_COLOR, PKEY_LABEL_FONT, PKEY_POS,
            PKEY_SIZE, PKEY_ANCHOR, PKEY_BOUNDS, nullptr
        };
        concatArrays(keys, cGroupFigure::getAllowedPropertyKeys(), localKeys);
    }
    return keys;
}

getBackgrouncColor()

const cFigure::Color & inet::PlotFigure::getBackgrouncColor

(

)

const

{
    return backgroundFigure->getFillColor();
}

getBounds()

const cFigure::Rectangle & inet::PlotFigure::getBounds

(

)

const

{
    if (invalidLayout)
        const_cast<PlotFigure *>(this)->layout();
    return bounds;
}

Referenced by parse().

getLabel()

const char* inet::PlotFigure::getLabel ( ) const

inline

{ return labelFigure->getText(); }

getLabelColor()

const cFigure::Color & inet::PlotFigure::getLabelColor

(

)

const

{
    return labelFigure->getColor();
}

getLabelFont()

const cFigure::Font & inet::PlotFigure::getLabelFont

(

)

const

{
    return labelFigure->getFont();
}

getLabelOffset()

int inet::PlotFigure::getLabelOffset

(

)

const

{
    return labelOffset;
}

getLineColor()

const cFigure::Color & inet::PlotFigure::getLineColor

(

int

series

)

const

{
    return seriesPlotFigures[series]->getLineColor();
}

getMaxX()

double inet::PlotFigure::getMaxX ( ) const

inline

{ return maxX; }

getMaxY()

double inet::PlotFigure::getMaxY ( ) const

inline

{ return maxY; }

getMinX()

double inet::PlotFigure::getMinX ( ) const

inline

{ return minX; }

getMinY()

double inet::PlotFigure::getMinY ( ) const

inline

{ return minY; }

getNumSeries()

virtual int inet::PlotFigure::getNumSeries ( ) const

inlineoverridevirtual

Reimplemented from inet::IIndicatorFigure.

{ return numSeries; }

getPlotSize()

const Point inet::PlotFigure::getPlotSize ( ) const

inline

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

getSize()

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

inlineoverridevirtual

Implements inet::IIndicatorFigure.

{ return getBounds().getSize(); }

getTimeWindow()

double inet::PlotFigure::getTimeWindow

(

)

const

{
    return timeWindow;
}

getXAxisLabel()

const char* inet::PlotFigure::getXAxisLabel ( ) const

inline

{ return xAxisLabelFigure->getText(); }

getXTickSize()

double inet::PlotFigure::getXTickSize

(

)

const

{
    return xTickSize;
}

getYAxisLabel()

const char* inet::PlotFigure::getYAxisLabel ( ) const

inline

{ return yAxisLabelFigure->getText(); }

getYTickSize()

double inet::PlotFigure::getYTickSize

(

)

const

{
    return yTickSize;
}

layout()

void inet::PlotFigure::layout ( )

protected

{
    redrawXTicks();
    redrawYTicks();
 
    Rectangle b = backgroundFigure->getBounds();
    double fontSize = xTicks.size() > 0 && xTicks[0].number ? xTicks[0].number->getFont().pointSize : 12;
    labelFigure->setPosition(Point(b.getCenter().x, b.y + b.height + fontSize * LABEL_Y_DISTANCE_FACTOR + labelOffset));
    xAxisLabelFigure->setPosition(Point(b.x + b.width / 2, b.y - 5));
    yAxisLabelFigure->setPosition(Point(-5, b.height / 2));
 
    bounds = backgroundFigure->getBounds();
    bounds = rectangleUnion(bounds, labelFigure->getBounds());
    bounds.x -= fontSize;
    bounds.y -= fontSize;
    bounds.width += 2 * fontSize;
    bounds.height += 2 * fontSize;
    invalidLayout = false;
}

Referenced by getBounds(), and refreshDisplay().

parse()

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

overridevirtual

{
    cGroupFigure::parse(property);
 
    const char *s;
 
    setBounds(parseBounds(property, getBounds()));
 
    if ((s = property->getValue(PKEY_BACKGROUND_COLOR)) != nullptr)
        setBackgroundColor(parseColor(s));
    if ((s = property->getValue(PKEY_X_TICK_SIZE)) != nullptr)
        setXTickSize(atoi(s));
    if ((s = property->getValue(PKEY_Y_TICK_SIZE)) != nullptr)
        setYTickSize(atoi(s));
    if ((s = property->getValue(PKEY_TIME_WINDOW)) != nullptr)
        setTimeWindow(atoi(s));
    if ((s = property->getValue(PKEY_LINE_COLOR)) != nullptr) {
        for (int i = 0; i < numSeries; i++)
            setLineColor(i, parseColor(s));
    }
    if ((s = property->getValue(PKEY_MIN_X)) != nullptr)
        setMinX(atof(s));
    if ((s = property->getValue(PKEY_MAX_X)) != nullptr)
        setMaxX(atof(s));
    if ((s = property->getValue(PKEY_MIN_Y)) != nullptr)
        setMinY(atof(s));
    if ((s = property->getValue(PKEY_MAX_Y)) != nullptr)
        setMaxY(atof(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_COLOR)) != nullptr)
        setLabelColor(parseColor(s));
    if ((s = property->getValue(PKEY_LABEL_FONT)) != nullptr)
        setLabelFont(parseFont(s));
    refreshDisplay();
}

plot()

void inet::PlotFigure::plot ( )

protected

{
    double minX = std::isnan(timeWindow) ? this->minX : simTime().dbl() - timeWindow;
    double maxX = std::isnan(timeWindow) ? this->maxX : simTime().dbl();
 
    for (int i = 0; i < numSeries; i++) {
        auto values = seriesValues[i];
        auto plotFigure = seriesPlotFigures[i];
        plotFigure->clearPath();
 
        if (values.size() < 2)
            continue;
        if (minX > values.front().first) {
            values.clear();
            continue;
        }
 
        auto r = backgroundFigure->getBounds();
        auto it = values.begin();
        double startX = r.x + r.width - (maxX - it->first) / (maxX - minX) * r.width;
        double startY = std::min(r.y + 100 * r.height, r.y + (maxY - it->second) / std::abs(maxY - minY) * r.height);
        plotFigure->addMoveTo(startX, startY);
 
        ++it;
        do {
            double endX = r.x + r.width - (maxX - it->first) / (maxX - minX) * r.width;
            double endY = std::min(r.y + 100 * r.height, r.y + (maxY - it->second) / std::abs(maxY - minY) * r.height);
 
            double originalStartX = startX;
            double originalStartY = startY;
            double originalEndX = endX;
            double originalEndY = endY;
            if (InstrumentUtil::CohenSutherlandLineClip(startX, startY, endX, endY, r.x, r.x + r.width, r.y, r.y + r.height)) {
                if (originalStartX != startX || originalStartY != startY)
                    plotFigure->addMoveTo(startX, startY);
 
                plotFigure->addLineTo(endX, endY);
            }
 
            if (minX > it->first)
                break;
 
            startX = originalEndX;
            startY = originalEndY;
            ++it;
        } while (it != values.end());
 
        // Delete old elements
        if (!std::isnan(timeWindow) && it != values.end())
            values.erase(++it, values.end());
    }
}

Referenced by refreshDisplay().

redrawXTicks()

void inet::PlotFigure::redrawXTicks ( )

protected

{
    Rectangle bounds = backgroundFigure->getBounds();
    double minX = std::isnan(timeWindow) ? this->minX : simTime().dbl() - timeWindow;
    double maxX = std::isnan(timeWindow) ? this->maxX : simTime().dbl();
 
    double shifting = 0;
    if (!std::isnan(timeWindow)) {
        double fraction = std::abs(fmod((minX / xTickSize), 1));
        shifting = xTickSize * (minX < 0 ? fraction : 1 - fraction);
        // if fraction == 0 then shifting == xTickSize therefore don't have to shift the X ticks
        if (shifting == xTickSize)
            shifting = 0;
    }
 
    int numTicks = std::isfinite(xTickSize) ? ((maxX - minX) - shifting) / xTickSize + 1 : 0;
 
    // Allocate ticks and numbers if needed
    if ((size_t)numTicks > xTicks.size())
        while ((size_t)numTicks > xTicks.size()) {
            cLineFigure *tick = new cLineFigure("xTick");
            cLineFigure *dashLine = new cLineFigure("xDashLine");
            cLabelFigure *number = new cLabelFigure("xNumber");
 
            dashLine->setLineStyle(LINE_DASHED);
 
            number->setAnchor(ANCHOR_N);
            auto plotFigure = seriesPlotFigures[seriesPlotFigures.size() - 1];
            tick->insertBelow(plotFigure);
            dashLine->insertBelow(plotFigure);
            number->insertBelow(plotFigure);
            xTicks.push_back(Tick(tick, dashLine, number));
        }
    else
        // Add or remove figures from canvas according to previous number of ticks
        for (int i = xTicks.size() - 1; i >= numTicks; --i) {
            delete removeFigure(xTicks[i].number);
            delete removeFigure(xTicks[i].dashLine);
            delete removeFigure(xTicks[i].tick);
            xTicks.pop_back();
        }
 
    for (uint32_t i = 0; i < xTicks.size(); ++i) {
        double x = bounds.x + bounds.width * (i * xTickSize + shifting) / (maxX - minX);
        double y = bounds.y + bounds.height;
        if (x > bounds.x && x < bounds.x + bounds.width) {
            xTicks[i].tick->setVisible(true);
            xTicks[i].tick->setStart(Point(x, y));
            xTicks[i].tick->setEnd(Point(x, y - TICK_LENGTH));
 
            xTicks[i].dashLine->setVisible(true);
            xTicks[i].dashLine->setStart(Point(x, y - TICK_LENGTH));
            xTicks[i].dashLine->setEnd(Point(x, bounds.y));
        }
        else {
            xTicks[i].tick->setVisible(false);
            xTicks[i].dashLine->setVisible(false);
        }
 
        char buf[32];
        double number = minX + i * xTickSize + shifting;
 
        sprintf(buf, xValueFormat, number);
        xTicks[i].number->setText(buf);
        xTicks[i].number->setPosition(Point(x, y + 5));
    }
}

Referenced by layout(), and refreshDisplay().

redrawYTicks()

void inet::PlotFigure::redrawYTicks ( )

protected

{
    Rectangle bounds = backgroundFigure->getBounds();
    int numTicks = std::isfinite(yTickSize) ? std::abs(maxY - minY) / yTickSize + 1 : 0;
 
    double valueTickYposAdjust[2] = { 0, 0 };
    int fontSize = labelFigure->getFont().pointSize;
    if (yTicks.size() == 1) {
        valueTickYposAdjust[0] = -(fontSize / 2);
        valueTickYposAdjust[1] = fontSize / 2;
    }
 
    // Allocate ticks and numbers if needed
    if ((size_t)numTicks > yTicks.size())
        while ((size_t)numTicks > yTicks.size()) {
            cLineFigure *tick = new cLineFigure("yTick");
            cLineFigure *dashLine = new cLineFigure("yDashLine");
            cLabelFigure *number = new cLabelFigure("yNumber");
 
            dashLine->setLineStyle(LINE_DASHED);
 
            number->setAnchor(ANCHOR_W);
            auto plotFigure = seriesPlotFigures[seriesPlotFigures.size() - 1];
            tick->insertBelow(plotFigure);
            dashLine->insertBelow(plotFigure);
            number->insertBelow(plotFigure);
            yTicks.push_back(Tick(tick, dashLine, number));
        }
    else
        // Add or remove figures from canvas according to previous number of ticks
        for (int i = yTicks.size() - 1; i >= numTicks; --i) {
            delete removeFigure(yTicks[i].number);
            delete removeFigure(yTicks[i].dashLine);
            delete removeFigure(yTicks[i].tick);
            yTicks.pop_back();
        }
 
    for (size_t i = 0; i < yTicks.size(); ++i) {
        double x = bounds.x + bounds.width;
        double y = bounds.y + bounds.height - bounds.height * (i * yTickSize) / std::abs(maxY - minY);
        if (y > bounds.y && y < bounds.y + bounds.height) {
            yTicks[i].tick->setVisible(true);
            yTicks[i].tick->setStart(Point(x, y));
            yTicks[i].tick->setEnd(Point(x - TICK_LENGTH, y));
 
            yTicks[i].dashLine->setVisible(true);
            yTicks[i].dashLine->setStart(Point(x - TICK_LENGTH, y));
            yTicks[i].dashLine->setEnd(Point(bounds.x, y));
        }
        else {
            yTicks[i].tick->setVisible(false);
            yTicks[i].dashLine->setVisible(false);
        }
 
        char buf[32];
        sprintf(buf, yValueFormat, minY + i * yTickSize);
        yTicks[i].number->setText(buf);
        yTicks[i].number->setPosition(Point(x + 5, y + valueTickYposAdjust[i % 2]));
    }
}

Referenced by layout().

refreshDisplay()

void inet::PlotFigure::refreshDisplay ( )

overridevirtual

Reimplemented from inet::IIndicatorFigure.

{
    if (invalidLayout)
        layout();
    else if (!std::isnan(timeWindow))
        redrawXTicks();
    if (invalidPlot)
        plot();
}

Referenced by parse().

setBackgroundColor()

void inet::PlotFigure::setBackgroundColor

(

const Color &

color

)

{
    backgroundFigure->setFillColor(color);
}

Referenced by parse().

setBounds()

void inet::PlotFigure::setBounds

(

const Rectangle &

rect

)

{
    const auto& backgroundBounds = backgroundFigure->getBounds();
    backgroundFigure->setBounds(Rectangle(backgroundBounds.x + rect.x - bounds.x, backgroundBounds.y + rect.y - bounds.y, rect.width - (bounds.width - backgroundBounds.width), rect.height - (bounds.height - backgroundBounds.height)));
    invalidLayout = true;
}

Referenced by parse().

setLabel()

void inet::PlotFigure::setLabel ( const char *  text )

inline

{ labelFigure->setText(text); }

Referenced by parse().

setLabelColor()

void inet::PlotFigure::setLabelColor

(

const Color &

color

)

{
    labelFigure->setColor(color);
}

Referenced by parse().

setLabelFont()

void inet::PlotFigure::setLabelFont

(

const Font &

font

)

{
    labelFigure->setFont(font);
}

Referenced by parse().

setLabelOffset()

void inet::PlotFigure::setLabelOffset

(

int

offset

)

{
    if (labelOffset == offset)
        return;
 
    labelOffset = offset;
    invalidLayout = true;
}

Referenced by parse().

setLineColor()

void inet::PlotFigure::setLineColor	(	int	series,
		const Color &	color
	)

{
    seriesPlotFigures[series]->setLineColor(color);
}

Referenced by parse().

setMaxX()

void inet::PlotFigure::setMaxX

(

double

value

)

{
    if (maxX == value)
        return;
 
    maxX = value;
    invalidLayout = true;
}

Referenced by parse().

setMaxY()

void inet::PlotFigure::setMaxY

(

double

value

)

{
    if (maxY == value)
        return;
 
    maxY = value;
    invalidLayout = true;
}

Referenced by parse().

setMinX()

void inet::PlotFigure::setMinX

(

double

value

)

{
    if (minX == value)
        return;
 
    minX = value;
    invalidLayout = true;
}

Referenced by parse().

setMinY()

void inet::PlotFigure::setMinY

(

double

value

)

{
    if (minY == value)
        return;
 
    minY = value;
    invalidLayout = true;
}

Referenced by parse().

setNumSeries()

void inet::PlotFigure::setNumSeries ( int  numSeries )

virtual

{
    this->numSeries = numSeries;
    seriesValues.resize(numSeries);
    for (auto plotFigure : seriesPlotFigures) {
        removeFigure(plotFigure);
        delete plotFigure;
    }
    seriesPlotFigures.clear();
    for (int i = 0; i < numSeries; i++) {
        auto plotFigure = new cPathFigure("plot");
        plotFigure->setLineColor(INIT_PLOT_COLOR);
        addFigure(plotFigure);
        seriesPlotFigures.push_back(plotFigure);
    }
}

Referenced by PlotFigure().

setPlotSize()

void inet::PlotFigure::setPlotSize

(

const Point &

p

)

{
    const auto& backgroundBounds = backgroundFigure->getBounds();
    backgroundFigure->setBounds(Rectangle(backgroundBounds.x, backgroundBounds.y, p.x, p.y));
    invalidLayout = true;
}

setTimeWindow()

void inet::PlotFigure::setTimeWindow

(

double

timeWindow

)

{
    if (this->timeWindow == timeWindow)
        return;
 
    this->timeWindow = timeWindow;
}

Referenced by parse().

setValue() [1/2]

void inet::PlotFigure::setValue ( int  series, double  x, double  y  )

virtual

{
    seriesValues[series].push_front({ x, y });
    invalidPlot = true;
}

setValue() [2/2]

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

inlineoverridevirtual

Implements inet::IIndicatorFigure.

{ setValue(series, timestamp.dbl(), value); }

Referenced by setValue().

setXAxisLabel()

void inet::PlotFigure::setXAxisLabel ( const char *  text )

inline

{ xAxisLabelFigure->setText(text); }

setXTickCount()

void inet::PlotFigure::setXTickCount

(

int

count

)

{
    if (count != 0 && std::isfinite(minX) && std::isfinite(maxX))
        setXTickSize((maxX - minX) / (count - 1));
    else
        setXTickSize(INFINITY);
}

setXTickSize()

void inet::PlotFigure::setXTickSize

(

double

size

)

{
    if (xTickSize == size)
        return;
 
    xTickSize = size;
}

Referenced by parse(), and setXTickCount().

setXValueFormat()

void inet::PlotFigure::setXValueFormat ( const char *  format )

inline

{ xValueFormat = format; }

setYAxisLabel()

void inet::PlotFigure::setYAxisLabel ( const char *  text )

inline

{ yAxisLabelFigure->setText(text); }

setYTickCount()

void inet::PlotFigure::setYTickCount

(

int

count

)

{
    if (count != 0 && std::isfinite(minY) && std::isfinite(maxY))
        setYTickSize((maxY - minY) / (count - 1));
    else
        setYTickSize(INFINITY);
}

setYTickSize()

void inet::PlotFigure::setYTickSize

(

double

size

)

{
    if (yTickSize == size)
        return;
 
    yTickSize = size;
    invalidLayout = true;
}

Referenced by parse(), and setYTickCount().

setYValueFormat()

void inet::PlotFigure::setYValueFormat ( const char *  format )

inline

{ yValueFormat = format; }

Member Data Documentation

backgroundFigure

cRectangleFigure* inet::PlotFigure::backgroundFigure

private

Referenced by addChildren(), getBackgrouncColor(), layout(), plot(), redrawXTicks(), redrawYTicks(), setBackgroundColor(), setBounds(), and setPlotSize().

bounds

Rectangle inet::PlotFigure::bounds

private

Referenced by getBounds(), layout(), redrawXTicks(), redrawYTicks(), and setBounds().

invalidLayout

bool inet::PlotFigure::invalidLayout = true

private

Referenced by getBounds(), layout(), refreshDisplay(), setBounds(), setLabelOffset(), setMaxX(), setMaxY(), setMinX(), setMinY(), setPlotSize(), and setYTickSize().

invalidPlot

bool inet::PlotFigure::invalidPlot = true

private

Referenced by refreshDisplay(), and setValue().

labelFigure

cLabelFigure* inet::PlotFigure::labelFigure

private

Referenced by addChildren(), getLabelColor(), getLabelFont(), layout(), redrawYTicks(), setLabelColor(), and setLabelFont().

labelOffset

int inet::PlotFigure::labelOffset = 0

private

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

maxX

double inet::PlotFigure::maxX = 1

private

Referenced by plot(), redrawXTicks(), setMaxX(), and setXTickCount().

maxY

double inet::PlotFigure::maxY = 1

private

Referenced by plot(), redrawYTicks(), setMaxY(), and setYTickCount().

minX

double inet::PlotFigure::minX = 0

private

Referenced by plot(), redrawXTicks(), setMinX(), and setXTickCount().

minY

double inet::PlotFigure::minY = 0

private

Referenced by plot(), redrawYTicks(), setMinY(), and setYTickCount().

numSeries

int inet::PlotFigure::numSeries = -1

private

Referenced by parse(), plot(), and setNumSeries().

seriesPlotFigures

std::vector<cPathFigure *> inet::PlotFigure::seriesPlotFigures

private

Referenced by getLineColor(), plot(), redrawXTicks(), redrawYTicks(), setLineColor(), and setNumSeries().

seriesValues

std::vector<std::list<std::pair<double, double> > > inet::PlotFigure::seriesValues

private

Referenced by plot(), setNumSeries(), and setValue().

timeWindow

double inet::PlotFigure::timeWindow = NaN

private

Referenced by getTimeWindow(), plot(), redrawXTicks(), refreshDisplay(), and setTimeWindow().

xAxisLabelFigure

cLabelFigure* inet::PlotFigure::xAxisLabelFigure

private

Referenced by addChildren(), and layout().

xTicks

std::vector<Tick> inet::PlotFigure::xTicks

private

Referenced by layout(), and redrawXTicks().

xTickSize

double inet::PlotFigure::xTickSize = INFINITY

private

Referenced by getXTickSize(), redrawXTicks(), and setXTickSize().

xValueFormat

const char* inet::PlotFigure::xValueFormat = "%g"

private

Referenced by redrawXTicks().

yAxisLabelFigure

cLabelFigure* inet::PlotFigure::yAxisLabelFigure

private

Referenced by addChildren(), and layout().

yTicks

std::vector<Tick> inet::PlotFigure::yTicks

private

Referenced by redrawYTicks().

yTickSize

double inet::PlotFigure::yTickSize = INFINITY

private

Referenced by getYTickSize(), redrawYTicks(), and setYTickSize().

yValueFormat

const char* inet::PlotFigure::yValueFormat = "%g"

private

Referenced by redrawYTicks().

---

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

• PlotFigure.h
• PlotFigure.cc