|
#include <Wt/WApplication>
|
|
#include <Wt/WComboBox>
|
|
#include <Wt/WContainerWidget>
|
|
#include <Wt/WVBoxLayout>
|
|
#include <Wt/WHBoxLayout>
|
|
#include <Wt/WGroupBox>
|
|
#include <Wt/WLabel>
|
|
#include <Wt/WText>
|
|
#include <Wt/WPushButton>
|
|
#include <Wt/WLineEdit>
|
|
#include <Wt/WPopupMenu>
|
|
#include <Wt/WCssDecorationStyle>
|
|
#include <Wt/WStandardItemModel>
|
|
#include <Wt/WStandardItem>
|
|
#include <Wt/WTableView>
|
|
#include <Wt/Chart/WCartesianChart>
|
|
#include <Wt/Chart/WAxis>
|
|
#include <iostream>
|
|
|
|
class AttributeGroup;
|
|
|
|
using namespace Wt;
|
|
|
|
//#define USE_POINTSERIES 1
|
|
#define USE_POINTSERIES 0
|
|
|
|
class WtApp : public Wt::WApplication
|
|
{
|
|
public:
|
|
WtApp( const Wt::WEnvironment& env);
|
|
~WtApp() {}
|
|
|
|
private:
|
|
Wt::WText *createText(const Wt::WString& text);
|
|
Wt::WWidget* createGraph();
|
|
|
|
void vboxLayout();
|
|
};
|
|
|
|
class TransactionResponseTimeSeriesModel : public Wt::WAbstractItemModel
|
|
{
|
|
public:
|
|
TransactionResponseTimeSeriesModel(Wt::WObject *parent = 0)
|
|
: WAbstractItemModel(parent)
|
|
, tranData_()
|
|
, data_()
|
|
|
|
, rows_(0)
|
|
, columns_(0)
|
|
|
|
, startTime_(0)
|
|
, endTime_(0)
|
|
|
|
, maxrt_(0)
|
|
{
|
|
tranData_.push_back(TranData("series1", 0, 1, Wt::WColor(255, 0, 0)));
|
|
tranData_.push_back(TranData("series2", 1, 1, Wt::WColor(0, 255, 0)));
|
|
const int addRows = 2000;
|
|
|
|
time_t now = time(NULL);
|
|
data_[0] = std::vector<Data>();
|
|
data_[1] = std::vector<Data>();
|
|
for(size_t i=0; i<tranData_.size(); ++i)
|
|
{
|
|
size_t r=i+1;
|
|
for(size_t s=0; s<r*addRows; ++s)
|
|
{
|
|
int64_t rt = s * addRows / (((r+(s%2))*(7+i)));
|
|
data_[i].push_back(Data(now + s, rt));
|
|
maxrt_ = std::max(rt, maxrt_);
|
|
}
|
|
}
|
|
rows_ = tranData_.size()*addRows;
|
|
columns_ = tranData_.size()*2;
|
|
startTime_ = now;
|
|
endTime_ = startTime_ + rows_;
|
|
}
|
|
|
|
time_t startTime() const { return startTime_; }
|
|
time_t endTime() const { return endTime_; }
|
|
|
|
void fillDataSeries(std::vector<Wt::Chart::WDataSeries>& dataSeries,
|
|
Wt::Chart::SeriesType seriesType,
|
|
int& maxLabelLen,
|
|
double& ymax)
|
|
{
|
|
maxLabelLen = 0;
|
|
for(size_t i=0; i<tranData_.size(); ++i)
|
|
{
|
|
const TranData& data = tranData_[i];
|
|
maxLabelLen = std::max(maxLabelLen, static_cast<int>(data.name_.value().size()));
|
|
int col = data.column_*2;
|
|
Wt::Chart::WDataSeries tranSeries(col+1, seriesType);
|
|
switch(seriesType)
|
|
{
|
|
case Wt::Chart::LineSeries:
|
|
tranSeries.setPen(Wt::WPen(data.color_));
|
|
break;
|
|
case Wt::Chart::PointSeries:
|
|
tranSeries.setPen(Wt::WPen(data.color_));
|
|
tranSeries.setMarker(Wt::Chart::XCrossMarker);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
tranSeries.setXSeriesColumn(col);
|
|
tranSeries.setShadow(Wt::WShadow(1, 1, Wt::WColor(0, 0, 0, 127+64), 1));
|
|
dataSeries.push_back(tranSeries);
|
|
}
|
|
ymax = maxrt_;
|
|
}
|
|
|
|
virtual int columnCount(const Wt::WModelIndex&) const
|
|
{
|
|
return columns_;
|
|
}
|
|
virtual int rowCount(const Wt::WModelIndex&) const
|
|
{
|
|
return rows_;
|
|
}
|
|
virtual Wt::WModelIndex parent(const Wt::WModelIndex&) const
|
|
{
|
|
return Wt::WModelIndex();
|
|
}
|
|
virtual boost::any headerData (int section, Wt::Orientation orientation, int role) const
|
|
{
|
|
if(role != Wt::DisplayRole)
|
|
return boost::any();
|
|
int column = section/2;
|
|
for(size_t i=0; i< tranData_.size(); ++i)
|
|
{
|
|
if(tranData_[i].column_ == column)
|
|
return boost::any(tranData_[i].name_);
|
|
}
|
|
return boost::any();
|
|
}
|
|
virtual boost::any data(const Wt::WModelIndex& idx, int role) const
|
|
{
|
|
if(!idx.isValid() || role != Wt::DisplayRole)
|
|
return boost::any();
|
|
|
|
const Data& data = *reinterpret_cast<const Data*>(idx.internalPointer());
|
|
double value = 0.0;
|
|
int rcol = idx.column();
|
|
rcol %= 2;
|
|
switch(rcol)
|
|
{
|
|
case 0:
|
|
value = data.start_;
|
|
break;
|
|
case 1:
|
|
value = data.rt_;
|
|
break;
|
|
}
|
|
return boost::any(value);
|
|
}
|
|
virtual Wt::WModelIndex index(int row, int column, const Wt::WModelIndex&) const
|
|
{
|
|
if(column < columns_)
|
|
{
|
|
int col = column/2;
|
|
DataType::const_iterator it = data_.find(col);
|
|
if(it != data_.end())
|
|
{
|
|
const std::vector<Data>& dv = it->second;
|
|
int rows = dv.size();
|
|
if(row < rows)
|
|
{
|
|
const Data& data = dv[row];
|
|
return createIndex(row, column, const_cast<void*>(reinterpret_cast<const void*>(&data)));
|
|
}
|
|
}
|
|
}
|
|
return Wt::WModelIndex();
|
|
}
|
|
private:
|
|
struct Data
|
|
{
|
|
Data(time_t start, int64_t rt = 0)
|
|
: start_(start) , rt_(rt) { }
|
|
time_t start_;
|
|
int64_t rt_;
|
|
bool operator<(const Data& data) const
|
|
{
|
|
return start_ < data.start_;
|
|
}
|
|
};
|
|
struct TranData
|
|
{
|
|
TranData(Wt::WString name = Wt::WString::Empty, int col = 0, int lvl = 1, Wt::WColor color = Wt::WColor())
|
|
: name_(name), column_(col), level_(lvl), index_(0), color_(color) {}
|
|
Wt::WString name_;
|
|
int column_;
|
|
int level_;
|
|
int index_;
|
|
Wt::WColor color_;
|
|
};
|
|
typedef std::map<int, std::vector<Data> > DataType;
|
|
std::vector<TranData> tranData_;
|
|
DataType data_;
|
|
|
|
int rows_;
|
|
int columns_;
|
|
|
|
time_t startTime_;
|
|
time_t endTime_;
|
|
|
|
int64_t maxrt_;
|
|
};
|
|
|
|
class TransactionScatterChart : public Wt::Chart::WCartesianChart
|
|
{
|
|
public:
|
|
TransactionScatterChart(TransactionResponseTimeSeriesModel* model,
|
|
Wt::WContainerWidget *parent=0)
|
|
: WCartesianChart(Chart::ScatterPlot, parent)
|
|
, model_(model)
|
|
{
|
|
setModel(model_);
|
|
setMargin(WLength::Auto, Left | Right);
|
|
setPlotAreaPadding(25, Top);
|
|
setPlotAreaPadding(30, Right);
|
|
setXSeriesColumn(0);
|
|
resize(WLength::Auto, WLength::Auto);
|
|
Chart::WAxis& xAxis = axis(Chart::XAxis);
|
|
Chart::WAxis& yAxis = axis(Chart::YAxis);
|
|
yAxis.setMinimum(0.0);
|
|
yAxis.setGridLinesEnabled(true);
|
|
yAxis.setTitle(WString("RT [{1}]").arg("ms"));
|
|
Wt::WFont tf = yAxis.titleFont();
|
|
tf.setSize(10);
|
|
yAxis.setTitleFont(tf);
|
|
xAxis.setScale(Chart::DateTimeScale);
|
|
xAxis.setGridLinesEnabled(true);
|
|
setLayoutSizeAware(true);
|
|
mouseWheel().connect(this, &TransactionScatterChart::zoom);
|
|
}
|
|
|
|
protected:
|
|
virtual void modelReset()
|
|
{
|
|
std::vector<Chart::WDataSeries> dataSeries;
|
|
int maxLabelLen;
|
|
double ymax = 0.0;
|
|
|
|
#if USE_POINTSERIES
|
|
model_->fillDataSeries(dataSeries, Wt::Chart::PointSeries, maxLabelLen, ymax);
|
|
#else
|
|
model_->fillDataSeries(dataSeries, Wt::Chart::LineSeries, maxLabelLen, ymax);
|
|
#endif
|
|
|
|
const double width = WLength(maxLabelLen, WLength::FontEm).toPixels(8.0) + 20.0;
|
|
const int labelsPerColumn = 6;
|
|
const int columns = (dataSeries.size()+labelsPerColumn-1)/labelsPerColumn;
|
|
|
|
Chart::WAxis& yAxis = axis(Chart::YAxis);
|
|
if(ymax > yMax_)
|
|
{
|
|
int maxLen = log10(ymax)+1;
|
|
if(ymax < 100.0)
|
|
{
|
|
yAxis.setLabelFormat("%.1f");
|
|
maxLen += 2;
|
|
} else
|
|
{
|
|
yAxis.setLabelFormat("%.0f");
|
|
}
|
|
WCartesianChart::setPlotAreaPadding(WLength(maxLen, WLength::FontEm).toPixels(8.0)+10, Left);
|
|
yMax_ = ymax;
|
|
}
|
|
axis(Chart::XAxis).setAutoLimits(Chart::MinimumValue | Chart::MaximumValue);
|
|
yAxis.setAutoLimits(Chart::MinimumValue | Chart::MaximumValue);
|
|
|
|
WCartesianChart::setLegendColumns(std::max(1, columns), std::max(120.0, width));
|
|
WCartesianChart::setSeries(dataSeries);
|
|
}
|
|
void layoutSizeChanged(int width, int height)
|
|
{
|
|
width_ = width;
|
|
WCartesianChart::layoutSizeChanged(width, height);
|
|
}
|
|
|
|
private:
|
|
void zoom(const Wt::WMouseEvent& e)
|
|
{
|
|
double zoomStep = 0.25 * (double) e.wheelDelta();
|
|
double width = width_ - plotAreaPadding(Left) - plotAreaPadding(Right);
|
|
double weight = (double)(e.widget().x - plotAreaPadding(Left)) / std::max(width, 1.0);
|
|
weight = std::min(weight, 1.0);
|
|
weight = std::max(weight, 0.0);
|
|
//fprintf(stderr, "padding left:%d padding right:%d mouse x:%d width:%f weight:%f\n", plotAreaPadding(Left), plotAreaPadding(Right), e.widget().x, width, weight);
|
|
|
|
double start = model_->startTime();
|
|
double end = model_->endTime();
|
|
|
|
Chart::WAxis& xAxis = axis(Chart::XAxis);
|
|
double interval = xAxis.maximum() - xAxis.minimum();
|
|
double zoomAdd = interval * zoomStep;
|
|
double newStart = xAxis.minimum() + (zoomAdd * (weight));
|
|
double newEnd = xAxis.maximum() - (zoomAdd * (1.0 - weight));
|
|
|
|
newStart = std::max(start, newStart);
|
|
newEnd = std::min(end, newEnd);
|
|
|
|
//fprintf(stderr, "start:%f end:%f\n", start, end);
|
|
//fprintf(stderr, "oldStart:%f, oldEnd:%f\n", xAxis.minimum(), xAxis.maximum());
|
|
//fprintf(stderr, "newStart:%f, newEnd:%f diff:%f\n", newStart, newEnd, newEnd - newStart);
|
|
//fprintf(stderr, "zoomAdd:%f, zoomstep:%f weight:%f interv:%f\n", zoomAdd, zoomStep, weight, interval);
|
|
|
|
if(newEnd - newStart > 1.0)
|
|
{
|
|
xAxis.setRange(newStart, newEnd);
|
|
}
|
|
}
|
|
|
|
private:
|
|
TransactionResponseTimeSeriesModel* model_;
|
|
double yMax_;
|
|
int width_;
|
|
};
|
|
|
|
|
|
|
|
WtApp::WtApp(const Wt::WEnvironment& env)
|
|
: Wt::WApplication(env)
|
|
{
|
|
setCssTheme("polished");
|
|
|
|
vboxLayout();
|
|
}
|
|
|
|
void WtApp::vboxLayout()
|
|
{
|
|
Wt::WVBoxLayout* layout = new Wt::WVBoxLayout(root());
|
|
|
|
root()->setLayout(layout);
|
|
|
|
// row 0
|
|
layout->addWidget(createText("Title"), 0, Wt::AlignTop);
|
|
|
|
|
|
// row 1
|
|
layout->addWidget(createText("SubTitle"), 0);
|
|
|
|
// row 2
|
|
Wt::WHBoxLayout* hbox = new Wt::WHBoxLayout();
|
|
hbox->addWidget(createText("Selection"), 0, Wt::AlignLeft);
|
|
hbox->addWidget(createText("Main"), 1, Wt::AlignJustify);
|
|
hbox->addWidget(createText("Details"), 0, Wt::AlignJustify);
|
|
hbox->setResizable(1, true);
|
|
hbox->setSpacing(4);
|
|
layout->addLayout(hbox, 1, Wt::AlignJustify);
|
|
|
|
// row 3
|
|
layout->addWidget(createGraph(), 2);
|
|
|
|
layout->setResizable(2, true);
|
|
}
|
|
|
|
Wt::WText *WtApp::createText(const Wt::WString& text)
|
|
{
|
|
Wt::WText *w = new Wt::WText(text);
|
|
Wt::WCssDecorationStyle style;
|
|
style.setBackgroundColor(Wt::WColor(200,200,200));
|
|
w->setDecorationStyle(style);
|
|
return w;
|
|
}
|
|
|
|
Wt::WWidget* WtApp::createGraph()
|
|
{
|
|
TransactionResponseTimeSeriesModel* model = new TransactionResponseTimeSeriesModel();
|
|
TransactionScatterChart *graph = new TransactionScatterChart(model);
|
|
model->modelReset().emit();
|
|
return graph;
|
|
}
|
|
|
|
Wt::WApplication *createApplication(const Wt::WEnvironment& env)
|
|
{
|
|
Wt::WApplication* myApplication = 0;
|
|
myApplication = new WtApp( env );
|
|
return myApplication;
|
|
}
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
Wt::WRun(argc, argv, &createApplication);
|
|
return 0;
|
|
}
|