Render_alternate.hpp 18.2 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
 ** 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
 **
 */
43 44 45 46 47 48 49
/*!
 *\file Render_alternate.hpp
 */

#ifndef RENDER_OPENGL_HPP
#define RENDER_OPENGL_HPP

50 51 52 53 54 55 56 57
#include <stack>
#include <cmath>
#include <sstream>
/* -- */
#include <QObject>
#include <QGLWidget>
#include <QLabel>
#include <QPainter>
58 59 60 61
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtx/transform.hpp>
#include <glm/gtc/type_ptr.hpp>
62 63 64 65 66 67 68 69 70 71
/* -- */
#include "common/common.hpp"
#include "common/Info.hpp"
/* -- */
#include "render/Geometry.hpp"
#include "render/Hook_event.hpp"
#include "render/Render.hpp"
#include "render/Minimap.hpp"
#include "render/Ruler.hpp"
#include "render/GanttDiagram.hpp"
72 73
#include "render/vbo.hpp"
#include "render/Shader.hpp"
74

75 76
class Render_alternate;
class Interface_console;
77
class StateType;
78
struct Container_text_;
Thibault Soucarre's avatar
Thibault Soucarre committed
79 80 81 82 83 84 85
/*!
 * \brief Structure used to store text for variables.
 */
struct Variable_text_{
    Element_pos y;
    Element_pos value;
};
86

87 88 89 90 91 92 93
/*!
 * \def _DRAWING_CONTAINER_HEIGHT_DEFAULT
 * \brief The default height for basic containers.
 */

#define _DRAWING_CONTAINER_HEIGHT_DEFAULT 1.2f

94 95 96
/*!
 * \brief This class redefined the OpenGL widget - QGLWidget - to display the trace.
 */
97

98
class Render_alternate :  /*public QGLWidget,*/ public Hook_event, public Render
99 100
{
    Q_OBJECT
101
private:
102 103
    int _glsl; //version of OpenGL Shading Language
    Shader* _shader;
104
    //Shader* _wait_shader;
105
    Element_pos _container_height;
106 107 108
    Element_col _r;
    Element_col _g;
    Element_col _b;
109
    //std::vector<Element_pos> _links;
110
    //std::vector<Element_pos> _events;
111
    std::vector<Container_text_> _texts;
Thibault Soucarre's avatar
Thibault Soucarre committed
112
    std::map<long int, Variable_text_> _variable_texts;
113
    glm::mat4 _modelview;
114
    glm::mat4 _projection;
115
    Vbo _containers;
116
    //Vbo _states;
117 118
    //Vbo _events;
    //Vbo _events2;
119 120
    //Vbo _arrows;
    //Vbo _arrows2;
121
    Vbo _arrows3;
122 123
    Vbo _counters;
    Vbo _ruler;
Thibault Soucarre's avatar
Thibault Soucarre committed
124
    Vbo _wait;
125
    Vbo *_current;
126
    GLuint _textureID;
127
    std::map<EntityValue*, Vbo*> _states;
128
    //std::map<EntityValue*, Shader*> _states_shaders;
129 130
    //first element of the pair contains the points, second contains the lines
    std::map<EntityValue*, std::pair<Vbo*, Vbo*> > _events;
131
    //std::map<EntityValue*, Shader*> _events_shaders;
132 133
    //first element of the pair contains the line of the arrow, second contains the position of the head
    std::map<EntityValue*, std::pair<Vbo*, Vbo*> > _arrows;
134
    //std::map<EntityValue*, Shader*> _arrows_shaders;
135
    std::map<EntityValue*, std::vector<Element_pos> > _links;
Thibault Soucarre's avatar
Thibault Soucarre committed
136 137 138 139
    /*!
     * \brief Offset of the vertical helper line
     */
    Element_pos vertical_line;
140 141
public:

142 143 144 145 146
/***********************************
 *
 * Constructor and destructor.
 *
 **********************************/
147

148 149 150 151
/*!
 * \brief The default constructor
 */
Render_alternate(Core* core, QWidget *parent, const QGLFormat& format);
152

153 154 155 156
/*!
 * \brief The destructor
 */
virtual ~Render_alternate();
157

158 159 160 161
/*!
 * \brief Set Statistics and Informations about input trace
 */
void set_total_width(Element_pos){}
162

163 164 165 166
/*!
 * \brief Set Statistics and Informations about input trace
 */
void set_total_time(Times){}
167

168 169 170 171
/*!
 * \brief display the scale
 */
void display_time_scale(){}
172 173


174 175 176 177 178
/***********************************
 *
 * Default QGLWidget functions.
 *
 **********************************/
Thibault Soucarre's avatar
Thibault Soucarre committed
179

180 181 182 183
/*!
 * \brief Call by the system to initialize the OpenGL render area.
 */
void initializeGL();
Thibault Soucarre's avatar
Thibault Soucarre committed
184

185 186 187 188 189 190
/*!
 * \brief Call by the system when the render area was resized (occurs during a window resizement).
 * \param width : the new width of the render area.
 * \param height : the new height of the render area.
 */
void resizeGL(int width, int height);
Thibault Soucarre's avatar
Thibault Soucarre committed
191

192 193 194 195
/*!
 * \brief Call by the system each time the render area need to be updated.
 */
void paintGL();
Thibault Soucarre's avatar
Thibault Soucarre committed
196

197
//void paintEvent(QPaintEvent *event);
198

199 200 201
/* void initializeOverlayGL();
 void resizeOverlayGL(int width, int height);
 void paintOverlayGL();*/
Thibault Soucarre's avatar
Thibault Soucarre committed
202

203

204 205 206 207 208
/***********************************
 *
 * Building functions.
 *
 **********************************/
209

210 211 212 213
/*!
 * \brief This function constructs the trace.
 */
//  bool display_build() ;
214

215 216 217 218
/*!
 * \brief This function releases the trace.
 */
//   bool display_unbuild() ;
219

220 221 222 223
/*!
 * \brief Proceeds with the initialization of the OpenGL draw functions.
 */
void start_draw();
224

225 226 227 228
/*!
 * \brief Creates and opens the display list for container draws.
 */
void start_draw_containers();
229

230 231 232 233 234 235 236 237
/*!
 * \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
 */
void draw_container(const Element_pos x, const Element_pos y, const Element_pos w, const Element_pos h);
238

239 240 241 242 243 244 245 246 247
/*!
 * \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.
 */
void draw_container_text(const Element_pos x, const Element_pos y, const std::string value);
248

249 250 251 252
/*!
 * \brief Closes the container display list.
 */
void end_draw_containers();
Thibault Soucarre's avatar
Thibault Soucarre committed
253

254 255 256 257
/*!
 * \brief Creates and opens the display list for stater draws.
 */
void start_draw_states();
258

259 260 261 262 263 264 265 266 267 268
/*!
 * \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.
 */
269
void draw_state(const Element_pos start , const Element_pos end, const Element_pos base, const Element_pos height, const Element_pos r, EntityValue* type);
270

271 272 273 274
/*!
 * \brief Closes the state display list.
 */
void end_draw_states();
275

276 277 278 279
/*!
 * \brief Open the arrow display list.
 */
void start_draw_arrows();
280

281 282 283 284 285 286 287 288 289
/*!
 * \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.
 */
290
    void draw_arrow(const Element_pos start_time, const Element_pos end_time, const Element_pos start_height, const Element_pos end_height,const Element_col red, const Element_col green, const Element_col blue, EntityValue *value);
291

292 293 294 295
/*!
 * \brief Closes the arrow display list.
 */
void end_draw_arrows();
296

297 298 299 300
/*!
 * \brief Draw arrows contained in the Arrow_ vector
 * \param arrows An arrow vector.
 */
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
    // void draw_stored_arrows(std::vector<Arrow_> &arrows);

    void start_draw_events();

    /*!
     * \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.
     *
     *
     * \brief Creates and opens the display list for container draws.
     *
     * This function stores all the information of the event to display it each time the render area need to be updated.
     */
316
    void draw_event(const Element_pos time, const Element_pos height,  const Element_pos container_height, EntityValue*);
317 318 319 320 321 322 323 324 325 326 327 328 329 330

    void end_draw_events();


    /*!
     * \brief Draw events contained in the Event_ vector
     * \param events An event vector.
     */
    //  void draw_stored_events(std::vector<Event_> &events);

    /*!
     * \brief Creates and opens the display list for counter draws.
     */
    void start_draw_counter();
Thibault Soucarre's avatar
Thibault Soucarre committed
331

332 333 334 335 336 337 338 339
    /*!
     * \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.
     */
    void draw_counter(const Element_pos x, const Element_pos y);
Thibault Soucarre's avatar
Thibault Soucarre committed
340

341 342 343 344 345 346 347 348 349
    /*!
     * \brief Closes the counter display list.
     */
    void end_draw_counter();

    /*!
     * \brief Called before ruler drawing.
     */
    void start_ruler();
Thibault Soucarre's avatar
Thibault Soucarre committed
350

351 352 353 354
    /*!
     * \brief Called after ruler drawing.
     */
    void end_ruler();
Thibault Soucarre's avatar
Thibault Soucarre committed
355

356 357 358 359 360 361

    /*!
     * \brief Do nothing (it is present for compatibility of the Render class).
     */
    void end_draw();

Thibault Soucarre's avatar
Thibault Soucarre committed
362

363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404

    /***********************************
     *
     * Render OpenGL drawing functions.
     *
     **********************************/

    /*!
     * \brief Display a wait on the screen if there is no file opened.
     * \return Asset value of the wait.
     */
    GLuint draw_wait();

    /*!
     * \brief Draw the ruler display list.
     */
    void call_ruler();



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

    /*!
     * \brief This function draws the trace.
     */
    bool build();

    /*!
     * \brief This function releases the trace.
     */
    bool unbuild();

    /***********************************
     *
     * Displaying functions.
     *
     **********************************/

405 406 407 408 409 410 411 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 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
    //    /*!
    //      * \brief Display on screen containers between container_begin and container_end.
    //      * \param container_begin integer value : id of the first container.
    //      * \param container_end integer value : id of the last container.
    //      */
    //       void display_container(Element_count container_begin, Element_count container_end) =0;

    //     /*!
    //      * \brief Display on screen states between timer_begin and time_end,
    //      * container_begin and container_end and with timer width between depth_begin and depth_end.
    //      * \param time_begin floating point value : time of the first state.
    //      * \param time_end floating point value : time of the last state.
    //      * \param container_begin integer value : id of the first container.
    //      * \param container_end integer value : id of the last container.
    //      * \param depth_begin floating point value : width of the narrowest state.
    //      * \param depth_end floating point value : width of the widest state.
    //      */
    //        void display_state(Element_pos time_begin, Element_pos time_end,
    //                        Element_count container_begin, Element_count container_end,
    //                        Element_pos depth_begin, Element_pos depth_end) =0;

    //     /*!
    //      * \brief Display on screen arrows between timer_begin and time_end,
    //      * container_begin and container_end and with timer width between depth_begin and depth_end.
    //      * \param time_begin floating point value : time of the smallest arrow time value.
    //      * \param time_end floating point value : time of the higher arrow time value.
    //      * \param container_begin integer value : id of the first container.
    //      * \param container_end integer value : id of the last container.
    //      * \param depth_begin floating point value : the narrowest difference between
    //      * the beginning time and the ending time of the arrow.
    //      * \param depth_end floating point value : width of the widest difference between
    //      * the beginning time and the ending time of the arrow.
    //      */
    //     virtual void display_arrow(Element_pos time_begin, Element_pos time_end,
    //                        Element_count container_begin, Element_count container_end,
    //                        Element_pos depth_begin, Element_pos depth_end) =0;

    //     /*!
    //      * \brief Display on screen events between timer_begin and time_end,
    //      * container_begin and container_end.
    //      * \param time_begin floating point value : time of the first event.
    //      * \param time_end floating point value : time of the last event.
    //      * \param container_begin integer value : id of the first container.
    //      * \param container_end integer value : id of the last container.
    //      */
    //     virtual void display_event(Element_pos time_begin, Element_pos time_end,
    //                        Element_count container_begin, Element_count container_end) =0;

    //     /*!
    //      * \brief Display on screen counters between timer_begin and time_end,
    //      * container_begin and container_end.
    //      * \param time_begin floating point value : time of the smallest counter time value.
    //      * \param time_end floating point value : time of the higher counter time value.
    //      * \param container_begin integer value : id of the first container.
    //      * \param container_end integer value : id of the last container.
    //      */
    //     virtual void display_counter(Element_pos time_begin, Element_pos time_end,
    //                          Element_count container_begin, Element_count container_end) =0;
Thibault Soucarre's avatar
Thibault Soucarre committed
463

464 465 466 467
    /*!
     * \brief Set the color for the further drawings.
     * \param r the red value. Within [0 ; 1].
     * \param g the green value. Within [0 ; 1].
Thibault Soucarre's avatar
Thibault Soucarre committed
468
     * \param b the blue value. Within [0 ; 1].
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
     */
    void set_color(float r, float g, float b);

    /*!
     * \brief Draw a text.
     * \param x the horizontal position of the left bottom corner of the text.
     * \param y the vertical position of the left bottom corner of the text.
     * \param z the deep position of the text.
     * \param s the text.
     */
    virtual void draw_text(const Element_pos x, const Element_pos y, const Element_pos z, const std::string s);

    /*!
     * \brief Draw a quad.
     * \param x the horizontal position of the left bottom corner of the quad.
     * \param y the vertical position of the left bottom corner of the quad.
     * \param z the deep position of the quad.
     * \param w the width of the quad.
     * \param h the height of the quad.
     */
    void draw_quad(Element_pos x, Element_pos y, Element_pos z, Element_pos w, Element_pos h);

    /*!
     * \brief Draw a triangle.
     * \param x the horizontal position of the triangle center.
     * \param y the vertical position of the triangle center.
     * \param size the edge size.
     * \param r the rotation of triangle. (clockwise and in degree)
     */
    void draw_triangle(Element_pos x, Element_pos y,
                       Element_pos size, Element_pos r);
Thibault Soucarre's avatar
Thibault Soucarre committed
500

501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
    /*!
     * \brief Draw a line.
     * \param x1 the horizontal position of the first point.
     * \param y1 the vertical position of the firt point.
     * \param x2 the horizontal position of the second point.
     * \param y2 the vertical position of the second point.
     * \param z the deep position of the triangle.
     */
    void draw_line(Element_pos x1, Element_pos y1, Element_pos x2, Element_pos y2, Element_pos z);

    /*!
     * \brief Draw a circle.
     * \param x the horizontal position of the circle center.
     * \param y the vertical position of the circle center.
     * \param z the deep position of the circle.
     * \param r the circle radius.
     */
    void draw_circle(Element_pos x, Element_pos y, Element_pos z, Element_pos r);

    /* Temporary methods. Use to draw stored arrows and circles. It is to prevent scaling */
    void draw_stored_arrows();
    void draw_stored_circles();

    void draw_stored_texts();
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
    void release();
    void draw_text_value(long int id,double text, double y);
    void show_minimap();

    /*!
     * \brief draws the vertical helper line
     */

    void draw_vertical_line();

    /*!
     * \brief set the vertical line offset
     * \param l the line offset.
     */
    void set_vertical_line(Element_pos l);
540 541


Thibault Soucarre's avatar
Thibault Soucarre committed
542 543 544 545 546 547
    /*!
     * \brief returns the offset of the vertical helper line
     */
    Element_pos get_vertical_line();

public slots:
548
    /*!
Thibault Soucarre's avatar
Thibault Soucarre committed
549 550 551 552
     * \brief slot connected to the simple click event
     */
    void update_vertical_line();

553 554 555
    /*!
     * \brief Function that only delete the text of the screen
     */
556 557
    void clear_text ();

558 559 560 561 562 563
    /*!
     * \brief Change the color corresponding to an EntityValue
     */

    void change_color(std::string entity, Element_col r, Element_col g, Element_col b);

564 565
    void change_event_color(std::string event, Element_col r, Element_col g, Element_col b);

566 567
    void change_link_color(std::string link, Element_col r, Element_col g, Element_col b);

568 569
    void change_visible(std::string entity, bool visible);

570 571
    void change_event_visible(std::string event, bool visible);

572 573
    void change_link_visible(std::string link, bool visible);

574 575 576 577 578
    /*!
     * \brief reload state color from trace file
     */
    void reload_states();

579 580 581 582
    void reload_links();

    void reload_events();

Thibault Soucarre's avatar
Thibault Soucarre committed
583 584
};

585 586

#endif