Quand vous appelez une fenêtre modale avec Qt, Windows se charge de faire clignoter la bordure de cette dernière.

Par contre, quand elle n’a PAS de bordure (avec le flag Qt::FramelessWindowHint), rien ne se passe.

Résultat ?

L’utilisateur teste votre logiciel, essaie de faire autre chose après avoir ouvert une fenêtre modale en cliquant dans une autre fenêtre de votre application, et absolument rien ne se passe. Il pense qu’il y a un bug, ferme l’application et ne l’ouvre plus jamais parce qu’il a détesté sa première expérience.

Comment régler ce problème ?

J’ai passé énormément de temps pour une si petite chose, puisque personne n’en parle nulle part sur Internet, la documentation de Qt non plus d’ailleurs.

Voici comment j’ai fait.

Je ne dis pas que c’es la meilleure solution, mais c’est un début vers la bonne solution, mais plus important encore : elle fonctionne.

J’ai d’abord essayé d’installer un eventFilter dans la fenêtre modale, mais absolument aucun évènement n’est appellé quand on clique sur une autre fenêtre … bizarre …

Donc j’ai fait l’inverse : J’ai fait hériter toutes mes fenêtres d’une classe QMainWindow, qui capte l’évènement d’activation de fenêtre (QEvent::WindowActivate), pour ensuite vérifier si l’application a une fenêtre modale active (QApplication::activeModalWidget()). Si c’est le cas, je fais clignoter cette fenêtre modale avec un QTimer.

Oui je sais c’est pas très joli, mais je n’ai rien trouvé d’autre après des heures de tatonnement.

Par contre, pour faire les fenêtres modales, il faut faire attention pour que ce code fonctionne.

• D’abord, il ne faut pas qu’elle aille de parent, sans quoi le parent ne recevra pas d’évènement.
• Ensuite, exec() et setModal(true) ne fonctionneront pas, pas plus que setWindowModality(Qt::ApplicationModal). Vous devez utiliser setWindowModality(Qt::WindowModal), avec show()
• Pour finir, ne pas oublier que toutes vos fenêtre doivent hériter de MyMainWindow, et ne pas oublier d’installer un eventFilter, avec
  installEventFilter(this);
  dans le constructeur . Si vous l’avez déjà implémenté, n’oubliez pas de faire au moins: 

  bool YourWindow::eventFilter(QObject *o, QEvent *e)
  {
  	return MyMainWindow::eventFilter(o, e);
  }

Voici la classe en question :

MyMainWindow::MyMainWindow( QWidget *parent, Qt::WindowFlags flags) : QMainWindow(parent, flags), nFlash(0)
{
	timer = new QTimer();
	timer->setInterval(75);
	connect(timer, SIGNAL(timeout()), SLOT(flash()));
}

MyMainWindow::~MyMainWindow()
{
	timer->stop();
	delete timer;
}

void MyMainWindow::flashWindow()
{
	if(nFlash == 0 || nFlash > 5) {
		nFlash = 1;
		timer->start();
	}
}

void MyMainWindow::flash()
{
	QWidget* pWidget = QApplication::activeModalWidget();
    if (pWidget)
    {
		if(!(nFlash % 2)) {
			pWidget->setWindowOpacity(1);

			if(nFlash >= 9){
				timer->stop();
				nFlash = 0;
				return;
			}
		}
		else
			pWidget->setWindowOpacity(.85);

		nFlash++;
	} else {
		timer->stop();
		nFlash = 0;
	}
}

bool MyMainWindow::eventFilter(QObject *o, QEvent *e)
{
	if(e->type() == QEvent::WindowActivate)
	{
		QWidget* pWidget = QApplication::activeModalWidget();
        if (pWidget)
        {
            pWidget->raise();
			pWidget->activateWindow();

			flashWindow(false);

			e->accept();
        }
	}
	return QMainWindow::eventFilter(o, e);
}
class MyMainWindow : public QMainWindow
{
	Q_OBJECT
public:

	MyMainWindow(QWidget *parent=0, Qt::WindowFlags flags = 0);
	~MyMainWindow();
	void flashWindow();

private slots:
	void flash();

protected:
	bool eventFilter(QObject *obj, QEvent *event);

	QTimer *timer;
	int nFlash;
};
 
 
Ensuite, il n'y a qu'àQuand vous appelez une fenêtre modale avec Qt, Windows se charge de faire clignoter la bordure de cette dernière.
Par contre, quand elle n'a PAS de bordure (avec le flag Qt::FramelessWindowHint), rien ne se passe.
Résultat ?
L'utilisateur teste votre logiciel, essaie de faire autre chose après avoir ouvert une fenêtre modale en cliquant dans une autre fenêtre de votre application, et absolument rien ne se passe. Il pense qu'il y a un bug, ferme l'application et ne l'ouvre plus jamais parce qu'il a détesté sa première expérience.
Comment régler ce problème ?
J'ai passé énormément de temps pour une si petite chose, puisque personne n'en parle nulle part sur Internet, la documentation de Qt non plus d'ailleurs.
Voici comment j'ai fait.
Je ne dis pas que c'es la meilleure solution, mais c'est un début vers la bonne solution, mais plus important encore : elle fonctionne.
J'ai d'abord essayé d'installer un eventFilter dans la fenêtre modale, mais absolument aucun évènement n'est appellé quand on clique sur une autre fenêtre ... bizarre ...
Donc j'ai fait l'inverse : J'ai fait hériter toutes mes fenêtres d'une classe QMainWindow, qui capte l'évènement d'activation de fenêtre (QEvent::WindowActivate), pour ensuite vérifier si l'application a une fenêtre modale active (QApplication::activeModalWidget()). Si c'est le cas, je fais clignoter cette fenêtre modale avec un QTimer.
Oui je sais c'est pas très joli, mais je n'ai rien trouvé d'autre après des heures de tatonnement.
Par contre, pour faire les fenêtres modales, il faut faire attention pour que ce code fonctionne.

D'abord, il ne faut pas qu'elle aille de parent, sans quoi le parent ne recevra pas d'évènement.
Ensuite, exec() et setModal(true) ne fonctionneront pas, pas plus que setWindowModality(Qt::ApplicationModal). Vous devez utiliser setWindowModality(Qt::WindowModal), avec show()
Pour finir, ne pas oublier que toutes vos fenêtre doivent hériter de

Voici la classe en question :
 
#include "stdafx.h"
#include "RCSWidget.h"

#include
#include 

MyMainWindow::MyMainWindow( QWidget *parent, Qt::WindowFlags flags) : QMainWindow(parent, flags), nFlash(0)
{
	timer = new QTimer();
	timer->setInterval(75);
	connect(timer, SIGNAL(timeout()), SLOT(flash()));
}

MyMainWindow::~MyMainWindow()
{
	timer->stop();
	delete timer;
}

void MyMainWindow::flashWindow(bool self)
{
	if(nFlash == 0 || nFlash > 5 ||  self != mFlashSelf) {
		nFlash = 1;
		mFlashSelf = self;
		timer->start();
	}
}

void MyMainWindow::flash()
{
	QWidget* pWidget = (mFlashSelf ? this : QApplication::activeModalWidget());
    if (pWidget)
    {
		if(!(nFlash % 2)) {
			pWidget->setWindowOpacity(1);

			if(nFlash >= 9){
				timer->stop();
				nFlash = 0;
				return;
			}
		}
		else
			pWidget->setWindowOpacity(.85);

		nFlash++;
	} else {
		timer->stop();
		nFlash = 0;
	}
}

bool MyMainWindow::eventFilter(QObject *o, QEvent *e)
{
	if(e->type() == QEvent::WindowActivate)
	{
		QWidget* pWidget = QApplication::activeModalWidget();
        if (pWidget)
        {
            pWidget->raise();
			pWidget->activateWindow();

			flashWindow(false);

			e->accept();
        }
	}
	return QMainWindow::eventFilter(o, e);
}
#include
#include 

class RCSMainWindow : public QMainWindow
{
	Q_OBJECT
public:

	RCSMainWindow(QWidget *parent=0, Qt::WindowFlags flags = 0);
	~RCSMainWindow();
	void flashWindow();

private slots:
	void flash();

protected:
	bool eventFilter(QObject *obj, QEvent *event);

	QTimer *timer;
	int nFlash;
};
 
 
Ensuite, il n'y a qu'à
 

QImage img(ui->widget->size, QImage::Format_RGB32);
QPainter painter(&img);
ui->widget->render(&painter);

fileName = QString("%1/%2")
    .arg(QDesktopServices::storageLocation(QDesktopServices::TempLocation))
    .arg("fichierTemporaire.jpg");

img.save(fileName);

Quand vous sousclassez un QWidget pour qu’il aille des comportements différents, il peut être difficile de trouver quelle est la taille des marges, bordures, etc.

Par exemple, si vous voulez sousclasser un QLineEdit pour ajuster automatiquement la taille du texte, vous pouvez trouver le rectangle où le texte est entré avec la méthode suivante : QWidget::contentsRect();

J’ai fait, par exemple, pour ajuster la taille du texte entré :

void QMyLineEdit::onTextChanged ( const QString & text ) {

if(mMaxFontSize == -1)
mMaxFontSize = font().pixelSize();// in the constructor the pixelSize is -1

QFont tmpFont = QFont(font());
tmpFont.setPixelSize(mMaxFontSize);

while(tmpFont.pixelSize() >= mMinFontSize && contentsRect().width() < QFontMetrics(tmpFont).width(QString(" %1 ").arg(text))) {
tmpFont.setPixelSize(tmpFont.pixelSize() - 1);
}
setFont(tmpFont);
}

Qt ne permet pas d’inclure du HTML dans un tableau ou un liste

Par contre, il est possible d’arriver à dessiner du “rich text” grâce à un delegate.

Pour ce qui est de l’implémentation d’un delegate, je vous épargne la théorie, c’est relativement facile, il n’y a qu’à voir les centaines d’exemples sur le web à ce sujet.

Cherchez ‘HTML OR “Rich text” Qt QStyledItemDelegate’ … ou quelque chose du genre pour y arriver, parce qu’effectivement, on doit hériter de QStyledItemDelegate.

Poiur ce qui est de la méthode paint() surchargée, voici un exemple fonctionnel :

void MyTableViewDelegate::paint(QPainter *a_pPainter
   , const QStyleOptionViewItem &a_Option
   , const QModelIndex &a_Index) const
{
   QVariant value = a_Index.data();
   if (value.isValid() && !value.isNull())
   {
      // On crée un document pour y écrire du HTML.
      QTextDocument _Document;
      QStyleOptionViewItemV4 _Options = a_Option;

      initStyleOption(&_Options, a_Index);

      // On enregistre le painter pour qu'il ne soit pas
      // modifié à la fin de la méthode.
      a_pPainter->save();

      QString _Text = _Options.text;

      // Pour voir la sélection, on met le texte en gras
      // si l'item est sélectionné et que la vue a le focus.
      if((a_Option.state & QStyle::State_Selected)
        && (a_Option.state & QStyle::State_HasFocus))
      {
         _Text = "<div style='color:"
            + a_Option.palette.highlightedText().color().name()
            + "; font-weight: bold;'>" + _Text + "</div>";
      }

      // On prends la peine de dessiner un document
      // seulement s'il y a du HTML.
      bool _MightBeRichText;
      if(_MightBeRichText = Qt::mightBeRichText(_Text))
         _Options.text = "";

      // S'il y a du HTML, on dessine un controle vide.
      // Sinon on garde le texte et on laisse tomber le document.

      _Options.widget->style()->drawControl(QStyle::CE_ItemViewItem
      , &_Options, a_pPainter, _Options.widget);

      if(_MightBeRichText)
      {
         // On met le HTML dans le document (pas setText)
         _Document.setHtml(_Text);

         // On centre le document dans le contrôle.
         QPoint _Point = a_Option.rect.center();

	// On bouge le texte s'il y a une icône.
         QSize _IconSize = _Options.icon.actualSize(_Options.rect.size());
         _Point.setX(a_Option.rect.left()
          + _IconSize.width()
          + (_IconSize.width() > 1 ? 4 : 0));
         // avec une petite marge (4px) pour avoir
         // la même apparence que si on dessine
         // le contrôle normalement.

         int _TextHeight = _Document.size().height();
         // On centre le texte verticalement.
         _Point.setY(_Point.y() -  (_TextHeight>>1));
         a_pPainter->translate(_Point);      

         // Finalement on dessine le texte HTML.
         _Document.drawContents(a_pPainter);
      }

      // Et on remet le painter comme il était au départ de la méthode.
      a_pPainter->restore();
   }
}

Voilà !

Ça fonctionne bien pour moi, si vous avez des commentaires, n’hésitez pas.

Vous le savez, gérer la mémoire avec c++ demande une certaine vigilance.

En effet, il faut penser à faire un “delete” quand on fait un “new”.

Par contre avec Qt, une grosse partie a déjà été faite pour vous. Si vous donnez un parent à un objet, quand le parent sera détruit, l’enfant le sera aussi !

Donc, si vous donnez comme parent un object qui est géré par Qt à tout ce que vous créez, plus besoin d’y penser. Bien entendu il y a des exceptions, mais dans ces cas là, on y pense, à notre “delete”, et ça peut causer quelques maux de tête …

Justement parlant d’exceptions qui donnent mal à la tête, Qt y a pensé aussi.

Si vous voulez partager un pointeur dans différentes classes, mais que vous ne savez pas qui doit le détruire, vous ne savez pas si l’objet est créé, s’il a été détruit par Qt par inadvertance …

Qu’à cela ne tienne ! Qt a créé une classe QPointer, qui garde un pointeur, et il peut être utilisé comme un pointeur … à la seule exception près que si l’objet pointé est détruit, QPointer retourne NULL, ce qui peut être très pratique.

Mais ce n’est pas tout, Qt a aussi ajouté une fonctionnalité fort utile aux objets: deleteLater().

Parce que parfois, on veut détruire un objet qui a appelé la fonction qui détruit cet objet … ou en tout cas, un truc qui peut être complexe. Eh bien deleteLater() va détruire l’objet seulement quand tous les évènements qu’il est présentement en train de faire seront terminés.

C’est déjà pas mal pour la gestion de la destruction des objets … mais il existe aussi d’autres fonctions fort utiles, comme qDeleteAll(), qui détruit tous les objets contenus dans une liste.

Vous savez probablement que quand une instance de QWebview a terminé de charger la page en cours, vous pouvez simplement vous connecter à son signal loadFinished(), comme ceci :

connect(ui->webView, SIGNAL(loadFinished(bool)), this, SLOT(vLoadFinished(bool)));

Mais ce que je ne savais pas il n’y a pas si longtemps de cela, c’est que vous pouvez vous connecter avec le “network access manager” (Gestionnaire d’accès réseau) de l’instance du QWebview.

Vous pouvez donc savoir tout ce que votre Webview télécharge (les images, par exemple), et plus important encore, les requêtes qui sont faites APRÈS que le page soit chargée, causée par javascript par exemple.

Pour se faire, vous pouvez connecter le QNetworkAccessManager de votre QWebview, dans votre constructeur :

QNetworkAccessManager _Mgr;
_Mgr = webView->page()->networkAccessManager();

connect(_Mgr, SIGNAL(finished(QNetworkReply*)), this, SLOT(vFinished(QNetworkReply*)));

et ensuite implémenter le slot que vous venez tout juste de créer !

YourWidgetClass::vFinished(QNetworkReply*)
{
reply->request()->url();
}

Vous savez sans doute qu’on peut accéder à la position du curseur grâce au QMouseEvent, en ré implémentant la méthode mouseMoveEvent, par exemple.

Par contre, si vous voulez la position du curseur en dehors de cette méthode pour une quelconque raison, vous n’avez qu’à utiliser une méthode statique de QCursor.

QPoint _Point = _pWidget->mapFromGlobal(QCursor::pos());

Si vous voulez créer un fichier avec QFile, il n’y a pas de fonction comme touch() sur linux, mais vous pouvez facilement créer un fichier vide avec la méthode open().

QFile( _Path ).open( QIODevice::WriteOnly );

En effet, QFile crée automatiquement le fichier s’il n’existe pas et que vous voulez y écrire.

J’ai découvert Qt il y a quelques années, et à chaque fois que je l’utilise, sa facilité d’utilisation m’impressionne. À chaque fois que j’utilise un autre framework, je m’ennuie de Qt.

C’est pourquoi j’ai décidé de créer ce blog pour y inclure les parties qui m’ont donné du mal. Parce que, oui, le cadre d’applications Qt n’est pas infaillible, et parfois il peut être “stupide”, mais je pense que ça ne vaut pas la peine de buter sur ce genre de choses.

De plus, j’aimerais montrer à de nouveaux utilisateurs ce que Qt est capable de faire, parce que quand j’ai commencé, j’étais loin de me douter de tout ce que je pouvais faire avec.

Ceci étant dit, si jamais vous butez sur un problème en Qt, faites-le moi savoir dans les commentaires. Qui sait, peut-être que je vais en faire un prochain post ?