[occt.git] / samples / qt / FuncDemo / src / graphwidget.cpp

/****************************************************************************
**
** Copyright (C) 2006-2007 Trolltech ASA. All rights reserved.
**
** This file is part of the example classes of the Qt Toolkit.
**
** Licensees holding a valid Qt License Agreement may use this file in
** accordance with the rights, responsibilities and obligations
** contained therein.  Please consult your licensing agreement or
** contact sales@trolltech.com if any conditions of this licensing
** agreement are not clear to you.
**
** Further information about Qt licensing is available at:
** http://www.trolltech.com/products/qt/licensing.html or by
** contacting info@trolltech.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include "graphwidget.h"
#include "edge.h"
#include "node.h"

#include <QDebug>
#include <QGraphicsScene>
#include <QWheelEvent>
#include <QApplication>

#include <math.h>

#include <TFunction_Iterator.hxx>
#include <TFunction_IFunction.hxx>
#include <TFunction_GraphNode.hxx>
#include <TFunction_Scope.hxx>
#include <TFunction_DriverTable.hxx>
#include <TFunction_Driver.hxx>
#include <TFunction_Function.hxx>

#include <TDataStd_Name.hxx>
#include <TDF_ChildIterator.hxx>
#include <TDF_ListIteratorOfLabelList.hxx>
#include <TColStd_MapIteratorOfMapOfInteger.hxx>

#include "SimpleDriver.h"
#include "PointDriver.h"
#include "CircleDriver.h"
#include "PrismDriver.h"
#include "ConeDriver.h"
#include "CylinderDriver.h"
#include "ShapeSaverDriver.h"
#include "SimpleDriver.h"

GraphWidget::GraphWidget(QWidget* parent):QGraphicsView(parent),
    myThread1(0),myThread2(0),myThread3(0),myThread4(0)
{
    QGraphicsScene *scene = new QGraphicsScene(this);
    scene->setItemIndexMethod(QGraphicsScene::NoIndex);
    scene->setSceneRect(1, 1, parent->width(), parent->height());
    setScene(scene);
    setCacheMode(CacheBackground);
    setRenderHint(QPainter::Antialiasing);
    setTransformationAnchor(AnchorUnderMouse);
    setResizeAnchor(AnchorViewCenter);

    scale(0.7, 0.81);
    setMinimumSize(400, 400);
    setWindowTitle(tr("Function Mechanism"));

    setNbThreads(1);
}

GraphWidget::~GraphWidget()
{
    if (myThread1)
    {
        myThread1->wait();
        myThread1->deleteLater();
    }
    if (myThread2)
    {
        myThread2->wait();
        myThread2->deleteLater();
    }
    if (myThread3)
    {
        myThread3->wait();
        myThread3->deleteLater();
    }
    if (myThread4)
    {
        myThread4->wait();
        myThread4->deleteLater();
    }
}

bool GraphWidget::createModel(const Handle(TDocStd_Document)& doc)
{
    myDocument = doc;
    
    TFunction_Iterator fIterator(myDocument->Main());
    fIterator.SetUsageOfExecutionStatus(false);
    Handle(TFunction_Scope) scope = TFunction_Scope::Set(myDocument->Main());

    // Find out the size of the grid: number of functions in X and Y directions
    int nbx = 0, nby = 0;
    while (!fIterator.Current().IsEmpty())
    {
        const TDF_LabelList& funcs = fIterator.Current();
        if (funcs.Extent() > nbx)
            nbx = funcs.Extent();
        nby++;
        fIterator.Next();
    }
    if (!nbx || !nby)
        return false;

    // Grid of functions
    int dx = width() / nbx, dy = height() / nby;
    int x0 = dx / 2, y0 = dy / 2; // start position

    // Draw functions
    double x = x0, y = y0;
    fIterator.Init(myDocument->Main());
    while (!fIterator.Current().IsEmpty())
    {
        const TDF_LabelList& funcs = fIterator.Current();
        TDF_ListIteratorOfLabelList itrl(funcs);
        for (; itrl.More(); itrl.Next())
        {
            TDF_Label L = itrl.Value();
            Node *node = new Node(this);
            node->setFunction(L);
            scene()->addItem(node);
            node->setPos(x, y);
            x += dx;
            if (x > width())
                x = x0;
        }
        y += dy;
        if (y > height())
            y = y0;
        fIterator.Next();
    }

    // Draw dependencies
    fIterator.Init(myDocument->Main());
    while (!fIterator.Current().IsEmpty())
    {
        const TDF_LabelList& funcs = fIterator.Current();
        TDF_ListIteratorOfLabelList itrl(funcs);
        for (; itrl.More(); itrl.Next())
        {
            TDF_Label L = itrl.Value();
            Node* node = findNode(L);
            if (!node)
                continue;

            // Find backward dependencies of the function
            TFunction_IFunction iFunc(L);
            Handle(TFunction_GraphNode) graphNode = iFunc.GetGraphNode();
            const TColStd_MapOfInteger& prev = graphNode->GetPrevious();
            TColStd_MapIteratorOfMapOfInteger itrm(prev);
            for (; itrm.More(); itrm.Next())
            {
                const int argID = itrm.Key();
                const TDF_Label& argL = scope->GetFunction(argID);
                Node* n = findNode(argL);
                if (!n)
                    continue;
                scene()->addItem(new Edge(n, node));
            }
        }
        fIterator.Next();
    }

    return !myDocument.IsNull();
}

void GraphWidget::wheelEvent(QWheelEvent *event)
{
    scaleView(pow((double)2, -event->delta() / 240.0));
}

void GraphWidget::drawBackground(QPainter *painter, const QRectF &rect)
{
    Q_UNUSED(rect);

    // Shadow
    QRectF sceneRect = this->sceneRect();
    QRectF rightShadow(sceneRect.right(), sceneRect.top() + 5, 5, sceneRect.height());
    QRectF bottomShadow(sceneRect.left() + 5, sceneRect.bottom(), sceneRect.width(), 5);
    if (rightShadow.intersects(rect) || rightShadow.contains(rect))
	painter->fillRect(rightShadow, Qt::darkGray);
    if (bottomShadow.intersects(rect) || bottomShadow.contains(rect))
	painter->fillRect(bottomShadow, Qt::darkGray);

    // Fill
    QLinearGradient gradient(sceneRect.topLeft(), sceneRect.bottomRight());
    gradient.setColorAt(0, Qt::white);
    gradient.setColorAt(1, Qt::lightGray);
    painter->fillRect(rect.intersected(sceneRect), gradient);
    painter->setBrush(Qt::NoBrush);
    painter->drawRect(sceneRect);
}

void GraphWidget::scaleView(qreal scaleFactor)
{
    qreal factor = matrix().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)).width();
    if (factor < 0.07 || factor > 100)
        return;

    scale(scaleFactor, scaleFactor);
}

// Find node of the function
Node* GraphWidget::findNode(const TDF_Label& L)
{
    Node* node = 0;
    for (int i = 0; i < scene()->items().size(); i++)
    {
        Node* n = qgraphicsitem_cast<Node *>(scene()->items().at(i));
        if (n && n->getFunction() == L)
        {
            node = n;
            break;
        }
    }
    return node;
}

void GraphWidget::compute()
{
    myNbFinishedThreads = 0;

    TFunction_Iterator fIterator(myDocument->Main());
    fIterator.SetUsageOfExecutionStatus(true);

    myThread1 = new FThread();
    if (myNbThreads > 1)
        myThread2 = new FThread();
    if (myNbThreads > 2)
        myThread3 = new FThread();
    if (myNbThreads > 3)
        myThread4 = new FThread();

    // Logbook
    Handle(TFunction_Logbook) log = TFunction_Scope::Set(myDocument->Main())->GetLogbook();
    myThread1->setLogbook(log);
    if (myNbThreads > 1)
        myThread2->setLogbook(log);
    if (myNbThreads > 2)
        myThread3->setLogbook(log);
    if (myNbThreads > 3)
        myThread4->setLogbook(log);

    myThread1->setIterator(fIterator);
    if (myNbThreads > 1)
        myThread2->setIterator(fIterator);
    if (myNbThreads > 2)
        myThread3->setIterator(fIterator);
    if (myNbThreads > 3)
        myThread4->setIterator(fIterator);

    myThread1->setGraph(this);
    if (myNbThreads > 1)
        myThread2->setGraph(this);
    if (myNbThreads > 2)
        myThread3->setGraph(this);
    if (myNbThreads > 3)
        myThread4->setGraph(this);

    myThread1->setThreadIndex(1);
    if (myNbThreads > 1)
        myThread2->setThreadIndex(2);
    if (myNbThreads > 2)
        myThread3->setThreadIndex(3);
    if (myNbThreads > 3)
        myThread4->setThreadIndex(4);

    QThread::Priority priority = QThread::LowestPriority;
    if (!myThread1->isRunning())
        myThread1->start(priority);
    if (myNbThreads > 1 && !myThread2->isRunning())
        myThread2->start(priority);
    if (myNbThreads > 2 && !myThread3->isRunning())
        myThread3->start(priority);
    if (myNbThreads > 3 && !myThread4->isRunning())
        myThread4->start(priority);
}

void GraphWidget::setNbThreads(const int nb)
{
    myNbThreads = nb;
    if (myNbThreads < 4 && myThread4)
    {
        myThread4->wait();
        myThread4->deleteLater();
        myThread4 = 0;
    }
    if (myNbThreads < 3 && myThread3)
    {
        myThread3->wait();
        myThread3->deleteLater();
        myThread3 = 0;
    }
    if (myNbThreads < 2 && myThread2)
    {
        myThread2->wait();
        myThread2->deleteLater();
        myThread2 = 0;
    }

    for (int i = 1; i <= myNbThreads; i++)
    {
        TFunction_DriverTable::Get()->AddDriver(PointDriver::GetID(), new PointDriver(), i);
        TFunction_DriverTable::Get()->AddDriver(CircleDriver::GetID(), new CircleDriver(), i);
        TFunction_DriverTable::Get()->AddDriver(PrismDriver::GetID(), new PrismDriver(), i);
        TFunction_DriverTable::Get()->AddDriver(ConeDriver::GetID(), new ConeDriver(), i);
        TFunction_DriverTable::Get()->AddDriver(CylinderDriver::GetID(), new CylinderDriver(), i);
        TFunction_DriverTable::Get()->AddDriver(ShapeSaverDriver::GetID(), new ShapeSaverDriver(), i);
        TFunction_DriverTable::Get()->AddDriver(SimpleDriver::GetID(), new SimpleDriver(), i);
    }
}

int GraphWidget::getNbThreads()
{
    return myNbThreads;
}

void GraphWidget::setFinished()
{
    myNbFinishedThreads++;
}

bool GraphWidget::isFinished()
{
    return myNbThreads == myNbFinishedThreads ;
}

void GraphWidget::accelerateThread(const int thread_index)
{
    bool all_slow = true;
    if (myThread1 && myThread1->priority() != QThread::LowPriority)
        all_slow = false;
    if (all_slow && myThread2 && myThread2->priority() != QThread::LowPriority)
        all_slow = false;
    if (all_slow && myThread3 && myThread3->priority() != QThread::LowPriority)
        all_slow = false;
    if (all_slow && myThread4 && myThread4->priority() != QThread::LowPriority)
        all_slow = false;
    if (!all_slow)
        return;

    QThread::Priority priority = QThread::NormalPriority;
    switch (thread_index)
    {
    case 1:
        myThread1->setPriority(priority);
        break;
    case 2:
        myThread2->setPriority(priority);
        break;
    case 3:
        myThread3->setPriority(priority);
        break;
    case 4:
        myThread4->setPriority(priority);
        break;
    }
}

void GraphWidget::slowDownThread(const int thread_index)
{
    QThread::Priority priority = QThread::LowPriority;
    switch (thread_index)
    {
    case 1:
        myThread1->setPriority(priority);
        break;
    case 2:
        myThread2->setPriority(priority);
        break;
    case 3:
        myThread3->setPriority(priority);
        break;
    case 4:
        myThread4->setPriority(priority);
        break;
    }
}
Commit	Line	Data
aff5997d	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2006-2007 Trolltech ASA. All rights reserved.
	4	**
	5	** This file is part of the example classes of the Qt Toolkit.
	6	**
	7	** Licensees holding a valid Qt License Agreement may use this file in
	8	** accordance with the rights, responsibilities and obligations
	9	** contained therein. Please consult your licensing agreement or
	10	** contact sales@trolltech.com if any conditions of this licensing
	11	** agreement are not clear to you.
	12	**
	13	** Further information about Qt licensing is available at:
	14	** http://www.trolltech.com/products/qt/licensing.html or by
	15	** contacting info@trolltech.com.
	16	**
	17	** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
	18	** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	19	**
	20	****************************************************************************/
	21
	22	#include "graphwidget.h"
	23	#include "edge.h"
	24	#include "node.h"
	25
	26	#include <QDebug>
	27	#include <QGraphicsScene>
	28	#include <QWheelEvent>
	29	#include <QApplication>
	30
	31	#include <math.h>
	32
	33	#include <TFunction_Iterator.hxx>
	34	#include <TFunction_IFunction.hxx>
	35	#include <TFunction_GraphNode.hxx>
	36	#include <TFunction_Scope.hxx>
	37	#include <TFunction_DriverTable.hxx>
	38	#include <TFunction_Driver.hxx>
	39	#include <TFunction_Function.hxx>
	40
	41	#include <TDataStd_Name.hxx>
	42	#include <TDF_ChildIterator.hxx>
	43	#include <TDF_ListIteratorOfLabelList.hxx>
	44	#include <TColStd_MapIteratorOfMapOfInteger.hxx>
	45
	46	#include "SimpleDriver.h"
	47	#include "PointDriver.h"
	48	#include "CircleDriver.h"
	49	#include "PrismDriver.h"
	50	#include "ConeDriver.h"
	51	#include "CylinderDriver.h"
	52	#include "ShapeSaverDriver.h"
	53	#include "SimpleDriver.h"
	54
	55	GraphWidget::GraphWidget(QWidget* parent):QGraphicsView(parent),
	56	myThread1(0),myThread2(0),myThread3(0),myThread4(0)
	57	{
	58	QGraphicsScene *scene = new QGraphicsScene(this);
	59	scene->setItemIndexMethod(QGraphicsScene::NoIndex);
	60	scene->setSceneRect(1, 1, parent->width(), parent->height());
	61	setScene(scene);
	62	setCacheMode(CacheBackground);
	63	setRenderHint(QPainter::Antialiasing);
	64	setTransformationAnchor(AnchorUnderMouse);
65	setResizeAnchor(AnchorViewCenter);
66
67	scale(0.7, 0.81);
68	setMinimumSize(400, 400);
69	setWindowTitle(tr("Function Mechanism"));
70
71	setNbThreads(1);
72	}
73
74	GraphWidget::~GraphWidget()
75	{
76	if (myThread1)
77	{
78	myThread1->wait();
79	myThread1->deleteLater();
80	}
81	if (myThread2)
82	{
83	myThread2->wait();
84	myThread2->deleteLater();
85	}
86	if (myThread3)
87	{
88	myThread3->wait();
89	myThread3->deleteLater();
90	}
91	if (myThread4)
92	{
93	myThread4->wait();
94	myThread4->deleteLater();
95	}
96	}
97
98	bool GraphWidget::createModel(const Handle(TDocStd_Document)& doc)
99	{
100	myDocument = doc;
101
102	TFunction_Iterator fIterator(myDocument->Main());
103	fIterator.SetUsageOfExecutionStatus(false);
104	Handle(TFunction_Scope) scope = TFunction_Scope::Set(myDocument->Main());
105
106	// Find out the size of the grid: number of functions in X and Y directions
107	int nbx = 0, nby = 0;
108	while (!fIterator.Current().IsEmpty())
109	{
110	const TDF_LabelList& funcs = fIterator.Current();
111	if (funcs.Extent() > nbx)
112	nbx = funcs.Extent();
113	nby++;
114	fIterator.Next();
115	}
116	if (!nbx \|\| !nby)
117	return false;
118
119	// Grid of functions
120	int dx = width() / nbx, dy = height() / nby;
121	int x0 = dx / 2, y0 = dy / 2; // start position
122
123	// Draw functions
124	double x = x0, y = y0;
125	fIterator.Init(myDocument->Main());
126	while (!fIterator.Current().IsEmpty())
127	{
128	const TDF_LabelList& funcs = fIterator.Current();
129	TDF_ListIteratorOfLabelList itrl(funcs);
130	for (; itrl.More(); itrl.Next())
131	{
132	TDF_Label L = itrl.Value();
133	Node *node = new Node(this);
134	node->setFunction(L);
135	scene()->addItem(node);
136	node->setPos(x, y);
137	x += dx;
138	if (x > width())
139	x = x0;
140	}
141	y += dy;
142	if (y > height())
143	y = y0;
144	fIterator.Next();
145	}
146
147	// Draw dependencies
148	fIterator.Init(myDocument->Main());
149	while (!fIterator.Current().IsEmpty())
150	{
151	const TDF_LabelList& funcs = fIterator.Current();
152	TDF_ListIteratorOfLabelList itrl(funcs);
153	for (; itrl.More(); itrl.Next())
154	{
155	TDF_Label L = itrl.Value();
156	Node* node = findNode(L);
157	if (!node)
158	continue;
159
160	// Find backward dependencies of the function
161	TFunction_IFunction iFunc(L);
162	Handle(TFunction_GraphNode) graphNode = iFunc.GetGraphNode();
163	const TColStd_MapOfInteger& prev = graphNode->GetPrevious();
164	TColStd_MapIteratorOfMapOfInteger itrm(prev);
165	for (; itrm.More(); itrm.Next())
166	{
167	const int argID = itrm.Key();
168	const TDF_Label& argL = scope->GetFunction(argID);
169	Node* n = findNode(argL);
170	if (!n)
171	continue;
172	scene()->addItem(new Edge(n, node));
173	}
174	}
175	fIterator.Next();
176	}
177
178	return !myDocument.IsNull();
179	}
180
181	void GraphWidget::wheelEvent(QWheelEvent *event)
182	{
183	scaleView(pow((double)2, -event->delta() / 240.0));
184	}
185
186	void GraphWidget::drawBackground(QPainter *painter, const QRectF &rect)
187	{
188	Q_UNUSED(rect);
189
190	// Shadow
191	QRectF sceneRect = this->sceneRect();
192	QRectF rightShadow(sceneRect.right(), sceneRect.top() + 5, 5, sceneRect.height());
193	QRectF bottomShadow(sceneRect.left() + 5, sceneRect.bottom(), sceneRect.width(), 5);
194	if (rightShadow.intersects(rect) \|\| rightShadow.contains(rect))
195	painter->fillRect(rightShadow, Qt::darkGray);
196	if (bottomShadow.intersects(rect) \|\| bottomShadow.contains(rect))
197	painter->fillRect(bottomShadow, Qt::darkGray);
198
199	// Fill
200	QLinearGradient gradient(sceneRect.topLeft(), sceneRect.bottomRight());
201	gradient.setColorAt(0, Qt::white);
202	gradient.setColorAt(1, Qt::lightGray);
caee72a9	203	painter->fillRect(rect.intersected(sceneRect), gradient);
aff5997d	204	painter->setBrush(Qt::NoBrush);
	205	painter->drawRect(sceneRect);
	206	}
	207
	208	void GraphWidget::scaleView(qreal scaleFactor)
	209	{
	210	qreal factor = matrix().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)).width();
	211	if (factor < 0.07 \|\| factor > 100)
	212	return;
	213
	214	scale(scaleFactor, scaleFactor);
	215	}
	216
	217	// Find node of the function
	218	Node* GraphWidget::findNode(const TDF_Label& L)
	219	{
	220	Node* node = 0;
	221	for (int i = 0; i < scene()->items().size(); i++)
	222	{
	223	Node* n = qgraphicsitem_cast<Node *>(scene()->items().at(i));
	224	if (n && n->getFunction() == L)
	225	{
	226	node = n;
	227	break;
	228	}
	229	}
	230	return node;
	231	}
	232
	233	void GraphWidget::compute()
	234	{
	235	myNbFinishedThreads = 0;
	236
	237	TFunction_Iterator fIterator(myDocument->Main());
	238	fIterator.SetUsageOfExecutionStatus(true);
	239
	240	myThread1 = new FThread();
	241	if (myNbThreads > 1)
	242	myThread2 = new FThread();
	243	if (myNbThreads > 2)
	244	myThread3 = new FThread();
	245	if (myNbThreads > 3)
	246	myThread4 = new FThread();
	247
	248	// Logbook
	249	Handle(TFunction_Logbook) log = TFunction_Scope::Set(myDocument->Main())->GetLogbook();
	250	myThread1->setLogbook(log);
	251	if (myNbThreads > 1)
	252	myThread2->setLogbook(log);
	253	if (myNbThreads > 2)
	254	myThread3->setLogbook(log);
	255	if (myNbThreads > 3)
	256	myThread4->setLogbook(log);
	257
	258	myThread1->setIterator(fIterator);
	259	if (myNbThreads > 1)
	260	myThread2->setIterator(fIterator);
	261	if (myNbThreads > 2)
	262	myThread3->setIterator(fIterator);
	263	if (myNbThreads > 3)
	264	myThread4->setIterator(fIterator);
	265
	266	myThread1->setGraph(this);
	267	if (myNbThreads > 1)
268	myThread2->setGraph(this);
269	if (myNbThreads > 2)
270	myThread3->setGraph(this);
271	if (myNbThreads > 3)
272	myThread4->setGraph(this);
273
274	myThread1->setThreadIndex(1);
275	if (myNbThreads > 1)
276	myThread2->setThreadIndex(2);
277	if (myNbThreads > 2)
278	myThread3->setThreadIndex(3);
279	if (myNbThreads > 3)
280	myThread4->setThreadIndex(4);
281
282	QThread::Priority priority = QThread::LowestPriority;
283	if (!myThread1->isRunning())
284	myThread1->start(priority);
285	if (myNbThreads > 1 && !myThread2->isRunning())
286	myThread2->start(priority);
287	if (myNbThreads > 2 && !myThread3->isRunning())
288	myThread3->start(priority);
289	if (myNbThreads > 3 && !myThread4->isRunning())
290	myThread4->start(priority);
291	}
292
293	void GraphWidget::setNbThreads(const int nb)
294	{
295	myNbThreads = nb;
296	if (myNbThreads < 4 && myThread4)
297	{
298	myThread4->wait();
299	myThread4->deleteLater();
300	myThread4 = 0;
301	}
302	if (myNbThreads < 3 && myThread3)
303	{
304	myThread3->wait();
305	myThread3->deleteLater();
306	myThread3 = 0;
307	}
308	if (myNbThreads < 2 && myThread2)
309	{
310	myThread2->wait();
311	myThread2->deleteLater();
312	myThread2 = 0;
313	}
314
315	for (int i = 1; i <= myNbThreads; i++)
316	{
317	TFunction_DriverTable::Get()->AddDriver(PointDriver::GetID(), new PointDriver(), i);
318	TFunction_DriverTable::Get()->AddDriver(CircleDriver::GetID(), new CircleDriver(), i);
319	TFunction_DriverTable::Get()->AddDriver(PrismDriver::GetID(), new PrismDriver(), i);
320	TFunction_DriverTable::Get()->AddDriver(ConeDriver::GetID(), new ConeDriver(), i);
321	TFunction_DriverTable::Get()->AddDriver(CylinderDriver::GetID(), new CylinderDriver(), i);
322	TFunction_DriverTable::Get()->AddDriver(ShapeSaverDriver::GetID(), new ShapeSaverDriver(), i);
323	TFunction_DriverTable::Get()->AddDriver(SimpleDriver::GetID(), new SimpleDriver(), i);
324	}
325	}
326
327	int GraphWidget::getNbThreads()
328	{
329	return myNbThreads;
330	}
331
332	void GraphWidget::setFinished()
333	{
334	myNbFinishedThreads++;
335	}
336
337	bool GraphWidget::isFinished()
338	{
339	return myNbThreads == myNbFinishedThreads ;
340	}
341
342	void GraphWidget::accelerateThread(const int thread_index)
343	{
344	bool all_slow = true;
345	if (myThread1 && myThread1->priority() != QThread::LowPriority)
346	all_slow = false;
347	if (all_slow && myThread2 && myThread2->priority() != QThread::LowPriority)
348	all_slow = false;
349	if (all_slow && myThread3 && myThread3->priority() != QThread::LowPriority)
350	all_slow = false;
351	if (all_slow && myThread4 && myThread4->priority() != QThread::LowPriority)
352	all_slow = false;
353	if (!all_slow)
354	return;
355
356	QThread::Priority priority = QThread::NormalPriority;
357	switch (thread_index)
358	{
359	case 1:
360	myThread1->setPriority(priority);
361	break;
362	case 2:
363	myThread2->setPriority(priority);
364	break;
365	case 3:
366	myThread3->setPriority(priority);
367	break;
368	case 4:
369	myThread4->setPriority(priority);
370	break;
371	}
372	}
373
374	void GraphWidget::slowDownThread(const int thread_index)
375	{
376	QThread::Priority priority = QThread::LowPriority;
377	switch (thread_index)
378	{
379	case 1:
380	myThread1->setPriority(priority);
381	break;
382	case 2:
383	myThread2->setPriority(priority);
384	break;
385	case 3:
386	myThread3->setPriority(priority);
387	break;
388	case 4:
389	myThread4->setPriority(priority);
390	break;
391	}
392	}