From 0cbe635c1e490673076a28920f3349efd544fcb7 Mon Sep 17 00:00:00 2001 From: paolo Date: Fri, 15 Sep 2006 22:14:23 +0000 Subject: [PATCH] - documentation and warning removal: holt_widget.??, simulation_widget.hh holt_container_window.cc git-svn-id: svn://svn.gna.org/svn/sgpemv2/trunk@1180 3ecf2c5c-341e-0410-92b4-d18e462d057c --- src/holt_container_window.cc | 4 +- src/holt_widget.cc | 182 ++++++++++----- src/holt_widget.hh | 434 ++++++++++++++++++++++++++++++++--- src/simulation_widget.hh | 4 +- 4 files changed, 533 insertions(+), 91 deletions(-) diff --git a/src/holt_container_window.cc b/src/holt_container_window.cc index 0d01878..9aaeda6 100644 --- a/src/holt_container_window.cc +++ b/src/holt_container_window.cc @@ -77,7 +77,9 @@ HoltContainerWindow::on_button_press_event(GdkEventButton* event) " "; HoltWidget::arrange_mode arrange = _holt_widget.get_arrange_mode(); - CairoWidget::scaling_mode scaling = _holt_widget.get_scaling_mode(); + + // actually unused + //CairoWidget::scaling_mode scaling = _holt_widget.get_scaling_mode(); RefPtr action_group = Gtk::ActionGroup::create(); diff --git a/src/holt_widget.cc b/src/holt_widget.cc index 8993174..a5a20cc 100644 --- a/src/holt_widget.cc +++ b/src/holt_widget.cc @@ -58,7 +58,6 @@ using namespace std; HoltNode::HoltNode(Vec2 pt) : _radius(20) { - //_x = pt.real(); _y = pt.imag(); _pos = pt; } @@ -92,9 +91,6 @@ double HoltNode::get_radius() return _radius; } -// double HoltNode::_radius = 20; - - HoltResource::HoltResource(const Resource& resource, resource_key_t resource_key, Vec2 pt) : HoltNode(pt) @@ -195,7 +191,7 @@ void HoltSchedulable::draw(cairo_t *cr) cairo_save(cr); // save context state const Point center(_pos.real(), _pos.imag()); - const Color* color; + const Color* color = &red; // draw circle CairoElements cel(cr); @@ -240,9 +236,15 @@ void HoltSchedulable::draw(cairo_t *cr) Vec2 HoltSchedulable::get_intersection_to(Vec2 pt) { + // schedulables ar circles + // intersection is a radius from center then... Vec2 final = _pos; + + // take segment Vec2 segment = pt - _pos; double len = std::abs(segment); + + // and normalize to radius if(len>0) { segment *= _radius/len; @@ -270,7 +272,7 @@ void HoltRequest::draw(cairo_t *cr) Vec2 schedulable = _hr->get_intersection_to(_hp->get_position()); cairo_save(cr); - // cairo_set_line_width(cr, 0.5*cairo_get_line_width(cr)); + switch(_state) { case Request::state_unallocable: @@ -278,15 +280,19 @@ void HoltRequest::draw(cairo_t *cr) cairo_set_source_rgb(cr, 1, 0, 0); arrow(cr, schedulable, resource); break; + case Request::state_allocated: // green cairo_set_source_rgb(cr, 0, 1, 0); arrow(cr, resource, schedulable); break; + case Request::state_future: break; + case Request::state_exhausted: break; + case Request::state_allocable: // yellow cairo_set_source_rgb(cr, 1, 0.7, 0); @@ -294,22 +300,51 @@ void HoltRequest::draw(cairo_t *cr) break; } - // stroke all + // stroke all and restore status cairo_stroke (cr); cairo_restore(cr); } void HoltRequest::arrow(cairo_t *cr, Vec2 first, Vec2 second) { + // option to draw the line a little translated + // this allow to draw two counterflow arrows + // without overlap + bool traslate = true; + double line_width = cairo_get_line_width(cr); + if(traslate) + { + // if needed calc parallel versor of arrow + Vec2 direction = second-first; + direction /= std::abs(direction); // set unary modulus + + // and rotate it 90 degrees + Vec2 dir_rotation(0.0, 1.0); + direction *= dir_rotation; + + // translation modulus equals line width + direction *= line_width; + first += direction; + second += direction; + } + + // draw main line cairo_move_to(cr, second.real(), second.imag()); cairo_line_to(cr, first.real(), first.imag()); + + // some calculation to draw arrowpoint... + // take a short line parallel to main line Vec2 arrowside = second-first; - arrowside *= 10.0/std::abs(arrowside); - Vec2 deviation(5.0, 1.0); deviation /= std::abs(deviation);// = std::polar(1,M_PI/6.0); + arrowside *= 15.0*line_width/std::abs(arrowside); + // make a rotation component + Vec2 deviation(5.0, 1.0); deviation /= std::abs(deviation); + // make left and right sides rotating that first short line Vec2 side1 = arrowside * deviation; Vec2 side2 = arrowside * conj(deviation); + // draw one side cairo_move_to(cr, first.real(), first.imag()); cairo_line_to(cr, first.real()+side1.real(), first.imag()+side1.imag()); + // draw the other side cairo_move_to(cr, first.real(), first.imag()); cairo_line_to(cr, first.real()+side2.real(), first.imag()+side2.imag()); } @@ -323,15 +358,15 @@ void HoltRequest::arrow(cairo_t *cr, Vec2 first, Vec2 second) HoltWidget::HoltWidget(Simulation& simulation) : Glib::ObjectBase("sgpem_HoltWidget"), - CairoWidget(), SimulationObserver(), HistoryObserver(), + CairoWidget(), _simulation(&simulation), + _radius(20), _n_proc(0), _n_res(0), - _radius(20), - _show_threads(false), - _arrange_mode(arrange_horizontal) + _arrange_mode(arrange_horizontal), + _show_threads(false) { // Register this SimulationObserver: @@ -374,7 +409,6 @@ HoltWidget::set_radius(double radius) double old_radius = _radius; if(radius>0) _radius = radius; - // resize_redraw(); return old_radius; } @@ -390,27 +424,53 @@ HoltWidget::set_arrange_mode(arrange_mode mode) arrange_mode old_mode = _arrange_mode; _arrange_mode = mode; arrange(); - // resize_redraw(); return old_mode; } void HoltWidget::arrange() { +#ifndef NDEBUG std::cout << "HoltWidget::arrange" << endl; - // cout << "START:" << endl; - // _x_req = 0; - // _y_req = 0; +#endif - Vec2 pos, inc, mul, cen; + // Differents graph's dispositions are made easy by + // usual complex number algebra: + // + // v1 += v2 - translation + // v1 *= d - scaling + // v1 *= v2 - rotating if abs(v2)==1.0 + // v1 *= v2 - rotating and scaling by modulus if abs(v2)!=1.0 + // + // where v1, v2 are Vec2 (complex), d is double + // + + // to draw a linear disposition the algorithm starts with + // first desired position and sums an inc vetor each step + // + // to draw a circular disposition the center and radius are taken + // then every position is calculated summing to center a radius (inc) + // vector. The inc vector is rotated each step + // + + Vec2 pos; // position of current HoltNode derived object (all) + Vec2 inc; // increment (vertical and horizontal) or radius (circular) + Vec2 cen; // center of rotation (circular only) + Vec2 mul; // rotation multiplier (circular only) + + // vectors building if(_arrange_mode==arrange_horizontal) { + // first position pos = Vec2(2*_radius, 2*_radius); + // increment inc = Vec2(3*_radius, 0); } else if(_arrange_mode==arrange_vertical) { + // first position pos = Vec2(2*_radius, 2*_radius); + // increment inc = Vec2(0, 3*_radius); } else // _arrange_mode==arrange_circular @@ -418,33 +478,39 @@ HoltWidget::arrange() int sx = _draw_w; // get_width(); int sy = _draw_h; // get_height(); int nelem = _holt_resources.size()+_holt_schedulables.size(); - if(sx<=sy) - inc = Vec2(sx/2-2*_radius, 0); + if(nelem>1) + { + // take minimum between x and y + if(sx<=sy) + inc = Vec2(-(sx/2-2*_radius), 0); + else + inc = Vec2(-(sy/2-2*_radius), 0); + } else - inc = Vec2(sy/2-2*_radius, 0); + { + // zero or one object always at center + inc = Vec2(0, 0); + } + + // calc rotation angle if(nelem>0) mul = Vec2(cos(2*M_PI/(double)nelem), sin(2*M_PI/(double)nelem)); else mul = Vec2(0,0); - // cen = Vec2(sx/2, sy/2); + cen = Vec2(2*_radius+inc.real(), 2*_radius+inc.real()); pos = inc + cen; - // cout << "A) pos=" << pos << " cen=" << cen << " inc=" << inc << " mul=" << mul << endl; } + // positions all resources HoltResources::const_iterator riter = _holt_resources.begin(); while(riter!=_holt_resources.end()) { HoltResource* hr = (*riter).second; - // cout << "r-A) pos=" << pos << " cen=" << cen << " inc=" << inc << " mul=" << mul << endl; hr->set_position(pos); hr->set_radius(_radius); - /* - if(pos.real()+_radius>_x_req) - _x_req = pos.real()+_radius; - if(pos.imag()+_radius>_y_req) - _y_req = pos.imag()+_radius; - */ + + // calc next position if(_arrange_mode!=arrange_circular) { pos += inc; @@ -455,9 +521,11 @@ HoltWidget::arrange() pos = cen + inc; } riter++; - // cout << "r-B) pos=" << pos << " cen=" << cen << " inc=" << inc << " mul=" << mul << endl; } + // positions all schedulables + // if linear disposition then must reevaluate start and increment + // when circular continue with previous values to end circle if(_arrange_mode==arrange_horizontal) { pos = Vec2(2*_radius, 8*_radius); @@ -473,15 +541,9 @@ HoltWidget::arrange() while(piter!=_holt_schedulables.end()) { HoltSchedulable* hp = (*piter); - // cout << "p-A) pos=" << pos << " cen=" << cen << " inc=" << inc << " mul=" << mul << endl; hp->set_position(pos); hp->set_radius(_radius); - /* - if(pos.real()+_radius>_x_req) - _x_req = pos.real()+_radius; - if(pos.imag()+_radius>_y_req) - _y_req = pos.imag()+_radius; - */ + if(_arrange_mode!=arrange_circular) { pos += inc; @@ -491,7 +553,6 @@ HoltWidget::arrange() inc *= mul; pos = cen + inc; } - // cout << "p-B) pos=" << pos << " cen=" << cen << " inc=" << inc << " mul=" << mul << endl; piter++; } @@ -518,23 +579,21 @@ HoltWidget::set_show_threads(bool show) void -HoltWidget::update(const Simulation& changed_simulation) +HoltWidget::update(const Simulation& /*changed_simulation*/) { - std::cout << "HoltWidget::update - Simulation" << endl; - // Force redraw - //redraw(); - // acquire(); - // resize_redraw(); } void -HoltWidget::update(const History& changed_history) +HoltWidget::update(const History& /*changed_history*/) { +#ifndef NDEBUG std::cout << "HoltWidget::update - History" << endl; - // Force redraw - //redraw(); +#endif + // take new data acquire(); + + // Force redraw resize_redraw(); } @@ -544,7 +603,9 @@ HoltWidget::update(const History& changed_history) void HoltWidget::acquire() { +#ifndef NDEBUG std::cout << "HoltWidget::acquire" << endl; +#endif const HoltResources& const_holt_resources = _holt_resources; for(Iseq it = iseq(const_holt_resources); it; ++it) @@ -603,9 +664,6 @@ HoltWidget::acquire() } // iter trough threads, requests, subrequests - // FIXME - // typedef std::vector Threads; - // typedef std::vector::const_iterator thr_iterator; const std::vector& tvect = p->get_threads(); std::vector::const_iterator thr_iter = tvect.begin(); while(thr_iter!=tvect.end()) @@ -661,8 +719,6 @@ HoltWidget::acquire() // associates process (or thread) with resource) HoltRequest *hreq = new HoltRequest(*hp, *(hpos->second), sr->get_state()); _holt_requests.push_back(hreq); - // cout << "added HoltRequest\n" - // os << " name: " << pos->second->get_name(); } } // ~ if(subr_state==Request::state_unallocable ... etc /* @@ -686,7 +742,9 @@ HoltWidget::acquire() void HoltWidget::draw_widget(cairo_t* ctx) { +#ifndef NDEBUG std::cout << "HoltWidget::draw_widget" << endl; +#endif // dispose objects arrange(); @@ -754,7 +812,6 @@ HoltWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height) max = _n_res; cairo_text_extents_t extents; - // std::cout << " x_unit: " << std::endl; static const Glib::ustring val("Process 999 Resource 999"); cairo_text_extents(ctx, val.c_str(), &extents); _radius = extents.width/4.0; @@ -762,13 +819,15 @@ HoltWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height) switch(_arrange_mode) { case arrange_horizontal: - width = max * 4 * _radius; - height = 10 * _radius; + width = (size_t) (max * 4 * _radius); + height = (size_t) (10 * _radius); break; + case arrange_vertical: - width = 10 * _radius; - height = max * 4 * _radius; + width = (size_t) (10 * _radius); + height = (size_t) (max * 4 * _radius); break; + case arrange_circular: int tot = (_n_proc + _n_res); double alpha = 0; @@ -782,15 +841,16 @@ HoltWidget::calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height) } if(diam<4 * _radius) diam = 4 * _radius; - width = height = diam + 4 * _radius; + width = height = (size_t) (diam + 4 * _radius); break; } - cout << "Holt widget AFTER calc_drawing_size width=" << width << " height=" << height << endl; } +/* void HoltWidget::calc_widget_size(size_t& width, size_t& height) { cout << "Holt widget BEFORE calc_widget_size width=" << width << " height=" << height << endl; width = height = 20; // default minimum size } +*/ diff --git a/src/holt_widget.hh b/src/holt_widget.hh index ad3d221..95ec725 100644 --- a/src/holt_widget.hh +++ b/src/holt_widget.hh @@ -44,88 +44,329 @@ namespace sgpem /** * \brief Every point or vector is a Vec2. + * * This phisical vector class, Vec2 is realized trough - * complex because it's a full operative class with operators. + * complex because it's a full functional + * class with operators and easy vector operation as + * sum, multiply by scalar, rotation. */ typedef std::complex Vec2; + /** + * \brief Base class to draw holt graph nodes (schedulables and resources). + * + * This class is an "element" used by HoltWidget to draw holt graphs. + * An holt graph is built of circular nodes representing schedulables + * and square nodes representing resources connected as needed by + * arrows. + * + * This is a base abstract class for schedulables and resources. + * It has basic methods for positioning and sizing. + * The abstract method get_intersection() must be defined + * in derived classes to calculate the intersection of a request + * arrow with the node edge. + * + * Method draw() (abstract too) must provide effective object drawing. + */ class HoltNode { public: - // HoltNode(double x=0.0, double y=0.0); + /** + * \brief Unique constructor taking a Vec2 point as position. + * + * \param pt the predefined node position; default position at (0,0). + */ HoltNode(Vec2 pt = Vec2(0.0, 0.0)); + + /** + * \brief Class virtual destructor. + */ virtual ~HoltNode(); + /** + * \brief Effective output cairo drawing method. + * + * \param cr The cairo context to draw to. + */ virtual void draw(cairo_t *cr) = 0; - // void set_position(double x, double y); + + /** + * \brief Setter and getter method for position parameter. + * + * Position is in the center of object. + * + * \param pt The point to position the object. + * \return The previous position. + */ Vec2 set_position(Vec2 pt); + + /** + * \brief Getter method for position parameter. + * + * Position is in the center of object. + * + * \return The object actual position. + */ Vec2 get_position(); + + /** + * \brief Sets dimension of object. + * + * Radius represent the node dimension. + * By default these object are symmetrical and radius stay + * for "radius" in circular shaped nodes (schedulables), + * an half of the side for square objects (resources). + * + * \param radius The new desired value. + * \return The radius previous value. + */ double set_radius(double radius); + + /** + * \brief Gets dimension of object. + * + * Radius represent the node dimension. + * By default these object are symmetrical and radius stay + * for "radius" in circular shaped nodes (schedulables), + * an half of the side for square objects (resources). + * + * \return The actual radius value. + */ double get_radius(); + + /** + * \brief Computes point of intersection with edge. + * + * Giving a point outside the object edge this funcion returns + * the intersection of the segment connecting the shape center + * with the given point. + * Because is "shape dependent" it must be redefined in derived + * classes. + * + * \param pt The point to (ideally) connect to. + * \return The intersection of edge with segment from center to pt. + */ virtual Vec2 get_intersection_to(Vec2 pt) = 0; + protected: + /** + * \brief Object dimension. + */ double _radius; - // double _x, _y; + + /** + * \brief Object position. + */ Vec2 _pos; - private: }; - + /** + * \brief An holt node representing resources. + * + * A resource is drawn in form of square. + * This class derives from HoltNode and implements + * the abstract methods draw() and get_intersection(). + * + * This class is used internally by HoltWidget, an HistoryObserver + * and is strictly related to backend class Resource (and derived). + * Inside there is a pointer to the rapresented resource and its key. + * + */ class HoltResource : public HoltNode { public: - // HoltResource(const Resource& resource, resource_key_t resource_key, double x=0.0, double y=0.0); + /** + * \brief Unique constructor referring to resource and position in graph. + * + * \param resource The referred resource rapresented by this object. + * \param resource_key Unique numeric key associated with this resource. + * \param pt Position of object in graph. + */ HoltResource(const Resource& resource, resource_key_t resource_key, Vec2 pt = Vec2(0.0, 0.0)); + + /** + * \brief Object's virtual destructor. + */ virtual ~HoltResource(); + /** + * \brief Object's drawing method. + * + * \param cr Cairo context to draw to. + */ virtual void draw(cairo_t *cr); + + /** + * \brief Computes point of intersection with edge. + * + * Giving a point outside the object (square) edge this funcion returns + * the intersection of the segment connecting the shape center + * with the given point. + * + * \param pt The point to (ideally) connect to. + * \return The intersection of edge with segment from center to pt. + */ virtual Vec2 get_intersection_to(Vec2 pt); - protected: + private: + /** + * \brief Pointer to the related resource. + */ const Resource* _resource; + + /** + * \brief Numeric key associated with this resource. + */ resource_key_t _resource_key; }; + /** + * \brief An holt node representing schedulables (processes and threads). + * + * A schedulable is drawn in form of circle. + * This class derives from HoltNode and implements + * the abstract methods draw() and get_intersection(). + * + * This class is used internally by HoltWidget, an HistoryObserver + * and is strictly related to backend class Schedulable (and derived). + * Inside there is a pointer to the rapresented schedulable. + * + */ class HoltSchedulable : public HoltNode { public: - //HoltSchedulable(const Schedulable& schedulable, double x=0.0, double y=0.0); + /** + * \brief Unique constructor referring to schedulable and position in graph. + * + * \param schedulable The referred schedulable rapresented by this object. + * \param pt Position of object in graph. + */ HoltSchedulable(const Schedulable& schedulable, Vec2 pt = Vec2(0.0, 0.0)); + + /** + * \brief Object's virtual destructor. + */ virtual ~HoltSchedulable(); + /** + * \brief Object's drawing method. + * + * \param cr Cairo context to draw to. + */ virtual void draw(cairo_t *cr); + + /** + * \brief Computes point of intersection with edge. + * + * Giving a point outside the object (circle) edge this funcion returns + * the intersection of the segment connecting the shape center + * with the given point. + * + * \param pt The point to (ideally) connect to. + * \return The intersection of edge with segment from center to pt. + */ virtual Vec2 get_intersection_to(Vec2 pt); - protected: + private: + /** + * \brief Pointer to the related schedulable. + */ const Schedulable* _schedulable; }; + /** + * \brief Base class to draw holt graph arrows (requests/allocation). + * + * An arrow from a schedulable to a resource is called + * a request, counter is called an assignment. + * + * This is the class for both. + * It "connects" two objects: a schedulable and a resource and + * has a state to tell the direction of arrow. + * The state definition come from the class Request. + * Not all the values are drawn but only allocated (green), + * allocable (yellow), unallocable (red). + */ class HoltRequest { public: + /** + * \brief Object construcor. + * + * \param hp Reference to the HoltSchedulable. + * \param hr Reference to HoltResource. + * \param state Type of request. + */ HoltRequest(HoltSchedulable& hp, HoltResource& hr, Request::state state); + + /** + * \brief Object's virtual destructor. + */ virtual ~HoltRequest(); + /** + * \brief Object's drawing method. + * + * \param cr Cairo context to draw to. + */ virtual void draw(cairo_t *cr); - virtual void arrow(cairo_t *cr, Vec2 first, Vec2 second); - protected: + private: + /** + * \brief Methot for draw an arrow giving starting and ending points. + * + * \param cr Cairo context. + * \param first Starting point. + * \param first Ending point. + */ + virtual void arrow(cairo_t *cr, Vec2 first, Vec2 second); + + /** + * \brief Pointer to the referring schedulable. + */ HoltSchedulable* _hp; + + /** + * \brief Pointer to the referring resource. + */ HoltResource* _hr; + + /** + * \brief State of request. + */ Request::state _state; }; - + /** + * \brief Widget representing an Holt graph. + * + * This class is based on Simulation and History observers + * to get updates during the simulation progress; it's + * derived from CairoWidget to get the buffering and scaling + * features of that class. + * + * The objects disposition can be done in three ways: + * - horizontal: resources top, schedulables bottom, from left to right + * - vertical: resources left, schedulables right, from top to bottom + * - circular: resources and processes along a cricle + * This disposition is called "arrange mode" + * + * \deprecated The class should implement only HistoryObserver + * + */ class HoltWidget : public SimulationObserver, public HistoryObserver, public CairoWidget { public: + /** + * \brief Modes to dispose graph nodes. + */ enum arrange_mode { arrange_horizontal = 1 << 0, @@ -133,46 +374,185 @@ namespace sgpem arrange_circular = 1 << 2 }; - typedef std::map HoltResources; - typedef std::vector HoltProcesses; - typedef std::vector HoltRequests; - + /** + * \brief Unique constructor. + * + * Saves the passed argument in data member _simulation. + * + * \param simulation The observed Simulation + */ HoltWidget(Simulation& simulation); + + /** + * \brief Object's virtual destructor. + */ virtual ~HoltWidget(); + /** + * \brief SimulationObserver's update method redefinition. + * + * Actually is a dummy method. + * + * \param changed_simulation the observed Simulation + */ void update(const Simulation& changed_simulation); - void update(const History& changed_history); - void acquire(); - double get_radius(); + /** + * \brief HistoryObserver's update method redefinition. + * + * Updates the widget to reflects history current state. + * + * \param changed_history the observed History + */ + void update(const History& changed_history); + + + + /** + * \brief Sets dimension of contained objects. + * + * \param radius The new desired value. + * \return The radius previous value. + */ double set_radius(double radius); + + /** + * \brief Gets dimension of contained objects. + * + * \return The actual radius value. + */ + double get_radius(); + + /** + * \brief Gets the current arrange mode. + * + * \return The actual arrange mode value. + */ arrange_mode get_arrange_mode(); + + /** + * \brief Sets and gets arrange mode. + * + * \param mode The desired arrange mode. + * \return The previous mode value. + */ arrange_mode set_arrange_mode(arrange_mode mode); - void arrange(); + + /** + * \brief Gets the _show_threads flag current status. + * + * \return true if threads visualization is enabled + */ bool get_show_threads(); + + /** + * \brief Sets and gets the _show_threads flag status. + * + * If _show_threads is disabled processes will be drawn on widget. + * If _show_threads is enabled then threads will be shown. + * + * \param show the new desired status of threads visualization + * \return the previous status + */ bool set_show_threads(bool show); protected: + + /** + * \brief Execute the widget painting when needed. + * + * \param ctx the cairo context to draw to + * \see CairoWidget for more. + */ void draw_widget(cairo_t* ctx); - virtual void calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height); - virtual void calc_widget_size(size_t& width, size_t& height); - private: - // int _x_unit; - //int _y_unit; - Simulation* _simulation; + /** + * \brief calculated the needed drawing surface dimensions. + * + * \param ctx the cairo context to calc draw related dimensions + * \param width the return parameter for desired width + * \param height the return parameter for desired height + */ + virtual void calc_drawing_size(cairo_t* ctx, size_t& width, size_t& height); + + // virtual void calc_widget_size(size_t& width, size_t& height); + + /** + * \brief Gets the actual history status and make graph objects. + */ + void acquire(); + /** + * \brief Reposition objects respecting actual arrange mode. + */ + void arrange(); + private: + /** + * \brief Associative container to keep HoltResource elements. + * + * This is a map because each schedulables request must find + * the related object throug its key. + */ + typedef std::map HoltResources; + + /** + * \brief Container to keep HoltSchedulable elements. + */ + typedef std::vector HoltProcesses; + + /** + * \brief Container to keep HoltRequest elements. + */ + typedef std::vector HoltRequests; + + + /** + * \brief Pointer to the observed simulation. + */ + Simulation* _simulation; + + /** + * \brief Radius used to dimension all controlled objects. + */ double _radius; + /** + * \brief The HoltResource container. + */ HoltResources _holt_resources; + + /** + * \brief The HoltProcess container. + */ HoltProcesses _holt_schedulables; + + /** + * \brief The HoltRequest container. + */ HoltRequests _holt_requests; + + /** + * \brief Number of schedulables (processes or threads) to draw. + */ int _n_proc; + + /** + * \brief Number of resources to draw. + */ int _n_res; + /** + * \brief The current "arrange mode". + * + * \see arrange_mode + */ arrange_mode _arrange_mode; + + /** + * \brief Flag to select processes or threads visualization. + */ bool _show_threads; }; diff --git a/src/simulation_widget.hh b/src/simulation_widget.hh index 77ac487..ab73c8b 100644 --- a/src/simulation_widget.hh +++ b/src/simulation_widget.hh @@ -61,11 +61,11 @@ namespace sgpem { public: /** - * \brief default and unique constructor. + * \brief Unique constructor. * * Saves the passed argument in data member _simulation. * - * \param simulation the observed Simulation + * \param simulation The observed Simulation */ SimulationWidget(Simulation& simulation);