Wt examples  4.12.2
Loading...
Searching...
No Matches
Classes | Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
ChartConfig Class Reference

A class that allows configuration of a cartesian chart. More...

#include <ChartConfig.h>

Inheritance diagram for ChartConfig:
[legend]

Classes

struct  AxisControl
 Struct that holds the controls for one axis. More...
 
struct  SeriesControl
 Struct that holds the controls for one series. More...
 

Public Member Functions

 ChartConfig (Wt::Chart::WCartesianChart *chart)
 Constructor.
 
void setValueFill (Wt::Chart::FillRangeType fill)
 
- Public Member Functions inherited from Wt::WContainerWidget
 WContainerWidget ()
 
 ~WContainerWidget ()
 
void setLayout (std::unique_ptr< WLayout > layout)
 
Layout * setLayout (std::unique_ptr< Layout > layout)
 
WLayout * layout () const
 
virtual void addWidget (std::unique_ptr< WWidget > widget)
 
Widget * addWidget (std::unique_ptr< Widget > widget)
 
Widget * addNew (Args &&...args)
 
virtual void insertBefore (std::unique_ptr< WWidget > widget, WWidget *before)
 
Widget * insertBefore (std::unique_ptr< Widget > widget, WWidget *before)
 
virtual void insertWidget (int index, std::unique_ptr< WWidget > widget)
 
Widget * insertWidget (int index, std::unique_ptr< Widget > widget)
 
Widget * insertNew (int index, Args &&...args)
 
virtual std::unique_ptr< WWidget > removeWidget (WWidget *widget) override
 
virtual void clear ()
 
virtual int indexOf (WWidget *widget) const
 
virtual WWidget * widget (int index) const
 
virtual int count () const
 
void setContentAlignment (WFlags< AlignmentFlag > contentAlignment)
 
void setPadding (const WLength &padding, WFlags< Side > sides=AllSides)
 
WLength padding (Side side) const
 
WFlags< AlignmentFlag > contentAlignment () const
 
void setOverflow (Overflow overflow, WFlags< Orientation > orientation=(Orientation::Horizontal|Orientation::Vertical))
 
void setList (bool list, bool ordered=false)
 
bool isList () const
 
bool isUnorderedList () const
 
bool isOrderedList () const
 
EventSignal< WScrollEvent > & scrolled ()
 
int scrollTop () const
 
int scrollLeft () const
 
virtual std::unique_ptr< WWidget > removeWidget (WWidget *widget)
 
std::unique_ptr< Widget > removeWidget (Widget *widget)
 
- Public Member Functions inherited from Wt::WInteractWidget
 WInteractWidget ()
 
EventSignal< WKeyEvent > & keyWentDown ()
 
EventSignal< WKeyEvent > & keyPressed ()
 
EventSignal< WKeyEvent > & keyWentUp ()
 
EventSignal & enterPressed ()
 
EventSignal & escapePressed ()
 
EventSignal< WMouseEvent > & clicked ()
 
EventSignal< WMouseEvent > & doubleClicked ()
 
EventSignal< WMouseEvent > & mouseWentDown ()
 
EventSignal< WMouseEvent > & mouseWentUp ()
 
EventSignal< WMouseEvent > & mouseWentOut ()
 
EventSignal< WMouseEvent > & mouseWentOver ()
 
EventSignal< WMouseEvent > & mouseMoved ()
 
EventSignal< WMouseEvent > & mouseDragged ()
 
EventSignal< WMouseEvent > & mouseWheel ()
 
EventSignal< WTouchEvent > & touchStarted ()
 
EventSignal< WTouchEvent > & touchEnded ()
 
EventSignal< WTouchEvent > & touchMoved ()
 
EventSignal< WGestureEvent > & gestureStarted ()
 
EventSignal< WGestureEvent > & gestureChanged ()
 
EventSignal< WGestureEvent > & gestureEnded ()
 
void setDraggable (const std::string &mimeType, WWidget *dragWidget=nullptr, bool isDragWidgetOnly=false, WObject *sourceWidget=nullptr)
 
void unsetDraggable ()
 
void setMouseOverDelay (int delay)
 
int mouseOverDelay () const
 
virtual void setPopup (bool popup) override
 
virtual void load () override
 
virtual bool isEnabled () const override
 
- Public Member Functions inherited from Wt::WWebWidget
 WWebWidget ()
 
virtual std::vector< WWidget * > children () const override
 
Signal & childrenChanged ()
 
virtual void setPositionScheme (PositionScheme scheme) override
 
virtual PositionScheme positionScheme () const override
 
virtual void setOffsets (const WLength &offset, WFlags< Side > sides=AllSides) override
 
virtual WLength offset (Side s) const override
 
virtual void resize (const WLength &width, const WLength &height) override
 
virtual WLength width () const override
 
virtual WLength height () const override
 
virtual void setMinimumSize (const WLength &width, const WLength &height) override
 
virtual WLength minimumWidth () const override
 
virtual WLength minimumHeight () const override
 
virtual void setMaximumSize (const WLength &width, const WLength &height) override
 
virtual WLength maximumWidth () const override
 
virtual WLength maximumHeight () const override
 
virtual void setLineHeight (const WLength &height) override
 
virtual WLength lineHeight () const override
 
virtual void setFloatSide (Side s) override
 
virtual Side floatSide () const override
 
virtual void setClearSides (WFlags< Side > sides) override
 
virtual WFlags< Side > clearSides () const override
 
virtual void setMargin (const WLength &margin, WFlags< Side > sides=AllSides) override
 
virtual WLength margin (Side side) const override
 
virtual void setHiddenKeepsGeometry (bool enabled) override
 
virtual bool hiddenKeepsGeometry () const override
 
virtual void setHidden (bool hidden, const WAnimation &animation=WAnimation()) override
 
virtual bool isHidden () const override
 
virtual bool isVisible () const override
 
virtual void setDisabled (bool disabled) override
 
virtual bool isDisabled () const override
 
virtual bool isPopup () const override
 
virtual void setInline (bool isInline) override
 
virtual bool isInline () const override
 
virtual void setDecorationStyle (const WCssDecorationStyle &style) override
 
virtual WCssDecorationStyle & decorationStyle () override
 
virtual void setStyleClass (const WString &styleClass) override
 
virtual WString styleClass () const override
 
virtual void addStyleClass (const WString &styleClass, bool force=false) override
 
virtual void removeStyleClass (const WString &styleClass, bool force=false) override
 
virtual bool hasStyleClass (const WString &styleClass) const override
 
virtual void setVerticalAlignment (AlignmentFlag alignment, const WLength &length=WLength()) override
 
virtual AlignmentFlag verticalAlignment () const override
 
virtual WLength verticalAlignmentLength () const override
 
virtual void setToolTip (const WString &text, TextFormat textFormat=TextFormat::Plain) override
 
virtual void setDeferredToolTip (bool enable, TextFormat textFormat=TextFormat::Plain) override
 
virtual WString toolTip () const override
 
void showToolTipOnHover (bool enable)
 
void showToolTip ()
 
void hideToolTip ()
 
virtual void refresh () override
 
virtual void setAttributeValue (const std::string &name, const WString &value) override
 
virtual WString attributeValue (const std::string &name) const override
 
virtual void setJavaScriptMember (const std::string &name, const std::string &value) override
 
virtual std::string javaScriptMember (const std::string &name) const override
 
virtual void callJavaScriptMember (const std::string &name, const std::string &args) override
 
virtual bool loaded () const override
 
virtual void setId (const std::string &id) override
 
virtual WWidget * find (const std::string &name) override
 
virtual WWidget * findById (const std::string &id) override
 
virtual void setSelectable (bool selectable) override
 
virtual void doJavaScript (const std::string &javascript) override
 
virtual const std::string id () const override
 
void setLoadLaterWhenInvisible (bool)
 
std::string htmlTagName () const
 
void setHtmlTagName (const std::string &tag)
 
virtual void setCanReceiveFocus (bool enabled) override
 
virtual bool canReceiveFocus () const override
 
virtual bool setFirstFocus () override
 
virtual void setFocus (bool focus) override
 
virtual bool hasFocus () const override
 
virtual void setTabIndex (int index) override
 
virtual int tabIndex () const override
 
EventSignal & blurred ()
 
EventSignal & focussed ()
 
virtual bool scrollVisibilityEnabled () const final override
 
virtual void setScrollVisibilityEnabled (bool enabled) final override
 
virtual int scrollVisibilityMargin () const final override
 
virtual void setScrollVisibilityMargin (int margin) final override
 
virtual Signal< bool > & scrollVisibilityChanged () final override
 
virtual bool isScrollVisible () const final override
 
virtual void setThemeStyleEnabled (bool enabled) final override
 
virtual bool isThemeStyleEnabled () const final override
 
virtual void setObjectName (const std::string &name) override
 
void setFocus ()
 
virtual void setFocus (bool focus)=0
 
- Public Member Functions inherited from Wt::WWidget
virtual ~WWidget ()
 
WWidget * parent () const
 
std::unique_ptr< Widget > removeWidget (Widget *widget)
 
std::unique_ptr< WWidget > removeFromParent ()
 
void setWidth (const WLength &width)
 
void setHeight (const WLength &height)
 
virtual void positionAt (const WWidget *widget, Orientation orientation=Orientation::Vertical, WFlags< Orientation > adjustOrientations=AllOrientations)
 
virtual void toggleStyleClass (const WString &styleClass, bool add, bool force=false)
 
std::string jsRef () const
 
void setFocus ()
 
virtual void acceptDrops (const std::string &mimeType, const WString &hoverStyleClass=WString())
 
virtual void stopAcceptDrops (const std::string &mimeType)
 
virtual void htmlText (std::ostream &out)
 
bool isRendered () const
 
void hide ()
 
void animateHide (const WAnimation &animation)
 
void show ()
 
void animateShow (const WAnimation &animation)
 
void enable ()
 
void disable ()
 
bool layoutSizeAware () const
 
virtual void scheduleThemeStyleApply (std::shared_ptr< Wt::WTheme > theme, WWidget *child, int role)
 
virtual void applyThemeStyles ()
 
- Public Member Functions inherited from Wt::WObject
void addChild (std::unique_ptr< WObject > child)
 
Child * addChild (std::unique_ptr< Child > child)
 
std::unique_ptr< WObject > removeChild (WObject *child)
 
std::unique_ptr< Child > removeChild (Child *child)
 
virtual std::string objectName () const
 
void resetLearnedSlots ()
 
void resetLearnedSlot (void(T::*method)())
 
WStatelessSlot * implementStateless (void(T::*method)())
 
WStatelessSlot * implementStateless (void(T::*method)(), void(T::*undoMethod)())
 
void isNotStateless ()
 
WStatelessSlot * implementJavaScript (void(T::*method)(), const std::string &jsCode)
 
- Public Member Functions inherited from Wt::Core::observable
 observable () noexcept
 
virtual ~observable ()
 
auto bindSafe (void(C::*method)(Args...)) noexcept
 
auto bindSafe (void(C::*method)(Args...) const) const noexcept
 
auto bindSafe (const Function &function) noexcept
 

Private Member Functions

void connectSignals (Wt::WFormWidget *w)
 
void update ()
 
void addXAxis ()
 
void addYAxis ()
 
void addAxis (Wt::Chart::Axis axis, int axisId)
 
void removeXAxis (const Wt::Chart::WAxis *axis)
 
void removeYAxis (const Wt::Chart::WAxis *axis)
 
void clearXAxes ()
 
void clearYAxes ()
 

Static Private Member Functions

static bool validate (Wt::WFormWidget *w)
 

Private Attributes

Wt::Chart::WCartesianChart * chart_
 
Wt::Chart::FillRangeType fill_
 
std::vector< SeriesControl > seriesControls_
 Controls for series.
 
std::vector< AxisControl > axisControls_
 Controls for axes.
 
Wt::WLineEdit * titleEdit_
 
Wt::WLineEdit * chartWidthEdit_
 
Wt::WLineEdit * chartHeightEdit_
 
Wt::WComboBox * chartOrientationEdit_
 
Wt::WComboBox * legendLocationEdit_
 
Wt::WComboBox * legendSideEdit_
 
Wt::WComboBox * legendAlignmentEdit_
 
Wt::WCheckBox * borderEdit_
 
std::shared_ptr< Wt::WStandardItemModel > xAxesModel_
 
std::shared_ptr< Wt::WStandardItemModel > yAxesModel_
 
std::shared_ptr< Wt::WStandardItemModel > xScales_
 
std::shared_ptr< Wt::WStandardItemModel > yScales_
 
Wt::WTable * axisConfig_
 
std::shared_ptr< Wt::WValidator > anyNumberValidator_
 
std::shared_ptr< Wt::WValidator > angleValidator_
 

Additional Inherited Members

- Public Types inherited from Wt::WObject
typedef void(WObject::* Method) ()
 
- Static Public Member Functions inherited from Wt::WWebWidget
static std::string jsStringLiteral (const std::string &v, char delimiter='\'')
 
- Static Public Member Functions inherited from Wt::WWidget
static WString tr (const char *key)
 
- Static Public Attributes inherited from Wt::WInteractWidget
static const std::string noDefault
 
- Protected Member Functions inherited from Wt::WInteractWidget
void render (WFlags< RenderFlag > flags) override
 
virtual void propagateSetEnabled (bool enabled) override
 
- Protected Member Functions inherited from Wt::WWebWidget
virtual void enableAjax () override
 
virtual WStatelessSlot * getStateless (Method method) override
 
- Protected Member Functions inherited from Wt::WWidget
void setLayoutSizeAware (bool sizeAware)
 
virtual void layoutSizeChanged (int width, int height)
 
 WWidget ()
 
virtual void dropEvent (WDropEvent dropEvent)
 
virtual int boxPadding (Orientation orientation) const
 
virtual int boxBorder (Orientation orientation) const
 
void scheduleRender (WFlags< RepaintFlag > flags=None)
 

Detailed Description

A class that allows configuration of a cartesian chart.

This widget provides forms for configuring chart, series, and axis properties and manipulates the chart according to user settings.

This widget is part of the Wt charts example.

Definition at line 40 of file ChartConfig.h.

Constructor & Destructor Documentation

◆ ChartConfig()

ChartConfig::ChartConfig ( Wt::Chart::WCartesianChart *  chart)

Constructor.

Definition at line 76 of file ChartConfig.C.

77 : WContainerWidget(),
78 chart_(chart),
79 fill_(FillRangeType::MinimumValue)
80{
81 chart_->setLegendStyle(chart_->legendFont(), WPen(WColor("black")),
82 WBrush(WColor(0xFF, 0xFA, 0xE5)));
83
84 PanelList *list = this->addWidget(std::make_unique<PanelList>());
85
86 std::shared_ptr<WIntValidator> sizeValidator
87 = std::make_shared<WIntValidator>(200,2000);
88 sizeValidator->setMandatory(true);
89
90 anyNumberValidator_ = std::make_shared<WDoubleValidator>();
91 anyNumberValidator_->setMandatory(true);
92
93 angleValidator_ = std::make_shared<WDoubleValidator>(-90, 90);
94 angleValidator_->setMandatory(true);
95
96 // ---- Chart properties ----
97
98 std::shared_ptr<WStandardItemModel> orientation
99 = std::make_shared<WStandardItemModel>(0,1);
100 addEntry(orientation, "Vertical");
101 addEntry(orientation, "Horizontal");
102
103 std::shared_ptr<WStandardItemModel> legendLocation
104 = std::make_shared<WStandardItemModel>(0,1);
105 addEntry(legendLocation, "Outside");
106 addEntry(legendLocation, "Inside");
107
108 std::shared_ptr<WStandardItemModel> legendSide
109 = std::make_shared<WStandardItemModel>(0,1);
110 addEntry(legendSide, "Top");
111 addEntry(legendSide, "Right");
112 addEntry(legendSide, "Bottom");
113 addEntry(legendSide, "Left");
114
115 std::shared_ptr<WStandardItemModel> legendAlignment
116 = std::make_shared<WStandardItemModel>(0,1);
117 addEntry(legendAlignment, "AlignLeft");
118 addEntry(legendAlignment, "AlignCenter");
119 addEntry(legendAlignment, "AlignRight");
120 addEntry(legendAlignment, "AlignTop");
121 addEntry(legendAlignment, "AlignMiddle");
122 addEntry(legendAlignment, "AlignBottom");
123
124 std::unique_ptr<WTable> chartConfig
125 = std::make_unique<WTable>();
126 chartConfig->setMargin(WLength::Auto, Side::Left | Side::Right);
127
128 int row = 0;
129 chartConfig->elementAt(row, 0)->addWidget(std::make_unique<WText>("Title:"));
130 titleEdit_ = chartConfig->elementAt(row,1)->addWidget(std::make_unique<WLineEdit>());
131 connectSignals(titleEdit_);
132 ++row;
133
134 chartConfig->elementAt(row, 0)->addWidget(std::make_unique<WText>("Width:"));
135 chartWidthEdit_ = chartConfig->elementAt(row,1)->addWidget(std::make_unique<WLineEdit>());
136 chartWidthEdit_
137 ->setText(WLocale::currentLocale().toString(chart_->width().value()));
138 chartWidthEdit_->setValidator(sizeValidator);
139 chartWidthEdit_->setMaxLength(4);
140 connectSignals(chartWidthEdit_);
141 ++row;
142
143 chartConfig->elementAt(row, 0)->addWidget(std::make_unique<WText>("Height:"));
144 chartHeightEdit_ = chartConfig->elementAt(row,1)->addWidget(std::make_unique<WLineEdit>());
145 chartHeightEdit_
146 ->setText(WLocale::currentLocale().toString(chart_->height().value()));
147 chartHeightEdit_->setValidator(sizeValidator);
148 chartHeightEdit_->setMaxLength(4);
149 connectSignals(chartHeightEdit_);
150 ++row;
151
152 chartConfig->elementAt(row, 0)->addWidget(std::make_unique<WText>("Orientation:"));
153 chartOrientationEdit_ = chartConfig->elementAt(row,1)->addWidget(std::make_unique<WComboBox>());
154 chartOrientationEdit_->setModel(orientation);
155 chartOrientationEdit_->setCurrentIndex(0);
156 connectSignals(chartOrientationEdit_);
157 ++row;
158
159 chartConfig->elementAt(row, 0)->addWidget(std::make_unique<WText>("Legend location:"));
160 legendLocationEdit_ = chartConfig->elementAt(row,1)->addWidget(std::make_unique<WComboBox>());
161 legendLocationEdit_->setModel(legendLocation);
162 legendLocationEdit_->setCurrentIndex(0);
163 connectSignals(legendLocationEdit_);
164 ++row;
165
166 chartConfig->elementAt(row, 0)->addWidget(std::make_unique<WText>("Legend side:"));
167 legendSideEdit_ = chartConfig->elementAt(row,1)->addWidget(std::make_unique<WComboBox>());
168 legendSideEdit_->setModel(legendSide);
169 legendSideEdit_->setCurrentIndex(1);
170 connectSignals(legendSideEdit_);
171 ++row;
172
173 chartConfig->elementAt(row, 0)->addWidget(std::make_unique<WText>("Legend alignment:"));
174 legendAlignmentEdit_ = chartConfig->elementAt(row,1)->addWidget(std::make_unique<WComboBox>());
175 legendAlignmentEdit_->setModel(legendAlignment);
176 legendAlignmentEdit_->setCurrentIndex(4);
177 connectSignals(legendAlignmentEdit_);
178 ++row;
179
180 chartConfig->elementAt(row, 0)->addWidget(std::make_unique<WText>("Border:"));
181 borderEdit_ = chartConfig->elementAt(row,1)->addWidget(std::make_unique<WCheckBox>());
182 borderEdit_->setChecked(false);
183 connectSignals(borderEdit_);
184 ++row;
185
186 for (int i = 0; i < chartConfig->rowCount(); ++i) {
187 chartConfig->elementAt(i, 0)->setStyleClass("tdhead");
188 chartConfig->elementAt(i, 1)->setStyleClass("tddata");
189 }
190
191 WPanel *p = list->addWidget("Chart properties", std::move(chartConfig));
192 p->setMargin(WLength::Auto, Side::Left | Side::Right);
193 p->resize(1160, WLength::Auto);
194 p->setMargin(20, Side::Top | Side::Bottom);
195
196 // ---- Series properties ----
197
198 std::shared_ptr<WStandardItemModel> types
199 = std::make_shared<WStandardItemModel>(0,1);
200 addEntry(types, "Points");
201 addEntry(types, "Line");
202 addEntry(types, "Curve");
203 addEntry(types, "Bar");
204 addEntry(types, "Line Area");
205 addEntry(types, "Curve Area");
206 addEntry(types, "Stacked Bar");
207 addEntry(types, "Stacked Line Area");
208 addEntry(types, "Stacked Curve Area");
209
210 std::shared_ptr<WStandardItemModel> markers
211 = std::make_shared<WStandardItemModel>(0,1);
212 addEntry(markers, "None");
213 addEntry(markers, "Square");
214 addEntry(markers, "Circle");
215 addEntry(markers, "Cross");
216 addEntry(markers, "X cross");
217 addEntry(markers, "Triangle");
218 addEntry(markers, "Pipe");
219 addEntry(markers, "Star");
220 addEntry(markers, "Inverted triangle");
221 addEntry(markers, "Asterisk");
222 addEntry(markers, "Diamond");
223
224 xAxesModel_ = std::make_shared<WStandardItemModel>(0, 1);
225 addEntry(xAxesModel_, axisName(Axis::X, 0));
226
227 yAxesModel_ = std::make_shared<WStandardItemModel>(0, 1);
228 addEntry(yAxesModel_, axisName(Axis::Y, 0));
229 addEntry(yAxesModel_, axisName(Axis::Y, 1));
230
231 std::shared_ptr<WStandardItemModel> labels
232 = std::make_shared<WStandardItemModel>(0,1);
233 addEntry(labels, "None");
234 addEntry(labels, "X");
235 addEntry(labels, "Y");
236 addEntry(labels, "X: Y");
237
238 std::unique_ptr<WTable> seriesConfig
239 = std::make_unique<WTable>();
240 WTable *seriesConfigPtr = seriesConfig.get();
241 seriesConfig->setMargin(WLength::Auto, Side::Left | Side::Right);
242 ::addHeader(seriesConfigPtr, "Name");
243 ::addHeader(seriesConfigPtr, "Enabled");
244 ::addHeader(seriesConfigPtr, "Type");
245 ::addHeader(seriesConfigPtr, "Marker");
246 ::addHeader(seriesConfigPtr, "X axis");
247 ::addHeader(seriesConfigPtr, "Y axis");
248 ::addHeader(seriesConfigPtr, "Legend");
249 ::addHeader(seriesConfigPtr, "Shadow");
250 ::addHeader(seriesConfigPtr, "Value labels");
251
252 seriesConfig->rowAt(0)->setStyleClass("trhead");
253
254 for (int j = 1; j < chart->model()->columnCount(); ++j) {
255 SeriesControl sc;
256
257 seriesConfig->elementAt(j,0)->addWidget(std::make_unique<WText>(chart->model()->headerData(j)));
258
259 sc.enabledEdit = seriesConfig->elementAt(j,1)->addWidget(std::make_unique<WCheckBox>());
260 connectSignals(sc.enabledEdit);
261
262 sc.typeEdit = seriesConfig->elementAt(j,2)->addWidget(std::make_unique<WComboBox>());
263 sc.typeEdit->setModel(types);
264 sc.typeEdit->setCurrentIndex(0);
265 connectSignals(sc.typeEdit);
266
267 sc.markerEdit = seriesConfig->elementAt(j,3)->addWidget(std::make_unique<WComboBox>());
268 sc.markerEdit->setModel(markers);
269 sc.markerEdit->setCurrentIndex(0);
270 connectSignals(sc.markerEdit);
271
272 sc.xAxisEdit = seriesConfig->elementAt(j, 4)->addNew<WComboBox>();
273 sc.xAxisEdit->setModel(xAxesModel_);
274 sc.xAxisEdit->setCurrentIndex(0);
275 connectSignals(sc.xAxisEdit);
276
277 sc.yAxisEdit = seriesConfig->elementAt(j, 5)->addNew<WComboBox>();
278 sc.yAxisEdit->setModel(yAxesModel_);
279 sc.yAxisEdit->setCurrentIndex(0);
280 connectSignals(sc.yAxisEdit);
281
282 sc.legendEdit = seriesConfig->elementAt(j, 6)->addWidget(std::make_unique<WCheckBox>());
283 connectSignals(sc.legendEdit);
284
285 sc.shadowEdit = seriesConfig->elementAt(j, 7)->addWidget(std::make_unique<WCheckBox>());
286 connectSignals(sc.shadowEdit);
287
288 sc.labelsEdit = seriesConfig->elementAt(j, 8)->addWidget(std::make_unique<WComboBox>());
289 sc.labelsEdit->setModel(labels);
290 sc.labelsEdit->setCurrentIndex(0);
291 connectSignals(sc.labelsEdit);
292
293 int si = seriesIndexOf(chart, j);
294
295 if (si != -1) {
296 sc.enabledEdit->setChecked();
297 const WDataSeries& s = chart_->series(j);
298 switch (s.type()) {
299 case SeriesType::Point:
300 sc.typeEdit->setCurrentIndex(0); break;
301 case SeriesType::Line:
302 sc.typeEdit->setCurrentIndex(s.fillRange() != FillRangeType::None ?
303 (s.isStacked() ? 7 : 4) : 1); break;
304 case SeriesType::Curve:
305 sc.typeEdit->setCurrentIndex(s.fillRange() != FillRangeType::None ?
306 (s.isStacked() ? 8 : 5) : 2); break;
307 case SeriesType::Bar:
308 sc.typeEdit->setCurrentIndex(s.isStacked() ? 6 : 3);
309 }
310
311 sc.markerEdit->setCurrentIndex((int)s.marker());
312 sc.legendEdit->setChecked(s.isLegendEnabled());
313 sc.shadowEdit->setChecked(s.shadow() != WShadow());
314 }
315
316 seriesControls_.push_back(sc);
317
318 seriesConfig->rowAt(j)->setStyleClass("trdata");
319 }
320
321 p = list->addWidget("Series properties", std::move(seriesConfig));
322 p->expand();
323 p->setMargin(WLength::Auto, Side::Left | Side::Right);
324 p->resize(1160, WLength::Auto);
325 p->setMargin(20, Side::Top | Side::Bottom);
326
327 // ---- Axis properties ----
328
329 yScales_ = std::make_shared<WStandardItemModel>(0, 1);
330 addEntry(yScales_, "Linear scale");
331 addEntry(yScales_, "Log scale");
332
333 xScales_ = std::make_shared<WStandardItemModel>(0, 1);
334 addEntry(xScales_, "Categories");
335 addEntry(xScales_, "Linear scale");
336 addEntry(xScales_, "Log scale");
337 addEntry(xScales_, "Date scale");
338
339 auto axisConfig = std::make_unique<WContainerWidget>();
340 axisConfig_ = axisConfig->addNew<WTable>();
341 axisConfig_->setMargin(WLength::Auto, Side::Left | Side::Right);
342
343 ::addHeader(axisConfig_, "Axis");
344 ::addHeader(axisConfig_, "Visible");
345 ::addHeader(axisConfig_, "Scale");
346 ::addHeader(axisConfig_, "Automatic");
347 ::addHeader(axisConfig_, "Minimum");
348 ::addHeader(axisConfig_, "Maximum");
349 ::addHeader(axisConfig_, "Gridlines");
350 ::addHeader(axisConfig_, "Label angle");
351 ::addHeader(axisConfig_, "Title");
352 ::addHeader(axisConfig_, "Title orientation");
353 ::addHeader(axisConfig_, "Tick direction");
354 ::addHeader(axisConfig_, "Location");
355
356 axisConfig_->rowAt(0)->setStyleClass("trhead");
357
358 addAxis(Axis::X, 0);
359 addAxis(Axis::Y, 0);
360 addAxis(Axis::Y, 1);
361
362 WPushButton *addXAxisBtn =
363 axisConfig->addNew<WPushButton>(Wt::utf8("Add X axis"));
364 addXAxisBtn->clicked().connect(this, &ChartConfig::addXAxis);
365 WPushButton *clearXAxesBtn =
366 axisConfig->addNew<WPushButton>(Wt::utf8("Clear X axes"));
367 clearXAxesBtn->clicked().connect(this, &ChartConfig::clearXAxes);
368 WPushButton *addYAxisBtn =
369 axisConfig->addNew<WPushButton>(utf8("Add Y axis"));
370 addYAxisBtn->clicked().connect(this, &ChartConfig::addYAxis);
371 WPushButton *clearYAxesBtn =
372 axisConfig->addNew<WPushButton>(utf8("Clear Y axes"));
373 clearYAxesBtn->clicked().connect(this, &ChartConfig::clearYAxes);
374
375 p = list->addWidget("Axis properties", std::move(axisConfig));
376 p->setMargin(WLength::Auto, Side::Left | Side::Right);
377 p->resize(1160, WLength::Auto);
378 p->setMargin(20, Side::Top | Side::Bottom);
379
380 /*
381 * If we do not have JavaScript, then add a button to reflect changes to
382 * the chart.
383 */
384 if (!WApplication::instance()->environment().javaScript()) {
385 auto *b = this->addWidget(std::make_unique<WPushButton>());
386 b->setText("Update chart");
387 b->setInline(false); // so we can add margin to center horizontally
388 b->setMargin(WLength::Auto, Side::Left | Side::Right);
389 b->clicked().connect(this, &ChartConfig::update);
390 }
391}
ChartConfig::seriesControls_
std::vector< SeriesControl > seriesControls_
Controls for series.
Definition ChartConfig.h:66
ChartConfig::addAxis
void addAxis(Wt::Chart::Axis axis, int axisId)
Definition ChartConfig.C:692
ChartConfig::legendAlignmentEdit_
Wt::WComboBox * legendAlignmentEdit_
Definition ChartConfig.h:92
ChartConfig::legendLocationEdit_
Wt::WComboBox * legendLocationEdit_
Definition ChartConfig.h:90
ChartConfig::angleValidator_
std::shared_ptr< Wt::WValidator > angleValidator_
Definition ChartConfig.h:97
ChartConfig::axisConfig_
Wt::WTable * axisConfig_
Definition ChartConfig.h:96
ChartConfig::legendSideEdit_
Wt::WComboBox * legendSideEdit_
Definition ChartConfig.h:91
ChartConfig::anyNumberValidator_
std::shared_ptr< Wt::WValidator > anyNumberValidator_
Definition ChartConfig.h:97
ChartConfig::chartWidthEdit_
Wt::WLineEdit * chartWidthEdit_
Definition ChartConfig.h:87
ChartConfig::titleEdit_
Wt::WLineEdit * titleEdit_
Definition ChartConfig.h:86
ChartConfig::addYAxis
void addYAxis()
Definition ChartConfig.C:683
ChartConfig::xAxesModel_
std::shared_ptr< Wt::WStandardItemModel > xAxesModel_
Definition ChartConfig.h:95
ChartConfig::connectSignals
void connectSignals(Wt::WFormWidget *w)
Definition ChartConfig.C:667
ChartConfig::chart_
Wt::Chart::WCartesianChart * chart_
Definition ChartConfig.h:50
ChartConfig::clearYAxes
void clearYAxes()
Definition ChartConfig.C:839
ChartConfig::xScales_
std::shared_ptr< Wt::WStandardItemModel > xScales_
Definition ChartConfig.h:95
ChartConfig::clearXAxes
void clearXAxes()
Definition ChartConfig.C:822
ChartConfig::fill_
Wt::Chart::FillRangeType fill_
Definition ChartConfig.h:51
ChartConfig::addXAxis
void addXAxis()
Definition ChartConfig.C:674
ChartConfig::update
void update()
Definition ChartConfig.C:398
ChartConfig::borderEdit_
Wt::WCheckBox * borderEdit_
Definition ChartConfig.h:93
ChartConfig::chartHeightEdit_
Wt::WLineEdit * chartHeightEdit_
Definition ChartConfig.h:88
ChartConfig::yAxesModel_
std::shared_ptr< Wt::WStandardItemModel > yAxesModel_
Definition ChartConfig.h:95
ChartConfig::chartOrientationEdit_
Wt::WComboBox * chartOrientationEdit_
Definition ChartConfig.h:89
ChartConfig::yScales_
std::shared_ptr< Wt::WStandardItemModel > yScales_
Definition ChartConfig.h:95
PanelList::addWidget
Wt::WPanel * addWidget(const Wt::WString &text, std::unique_ptr< Wt::WWidget > w)
Definition PanelList.C:17
Wt::Chart::WAbstractChart::model
std::shared_ptr< WAbstractChartModel > model() const
Wt::Chart::WCartesianChart::setLegendStyle
void setLegendStyle(const WFont &font, const WPen &border, const WBrush &background)
Wt::Chart::WCartesianChart::series
WDataSeries & series(int modelColumn)
Wt::Chart::WDataSeries::marker
MarkerType marker() const
Wt::Chart::WDataSeries::shadow
const WShadow & shadow() const
Wt::Chart::WDataSeries::isStacked
bool isStacked() const
Wt::Chart::WDataSeries::fillRange
FillRangeType fillRange() const
Wt::Chart::WDataSeries::type
SeriesType type() const
Wt::Chart::WDataSeries::isLegendEnabled
bool isLegendEnabled() const
Wt::WAbstractToggleButton::setChecked
void setChecked(bool checked)
Wt::WComboBox::setCurrentIndex
void setCurrentIndex(int index)
Wt::WComboBox::setModel
void setModel(const std::shared_ptr< WAbstractItemModel > model)
Wt::WCompositeWidget::resize
virtual void resize(const WLength &width, const WLength &height) override
Wt::WCompositeWidget::setMargin
virtual void setMargin(const WLength &margin, WFlags< Side > sides=AllSides) override
Wt::WContainerWidget::addWidget
virtual void addWidget(std::unique_ptr< WWidget > widget)
Wt::WFormWidget::setValidator
virtual void setValidator(const std::shared_ptr< WValidator > &validator)
Wt::WInteractWidget::clicked
EventSignal< WMouseEvent > & clicked()
Wt::WLength::Auto
static WLength Auto
Wt::WLength::value
double value() const
Wt::WLineEdit::setMaxLength
virtual void setMaxLength(int length)
Wt::WLineEdit::setText
virtual void setText(const WString &text)
Wt::WLocale::currentLocale
static const WLocale & currentLocale()
Wt::WPanel::expand
void expand()
Wt::WTableRow::setStyleClass
void setStyleClass(const WString &style)
Wt::WTable::rowAt
WTableRow * rowAt(int row)
Wt::WWebWidget::width
virtual WLength width() const override
Wt::WWebWidget::setMargin
virtual void setMargin(const WLength &margin, WFlags< Side > sides=AllSides) override
Wt::WWebWidget::height
virtual WLength height() const override

Member Function Documentation

◆ addAxis()

void ChartConfig::addAxis ( Wt::Chart::Axis  axis,
int  axisId 
)
private

Definition at line 692 of file ChartConfig.C.

693{
694 int j = ax == Axis::X ? 1 + axisId : 1 + chart_->xAxisCount() + axisId;
695
696 const WAxis& axis = ax == Axis::X ? chart_->xAxis(axisId) : chart_->yAxis(axisId);
697 AxisControl sc;
698
699 axisConfig_->insertRow(j);
700 axisConfig_->elementAt(j, 0)->addNew<WText>(axisName(axis.id(), axis.yAxisId()));
701
702 sc.visibleEdit = axisConfig_->elementAt(j, 1)->addNew<WCheckBox>();
703 sc.visibleEdit->setChecked(axis.isVisible());
704 connectSignals(sc.visibleEdit);
705
706 sc.scaleEdit = axisConfig_->elementAt(j, 2)->addNew<WComboBox>();
707 if (axis.scale() == AxisScale::Discrete)
708 sc.scaleEdit->addItem("Discrete scale");
709 else {
710 if (axis.id() == Axis::X) {
711 sc.scaleEdit->setModel(xScales_);
712 sc.scaleEdit->setCurrentIndex(static_cast<int>(axis.scale()));
713 } else {
714 sc.scaleEdit->setModel(yScales_);
715 sc.scaleEdit->setCurrentIndex(static_cast<int>(axis.scale()) - 1);
716 }
717 }
718 connectSignals(sc.scaleEdit);
719
720 bool autoValues = axis.autoLimits() == (AxisValue::Minimum | AxisValue::Maximum);
721
722 sc.minimumEdit = axisConfig_->elementAt(j, 4)->addNew<WLineEdit>();
723 sc.minimumEdit->setText(WLocale::currentLocale()
724 .toString(axis.minimum()));
725 sc.minimumEdit->setValidator(anyNumberValidator_);
726 sc.minimumEdit->setEnabled(!autoValues);
727 connectSignals(sc.minimumEdit);
728
729 sc.maximumEdit = axisConfig_->elementAt(j, 5)->addNew<WLineEdit>();
730 sc.maximumEdit->setText(WLocale::currentLocale()
731 .toString(axis.maximum()));
732 sc.maximumEdit->setValidator(anyNumberValidator_);
733 sc.maximumEdit->setEnabled(!autoValues);
734 connectSignals(sc.maximumEdit);
735
736 sc.autoEdit = axisConfig_->elementAt(j, 3)->addNew<WCheckBox>();
737 sc.autoEdit->setChecked(autoValues);
738 connectSignals(sc.autoEdit);
739 sc.autoEdit->checked().connect(sc.maximumEdit, &WLineEdit::disable);
740 sc.autoEdit->unChecked().connect(sc.maximumEdit, &WLineEdit::enable);
741 sc.autoEdit->checked().connect(sc.minimumEdit, &WLineEdit::disable);
742 sc.autoEdit->unChecked().connect(sc.minimumEdit, &WLineEdit::enable);
743
744 sc.gridLinesEdit = axisConfig_->elementAt(j, 6)->addNew<WCheckBox>();
745 connectSignals(sc.gridLinesEdit);
746
747 sc.labelAngleEdit = axisConfig_->elementAt(j, 7)->addNew<WLineEdit>();
748 sc.labelAngleEdit->setText("0");
749 sc.labelAngleEdit->setValidator(angleValidator_);
750 connectSignals(sc.labelAngleEdit);
751
752 sc.titleEdit = axisConfig_->elementAt(j, 8)->addNew<WLineEdit>();
753 sc.titleEdit->setText("");
754 connectSignals(sc.titleEdit);
755
756 sc.titleOrientationEdit = axisConfig_->elementAt(j, 9)->addNew<WComboBox>();
757 sc.titleOrientationEdit->addItem("Horizontal");
758 sc.titleOrientationEdit->addItem("Vertical");
759 sc.titleOrientationEdit->setCurrentIndex(0);
760 connectSignals(sc.titleOrientationEdit);
761
762 sc.tickDirectionEdit = axisConfig_->elementAt(j, 10)->addNew<WComboBox>();
763 sc.tickDirectionEdit->addItem("Outwards");
764 sc.tickDirectionEdit->addItem("Inwards");
765 sc.tickDirectionEdit->setCurrentIndex(0);
766 connectSignals(sc.tickDirectionEdit);
767
768 sc.locationEdit = axisConfig_->elementAt(j, 11)->addNew<WComboBox>();
769 sc.locationEdit->addItem("Minimum value");
770 sc.locationEdit->addItem("Maximum value");
771 sc.locationEdit->addItem("Zero value");
772 sc.locationEdit->addItem("Both sides");
773 sc.locationEdit->setCurrentIndex(0);
774 if (axis.location() == AxisValue::Maximum) {
775 sc.locationEdit->setCurrentIndex(1);
776 } else if (axis.location() == AxisValue::Zero) {
777 sc.locationEdit->setCurrentIndex(2);
778 }
779 connectSignals(sc.locationEdit);
780
781 WPushButton *removeAxisButton =
782 axisConfig_->elementAt(j, 12)->addNew<WPushButton>(utf8("x"));
783 if (ax == Axis::X) {
784 removeAxisButton->clicked().connect(std::bind(&ChartConfig::removeXAxis, this, &axis));
785 } else {
786 removeAxisButton->clicked().connect(std::bind(&ChartConfig::removeYAxis, this, &axis));
787 }
788
789 axisConfig_->rowAt(j)->setStyleClass("trdata");
790
791 axisControls_.insert(axisControls_.begin() + j - 1, sc);
792}
ChartConfig::removeXAxis
void removeXAxis(const Wt::Chart::WAxis *axis)
Definition ChartConfig.C:794
ChartConfig::removeYAxis
void removeYAxis(const Wt::Chart::WAxis *axis)
Definition ChartConfig.C:808
ChartConfig::axisControls_
std::vector< AxisControl > axisControls_
Controls for axes.
Definition ChartConfig.h:84
Wt::Chart::WAxis::maximum
double maximum() const
Wt::Chart::WAxis::yAxisId
int yAxisId() const
Wt::Chart::WAxis::autoLimits
WFlags< AxisValue > autoLimits() const
Wt::Chart::WAxis::id
Axis id() const
Wt::Chart::WAxis::isVisible
bool isVisible() const
Wt::Chart::WAxis::scale
AxisScale scale() const
Wt::Chart::WAxis::minimum
double minimum() const
Wt::Chart::WAxis::location
AxisValue location() const
Wt::WComboBox::addItem
void addItem(const WString &text)
Wt::WContainerWidget::addNew
Widget * addNew(Args &&...args)
Wt::WLocale::toString
WString toString(int value) const
Wt::WTable::insertRow
virtual WTableRow * insertRow(int row, std::unique_ptr< WTableRow > tableRow=nullptr)
Wt::WTable::elementAt
WTableCell * elementAt(int row, int column)

◆ addXAxis()

void ChartConfig::addXAxis ( )
private

Definition at line 674 of file ChartConfig.C.

675{
676 int xAxis = chart_->addXAxis(std::make_unique<WAxis>());
677 addAxis(Axis::X, xAxis);
678 addEntry(xAxesModel_, axisName(Axis::X, xAxis));
679 if (xAxis == 0)
680 update();
681}
Wt::Chart::WCartesianChart::addXAxis
int addXAxis(std::unique_ptr< WAxis > waxis)

◆ addYAxis()

void ChartConfig::addYAxis ( )
private

Definition at line 683 of file ChartConfig.C.

684{
685 int yAxis = chart_->addYAxis(std::make_unique<WAxis>());
686 addAxis(Axis::Y, yAxis);
687 addEntry(yAxesModel_, axisName(Axis::Y, yAxis));
688 if (yAxis == 0)
689 update();
690}
Wt::Chart::WCartesianChart::addYAxis
int addYAxis(std::unique_ptr< WAxis > waxis)

◆ clearXAxes()

void ChartConfig::clearXAxes ( )
private

Definition at line 822 of file ChartConfig.C.

823{
824 if (chart_->xAxisCount() == 0)
825 return;
826
827 for (std::size_t i = 0; i < chart_->series().size(); ++i) {
828 chart_->series()[i]->bindToXAxis(-1);
829 }
830 const int xAxisCount = chart_->xAxisCount();
831 chart_->clearXAxes();
832 for (int i = 0; i < xAxisCount; ++i) {
833 axisConfig_->removeRow(1);
834 }
835 xAxesModel_->clear();
836 axisControls_.erase(axisControls_.begin(), axisControls_.begin() + xAxisCount);
837}
Wt::Chart::WDataSeries::bindToXAxis
void bindToXAxis(int xAxis)
Wt::WTable::removeRow
virtual std::unique_ptr< WTableRow > removeRow(int row)

◆ clearYAxes()

void ChartConfig::clearYAxes ( )
private

Definition at line 839 of file ChartConfig.C.

840{
841 if (chart_->yAxisCount() == 0)
842 return;
843
844 for (std::size_t i = 0; i < chart_->series().size(); ++i) {
845 chart_->series()[i]->bindToYAxis(-1);
846 }
847 const int yAxisCount = chart_->yAxisCount();
848 chart_->clearYAxes();
849 for (int i = 0; i < yAxisCount; ++i) {
850 axisConfig_->removeRow(axisConfig_->rowCount() - 1);
851 }
852 yAxesModel_->clear();
853 axisControls_.resize(chart_->xAxisCount());
854}
Wt::Chart::WDataSeries::bindToYAxis
void bindToYAxis(int yAxis)
Wt::WTable::rowCount
int rowCount() const

◆ connectSignals()

void ChartConfig::connectSignals ( Wt::WFormWidget *  w)
private

Definition at line 667 of file ChartConfig.C.

668{
669 w->changed().connect(this, &ChartConfig::update);
670 if (dynamic_cast<WLineEdit *>(w))
671 w->enterPressed().connect(this, &ChartConfig::update);
672}
Wt::EventSignal::connect
Wt::Signals::connection connect(F function)
Wt::WFormWidget::changed
EventSignal & changed()
Wt::WInteractWidget::enterPressed
EventSignal & enterPressed()

◆ removeXAxis()

void ChartConfig::removeXAxis ( const Wt::Chart::WAxis *  axis)
private

Definition at line 794 of file ChartConfig.C.

795{
796 int xAxis = axis->xAxisId();
797 for (std::size_t i = 0; i < chart_->series().size(); ++i) {
798 if (chart_->series()[i]->xAxis() == xAxis)
799 chart_->series()[i]->bindToXAxis(-1);
800 }
801 chart_->removeXAxis(xAxis);
802 axisConfig_->removeRow(1 + xAxis);
803 xAxesModel_->removeRow(xAxis);
804 axisControls_.erase(axisControls_.begin() + xAxis);
805 update();
806}
Wt::Chart::WAxis::xAxisId
int xAxisId() const
Wt::Chart::WCartesianChart::removeXAxis
std::unique_ptr< WAxis > removeXAxis(int xAxisId)

◆ removeYAxis()

void ChartConfig::removeYAxis ( const Wt::Chart::WAxis *  axis)
private

Definition at line 808 of file ChartConfig.C.

809{
810 int yAxis = axis->yAxisId();
811 for (std::size_t i = 0; i < chart_->series().size(); ++i) {
812 if (chart_->series()[i]->yAxis() == yAxis)
813 chart_->series()[i]->bindToYAxis(-1);
814 }
815 chart_->removeYAxis(yAxis);
816 axisConfig_->removeRow(1 + chart_->xAxisCount() + yAxis);
817 yAxesModel_->removeRow(yAxis);
818 axisControls_.erase(axisControls_.begin() + chart_->xAxisCount() + yAxis);
819 update();
820}
Wt::Chart::WCartesianChart::removeYAxis
std::unique_ptr< WAxis > removeYAxis(int yAxisId)

◆ setValueFill()

void ChartConfig::setValueFill ( Wt::Chart::FillRangeType  fill)

Definition at line 393 of file ChartConfig.C.

394{
395 fill_ = fill;
396}

◆ update()

void ChartConfig::update ( )
private

Definition at line 398 of file ChartConfig.C.

399{
400 bool haveLegend = false;
401 std::vector<std::unique_ptr<WDataSeries>> series;
402
403 for (int i = 1; i < chart_->model()->columnCount(); ++i) {
404 SeriesControl& sc = seriesControls_[i-1];
405
406 if (sc.enabledEdit->isChecked()) {
407 std::unique_ptr<WDataSeries> s
408 = std::make_unique<WDataSeries>(i);
409
410 switch (sc.typeEdit->currentIndex()) {
411 case 0:
412 s->setType(SeriesType::Point);
413 if (sc.markerEdit->currentIndex() == 0)
414 sc.markerEdit->setCurrentIndex(1);
415 break;
416 case 1:
417 s->setType(SeriesType::Line);
418 break;
419 case 2:
420 s->setType(SeriesType::Curve);
421 break;
422 case 3:
423 s->setType(SeriesType::Bar);
424 break;
425 case 4:
426 s->setType(SeriesType::Line);
427 s->setFillRange(fill_);
428 break;
429 case 5:
430 s->setType(SeriesType::Curve);
431 s->setFillRange(fill_);
432 break;
433 case 6:
434 s->setType(SeriesType::Bar);
435 s->setStacked(true);
436 break;
437 case 7:
438 s->setType(SeriesType::Line);
439 s->setFillRange(fill_);
440 s->setStacked(true);
441 break;
442 case 8:
443 s->setType(SeriesType::Curve);
444 s->setFillRange(fill_);
445 s->setStacked(true);
446 }
447
448 //set WPainterPath to draw a pipe
449 if(sc.markerEdit->currentIndex() == static_cast<int>(MarkerType::Custom)){ //was customMarker before
450 WPainterPath pp = WPainterPath();
451 pp.moveTo(0, -6);
452 pp.lineTo(0, 6);
453 s->setCustomMarker(pp);
454 }
455
456 s->setMarker(static_cast<MarkerType>(sc.markerEdit->currentIndex()));
457
458 s->bindToXAxis(sc.xAxisEdit->currentIndex());
459 s->bindToYAxis(sc.yAxisEdit->currentIndex());
460
461 if (sc.legendEdit->isChecked()) {
462 s->setLegendEnabled(true);
463 haveLegend = true;
464 } else
465 s->setLegendEnabled(false);
466
467 if (sc.shadowEdit->isChecked()) {
468 s->setShadow(WShadow(3, 3, WColor(0, 0, 0, 127), 3));
469 } else
470 s->setShadow(WShadow());
471
472 switch (sc.labelsEdit->currentIndex()) {
473 case 1:
474 s->setLabelsEnabled(Axis::X);
475 break;
476 case 2:
477 s->setLabelsEnabled(Axis::Y);
478 break;
479 case 3:
480 s->setLabelsEnabled(Axis::X);
481 s->setLabelsEnabled(Axis::Y);
482 break;
483 }
484
485 series.push_back(std::move(s));
486 }
487 }
488
489 chart_->setSeries(std::move(series));
490
491 for (std::size_t i = 0; i < axisControls_.size(); ++i) {
492 AxisControl& sc = axisControls_[i];
493 WAxis& axis = static_cast<int>(i) < chart_->xAxisCount() ? chart_->xAxis(i) : chart_->yAxis(i - chart_->xAxisCount());
494
495 axis.setVisible(sc.visibleEdit->isChecked());
496
497 if (sc.scaleEdit->count() != 1) {
498 int k = sc.scaleEdit->currentIndex();
499 if (axis.id() != Axis::X)
500 k += 1;
501 else {
502 if (k == 0)
503 chart_->setType(ChartType::Category);
504 else
505 chart_->setType(ChartType::Scatter);
506 }
507
508 switch (k) {
509 case 1:
510 axis.setScale(AxisScale::Linear); break;
511 case 2:
512 axis.setScale(AxisScale::Log); break;
513 case 3:
514 axis.setScale(AxisScale::Date); break;
515 }
516 }
517
518 if (sc.autoEdit->isChecked())
519 axis.setAutoLimits(AxisValue::Minimum | AxisValue::Maximum);
520 else {
521 if (!(axis.autoLimits() & (AxisValue::Minimum | AxisValue::Maximum)).empty()) {
522 sc.minimumEdit->setText(WLocale::currentLocale()
523 .toString(axis.minimum()));
524 sc.maximumEdit->setText(WLocale::currentLocale()
525 .toString(axis.maximum()));
526 }
527 if (validate(sc.minimumEdit) && validate(sc.maximumEdit)) {
528 double min, max;
529 getDouble(sc.minimumEdit, min);
530 getDouble(sc.maximumEdit, max);
531
532 if (axis.scale() == AxisScale::Log)
533 if (min <= 0)
534 min = 0.0001;
535
536 if (axis.scale() == AxisScale::Date){
537 //the number of julian days until year 1986
538 WDate dMin = WDate(1900,1,1);
539 double gregDaysMin = (double)dMin.toJulianDay();
540 //the number of julian days until year 1988
541 WDate dMax = WDate(3000,1,1);
542 double gregDaysMax = (double)dMax.toJulianDay();
543
544 bool greg_year_validation =
545 (min > gregDaysMin &&
546 min < gregDaysMax &&
547 max > gregDaysMin &&
548 max < gregDaysMax);
549
550 if(!greg_year_validation){
551 min = gregDaysMin;
552 max = gregDaysMax;
553 }
554 }
555
556 axis.setRange(min, max);
557 }
558
559 }
560
561 if (validate(sc.labelAngleEdit)) {
562 double angle;
563 getDouble(sc.labelAngleEdit, angle);
564 axis.setLabelAngle(angle);
565 }
566
567 axis.setGridLinesEnabled(sc.gridLinesEdit->isChecked());
568
569 axis.setTitle(sc.titleEdit->text());
570
571 axis.setTitleOrientation(sc.titleOrientationEdit->currentIndex() == 0 ? Orientation::Horizontal : Orientation::Vertical);
572
573 axis.setTickDirection(sc.tickDirectionEdit->currentIndex() == 0 ? TickDirection::Outwards : TickDirection::Inwards);
574
575 switch (sc.locationEdit->currentIndex()) {
576 case 0:
577 axis.setLocation(AxisValue::Minimum);
578 break;
579 case 1:
580 axis.setLocation(AxisValue::Maximum);
581 break;
582 case 2:
583 axis.setLocation(AxisValue::Zero);
584 break;
585 case 3:
586 axis.setLocation(AxisValue::Both);
587 break;
588 }
589 }
590
591 chart_->setTitle(titleEdit_->text());
592
593 if (validate(chartWidthEdit_) && validate(chartHeightEdit_)) {
594 double width, height;
595 getDouble(chartWidthEdit_, width);
596 getDouble(chartHeightEdit_, height);
597 chart_->resize(width, height);
598 }
599
600 switch (chartOrientationEdit_->currentIndex()) {
601 case 0:
602 chart_->setOrientation(Orientation::Vertical); break;
603 case 1:
604 chart_->setOrientation(Orientation::Horizontal); break;
605 }
606
607 chart_->setLegendEnabled(haveLegend);
608
609 if (haveLegend) {
610 LegendLocation location = LegendLocation::Outside;
611 Side side = Side::Right;
612 AlignmentFlag alignment = AlignmentFlag::Middle;
613 switch (legendLocationEdit_->currentIndex()) {
614 case 0: location = LegendLocation::Outside; break;
615 case 1: location = LegendLocation::Inside; break;
616 }
617
618 switch (legendSideEdit_->currentIndex()) {
619 case 0: side = Side::Top; break;
620 case 1: side = Side::Right; break;
621 case 2: side = Side::Bottom; break;
622 case 3: side = Side::Left; break;
623 }
624
625 if (side == Side::Left || side == Side::Right) {
626 if (legendAlignmentEdit_->currentIndex() < 3)
627 legendAlignmentEdit_->setCurrentIndex(4);
628 } else {
629 if (legendAlignmentEdit_->currentIndex() >= 3)
630 legendAlignmentEdit_->setCurrentIndex(2);
631 }
632
633 switch (legendAlignmentEdit_->currentIndex()) {
634 case 0: alignment = AlignmentFlag::Left; break;
635 case 1: alignment = AlignmentFlag::Center; break;
636 case 2: alignment = AlignmentFlag::Right; break;
637 case 3: alignment = AlignmentFlag::Top; break;
638 case 4: alignment = AlignmentFlag::Middle; break;
639 case 5: alignment = AlignmentFlag::Bottom; break;
640 }
641
642 chart_->setLegendLocation(location, side, alignment);
643
644 chart_->setLegendColumns((side == Side::Top || side == Side::Bottom ) ? 2 : 1,
645 WLength(100));
646 }
647
648 if (borderEdit_->isChecked()) {
649 chart_->setBorderPen(WPen());
650 } else {
651 chart_->setBorderPen(PenStyle::None);
652 }
653}
ChartConfig::validate
static bool validate(Wt::WFormWidget *w)
Definition ChartConfig.C:655
Wt::Chart::WAbstractChart::setTitle
void setTitle(const WString &title)
Wt::Chart::WAxis::setAutoLimits
void setAutoLimits(WFlags< AxisValue > locations)
Wt::Chart::WAxis::setVisible
void setVisible(bool visible)
Wt::Chart::WAxis::setLocation
void setLocation(AxisValue value)
Wt::Chart::WAxis::setGridLinesEnabled
void setGridLinesEnabled(bool enabled)
Wt::Chart::WAxis::setRange
void setRange(double minimum, double maximum)
Wt::Chart::WAxis::setScale
void setScale(AxisScale scale)
Wt::Chart::WAxis::setTickDirection
void setTickDirection(TickDirection direction)
Wt::Chart::WAxis::setTitleOrientation
void setTitleOrientation(const Orientation &orientation)
Wt::Chart::WAxis::setTitle
void setTitle(const WString &title)
Wt::Chart::WAxis::setLabelAngle
void setLabelAngle(double angle)
Wt::Chart::WCartesianChart::setType
void setType(ChartType type)
Wt::Chart::WCartesianChart::setLegendEnabled
void setLegendEnabled(bool enabled)
Wt::Chart::WCartesianChart::setLegendColumns
void setLegendColumns(int columns, const WLength &width)
Wt::Chart::WCartesianChart::setOrientation
void setOrientation(Orientation orientation)
Wt::Chart::WCartesianChart::setBorderPen
void setBorderPen(const WPen &pen)
Wt::Chart::WCartesianChart::setSeries
void setSeries(std::vector< std::unique_ptr< WDataSeries > > series)
Wt::Chart::WCartesianChart::setLegendLocation
void setLegendLocation(LegendLocation location, Side side, AlignmentFlag alignment)
Wt::WComboBox::currentIndex
int currentIndex() const
Wt::WDate::toJulianDay
int toJulianDay() const
Wt::WLineEdit::text
const WString & text() const
Wt::WPaintedWidget::resize
virtual void resize(const WLength &width, const WLength &height) override
Wt::WPainterPath::moveTo
void moveTo(const WPointF &point)
Wt::WPainterPath::lineTo
void lineTo(const WPointF &point)
Wt::Chart::LegendLocation
LegendLocation
Wt::Chart::MarkerType
MarkerType
Wt::Orientation
Orientation
Wt::AlignmentFlag
AlignmentFlag

◆ validate()

bool ChartConfig::validate ( Wt::WFormWidget *  w)
staticprivate

Definition at line 655 of file ChartConfig.C.

656{
657 bool valid = w->validate() == ValidationState::Valid;
658
659 if (!WApplication::instance()->environment().javaScript()) {
660 w->setStyleClass(valid ? "" : "Wt-invalid");
661 w->setToolTip(valid ? "" : "Invalid value");
662 }
663
664 return valid;
665}
Wt::WFormWidget::validate
virtual ValidationState validate()
Wt::WFormWidget::setToolTip
virtual void setToolTip(const WString &text, TextFormat textFormat=TextFormat::Plain) override
Wt::WWebWidget::setStyleClass
virtual void setStyleClass(const WString &styleClass) override

Member Data Documentation

◆ angleValidator_

std::shared_ptr<Wt::WValidator> ChartConfig::angleValidator_
private

Definition at line 97 of file ChartConfig.h.

◆ anyNumberValidator_

std::shared_ptr<Wt::WValidator> ChartConfig::anyNumberValidator_
private

Definition at line 97 of file ChartConfig.h.

◆ axisConfig_

Wt::WTable* ChartConfig::axisConfig_
private

Definition at line 96 of file ChartConfig.h.

◆ axisControls_

std::vector<AxisControl> ChartConfig::axisControls_
private

Controls for axes.

Definition at line 84 of file ChartConfig.h.

◆ borderEdit_

Wt::WCheckBox* ChartConfig::borderEdit_
private

Definition at line 93 of file ChartConfig.h.

◆ chart_

Wt::Chart::WCartesianChart* ChartConfig::chart_
private

Definition at line 50 of file ChartConfig.h.

◆ chartHeightEdit_

Wt::WLineEdit* ChartConfig::chartHeightEdit_
private

Definition at line 88 of file ChartConfig.h.

◆ chartOrientationEdit_

Wt::WComboBox* ChartConfig::chartOrientationEdit_
private

Definition at line 89 of file ChartConfig.h.

◆ chartWidthEdit_

Wt::WLineEdit* ChartConfig::chartWidthEdit_
private

Definition at line 87 of file ChartConfig.h.

◆ fill_

Wt::Chart::FillRangeType ChartConfig::fill_
private

Definition at line 51 of file ChartConfig.h.

◆ legendAlignmentEdit_

Wt::WComboBox* ChartConfig::legendAlignmentEdit_
private

Definition at line 92 of file ChartConfig.h.

◆ legendLocationEdit_

Wt::WComboBox* ChartConfig::legendLocationEdit_
private

Definition at line 90 of file ChartConfig.h.

◆ legendSideEdit_

Wt::WComboBox* ChartConfig::legendSideEdit_
private

Definition at line 91 of file ChartConfig.h.

◆ seriesControls_

std::vector<SeriesControl> ChartConfig::seriesControls_
private

Controls for series.

Definition at line 66 of file ChartConfig.h.

◆ titleEdit_

Wt::WLineEdit* ChartConfig::titleEdit_
private

Definition at line 86 of file ChartConfig.h.

◆ xAxesModel_

std::shared_ptr<Wt::WStandardItemModel> ChartConfig::xAxesModel_
private

Definition at line 95 of file ChartConfig.h.

◆ xScales_

std::shared_ptr<Wt::WStandardItemModel> ChartConfig::xScales_
private

Definition at line 95 of file ChartConfig.h.

◆ yAxesModel_

std::shared_ptr<Wt::WStandardItemModel> ChartConfig::yAxesModel_
private

Definition at line 95 of file ChartConfig.h.

◆ yScales_

std::shared_ptr<Wt::WStandardItemModel> ChartConfig::yScales_
private

Definition at line 95 of file ChartConfig.h.

The documentation for this class was generated from the following files:
Generated on Tue Jan 27 2026 for the C++ Web Toolkit (Wt) by  doxygen 1.9.8