Viadeo Twitter Google Bookmarks ! Facebook Digg del.icio.us MySpace Yahoo MyWeb Blinklist Netvouz Reddit Simpy StumbleUpon Bookmarks Windows Live Favorites 
Logo Documentation Qt ·  Page d'accueil  ·  Toutes les classes  ·  Toutes les fonctions  ·  Vues d'ensemble  · 

pathstroke.cpp Example File

demos/pathstroke/pathstroke.cpp
 /****************************************************************************
 **
 ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the demonstration applications of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** GNU Lesser General Public License Usage
 ** This file may be used under the terms of the GNU Lesser General Public
 ** License version 2.1 as published by the Free Software Foundation and
 ** appearing in the file LICENSE.LGPL included in the packaging of this
 ** file. Please review the following information to ensure the GNU Lesser
 ** General Public License version 2.1 requirements will be met:
 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights. These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU General
 ** Public License version 3.0 as published by the Free Software Foundation
 ** and appearing in the file LICENSE.GPL included in the packaging of this
 ** file. Please review the following information to ensure the GNU General
 ** Public License version 3.0 requirements will be met:
 ** http://www.gnu.org/copyleft/gpl.html.
 **
 ** Other Usage
 ** Alternatively, this file may be used in accordance with the terms and
 ** conditions contained in a signed written agreement between you and Nokia.
 **
 **
 **
 **
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include "pathstroke.h"
 #include "arthurstyle.h"
 #include "arthurwidgets.h"

 #include <stdio.h>

 extern void draw_round_rect(QPainter *p, const QRect &bounds, int radius);

 PathStrokeControls::PathStrokeControls(QWidget* parent, PathStrokeRenderer* renderer, bool smallScreen)
       : QWidget(parent)
 {
     m_renderer = renderer;

     if (smallScreen)
         layoutForSmallScreens();
     else
         layoutForDesktop();
 }

 void PathStrokeControls::createCommonControls(QWidget* parent)
 {
     m_capGroup = new QGroupBox(parent);
     m_capGroup->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
     QRadioButton *flatCap = new QRadioButton(m_capGroup);
     QRadioButton *squareCap = new QRadioButton(m_capGroup);
     QRadioButton *roundCap = new QRadioButton(m_capGroup);
     m_capGroup->setTitle(tr("Cap Style"));
     flatCap->setText(tr("Flat"));
     squareCap->setText(tr("Square"));
     roundCap->setText(tr("Round"));
     flatCap->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     squareCap->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     roundCap->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);

     m_joinGroup = new QGroupBox(parent);
     m_joinGroup->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
     QRadioButton *bevelJoin = new QRadioButton(m_joinGroup);
     QRadioButton *miterJoin = new QRadioButton(m_joinGroup);
     QRadioButton *roundJoin = new QRadioButton(m_joinGroup);
     m_joinGroup->setTitle(tr("Join Style"));
     bevelJoin->setText(tr("Bevel"));
     miterJoin->setText(tr("Miter"));
     roundJoin->setText(tr("Round"));

     m_styleGroup = new QGroupBox(parent);
     m_styleGroup->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
     QRadioButton *solidLine = new QRadioButton(m_styleGroup);
     QRadioButton *dashLine = new QRadioButton(m_styleGroup);
     QRadioButton *dotLine = new QRadioButton(m_styleGroup);
     QRadioButton *dashDotLine = new QRadioButton(m_styleGroup);
     QRadioButton *dashDotDotLine = new QRadioButton(m_styleGroup);
     QRadioButton *customDashLine = new QRadioButton(m_styleGroup);
     m_styleGroup->setTitle(tr("Pen Style"));

     QPixmap line_solid(":res/images/line_solid.png");
     solidLine->setIcon(line_solid);
     solidLine->setIconSize(line_solid.size());
     QPixmap line_dashed(":res/images/line_dashed.png");
     dashLine->setIcon(line_dashed);
     dashLine->setIconSize(line_dashed.size());
     QPixmap line_dotted(":res/images/line_dotted.png");
     dotLine->setIcon(line_dotted);
     dotLine->setIconSize(line_dotted.size());
     QPixmap line_dash_dot(":res/images/line_dash_dot.png");
     dashDotLine->setIcon(line_dash_dot);
     dashDotLine->setIconSize(line_dash_dot.size());
     QPixmap line_dash_dot_dot(":res/images/line_dash_dot_dot.png");
     dashDotDotLine->setIcon(line_dash_dot_dot);
     dashDotDotLine->setIconSize(line_dash_dot_dot.size());
     customDashLine->setText(tr("Custom"));

     int fixedHeight = bevelJoin->sizeHint().height();
     solidLine->setFixedHeight(fixedHeight);
     dashLine->setFixedHeight(fixedHeight);
     dotLine->setFixedHeight(fixedHeight);
     dashDotLine->setFixedHeight(fixedHeight);
     dashDotDotLine->setFixedHeight(fixedHeight);

     m_pathModeGroup = new QGroupBox(parent);
     m_pathModeGroup->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
     QRadioButton *curveMode = new QRadioButton(m_pathModeGroup);
     QRadioButton *lineMode = new QRadioButton(m_pathModeGroup);
     m_pathModeGroup->setTitle(tr("Line Style"));
     curveMode->setText(tr("Curves"));
     lineMode->setText(tr("Lines"));

     // Layouts
     QVBoxLayout *capGroupLayout = new QVBoxLayout(m_capGroup);
     capGroupLayout->addWidget(flatCap);
     capGroupLayout->addWidget(squareCap);
     capGroupLayout->addWidget(roundCap);

     QVBoxLayout *joinGroupLayout = new QVBoxLayout(m_joinGroup);
     joinGroupLayout->addWidget(bevelJoin);
     joinGroupLayout->addWidget(miterJoin);
     joinGroupLayout->addWidget(roundJoin);

     QVBoxLayout *styleGroupLayout = new QVBoxLayout(m_styleGroup);
     styleGroupLayout->addWidget(solidLine);
     styleGroupLayout->addWidget(dashLine);
     styleGroupLayout->addWidget(dotLine);
     styleGroupLayout->addWidget(dashDotLine);
     styleGroupLayout->addWidget(dashDotDotLine);
     styleGroupLayout->addWidget(customDashLine);

     QVBoxLayout *pathModeGroupLayout = new QVBoxLayout(m_pathModeGroup);
     pathModeGroupLayout->addWidget(curveMode);
     pathModeGroupLayout->addWidget(lineMode);

     // Connections
     connect(flatCap, SIGNAL(clicked()), m_renderer, SLOT(setFlatCap()));
     connect(squareCap, SIGNAL(clicked()), m_renderer, SLOT(setSquareCap()));
     connect(roundCap, SIGNAL(clicked()), m_renderer, SLOT(setRoundCap()));

     connect(bevelJoin, SIGNAL(clicked()), m_renderer, SLOT(setBevelJoin()));
     connect(miterJoin, SIGNAL(clicked()), m_renderer, SLOT(setMiterJoin()));
     connect(roundJoin, SIGNAL(clicked()), m_renderer, SLOT(setRoundJoin()));

     connect(curveMode, SIGNAL(clicked()), m_renderer, SLOT(setCurveMode()));
     connect(lineMode, SIGNAL(clicked()), m_renderer, SLOT(setLineMode()));

     connect(solidLine, SIGNAL(clicked()), m_renderer, SLOT(setSolidLine()));
     connect(dashLine, SIGNAL(clicked()), m_renderer, SLOT(setDashLine()));
     connect(dotLine, SIGNAL(clicked()), m_renderer, SLOT(setDotLine()));
     connect(dashDotLine, SIGNAL(clicked()), m_renderer, SLOT(setDashDotLine()));
     connect(dashDotDotLine, SIGNAL(clicked()), m_renderer, SLOT(setDashDotDotLine()));
     connect(customDashLine, SIGNAL(clicked()), m_renderer, SLOT(setCustomDashLine()));

     // Set the defaults:
     flatCap->setChecked(true);
     bevelJoin->setChecked(true);
     curveMode->setChecked(true);
     solidLine->setChecked(true);
 }

 void PathStrokeControls::layoutForDesktop()
 {
     QGroupBox *mainGroup = new QGroupBox(this);
     mainGroup->setFixedWidth(180);
     mainGroup->setTitle(tr("Path Stroking"));

     createCommonControls(mainGroup);

     QGroupBox* penWidthGroup = new QGroupBox(mainGroup);
     QSlider *penWidth = new QSlider(Qt::Horizontal, penWidthGroup);
     penWidth->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
     penWidthGroup->setTitle(tr("Pen Width"));
     penWidth->setRange(0, 500);

     QPushButton *animated = new QPushButton(mainGroup);
     animated->setText(tr("Animate"));
     animated->setCheckable(true);

     QPushButton *showSourceButton = new QPushButton(mainGroup);
     showSourceButton->setText(tr("Show Source"));
 #ifdef QT_OPENGL_SUPPORT
     QPushButton *enableOpenGLButton = new QPushButton(mainGroup);
     enableOpenGLButton->setText(tr("Use OpenGL"));
     enableOpenGLButton->setCheckable(true);
     enableOpenGLButton->setChecked(m_renderer->usesOpenGL());
     if (!QGLFormat::hasOpenGL())
         enableOpenGLButton->hide();
 #endif
     QPushButton *whatsThisButton = new QPushButton(mainGroup);
     whatsThisButton->setText(tr("What's This?"));
     whatsThisButton->setCheckable(true);

     // Layouts:
     QVBoxLayout *penWidthLayout = new QVBoxLayout(penWidthGroup);
     penWidthLayout->addWidget(penWidth);

     QVBoxLayout * mainLayout = new QVBoxLayout(this);
     mainLayout->setMargin(0);
     mainLayout->addWidget(mainGroup);

     QVBoxLayout *mainGroupLayout = new QVBoxLayout(mainGroup);
     mainGroupLayout->setMargin(3);
     mainGroupLayout->addWidget(m_capGroup);
     mainGroupLayout->addWidget(m_joinGroup);
     mainGroupLayout->addWidget(m_styleGroup);
     mainGroupLayout->addWidget(penWidthGroup);
     mainGroupLayout->addWidget(m_pathModeGroup);
     mainGroupLayout->addWidget(animated);
     mainGroupLayout->addStretch(1);
     mainGroupLayout->addWidget(showSourceButton);
 #ifdef QT_OPENGL_SUPPORT
     mainGroupLayout->addWidget(enableOpenGLButton);
 #endif
     mainGroupLayout->addWidget(whatsThisButton);

     // Set up connections
     connect(animated, SIGNAL(toggled(bool)),
             m_renderer, SLOT(setAnimation(bool)));

     connect(penWidth, SIGNAL(valueChanged(int)),
             m_renderer, SLOT(setPenWidth(int)));

     connect(showSourceButton, SIGNAL(clicked()), m_renderer, SLOT(showSource()));
 #ifdef QT_OPENGL_SUPPORT
     connect(enableOpenGLButton, SIGNAL(clicked(bool)), m_renderer, SLOT(enableOpenGL(bool)));
 #endif
     connect(whatsThisButton, SIGNAL(clicked(bool)), m_renderer, SLOT(setDescriptionEnabled(bool)));
     connect(m_renderer, SIGNAL(descriptionEnabledChanged(bool)),
             whatsThisButton, SLOT(setChecked(bool)));

     // Set the defaults
     animated->setChecked(true);
     penWidth->setValue(50);

 }

 void PathStrokeControls::layoutForSmallScreens()
 {
     createCommonControls(this);

     m_capGroup->layout()->setMargin(0);
     m_joinGroup->layout()->setMargin(0);
     m_styleGroup->layout()->setMargin(0);
     m_pathModeGroup->layout()->setMargin(0);

     QPushButton* okBtn = new QPushButton(tr("OK"), this);
     okBtn->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     okBtn->setMinimumSize(100,okBtn->minimumSize().height());

     QPushButton* quitBtn = new QPushButton(tr("Quit"), this);
     quitBtn->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     quitBtn->setMinimumSize(100, okBtn->minimumSize().height());

     QLabel *penWidthLabel = new QLabel(tr(" Width:"));
     QSlider *penWidth = new QSlider(Qt::Horizontal, this);
     penWidth->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
     penWidth->setRange(0, 500);

 #ifdef QT_OPENGL_SUPPORT
     QPushButton *enableOpenGLButton = new QPushButton(this);
     enableOpenGLButton->setText(tr("Use OpenGL"));
     enableOpenGLButton->setCheckable(true);
     enableOpenGLButton->setChecked(m_renderer->usesOpenGL());
     if (!QGLFormat::hasOpenGL())
         enableOpenGLButton->hide();
 #endif

     // Layouts:
     QHBoxLayout *penWidthLayout = new QHBoxLayout(0);
     penWidthLayout->addWidget(penWidthLabel, 0, Qt::AlignRight);
     penWidthLayout->addWidget(penWidth);

     QVBoxLayout *leftLayout = new QVBoxLayout(0);
     leftLayout->addWidget(m_capGroup);
     leftLayout->addWidget(m_joinGroup);
 #ifdef QT_OPENGL_SUPPORT
     leftLayout->addWidget(enableOpenGLButton);
 #endif
     leftLayout->addLayout(penWidthLayout);

     QVBoxLayout *rightLayout = new QVBoxLayout(0);
     rightLayout->addWidget(m_styleGroup);
     rightLayout->addWidget(m_pathModeGroup);

     QGridLayout *mainLayout = new QGridLayout(this);
     mainLayout->setMargin(0);

     // Add spacers around the form items so we don't look stupid at higher resolutions
     mainLayout->addItem(new QSpacerItem(0,0), 0, 0, 1, 4);
     mainLayout->addItem(new QSpacerItem(0,0), 1, 0, 2, 1);
     mainLayout->addItem(new QSpacerItem(0,0), 1, 3, 2, 1);
     mainLayout->addItem(new QSpacerItem(0,0), 3, 0, 1, 4);

     mainLayout->addLayout(leftLayout, 1, 1);
     mainLayout->addLayout(rightLayout, 1, 2);
     mainLayout->addWidget(quitBtn, 2, 1, Qt::AlignHCenter | Qt::AlignTop);
     mainLayout->addWidget(okBtn, 2, 2, Qt::AlignHCenter | Qt::AlignTop);

 #ifdef QT_OPENGL_SUPPORT
     connect(enableOpenGLButton, SIGNAL(clicked(bool)), m_renderer, SLOT(enableOpenGL(bool)));
 #endif

     connect(penWidth, SIGNAL(valueChanged(int)), m_renderer, SLOT(setPenWidth(int)));
     connect(quitBtn, SIGNAL(clicked()), this, SLOT(emitQuitSignal()));
     connect(okBtn, SIGNAL(clicked()), this, SLOT(emitOkSignal()));

     m_renderer->setAnimation(true);
     penWidth->setValue(50);
 }

 void PathStrokeControls::emitQuitSignal()
 {   emit quitPressed();  }

 void PathStrokeControls::emitOkSignal()
 {   emit okPressed();   }

 PathStrokeWidget::PathStrokeWidget(bool smallScreen)
 {
     setWindowTitle(tr("Path Stroking"));

     // Widget construction and property setting
     m_renderer = new PathStrokeRenderer(this, smallScreen);

     m_controls = new PathStrokeControls(0, m_renderer, smallScreen);

     // Layouting
     QHBoxLayout *viewLayout = new QHBoxLayout(this);
     viewLayout->addWidget(m_renderer);

     if (!smallScreen)
         viewLayout->addWidget(m_controls);

     m_renderer->loadSourceFile(":res/pathstroke/pathstroke.cpp");
     m_renderer->loadDescription(":res/pathstroke/pathstroke.html");

     connect(m_renderer, SIGNAL(clicked()), this, SLOT(showControls()));
     connect(m_controls, SIGNAL(okPressed()), this, SLOT(hideControls()));
     connect(m_controls, SIGNAL(quitPressed()), QApplication::instance(), SLOT(quit()));
 }

 void PathStrokeWidget::showControls()
 {
     m_controls->showFullScreen();
 }

 void PathStrokeWidget::hideControls()
 {
     m_controls->hide();
 }

 void PathStrokeWidget::setStyle( QStyle * style )
 {
     QWidget::setStyle(style);
     if (m_controls != 0)
     {
         m_controls->setStyle(style);

         QList<QWidget *> widgets = qFindChildren<QWidget *>(m_controls);
         foreach (QWidget *w, widgets)
             w->setStyle(style);
     }
 }

 PathStrokeRenderer::PathStrokeRenderer(QWidget *parent, bool smallScreen)
     : ArthurFrame(parent)
 {
     m_smallScreen = smallScreen;
     m_pointSize = 10;
     m_activePoint = -1;
     m_capStyle = Qt::FlatCap;
     m_joinStyle = Qt::BevelJoin;
     m_pathMode = CurveMode;
     m_penWidth = 1;
     m_penStyle = Qt::SolidLine;
     m_wasAnimated = true;
     setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     setAttribute(Qt::WA_AcceptTouchEvents);
 }

 void PathStrokeRenderer::paint(QPainter *painter)
 {
     if (m_points.isEmpty())
         initializePoints();

     painter->setRenderHint(QPainter::Antialiasing);

     QPalette pal = palette();
     painter->setPen(Qt::NoPen);

     // Construct the path
     QPainterPath path;
     path.moveTo(m_points.at(0));

     if (m_pathMode == LineMode) {
         for (int i=1; i<m_points.size(); ++i) {
             path.lineTo(m_points.at(i));
         }
     } else {
         int i=1;
         while (i + 2 < m_points.size()) {
             path.cubicTo(m_points.at(i), m_points.at(i+1), m_points.at(i+2));
             i += 3;
         }
         while (i < m_points.size()) {
             path.lineTo(m_points.at(i));
             ++i;
         }
     }

     // Draw the path
     {
         QColor lg = Qt::red;

         // The "custom" pen
         if (m_penStyle == Qt::NoPen) {
             QPainterPathStroker stroker;
             stroker.setWidth(m_penWidth);
             stroker.setJoinStyle(m_joinStyle);
             stroker.setCapStyle(m_capStyle);

             QVector<qreal> dashes;
             qreal space = 4;
             dashes << 1 << space
                    << 3 << space
                    << 9 << space
                    << 27 << space
                    << 9 << space
                    << 3 << space;
             stroker.setDashPattern(dashes);
             QPainterPath stroke = stroker.createStroke(path);
             painter->fillPath(stroke, lg);

         } else {
             QPen pen(lg, m_penWidth, m_penStyle, m_capStyle, m_joinStyle);
             painter->strokePath(path, pen);
         }
     }

     if (1) {
         // Draw the control points
         painter->setPen(QColor(50, 100, 120, 200));
         painter->setBrush(QColor(200, 200, 210, 120));
         for (int i=0; i<m_points.size(); ++i) {
             QPointF pos = m_points.at(i);
             painter->drawEllipse(QRectF(pos.x() - m_pointSize,
                                        pos.y() - m_pointSize,
                                        m_pointSize*2, m_pointSize*2));
         }
         painter->setPen(QPen(Qt::lightGray, 0, Qt::SolidLine));
         painter->setBrush(Qt::NoBrush);
         painter->drawPolyline(m_points);
     }

 }

 void PathStrokeRenderer::initializePoints()
 {
     const int count = 7;
     m_points.clear();
     m_vectors.clear();

     QMatrix m;
     qreal rot = 360 / count;
     QPointF center(width() / 2, height() / 2);
     QMatrix vm;
     vm.shear(2, -1);
     vm.scale(3, 3);

     for (int i=0; i<count; ++i) {
         m_vectors << QPointF(.1f, .25f) * (m * vm);
         m_points << QPointF(0, 100) * m + center;
         m.rotate(rot);
     }
 }

 void PathStrokeRenderer::updatePoints()
 {
     qreal pad = 10;
     qreal left = pad;
     qreal right = width() - pad;
     qreal top = pad;
     qreal bottom = height() - pad;

     Q_ASSERT(m_points.size() == m_vectors.size());
     for (int i=0; i<m_points.size(); ++i) {
         QPointF pos = m_points.at(i);
         QPointF vec = m_vectors.at(i);
         pos += vec;
         if (pos.x() < left || pos.x() > right) {
             vec.setX(-vec.x());
             pos.setX(pos.x() < left ? left : right);
         } if (pos.y() < top || pos.y() > bottom) {
             vec.setY(-vec.y());
             pos.setY(pos.y() < top ? top : bottom);
         }
         m_points[i] = pos;
         m_vectors[i] = vec;
     }
     update();
 }

 void PathStrokeRenderer::mousePressEvent(QMouseEvent *e)
 {
     if (!m_fingerPointMapping.isEmpty())
         return;
     setDescriptionEnabled(false);
     m_activePoint = -1;
     qreal distance = -1;
     for (int i=0; i<m_points.size(); ++i) {
         qreal d = QLineF(e->pos(), m_points.at(i)).length();
         if ((distance < 0 && d < 8 * m_pointSize) || d < distance) {
             distance = d;
             m_activePoint = i;
         }
     }

     if (m_activePoint != -1) {
         m_wasAnimated = m_timer.isActive();
         setAnimation(false);
         mouseMoveEvent(e);
     }

     // If we're not running in small screen mode, always assume we're dragging
     m_mouseDrag = !m_smallScreen;
     m_mousePress = e->pos();
 }

 void PathStrokeRenderer::mouseMoveEvent(QMouseEvent *e)
 {
     if (!m_fingerPointMapping.isEmpty())
         return;
     // If we've moved more then 25 pixels, assume user is dragging
     if (!m_mouseDrag && QPoint(m_mousePress - e->pos()).manhattanLength() > 25)
         m_mouseDrag = true;

     if (m_mouseDrag && m_activePoint >= 0 && m_activePoint < m_points.size()) {
         m_points[m_activePoint] = e->pos();
         update();
     }
 }

 void PathStrokeRenderer::mouseReleaseEvent(QMouseEvent *)
 {
     if (!m_fingerPointMapping.isEmpty())
         return;
     m_activePoint = -1;
     setAnimation(m_wasAnimated);

     if (!m_mouseDrag && m_smallScreen)
         emit clicked();
 }

 void PathStrokeRenderer::timerEvent(QTimerEvent *e)
 {
     if (e->timerId() == m_timer.timerId()) {
         updatePoints();
         QApplication::syncX();
     } // else if (e->timerId() == m_fpsTimer.timerId()) {
 //         emit frameRate(m_frameCount);
 //         m_frameCount = 0;
 //     }
 }

 bool PathStrokeRenderer::event(QEvent *e)
 {
     bool touchBegin = false;
     switch (e->type()) {
     case QEvent::TouchBegin:
         touchBegin = true;
     case QEvent::TouchUpdate:
         {
             const QTouchEvent *const event = static_cast<const QTouchEvent*>(e);
             const QList<QTouchEvent::TouchPoint> points = event->touchPoints();
             foreach (const QTouchEvent::TouchPoint &touchPoint, points) {
                 const int id = touchPoint.id();
                 switch (touchPoint.state()) {
                 case Qt::TouchPointPressed:
                     {
                         // find the point, move it
                         QSet<int> activePoints = QSet<int>::fromList(m_fingerPointMapping.values());
                         int activePoint = -1;
                         qreal distance = -1;
                         const int pointsCount = m_points.size();
                         for (int i=0; i<pointsCount; ++i) {
                             if (activePoints.contains(i))
                                 continue;

                             qreal d = QLineF(touchPoint.pos(), m_points.at(i)).length();
                             if ((distance < 0 && d < 12 * m_pointSize) || d < distance) {
                                 distance = d;
                                 activePoint = i;
                             }
                         }
                         if (activePoint != -1) {
                             m_fingerPointMapping.insert(touchPoint.id(), activePoint);
                             m_points[activePoint] = touchPoint.pos();
                         }
                     }
                     break;
                 case Qt::TouchPointReleased:
                     {
                         // move the point and release
                         QHash<int,int>::iterator it = m_fingerPointMapping.find(id);
                         m_points[it.value()] = touchPoint.pos();
                         m_fingerPointMapping.erase(it);
                     }
                     break;
                 case Qt::TouchPointMoved:
                     {
                         // move the point
                         const int pointIdx = m_fingerPointMapping.value(id, -1);
                         if (pointIdx >= 0)
                             m_points[pointIdx] = touchPoint.pos();
                     }
                     break;
                 default:
                     break;
                 }
             }
             if (m_fingerPointMapping.isEmpty()) {
                 e->ignore();
                 return false;
             } else {
                 if (touchBegin) {
                     m_wasAnimated = m_timer.isActive();
                     setAnimation(false);
                 }
                 update();
                 return true;
             }
         }
         break;
     case QEvent::TouchEnd:
         if (m_fingerPointMapping.isEmpty()) {
             e->ignore();
             return false;
         }
         m_fingerPointMapping.clear();
         setAnimation(m_wasAnimated);
         return true;
         break;
     default:
         break;
     }
     return QWidget::event(e);
 }

 void PathStrokeRenderer::setAnimation(bool animation)
 {
     m_timer.stop();
 //     m_fpsTimer.stop();

     if (animation) {
         m_timer.start(25, this);
 //         m_fpsTimer.start(1000, this);
 //         m_frameCount = 0;
     }
 }
Publicité

Best Of

Actualités les plus lues

Semaine
Mois
Année
  1. « Quelque chose ne va vraiment pas avec les développeurs "modernes" », un développeur à "l'ancienne" critique la multiplication des bibliothèques 81
  2. Apercevoir la troisième dimension ou l'utilisation multithreadée d'OpenGL dans Qt, un article des Qt Quarterly traduit par Guillaume Belz 0
  3. Les développeurs ignorent-ils trop les failles découvertes dans leur code ? Prenez-vous en compte les remarques des autres ? 17
  4. BlackBerry 10 : premières images du prochain OS de RIM qui devrait intégrer des widgets et des tuiles inspirées de Windows Phone 0
  5. Quelles nouveautés de C++11 Visual C++ doit-il rapidement intégrer ? Donnez-nous votre avis 10
  6. Adieu qmake, bienvenue qbs : Qt Building Suite, un outil déclaratif et extensible pour la compilation de projets Qt 17
  7. 2017 : un quinquennat pour une nouvelle version du C++ ? Possible, selon Herb Sutter 6
Page suivante

Le Qt Quarterly au hasard

Logo

Se brancher au Web

Qt Quarterly est la revue trimestrielle proposée par Nokia et à destination des développeurs Qt. Ces articles d'une grande qualité technique sont rédigés par des experts Qt. Lire l'article.

Communauté

Ressources

Liens utiles

Contact

  • Vous souhaitez rejoindre la rédaction ou proposer un tutoriel, une traduction, une question... ? Postez dans le forum Contribuez ou contactez-nous par MP ou par email (voir en bas de page).

Qt dans le magazine

Cette page est une traduction d'une page de la documentation de Qt, écrite par Nokia Corporation and/or its subsidiary(-ies). Les éventuels problèmes résultant d'une mauvaise traduction ne sont pas imputables à Nokia. Qt 4.7
Copyright © 2012 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon, vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
Vous avez déniché une erreur ? Un bug ? Une redirection cassée ? Ou tout autre problème, quel qu'il soit ? Ou bien vous désirez participer à ce projet de traduction ? N'hésitez pas à nous contacter ou par MP !
 
 
 
 
Partenaires

Hébergement Web