qtextorientationwidget.cpp

Go to the documentation of this file.

/*
    Copyright 2006-2019 The QElectroTech Team
    This file is part of QElectroTech.
    
    QElectroTech is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.
    
    QElectroTech is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "qtextorientationwidget.h"
#include <algorithm>

QTextOrientationWidget::QTextOrientationWidget(QWidget *parent) :
    QWidget(parent),
    squares_interval_(45.0),
    current_orientation_(0.0),
    display_text_(true),
    must_highlight_angle_(false),
    read_only_(false)
{
    // chaines par defaut
    text_size_hash_.insert(tr("Ex.",     "Short example string"),  -1);
    text_size_hash_.insert(tr("Exemple", "Longer example string"), -1);
    
    // definit la politique de gestion de la taille de ce widget :
    // on prefere la sizeHint()
    QSizePolicy size_policy(QSizePolicy::Minimum, QSizePolicy::Minimum);
    // on souhaite conserver le rapport entre sa hauteur et sa largeur
    size_policy.setHeightForWidth(true);
    setSizePolicy(size_policy);
    
    // suivi de la souris : permet de recevoir les evenements relatifs aux
    // mouvement de la souris sans que l'utilisateur n'ait a cliquer
    setMouseTracking(true);
}

QTextOrientationWidget::~QTextOrientationWidget() {
}

void QTextOrientationWidget::setOrientation(const double &angle) {
    current_orientation_ = angle;
    update();
}

double QTextOrientationWidget::orientation() const {
    return(current_orientation_);
}

void QTextOrientationWidget::setFont(const QFont &font) {
    text_font_ = font;
    
    // invalide le cache contenant les longueurs des textes a disposition
    foreach(QString text, text_size_hash_.keys()) {
        text_size_hash_[text] = -1;
    }
}

QFont QTextOrientationWidget::font() const {
    return(text_font_);
}

void QTextOrientationWidget::setDisplayText(bool display_text) {
    display_text_ = display_text;
}

bool QTextOrientationWidget::textDisplayed() const {
    return(display_text_);
}

void QTextOrientationWidget::setUsableTexts(const QStringList &texts_list) {
    if (texts_list.isEmpty()) return;
    
    // on oublie les anciennes chaines
    foreach(QString text, text_size_hash_.keys()) {
        // il faut oublier les anciennes chaines
        if (!texts_list.contains(text)) {
            text_size_hash_.remove(text);
        }
    }
    
    // on ajoute les nouvelles, sans les calculer (on met -1 en guise de longueur)
    foreach(QString text, texts_list) {
        if (!text_size_hash_.contains(text)) {
            text_size_hash_[text] = -1;
        }
    }
}

QStringList QTextOrientationWidget::usableTexts() const {
    return(text_size_hash_.keys());
}

bool QTextOrientationWidget::isReadOnly() const {
    return(read_only_);
}

void QTextOrientationWidget::setReadOnly(bool ro) {
    read_only_ = ro;
}

QSize QTextOrientationWidget::sizeHint() const {
    return(QSize(50, 50));
}

int QTextOrientationWidget::heightForWidth(int w) const {
    return(w);
}

void QTextOrientationWidget::paintEvent(QPaintEvent *event) {
    Q_UNUSED(event);
    
    // rectangle de travail avec son centre et son rayon
    QRect drawing_rectangle(QPoint(0, 0), size());
    drawing_rectangle.adjust(5, 5, -5, -5);
    
    QPointF drawing_rectangle_center(drawing_rectangle.center());
    qreal drawing_rectangle_radius = drawing_rectangle.width() / 2.0;
    
    QPainter p;
    p.begin(this);
    
    p.setRenderHint(QPainter::Antialiasing,     true);
    p.setRenderHint(QPainter::TextAntialiasing, true);
    
    // cercle gris a fond jaune
    p.setPen(QPen(QBrush(QColor("#9FA8A8")), 2.0));
    p.setBrush(QBrush(QColor("#ffffaa")));
    p.drawEllipse(drawing_rectangle);
    
    // ligne rouge indiquant l'angle actuel
    p.setPen(QPen(QBrush(Qt::red), 1.0));
    p.translate(drawing_rectangle_center);
    p.rotate(current_orientation_);
    p.drawLine(QLineF(QPointF(), QPointF(drawing_rectangle_radius, 0.0)));
    
    // texte optionnel
    if (display_text_) {
        // determine le texte a afficher
        QString chosen_text = getMostUsableStringForRadius(drawing_rectangle_radius);
        if (!chosen_text.isEmpty()) {
            p.resetTransform();
            p.setPen(Qt::black);
            p.setFont(text_font_);
            p.translate(drawing_rectangle_center);
            p.rotate(current_orientation_);
            p.drawText(QPoint(), chosen_text);
        }
    }
    
    // carres verts a fond vert
    qreal squares_size = size().width() / 15.0;
    qreal square_offset = - squares_size / 2.0;
    QRectF square_qrect = QRect(square_offset, square_offset, squares_size, squares_size);
    p.setPen(Qt::NoPen);
    p.setBrush(QBrush(QColor("#248A34")));
    for (double drawing_angle = 0.0 ; drawing_angle < 360.0 ; drawing_angle += squares_interval_) {
        if (must_highlight_angle_ && highlight_angle_ == drawing_angle && underMouse()) {
            p.setBrush(QBrush(QColor("#43FF5F")));
        }
        p.resetTransform();
        p.translate(drawing_rectangle_center);
        p.rotate(drawing_angle);
        p.translate(drawing_rectangle_radius - 1.0, 0.0);
        p.rotate(-45.0);
        p.drawRect(square_qrect);
        if (must_highlight_angle_ && highlight_angle_ == drawing_angle) {
            p.setBrush(QBrush(QColor("#248A34")));
        }
    }
    
    p.end();
}

void QTextOrientationWidget::mouseMoveEvent(QMouseEvent *event) {
    if (read_only_) return;
    
    bool drawn_angle_hovered = positionIsASquare(event -> localPos(), &highlight_angle_);
    
    if (must_highlight_angle_ != drawn_angle_hovered) {
        must_highlight_angle_ = drawn_angle_hovered;
        update();
    }
}

void QTextOrientationWidget::mouseReleaseEvent(QMouseEvent *event) {
    if (read_only_) return;
    
    double clicked_angle;
    bool drawn_angle_clicked = positionIsASquare(event -> localPos(), &clicked_angle);
    
    if (drawn_angle_clicked) {
        setOrientation(clicked_angle);
        emit(orientationChanged(clicked_angle));
        must_highlight_angle_ = false;
        update();
    }
}

QString QTextOrientationWidget::getMostUsableStringForRadius(const qreal &radius) {
    // s'assure que l'on connait la longueur de chaque texte a disposition
    generateTextSizeHash();
    
    // recupere les longueurs a disposition
    QList<qreal> available_lengths = text_size_hash_.values();
    // trie les longueurs par ordre croissant
    std::sort(available_lengths.begin(), available_lengths.end());
    // recherche la position ou l'on insererait le rayon
    QList<qreal>::const_iterator i = qUpperBound(available_lengths, radius);
    
    // la valeur precedent cette position est donc celle qui nous interesse
    if (i == available_lengths.begin()) {
        // nous sommes au debut de la liste - nous ne pouvons donc pas afficher de chaine
        return(QString());
    } else {
        -- i;
        qreal final_length = *i;
        QString final_string = text_size_hash_.keys(final_length).first();
        return(final_string);
    }
}

void QTextOrientationWidget::generateTextSizeHash() {
    QFontMetrics font_metrics(text_font_);
    foreach(QString text, text_size_hash_.keys()) {
        if (text_size_hash_[text] == -1) {
            text_size_hash_[text] = font_metrics.boundingRect(text).width();
        }
    }
}

bool QTextOrientationWidget::positionIsASquare(const QPointF &pos, double *angle_value_ptr) {
    // rectangle de travail avec son centre et son rayon
    QRect drawing_rectangle(QPoint(0, 0), size());
    drawing_rectangle.adjust(5, 5, -5, -5);
    
    QPointF drawing_rectangle_center(drawing_rectangle.center());
    qreal drawing_rectangle_radius = drawing_rectangle.width() / 2.0;
    
    qreal squares_size = size().width() / 15.0;
    qreal square_offset = - squares_size / 2.0;
    QRectF square_qrect = QRect(square_offset, square_offset, squares_size, squares_size);
    
    for (double drawing_angle = 0.0 ; drawing_angle < 360.0 ; drawing_angle += squares_interval_) {
        QTransform transform = QTransform()
            .translate(drawing_rectangle_center.x(), drawing_rectangle_center.y())
            .rotate(drawing_angle)
            .translate(drawing_rectangle_radius - 1.0, 0.0)
            .rotate(-45.0);
        
        QRectF mapped_rectangle = transform.mapRect(square_qrect);
        if (mapped_rectangle.contains(pos)) {
            if (angle_value_ptr) *angle_value_ptr = drawing_angle;
            return(true);
        }
    }
    
    return(false);
}