Eclipse SUMO - Simulation of Urban MObility
GNEGenericDataFrame.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2020 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
18 // The Widget for add genericData elements
19 /****************************************************************************/
20 #include <config.h>
21 
22 #include <netedit/GNENet.h>
23 #include <netedit/GNEViewNet.h>
28 
29 #include "GNEGenericDataFrame.h"
30 
31 
32 // ===========================================================================
33 // FOX callback mapping
34 // ===========================================================================
35 
41 
42 };
43 
49 };
50 
53 };
54 
55 // Object implementation
56 FXIMPLEMENT(GNEGenericDataFrame::DataSetSelector, FXGroupBox, DataSetSelectorMap, ARRAYNUMBER(DataSetSelectorMap))
57 FXIMPLEMENT(GNEGenericDataFrame::IntervalSelector, FXGroupBox, IntervalSelectorMap, ARRAYNUMBER(IntervalSelectorMap))
58 FXIMPLEMENT(GNEGenericDataFrame::AttributeSelector, FXGroupBox, AttributeSelectorMap, ARRAYNUMBER(AttributeSelectorMap))
59 
60 // ===========================================================================
61 // method definitions
62 // ===========================================================================
63 
64 // ---------------------------------------------------------------------------
65 // GNEGenericDataFrame::DataSetSelector - methods
66 // ---------------------------------------------------------------------------
67 
69  FXGroupBox(genericDataFrameParent->myContentFrame, "DataSet", GUIDesignGroupBoxFrame),
70  myGenericDataFrameParent(genericDataFrameParent) {
71  // create check button for new data set
72  myNewDataSetCheckButton = new FXCheckButton(this, "Create new dataSet", this, MID_GNE_SELECT, GUIDesignCheckButton);
73  // Create FXComboBox
74  myDataSetsComboBox = new FXComboBox(this, GUIDesignComboBoxNCol, this, MID_GNE_DATASET_SELECTED, GUIDesignComboBox);
75  // create new id label
76  myHorizontalFrameNewID = new FXHorizontalFrame(this, GUIDesignAuxiliarHorizontalFrame);
77  new FXLabel(myHorizontalFrameNewID, "new dataSet ID", nullptr, GUIDesignLabelAttribute);
78  // create new id textField
79  myNewDataSetIDTextField = new FXTextField(myHorizontalFrameNewID, GUIDesignTextFieldNCol, this, MID_GNE_SET_ATTRIBUTE, GUIDesignTextField);
80  // hide horizontal frame
81  myHorizontalFrameNewID->hide();
82  // create dataSet button
83  myCreateDataSetButton = new FXButton(this, "Create dataSet", GUIIconSubSys::getIcon(GUIIcon::DATASET), this, MID_GNE_CREATE, GUIDesignButton);
84  myCreateDataSetButton->hide();
85  // refresh interval selector
86  refreshDataSetSelector(nullptr);
87  // DataSetSelector is always shown
88  show();
89 }
90 
91 
93 
94 
95 void
97  // clear items
98  myDataSetsComboBox->clearItems();
99  // declare item index
100  int currentItemIndex = -1;
101  // fill myDataSetsComboBox with all DataSets
102  auto dataSetCopy = myGenericDataFrameParent->getViewNet()->getNet()->retrieveDataSets();
103  for (const auto& dataSet : dataSetCopy) {
104  // check if we have to set currentItemIndex
105  if ((currentItemIndex == -1) && (dataSet == currentDataSet)) {
106  currentItemIndex = myDataSetsComboBox->getNumItems();
107  }
108  myDataSetsComboBox->appendItem(dataSet->getID().c_str());
109  }
110  // Set visible items
111  myDataSetsComboBox->setNumVisible((int)myDataSetsComboBox->getNumItems());
112  // check if we have to set current element
113  if (currentItemIndex != -1) {
114  myDataSetsComboBox->setCurrentItem(currentItemIndex, FALSE);
115  }
116  // recalc frame
117  recalc();
118  // refresh interval selector
119  if (myGenericDataFrameParent->myIntervalSelector) {
120  myGenericDataFrameParent->myIntervalSelector->refreshIntervalSelector();
121  }
122 }
123 
124 
125 GNEDataSet*
127  if ((myNewDataSetCheckButton->getCheck() == TRUE) || (myDataSetsComboBox->getNumItems() == 0)) {
128  return nullptr;
129  } else {
130  return myGenericDataFrameParent->getViewNet()->getNet()->retrieveDataSet(myDataSetsComboBox->getItem(myDataSetsComboBox->getCurrentItem()).text(), false);
131  }
132 }
133 
134 
135 long
137  // get string
138  const std::string dataSetID = myNewDataSetIDTextField->getText().text();
139  // check conditions
140  if (myNewDataSetIDTextField->getTextColor() == FXRGB(255, 0, 0)) {
141  WRITE_WARNING("Invalid dataSet ID");
142  } else if (dataSetID.empty()) {
143  WRITE_WARNING("Invalid empty dataSet ID");
144  } else if (myGenericDataFrameParent->getViewNet()->getNet()->retrieveDataSet(dataSetID, false) != nullptr) {
145  WRITE_WARNING("Invalid duplicated dataSet ID");
146  } else {
147  // build data set
148  const GNEDataSet* dataSet = GNEDataHandler::buildDataSet(myGenericDataFrameParent->getViewNet()->getNet(), true, dataSetID);
149  // refresh tag selector
150  refreshDataSetSelector(dataSet);
151  // change check button
152  myNewDataSetCheckButton->setCheck(FALSE, TRUE);
153  }
154  return 1;
155 }
156 
157 
158 long
160  //
161  return 1;
162 }
163 
164 
165 long
167  // update interval modul
168  myGenericDataFrameParent->myIntervalSelector->refreshIntervalSelector();
169  return 1;
170 }
171 
172 
173 long
175  if (myNewDataSetCheckButton->getCheck() == TRUE) {
176  // enable textfield and label
177  myHorizontalFrameNewID->show();
178  myCreateDataSetButton->show();
179  // disable comboBox
180  myDataSetsComboBox->hide();
181  } else {
182  // disable textfield and label
183  myHorizontalFrameNewID->hide();
184  myCreateDataSetButton->hide();
185  // enable comboBox
186  myDataSetsComboBox->show();
187  }
188  // update interval modul
189  myGenericDataFrameParent->myIntervalSelector->refreshIntervalSelector();
190  return 1;
191 }
192 
193 // ---------------------------------------------------------------------------
194 // GNEGenericDataFrame::IntervalSelector - methods
195 // ---------------------------------------------------------------------------
196 
198  FXGroupBox(genericDataFrameParent->myContentFrame, "Interval", GUIDesignGroupBoxFrame),
199  myGenericDataFrameParent(genericDataFrameParent) {
200  // create check button for new interval
201  myNewIntervalCheckButton = new FXCheckButton(this, "Create new interval", this, MID_GNE_SELECT, GUIDesignCheckButton);
202  // create begin label
203  myHorizontalFrameBegin = new FXHorizontalFrame(this, GUIDesignAuxiliarHorizontalFrame);
205  // create begin TextField
207  myBeginTextField->setText("0");
208  // hide horizontal frame begin
209  myHorizontalFrameBegin->hide();
210  // create end label
211  myHorizontalFrameEnd = new FXHorizontalFrame(this, GUIDesignAuxiliarHorizontalFrame);
212  new FXLabel(myHorizontalFrameEnd, toString(SUMO_ATTR_END).c_str(), nullptr, GUIDesignLabelAttribute);
213  // create end textfield
215  myEndTextField->setText("3600");
216  // hide horizontal frame end
217  myHorizontalFrameEnd->hide();
218  // create interval button
220  myCreateIntervalButton->hide();
221  // Create three list
223  // refresh interval selector
225  // IntervalSelector is always shown
226  show();
227 }
228 
229 
231 
232 
233 void
235  // first clear items from tree and intervalMap
236  myIntervalsTreelist->clearItems();
237  myTreeItemIntervalMap.clear();
238  // obtain data set
239  const GNEDataSet* dataSet = myGenericDataFrameParent->myDataSetSelector->getDataSet();
240  // add intervals
241  if (dataSet) {
242  // insert dataSetItem in Tree list
243  FXTreeItem* dataSetItem = myIntervalsTreelist->insertItem(
244  nullptr, nullptr,
245  dataSet->getHierarchyName().c_str(),
246  dataSet->getIcon(),
247  dataSet->getIcon());
248  // by default item is expanded
249  dataSetItem->setExpanded(true);
250  // iterate over intevals
251  for (const auto& interval : dataSet->getDataIntervalChildren()) {
252  addIntervalItem(interval.second, dataSetItem);
253  }
254  }
255  // refresh attribute selector
256  if (myGenericDataFrameParent->myAttributeSelector) {
257  myGenericDataFrameParent->myAttributeSelector->refreshAttributeSelector();
258  }
259  // recalc frame
260  recalc();
261 }
262 
263 
266  // first check if there is elements in interval tree
267  if (myIntervalsTreelist->getNumItems() > 0) {
268  for (const auto& treeItem : myTreeItemIntervalMap) {
269  if (treeItem.first->isSelected()) {
270  return treeItem.second;
271  }
272  }
273  }
274  // no GNEDataInterval found, then return nullptr
275  return nullptr;
276 }
277 
278 
279 long
281  // first check that begin and end are valid
282  if (GNEAttributeCarrier::canParse<double>(myBeginTextField->getText().text()) &&
283  GNEAttributeCarrier::canParse<double>(myEndTextField->getText().text())) {
284  // obtain begin and end
285  const double begin = GNEAttributeCarrier::parse<double>(myBeginTextField->getText().text());
286  const double end = GNEAttributeCarrier::parse<double>(myEndTextField->getText().text());
287  // get data set parent
288  GNEDataSet* dataSet = myGenericDataFrameParent->myDataSetSelector->getDataSet();
289  if (dataSet && dataSet->checkNewInterval(begin, end)) {
290  GNEDataHandler::buildDataInterval(myGenericDataFrameParent->getViewNet()->getNet(), true, dataSet, begin, end);
291  }
292  // disable select interval check button
293  myNewIntervalCheckButton->setCheck(FALSE, TRUE);
294  }
295  return 1;
296 }
297 
298 
299 long
301  // refresh attribute selector
302  myGenericDataFrameParent->myAttributeSelector->refreshAttributeSelector();
303  return 1;
304 }
305 
306 
307 long
309  if (obj == myBeginTextField) {
310  // check if begin value can be parsed to double
311  if (GNEAttributeCarrier::canParse<double>(myBeginTextField->getText().text())) {
312  myBeginTextField->setTextColor(FXRGB(0, 0, 0));
313  myBeginTextField->killFocus();
314  } else {
315  myBeginTextField->setTextColor(FXRGB(255, 0, 0));
316  }
317  } else if (obj == myEndTextField) {
318  // check if end value can be parsed to double
319  if (GNEAttributeCarrier::canParse<double>(myEndTextField->getText().text())) {
320  myEndTextField->setTextColor(FXRGB(0, 0, 0));
321  myEndTextField->killFocus();
322  } else {
323  myEndTextField->setTextColor(FXRGB(255, 0, 0));
324  }
325  }
326  return 1;
327 }
328 
329 
330 long
332  if (myNewIntervalCheckButton->getCheck() == TRUE) {
333  // enable begin and end elements
334  myHorizontalFrameBegin->show();
335  myHorizontalFrameEnd->show();
336  myCreateIntervalButton->show();
337  // refresh begin and end text fields
338  const GNEDataSet* dataSet = myGenericDataFrameParent->myDataSetSelector->getDataSet();
339  if (dataSet) {
340  if (dataSet->getDataIntervalChildren().empty()) {
341  // set default interval (1 hour)
342  myBeginTextField->setText("0");
343  myEndTextField->setText("3600");
344  } else {
345  // obtain last data interval
346  const GNEDataInterval* lastDataInterval = dataSet->getDataIntervalChildren().rbegin()->second;
347  const double intervalDuration = lastDataInterval->getAttributeDouble(SUMO_ATTR_END) - lastDataInterval->getAttributeDouble(SUMO_ATTR_BEGIN);
348  // set new begin end
349  myBeginTextField->setText(toString(lastDataInterval->getAttributeDouble(SUMO_ATTR_END)).c_str());
350  myEndTextField->setText(toString(lastDataInterval->getAttributeDouble(SUMO_ATTR_END) + intervalDuration).c_str());
351  }
352  }
353  } else {
354  // disable begin and end elements
355  myHorizontalFrameBegin->hide();
356  myHorizontalFrameEnd->hide();
357  myCreateIntervalButton->hide();
358  }
359  // refresh interval seletor
360  refreshIntervalSelector();
361  return 1;
362 }
363 
364 
365 FXTreeItem*
367  // insert item in Tree list
368  FXTreeItem* item = myIntervalsTreelist->insertItem(nullptr, itemParent,
369  dataInterval->getHierarchyName().c_str(),
370  dataInterval->getIcon(),
371  dataInterval->getIcon());
372  // insert item in map
373  myTreeItemIntervalMap[item] = dataInterval;
374  // by default item is expanded
375  item->setExpanded(true);
376  // select first item
377  if (myTreeItemIntervalMap.size() == 1) {
378  item->setSelected(TRUE);
379  }
380  // return created FXTreeItem
381  return item;
382 }
383 
384 // ---------------------------------------------------------------------------
385 // GNEGenericDataFrame::AttributeSelector - methods
386 // ---------------------------------------------------------------------------
387 
389  FXGroupBox(genericDataFrameParent->myContentFrame, "Data attributes", GUIDesignGroupBoxFrame),
390  myGenericDataFrameParent(genericDataFrameParent),
391  myMinMaxLabel(nullptr),
392  myGenericDataTag(tag) {
393  // Create FXComboBox
395  // build rainbow
397  // refresh interval selector
399  // AttributeSelector is always shown
400  show();
401 }
402 
403 
405 
406 
407 void
409  // first clear items
410  myAttributesComboBox->clearItems();
411  // restore myMinMaxLabel
412  myMinMaxLabel->setText("Scale: Min -> Max");
413  // fill myAttributesComboBox depending of data sets
414  if (myGenericDataFrameParent->myDataSetSelector->getDataSet() == nullptr) {
415  myAttributesComboBox->appendItem("<no dataSet selected>");
416  myAttributesComboBox->disable();
417  } else {
418  // add all item
419  myAttributesComboBox->appendItem("<all>");
420  // add attributes depending of interval
421  if (myGenericDataFrameParent->myIntervalSelector->getDataInterval() == nullptr) {
422  const auto parameters = myGenericDataFrameParent->getViewNet()->getNet()->retrieveGenericDataParameters(
423  myGenericDataFrameParent->myDataSetSelector->getDataSet()->getID(), toString(myGenericDataTag), "", "");
424  // add all parameters
425  for (const auto& attribute : parameters) {
426  myAttributesComboBox->appendItem(attribute.c_str());
427  }
428  } else {
429  // retrieve all parameters within begin and end
430  const auto parameters = myGenericDataFrameParent->getViewNet()->getNet()->retrieveGenericDataParameters(
431  myGenericDataFrameParent->myDataSetSelector->getDataSet()->getID(), toString(myGenericDataTag),
432  myGenericDataFrameParent->myIntervalSelector->getDataInterval()->getAttribute(SUMO_ATTR_BEGIN),
433  myGenericDataFrameParent->myIntervalSelector->getDataInterval()->getAttribute(SUMO_ATTR_END));
434  // add all parameters
435  for (const auto& attribute : parameters) {
436  myAttributesComboBox->appendItem(attribute.c_str());
437  }
438  }
439  // enable combo Box
440  myAttributesComboBox->enable();
441  // adjust visible items
442  if (myAttributesComboBox->getNumItems() < 10) {
443  myAttributesComboBox->setNumVisible(myAttributesComboBox->getNumItems());
444  } else {
445  myAttributesComboBox->setNumVisible(10);
446  }
447  }
448  // recalc frame
449  recalc();
450  // update view net
451  myGenericDataFrameParent->getViewNet()->updateViewNet();
452 }
453 
454 
455 std::string
457  if (myAttributesComboBox->getNumItems() == 0) {
458  return "";
459  } else if (myAttributesComboBox->getText() == "<all>") {
460  return "";
461  } else {
462  return myAttributesComboBox->getText().text();
463  }
464 }
465 
466 
467 const RGBColor&
468 GNEGenericDataFrame::AttributeSelector::getScaledColor(const double min, const double max, const double value) const {
469  // update myMinMaxLabel
470  myMinMaxLabel->setText(("Min: " + toString(min) + " -> Max: " + toString(max)).c_str());
471  // return scaled color
472  return GNEViewNetHelper::getRainbowScaledColor(min, max, value);
473 }
474 
475 
476 long
478  // empty attribute means <all>
479  if (myAttributesComboBox->getText().empty()) {
480  myAttributesComboBox->setText("<all>");
481  }
482  if (myAttributesComboBox->getText() == "<all>") {
483  myMinMaxLabel->setText("Scale: Min -> Max");
484  }
485  // update view
486  myGenericDataFrameParent->getViewNet()->updateViewNet();
487  return 1;
488 }
489 
490 // ---------------------------------------------------------------------------
491 // GNEGenericDataFrame - methods
492 // ---------------------------------------------------------------------------
493 
496  return myDataSetSelector;
497 }
498 
499 
502  return myIntervalSelector;
503 }
504 
505 
508  return myAttributeSelector;
509 }
510 
511 
514  return myPathCreator;
515 }
516 
517 
520  return myGenericDataTag;
521 }
522 
523 
524 void
526  // first refresh data set selector
528  // check if there is an edge path creator
529  if (myPathCreator) {
531  }
532  // show frame
533  GNEFrame::show();
534 }
535 
536 
537 void
539  if (myPathCreator) {
540  // reset candidate edges
541  for (const auto& edge : myViewNet->getNet()->getAttributeCarriers()->getEdges()) {
542  edge.second->resetCandidateFlags();
543  }
544  }
545  // hide frame
546  GNEFrame::hide();
547 }
548 
549 
550 GNEGenericDataFrame::GNEGenericDataFrame(FXHorizontalFrame* horizontalFrameParent, GNEViewNet* viewNet, SumoXMLTag tag, const bool pathCreator) :
551  GNEFrame(horizontalFrameParent, viewNet, toString(tag)),
552  myDataSetSelector(nullptr),
553  myIntervalSelector(nullptr),
554  myAttributeSelector(nullptr),
555  myParametersEditorCreator(nullptr),
556  myPathCreator(nullptr),
557  myGenericDataTag(tag) {
558  // create DataSetSelector
560  // create IntervalSelector modul
562  // create AttributeSelector modul
563  myAttributeSelector = new AttributeSelector(this, tag);
564  // create parameter editor modul
566  // create PathCreator modul
567  if (pathCreator) {
569  }
570 }
571 
572 
574 
575 
576 void
578  //
579 }
580 
581 
582 void
584  // this function has to be reimplemente in all child frames that uses a PathCreator
585 }
586 
587 /****************************************************************************/
FXDEFMAP(GNEGenericDataFrame::DataSetSelector) DataSetSelectorMap[]
@ MID_GNE_SET_ATTRIBUTE
attribute edited
Definition: GUIAppEnum.h:717
@ MID_GNE_DATASET_SELECTED
GNEDataInterval selected in comboBox of IntervalBar.
Definition: GUIAppEnum.h:741
@ MID_GNE_CREATE
create element
Definition: GUIAppEnum.h:719
@ MID_GNE_DATAINTERVAL_SELECTED
GNEDataInterval selected in comboBox of IntervalBar.
Definition: GUIAppEnum.h:743
@ MID_GNE_DATASET_NEW
create new data set
Definition: GUIAppEnum.h:739
@ MID_GNE_SELECT
select element
Definition: GUIAppEnum.h:731
#define GUIDesignButton
Definition: GUIDesigns.h:62
#define GUIDesignComboBox
Definition: GUIDesigns.h:237
#define GUIDesignComboBoxNCol
number of column of every combo box
Definition: GUIDesigns.h:255
#define GUIDesignTextField
Definition: GUIDesigns.h:36
#define GUIDesignAuxiliarHorizontalFrame
design for auxiliar (Without borders) horizontal frame used to pack another frames
Definition: GUIDesigns.h:313
#define GUIDesignLabelAttribute
label extended over the matrix column with thick frame
Definition: GUIDesigns.h:199
#define GUIDesignTextFieldNCol
Num of column of text field.
Definition: GUIDesigns.h:54
#define GUIDesignGroupBoxFrame
Group box design extended over frame.
Definition: GUIDesigns.h:278
#define GUIDesignTreeListFrame
Tree list used in frames to represent elements children.
Definition: GUIDesigns.h:564
#define GUIDesignCheckButton
checkButton placed in left position
Definition: GUIDesigns.h:133
@ DATAINTERVAL
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:276
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_END
weights: time range end
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:44
FXIcon * getIcon() const
get FXIcon associated to this AC
GNENet * getNet() const
get pointer to net
static GNEDataInterval * buildDataInterval(GNENet *net, bool allowUndoRedo, GNEDataSet *dataSetParent, const double begin, const double end)
Builds DataInterval.
static GNEDataSet * buildDataSet(GNENet *net, bool allowUndoRedo, const std::string &dataSetID)
Builds DataSet.
An Element which don't belongs to GNENet but has influency in the simulation.
double getAttributeDouble(SumoXMLAttr key) const
std::string getHierarchyName() const
get Hierarchy Name (Used in AC Hierarchy)
std::string getHierarchyName() const
get Hierarchy Name (Used in AC Hierarchy)
Definition: GNEDataSet.cpp:368
const std::map< const double, GNEDataInterval * > & getDataIntervalChildren() const
get data interval children
Definition: GNEDataSet.cpp:293
bool checkNewInterval(const double newBegin, const double newEnd)
check if a new GNEDataInterval with the given begin and end can be inserted in current GNEDataSet
Definition: GNEDataSet.cpp:262
GNEViewNet * myViewNet
View Net.
Definition: GNEFrame.h:113
FXVerticalFrame * myContentFrame
Vertical frame that holds all widgets of frame.
Definition: GNEFrame.h:116
virtual void show()
show Frame
Definition: GNEFrame.cpp:108
virtual void hide()
hide Frame
Definition: GNEFrame.cpp:117
void showPathCreatorModul(SumoXMLTag tag, const bool firstElement, const bool consecutives)
show PathCreator for the given tag
static FXLabel * buildRainbow(FXComposite *parent)
build rainbow in frame modul
AttributeSelector(GNEGenericDataFrame *genericDataFrameParent, SumoXMLTag tag)
FOX-declaration.
long onCmdSelectAttribute(FXObject *, FXSelector, void *)
Called when the user select a attribute in the combo boz.
const RGBColor & getScaledColor(const double min, const double max, const double value) const
get color for the given value
FXLabel * myMinMaxLabel
label for min/max attribute
void refreshAttributeSelector()
refresh interval selector
std::string getFilteredAttribute() const
get filtered attribute
FXComboBox * myAttributesComboBox
combo box for attributes
GNEDataSet * getDataSet() const
get current select data set ID
long onCmdSelectDataSet(FXObject *obj, FXSelector, void *)
Called when the user select an existent data set.
long onCmdCreateDataSet(FXObject *, FXSelector, void *)
void refreshDataSetSelector(const GNEDataSet *currentDataSet)
refresh interval selector
long onCmdSetNewDataSetID(FXObject *, FXSelector, void *)
Called when the user set a new data set ID.
long onCmdSelectCheckButton(FXObject *obj, FXSelector, void *)
Called when the user select check button.
FXTreeList * myIntervalsTreelist
tree list to show the interval list
FXTreeItem * addIntervalItem(GNEDataInterval *dataInterval, FXTreeItem *itemParent=nullptr)
add interval item into list
FXHorizontalFrame * myHorizontalFrameEnd
interval end horizontal frame
GNEDataInterval * getDataInterval() const
get current select data set ID
long onCmdCreateInterval(FXObject *, FXSelector, void *)
FXCheckButton * myNewIntervalCheckButton
check button to create a new interval
FXButton * myCreateIntervalButton
create interval button
IntervalSelector(GNEGenericDataFrame *genericDataFrameParent)
FOX-declaration.
FXTextField * myEndTextField
interval end
FXHorizontalFrame * myHorizontalFrameBegin
interval begin horizontal frame
long onCmdSetIntervalAttribute(FXObject *, FXSelector, void *)
Called when the user changes begin or end.
long onCmdSelectInterval(FXObject *, FXSelector, void *)
Called when the user select an interval in the list.
void refreshIntervalSelector()
refresh interval selector
long onCmdSelectCheckButton(FXObject *obj, FXSelector, void *)
Called when the user select check button.
FXTextField * myBeginTextField
interval begin text field
void intervalSelected()
interval selected
IntervalSelector * myIntervalSelector
interval selector modul
DataSetSelector * myDataSetSelector
dataSet selector modul
const AttributeSelector * getAttributeSelector() const
getattribute selector modul
virtual void createPath()
create path
GNEFrameModuls::PathCreator * myPathCreator
edge path creator (used for Walks, rides and trips)
GNEFrameModuls::PathCreator * getPathCreator() const
get PathCreator modul
AttributeSelector * myAttributeSelector
attribute selector modul
const DataSetSelector * getDataSetSelector() const
get dataSet selector modul
SumoXMLTag getTag() const
@bried get element type of this data frame
GNEFrameAttributesModuls::ParametersEditorCreator * myParametersEditorCreator
parameters editor creator
SumoXMLTag myGenericDataTag
generic data tag
const IntervalSelector * getIntervalSelector() const
get interval selector modul
GNEGenericDataFrame(FXHorizontalFrame *horizontalFrameParent, GNEViewNet *viewNet, SumoXMLTag tag, const bool pathCreator)
Constructor (protected due GNEGenericDataFrame is abtract)
const std::map< std::string, GNEEdge * > & getEdges() const
map with the ID and pointer to edges of net
GNEDataSet * retrieveDataSet(const std::string &id, bool hardFail=true) const
Returns the named data set.
Definition: GNENet.cpp:2590
GNENetHelper::AttributeCarriers * getAttributeCarriers() const
retrieve all attribute carriers of Net
Definition: GNENet.cpp:130
GNENet * getNet() const
get the net object
static FXIcon * getIcon(const GUIIcon which)
returns a icon previously defined in the enum GUIIcon
static const RGBColor & getRainbowScaledColor(const double min, const double max, const double value)
get rainbow scaled color