mandelbrotwidget.cpp Example File

  /****************************************************************************
  **
  ** Copyright (C) 2016 The Qt Company Ltd.
  ** Contact: https://www.qt.io/licensing/
  **
  ** This file is part of the examples of the Qt Toolkit.
  **
  ** $QT_BEGIN_LICENSE:BSD$
  ** Commercial License Usage
  ** Licensees holding valid commercial Qt licenses may use this file in
  ** accordance with the commercial license agreement provided with the
  ** Software or, alternatively, in accordance with the terms contained in
  ** a written agreement between you and The Qt Company. For licensing terms
  ** and conditions see https://www.qt.io/terms-conditions. For further
  ** information use the contact form at https://www.qt.io/contact-us.
  **
  ** BSD License Usage
  ** Alternatively, you may use this file under the terms of the BSD license
  ** as follows:
  **
  ** "Redistribution and use in source and binary forms, with or without
  ** modification, are permitted provided that the following conditions are
  ** met:
  **   * Redistributions of source code must retain the above copyright
  **     notice, this list of conditions and the following disclaimer.
  **   * Redistributions in binary form must reproduce the above copyright
  **     notice, this list of conditions and the following disclaimer in
  **     the documentation and/or other materials provided with the
  **     distribution.
  **   * Neither the name of The Qt Company Ltd nor the names of its
  **     contributors may be used to endorse or promote products derived
  **     from this software without specific prior written permission.
  **
  **
  ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
  **
  ** $QT_END_LICENSE$
  **
  ****************************************************************************/

  #include <QPainter>
  #include <QKeyEvent>

  #include <math.h>

  #include "mandelbrotwidget.h"

  const double DefaultCenterX = -0.637011f;
  const double DefaultCenterY = -0.0395159f;
  const double DefaultScale = 0.00403897f;

  const double ZoomInFactor = 0.8f;
  const double ZoomOutFactor = 1 / ZoomInFactor;
  const int ScrollStep = 20;

  MandelbrotWidget::MandelbrotWidget(QWidget *parent)
      : QWidget(parent)
  {
      centerX = DefaultCenterX;
      centerY = DefaultCenterY;
      pixmapScale = DefaultScale;
      curScale = DefaultScale;

      connect(&thread, SIGNAL(renderedImage(QImage,double)), this, SLOT(updatePixmap(QImage,double)));

      setWindowTitle(tr("Mandelbrot"));
  #ifndef QT_NO_CURSOR
      setCursor(Qt::CrossCursor);
  #endif
      resize(550, 400);

  }

  void MandelbrotWidget::paintEvent(QPaintEvent * /* event */)
  {
      QPainter painter(this);
      painter.fillRect(rect(), Qt::black);

      if (pixmap.isNull()) {
          painter.setPen(Qt::white);
          painter.drawText(rect(), Qt::AlignCenter, tr("Rendering initial image, please wait..."));
          return;
      }

      if (curScale == pixmapScale) {
          painter.drawPixmap(pixmapOffset, pixmap);
      } else {
          double scaleFactor = pixmapScale / curScale;
          int newWidth = int(pixmap.width() * scaleFactor);
          int newHeight = int(pixmap.height() * scaleFactor);
          int newX = pixmapOffset.x() + (pixmap.width() - newWidth) / 2;
          int newY = pixmapOffset.y() + (pixmap.height() - newHeight) / 2;

          painter.save();
          painter.translate(newX, newY);
          painter.scale(scaleFactor, scaleFactor);
          QRectF exposed = painter.matrix().inverted().mapRect(rect()).adjusted(-1, -1, 1, 1);
          painter.drawPixmap(exposed, pixmap, exposed);
          painter.restore();
      }

      QString text = tr("Use mouse wheel or the '+' and '-' keys to zoom. "
                        "Press and hold left mouse button to scroll.");
      QFontMetrics metrics = painter.fontMetrics();
      int textWidth = metrics.width(text);

      painter.setPen(Qt::NoPen);
      painter.setBrush(QColor(0, 0, 0, 127));
      painter.drawRect((width() - textWidth) / 2 - 5, 0, textWidth + 10, metrics.lineSpacing() + 5);
      painter.setPen(Qt::white);
      painter.drawText((width() - textWidth) / 2, metrics.leading() + metrics.ascent(), text);
  }

  void MandelbrotWidget::resizeEvent(QResizeEvent * /* event */)
  {
      thread.render(centerX, centerY, curScale, size());
  }

  void MandelbrotWidget::keyPressEvent(QKeyEvent *event)
  {
      switch (event->key()) {
      case Qt::Key_Plus:
          zoom(ZoomInFactor);
          break;
      case Qt::Key_Minus:
          zoom(ZoomOutFactor);
          break;
      case Qt::Key_Left:
          scroll(-ScrollStep, 0);
          break;
      case Qt::Key_Right:
          scroll(+ScrollStep, 0);
          break;
      case Qt::Key_Down:
          scroll(0, -ScrollStep);
          break;
      case Qt::Key_Up:
          scroll(0, +ScrollStep);
          break;
      default:
          QWidget::keyPressEvent(event);
      }
  }

  #ifndef QT_NO_WHEELEVENT
  void MandelbrotWidget::wheelEvent(QWheelEvent *event)
  {
      int numDegrees = event->delta() / 8;
      double numSteps = numDegrees / 15.0f;
      zoom(pow(ZoomInFactor, numSteps));
  }
  #endif

  void MandelbrotWidget::mousePressEvent(QMouseEvent *event)
  {
      if (event->button() == Qt::LeftButton)
          lastDragPos = event->pos();
  }

  void MandelbrotWidget::mouseMoveEvent(QMouseEvent *event)
  {
      if (event->buttons() & Qt::LeftButton) {
          pixmapOffset += event->pos() - lastDragPos;
          lastDragPos = event->pos();
          update();
      }
  }

  void MandelbrotWidget::mouseReleaseEvent(QMouseEvent *event)
  {
      if (event->button() == Qt::LeftButton) {
          pixmapOffset += event->pos() - lastDragPos;
          lastDragPos = QPoint();

          int deltaX = (width() - pixmap.width()) / 2 - pixmapOffset.x();
          int deltaY = (height() - pixmap.height()) / 2 - pixmapOffset.y();
          scroll(deltaX, deltaY);
      }
  }

  void MandelbrotWidget::updatePixmap(const QImage &image, double scaleFactor)
  {
      if (!lastDragPos.isNull())
          return;

      pixmap = QPixmap::fromImage(image);
      pixmapOffset = QPoint();
      lastDragPos = QPoint();
      pixmapScale = scaleFactor;
      update();
  }

  void MandelbrotWidget::zoom(double zoomFactor)
  {
      curScale *= zoomFactor;
      update();
      thread.render(centerX, centerY, curScale, size());
  }

  void MandelbrotWidget::scroll(int deltaX, int deltaY)
  {
      centerX += deltaX * curScale;
      centerY += deltaY * curScale;
      update();
      thread.render(centerX, centerY, curScale, size());
  }