GanttDiagram.hpp 16.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/*
 ** This file is part of the ViTE project.
 **
 ** This software is governed by the CeCILL-A license under French law
 ** and abiding by the rules of distribution of free software. You can
 ** use, modify and/or redistribute the software under the terms of the
 ** CeCILL-A license as circulated by CEA, CNRS and INRIA at the following
 ** URL: "http://www.cecill.info".
 **
 ** As a counterpart to the access to the source code and rights to copy,
 ** modify and redistribute granted by the license, users are provided
 ** only with a limited warranty and the software's author, the holder of
 ** the economic rights, and the successive licensors have only limited
 ** liability.
 **
 ** In this respect, the user's attention is drawn to the risks associated
 ** with loading, using, modifying and/or developing or reproducing the
 ** software by the user in light of its specific status of free software,
 ** that may mean that it is complicated to manipulate, and that also
 ** therefore means that it is reserved for developers and experienced
 ** professionals having in-depth computer knowledge. Users are therefore
 ** encouraged to load and test the software's suitability as regards
 ** their requirements in conditions enabling the security of their
 ** systems and/or data to be ensured and, more generally, to use and
 ** operate it in the same conditions as regards security.
 **
 ** The fact that you are presently reading this means that you have had
 ** knowledge of the CeCILL-A license and that you accept its terms.
 **
 **
 ** ViTE developers are (for version 0.* to 1.0):
 **
 **        - COULOMB Kevin
 **        - FAVERGE Mathieu
 **        - JAZEIX Johnny
 **        - LAGRASSE Olivier
 **        - MARCOUEILLE Jule
 **        - NOISETTE Pascal
 **        - REDONDY Arthur
 **        - VUCHENER Clément
 **
 */
/*!
 *\file GanttDiagram.hpp
 */

#ifndef GANTTDIAGRAM_HPP
#define GANTTDIAGRAM_HPP
49
#include <iostream>
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#include "Render.hpp"

class Trace;
/*!
 * \brief Structure used to store container information.
 */
struct Container_{
    /*!
     * \brief Coordinates.
     */
    Element_pos x, y, w, h;
};

/*!
 * \brief Structure used to store container text.
 */
struct Container_text_{
    /*!
     * \brief Coordinates.
     */
Thibault Soucarre's avatar
Thibault Soucarre committed
70
    Element_pos x, y, size;
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
    /*!
     * \brief Text.
     */
    std::string value;
};

/*!
 * \brief This class is used to called opengl or svg primitive functions to draw trace elements.
 */
class GanttDiagram : public Geometry
{
private:

    /*!
     * This attribute store the instance of a drawing class. (OpenGL or SVG for example)
     */
87
    Render *_render;
88
89
90
91
92
93
94

    /*!
     * \brief Used to draw counter.
     */
    bool _start_new_line;


95
    std::vector<Container_>      _containers;
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
    std::vector<Container_text_> _container_texts;

    /*!
     * \brief The default constructor is in private scope to prevent Render instanciation without
     * provide a drawing instance.
     */
    GanttDiagram(){
    }

public:

    /***********************************
     *
     * Constructor and destructor.
     *
     **********************************/

    /*!
     * \brief The default constructor
     */
    GanttDiagram(Render* instance){
117
        _render = instance;
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
    }

    /*!
     * \brief The destructor
     */
    virtual ~GanttDiagram(){
    }


    /***********************************
     *
     * Building functions.
     *
     **********************************/

    /*!
     * \brief Proceeds with the initialization of the draw functions.
     */
    inline void start_draw(){
        /* clear vectors */
        _containers.clear();
        _container_texts.clear();

141
        _render->start_draw();
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
    }

    /*!
     * \brief Initialize container draws.
     */
    inline void start_draw_containers(){
    }

    /*!
     * \brief Draw a container according to the parameters
     * \param x the x position of the container
     * \param y the y position of the container
     * \param w the width of the container
     * \param h the height of the container
     */
157
158
159
160
161
    inline void draw_container(const Element_pos x,
                               const Element_pos y,
                               const Element_pos w,
                               const Element_pos h,
                               const std::string &value)
Mathieu Faverge's avatar
Mathieu Faverge committed
162
163
164
        {
            Container_text_ buft;
            Container_      buf;
165

Mathieu Faverge's avatar
Mathieu Faverge committed
166
167
168
169
            buf.x = x;
            buf.y = y;
            buf.w = w;
            buf.h = h;
170

Mathieu Faverge's avatar
Mathieu Faverge committed
171
            _containers.push_back(buf);
172

Mathieu Faverge's avatar
Mathieu Faverge committed
173
174
175
            buft.x     = x + w/5;
            buft.y     = y + h/2;
            buft.value = value;
176

Mathieu Faverge's avatar
Mathieu Faverge committed
177
            _container_texts.push_back(buft);
178

Mathieu Faverge's avatar
Mathieu Faverge committed
179
180
            if ((x+w)>Info::Container::x_max)
                Info::Container::x_max = x+w;
181

Mathieu Faverge's avatar
Mathieu Faverge committed
182
183
            if ((y+h)>Info::Container::y_max)
                Info::Container::y_max = y+h;
184

Mathieu Faverge's avatar
Mathieu Faverge committed
185
186
            if (Info::Container::x_min > x)
                Info::Container::x_min = x;
187

Mathieu Faverge's avatar
Mathieu Faverge committed
188
189
            if (Info::Container::y_min > y)
                Info::Container::y_min = y;
190
191

#ifdef DEBUG_MODE_RENDER_AREA
Mathieu Faverge's avatar
Mathieu Faverge committed
192
193
194
            std::cerr << __FILE__ << " l." << __LINE__ << ":" << std::endl;
            std::cerr < "Container drawing:" << std::endl;
            std::cerr << "x: " << x << " y: " << y << " w: " << w << " h: " << h << " xmax-xmin: " << Info::Container::x_max << " - " << Info::Container::x_min << " ymax-ymin: " << Info::Container::y_max << " - " << Info::Container::y_min << std::endl;
195
196

#endif
Mathieu Faverge's avatar
Mathieu Faverge committed
197
        }
198
199
200
201
202
203
204
205
206

    /*!
     * \brief Draw the text of a container.
     * \param x the x position of the text.
     * \param y the y position of the text.
     * \param value the string value of the text.
     *
     * This function stores text in a list. This list will be display each time the render area need to be updated.
     */
207
    inline void draw_container_text(const Element_pos x, const Element_pos y, const std::string value)
Mathieu Faverge's avatar
Mathieu Faverge committed
208
209
210
        {
            return;
        }
211
212
213
214

    /*!
     * \brief Closes the container display list.
     */
215
    inline void end_draw_containers()
Mathieu Faverge's avatar
Mathieu Faverge committed
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
        {
            static float j = 0.6f;
            float coeffx =  (Info::Render::width                /Info::Container::x_max) * _x_scale_container_state;
            float coeffy = ((Info::Render::height-_ruler_height)/Info::Container::y_max) * _y_state_scale;

            /* Before calling start_draw_container(), Info::Container::y_max should have a correct value */
            _render->start_draw_containers();

            for (unsigned int i=0 ; i<_containers.size() ; i++){
                _render->set_color(0, 0, j);
                _render->draw_quad(_containers[i].x * coeffx,
                                   trace_to_render_y(_containers[i].y),
                                   _z_container,
                                   _containers[i].w * coeffx,
                                   _containers[i].h * coeffy);
            }
232

Mathieu Faverge's avatar
Mathieu Faverge committed
233
234
235
            for (unsigned int i=0 ; i<_container_texts.size() ; i++){
                _container_texts[i].x *= coeffx;
                _container_texts[i].y  = trace_to_render_y(_container_texts[i].y);
236

Mathieu Faverge's avatar
Mathieu Faverge committed
237
238
239
240
241
                _render->draw_text(_container_texts[i].x,
                                   _container_texts[i].y,
                                   _containers[i].w * coeffx,
                                   _container_texts[i].value);
            }
242

Mathieu Faverge's avatar
Mathieu Faverge committed
243
244
            _render->end_draw_containers();
        }
245
246
247
248

    /*!
     * \brief Creates and opens the display list for state draws.
     */
249
    inline void start_draw_states()
Mathieu Faverge's avatar
Mathieu Faverge committed
250
251
252
        {
            _render->start_draw_states();
        }
253
254
255
256
257
258
259
260
261
262
263

    /*!
     * \brief Draw a state of the trace.
     * \param start the beginning time of the state.
     * \param end the ending time of the state.
     * \param base vertical position of the state.
     * \param height the state height.
     * \param r the red color rate of the state.
     * \param g the green color rate of the state.
     * \param b the blue color rate of the state.
     */
264
265
266
267
268
269
270
271
    inline void draw_state(const Element_pos start,
                           const Element_pos end,
                           const Element_pos base,
                           const Element_pos height,
                           const Element_col r,
                           const Element_col g,
                           const Element_col b,
                           EntityValue * value)
Mathieu Faverge's avatar
Mathieu Faverge committed
272
273
274
275
276
277
278
279
280
        {
            _render->set_color(r, g, b);
            _render->draw_state(trace_to_render_x(start - Info::Render::_x_min_visible),
                                trace_to_render_y(base),
                                _z_state,
                                (end-start)*coeff_trace_render_x(),
                                height     *coeff_trace_render_y(),
                                value);
        }
281
282
283
284

    /*!
     * \brief Closes the state display list.
     */
285
    inline void end_draw_states()
Mathieu Faverge's avatar
Mathieu Faverge committed
286
287
288
        {
            _render->end_draw_states();
        }
289
290
291
292

    /*!
     * \brief Open the arrow display list.
     */
293
    inline void start_draw_arrows()
Mathieu Faverge's avatar
Mathieu Faverge committed
294
295
296
        {
            _render->start_draw_arrows();
        }
297
298
299
300
301
302
303
304
305
306

    /*!
     * \brief Draw an arrow.
     * \param start_time the beginning time of the arrow.
     * \param end_time the ending time of the arrow.
     * \param start_height vertical position of the begining time of the arrow.
     * \param end_height vertical position of the ending time of the arrow.
     *
     * This function stores all the information of the arrow to display it each time the render area need to be updated.
     */
307
308
309
310
311
312
313
314
    inline void draw_arrow(Element_pos start_time,
                           Element_pos end_time,
                           Element_pos start_height,
                           Element_pos end_height,
                           const Element_col r,
                           const Element_col g,
                           const Element_col b,
                           EntityValue* value)
Mathieu Faverge's avatar
Mathieu Faverge committed
315
316
        {
            _render->set_color(r, g, b);
317

Mathieu Faverge's avatar
Mathieu Faverge committed
318
319
320
321
            start_time   = trace_to_render_x(start_time - Info::Render::_x_min_visible);
            end_time     = trace_to_render_x(end_time   - Info::Render::_x_min_visible);
            start_height = trace_to_render_y(start_height);
            end_height   = trace_to_render_y(end_height);
322

Mathieu Faverge's avatar
Mathieu Faverge committed
323
324
325
            /* For OpenGL */
            _render->draw_arrow(start_time, end_time, start_height, end_height, r, g, b, value);
        }
326
327
328
329

    /*!
     * \brief Closes the arrow display list.
     */
330
    inline void end_draw_arrows()
Mathieu Faverge's avatar
Mathieu Faverge committed
331
332
333
        {
            _render->end_draw_arrows();
        }
334

335
    inline void start_draw_events()
Mathieu Faverge's avatar
Mathieu Faverge committed
336
337
338
        {
            _render->start_draw_events();
        }
339
340
341
342
343
344
345
346
347

    /*!
     * \brief Draw an event.
     * \param time time when the event occurs.
     * \param height vertical position of the event.
     * \param container_height information to draw event. It corresponds to the container height when they are drawn horizontally.
     *
     * This function stores all the information of the event to display it each time the render area need to be updated.
     */
348
349
350
351
352
353
354
    inline void draw_event(Element_pos time,
                           Element_pos height,
                           Element_pos container_height,
                           const Element_col r,
                           const Element_col g,
                           const Element_col b,
                           EntityValue* value)
Mathieu Faverge's avatar
Mathieu Faverge committed
355
356
357
        {
            /* For SVG */
            _render->set_color(r, g, b);
358

Mathieu Faverge's avatar
Mathieu Faverge committed
359
360
361
            time             = trace_to_render_x(time - Info::Render::_x_min_visible);
            height           = trace_to_render_y(height);
            container_height = container_height*coeff_trace_render_y();
362

Mathieu Faverge's avatar
Mathieu Faverge committed
363
364
365
            /* For OpenGL */
            _render->draw_event(time, height, container_height, value);
        }
366

367
    inline void end_draw_events()
Mathieu Faverge's avatar
Mathieu Faverge committed
368
369
370
        {
            _render->end_draw_events();
        }
371
372
373
374

    /*!
     * \brief Creates and opens the display list for counter draws.
     */
375
    inline void start_draw_counter()
Mathieu Faverge's avatar
Mathieu Faverge committed
376
377
378
379
380
381
382
        {
            _render->set_color(1.0, 1.0, 1.0);
            _counter_last_x=0.0;
            _counter_last_y=0.0;
            _render->start_draw_counter();
            _start_new_line = true;
        }
383
384
385
386
387
388
389

    /*!
     * \brief Draw a text with the value of a variable
     * \param text text to draw.
     * \param y y position of the point.
     *
     */
390
    inline void draw_text_value(long int id, double text, double y)
Mathieu Faverge's avatar
Mathieu Faverge committed
391
392
393
        {
            _render->draw_text_value(id,text,y);
        }
394

395
396
397
398
399
400
401
    /*!
     * \brief Draw a point of the counter.
     * \param x x position of the point.
     * \param y y position of the point.
     *
     * Each time counter is increased, this function is called with the coordinates of the new point.
     */
402
    inline void draw_counter(const Element_pos x, const Element_pos y)
Mathieu Faverge's avatar
Mathieu Faverge committed
403
404
        {
            if (_start_new_line){/* Start a new line */
405

Mathieu Faverge's avatar
Mathieu Faverge committed
406
407
408
                _counter_last_x = x;
                _counter_last_y = y;
                _start_new_line = false;
409

410
411
            }
            else
Mathieu Faverge's avatar
Mathieu Faverge committed
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
            {/* line is already started */

                if (x <= 0.0){/* convention: the line is over */
                    _render->draw_line( trace_to_render_x(_counter_last_x - Info::Render::_x_min_visible),
                                        trace_to_render_y(_counter_last_y),
                                        trace_to_render_x(Info::Entity::x_max),
                                        trace_to_render_y(_counter_last_y),
                                        _z_counter );
                    _start_new_line = true;
                }
                else
                {/* add new points to the line */

                    /* Each time, the method draw the line from the previous point to
                     the current point (x, y). This last is stored for the next line drawing. */
                    _render->draw_line( trace_to_render_x(_counter_last_x - Info::Render::_x_min_visible),
                                        trace_to_render_y(_counter_last_y),
                                        trace_to_render_x(x - Info::Render::_x_min_visible),
                                        trace_to_render_y(_counter_last_y),
                                        _z_counter );
                    _render->draw_line( trace_to_render_x(x - Info::Render::_x_min_visible),
                                        trace_to_render_y(_counter_last_y),
                                        trace_to_render_x(x - Info::Render::_x_min_visible),
                                        trace_to_render_y(y),
                                        _z_counter );
                    _counter_last_x = x;
                    _counter_last_y = y;
                }
440
441
442
443
444
445
            }
        }

    /*!
     * \brief Closes the counter display list.
     */
446
    inline void end_draw_counter()
Mathieu Faverge's avatar
Mathieu Faverge committed
447
448
449
450
451
452
453
454
455
456
        {
            if (!_start_new_line) {/* If a line was previously opened */
                /* Draw the last line */
                _render->draw_line( trace_to_render_x(_counter_last_x - Info::Render::_x_min_visible),
                                    trace_to_render_y(_counter_last_y),
                                    trace_to_render_x(Info::Entity::x_max),
                                    trace_to_render_y(_counter_last_y),
                                    _z_counter );
            }
            _render->end_draw_counter();
457
458
459
460
461
        }

    /*!
     * \brief Do nothing (it is present for compatibility of the Render class).
     */
462
    inline void end_draw()
463
        {
Mathieu Faverge's avatar
Mathieu Faverge committed
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
            std::ostringstream buf_txt;
            Element_pos graduation_diff;
            //Element_pos coeff_prefix;
            const Element_pos offset_x = 0;
            const Element_pos offset_y = 0;

            graduation_diff = Ruler::get_graduation_diff(Info::Render::_x_min_visible, Info::Render::_x_max_visible);

            /* Now, draw ruler */
            /*Rendering is done in paintGL because we need to recalculate graduations each time paintGL is called, not just when launching the program*/
            _render->start_ruler();
            {
                //_render->call_ruler();
            }
            _render->end_ruler();
479

Mathieu Faverge's avatar
Mathieu Faverge committed
480
481
482
483
            /* clear vectors */
            _containers.clear();
            _container_texts.clear();
            _render->end_draw();
484

Mathieu Faverge's avatar
Mathieu Faverge committed
485
        }
486
};
487
488

#endif