26abc6be6c4d51e83ed5091d4f72116537d0fd27
[occt.git] / samples / qt / FuncDemo / src / graphwidget.cpp
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);
203     painter->fillRect(rect.intersected(sceneRect), gradient);
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 }