Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
last rev
[graphlib.git] / test / hello.cpp
1 /*
2  * Pour compiler
3  * =============
4  *
5  * 1. Créer le fichier hello.pro :
6  *      +------------------------------------------------------------+
7  *      |TARGET = hello                                              |
8  *      |CONFIG += qt debug                                          |
9  *      |SOURCES += hello.cc                                         |
10  *      +------------------------------------------------------------+
11  *
12  * 2. Créer le fichier Makefile avec la commande :
13  *      $ qmake -makefile hello.pro
14  *    ou tout simplement :
15  *      $ qmake -makefile
16  *
17  * 3. Compiler avec la commande :
18  *      $ make hello
19  *    ou tou simplement :
20  *      $ make
21  */
22
23
24 #include <QApplication>
25 #include <QImage>
26 #include <QLabel>
27 #include <QPaintEvent>
28 #include <QPainter>
29 #include <QPixmap>
30 #include <QThread>
31 #include <Qt>
32
33 #include <cmath>
34 #include <iostream>
35 #include <string>
36
37 //============================================================
38 // DrawingAreaInterface
39
40 class DrawingAreaInterface {
41 public:
42     static const int DEFAULT_WIDTH = 640;
43     static const int DEFAULT_HEIGHT = 480;
44
45     virtual ~DrawingAreaInterface() { }
46
47     virtual void setColor(float red, float green, float blue) = 0;
48     virtual void drawPoint(int x, int y) = 0;
49     virtual void drawLine(int x1, int y1, int x2, int y2) = 0;
50     
51     virtual void wait() = 0;
52     virtual void waitAll() = 0;
53 };
54
55 //============================================================
56 // WindowCore
57
58 class WindowCore {
59 private:
60     static int instanceCount;
61     static int DEFAULT_ARGC;
62     static char *DEFAULT_ARGV[];
63
64 protected:
65     WindowCore(int &argc = DEFAULT_ARGC, char *argv[] = DEFAULT_ARGV);
66     ~WindowCore();
67 };
68
69 int WindowCore::instanceCount = 0;
70 int WindowCore::DEFAULT_ARGC = 1;
71 char *WindowCore::DEFAULT_ARGV[] = { "class WindowCore", NULL };
72
73 WindowCore::WindowCore(int &argc, char *argv[])
74 {
75     if (!qApp)
76         new QApplication(argc, argv);
77     else
78         WindowCore::instanceCount++;
79 }
80
81 WindowCore::~WindowCore()
82 {
83     if (WindowCore::instanceCount == 0)
84         delete qApp;
85     else
86         WindowCore::instanceCount--;
87 }
88
89 //============================================================
90 // QtDrawingArea
91
92 class QtDrawingArea: public DrawingAreaInterface,
93                      public WindowCore, public QWidget {
94 private:
95     static int visibleCount;
96
97     QImage *image;
98     QPainter *painter;
99
100 private:
101     void init(int width, int height, const char *title);
102
103 protected:
104     void paintEvent(QPaintEvent *)
105     {
106         QPainter painter(this);
107         painter.drawImage(0, 0, *image);
108     }
109
110     void closeEvent(QCloseEvent *event)
111     {
112         QtDrawingArea::visibleCount--;
113         event->accept();
114     }
115
116     void keyPressEvent(QKeyEvent *event)
117     {
118         if (event->key() == Qt::Key_Escape) {
119             event->accept();
120             close();
121         } else
122             event->ignore();
123     }
124
125 public:
126     QtDrawingArea(int argc, char *argv[],
127                   int width = DEFAULT_WIDTH, int height = DEFAULT_HEIGHT,
128                   const char *title = NULL);
129
130     QtDrawingArea(QWidget *parent, Qt::WindowFlags flags,
131                   int width = DEFAULT_WIDTH, int height = DEFAULT_HEIGHT,
132                   const char *title = NULL);
133
134     QtDrawingArea(int width = DEFAULT_WIDTH, int height = DEFAULT_HEIGHT,
135                   const char *title = NULL);
136
137     ~QtDrawingArea();
138
139     int width() const
140     {
141         return image->width();
142     }
143
144     int height() const
145     {
146         return image->height();
147     }
148
149     void setColor(const QColor &color)
150     {
151         QPen pen(painter->pen());
152         pen.setColor(color);
153         painter->setPen(pen);
154     }
155     void setColor(float red, float green, float blue)
156     {
157         QColor color;
158         color.setRgbF(red, green, blue);
159         this->setColor(color);
160     }
161
162     void drawPoint(int x, int y)
163     {
164         painter->drawPoint(x, y);
165         this->update();
166     }
167
168     void drawLine(int x1, int y1, int x2, int y2)
169     {
170         painter->drawLine(x1, y1, x2, y2);
171         this->update();
172     }
173
174     void flush()
175     {
176         qApp->sendPostedEvents(this, 0);
177         qApp->processEvents();
178         qApp->flush();
179     }
180
181     void wait()
182     {
183         if (QtDrawingArea::visibleCount > 1)
184             while (this->isVisible())
185                 qApp->processEvents(QEventLoop::WaitForMoreEvents);
186         else if (QtDrawingArea::visibleCount > 0)
187             qApp->exec();
188     }
189
190     void waitAll()
191     {
192         if (QtDrawingArea::visibleCount > 0)
193             qApp->exec();
194     }
195 };
196
197 int QtDrawingArea::visibleCount = 0;
198
199 QtDrawingArea::QtDrawingArea(int argc, char *argv[],
200                              int width, int height, const char *title)
201     : WindowCore(argc, argv)
202     , QWidget()
203 {
204     init(width, height, title);
205 }
206
207 QtDrawingArea::QtDrawingArea(QWidget *parent, Qt::WindowFlags flags,
208                              int width, int height, const char *title)
209     : WindowCore()
210     , QWidget(parent, flags)
211 {
212     init(width, height, title);
213 }
214
215 QtDrawingArea::QtDrawingArea(int width, int height, const char *title)
216     : WindowCore()
217     , QWidget()
218 {
219     init(width, height, title);
220 }
221
222 QtDrawingArea::~QtDrawingArea()
223 {
224     delete painter;
225     delete image;
226 }
227
228 void QtDrawingArea::init(int width, int height, const char *title)
229 {
230     if (title)
231         this->setWindowTitle(title);
232     this->setFocusPolicy(Qt::StrongFocus);
233     image = new QImage(width, height, QImage::Format_RGB32);
234     image->fill(QColor(Qt::white).rgb());
235     this->setFixedSize(image->size());
236     QtDrawingArea::visibleCount++;
237     this->show();
238     painter = new QPainter(image);
239 }
240
241
242 //============================================================
243 class DrawingArea: public DrawingAreaInterface {
244 private:
245     QImage *image;
246     QPainter *painter;
247
248 public:
249     DrawingArea(int width = DEFAULT_WIDTH, int height = DEFAULT_HEIGHT);
250     ~DrawingArea();
251
252     int width() const
253     {
254         return image->width();
255     }
256
257     int height() const
258     {
259         return image->height();
260     }
261
262     void setColor(const QColor &color)
263     {
264         QPen pen(painter->pen());
265         pen.setColor(color);
266         painter->setPen(pen);
267     }
268
269     void setColor(float red, float green, float blue)
270     {
271         QColor color;
272         color.setRgbF(red, green, blue);
273         this->setColor(color);
274     }
275
276     void drawPoint(int x, int y)
277     {
278         painter->drawPoint(x, y);
279     }
280
281     void drawLine(int x1, int y1, int x2, int y2)
282     {
283         painter->drawLine(x1, y1, x2, y2);
284     }
285
286 };
287
288 DrawingArea::DrawingArea(int width, int height)
289 {
290     image = new QImage(width, height, QImage::Format_RGB32);
291     image->fill(QColor(Qt::white).rgb());
292     painter = new QPainter(image);
293 }
294
295 DrawingArea::~DrawingArea()
296 {
297     delete painter;
298     delete image;
299 }
300
301 //============================================================
302 class DrawingThreadCore: public QThread {
303 public:
304     void run();
305     virtual void runForReal() = 0;
306 };
307
308 void DrawingThreadCore::run()
309 {
310     this->runForReal();
311 }
312
313 //============================================================
314 class MainDrawinThread: public DrawingThreadCore {
315 public:
316     void runForReal();
317 };
318
319 void MainDrawingThread::runForReal()
320 {
321     // >>> insert main drawing code here <<<
322 }
323
324 //============================================================
325 int main(int argc, char *argv[])
326 {
327     QApplication application(argc, argv);
328     MainDrawingThread mainDrawingThread;
329
330     mainDrawingThread.start();
331
332     return application.exec();
333 }
334
335 //============================================================
336 #if 0
337
338 /* paramètres par défaut */
339 int larg = 600;
340 int haut = 600;
341 float Rmin = -2.05;
342 float Rmax = 0.55;
343 float Imin = -1.3;
344 float Imax = 1.3;
345
346 int maxiter = 100;
347
348 void DrawingThread::run()
349 {
350     int x, y;                   /* le pixel considéré */
351     float cr, ci;               /* le complexe correspondant */
352     float zr, zi;               /* pour calculer la suite */
353     float zr2, zi2;
354     float pr, pi;               /* taille d'un pixel */
355     float rouge, vert, bleu;
356     int i;
357
358     //    QtDrawingArea fen(argc, argv, larg, haut);
359
360     pr = (Rmax - Rmin) / larg;
361     pi = (Imax - Imin) / larg;
362
363     cr = Rmin;
364     for (x = 0; x < larg; x++) {
365         ci = Imin;
366         for (y = 0; y < larg; y++) {
367             /* z_1 = c */
368             zr = cr;
369             zi = ci;
370             for (i = 1; i <= maxiter; i++) {
371                 zr2 = zr * zr;
372                 zi2 = zi * zi;
373                 if (zr2 + zi2 >= 4) {
374                     /* |z| >= 2 : on sort de la boucle */
375                     break;
376                 }
377                 /* on calcule le z suivant */
378                 zi = 2*zr*zi + ci;
379                 zr = zr2 - zi2 + cr;
380             }
381                 /* on est sorti trop t\e-bôt du for(...):\e-A
382                    on affiche le pixel d'un couleur en fonction 
383                    de i */
384                  if (i <= maxiter / 2) {
385                     /* entre rouge et vert */
386                     vert = (2.0 * i) / maxiter;
387                     rouge = 1.0 - vert;
388                     bleu = 0.0;
389                 } else if (i <= maxiter) {
390                     /* entre vert et bleu */
391                     rouge = 0.0;
392                     bleu = (2.0 * i) / maxiter - 1.0;
393                     vert = 1.0 - bleu;
394                 } else /* (i > maxiter) */
395                     rouge = vert = bleu = 0.0;
396                 fen.setColor(rouge, vert, bleu);
397                 fen.drawPoint(x, y);
398
399             ci += pi;
400         }
401         cr += pr;
402         //        fen.flush();
403     }
404     //    fen.wait();
405 }
406
407 #endif