elementview.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 "elementview.h"
#include "qetelementeditor.h"
#include "editorcommands.h"
#include "qetapp.h"
ElementView::ElementView(ElementScene *scene, QWidget *parent) :
    QGraphicsView(scene, parent),
    m_scene(scene),
    offset_paste_count_(0)
{
    grabGesture(Qt::PinchGesture);
    setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
    setInteractive(true);
    setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
    setResizeAnchor(QGraphicsView::AnchorUnderMouse);
    setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
    zoomReset();
    connect(m_scene, SIGNAL(pasteAreaDefined(const QRectF &)), this, SLOT(pasteAreaDefined(const QRectF &)));
    connect(m_scene, SIGNAL(needZoomFit()), this, SLOT(zoomFit()));
}

ElementView::~ElementView() {
}

ElementScene *ElementView::scene() const {
    return(m_scene);
}

QRectF ElementView::viewedSceneRect() const {
    // recupere la taille du widget viewport
    QSize viewport_size = viewport() -> size();
    
    // recupere la transformation viewport -> scene
    QTransform view_to_scene   = viewportTransform().inverted();
    
    // mappe le coin superieur gauche et le coin inferieur droit de la viewport sur la scene
    QPointF scene_left_top     = view_to_scene.map(QPointF(0.0, 0.0));
    QPointF scene_right_bottom = view_to_scene.map(QPointF(viewport_size.width(), viewport_size.height()));
    
    // en deduit le rectangle visualise par la scene
    return(QRectF(scene_left_top, scene_right_bottom));
}

void ElementView::setScene(ElementScene *s) {
    QGraphicsView::setScene(s);
    m_scene = s;
}

void ElementView::setVisualisationMode() {
    setDragMode(ScrollHandDrag);
    setInteractive(false);
    emit(modeChanged());
}

void ElementView::setSelectionMode() {
    setDragMode(RubberBandDrag);
    setInteractive(true);
    emit(modeChanged());
}

void ElementView::zoomIn() {
    adjustSceneRect();
    scale(4.0/3.0, 4.0/3.0);
}

void ElementView::zoomOut() {
    adjustSceneRect();
    scale(0.75, 0.75);
}

void ElementView::zoomInSlowly() {
    scale(1.02, 1.02);
}

void ElementView::zoomOutSlowly() {
    scale(0.98, 0.98);
}

void ElementView::zoomFit() {
    resetSceneRect();
    fitInView(sceneRect(), Qt::KeepAspectRatio);
}

void ElementView::zoomReset() {
    resetSceneRect();
    resetMatrix();
    scale(4.0, 4.0);
}

void ElementView::adjustSceneRect() {
    QRectF esgr = m_scene -> elementSceneGeometricRect();
    QRectF vpbr = mapToScene(this -> viewport()->rect()).boundingRect();
    QRectF new_scene_rect = vpbr.adjusted(-vpbr.width()/3, -vpbr.height()/3, vpbr.width()/3, vpbr.height()/3);
    setSceneRect(new_scene_rect.united(esgr));
}

void ElementView::resetSceneRect() {
    setSceneRect(m_scene -> elementSceneGeometricRect());
}

void ElementView::cut() {
    // delegue cette action a la scene
    m_scene -> cut();
    offset_paste_count_ = -1;
}

void ElementView::copy() {
    // delegue cette action a la scene
    m_scene -> copy();
    offset_paste_count_ = 0;
}

void ElementView::paste() {
    QString clipboard_text = QApplication::clipboard() -> text();
    if (clipboard_text.isEmpty()) return;
    
    QDomDocument document_xml;
    if (!document_xml.setContent(clipboard_text)) return;
    
    if (m_scene -> wasCopiedFromThisElement(clipboard_text)) {
        // copier/coller avec decalage
        pasteWithOffset(document_xml);
    } else {
        // copier/coller par choix de la zone de collage
        QRectF pasted_content_bounding_rect = m_scene -> boundingRectFromXml(document_xml);
        if (pasted_content_bounding_rect.isEmpty()) return;
        
        to_paste_in_area_ = clipboard_text;
        getPasteArea(pasted_content_bounding_rect);
    }
}

void ElementView::pasteInArea() {
    QString clipboard_text = QApplication::clipboard() -> text();
    if (clipboard_text.isEmpty()) return;
    
    QDomDocument document_xml;
    if (!document_xml.setContent(clipboard_text)) return;
    
    QRectF pasted_content_bounding_rect = m_scene -> boundingRectFromXml(document_xml);
    if (pasted_content_bounding_rect.isEmpty()) return;
    
    // copier/coller par choix de la zone de collage
    to_paste_in_area_ = clipboard_text;
    getPasteArea(pasted_content_bounding_rect);
}

ElementContent ElementView::paste(const QPointF &position) {
    QString clipboard_text = QApplication::clipboard() -> text();
    if (clipboard_text.isEmpty()) return(ElementContent());
    
    QDomDocument document_xml;
    if (!document_xml.setContent(clipboard_text)) return(ElementContent());
    
    // objet pour recuperer le contenu ajoute au schema par le coller
    return(paste(document_xml, position));
}

void ElementView::getPasteArea(const QRectF &to_paste) {
    // on copie le rectangle fourni - on s'interesse a ses dimensions, pas a sa position
    QRectF used_rect(to_paste);
    
    // on lui attribue pour centre l'origine du repere
    if (underMouse()) {
        used_rect.moveCenter(mapToScene(mapFromGlobal(QCursor::pos())));
    } else {
        used_rect.moveCenter(QPointF(0.0, 0.0));
    }
    m_scene -> getPasteArea(used_rect);
}

ElementContent ElementView::pasteAreaDefined(const QRectF &target_rect) {
    if (to_paste_in_area_.isEmpty()) return(ElementContent());
    
    QDomDocument xml_document;
    if (!xml_document.setContent(to_paste_in_area_)) {
        to_paste_in_area_.clear();
        return(ElementContent());
    } else {
        return(paste(xml_document, target_rect.topLeft()));
    }
}

ElementContent ElementView::paste(const QDomDocument &xml_document, const QPointF &pos) {
    // objet pour recuperer le contenu ajoute au schema par le coller
    ElementContent content_pasted;
    m_scene -> fromXml(xml_document, pos, false, &content_pasted);
    
    // si quelque chose a effectivement ete ajoute au schema, on cree un objet d'annulation
    if (content_pasted.count()) {
        m_scene -> clearSelection();
        PastePartsCommand *undo_object = new PastePartsCommand(this, content_pasted);
        m_scene -> undoStack().push(undo_object);
    }
    return(content_pasted);
}

ElementContent ElementView::pasteWithOffset(const QDomDocument &xml_document) {
    // objet pour recuperer le contenu ajoute au schema par le coller
    ElementContent content_pasted;
    
    // rectangle source
    QRectF pasted_content_bounding_rect = m_scene -> boundingRectFromXml(xml_document);
    if (pasted_content_bounding_rect.isEmpty()) return(content_pasted);
    
    // copier/coller avec decalage
    QRectF final_pasted_content_bounding_rect;
    ++ offset_paste_count_;
    if (!offset_paste_count_) {
        // the pasted content was cut
        start_top_left_corner_ = pasted_content_bounding_rect.topLeft();
        final_pasted_content_bounding_rect = pasted_content_bounding_rect;
    }
    else {
        // the pasted content was copied
        if (offset_paste_count_ == 1) {
            start_top_left_corner_ = pasted_content_bounding_rect.topLeft();
        } else {
            pasted_content_bounding_rect.moveTopLeft(start_top_left_corner_);
        }
        
        // on applique le decalage qui convient
        final_pasted_content_bounding_rect = applyMovement(
            pasted_content_bounding_rect,
            QETElementEditor::pasteOffset()
        );
    }
    QPointF old_start_top_left_corner = start_top_left_corner_;
    start_top_left_corner_ = final_pasted_content_bounding_rect.topLeft();
    m_scene -> fromXml(xml_document, start_top_left_corner_, false, &content_pasted);
    
    // si quelque chose a effectivement ete ajoute au schema, on cree un objet d'annulation
    if (content_pasted.count()) {
        m_scene -> clearSelection();
        PastePartsCommand *undo_object = new PastePartsCommand(this, content_pasted);
        undo_object -> setOffset(offset_paste_count_ - 1, old_start_top_left_corner, offset_paste_count_, start_top_left_corner_);
        m_scene -> undoStack().push(undo_object);
    }
    return(content_pasted);
}

void ElementView::mousePressEvent(QMouseEvent *e) {
    if (e->buttons() == Qt::MidButton)
    {
        setCursor( (Qt::ClosedHandCursor));
        reference_view_ = e->pos();
    }
    else
        QGraphicsView::mousePressEvent(e);
}

void ElementView::mouseMoveEvent(QMouseEvent *e) {
    if (e->buttons() == Qt::MidButton)
    {
        QScrollBar *h = horizontalScrollBar();
        QScrollBar *v = verticalScrollBar();
        QPointF pos = reference_view_ - e -> pos();
        reference_view_ = e -> pos();
        h -> setValue(h -> value() + pos.x());
        v -> setValue(v -> value() + pos.y());
    }
    else
        QGraphicsView::mouseMoveEvent(e);
}

void ElementView::mouseReleaseEvent(QMouseEvent *e) {
    if (e -> button() == Qt::MidButton) {
        setCursor(Qt::ArrowCursor);
        adjustSceneRect();
        return;
    }
    QGraphicsView::mouseReleaseEvent(e);
}

bool ElementView::gestures() const
{
    QSettings settings;
    return(settings.value("diagramview/gestures", false).toBool());
}


void ElementView::wheelEvent(QWheelEvent *e) {
    //Zoom and scrolling
    if ( gestures() ) {
        if (e -> modifiers() & Qt::ControlModifier)
            e -> delta() > 0 ? zoomInSlowly() : zoomOutSlowly();
        else
            QGraphicsView::wheelEvent(e);
    } else {
        e -> delta() > 0 ? zoomIn(): zoomOut();
    }
}

bool ElementView::event(QEvent *e) {
    // By default touch events are converted to mouse events. So
    // after this event we will get a mouse event also but we want
    // to handle touch events as gestures only. So we need this safeguard
    // to block mouse events that are actually generated from touch.
    if (e->type() == QEvent::Gesture)
        return gestureEvent(static_cast<QGestureEvent *>(e));

    return(QGraphicsView::event(e));
}

bool ElementView::gestureEvent(QGestureEvent *event){
    if (QGesture *gesture = event->gesture(Qt::PinchGesture)) {
        QPinchGesture *pinch = static_cast<QPinchGesture *>(gesture);
        if (pinch->changeFlags() & QPinchGesture::ScaleFactorChanged){
            qreal value = gesture->property("scaleFactor").toReal();
            if (value > 1){
                zoomInSlowly();
            }else{
                zoomOutSlowly();
            }
        }
    }
    return true;
}


void ElementView::drawBackground(QPainter *p, const QRectF &r) {
    p -> save();
    
    // desactive tout antialiasing, sauf pour le texte
    p -> setRenderHint(QPainter::Antialiasing, false);
    p -> setRenderHint(QPainter::TextAntialiasing, true);
    p -> setRenderHint(QPainter::SmoothPixmapTransform, false);
    
    // dessine un fond blanc
    p -> setPen(Qt::NoPen);
    p -> setBrush(Qt::white);
    p -> drawRect(r);
        
    // determine le zoom en cours
    qreal zoom_factor = matrix().m11();
    
    // choisit la granularite de la grille en fonction du zoom en cours
    int drawn_x_grid = 1;//scene_ -> xGrid();
    int drawn_y_grid = 1;//scene_ -> yGrid();
    bool draw_grid = true;
    bool draw_cross = false;

    if (zoom_factor < (4.0/3.0)) { //< no grid
        draw_grid = false;
    } else if (zoom_factor < 4.0) { //< grid 10*10
        drawn_x_grid *= 10;
        drawn_y_grid *= 10;
    }else if (zoom_factor < 8.0) { //< grid 5*5
        drawn_x_grid *= 5;
        drawn_y_grid *= 5;
        draw_cross = true;
    } else if (zoom_factor < 10.0) { //< grid 2*2
        drawn_x_grid *= 2;
        drawn_y_grid *= 2;
        draw_cross = true;  
    } else { //< grid 1*1
        draw_cross = true;
    }

    m_scene->setGrid(drawn_x_grid, drawn_y_grid);
    
    if (draw_grid) {
        // draw the dot of the grid
        QPen pen(Qt::black);
        pen.setCosmetic(true);
        p -> setPen(pen);
        p -> setBrush(Qt::NoBrush);
        qreal limite_x = r.x() + r.width();
        qreal limite_y = r.y() + r.height();
        
        int g_x = (int)ceil(r.x());
        while (g_x % drawn_x_grid) ++ g_x;
        int g_y = (int)ceil(r.y());
        while (g_y % drawn_y_grid) ++ g_y;
        
        for (int gx = g_x ; gx < limite_x ; gx += drawn_x_grid) {
            for (int gy = g_y ; gy < limite_y ; gy += drawn_y_grid) {
                if (draw_cross) {
                    if (!(gx % 10) && !(gy % 10)) {
                        p -> drawLine(QLineF(gx - 0.25, gy, gx + 0.25, gy));
                        p -> drawLine(QLineF(gx, gy - 0.25, gx, gy + 0.25));
                    } else {
                        p -> drawPoint(gx, gy);
                    }
                } else {
                    p -> drawPoint(gx, gy);
                }
            }
        }
    }
    p -> restore();
}

QRectF ElementView::applyMovement(const QRectF &start, const QPointF &offset) {
    // calcule le decalage a appliquer a partir de l'offset
    QPointF final_offset;
    final_offset.rx() =  start.width() + offset.x();

    // applique le decalage ainsi calcule
    return(start.translated(final_offset));
}