diff --git a/src/trace/Container.cpp b/src/trace/Container.cpp index bdbeefd8be234981c5b70b2224da21d63ef24b07..9e3c82fcf80775f0a92327e88eee049e40a87469 100644 --- a/src/trace/Container.cpp +++ b/src/trace/Container.cpp @@ -3,7 +3,7 @@ Container::Container(Name name, Date creation_time, ContainerType *type, Container *parent): _name(name), _creation_time(creation_time), _destruction_time(0.0), _type(type), _parent(parent), - _n_variables(0), _event_tree(0), _state_tree(0), _n_events(0), _n_states(0) { + _n_states(0), _state_tree(0), _n_events(0), _event_tree(0), _n_variables(0) { } template diff --git a/src/trace/DrawTrace.hpp b/src/trace/DrawTrace.hpp index 24e54e5fa1eb3eb875742e1ef433577e5439c4db..b30869cdce8b9b193e87a3359fcf7dbee5f7dcca 100644 --- a/src/trace/DrawTrace.hpp +++ b/src/trace/DrawTrace.hpp @@ -25,9 +25,19 @@ class DrawTrace protected: // Interface_graphic* _window; - std::list _entity_containers; // Containers with states or events - std::list _link_containers; // Containers with links - std::list _variable_containers; // Containers with variables + + /*! + * \brief Containers with states or events + */ + std::list _entity_containers; + /*! + * \brief Containers with links + */ + std::list _link_containers; + /*! + * \brief Containers with variables + */ + std::list _variable_containers; std::map > _container_positions; /*! @@ -140,6 +150,10 @@ public: * **********************************/ + /* + * \fn browse_container_tree(T* draw_object, Trace* trace) + * \brief Function that browses the containers of the trace argument and make them painted with a T object + */ inline void browse_container_tree(T* draw_object, Trace* trace){ /*** Drawing containers ***/ int position = 0; @@ -156,6 +170,11 @@ public: }/* end browse_container_tree */ + + /* + * \fn browse_container(T* draw_object, const Container *container, int position, int depth) + * \brief Recursive function that browse a container to draw it with a T painting object in position, knowing the current depth in the tree + */ int browse_container(T* draw_object, const Container *container, int position, int depth) { int size = 0; @@ -311,32 +330,7 @@ public: draw_object->end_draw_counter(); } - - /*! - * \brief Draw a state - * \param draw_object Object that contains the drawing methods - * \param starttime Time when the state begins - * \param endtime Time when the state ends - * \param position Line where the state is drawn - * \param r Red value of the state color - * \param g Green value of the state color - * \param b Blue value of the state color - */ - /* inline void draw_state(T *draw_object, double starttime, double endtime, int position, double r, double g, double b) { - Element_pos y = position*(_container_height+_container_v_space) + _container_v_space/2; - draw_object->draw_state(starttime, endtime, y, _state_height, r, g, b); - }*/ - - /*! - * \brief Draw an event - * \param draw_object Object that contains the drawing methods - * \param time Time of the event - * \param position Line where the event is drawn - */ - /*inline void draw_event(T *draw_object, double time, int position) { - Element_pos y = position*(_container_height+_container_v_space) + _container_v_space/2; - draw_object->draw_event(time, y, _state_height); - }*/ + /*! * \brief Draw a point of a variable curve diff --git a/src/trace/DrawTree.hpp b/src/trace/DrawTree.hpp index 74bcc0004ccc98b088f3a764ef2b8a6dad882531..798c6fecd3085c90711a9c13a06cc2b9d53d288e 100644 --- a/src/trace/DrawTree.hpp +++ b/src/trace/DrawTree.hpp @@ -1,3 +1,7 @@ +/*! + *\file DrawTree.hpp + */ + #ifndef DRAWTREE_HPP #define DRAWTREE_HPP @@ -6,6 +10,9 @@ #include template +/*! + * \brief Class called to draw a binary tree of type E using a D painting object + */ class DrawTree { private: D *_draw_object; @@ -31,7 +38,7 @@ public: } /*! - * \fn browse_draw_tree_root( BinaryTree * tree, Interval * I) + * \fn draw_tree( BinaryTree * tree, const Interval &I) * \brief Function called to draw on ViTE the elements of a tree * \param tree : The tree we want to draw * \param I : The interval we have to draw the tree @@ -43,7 +50,7 @@ public: } /*! - * \fn browse_draw_tree( Interval * I, Node * node) + * \fn browse_tree(const Interval &I, Node *node) * \brief Function called to draw on ViTE a node * \param I : The interval we have to draw node * \param node : The node we want to draw @@ -75,27 +82,46 @@ public: } /*! - * \fn display_busy(Interval *I) + * \fn draw_busy(Interval *I) * \brief Function that display a purple squarre in the interval selected */ inline void draw_busy(Interval *I) { - draw_state(I->_left.get_value(), I->_right.get_value(), 0.9, 0.9, 0.9); + draw_state(I->_left.get_value(), I->_right.get_value(), 0.2, 0.2, 0.2); } }; +/*! + * \struct DrawNode + * \brief Structure to draw a node of type E with a painting object of type D + */ template struct DrawNode { + /*! + * \fn draw_node(DrawTree *draw, Node *node) + * \brief To draw a node of type E with a painting object of type D + */ static void draw_node(DrawTree *draw, Node *node) { } }; +/*! + * \struct DrawNode + * \brief Draw a Node with a D painting object + */ template struct DrawNode { + /*! + * \fn draw_node(DrawTree *draw, Node *node) + * \brief To draw a node of type Event with a painting object of type D + */ static void draw_node(DrawTree *draw, Node *node) { draw->draw_event(node->get_element()->get_time().get_value()); } }; - +/*! + * \struct DrawNode + * \brief Draw a Node with a D painting object + */ template struct DrawNode { static void draw_node(DrawTree *draw, Node *node) { @@ -124,7 +150,7 @@ struct DrawNode { template /*! - *\fn browse_tree(Interval * I, Node * node) + *\fn DrawTree::browse_tree(const Interval &I, Node * node) *\brief Function that browses a tree to display *\param I : The interval we have to display node *\param Node : The node in the tree we want to display @@ -151,9 +177,9 @@ void DrawTree::browse_tree(const Interval &I, Node *node) { // If the node is in the interval if(node->get_element()->get_time() <= I._right && node->get_element()->get_time() >= I._left) { - + // If the node can be displayed (interval is wide enought) - if (I._right - I._left > _min_size) { + if (I._right - I._left > _min_size){ // Launching Recursively in children if (n_children >= 1)//left browse_tree(Interval(I._left, node->get_element()->get_time()), @@ -168,7 +194,7 @@ void DrawTree::browse_tree(const Interval &I, Node *node) { node->_left_interval = new Interval(node->get_left_child()->_left_interval->_left, node->get_left_child()->_left_interval->_right); } - // Else no problem on the left + // Else no problem on the left (if a leaf, treated later) else { node->_left_interval = NULL; } @@ -178,83 +204,32 @@ void DrawTree::browse_tree(const Interval &I, Node *node) { node->get_left_child()->_right_interval && node->get_right_child()->_left_interval) { - // If node is too close of the problematic area by both sides - if(node->get_element()->get_time() - node->get_left_child()->_right_interval->_right < _min_size && - node->get_right_child()->_left_interval->_left - node->get_element()->get_time() < _min_size) { - // Drawing a crowded area - draw_busy(new Interval(node->get_left_child()->_right_interval->_left, - node->get_right_child()->_left_interval->_right)); - displayed = true; - - if(!node->get_left_child()->_right_interval) - delete node->get_left_child()->_right_interval; - if (!node->get_left_child()->_left_interval && - node->get_left_child()->_right_interval != node->get_right_child()->_left_interval) - delete node->get_right_child()->_left_interval; - node->get_right_child()->_left_interval = NULL; - node->get_left_child()->_right_interval = NULL; - } - // If 2 intervals present but only the left is problematic - else if(node->get_element()->get_time() - node->get_left_child()->_right_interval->_right < _min_size){ - displayed = true; - draw_busy(new Interval(node->get_left_child()->_right_interval->_left, - node->get_element()->get_time())); - draw_busy(node->get_right_child()->_left_interval); - - if(!node->get_left_child()->_right_interval) - delete node->get_left_child()->_right_interval; - node->get_left_child()->_right_interval = NULL; - } - // If 2 intervals present but only the right is problematic - else if(node->get_right_child()->_left_interval->_left - node->get_element()->get_time() < _min_size){ - displayed = true; - draw_busy(new Interval(node->get_element()->get_time(), - node->get_right_child()->_left_interval->_right)); - draw_busy(node->get_left_child()->_right_interval); - if(!node->get_right_child()->_left_interval) - delete node->get_right_child()->_left_interval; - node->get_right_child()->_left_interval = NULL; - } - else{ - draw_busy(node->get_left_child()->_right_interval); - draw_busy(node->get_right_child()->_left_interval); - displayed = true; - DrawNode::draw_node(this, node); - } + // Drawing a crowded area + draw_busy(new Interval(node->get_left_child()->_right_interval->_left, + node->get_right_child()->_left_interval->_right)); + displayed = true; + + delete node->get_left_child()->_right_interval; + delete node->get_right_child()->_left_interval; + node->get_right_child()->_left_interval = NULL; + node->get_left_child()->_right_interval = NULL; } + // Else if problem possible with the left child : it's right interval else if (n_children >= 1 && node->get_left_child()->_right_interval) { - // If node is in the problematic area - if(node->get_element()->get_time() - node->get_left_child()->_right_interval->_right < _min_size) { - displayed = true; - draw_busy(new Interval(node->get_left_child()->_right_interval->_left, - node->get_element()->get_time())); - - if(!node->get_left_child()->_right_interval) - delete node->get_left_child()->_right_interval; - node->get_left_child()->_right_interval = NULL; - } - else { - draw_busy(node->get_left_child()->_right_interval); - } + + draw_busy(new Interval(node->get_left_child()->_right_interval->_left, + node->get_element()->get_time())); + delete node->get_left_child()->_right_interval; + node->get_left_child()->_right_interval = NULL; } // Else if problem possible with the right child : it's left interval else if (n_children >= 2 && node->get_right_child()->_left_interval) { - if(node->get_right_child()->_left_interval->_left - node->get_element()->get_time() < _min_size) { - displayed = true; - draw_busy(new Interval(node->get_element()->get_time(), - node->get_right_child()->_left_interval->_right)); - if(!node->get_right_child()->_left_interval) - delete node->get_right_child()->_left_interval; - node->get_right_child()->_left_interval = NULL; - } - else { - draw_busy(node->get_right_child()->_left_interval); - } - } - else if(n_children>= 1 && !displayed){ displayed = true; - DrawNode::draw_node(this, node); + draw_busy(new Interval(node->get_element()->get_time(), + node->get_right_child()->_left_interval->_right)); + delete node->get_right_child()->_left_interval; + node->get_right_child()->_left_interval = NULL; } @@ -262,18 +237,35 @@ void DrawTree::browse_tree(const Interval &I, Node *node) { if(n_children >= 2 && node->get_right_child()->_right_interval) { // Setting the node's right interval as busy node->_right_interval = node->get_right_child()->_right_interval; - } - // Else no problem on the right + } + // Else no problem on the right (if a leaf, treated after) else { node->_right_interval = NULL; } + // Treating the special case of a leaf + if(n_children == 0){ + //If too close of the previous node + if(node->get_element()->get_time() - I._left < _min_size){ + node->_left_interval= new Interval(I._left, + node->get_element()->get_time()); + node->_right_interval = NULL; + } + //If too close of the following node + if(I._right - node->get_element()->get_time() < _min_size){ + node->_right_interval = new Interval(node->get_element()->get_time(), + I._right); + node->_left_interval = NULL; + } + } + // Making sure node has been displayed if(!displayed) { DrawNode::draw_node(this, node); } } // end if has enough space + else { // Cannot display node so the busy intervals are the same and value I node->_left_interval = new Interval(I);