diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index d5bdde91510416136f123ec4ce5d72026d11cfbd..e498fdf4d39c6c735a164597ed4bb7761bdc19f6 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -101,6 +101,9 @@ SET(VITE_HDRS interface/Interface_graphic.hpp interface/Node_select.hpp interface/viteqtreewidget.hpp + interface/Interval_select.hpp + interface/qxtspanslider.h + interface/qxtspanslider_p.h # Core header core/Core.hpp core/getopt.h @@ -143,6 +146,7 @@ SET(VITE_UIS interface/global_cmd.ui interface/list_of_counter_to_export.ui interface/node_select.ui + interface/interval_select.ui ) SET(VITE_SRCS @@ -214,6 +218,8 @@ SET(VITE_SRCS interface/Interface_graphic.cpp interface/Node_select.cpp interface/viteqtreewidget.cpp + interface/Interval_select.cpp + interface/qxtspanslider.cpp # Plugin code file plugin/Command_window.cpp plugin/Plugin_window.cpp diff --git a/src/common/Info.cpp b/src/common/Info.cpp index 16fbe4621a343eac2df9bb6f87b53acae5fbec87..cf5593df2af5d656f5faf655bbfaaf8b1456571c 100644 --- a/src/common/Info.cpp +++ b/src/common/Info.cpp @@ -69,6 +69,8 @@ bool Info::Render::_key_alt = false; bool Info::Render::_key_ctrl = false; Element_pos Info::Render::_x_min_visible = 0.0; Element_pos Info::Render::_x_max_visible = 0.0; +Element_pos Info::Render::_x_min = 0.0; +Element_pos Info::Render::_x_max = 0.0; Element_pos Info::Render::_info_x = 0.0; Element_pos Info::Render::_info_y = 0.0; @@ -84,8 +86,8 @@ bool Info::Splitter::load_splitted = false; bool Info::Splitter::preview = false; std::string Info::Splitter::path ; std::string Info::Splitter::filename ; -Element_pos Info::Splitter::_x_min = 0.; -Element_pos Info::Splitter::_x_max = 0.; +Element_pos Info::Splitter::_x_min = 0.0; +Element_pos Info::Splitter::_x_max = 0.0; int Info::Trace::depth=0; diff --git a/src/common/Info.hpp b/src/common/Info.hpp index b38fc9a294595b6a72d2e9225453aaa74a729784..c50374c438f50681b3fc622d061ca39cc613af11 100644 --- a/src/common/Info.hpp +++ b/src/common/Info.hpp @@ -199,6 +199,16 @@ public: */ static Element_pos _x_min_visible; + /*! + * \brief Contains the trace maximum visible time. + */ + static Element_pos _x_max; + + /*! + * \brief Contains the trace minimum visible time, uncorrected (state width isn't removed) + */ + static Element_pos _x_min; + /*! * \brief Contains the trace maximum visible time. */ diff --git a/src/interface/Interface_graphic.cpp b/src/interface/Interface_graphic.cpp index 86cf166366f222be3fcf4c69468b999d0dcbe619..0b8cf1df0bad997d89427be2c7254e700563da5e 100644 --- a/src/interface/Interface_graphic.cpp +++ b/src/interface/Interface_graphic.cpp @@ -119,6 +119,7 @@ Interface_graphic::Interface_graphic(Core* core, QWidget *parent):QMainWindow(pa _plugin_window = NULL; _ui_settings = NULL; _ui_node_selection=NULL; + _ui_interval_selection=NULL; // _cmd_window = NULL; _cmd_window = new Command_window(this,this); @@ -130,6 +131,13 @@ Interface_graphic::Interface_graphic(Core* core, QWidget *parent):QMainWindow(pa connect(quit, SIGNAL(triggered()), _ui_node_selection, SLOT(close())); } + if (!_ui_interval_selection) { + _ui_interval_selection = new Interval_select(this, 0); + + //connect( _ui_node_selection, SIGNAL(settings_changed()), this, SLOT(update_settings())); + // To close the window when we quit the application + connect(quit, SIGNAL(triggered()), _ui_interval_selection, SLOT(close())); + } // For drag and drop operations setAcceptDrops(true); } @@ -436,6 +444,9 @@ void Interface_graphic::change_zoom_box_value(int new_value){ else{ _ui_zoom_box->setCurrentIndex(index);/* value exists, select it */ } + + //update the interval selection display + if(_ui_interval_selection!=NULL)_ui_interval_selection->update_values(); } @@ -727,6 +738,7 @@ void Interface_graphic::on_close_triggered(){ void Interface_graphic::on_quit_triggered(){ ((QWidget*)_ui_node_selection)->close(); + ((QWidget*)_ui_interval_selection)->close(); ((QWidget*)_ui_help_window)->close(); ((QWidget*)this)->close(); } @@ -863,6 +875,21 @@ void Interface_graphic::on_show_settings_triggered() { //} _ui_node_selection->show(); } + + void Interface_graphic::on_interval_selection_triggered() { + + //if (!_ui_node_selection) { + // _ui_node_selection = new Node_select(this, 0); + if(!_ui_interval_selection->get_trace() && _core->get_trace()){//first use + _ui_interval_selection->set_trace(_core->get_trace()); + + } + //connect( _ui_node_selection, SIGNAL(settings_changed()), this, SLOT(update_settings())); + // To close the window when we quit the application + //connect(quit, SIGNAL(triggered()), _ui_node_selection, SLOT(close())); + //} + _ui_interval_selection->show(); + } void Interface_graphic::on_actionCommand_triggered(){ if(_core->get_trace()){ @@ -1004,6 +1031,9 @@ void Interface_graphic::closeEvent(QCloseEvent *event){ if(_ui_node_selection) _ui_node_selection->close(); + + if(_ui_interval_selection) + _ui_interval_selection->close(); } const std::string Interface_graphic::get_filename() const{ @@ -1018,6 +1048,11 @@ Core * Interface_graphic::get_console(){ Node_select* Interface_graphic::get_node_select(){ return _ui_node_selection; } + +Interval_select* Interface_graphic::get_interval_select(){ + return _ui_interval_selection; +} + void Interface_graphic::update_recent_files_menu() { const QStringList filenames = Session::get_recent_files(); QString absoluteFilename; diff --git a/src/interface/Interface_graphic.hpp b/src/interface/Interface_graphic.hpp index af603d23f57e00dd936f592646d50330a2b37aca..3ba90bf8288679e8279554120e53ff27d063fc89 100644 --- a/src/interface/Interface_graphic.hpp +++ b/src/interface/Interface_graphic.hpp @@ -71,6 +71,7 @@ class QProgressDialog; #include "interface/Interface.hpp" #include "interface/Settings_window.hpp" #include "interface/Node_select.hpp" +#include "interface/Interval_select.hpp" /*! *\brief This class is a graphical interface which creates a window, it inherited from the Interface interface. @@ -224,6 +225,11 @@ class Interface_graphic : public QMainWindow, protected Ui::main_window, public */ Node_select* _ui_node_selection; + /*! + * \brief Dialog box to allow user to select nodes to display + */ + Interval_select* _ui_interval_selection; + /*! * \brief Text area which informs the user about the trace resume. */ @@ -483,6 +489,13 @@ public: */ Node_select* get_node_select(); + + /*! + * \fn get_interval_select() + * \brief To get the node selection console + */ + Interval_select* get_interval_select(); + /*! * \fn update_recent_files_menu() * \brief update the recent files opened menu @@ -607,6 +620,11 @@ protected slots: */ void on_node_selection_triggered(); + /*! + *\brief A slot called when 'Node selection' in the menu is clicked. + */ + void on_interval_selection_triggered(); + /*! * \brief A slot called when 'command' in the menu is clicked. */ diff --git a/src/interface/Interval_select.cpp b/src/interface/Interval_select.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f95b756aa1302adb3a4aa30caa50cc3be6cba02a --- /dev/null +++ b/src/interface/Interval_select.cpp @@ -0,0 +1,325 @@ +/* +** 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 +** +*/ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* -- */ +#include "common/common.hpp" +#include "common/Info.hpp" +#include "common/Message.hpp" +#include "interface/resource.hpp" +#include "interface/Interface.hpp" + +#include "core/Core.hpp" +#include "interface/Interface_graphic.hpp" +/* -- */ +#include "trace/values/Values.hpp" +#include "trace/EntityValue.hpp" +#include "trace/EntityTypes.hpp" +#include "trace/Entitys.hpp" +#include "trace/tree/Interval.hpp" +#include "trace/Container.hpp" +/* -- */ +#include + +#include "interface/Interval_select.hpp" + +using namespace std; + +Interval_select::Interval_select(Interface_graphic * console,QWidget *parent) : QDialog(parent), _trace(NULL),_console(console) { + setupUi(this); + connect( minSpinBox, SIGNAL(valueChanged( double )), SLOT(minSpinBoxValueChanged( double ) ) ); + connect( interval_slider, SIGNAL(lowerValueChanged( int )), SLOT(minSliderValueChanged( int ) ) ); + connect( maxSpinBox, SIGNAL(valueChanged( double )), SLOT(maxSpinBoxValueChanged( double ) ) ); + connect( interval_slider, SIGNAL(upperValueChanged( int )), SLOT(maxSliderValueChanged( int ) ) ); + QMetaObject::connectSlotsByName(NULL); + _auto_refresh=auto_refresh_box->isChecked();//true by default + _applied=false; + //interval_slider->setHandleMovementMode(QxtSpanSlider::NoOverlapping); +} + +Interval_select::~Interval_select() { +} + +Trace* Interval_select::get_trace() { + return _trace; +} + +void Interval_select::set_trace(Trace *trace) { + // Initialize _trace + _trace = trace; + //double max =_trace->get_max_date().get_value(); + min_value->setText(QString().setNum (Info::Entity::x_min)); + max_value->setText(QString().setNum (Info::Entity::x_max)); + minSpinBox->setMinimum(Info::Entity::x_min); + minSpinBox->setMaximum(Info::Entity::x_max); + maxSpinBox->setMinimum(Info::Entity::x_min); + maxSpinBox->setMaximum(Info::Entity::x_max); + //the slider stays in int, we will translate its values + /*interval_slider->setMinimum(0); + interval_slider->setMaximum(99);*/ + + double delta=Info::Entity::x_max-Info::Entity::x_min; + double step= 0.001*delta; //make steps of .1% for spinboxes + minSpinBox->setSingleStep(step); + maxSpinBox->setSingleStep(step); + + update_values(); +} + +//called if a zoom is triggered outside of the window, to update slider position and spinboxes with the real values +void Interval_select::update_values() { + + if(_trace!=NULL){//if init + +Element_pos _min; +Element_pos _max; + +//choose which value to load the actual position from (can change if we are loading from a splitted file set) +if(Info::Splitter::preview==true){ + _min=Info::Entity::x_min; + _max=Info::Entity::x_max; +}else if(Info::Splitter::load_splitted==true){ + Info::Render::_x_min=Info::Splitter::_x_min; + Info::Render::_x_max=Info::Splitter::_x_max; + auto_refresh_box->setChecked(false);//set the checkbox to false because reload is expensive for splitted mode + _min=Info::Splitter::_x_min; + _max=Info::Splitter::_x_max; +}else{ + _min=Info::Render::_x_min; + _max=Info::Render::_x_max; + } + bool v = minSpinBox->blockSignals(true); + bool v2 = maxSpinBox->blockSignals(true); + bool v3 = interval_slider->blockSignals(true); + int maxvalue=int(_max*(interval_slider->maximum() - interval_slider->minimum())/(minSpinBox->maximum() - minSpinBox->minimum())); + interval_slider->setUpperValue(maxvalue); + interval_slider->setLowerValue(int(_min*(interval_slider->maximum() - interval_slider->minimum())/(minSpinBox->maximum() - minSpinBox->minimum()))); + maxSpinBox->setValue(_max); + minSpinBox->setValue(_min); + minSpinBox->blockSignals(v); + maxSpinBox->blockSignals(v2); + interval_slider->blockSignals(v3); + _applied=false; + } +} + + +void Interval_select::minSpinBoxValueChanged( double _value ) +{ + QPalette myPalette(minSpinBox->palette()); + + if(_value < maxSpinBox->value()){ + + bool v = interval_slider->blockSignals(true); + interval_slider->setLowerValue( int(_value *(interval_slider->maximum() - interval_slider->minimum())/(minSpinBox->maximum() - minSpinBox->minimum())) ); + + interval_slider->blockSignals(v); + emit( minValueChanged( minSpinBox->value() ) ); + myPalette.setColor(QPalette::Active, QPalette::Text, Qt::black); + myPalette.setColor(QPalette::Active, QPalette::HighlightedText, Qt::white); + + if(_auto_refresh)apply_settings(); + }else{ + //min cannot be greater than max + //set the incorrect value to red, but don't change it in order to let the user type a full correct value + myPalette.setColor(QPalette::Active, QPalette::Text, Qt::red); + myPalette.setColor(QPalette::Active, QPalette::HighlightedText, Qt::red); + //minSliderValueChanged( maxSpinBox->value() ); + } + + minSpinBox->setPalette(myPalette); + maxSpinBox->setPalette(myPalette); + + _applied=false; + +} + +void Interval_select::minSliderValueChanged( int _value ) +{ + if(_value < interval_slider->upperValue()){ + bool v = minSpinBox->blockSignals(true); + minSpinBox->setValue( _value *(minSpinBox->maximum() - minSpinBox->minimum())/(interval_slider->maximum() - interval_slider->minimum())); + minSpinBox->blockSignals(v); + emit( minValueChanged( minSpinBox->value() ) ); + if(_auto_refresh)apply_settings(); + } + _applied=false; +} + +void Interval_select::maxSpinBoxValueChanged( double _value ) +{ + QPalette myPalette(minSpinBox->palette()); + if(_value > minSpinBox->value()){ + bool v = interval_slider->blockSignals(true); + interval_slider->setUpperValue( int(_value* (interval_slider->maximum() - interval_slider->minimum())/(maxSpinBox->maximum() - maxSpinBox->minimum()))); + interval_slider->blockSignals(v); + emit( maxValueChanged( maxSpinBox->value() ) ); + myPalette.setColor(QPalette::Active, QPalette::Text, Qt::black); + myPalette.setColor(QPalette::Active, QPalette::HighlightedText, Qt::white); + if(_auto_refresh)apply_settings(); + }else{ + //max cannot be lower than min + + myPalette.setColor(QPalette::Active, QPalette::Text, Qt::red); + myPalette.setColor(QPalette::Active, QPalette::HighlightedText, Qt::red); + //maxSliderValueChanged( minSpinBox->value() ) ; + } + maxSpinBox->setPalette(myPalette); + minSpinBox->setPalette(myPalette); + _applied=false; +} + +void Interval_select::maxSliderValueChanged( int _value ) +{ + + if(_value > interval_slider->lowerValue()){ + bool v = maxSpinBox->blockSignals(true); + maxSpinBox->setValue( _value * (maxSpinBox->maximum() - maxSpinBox->minimum())/(interval_slider->maximum() - interval_slider->minimum())); + maxSpinBox->blockSignals(v); + emit( maxValueChanged( maxSpinBox->value() ) ); + if(_auto_refresh)apply_settings(); + } + _applied=false; +} + + +void Interval_select::apply_settings(){ + if(minSpinBox->value()!=maxSpinBox->value()){ + Element_pos zoom[2]={minSpinBox->value(), maxSpinBox->value()}; + + Info::Render::_x_min_visible = 0.0; + Info::Render::_x_max_visible = 0.0; + _console->get_console()->launch_action(Core:: _STATE_CLEAN_RENDER_AREA); + + //reload data from disk if needed + #if defined(USE_ITC) && defined(BOOST_SERIALIZE) + Info::Splitter::_x_min=zoom[0]; + Info::Splitter::_x_max=zoom[1]; + _trace->updateTrace(new Interval(zoom[0], zoom[1])); + #endif + + _console->get_console()->draw_trace(_console->get_filename(),Core::_DRAW_OPENGL); + + _console->get_console()->launch_action(Core:: _STATE_ZOOM_IN_AN_INTERVAL, &zoom); + _console->get_console()->launch_action(Core:: _STATE_RENDER_UPDATE); + } +} + + +void Interval_select::on_apply_button_clicked(){ + apply_settings(); + _applied=true; +} + +void Interval_select::on_cancel_button_clicked(){ + hide(); +} + +void Interval_select::on_ok_button_clicked(){ + + if(!_applied)on_apply_button_clicked(); + hide(); +} + + +void Interval_select::on_reset_button_clicked(){ + //maxValueChanged( interval_slider->maximum() ); + //minValueChanged( interval_slider->minimum() ); + interval_slider->setUpperValue(interval_slider->maximum()); + interval_slider->setLowerValue(interval_slider->minimum()); + //maxSliderValueChanged( interval_slider->maximum() ); + //minSliderValueChanged( interval_slider->minimum() ); +} + + +void Interval_select::on_auto_refresh_box_stateChanged(){ + _auto_refresh=auto_refresh_box->isChecked(); +} + +/* +void Stats_window::init() { + // We set the names of the containers for the tree widget + _nodes_selected->clear(); + set_container_names(); + + // We init the times + _start_time = Info::Render::_x_min_visible; + _end_time = Info::Render::_x_max_visible; + + QString temp; + temp.setNum(_start_time); + _start_time_widget->setText(temp); + temp.setNum(_end_time); + _end_time_widget->setText(temp); + + _ui_stats_area->clear(); + Reinit_scroll_bars(); +} + +void Stats_window::clear() { + _ui_stats_area->makeCurrent(); + _nodes_selected->clear(); + _ui_stats_area->clear(); + _kind_of_state_box->clear(); + Reinit_scroll_bars(); + _ui_stats_area->doneCurrent(); +} + +void Stats_window::set_arguments(std::map) { +} + +void Stats_window::execute() { + on_reload_button_clicked(); +} + +string Stats_window::get_name() { + return "Statistics window"; +}*/ diff --git a/src/interface/Interval_select.hpp b/src/interface/Interval_select.hpp new file mode 100644 index 0000000000000000000000000000000000000000..48b40ddb03ba1abbcce6b322842dab199cd6235f --- /dev/null +++ b/src/interface/Interval_select.hpp @@ -0,0 +1,135 @@ +/* +** 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 Interval_select.hpp + */ + +#ifndef INTERVAL_SELECT_HPP +#define INTERVAL_SELECT_HPP + +class Interval_select; + +/* For moc compilation */ +#include +#include +#include +/* -- */ +#include +#include "ui_interval_select.h" + +#include "trace/values/Values.hpp" +#include "trace/EntityValue.hpp" +#include "trace/EntityTypes.hpp" +#include "trace/Entitys.hpp" +#include "trace/tree/Interval.hpp" +#include "trace/Trace.hpp" + +#include "interface/Interface_graphic.hpp" + +/* -- */ + + + + +/*! + * \class Node select + * \brief Class used to select which containers should be displayed + * + */ + +class Interval_select : public QDialog, protected Ui::interval_selector { + + Q_OBJECT + + private: + + Trace* _trace; + Interface_graphic *_console; + bool _applied; + bool _auto_refresh; +public: + /*! + * Default constructor + * \param parent The parent widget of the window. + */ + Interval_select( Interface_graphic *console, QWidget *parent = 0); + + ~Interval_select(); + + /*! + * \fn set_trace(Trace *trace) + * \brief Set the trace parsed (give the container names) + * \param trace The trace. + */ + void set_trace(Trace *trace); + + /*! + * \fn get_trace() + * \brief returns the trace + */ + Trace * get_trace(); + + void apply_settings(); + void update_values(); + + + private slots: + void minSpinBoxValueChanged( double value ); + void minSliderValueChanged( int value ); + void maxSpinBoxValueChanged( double value ); + void maxSliderValueChanged( int value ); + + void on_ok_button_clicked(); + void on_cancel_button_clicked(); + void on_reset_button_clicked(); + void on_apply_button_clicked(); + void on_auto_refresh_box_stateChanged(); + +signals: + void minValueChanged( double value ); + void maxValueChanged( double value ); + + +}; + +#endif // INTERVAL_SELECT_HPP diff --git a/src/interface/Node_select.cpp b/src/interface/Node_select.cpp index 992fd25e5a59cf327463e9272f5f33528c925c27..4e97c5904f13455f7a4d53a31c2f75f07de3fa25 100644 --- a/src/interface/Node_select.cpp +++ b/src/interface/Node_select.cpp @@ -260,7 +260,7 @@ void Stats_window::set_selected_nodes(string kind_of_state){ _nodes_displayed->clear(); //can we load that from _nodes_original instead ? set_displayed_container_names(); - Element_pos zoom[2]={Info::Render::_x_min_visible, Info::Render::_x_max_visible}; + Element_pos zoom[2]={Info::Render::_x_min, Info::Render::_x_max}; Info::Render::_x_min_visible = 0.0; Info::Render::_x_max_visible = 0.0; _trace->set_view_root_containers(_displayed_containers); @@ -335,7 +335,7 @@ void Node_select::on_load_button_clicked(){ build_displayed_nodes(_displayed_containers); _trace->set_view_root_containers(_displayed_containers); - Element_pos it[2]={Info::Render::_x_min_visible, Info::Render::_x_max_visible}; + Element_pos it[2]={Info::Render::_x_min, Info::Render::_x_max}; Info::Render::_x_min_visible = 0.0; Info::Render::_x_max_visible = 0.0; diff --git a/src/interface/Node_select.hpp b/src/interface/Node_select.hpp index 39f67ef2a9eb0eecf290f78dc661236c2138a4b1..c619ed1dfe9f388c8ad22240489ad06f3ad4503d 100644 --- a/src/interface/Node_select.hpp +++ b/src/interface/Node_select.hpp @@ -189,7 +189,6 @@ private slots: void on_export_button_clicked(); void on_load_button_clicked(); -public slots: // just for testing, remove void on_display_button_clicked(); }; diff --git a/src/interface/interval_select.ui b/src/interface/interval_select.ui new file mode 100644 index 0000000000000000000000000000000000000000..15416abc8de9453e84011d6010bcf4cb0e903a78 --- /dev/null +++ b/src/interface/interval_select.ui @@ -0,0 +1,220 @@ + + + interval_selector + + + + 0 + 0 + 522 + 283 + + + + + 0 + 0 + + + + + 522 + 283 + + + + Interval Selection + + + + + 60 + 140 + 401 + 20 + + + + Qt::Horizontal + + + + + + 140 + 80 + 101 + 22 + + + + + + + 350 + 80 + 101 + 22 + + + + + + + 30 + 140 + 21 + 16 + + + + Min + + + + + + 470 + 140 + 31 + 16 + + + + Max + + + + + + 10 + 160 + 46 + 13 + + + + 0 + + + + + + 460 + 160 + 46 + 13 + + + + 0 + + + + + + 60 + 80 + 81 + 16 + + + + New min value : + + + + + + 270 + 80 + 81 + 16 + + + + New max value : + + + + + + 300 + 240 + 75 + 23 + + + + OK + + + + + + 390 + 240 + 75 + 23 + + + + Cancel + + + + + + 120 + 240 + 75 + 23 + + + + Reset + + + + + + 210 + 240 + 75 + 23 + + + + Apply + + + + + true + + + + 350 + 180 + 171 + 17 + + + + Auto Refresh (disable if slow) + + + true + + + + + + QxtSpanSlider + QSlider +
interface/qxtspanslider.h
+ + + + + diff --git a/src/interface/main_window.ui b/src/interface/main_window.ui index 1b566645c451d867156ea3ca00340a4d4eb430fa..0b33d4fe76d431ffe102700559526258c1e0957d 100644 --- a/src/interface/main_window.ui +++ b/src/interface/main_window.ui @@ -249,6 +249,7 @@ + @@ -536,6 +537,11 @@ Node Selection + + + Interval Selection + + true diff --git a/src/interface/qxtpimpl.h b/src/interface/qxtpimpl.h new file mode 100644 index 0000000000000000000000000000000000000000..52a52a894d15d372e88e39d25a896e75a8956788 --- /dev/null +++ b/src/interface/qxtpimpl.h @@ -0,0 +1,189 @@ +/**************************************************************************** +** +** Copyright (C) Adam Higerd . Some rights reserved. +** +** This file is part of the QxtCore module of the +** Qt eXTension library +** +** This library is free software; you can redistribute it and/or +** modify it under the terms of the GNU Lesser General Public +** License as published by the Free Software Foundation; either +** version 2.1 of the License, or any later version. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** There is aditional information in the LICENSE file of libqxt. +** If you did not receive a copy of the file try to download it or +** contact the libqxt Management +** +****************************************************************************/ +/** +\class QxtPimpl QxtPimpl +\ingroup core +\brief Hide private details of a class + +Application code generally doesn't have to be concerned about hiding its +implementation details, but when writing library code it is important to +maintain a constant interface, both source and binary. Maintaining a constant +source interface is easy enough, but keeping the binary interface constant +means moving implementation details into a private class. The PIMPL, or +d-pointer, idiom is a common method of implementing this separation. QxtPimpl +offers a convenient way to connect the public and private sides of your class. + +\section start Getting Started +Before you declare the public class, you need to make a forward declaration +of the private class. The private class must have the same name as the public +class, followed by the word Private. For example, a class named MyTest would +declare the private class with: +\code +class MyTestPrivate; +\endcode + +\subsection pub The Public Class +Generally, you shouldn't keep any data members in the public class without a +good reason. Functions that are part of the public interface should be declared +in the public class, and functions that need to be available to subclasses (for +calling or overriding) should be in the protected section of the public class. +To connect the private class to the public class, include the +QXT_DECLARE_PRIVATE macro in the private section of the public class. In the +example above, the private class is connected as follows: +\code +private: + QXT_DECLARE_PRIVATE(MyTest); +\endcode + +Additionally, you must include the QXT_INIT_PRIVATE macro in the public class's +constructor. Continuing with the MyTest example, your constructor might look +like this: +\code +MyTest::MyTest() { + // initialization + QXT_INIT_PRIVATE(MyTest); +} +\endcode + +\subsection priv The Private Class +As mentioned above, data members should usually be kept in the private class. +This allows the memory layout of the private class to change without breaking +binary compatibility for the public class. Functions that exist only as +implementation details, or functions that need access to private data members, +should be implemented here. + +To define the private class, inherit from the template QxtPrivate class, and +include the QXT_DECLARE_PUBLIC macro in its public section. The template +parameter should be the name of the public class. For example: +\code +class MyTestPrivate : public QxtPrivate { +public: + MyTestPrivate(); + QXT_DECLARE_PUBLIC(MyTest); +}; +\endcode + +\section cross Accessing Private Members +Use the qxt_d() function (actually a function-like object) from functions in +the public class to access the private class. Similarly, functions in the +private class can invoke functions in the public class by using the qxt_p() +function (this one's actually a function). + +For example, assume that MyTest has methods named getFoobar and doBaz(), +and MyTestPrivate has a member named foobar and a method named doQuux(). +The code might resemble this example: +\code +int MyTest::getFoobar() { + return qxt_d().foobar; +} + +void MyTestPrivate::doQuux() { + qxt_p().doBaz(foobar); +} +\endcode +*/ + +#ifndef QXTPIMPL_H +#define QXTPIMPL_H + +/*! \relates QxtPimpl + * Declares that a public class has a related private class. + * + * This shuold be put in the private section of the public class. The parameter is the name of the public class. + */ +#define QXT_DECLARE_PRIVATE(PUB) friend class PUB##Private; QxtPrivateInterface qxt_d; +/*! \relates QxtPimpl + * Declares that a private class has a related public class. + * + * This may be put anywhere in the declaration of the private class. The parameter is the name of the public class. + */ +#define QXT_DECLARE_PUBLIC(PUB) friend class PUB; +/*! \relates QxtPimpl + * Initializes resources owned by the private class. + * + * This should be called from the public class's constructor, + * before qxt_d() is used for the first time. The parameter is the name of the public class. + */ +#define QXT_INIT_PRIVATE(PUB) qxt_d.setPublic(this); + +#ifdef QXT_DOXYGEN_RUN +/*! \relates QxtPimpl + * Returns a reference to the private class. + * + * This function is only available in a class using \a QXT_DECLARE_PRIVATE. + */ +QxtPrivate& qxt_d(); + +/*! \relates QxtPimpl + * Returns a const reference to the private class. + * + * This function is only available in a class using \a QXT_DECLARE_PRIVATE. + * This overload will be automatically used in const functions. + */ +const QxtPrivate& qxt_d(); + +/*! \relates QxtPimpl + * Returns a reference to the public class. + * + * This function is only available in a class using \a QXT_DECLARE_PUBLIC. + */ +PUB& qxt_p(); + +/*! \relates QxtPimpl + * Returns a const reference to the public class. + * + * This function is only available in a class using \a QXT_DECLARE_PUBLIC. + * This overload will be automatically used in const functions. + */ +const PUB& qxt_p(); +#endif + +#ifndef QXT_DOXYGEN_RUN +template +class QxtPrivate { +public: + virtual ~QxtPrivate() {} + inline void QXT_setPublic(PUB* pub) { qxt_p_ptr = pub; } + +protected: + inline PUB& qxt_p() { return *qxt_p_ptr; } + inline const PUB& qxt_p() const { return *qxt_p_ptr; } + +private: + PUB* qxt_p_ptr; +}; + +template +class QxtPrivateInterface { +friend class QxtPrivate; +public: + QxtPrivateInterface() { pvt = new PVT; } + ~QxtPrivateInterface() { delete pvt; } + + inline void setPublic(PUB* pub) { pvt->QXT_setPublic(pub); } + inline PVT& operator()() { return *static_cast(pvt); } + inline const PVT& operator()() const { return *static_cast(pvt); } +private: + QxtPrivate* pvt; +}; +#endif + +#endif \ No newline at end of file diff --git a/src/interface/qxtspanslider.cpp b/src/interface/qxtspanslider.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1c72fbee4053d71f27efcbfe0db118608804efe4 --- /dev/null +++ b/src/interface/qxtspanslider.cpp @@ -0,0 +1,744 @@ +/**************************************************************************** + ** + ** Copyright (C) Qxt Foundation. Some rights reserved. + ** + ** This file is part of the QxtGui module of the Qxt library. + ** + ** This library is free software; you can redistribute it and/or modify it + ** under the terms of the Common Public License, version 1.0, as published + ** by IBM, and/or under the terms of the GNU Lesser General Public License, + ** version 2.1, as published by the Free Software Foundation. + ** + ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY + ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY + ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR + ** FITNESS FOR A PARTICULAR PURPOSE. + ** + ** You should have received a copy of the CPL and the LGPL along with this + ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files + ** included with the source distribution for more information. + ** If you did not receive a copy of the licenses, contact the Qxt Foundation. + ** + ** + ** + ****************************************************************************/ +#include "qxtspanslider.h" +#include "qxtspanslider_p.h" +#include +#include +#include +#include +#include + +QxtSpanSliderPrivate::QxtSpanSliderPrivate() : + lower(0), + upper(0), + lowerPos(0), + upperPos(0), + offset(0), + position(0), + lastPressed(QxtSpanSlider::NoHandle), + mainControl(QxtSpanSlider::LowerHandle), + lowerPressed(QStyle::SC_None), + upperPressed(QStyle::SC_None), + movement(QxtSpanSlider::FreeMovement), + firstMovement(false), + blockTracking(false) +{ +} + +void QxtSpanSliderPrivate::initStyleOption(QStyleOptionSlider* option, QxtSpanSlider::SpanHandle handle) const +{ + const QxtSpanSlider* p = &qxt_p(); + p->initStyleOption(option); + option->sliderPosition = (handle == QxtSpanSlider::LowerHandle ? lowerPos : upperPos); + option->sliderValue = (handle == QxtSpanSlider::LowerHandle ? lower : upper); +} + +int QxtSpanSliderPrivate::pixelPosToRangeValue(int pos) const +{ + QStyleOptionSlider opt; + initStyleOption(&opt); + + int sliderMin = 0; + int sliderMax = 0; + int sliderLength = 0; + const QSlider* p = &qxt_p(); + const QRect gr = p->style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderGroove, p); + const QRect sr = p->style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, p); + if (p->orientation() == Qt::Horizontal) + { + sliderLength = sr.width(); + sliderMin = gr.x(); + sliderMax = gr.right() - sliderLength + 1; + } + else + { + sliderLength = sr.height(); + sliderMin = gr.y(); + sliderMax = gr.bottom() - sliderLength + 1; + } + return QStyle::sliderValueFromPosition(p->minimum(), p->maximum(), pos - sliderMin, + sliderMax - sliderMin, opt.upsideDown); +} + +void QxtSpanSliderPrivate::handleMousePress(const QPoint& pos, QStyle::SubControl& control, int value, QxtSpanSlider::SpanHandle handle) +{ + QStyleOptionSlider opt; + initStyleOption(&opt, handle); + QxtSpanSlider* p = &qxt_p(); + const QStyle::SubControl oldControl = control; + control = p->style()->hitTestComplexControl(QStyle::CC_Slider, &opt, pos, p); + const QRect sr = p->style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, p); + if (control == QStyle::SC_SliderHandle) + { + position = value; + offset = pick(pos - sr.topLeft()); + lastPressed = handle; + p->setSliderDown(true); + emit p->sliderPressed(handle); + } + if (control != oldControl) + p->update(sr); +} + +void QxtSpanSliderPrivate::setupPainter(QPainter* painter, Qt::Orientation orientation, qreal x1, qreal y1, qreal x2, qreal y2) const +{ + QColor highlight = qxt_p().palette().color(QPalette::Highlight); + QLinearGradient gradient(x1, y1, x2, y2); + gradient.setColorAt(0, highlight.dark(120)); + gradient.setColorAt(1, highlight.light(108)); + painter->setBrush(gradient); + + if (orientation == Qt::Horizontal) + painter->setPen(QPen(highlight.dark(130), 0)); + else + painter->setPen(QPen(highlight.dark(150), 0)); +} + +void QxtSpanSliderPrivate::drawSpan(QStylePainter* painter, const QRect& rect) const +{ + QStyleOptionSlider opt; + initStyleOption(&opt); + const QSlider* p = &qxt_p(); + + // area + QRect groove = p->style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderGroove, p); + if (opt.orientation == Qt::Horizontal) + groove.adjust(0, 0, -1, 0); + else + groove.adjust(0, 0, 0, -1); + + // pen & brush + painter->setPen(QPen(p->palette().color(QPalette::Dark).light(110), 0)); + if (opt.orientation == Qt::Horizontal) + setupPainter(painter, opt.orientation, groove.center().x(), groove.top(), groove.center().x(), groove.bottom()); + else + setupPainter(painter, opt.orientation, groove.left(), groove.center().y(), groove.right(), groove.center().y()); + + // draw groove + painter->drawRect(rect.intersected(groove)); +} + +void QxtSpanSliderPrivate::drawHandle(QStylePainter* painter, QxtSpanSlider::SpanHandle handle) const +{ + QStyleOptionSlider opt; + initStyleOption(&opt, handle); + opt.subControls = QStyle::SC_SliderHandle; + QStyle::SubControl pressed = (handle == QxtSpanSlider::LowerHandle ? lowerPressed : upperPressed); + if (pressed == QStyle::SC_SliderHandle) + { + opt.activeSubControls = pressed; + opt.state |= QStyle::State_Sunken; + } + painter->drawComplexControl(QStyle::CC_Slider, opt); +} + +void QxtSpanSliderPrivate::triggerAction(QAbstractSlider::SliderAction action, bool main) +{ + int value = 0; + bool no = false; + bool up = false; + const int min = qxt_p().minimum(); + const int max = qxt_p().maximum(); + const QxtSpanSlider::SpanHandle altControl = (mainControl == QxtSpanSlider::LowerHandle ? QxtSpanSlider::UpperHandle : QxtSpanSlider::LowerHandle); + + blockTracking = true; + + switch (action) + { + case QAbstractSlider::SliderSingleStepAdd: + if ((main && mainControl == QxtSpanSlider::UpperHandle) || (!main && altControl == QxtSpanSlider::UpperHandle)) + { + value = qBound(min, upper + qxt_p().singleStep(), max); + up = true; + break; + } + value = qBound(min, lower + qxt_p().singleStep(), max); + break; + case QAbstractSlider::SliderSingleStepSub: + if ((main && mainControl == QxtSpanSlider::UpperHandle) || (!main && altControl == QxtSpanSlider::UpperHandle)) + { + value = qBound(min, upper - qxt_p().singleStep(), max); + up = true; + break; + } + value = qBound(min, lower - qxt_p().singleStep(), max); + break; + case QAbstractSlider::SliderToMinimum: + value = min; + if ((main && mainControl == QxtSpanSlider::UpperHandle) || (!main && altControl == QxtSpanSlider::UpperHandle)) + up = true; + break; + case QAbstractSlider::SliderToMaximum: + value = max; + if ((main && mainControl == QxtSpanSlider::UpperHandle) || (!main && altControl == QxtSpanSlider::UpperHandle)) + up = true; + break; + case QAbstractSlider::SliderMove: + if ((main && mainControl == QxtSpanSlider::UpperHandle) || (!main && altControl == QxtSpanSlider::UpperHandle)) + up = true; + case QAbstractSlider::SliderNoAction: + no = true; + break; + default: + qWarning("QxtSpanSliderPrivate::triggerAction: Unknown action"); + break; + } + + if (!no && !up) + { + if (movement == QxtSpanSlider::NoCrossing) + value = qMin(value, upper); + else if (movement == QxtSpanSlider::NoOverlapping) + value = qMin(value, upper - 1); + + if (movement == QxtSpanSlider::FreeMovement && value > upper) + { + swapControls(); + qxt_p().setUpperPosition(value); + } + else + { + qxt_p().setLowerPosition(value); + } + } + else if (!no) + { + if (movement == QxtSpanSlider::NoCrossing) + value = qMax(value, lower); + else if (movement == QxtSpanSlider::NoOverlapping) + value = qMax(value, lower + 1); + + if (movement == QxtSpanSlider::FreeMovement && value < lower) + { + swapControls(); + qxt_p().setLowerPosition(value); + } + else + { + qxt_p().setUpperPosition(value); + } + } + + blockTracking = false; + qxt_p().setLowerValue(lowerPos); + qxt_p().setUpperValue(upperPos); +} + +void QxtSpanSliderPrivate::swapControls() +{ + qSwap(lower, upper); + qSwap(lowerPressed, upperPressed); + lastPressed = (lastPressed == QxtSpanSlider::LowerHandle ? QxtSpanSlider::UpperHandle : QxtSpanSlider::LowerHandle); + mainControl = (mainControl == QxtSpanSlider::LowerHandle ? QxtSpanSlider::UpperHandle : QxtSpanSlider::LowerHandle); +} + +void QxtSpanSliderPrivate::updateRange(int min, int max) +{ + Q_UNUSED(min); + Q_UNUSED(max); + // setSpan() takes care of keeping span in range + qxt_p().setSpan(lower, upper); +} + +void QxtSpanSliderPrivate::movePressedHandle() +{ + switch (lastPressed) + { + case QxtSpanSlider::LowerHandle: + if (lowerPos != lower) + { + bool main = (mainControl == QxtSpanSlider::LowerHandle); + triggerAction(QAbstractSlider::SliderMove, main); + } + break; + case QxtSpanSlider::UpperHandle: + if (upperPos != upper) + { + bool main = (mainControl == QxtSpanSlider::UpperHandle); + triggerAction(QAbstractSlider::SliderMove, main); + } + break; + default: + break; + } +} + +/*! + \class QxtSpanSlider + \inmodule QxtGui + \brief The QxtSpanSlider widget is a QSlider with two handles. + + QxtSpanSlider is a slider with two handles. QxtSpanSlider is + handy for letting user to choose an span between min/max. + + The span color is calculated based on QPalette::Highlight. + + The keys are bound according to the following table: + \table + \header \o Orientation \o Key \o Handle + \row \o Qt::Horizontal \o Qt::Key_Left \o lower + \row \o Qt::Horizontal \o Qt::Key_Right \o lower + \row \o Qt::Horizontal \o Qt::Key_Up \o upper + \row \o Qt::Horizontal \o Qt::Key_Down \o upper + \row \o Qt::Vertical \o Qt::Key_Up \o lower + \row \o Qt::Vertical \o Qt::Key_Down \o lower + \row \o Qt::Vertical \o Qt::Key_Left \o upper + \row \o Qt::Vertical \o Qt::Key_Right \o upper + \endtable + + Keys are bound by the time the slider is created. A key is bound + to same handle for the lifetime of the slider. So even if the handle + representation might change from lower to upper, the same key binding + remains. + + \image qxtspanslider.png "QxtSpanSlider in Plastique style." + + \bold {Note:} QxtSpanSlider inherits QSlider for implementation specific + reasons. Adjusting any single handle specific properties like + \list + \o QAbstractSlider::sliderPosition + \o QAbstractSlider::value + \endlist + has no effect. However, all slider specific properties like + \list + \o QAbstractSlider::invertedAppearance + \o QAbstractSlider::invertedControls + \o QAbstractSlider::minimum + \o QAbstractSlider::maximum + \o QAbstractSlider::orientation + \o QAbstractSlider::pageStep + \o QAbstractSlider::singleStep + \o QSlider::tickInterval + \o QSlider::tickPosition + \endlist + are taken into consideration. + */ + +/*! + \enum QxtSpanSlider::HandleMovementMode + + This enum describes the available handle movement modes. + + \value FreeMovement The handles can be moved freely. + \value NoCrossing The handles cannot cross, but they can still overlap each other. The lower and upper values can be the same. + \value NoOverlapping The handles cannot overlap each other. The lower and upper values cannot be the same. + */ + +/*! + \enum QxtSpanSlider::SpanHandle + + This enum describes the available span handles. + + \omitvalue NoHandle \omit Internal only (for now). \endomit + \value LowerHandle The lower boundary handle. + \value UpperHandle The upper boundary handle. + */ + +/*! + \fn QxtSpanSlider::lowerValueChanged(int lower) + + This signal is emitted whenever the \a lower value has changed. + */ + +/*! + \fn QxtSpanSlider::upperValueChanged(int upper) + + This signal is emitted whenever the \a upper value has changed. + */ + +/*! + \fn QxtSpanSlider::spanChanged(int lower, int upper) + + This signal is emitted whenever both the \a lower and the \a upper + values have changed ie. the span has changed. + */ + +/*! + \fn QxtSpanSlider::lowerPositionChanged(int lower) + + This signal is emitted whenever the \a lower position has changed. + */ + +/*! + \fn QxtSpanSlider::upperPositionChanged(int upper) + + This signal is emitted whenever the \a upper position has changed. + */ + +/*! + \fn QxtSpanSlider::sliderPressed(SpanHandle handle) + + This signal is emitted whenever the \a handle has been pressed. + */ + +/*! + Constructs a new QxtSpanSlider with \a parent. + */ +QxtSpanSlider::QxtSpanSlider(QWidget* parent) : QSlider(parent) +{ + QXT_INIT_PRIVATE(QxtSpanSlider); + connect(this, SIGNAL(rangeChanged(int, int)), &qxt_d(), SLOT(updateRange(int, int))); + connect(this, SIGNAL(sliderReleased()), &qxt_d(), SLOT(movePressedHandle())); +} + +/*! + Constructs a new QxtSpanSlider with \a orientation and \a parent. + */ +QxtSpanSlider::QxtSpanSlider(Qt::Orientation orientation, QWidget* parent) : QSlider(orientation, parent) +{ + QXT_INIT_PRIVATE(QxtSpanSlider); + connect(this, SIGNAL(rangeChanged(int, int)), &qxt_d(), SLOT(updateRange(int, int))); + connect(this, SIGNAL(sliderReleased()), &qxt_d(), SLOT(movePressedHandle())); +} + +/*! + Destructs the span slider. + */ +QxtSpanSlider::~QxtSpanSlider() +{ +} + +/*! + \property QxtSpanSlider::handleMovementMode + \brief the handle movement mode + */ +QxtSpanSlider::HandleMovementMode QxtSpanSlider::handleMovementMode() const +{ + return qxt_d().movement; +} + +void QxtSpanSlider::setHandleMovementMode(QxtSpanSlider::HandleMovementMode mode) +{ + qxt_d().movement = mode; +} + +/*! + \property QxtSpanSlider::lowerValue + \brief the lower value of the span + */ +int QxtSpanSlider::lowerValue() const +{ + return qMin(qxt_d().lower, qxt_d().upper); +} + +void QxtSpanSlider::setLowerValue(int lower) +{ + setSpan(lower, qxt_d().upper); +} + +/*! + \property QxtSpanSlider::upperValue + \brief the upper value of the span + */ +int QxtSpanSlider::upperValue() const +{ + return qMax(qxt_d().lower, qxt_d().upper); +} + +void QxtSpanSlider::setUpperValue(int upper) +{ + setSpan(qxt_d().lower, upper); +} + +/*! + Sets the span from \a lower to \a upper. + */ +void QxtSpanSlider::setSpan(int lower, int upper) +{ + const int low = qBound(minimum(), qMin(lower, upper), maximum()); + const int upp = qBound(minimum(), qMax(lower, upper), maximum()); + if (low != qxt_d().lower || upp != qxt_d().upper) + { + if (low != qxt_d().lower) + { + qxt_d().lower = low; + qxt_d().lowerPos = low; + emit lowerValueChanged(low); + } + if (upp != qxt_d().upper) + { + qxt_d().upper = upp; + qxt_d().upperPos = upp; + emit upperValueChanged(upp); + } + emit spanChanged(qxt_d().lower, qxt_d().upper); + update(); + } +} + +/*! + \property QxtSpanSlider::lowerPosition + \brief the lower position of the span + */ +int QxtSpanSlider::lowerPosition() const +{ + return qxt_d().lowerPos; +} + +void QxtSpanSlider::setLowerPosition(int lower) +{ + if (qxt_d().lowerPos != lower) + { + qxt_d().lowerPos = lower; + if (!hasTracking()) + update(); + if (isSliderDown()) + emit lowerPositionChanged(lower); + if (hasTracking() && !qxt_d().blockTracking) + { + bool main = (qxt_d().mainControl == QxtSpanSlider::LowerHandle); + qxt_d().triggerAction(SliderMove, main); + } + } +} + +/*! + \property QxtSpanSlider::upperPosition + \brief the upper position of the span + */ +int QxtSpanSlider::upperPosition() const +{ + return qxt_d().upperPos; +} + +void QxtSpanSlider::setUpperPosition(int upper) +{ + if (qxt_d().upperPos != upper) + { + qxt_d().upperPos = upper; + if (!hasTracking()) + update(); + if (isSliderDown()) + emit upperPositionChanged(upper); + if (hasTracking() && !qxt_d().blockTracking) + { + bool main = (qxt_d().mainControl == QxtSpanSlider::UpperHandle); + qxt_d().triggerAction(SliderMove, main); + } + } +} + +/*! + \reimp + */ +void QxtSpanSlider::keyPressEvent(QKeyEvent* event) +{ + QSlider::keyPressEvent(event); + + bool main = true; + SliderAction action = SliderNoAction; + switch (event->key()) + { + case Qt::Key_Left: + main = (orientation() == Qt::Horizontal); + action = !invertedAppearance() ? SliderSingleStepSub : SliderSingleStepAdd; + break; + case Qt::Key_Right: + main = (orientation() == Qt::Horizontal); + action = !invertedAppearance() ? SliderSingleStepAdd : SliderSingleStepSub; + break; + case Qt::Key_Up: + main = (orientation() == Qt::Vertical); + action = invertedControls() ? SliderSingleStepSub : SliderSingleStepAdd; + break; + case Qt::Key_Down: + main = (orientation() == Qt::Vertical); + action = invertedControls() ? SliderSingleStepAdd : SliderSingleStepSub; + break; + case Qt::Key_Home: + main = (qxt_d().mainControl == QxtSpanSlider::LowerHandle); + action = SliderToMinimum; + break; + case Qt::Key_End: + main = (qxt_d().mainControl == QxtSpanSlider::UpperHandle); + action = SliderToMaximum; + break; + default: + event->ignore(); + break; + } + + if (action) + qxt_d().triggerAction(action, main); +} + +/*! + \reimp + */ +void QxtSpanSlider::mousePressEvent(QMouseEvent* event) +{ + if (minimum() == maximum() || (event->buttons() ^ event->button())) + { + event->ignore(); + return; + } + + qxt_d().handleMousePress(event->pos(), qxt_d().upperPressed, qxt_d().upper, QxtSpanSlider::UpperHandle); + if (qxt_d().upperPressed != QStyle::SC_SliderHandle) + qxt_d().handleMousePress(event->pos(), qxt_d().lowerPressed, qxt_d().lower, QxtSpanSlider::LowerHandle); + + qxt_d().firstMovement = true; + event->accept(); +} + +/*! + \reimp + */ +void QxtSpanSlider::mouseMoveEvent(QMouseEvent* event) +{ + if (qxt_d().lowerPressed != QStyle::SC_SliderHandle && qxt_d().upperPressed != QStyle::SC_SliderHandle) + { + event->ignore(); + return; + } + + QStyleOptionSlider opt; + qxt_d().initStyleOption(&opt); + const int m = style()->pixelMetric(QStyle::PM_MaximumDragDistance, &opt, this); + int newPosition = qxt_d().pixelPosToRangeValue(qxt_d().pick(event->pos()) - qxt_d().offset); + if (m >= 0) + { + const QRect r = rect().adjusted(-m, -m, m, m); + if (!r.contains(event->pos())) + { + newPosition = qxt_d().position; + } + } + + // pick the preferred handle on the first movement + if (qxt_d().firstMovement) + { + if (qxt_d().lower == qxt_d().upper) + { + if (newPosition < lowerValue()) + { + qxt_d().swapControls(); + qxt_d().firstMovement = false; + } + } + else + { + qxt_d().firstMovement = false; + } + } + + if (qxt_d().lowerPressed == QStyle::SC_SliderHandle) + { + if (qxt_d().movement == NoCrossing) + newPosition = qMin(newPosition, upperValue()); + else if (qxt_d().movement == NoOverlapping) + newPosition = qMin(newPosition, upperValue() - 1); + + if (qxt_d().movement == FreeMovement && newPosition > qxt_d().upper) + { + qxt_d().swapControls(); + setUpperPosition(newPosition); + } + else + { + setLowerPosition(newPosition); + } + } + else if (qxt_d().upperPressed == QStyle::SC_SliderHandle) + { + if (qxt_d().movement == NoCrossing) + newPosition = qMax(newPosition, lowerValue()); + else if (qxt_d().movement == NoOverlapping) + newPosition = qMax(newPosition, lowerValue() + 1); + + if (qxt_d().movement == FreeMovement && newPosition < qxt_d().lower) + { + qxt_d().swapControls(); + setLowerPosition(newPosition); + } + else + { + setUpperPosition(newPosition); + } + } + event->accept(); +} + +/*! + \reimp + */ +void QxtSpanSlider::mouseReleaseEvent(QMouseEvent* event) +{ + QSlider::mouseReleaseEvent(event); + setSliderDown(false); + qxt_d().lowerPressed = QStyle::SC_None; + qxt_d().upperPressed = QStyle::SC_None; + update(); +} + +/*! + \reimp + */ +void QxtSpanSlider::paintEvent(QPaintEvent* event) +{ + Q_UNUSED(event); + QStylePainter painter(this); + + // groove & ticks + QStyleOptionSlider opt; + qxt_d().initStyleOption(&opt); + opt.sliderValue = 0; + opt.sliderPosition = 0; + opt.subControls = QStyle::SC_SliderGroove | QStyle::SC_SliderTickmarks; + painter.drawComplexControl(QStyle::CC_Slider, opt); + + // handle rects + opt.sliderPosition = qxt_d().lowerPos; + const QRect lr = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this); + const int lrv = qxt_d().pick(lr.center()); + opt.sliderPosition = qxt_d().upperPos; + const QRect ur = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderHandle, this); + const int urv = qxt_d().pick(ur.center()); + + // span + const int minv = qMin(lrv, urv); + const int maxv = qMax(lrv, urv); + const QPoint c = QRect(lr.center(), ur.center()).center(); + QRect spanRect; + if (orientation() == Qt::Horizontal) + spanRect = QRect(QPoint(minv, c.y() - 2), QPoint(maxv, c.y() + 1)); + else + spanRect = QRect(QPoint(c.x() - 2, minv), QPoint(c.x() + 1, maxv)); + qxt_d().drawSpan(&painter, spanRect); + + // handles + switch (qxt_d().lastPressed) + { + case QxtSpanSlider::LowerHandle: + qxt_d().drawHandle(&painter, QxtSpanSlider::UpperHandle); + qxt_d().drawHandle(&painter, QxtSpanSlider::LowerHandle); + break; + case QxtSpanSlider::UpperHandle: + default: + qxt_d().drawHandle(&painter, QxtSpanSlider::LowerHandle); + qxt_d().drawHandle(&painter, QxtSpanSlider::UpperHandle); + break; + } +} diff --git a/src/interface/qxtspanslider.h b/src/interface/qxtspanslider.h new file mode 100644 index 0000000000000000000000000000000000000000..f0b853994c4fe15f0505d528870e5ccd97397ee6 --- /dev/null +++ b/src/interface/qxtspanslider.h @@ -0,0 +1,98 @@ +/**************************************************************************** + ** + ** Copyright (C) Qxt Foundation. Some rights reserved. + ** + ** This file is part of the QxtGui module of the Qxt library. + ** + ** This library is free software; you can redistribute it and/or modify it + ** under the terms of the Common Public License, version 1.0, as published + ** by IBM, and/or under the terms of the GNU Lesser General Public License, + ** version 2.1, as published by the Free Software Foundation. + ** + ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY + ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY + ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR + ** FITNESS FOR A PARTICULAR PURPOSE. + ** + ** You should have received a copy of the CPL and the LGPL along with this + ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files + ** included with the source distribution for more information. + ** If you did not receive a copy of the licenses, contact the Qxt Foundation. + ** + ** + ** + ****************************************************************************/ +#ifndef QXTSPANSLIDER_H +#define QXTSPANSLIDER_H + +#include +#include "interface/qxtpimpl.h" + +class QxtSpanSliderPrivate; + +class QxtSpanSlider : public QSlider +{ + Q_OBJECT + QXT_DECLARE_PRIVATE(QxtSpanSlider) + Q_PROPERTY(int lowerValue READ lowerValue WRITE setLowerValue) + Q_PROPERTY(int upperValue READ upperValue WRITE setUpperValue) + Q_PROPERTY(int lowerPosition READ lowerPosition WRITE setLowerPosition) + Q_PROPERTY(int upperPosition READ upperPosition WRITE setUpperPosition) + Q_PROPERTY(HandleMovementMode handleMovementMode READ handleMovementMode WRITE setHandleMovementMode) + Q_ENUMS(HandleMovementMode) + +public: + explicit QxtSpanSlider(QWidget* parent = 0); + explicit QxtSpanSlider(Qt::Orientation orientation, QWidget* parent = 0); + virtual ~QxtSpanSlider(); + + enum HandleMovementMode + { + FreeMovement, + NoCrossing, + NoOverlapping + }; + + enum SpanHandle + { + NoHandle, + LowerHandle, + UpperHandle + }; + + HandleMovementMode handleMovementMode() const; + void setHandleMovementMode(HandleMovementMode mode); + + int lowerValue() const; + int upperValue() const; + + int lowerPosition() const; + int upperPosition() const; + +public Q_SLOTS: + void setLowerValue(int lower); + void setUpperValue(int upper); + void setSpan(int lower, int upper); + + void setLowerPosition(int lower); + void setUpperPosition(int upper); + +Q_SIGNALS: + void spanChanged(int lower, int upper); + void lowerValueChanged(int lower); + void upperValueChanged(int upper); + + void lowerPositionChanged(int lower); + void upperPositionChanged(int upper); + + void sliderPressed(SpanHandle handle); + +protected: + virtual void keyPressEvent(QKeyEvent* event); + virtual void mousePressEvent(QMouseEvent* event); + virtual void mouseMoveEvent(QMouseEvent* event); + virtual void mouseReleaseEvent(QMouseEvent* event); + virtual void paintEvent(QPaintEvent* event); +}; + +#endif // QXTSPANSLIDER_H diff --git a/src/interface/qxtspanslider_p.h b/src/interface/qxtspanslider_p.h new file mode 100644 index 0000000000000000000000000000000000000000..290415efb124e1de4400ce6123e2e886df031b4d --- /dev/null +++ b/src/interface/qxtspanslider_p.h @@ -0,0 +1,76 @@ +/**************************************************************************** + ** + ** Copyright (C) Qxt Foundation. Some rights reserved. + ** + ** This file is part of the QxtGui module of the Qxt library. + ** + ** This library is free software; you can redistribute it and/or modify it + ** under the terms of the Common Public License, version 1.0, as published + ** by IBM, and/or under the terms of the GNU Lesser General Public License, + ** version 2.1, as published by the Free Software Foundation. + ** + ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY + ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY + ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR + ** FITNESS FOR A PARTICULAR PURPOSE. + ** + ** You should have received a copy of the CPL and the LGPL along with this + ** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files + ** included with the source distribution for more information. + ** If you did not receive a copy of the licenses, contact the Qxt Foundation. + ** + ** + ** + ****************************************************************************/ +#ifndef QXTSPANSLIDER_P_H +#define QXTSPANSLIDER_P_H + +#include +#include +#include "interface/qxtspanslider.h" +#include "interface/qxtpimpl.h" + +QT_FORWARD_DECLARE_CLASS(QStylePainter) +QT_FORWARD_DECLARE_CLASS(QStyleOptionSlider) + +class QxtSpanSliderPrivate : public QObject, public QxtPrivate +{ + Q_OBJECT + +public: + QXT_DECLARE_PUBLIC(QxtSpanSlider) + + QxtSpanSliderPrivate(); + void initStyleOption(QStyleOptionSlider* option, QxtSpanSlider::SpanHandle handle = QxtSpanSlider::UpperHandle) const; + int pick(const QPoint& pt) const + { + return qxt_p().orientation() == Qt::Horizontal ? pt.x() : pt.y(); + } + int pixelPosToRangeValue(int pos) const; + void handleMousePress(const QPoint& pos, QStyle::SubControl& control, int value, QxtSpanSlider::SpanHandle handle); + void drawHandle(QStylePainter* painter, QxtSpanSlider::SpanHandle handle) const; + void setupPainter(QPainter* painter, Qt::Orientation orientation, qreal x1, qreal y1, qreal x2, qreal y2) const; + void drawSpan(QStylePainter* painter, const QRect& rect) const; + void triggerAction(QAbstractSlider::SliderAction action, bool main); + void swapControls(); + + int lower; + int upper; + int lowerPos; + int upperPos; + int offset; + int position; + QxtSpanSlider::SpanHandle lastPressed; + QxtSpanSlider::SpanHandle mainControl; + QStyle::SubControl lowerPressed; + QStyle::SubControl upperPressed; + QxtSpanSlider::HandleMovementMode movement; + bool firstMovement; + bool blockTracking; + +public Q_SLOTS: + void updateRange(int min, int max); + void movePressedHandle(); +}; + +#endif // QXTSPANSLIDER_P_H diff --git a/src/parser/mt_ParserPaje.cpp b/src/parser/mt_ParserPaje.cpp index c9f20dffb713104d91f2fd261de4da6fb096c47c..fecbf386565a3b2f948c83036bc9e053bdd26dfa 100644 --- a/src/parser/mt_ParserPaje.cpp +++ b/src/parser/mt_ParserPaje.cpp @@ -122,7 +122,6 @@ mt_ParserPaje::~mt_ParserPaje() { void mt_ParserPaje::parse(Trace &trace, bool finish_trace_after_parse) { - static const string PERCENT = "%"; #ifdef DBG_PARSER_PAJE diff --git a/src/render/Geometry.cpp b/src/render/Geometry.cpp index ca0b352a86c5f885acbbec2b78e5e99a82976947..017bef9ea8b8ba9ff822bfcc5d5e1471c4854b7c 100644 --- a/src/render/Geometry.cpp +++ b/src/render/Geometry.cpp @@ -201,6 +201,8 @@ Element_pos Geometry::coeff_trace_render_y() const { void Geometry::update_visible_interval_value() const { Info::Render::_x_min_visible = max(Info::Entity::x_min, (_x_state_translate - _default_entity_x_translate )/coeff_trace_render_x()); + Info::Render::_x_min=max(Info::Entity::x_min, _x_state_translate/coeff_trace_render_x()); + Info::Render::_x_max=min(Info::Entity::x_max, (_x_state_translate- _default_entity_x_translate + Info::Render::width)/coeff_trace_render_x()); Info::Render::_x_max_visible = min(Info::Entity::x_max, (_x_state_translate - _default_entity_x_translate + Info::Render::width)/coeff_trace_render_x()); } /* diff --git a/src/render/Hook_event.cpp b/src/render/Hook_event.cpp index bdfc18b8c752e44cc4d52417aed5d4a9a00603ec..8815a23bb0fd2b9e9a9babd790f92a56f48d37c9 100644 --- a/src/render/Hook_event.cpp +++ b/src/render/Hook_event.cpp @@ -497,8 +497,7 @@ void Hook_event::apply_zoom_box(Element_pos x_min, Element_pos x_max, Element_po int buf; _x_state_scale *= (Info::Render::width*(1-_x_scale_container_state)) / screen_to_render_x(x_max - x_min); - buf = (int)(100*_x_state_scale); - _core->launch_action(_core->_STATE_ZOOM_BOX_VALUE, &buf); + _y_state_scale *= (Info::Render::height - _ruler_height) / screen_to_render_y(y_max - y_min); @@ -531,7 +530,8 @@ void Hook_event::apply_zoom_box(Element_pos x_min, Element_pos x_max, Element_po } #endif - + buf = (int)(100*_x_state_scale); + _core->launch_action(_core->_STATE_ZOOM_BOX_VALUE, &buf); /* Update render */ updateRender(); refresh_scroll_bars(true); diff --git a/src/src.pro b/src/src.pro index ed0b65f02ca0c0958e18b91e93c8d13f36fefc8c..6e11722231e773599366fbe705926a40e22dcbb7 100644 --- a/src/src.pro +++ b/src/src.pro @@ -54,9 +54,9 @@ TARGET = vite macx:QMAKE_LIBS_OPENGL += -framework -lobjc DEPENDPATH += . INCLUDEPATH += . -QMAKE_CFLAGS += -O2 -Wall -g +QMAKE_CFLAGS += -O2 -Wall -g -DMT_PARSING -DBOOST_GZIP #-DMT_PARSING -QMAKE_CXXFLAGS += -O2 -Wall -g -DMT_PARSING +QMAKE_CXXFLAGS += -O2 -Wall -g -DMT_PARSING -DBOOST_GZIP #TRANSLATIONS = ViTE_fr.ts #LIBS += -lGLEW @@ -81,6 +81,9 @@ HEADERS += common/common.hpp \ interface/resource.hpp \ interface/Node_select.hpp \ interface/viteqtreewidget.hpp \ + interface/Interval_select.hpp \ + interface/qxtspanslider.h \ + interface/qxtspanslider_p.h \ # Core header core/Core.hpp \ # Render headers @@ -167,7 +170,8 @@ FORMS += interface/info_window.ui \ interface/stats_viewer.ui \ interface/global_cmd.ui \ interface/list_of_counter_to_export.ui\ - interface/node_select.ui + interface/node_select.ui \ + interface/interval_select.ui SOURCES += common/Message.cpp \ common/Errors.cpp \ @@ -238,6 +242,8 @@ SOURCES += common/Message.cpp \ interface/interface_graphic.cpp \ interface/Node_select.cpp \ interface/viteqtreewidget.cpp \ + interface/Interval_select.cpp + interface/qxtspanslider.cpp # Core code file core/Core.cpp \ # Plugin code file diff --git a/src/trace/Container.cpp b/src/trace/Container.cpp index d33d1cbc2b5b190a00f31c4624e81d41f8cffd5e..fa2941050d8ca187cf3f97f0c7c5d992249352d0 100644 --- a/src/trace/Container.cpp +++ b/src/trace/Container.cpp @@ -634,7 +634,7 @@ void Container::loadItcInside(Interval* splitInterval){ if((*it)->_loaded==false){ sprintf(name, "%s/%d_%d",Info::Splitter::path.c_str(),_uid ,i); - //printf("%s : need to load itc beginning at %lf and finishing at %lf, file %s \n", _name.to_string().c_str(), (*it)->_beginning.get_value(), (*it)->_end.get_value(), name); + // printf("%s : need to load itc beginning at %lf and finishing at %lf, file %s \n", _name.to_string().c_str(), (*it)->_beginning.get_value(), (*it)->_end.get_value(), name); loading=(*it)->retrieve(name); if(loading==true)(*it)->_loaded=true; @@ -642,7 +642,15 @@ void Container::loadItcInside(Interval* splitInterval){ } - } + }else{ + //if the itc is loaded, unload it ! + if((*it)->_loaded==true){ + (*it)->unload(); + (*it)->_loaded=false; + // printf("%s :unload itc beginning at %lf and finishing at %lf, file %s \n", _name.to_string().c_str(), (*it)->_beginning.get_value(), (*it)->_end.get_value(), name); + } + + } i++; @@ -709,13 +717,17 @@ void Container::finish(const Date &time) { //boolean to check if the intervalOfcontainer is fully inside the visible interval, in order not to check each state if yes // bool fully_contained=false; +if(_event_tree)delete _event_tree; +if(_state_tree!=NULL)delete _state_tree; +_event_tree=NULL; +_state_tree=NULL; if(Info::Splitter::load_splitted==false){ if (_destruction_time.get_value() == 0.0) destroy(time); - if(_n_events!=0)delete _event_tree; - if(_n_states!=0)delete _state_tree; + + _states.clear(); _links.clear(); _variables.clear(); diff --git a/src/trace/Serializer_container.hpp b/src/trace/Serializer_container.hpp index 2f864bf692df42a37ba5041867f82536e418f074..f76c048bd8d4eb6439d1b8eb24f02df535335a59 100644 --- a/src/trace/Serializer_container.hpp +++ b/src/trace/Serializer_container.hpp @@ -96,6 +96,9 @@ ar & itc->_beginning; ar & itc->_end; ar & itc->_states_values_map; + + if(itc->_beginning_beginning.get_value(); + if(itc->_end>Info::Entity::x_max)Info::Entity::x_max=itc->_end.get_value(); _intervalsOfContainer.push_back(itc); } } diff --git a/src/trace/Trace.cpp b/src/trace/Trace.cpp index 4f752e404368ba271c28e4c7b8598ebfc43a1f66..eae762cd218293f760df89f1da53aaf0db0fe050 100644 --- a/src/trace/Trace.cpp +++ b/src/trace/Trace.cpp @@ -414,13 +414,15 @@ void Trace::finish() { #if defined(USE_ITC) && defined(BOOST_SERIALIZE) void Trace::updateTrace(Interval* interval){ -if(Info::Splitter::preview==false){ - loadTraceInside(interval); - finish(); -}else{ - loadPreview(); +if(Info::Splitter::load_splitted==true){ + if(Info::Splitter::preview==false){ + loadTraceInside(interval); + finish(); + }else{ + loadPreview(); } + } } diff --git a/src/trace/tree/Node.hpp b/src/trace/tree/Node.hpp index cb142486c715c2ca72fee3335a14adabdc9df5f7..fc7e32719aafd6258246fd30f247b9ef26d0a94f 100644 --- a/src/trace/tree/Node.hpp +++ b/src/trace/tree/Node.hpp @@ -87,7 +87,7 @@ public: delete _left_child; if(_right_child) delete _right_child; - delete _element; + // delete _element; _element = NULL; _left_child = NULL; _right_child = NULL;