#include <QThread>
#include <QTimerEvent>
-/*! Classe de thread.
- */
+//! Classe de thread.
class DrawingThread: public QThread {
public:
DrawingThread(DrawingWindow &w, DrawingWindow::ThreadFunction f);
DrawTextRequest, //!< Demande d'écriture de texte.
};
-/*! Demande de synchronisation.
- */
+//! Demande de synchronisation.
class SyncRequestEvent: public QEvent {
public:
SyncRequestEvent(): QEvent(static_cast<QEvent::Type>(SyncRequest))
{ }
};
-/*! Demande de fermeture de fenêtre.
- */
+//! Demande de fermeture de fenêtre.
class CloseRequestEvent: public QEvent {
public:
CloseRequestEvent(): QEvent(static_cast<QEvent::Type>(CloseRequest))
{ }
};
-/*! Demande de tracé de texte.
- */
+//! Demande de tracé de texte.
class DrawTextEvent: public QEvent {
public:
const int x;
//--- DrawingWindow ----------------------------------------------------
-/*! Constructeur.
+/*! \class DrawingWindow
+ * \brief Fenêtre de dessin.
*
+ * Bla bla bla
+ */
+
+/*! \typedef DrawingWindow::ThreadFunction
+ * \brief Type de la fonction de dessin, passée en paramètre de construction.
+ */
+/*! \var DrawingWindow::DEFAULT_WIDTH
+ * \brief Largeur par défaut de la fenêtre.
+ */
+/*! \var DrawingWindow::DEFAULT_HEIGHT
+ * \brief Hauteur par défaut de la fenêtre.
+ */
+/*! \var DrawingWindow::width
+ * \brief Largeur de la fenêtre.
+ */
+/*! \var DrawingWindow::height
+ * \brief Hauteur de la fenêtre.
+ */
+/*! \var DrawingWindow::paintInterval
+ * \brief Intervalle de temps entre deux rendus (ms).
+ */
+
+//! Constructeur.
+/*!
* Construit une nouvelle fenêtre de dessin avec les dimensions
* passées en paramètres. La fonction fun sera exécutée dans un
* nouveau thread.
initialize(fun);
}
-/*! Constructeur.
- *
+//! Constructeur.
+/*!
* Construit un nouveau widget de dessin avec les dimensions passées
* en paramètres. La fonction fun sera exécutée dans un nouveau
* thread.
initialize(fun);
}
-/*! Constructeur.
- *
+//! Constructeur.
+/*!
* Construit un nouveau widget de dessin avec les dimensions passées
* en paramètres. La fonction fun sera exécutée dans un nouveau
* thread.
initialize(fun);
}
-/*! Destructeur.
- */
+//! Destructeur.
DrawingWindow::~DrawingWindow()
{
delete thread;
delete image;
}
-/*! Change la couleur de dessin.
- *
+//! Change la couleur de dessin.
+/*!
* La couleur est un entier, tel que retourné par getPointColor.
* Normalement de la forme #00RRGGBB.
*
setColor(QColor::fromRgb(color));
}
-/*! Change la couleur de dessin.
- *
+//! Change la couleur de dessin.
+/*!
* Le nom de couleur est de la forme "black", "white", "red", "blue", ...
*
* \param name nom de couleur
setColor(QColor(name));
}
-/*! Change la couleur de dessin.
- *
+//! Change la couleur de dessin.
+/*!
* Les composantes de rouge, vert et bleu de la couleur doivent être
* compris entre 0 et 1. Si le trois composantes sont à 0, on obtient
* du noir; si les trois composantes sont à 1, on obtient du blanc.
setColor(QColor::fromRgbF(red, green, blue));
}
-/*! Change la couleur de fond.
- *
+//! Change la couleur de fond.
+/*!
* \param color couleur
*
* \see setBgColor(const char *), setBgColor(float, float, float),
setBgColor(QColor::fromRgb(color));
}
-/*! Change la couleur de fond.
- *
+//! Change la couleur de fond.
+/*!
* \param name nom de couleur
*
* \see setBgColor(unsigned int), setBgColor(float, float, float),
setBgColor(QColor(name));
}
-/*! Change la couleur de fond.
- *
+//! Change la couleur de fond.
+/*!
* \param red composante de rouge
* \param green composante de vert
* \param blue composante de bleu
setBgColor(QColor::fromRgbF(red, green, blue));
}
-/*! Efface la fenêtre.
- *
+//! Efface la fenêtre.
+/*!
* La fenêtre est effacée avec la couleur de fond courante.
*
* \see setBgColor
safeUnlock(imageMutex);
}
-/*! Dessine un point.
- *
+//! Dessine un point.
+/*!
* Dessine un point (pixel) aux coordonnées (x, y), avec la couleur de
* dessin courante.
*
safeUnlock(imageMutex);
}
-/*! Dessine un segment.
- *
+//! Dessine un segment.
+/*!
* Dessine un segement de droite entre les coordonnées (x1, y1) et
* (x2, y2), avec la couleur de dessin courante.
*
safeUnlock(imageMutex);
}
-/*! Dessine un rectangle.
- *
+//! Dessine un rectangle.
+/*!
* Dessine le rectangle parallèle aux axes et défini par les
* coordonnées de deux sommets opposés (x1, y1) et (x2, y2). Utilise
* la couleur de dessin courante.
safeUnlock(imageMutex);
}
-/*! Dessine un rectangle plein.
- *
+//! Dessine un rectangle plein.
+/*!
* Dessine le rectangle plein parallèle aux axes et défini par les
* coordonnées de deux sommets opposés (x1, y1) et (x2, y2). Utilise
* la couleur de dessin courante.
painter->setBrush(Qt::NoBrush);
}
-/*! Dessine un cercle.
- *
+//! Dessine un cercle.
+/*!
* Dessine un cercle de centre (x, y) et de rayon r. Utilise la
* couleur de dessin courante.
*
safeUnlock(imageMutex);
}
-/*! Dessine un disque.
- *
+//! Dessine un disque.
+/*!
* Dessine un disque (cercle plein) de centre (x, y) et de rayon r.
* Utilise la couleur de dessin courante.
*
painter->setBrush(Qt::NoBrush);
}
-/*! Écrit du texte.
- *
+//! Écrit du texte.
+/*!
* Écrit le texte text, aux coordonnées (x, y) et avec les paramètres
* d'alignement flags. Le texte est écrit avec la couleur de dessin
* courante. Les flags sont une combinaison (ou binaire) de
safeUnlock(syncMutex);
}
-/*! Écrit du texte sur fond coloré.
- *
+//! Écrit du texte sur fond coloré.
+/*!
* Écrit du texte comme drawText, mais l'arrière-plan est coloré avec
* la couleur de fond courante.
*
}
-/*! Retourne la couleur d'un pixel.
- *
+//! Retourne la couleur d'un pixel.
+/*!
* Retourne la couleur du pixel de coordonnées (x, y). La valeur
* retournée peut servir de paramètres à setColor(unsigned int) ou
* setBgColor(unsigned int).
return image->pixel(x, y);
}
-/*! Synchronise le contenu de la fenêtre.
- *
+//! Synchronise le contenu de la fenêtre.
+/*!
* Pour des raisons d'efficacités, le résultat des fonctions de dessin
* n'est pas affiché immédiatement. L'appel à sync permet de
* synchroniser le contenu de la fenêtre. Autrement dit, cela bloque
return synced;
}
-/*! Ferme la fenêtre graphique.
- */
+//! Ferme la fenêtre graphique.
void DrawingWindow::closeGraph()
{
qApp->postEvent(this, new CloseRequestEvent());
}
-/*! Suspend l'exécution pendant un certain temps.
- *
+//! Suspend l'exécution pendant un certain temps.
+/*!
* \param secs temps d'attente en seconde
*/
void DrawingWindow::sleep(unsigned long secs)
DrawingThread::sleep(secs);
}
-/*! Suspend l'exécution pendant un certain temps.
- *
+//! Suspend l'exécution pendant un certain temps.
+/*!
* \param msecs temps d'attente en millisecondes
*/
void DrawingWindow::msleep(unsigned long msecs)
DrawingThread::msleep(msecs);
}
-/*! Suspend l'exécution pendant un certain temps.
- *
+//! Suspend l'exécution pendant un certain temps.
+/*!
* \param usecs temps d'attente en microsecondes
*/
void DrawingWindow::usleep(unsigned long usecs)
DrawingThread::usleep(usecs);
}
-/*! \see QWidget
+/*!
+ * \see QWidget
*/
void DrawingWindow::closeEvent(QCloseEvent *ev)
{
thread->wait();
}
-/*! \see QWidget
+/*!
+ * \see QWidget
*/
void DrawingWindow::customEvent(QEvent *ev)
{
}
}
-/*! \see QWidget
+/*!
+ * \see QWidget
*/
void DrawingWindow::keyPressEvent(QKeyEvent *ev)
{
ev->accept();
}
-/*! \see QWidget
+/*!
+ * \see QWidget
*/
void DrawingWindow::paintEvent(QPaintEvent *ev)
{
widgetPainter.drawImage(rect, imageCopy, rect);
}
-/*! \see QWidget
+/*!
+ * \see QWidget
*/
void DrawingWindow::showEvent(QShowEvent *ev)
{
thread->start_once(QThread::IdlePriority);
}
-/*! \see QWidget
+/*!
+ * \see QWidget
*/
void DrawingWindow::timerEvent(QTimerEvent *ev)
{
//--- DrawingWindow (private methods) ----------------------------------
-/*! Fonction d'initialisation.
- *
+//! Fonction d'initialisation.
+/*!
* Fonction appelée par les différents constructeurs.
*
* \param fun fonction de dessin
dirtyFlag = false;
}
-/*! Change la couleur de dessin.
- *
+//! Change la couleur de dessin.
+/*!
* \param color couleur
*/
inline
painter->setPen(pen);
}
-/*! Change la couleur de fond.
- *
+//! Change la couleur de fond.
+/*!
* \param color couleur
*/
inline
painter->setBackground(color);
}
-/*! Retourne la couleur de dessin courante.
- *
+//! Retourne la couleur de dessin courante.
+/*!
* \return couleur de dessin courante
*/
inline
return painter->pen().color();
}
-/*! Retourne la couleur de fond courante.
- *
+//! Retourne la couleur de fond courante.
+/*!
* \return couleur de fond courante
*/
inline
return painter->background().color();
}
-/*! Verrouille un mutex.
- *
+//! Verrouille un mutex.
+/*!
* S'assure que le thread courant ne peut pas être terminé s'il
* détient un mutex. Pendant de safeUnlock.
*
mutex.lock();
}
-/*! Déverrouille un mutex.
- *
+//! Déverrouille un mutex.
+/*!
* S'assure que le thread courant ne peut pas être terminé s'il
* détient un mutex. Pendant de safeLock.
*
thread->setTerminationEnabled(true);
}
-/*! Marque l'image entière comme non à jour.
- */
+//! Marque l'image entière comme non à jour.
inline
void DrawingWindow::dirty()
{
dirtyRect = image->rect();
}
-/*! Marque un point de l'image comme non à jour.
- *
+//! Marque un point de l'image comme non à jour.
+/*!
* \param x, y coordonnées du point
*/
inline
dirty(QRect(x, y, 1, 1));
}
-/*! Marque une zone de l'image comme non à jour.
- *
+//! Marque une zone de l'image comme non à jour.
+/*!
* La zone est définie par un rectangle dont les coordonnées de deux
* sommets oppposés sont données.
*
dirty(r.normalized());
}
-/*! Marque une zone de l'image comme non à jour.
- *
+//! Marque une zone de l'image comme non à jour.
+/*!
* \param rect rectangle délimitant la zone
*/
void DrawingWindow::dirty(const QRect &rect)
}
}
-/*! Génère un update si besoin.
- *
+//! Génère un update si besoin.
+/*!
* Génère une demande de mise à jour de la fenêtre (appel à update)
* s'il y en a besoin.
*/
update(rect);
}
-/*! Fonction bas-niveau pour sync.
- *
+//! Fonction bas-niveau pour sync.
+/*!
* Fonction de synchronisation dans le thread principal.
*
* \see sync, customEvent
syncMutex.unlock();
}
-/*! Fonction bas-niveau pour drawText.
- *
+//! Fonction bas-niveau pour drawText.
+/*!
* Le rendu de texte doit être fait dans le thread principal. D'où
* les manipulations tordues et la synchronisation qui s'en suit.
*
//--- DrawingThread ----------------------------------------------------
-/*! Constructeur.
- */
+//! Constructeur.
DrawingThread::DrawingThread(DrawingWindow &w, DrawingWindow::ThreadFunction f)
: drawingWindow(w)
, threadFunction(f)
{
}
-/*! Démarre le thread si ce n'a pas encore été fait.
- */
+//! Démarre le thread si ce n'a pas encore été fait.
void DrawingThread::start_once(Priority priority)
{
if (!started_once) {
}
}
-/*! La vraie fonction pour le thread.
- */
+//! La vraie fonction pour le thread.
void DrawingThread::run()
{
threadFunction(drawingWindow);
