Qt 4.6: renderthread.cpp Example File (threads/queuedcustomtype/renderthread.cpp)

|  | Home · All Classes · Overviews |

# renderthread.cpp Example File
threads/queuedcustomtype/renderthread.cpp

     /****************************************************************************
     **
     ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
     ** Contact: Nokia Corporation (qt-info@nokia.com)
     **
     ** This file is part of the examples of the Qt Toolkit.
     **
     ** $QT_BEGIN_LICENSE:LGPL$
     ** No Commercial Usage
     ** This file contains pre-release code and may not be distributed.
     ** You may use this file in accordance with the terms and conditions
     ** contained in the Technology Preview License Agreement accompanying
     ** this package.
     **
     ** GNU Lesser General Public License Usage
     ** Alternatively, 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.
     **
     ** If you have questions regarding the use of this file, please contact
     ** Nokia at qt-info@nokia.com.
     **
     **
     **
     **
     **
     **
     **
     **
     ** $QT_END_LICENSE$
     **
     ****************************************************************************/

     #include "renderthread.h"

     RenderThread::RenderThread(QObject *parent)
         : QThread(parent)
     {
         m_abort = false;
     }

     RenderThread::~RenderThread()
     {
         mutex.lock();
         m_abort = true;
         mutex.unlock();

         wait();
     }

     void RenderThread::processImage(const QImage &image)
     {
         if (image.isNull())
             return;

         m_image = image;
         m_abort = false;
         start();
     }

     void RenderThread::run()
     {
         int size = qMax(m_image.width()/20, m_image.height()/20);
         for (int s = size; s > 0; --s) {
             for (int c = 0; c < 400; ++c) {
                 int x1 = qMax(0, (qrand() % m_image.width()) - s/2);
                 int x2 = qMin(x1 + s/2 + 1, m_image.width());
                 int y1 = qMax(0, (qrand() % m_image.height()) - s/2);
                 int y2 = qMin(y1 + s/2 + 1, m_image.height());
                 int n = 0;
                 int red = 0;
                 int green = 0;
                 int blue = 0;
                 for (int i = y1; i < y2; ++i) {
                     for (int j = x1; j < x2; ++j) {
                         QRgb pixel = m_image.pixel(j, i);
                         red += qRed(pixel);
                         green += qGreen(pixel);
                         blue += qBlue(pixel);
                         n += 1;
                     }
                 }
                 Block block(QRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1),
                             QColor(red/n, green/n, blue/n));
                 emit sendBlock(block);
                 if (m_abort)
                     return;
                 msleep(10);
             }
         }
     }

     void RenderThread::stopProcess()
     {
         mutex.lock();
         m_abort = true;
         mutex.unlock();
     }