GUITLLogicPhasesTrackerWindow Class Reference

#include <GUITLLogicPhasesTrackerWindow.h>

Inheritance diagram for GUITLLogicPhasesTrackerWindow:

FXMainWindow ValueRetriever< T >

Detailed Description

This window displays a phase diagram for a chosen tl-logic.

Definition at line 68 of file GUITLLogicPhasesTrackerWindow.h.


FOX-callbacks

{

typedef std::vector< size_t > DurationsVector
 Definition of a storage for durations.
typedef std::vector
< MSPhaseDefinition > 		PhasesVector
 }
bool myAmInTrackingMode
 Information whether the tracking mode is on.
GUIMainWindow * myApplication
 The main application.
FXRealSpinDial * myBeginOffset
 The offset changer (tracking mode).
SUMOTime myBeginTime
 The first time a phase was added at.
GLObjectValuePassConnector
< std::pair< SUMOTime,
MSPhaseDefinition > > * 		myConnector
 The connector for retrieval of further phases.
DurationsVector myDurations
 The list of phase durations.
size_t myFirstPhase2Show
 The index of the first phase that fits into the window.
size_t myFirstPhaseOffset
 The offset to draw the first phase (left offset).
SUMOTime myFirstTime2Show
 The time the diagram begins at.
SUMOTime myLastTime
 The last time a phase was added at.
std::vector< std::string > myLinkNames
 The names of links.
MFXMutex myLock
 A lock to avoid addition of new values while drawing.
GUITLLogicPhasesTrackerPanel * myPanel
 The panel to draw on.
PhasesVector myPhases
 The list of phases.
MSTrafficLightLogic * myTLLogic
 The logic to display.
FXToolBar * myToolBar
 The tool bar (tracking mode).
FXToolBarShell * myToolBarDrag
 The tool bar drag (tracking mode).
void drawValues (GUITLLogicPhasesTrackerPanel &caller) throw ()
 Draws all values.
long onConfigure (FXObject *sender, FXSelector sel, void *data)
 called on size change
long onPaint (FXObject *sender, FXSelector sel, void *data)
 called if the widget shall be repainted
long onSimStep (FXObject *sender, FXSelector sel, void *data)
 called on a simulation step
 GUITLLogicPhasesTrackerWindow ()
 protected constructor for FOX

Public Member Functions

virtual void addValue (T value)=0
void addValue (std::pair< SUMOTime, MSPhaseDefinition > def) throw ()
 Adds a further phase definition.
void create ()
 Creates the window (FOX-Toolkit).
 GUITLLogicPhasesTrackerWindow (GUIMainWindow &app, MSTrafficLightLogic &logic, GUITrafficLightLogicWrapper &wrapper, const MSSimpleTrafficLightLogic::Phases &phases) throw ()
 Constructor to show the complete phase diagram.
 GUITLLogicPhasesTrackerWindow (GUIMainWindow &app, MSTrafficLightLogic &logic, GUITrafficLightLogicWrapper &wrapper, ValueSource< std::pair< SUMOTime, MSPhaseDefinition > > *src) throw ()
 Constructor to track current phases.
void setBeginTime (SUMOTime time) throw ()
 Sets the time the display shall be shown as beginning at.
 ~GUITLLogicPhasesTrackerWindow () throw ()
 Destructor.

Data Structures

class  GUITLLogicPhasesTrackerPanel
 The canvas for the visualisation of phases. More...

Member Typedef Documentation

typedef std::vector<size_t> GUITLLogicPhasesTrackerWindow::DurationsVector

Definition of a storage for durations.

Definition at line 135 of file GUITLLogicPhasesTrackerWindow.h.

typedef std::vector<MSPhaseDefinition> GUITLLogicPhasesTrackerWindow::PhasesVector

}

Definition of a storage for phases

Definition at line 132 of file GUITLLogicPhasesTrackerWindow.h.

Constructor & Destructor Documentation

GUITLLogicPhasesTrackerWindow::GUITLLogicPhasesTrackerWindow ( GUIMainWindow &  app,
MSTrafficLightLogic &  logic,
GUITrafficLightLogicWrapper &  wrapper,
ValueSource< std::pair< SUMOTime, MSPhaseDefinition > > *  src 
) throw ()

Constructor to track current phases.

Parameters:
[in] app The main application window
[in] logic The logic to track
[in] wrapper The tracked logic's wrapper
[in] src The value source to track

GUITLLogicPhasesTrackerWindow::GUITLLogicPhasesTrackerWindow ( GUIMainWindow &  app,
MSTrafficLightLogic &  logic,
GUITrafficLightLogicWrapper &  wrapper,
const MSSimpleTrafficLightLogic::Phases &  phases 
) throw ()

Constructor to show the complete phase diagram.

Parameters:
[in] app The main application window
[in] logic The logic to show
[in] wrapper The shown logic's wrapper
[in] phases The phases to show

Definition at line 194 of file GUITLLogicPhasesTrackerWindow.cpp.

References GUIIconSubSys::getIcon(), MSTrafficLightLogic::getLinks(), ICON_APP_TLSTRACKER, myApplication, myConnector, myLinkNames, myPanel, and myTLLogic.

00198         : FXMainWindow(app.getApp(), "TLS-Tracker",NULL,NULL,DECOR_ALL,
00199                        20,20,300,200),
00200         myApplication(&app), myTLLogic(&logic), myAmInTrackingMode(false),
00201         myToolBarDrag(0), myBeginOffset(0) {
00202     myConnector = 0;
00203     FXint height = (FXint)(myTLLogic->getLinks().size() * 20 + 30 + 8);
00204     setTitle("TLS-Tracker");
00205     app.addChild(this, true);
00206     for (size_t i=0; i<myTLLogic->getLinks().size(); i++) {
00207         myLinkNames.push_back(toString<size_t>(i));
00208     }
00209     FXVerticalFrame *glcanvasFrame =
00210         new FXVerticalFrame(this,
00211                             FRAME_SUNKEN|LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y,
00212                             0,0,0,0,0,0,0,0);
00213     myPanel = new
00214     GUITLLogicPhasesTrackerPanel(glcanvasFrame, *myApplication, *this);
00215     setTitle((logic.getID() + " - " + logic.getSubID() + " - tracker").c_str());
00216     setIcon(GUIIconSubSys::getIcon(ICON_APP_TLSTRACKER));
00217     setHeight(height);
00218 }

GUITLLogicPhasesTrackerWindow::~GUITLLogicPhasesTrackerWindow (  )  throw ()

Destructor.

Definition at line 221 of file GUITLLogicPhasesTrackerWindow.cpp.

References MFXMutex::locked(), myApplication, myConnector, myLock, myToolBarDrag, GUIMainWindow::removeChild(), and MFXMutex::unlock().

00221                                                                       {
00222     myApplication->removeChild(this);
00223     delete myConnector;
00224     // just to quit cleanly on a failure
00225     if (myLock.locked()) {
00226         myLock.unlock();
00227     }
00228     delete myToolBarDrag;
00229 }

GUITLLogicPhasesTrackerWindow::GUITLLogicPhasesTrackerWindow (  )  [inline, protected]

protected constructor for FOX

Definition at line 250 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by GUITrafficLightLogicWrapper::begin2TrackPhases(), and GUITrafficLightLogicWrapper::showPhases().

00250 { }

Member Function Documentation

template<typename T>
virtual void ValueRetriever< T >::addValue ( T  value  )  [pure virtual, inherited]

Implemented in TrackerValueDesc.

void GUITLLogicPhasesTrackerWindow::addValue ( std::pair< SUMOTime, MSPhaseDefinition >  def  )  throw ()

Adds a further phase definition.

Parameters:
[in] def The definition to add

Definition at line 464 of file GUITLLogicPhasesTrackerWindow.cpp.

References MFXMutex::lock(), myBeginTime, myDurations, myLastTime, myLock, myPhases, and MFXMutex::unlock().

00464                                                                                         {
00465     // do not draw while adding
00466     myLock.lock();
00467     // set the first time if not set before
00468     if (myPhases.size()==0) {
00469         myBeginTime = def.first;
00470     }
00471     // append or set the phase
00472     if (myPhases.size()==0||*(myPhases.end()-1)!=def.second) {
00473         myPhases.push_back(def.second);
00474         myDurations.push_back(1);
00475     } else {
00476         *(myDurations.end()-1) += 1;
00477     }
00478     // set the last time a phase was added at
00479     myLastTime = def.first;
00480     // allow drawing
00481     myLock.unlock();
00482 }

void GUITLLogicPhasesTrackerWindow::create (  ) 

Creates the window (FOX-Toolkit).

Definition at line 233 of file GUITLLogicPhasesTrackerWindow.cpp.

References myToolBarDrag.

Referenced by GUITrafficLightLogicWrapper::begin2TrackPhases(), and GUITrafficLightLogicWrapper::showPhases().

00233                                       {
00234     FXMainWindow::create();
00235     if (myToolBarDrag!=0) {
00236         myToolBarDrag->create();
00237     }
00238 }

void GUITLLogicPhasesTrackerWindow::drawValues ( GUITLLogicPhasesTrackerPanel &  caller  )  throw ()

Draws all values.

Parameters:
[in] The target panel

Definition at line 242 of file GUITLLogicPhasesTrackerWindow.cpp.

References MSTrafficLightLogic::getLinks(), MSLink::LINKSTATE_TL_GREEN_MAJOR, MSLink::LINKSTATE_TL_GREEN_MINOR, MSLink::LINKSTATE_TL_RED, MSLink::LINKSTATE_TL_YELLOW_MAJOR, MSLink::LINKSTATE_TL_YELLOW_MINOR, MFXMutex::lock(), myAmInTrackingMode, myBeginOffset, myBeginTime, myDurations, myFirstPhase2Show, myFirstPhaseOffset, myFirstTime2Show, myLastTime, myLinkNames, myLock, myPhases, myTLLogic, pfdkGetStringWidth(), pfDrawString(), pfSetPosition(), pfSetScaleXY(), size, SUMOReal, and MFXMutex::unlock().

Referenced by GUITLLogicPhasesTrackerWindow::GUITLLogicPhasesTrackerPanel::onPaint().

00242                                                                                       {
00243     // compute what shall be shown (what is visible)
00244     myFirstPhase2Show = 0;
00245     myFirstPhaseOffset = 0;
00246     size_t leftOffset = 0;
00247     myFirstTime2Show = 0;
00248     if (!myAmInTrackingMode) {
00249         myPhases.clear();
00250         myDurations.clear();
00251         // insert phases
00252         const MSSimpleTrafficLightLogic::Phases &phases = static_cast<MSSimpleTrafficLightLogic*>(myTLLogic)->getPhases();
00253         MSSimpleTrafficLightLogic::Phases::const_iterator j;
00254         myLastTime = 0;
00255         myBeginTime = 0;
00256         for (j=phases.begin(); j!=phases.end(); ++j) {
00257             myPhases.push_back(*(*j));
00258             myDurations.push_back((*j)->duration);
00259             myLastTime += (*j)->duration;
00260         }
00261     } else {
00262         myBeginTime = myLastTime - (SUMOTime) myBeginOffset->getValue();
00263         myFirstTime2Show = myBeginTime;
00264         // check whether no phases are known at all
00265         if (myDurations.size()!=0) {
00266             size_t durs = 0;
00267             size_t phaseOffset = myDurations.size() - 1;
00268             DurationsVector::reverse_iterator i=myDurations.rbegin();
00269             while (/*noSecs>=0&&*/i!=myDurations.rend()) {
00270                 if (durs+(*i)>(size_t) myBeginOffset->getValue()) {
00271                     myFirstPhase2Show = phaseOffset;
00272                     myFirstPhaseOffset = (durs+(*i)) - (size_t) myBeginOffset->getValue();
00273                     break;
00274                 }
00275                 durs += (*i);
00276                 phaseOffset--;
00277                 ++i;
00278             }
00279             if (i==myDurations.rend()) {
00280                 // there are too few information stored;
00281                 myFirstPhase2Show = 0;
00282                 myFirstPhaseOffset = 0;
00283                 leftOffset = (size_t) myBeginOffset->getValue() - durs;
00284             }
00285         }
00286     }
00287     // begin drawing
00288     glMatrixMode(GL_PROJECTION);
00289     glLoadIdentity();
00290     glMatrixMode(GL_MODELVIEW);
00291     glLoadIdentity();
00292     glTranslated(-1, -1, 0);
00293     glScaled(2, 2, 1);
00294     glDisable(GL_TEXTURE_2D);
00295     // draw the horizontal lines dividing the signal groups
00296     glColor3d(1, 1, 1);
00297     // compute some values needed more than once
00298     SUMOReal height = (SUMOReal) caller.getHeight();
00299     SUMOReal width = (SUMOReal) caller.getWidth();
00300     pfSetScaleXY((SUMOReal)(.08*300./width), (SUMOReal)(.08*300./height));
00301     SUMOReal h4 = ((SUMOReal) 4 / height);
00302     SUMOReal h10 = ((SUMOReal) 10 / height);
00303     SUMOReal h16 = ((SUMOReal) 16 / height);
00304     SUMOReal h20 = ((SUMOReal) 20 / height);
00305     // draw the link names and the lines dividing them
00306     SUMOReal h = (SUMOReal)(1.0 - h10);
00307     SUMOReal h2 = 12;
00308     size_t i;
00309 
00310     for (i=0; i<myTLLogic->getLinks().size()+1; i++) {
00311         // draw the bar
00312         glBegin(GL_LINES);
00313         glVertex2d(0, h);
00314         glVertex2d((SUMOReal)(30. / width), h);
00315         glEnd();
00316         // draw the name
00317         if (i<myTLLogic->getLinks().size()) {
00318             glRotated(180, 1, 0, 0);
00319             pfSetPosition(0, 0);
00320             glTranslated(0.0, -h+h20-h4, 0);
00321             pfDrawString(myLinkNames[i].c_str());
00322             glTranslated(-0.0, h-h20+h4, 0);
00323             glRotated(-180, 1, 0, 0);
00324             h2 += 20;
00325         }
00326         h -= h20;
00327     }
00328     glBegin(GL_LINES);
00329     glVertex2d(0, h+h20);
00330     glVertex2d(1.0, h+h20);
00331     glEnd();
00332 
00333     // draw the names closure (vertical line)
00334     h += (SUMOReal) 20 / height;
00335     glColor3d(1, 1, 1);
00336     glBegin(GL_LINES);
00337     glVertex2d((SUMOReal) 30 / width, 1.0);
00338     glVertex2d((SUMOReal) 30 / width, h);
00339     glEnd();
00340 
00341 
00342     // draw the phases
00343     // disable value addition while drawing
00344     myLock.lock();
00345     // determine the initial offset
00346     SUMOReal x = ((SUMOReal) 31. / width) ;
00347     SUMOReal ta = (SUMOReal) leftOffset / width;
00348     ta *= (SUMOReal)(((width-31.0) / ((SUMOReal)(myLastTime - myBeginTime))));
00349     x += ta;
00350 
00351     // and the initial phase information
00352     PhasesVector::iterator pi = myPhases.begin() + myFirstPhase2Show;
00353     DurationsVector::iterator pd = myDurations.begin() + myFirstPhase2Show;
00354     size_t fpo = myFirstPhaseOffset;
00355 
00356     // start drawing
00357     for (i=30; i<width&&pd!=myDurations.end();) {
00358         // the first phase may be drawn incompletely
00359         size_t duration = *pd - fpo;
00360         // compute the heigh and the width of the phase
00361         h = (SUMOReal)(1.0 - h10);
00362         SUMOReal a = (SUMOReal) duration / width;
00363         a *= (SUMOReal)(((width-31.0) / ((SUMOReal)(myLastTime - myBeginTime))));
00364         SUMOReal x2 = x + a;
00365 
00366         // go through the links
00367         for (unsigned int j=0; j<(unsigned int) myTLLogic->getLinks().size(); j++) {
00368             // determine the current link's color
00369             MSLink::LinkState state = (*pi).getSignalState(j);
00370             // draw the bar (red is drawn as a line)
00371             switch (state) {
00372             case MSLink::LINKSTATE_TL_GREEN_MAJOR:
00373             case MSLink::LINKSTATE_TL_GREEN_MINOR:
00374                 glColor3d(0, 1.0, 0);
00375                 glBegin(GL_QUADS);
00376                 glVertex2d(x, h - h16);
00377                 glVertex2d(x, h - h4);
00378                 glVertex2d(x2, h - h4);
00379                 glVertex2d(x2, h - h16);
00380                 glEnd();
00381                 break;
00382             case MSLink::LINKSTATE_TL_YELLOW_MAJOR:
00383             case MSLink::LINKSTATE_TL_YELLOW_MINOR:
00384                 glColor3d(1.0, 1.0, 0);
00385                 glBegin(GL_QUADS);
00386                 glVertex2d(x, h - h16);
00387                 glVertex2d(x, h - h4);
00388                 glVertex2d(x2, h - h4);
00389                 glVertex2d(x2, h - h16);
00390                 glEnd();
00391                 break;
00392             case MSLink::LINKSTATE_TL_RED:
00393                 glColor3d(1.0, 0, 0);
00394                 glBegin(GL_LINES);
00395                 glVertex2d(x, h - h10);
00396                 glVertex2d(x2, h - h10);
00397                 glEnd();
00398                 break;
00399             default:
00400                 break;
00401             }
00402             // proceed to next link
00403             h -= h20;
00404         }
00405         // proceed to next phase
00406         i += duration;
00407         pi++;
00408         pd++;
00409         x = x2;
00410         // all further phases are drawn in full
00411         fpo = 0;
00412     }
00413     // allow value addition
00414     myLock.unlock();
00415 
00416     glColor3d(1, 1, 1);
00417     if (myPhases.size()!=0) {
00418         int tickDist = 10;
00419         // patch distances - hack
00420         SUMOReal t = myBeginOffset!=0 ? (SUMOReal) myBeginOffset->getValue() : (SUMOReal)(myLastTime - myBeginTime);
00421         while (t>(width-31.)/4.) {
00422             tickDist += 10;
00423             t -= (SUMOReal)((width-31.)/4.);
00424         }
00425         // draw time information
00426         h = (SUMOReal)(myTLLogic->getLinks().size() * 20 + 12);
00427         SUMOReal glh = (SUMOReal)(1.0 - myTLLogic->getLinks().size() * h20 - h10);
00428         // current begin time
00429         //string timeStr = toString<SUMOTime>(myFirstTime2Show);
00430         //SUMOReal w = pfdkGetStringWidth(timeStr.c_str());
00431         pfSetScaleXY((SUMOReal)(.05*300./width), (SUMOReal)(.05*300./height));
00432         // time ticks
00433         SUMOTime currTime = myFirstTime2Show;
00434         int pos = 31;// + /*!!!currTime*/ - myFirstTime2Show;
00435         SUMOReal glpos = (SUMOReal) pos / (SUMOReal) width;
00436         while (pos<width+50) {
00437             std::string timeStr = toString<SUMOTime>(currTime);
00438             SUMOReal w = pfdkGetStringWidth(timeStr.c_str());
00439             glRotated(180, 1, 0, 0);
00440             pfSetPosition(0, 0);
00441             glTranslated(glpos-w/2., -glh+h20-h4, 0);
00442             pfDrawString(timeStr.c_str());
00443             glTranslated(-glpos+w/2., glh-h20+h4, 0);
00444             glRotated(-180, 1, 0, 0);
00445 
00446             glBegin(GL_LINES);
00447             glVertex2d(glpos, glh);
00448             glVertex2d(glpos, glh-h4);
00449             glEnd();
00450 
00451             SUMOReal a = (SUMOReal) tickDist / width;
00452             a *= (SUMOReal)(((width-31.0) / ((SUMOReal)(myLastTime - myBeginTime))));
00453             glpos += a;
00454             SUMOReal a2 = (SUMOReal) tickDist;
00455             a2 *= (SUMOReal)(((width-31.0) / ((SUMOReal)(myLastTime - myBeginTime))));
00456             pos += (int) a2;
00457             currTime += tickDist;
00458         }
00459     }
00460 }

long GUITLLogicPhasesTrackerWindow::onConfigure ( FXObject *  sender,
FXSelector  sel,
void *  data 
)

called on size change

Definition at line 487 of file GUITLLogicPhasesTrackerWindow.cpp.

References myPanel, and GUITLLogicPhasesTrackerWindow::GUITLLogicPhasesTrackerPanel::onConfigure().

00488                                     {
00489     myPanel->onConfigure(sender, sel, data);
00490     return FXMainWindow::onConfigure(sender, sel, data);
00491 }

long GUITLLogicPhasesTrackerWindow::onPaint ( FXObject *  sender,
FXSelector  sel,
void *  data 
)

called if the widget shall be repainted

Definition at line 495 of file GUITLLogicPhasesTrackerWindow.cpp.

References myPanel, and GUITLLogicPhasesTrackerWindow::GUITLLogicPhasesTrackerPanel::onPaint().

00496                                                                    {
00497     myPanel->onPaint(sender, sel, data);
00498     return FXMainWindow::onPaint(sender, sel, data);
00499 }

long GUITLLogicPhasesTrackerWindow::onSimStep ( FXObject *  sender,
FXSelector  sel,
void *  data 
)

called on a simulation step

Definition at line 503 of file GUITLLogicPhasesTrackerWindow.cpp.

00504                           {
00505     update();
00506     return 1;
00507 }

void GUITLLogicPhasesTrackerWindow::setBeginTime ( SUMOTime  time  )  throw ()

Sets the time the display shall be shown as beginning at.

Parameters:
[in] time The time to start to show the phases from

Definition at line 512 of file GUITLLogicPhasesTrackerWindow.cpp.

References myBeginTime.

Referenced by GUITrafficLightLogicWrapper::showPhases().

00512                                                                  {
00513     myBeginTime = time;
00514 }

Field Documentation

bool GUITLLogicPhasesTrackerWindow::myAmInTrackingMode [private]

Information whether the tracking mode is on.

Definition at line 236 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by drawValues().

GUIMainWindow* GUITLLogicPhasesTrackerWindow::myApplication [private]

The main application.

Definition at line 195 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by GUITLLogicPhasesTrackerWindow(), and ~GUITLLogicPhasesTrackerWindow().

FXRealSpinDial* GUITLLogicPhasesTrackerWindow::myBeginOffset [private]

The offset changer (tracking mode).

Definition at line 245 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by drawValues(), and FXIMPLEMENT().

SUMOTime GUITLLogicPhasesTrackerWindow::myBeginTime [private]

The first time a phase was added at.

Definition at line 227 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by addValue(), drawValues(), and setBeginTime().

GLObjectValuePassConnector<std::pair<SUMOTime, MSPhaseDefinition> >* GUITLLogicPhasesTrackerWindow::myConnector [private]

The connector for retrieval of further phases.

Definition at line 233 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by FXIMPLEMENT(), GUITLLogicPhasesTrackerWindow(), and ~GUITLLogicPhasesTrackerWindow().

DurationsVector GUITLLogicPhasesTrackerWindow::myDurations [private]

The list of phase durations.

Definition at line 204 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by addValue(), and drawValues().

size_t GUITLLogicPhasesTrackerWindow::myFirstPhase2Show [private]

The index of the first phase that fits into the window.

Definition at line 218 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by drawValues().

size_t GUITLLogicPhasesTrackerWindow::myFirstPhaseOffset [private]

The offset to draw the first phase (left offset).

Definition at line 221 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by drawValues().

SUMOTime GUITLLogicPhasesTrackerWindow::myFirstTime2Show [private]

The time the diagram begins at.

Definition at line 224 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by drawValues().

SUMOTime GUITLLogicPhasesTrackerWindow::myLastTime [private]

The last time a phase was added at.

Definition at line 230 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by addValue(), and drawValues().

std::vector<std::string> GUITLLogicPhasesTrackerWindow::myLinkNames [private]

The names of links.

This holds an enumeration only - used to avoid time consuming string representation of ints

Definition at line 215 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by drawValues(), FXIMPLEMENT(), and GUITLLogicPhasesTrackerWindow().

MFXMutex GUITLLogicPhasesTrackerWindow::myLock [private]

A lock to avoid addition of new values while drawing.

Definition at line 210 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by addValue(), drawValues(), and ~GUITLLogicPhasesTrackerWindow().

GUITLLogicPhasesTrackerPanel* GUITLLogicPhasesTrackerWindow::myPanel [private]

The panel to draw on.

Definition at line 207 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by FXIMPLEMENT(), GUITLLogicPhasesTrackerWindow(), onConfigure(), and onPaint().

PhasesVector GUITLLogicPhasesTrackerWindow::myPhases [private]

The list of phases.

Definition at line 201 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by addValue(), and drawValues().

MSTrafficLightLogic* GUITLLogicPhasesTrackerWindow::myTLLogic [private]

The logic to display.

Definition at line 198 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by drawValues(), FXIMPLEMENT(), and GUITLLogicPhasesTrackerWindow().

FXToolBar* GUITLLogicPhasesTrackerWindow::myToolBar [private]

The tool bar (tracking mode).

Definition at line 242 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by FXIMPLEMENT().

FXToolBarShell* GUITLLogicPhasesTrackerWindow::myToolBarDrag [private]

The tool bar drag (tracking mode).

Definition at line 239 of file GUITLLogicPhasesTrackerWindow.h.

Referenced by create(), FXIMPLEMENT(), and ~GUITLLogicPhasesTrackerWindow().

The documentation for this class was generated from the following files:
Generated on Wed May 5 00:06:45 2010 for Sumo - Simulation of Urban MObility by  doxygen 1.5.6