update coding style

Methods of Qt classes now use the Qt coding style.

See-also: #1
Signed-off-by: Mattéo Rossillol‑‑Laruelle <beatussum@protonmail.com>

include/gui/MainWindow.hpp

@@ -56,13 +56,13 @@ namespace gui
     private:
         full_positions_data process();
     private slots:
-        void update_size(int __current_index);
+        void updateSize(int __current_index);
     private slots:
-        void find_contours(const QRect& __new_selection);
-        void load_selection(bool __new_status);
+        void findContours(const QRect& __new_selection);
+        void loadSelection(bool __new_status);
         void reset();
         void run();
-        void show_results();
+        void showResults();
     private:
         cv::VideoCapture     m_capture;
         cv::Mat              m_first_frame;

include/gui/pages/Calibration.hpp

@@ -27,47 +27,41 @@ namespace gui::pages
     {
         Q_OBJECT
 
-        Q_PROPERTY(
-            QPixmap pixmap
-            READ get_pixmap
-            WRITE set_pixmap
-            STORED false
-        )
-
-        Q_PROPERTY(double pixmap_measure READ get_pixmap_measure STORED false)
-        Q_PROPERTY(double ratio READ get_ratio STORED false)
-        Q_PROPERTY(double real_measure READ get_real_measure STORED false)
+        Q_PROPERTY(QPixmap pixmap READ pixmap WRITE setPixmap STORED false)
+        Q_PROPERTY(double pixmapMeasure READ pixmapMeasure STORED false)
+        Q_PROPERTY(double ratio READ ratio STORED false)
+        Q_PROPERTY(double realMeasure READ realMeasure STORED false)
 
         Q_PROPERTY(
             bool status
-            READ get_status
+            READ status
             RESET reset
-            NOTIFY status_changed
+            NOTIFY statusChanged
             STORED false
         )
 
     public:
         explicit Calibration(QWidget* __parent = nullptr, Qt::WindowFlags = {});
         virtual ~Calibration() { delete m_ui; }
     public:
-        QPixmap get_pixmap() const
+        QPixmap pixmap() const
             { return m_ui->m_calibration_widget->pixmap(Qt::ReturnByValue); }
 
-        void set_pixmap(const QPixmap&);
-        void set_pixmap(const cv::Mat&);
+        void setPixmap(const QPixmap&);
+        void setPixmap(const cv::Mat&);
 
-        double get_pixmap_measure() const
-            { return m_ui->m_calibration_widget->get_measure(); }
+        double pixmapMeasure() const
+            { return m_ui->m_calibration_widget->measure(); }
 
-        double get_ratio() const;
+        double ratio() const;
 
-        double get_real_measure() const
+        double realMeasure() const
             { return m_ui->m_line_edit->text().toDouble(); }
 
-        bool get_status() const;
+        bool status() const;
     signals:
-        void measure_changed(bool __status);
-        void status_changed(bool __new_status);
+        void measureChanged(bool __status);
+        void statusChanged(bool __new_status);
     public slots:
         void reset() const;
     private:

include/gui/pages/ContourSelection.hpp

@@ -29,16 +29,10 @@ namespace gui::pages
     {
         Q_OBJECT
 
-        Q_PROPERTY(sorted_contours_type contours READ get_contours)
-        Q_PROPERTY(QPixmap pixmap READ get_pixmap)
-
-        Q_PROPERTY(
-            contour_type current
-            READ get_current
-            NOTIFY current_changed
-        )
-
-        Q_PROPERTY(double current_area READ get_current_area STORED false)
+        Q_PROPERTY(sorted_contours_type contours READ contours)
+        Q_PROPERTY(QPixmap pixmap READ pixmap)
+        Q_PROPERTY(contour_type current READ current NOTIFY currentChanged)
+        Q_PROPERTY(double currentArea READ currentArea STORED false)
 
     public:
         using current_type = sorted_contours_type::const_iterator;
@@ -78,23 +72,23 @@ namespace gui::pages
 
         virtual ~ContourSelection() { delete m_ui; }
     public:
-        sorted_contours_type get_contours() const { return m_contours; }
-        QPixmap get_pixmap() const { return m_pixmap; }
+        sorted_contours_type contours() const { return m_contours; }
+        QPixmap pixmap() const { return m_pixmap; }
     public:
-        contour_type get_current() const
+        contour_type current() const
             { return (m_contours.empty() ? contour_type() : *m_current); }
 
-        double get_current_area() const;
+        double currentArea() const;
     signals:
-        void current_changed(current_type __new_current);
+        void currentChanged(current_type __new_current);
     private slots:
-        void update_shown_contour();
+        void updateShownContour();
     public slots:
-        void reset_values() { set_values(sorted_contours_type(), QPixmap()); }
-        void set_values(sorted_contours_type, QPixmap);
+        void resetValues() { setValues(sorted_contours_type(), QPixmap()); }
+        void setValues(sorted_contours_type, QPixmap);
 
-        void set_values(sorted_contours_type __c, const cv::Mat& __m)
-            { set_values(std::move(__c), qpixmap_from_mat(__m)); }
+        void setValues(sorted_contours_type __c, const cv::Mat& __m)
+            { setValues(std::move(__c), qpixmap_from_mat(__m)); }
     public slots:
         void next();
         void previous();

include/gui/pages/Selection.hpp

@@ -29,37 +29,38 @@ namespace gui::pages
 
         Q_PROPERTY(
             QRect selection
-            READ get_selection
-            WRITE set_selection
-            RESET reset_selection
-            NOTIFY selection_changed
+            READ selection
+            WRITE setSelection
+            RESET resetSelection
+            NOTIFY selectionChanged
         )
 
     public:
         explicit Selection(QWidget* __parent = nullptr, Qt::WindowFlags = {});
         virtual ~Selection() { delete m_ui; }
     public:
-        QRect get_selection() const noexcept
-            { return m_ui->m_selection_widget->get_selection(); }
+        QRect pixmapRect() const
+            { return m_ui->m_selection_widget->pixmapRect(); }
 
-        bool has_selection() const noexcept { return has_selection(); }
+        QRect selection() const noexcept
+            { return m_ui->m_selection_widget->selection(); }
 
-        QRect get_pixmap_rect() const
-            { return m_ui->m_selection_widget->get_pixmap_rect(); }
+        bool hasSelection() const noexcept
+            { return m_ui->m_selection_widget->hasSelection(); }
     signals:
-        void selection_changed(const QRect& __new_selection);
+        void selectionChanged(const QRect& __new_selection);
     public slots:
         void setPixmap(const QPixmap& __p)
             { m_ui->m_selection_widget->setPixmap(__p); }
 
         void setPixmap(const cv::Mat& __m)
             { m_ui->m_selection_widget->setPixmap(__m); }
 
-        void set_selection(QRect __r) noexcept
-            { m_ui->m_selection_widget->set_selection(std::move(__r)); }
+        void setSelection(QRect __r) noexcept
+            { m_ui->m_selection_widget->setSelection(std::move(__r)); }
 
-        void reset_selection() noexcept
-            { m_ui->m_selection_widget->reset_selection(); }
+        void resetSelection() noexcept
+            { m_ui->m_selection_widget->resetSelection(); }
     private:
         Ui::Selection* m_ui;
     };

include/gui/pages/Statistics.hpp

@@ -37,8 +37,8 @@ namespace gui::pages
             Qt::WindowFlags                   = {}
         );
     public slots:
-        void set_data(const full_positions_data& _data) const;
-        void reset_data() const;
+        void setData(const full_positions_data& _data) const;
+        void resetData() const;
     private:
         QCustomPlot* m_heading;
         QCustomPlot* m_position;

include/gui/pages/Upload.hpp

@@ -28,25 +28,24 @@ namespace gui::pages
         Q_OBJECT
 
         Q_PROPERTY(
-            bool upload_status
-            READ is_upload_valid
-            RESET reset_upload_status
-            NOTIFY upload_status_changed
+            bool uploadStatus
+            READ isUploadValid
+            RESET resetUploadStatus
+            NOTIFY uploadStatusChanged
         )
 
     public:
         explicit Upload(QWidget* __parent = nullptr, Qt::WindowFlags = {});
         virtual ~Upload() { delete m_ui; }
     public:
-        QString get_file_path() const
-            { return m_ui->m_uploader->get_file_path(); }
+        QString filePath() const
+            { return m_ui->m_uploader->filePath(); }
 
-        bool is_upload_valid() const { return !m_ui->m_uploader->is_empty(); }
+        bool isUploadValid() const { return !m_ui->m_uploader->isEmpty(); }
     signals:
-        void upload_status_changed(bool __new_status);
+        void uploadStatusChanged(bool __new_status);
     public slots:
-        void reset_upload_status() const
-            { m_ui->m_uploader->reset_file_path(); }
+        void resetUploadStatus() const { m_ui->m_uploader->resetFilePath(); }
     private:
         Ui::Upload* m_ui;
     };

include/gui/widgets/ButtonSelecterWidget.hpp

@@ -31,10 +31,10 @@ namespace gui::widgets
 
         Q_PROPERTY(
             int progress
-            READ get_progress
-            WRITE set_progress
-            RESET reset_progress
-            NOTIFY progress_changed
+            READ progress
+            WRITE setProgress
+            RESET resetProgress
+            NOTIFY progressChanged
         )
 
     public:
@@ -45,18 +45,18 @@ namespace gui::widgets
 
         virtual ~ButtonSelecterWidget() { delete m_ui; }
     protected:
-        void update_buttons(int __current_index) const override;
+        void updateButtons(int __current_index) const override;
     public:
-        int get_progress() const noexcept { return m_progress; }
-        void set_page_index(int) override;
+        int progress() const noexcept { return m_progress; }
+        void setPageIndex(int) override;
     signals:
-        void progress_changed(int);
+        void progressChanged(int);
         void run();
     protected slots:
-        virtual void update_page_index(int);
+        virtual void updatePageIndex(int);
     public slots:
-        void reset_progress() { emit progress_changed(m_progress = 0); }
-        void set_progress(int __p) { emit progress_changed(m_progress = __p); }
+        void resetProgress() { emit progressChanged(m_progress = 0); }
+        void setProgress(int __p) { emit progressChanged(m_progress = __p); }
     private:
         Ui::ButtonSelecterWidget* m_ui;
 

include/gui/widgets/CalibrationWidget.hpp

@@ -29,9 +29,9 @@ namespace gui::widgets
 
         Q_PROPERTY(
             double measure
-            READ get_measure
-            RESET reset_measure
-            NOTIFY measure_changed
+            READ measure
+            RESET resetMeasure
+            NOTIFY measureChanged
             STORED false
         )
 
@@ -61,13 +61,13 @@ namespace gui::widgets
         void mousePressEvent(QMouseEvent*) override;
         void mouseMoveEvent(QMouseEvent*) override;
     public:
-        double get_measure() const;
-        bool get_status() const { return (m_end != QPoint(-1., -1.)); }
+        double measure() const;
+        bool status() const { return (m_end != QPoint(-1., -1.)); }
     signals:
-        void measure_changed(bool __status);
+        void measureChanged(bool __status);
     public slots:
         void reset();
-        void reset_measure();
+        void resetMeasure();
 
         void setPixmap(const QPixmap&);
 

include/gui/widgets/CheckWidget.hpp

@@ -29,10 +29,10 @@ namespace gui::widgets
 
         Q_PROPERTY(
             bool status
-            READ get_status
-            WRITE set_status
-            RESET reset_status
-            NOTIFY status_changed
+            READ status
+            WRITE setStatus
+            RESET resetStatus
+            NOTIFY statusChanged
         )
 
     public:
@@ -56,12 +56,12 @@ namespace gui::widgets
             : CheckWidget(QString(), false, __parent, __f)
         {}
     public:
-        bool get_status() const noexcept { return m_status; }
+        bool status() const noexcept { return m_status; }
     signals:
-        void status_changed(bool __new_status);
+        void statusChanged(bool __new_status);
     public slots:
-        void set_status(bool);
-        void reset_status() { set_status(false); }
+        void setStatus(bool);
+        void resetStatus() { setStatus(false); }
     private:
         bool m_status;
     };

include/gui/widgets/ItemizeWidget.hpp

@@ -29,8 +29,8 @@ namespace gui::widgets
     {
         Q_OBJECT
 
-        Q_PROPERTY(QString info READ get_info WRITE set_info)
-        Q_PROPERTY(QPixmap pixmap READ get_pixmap WRITE set_pixmap)
+        Q_PROPERTY(QString info READ info WRITE setInfo)
+        Q_PROPERTY(QPixmap pixmap READ pixmap WRITE setPixmap)
 
     public:
         explicit ItemizeWidget(
@@ -55,17 +55,17 @@ namespace gui::widgets
 
         virtual ~ItemizeWidget() { delete m_ui; }
     public:
-        QString get_info() const { return m_ui->m_info_label->text(); }
-        QPixmap get_pixmap() const;
+        QString info() const { return m_ui->m_info_label->text(); }
+        QPixmap pixmap() const;
     public slots:
-        void set_info(const QString& __i) const
+        void setInfo(const QString& __i) const
             { m_ui->m_info_label->setText(__i); }
     protected slots:
-        void set_pixmap(const QPixmap& __p) const
+        void setPixmap(const QPixmap& __p) const
             { m_ui->m_pixmap_label->setPixmap(__p); }
 
-        void set_pixmap(const QIcon& __i) const
-            { set_pixmap(__i.pixmap({32, 32})); }
+        void setPixmap(const QIcon& __i) const
+            { setPixmap(__i.pixmap({32, 32})); }
     private:
         Ui::ItemizeWidget* m_ui;
     };

include/gui/widgets/LabelWidget.hpp

@@ -28,7 +28,7 @@ namespace gui::widgets
     class LabelWidget : public QLabel
     {
         Q_OBJECT
-        Q_PROPERTY(QRect pixmap_rect READ get_pixmap_rect STORED false)
+        Q_PROPERTY(QRect pixmapRect READ pixmapRect STORED false)
 
     public:
         explicit LabelWidget(
@@ -52,7 +52,7 @@ namespace gui::widgets
             : LabelWidget(QPixmap(), __parent, __f)
         {}
     public:
-        QRect get_pixmap_rect() const;
+        QRect pixmapRect() const;
     public slots:
         void setPixmap(const QPixmap& __p) { QLabel::setPixmap(__p); }