La gestion des événements dans Qt

Je suis nouveau sur Qt GUI programmation et viennent de un .NET/Winforms fond comme mesure du développement du GUI va. Je suis à l'aide de l'IDE Qt Creator.

Comment puis-je traiter un bouton de presse de l'événement de Qt pour faire quelque chose comme ce qui suit:

if (button.clicked = true)
{
    startProgram();
}

Aussi, comment pourrais-je rechercher un fichier de configuration qui permettraient d'alimenter des valeurs dans l'ensemble de ma ligne de modifier des zones de texte lors de l'ouverture? Je suis de la programmation, cette en C++.

MODIFIER: je suis prise d'une application de console que quelqu'un d'autre a écrit et la construction d'une interface graphique autour d'elle. Je veux accéder à l'une des fonctions de y à partir d'un événement de clic de bouton. Cependant, je ne peux pas comprendre comment obtenir les fonctions de l'application d'origine pour être dans le champ d'application de la GUI que j'ai créé lorsque j'essaie d'utiliser les SIGNAUX et les SLOTS.

Je vous suggère de suivre des tutoriels Qt doc.qt.nokia.com/latest/tutorials.html
Êtes-vous l'intention de l'utiliser QML, ou le concepteur d'INTERFACE utilisateur? Cela fait une énorme différence.
Je suis en utilisant le concepteur d'INTERFACE utilisateur.

OriginalL'auteur THE DOCTOR | 2011-07-15

button c++event-handling qt user-interface

1

Afin d'accéder à des fonctions définies dans l'application de console, vous devez inclure les en-têtes (.h/.hpp) que déclarer ces fonctions, et de faire le lien entre leur mise en œuvre. Je vous le code source de l'implémentation (.rpc), vous devez les ajouter à la sources à compiler (ils seront compilées dans des fichiers objets (.o) qui sera lié dans l'exécutable final). Si l'application de console est un front-end pour un ensemble de fonctions définies dans une bibliothèque (.lib, .un), vous devez le lien de cette bibliothèque.

Après cela, vous pouvez utiliser Qt signal/slot mécanisme de connecter le "bouton cliqué sur" signal à un slot de l'appel de la fonction que vous souhaitez exécuter, comme décrit dans d'autres réponses.

OriginalL'auteur Luc Touraille
15

Un exemple simple pourrait être quelque chose comme ça. Disons que vous avez une classe comme ProgramStarter:
```
#include <QObject>

class ProgramStarter : public QObject {

    Q_OBJECT

public slots:

    void startProgram() {
        //Do stuff
    }

};
```
et quelque chose comme ça où ProgramStarter est utilisé:
```
#include <QtGui/QApplication>
#include <QPushButton>
#include <QObject>

#include "programstarter.h"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QPushButton *testButton = new QPushButton("Push me");
    testButton->resize(100, 40);
    testButton->show();

    ProgramStarter *program = new ProgramStarter;

    QObject::connect(testButton, SIGNAL(clicked()), program, SLOT(startProgram()));

    return app.exec();
}
```
Qt utilise les signaux et les slots de communiquer entre les objets. L'idée de base est que les signaux sont émis lorsque des événements se produisent et ces signaux peuvent être connectés à des machines à sous. Dans ce cas, le bouton émet un clicked() du signal lorsque le bouton est pressé et le clicked() du signal est connecté à l'startProgram() fente. Ainsi, lorsque le bouton est enfoncé, startProgram() est appelée.

Qt a un méta-objet du système pour permettre l'utilisation de signaux et les slots, entre autres choses. C'est la raison pour laquelle ProgramStarter hérite de QObject et pourquoi la macro q_object est dans l'en-tête. Je vous suggère fortement la lecture de ce si vous voulez comprendre comment les signaux et les slots et le méta-objet du système de travail en Qt: http://doc.qt.io/qt-5/signalsandslots.html

Je vous remercie pour votre réponse, mais je n'arrive pas à accéder à toutes les fonctions dont j'ai besoin à partir de mon interface graphique. Veuillez voir les détails supplémentaires que j'ai ajouté à ma question initiale.

OriginalL'auteur Kalle
6

C'est un peu long à expliquer, mais vous vous connectez le signal du bouton de la fente avec la fonction.
```
 connect(button, SIGNAL(triggered()), this, SLOT(doSomething()));
```
Vous avez vraiment besoin de lire et de comprendre les signaux et les slots avant d'essayer d'écrire du code

edit: Vous essayez d'appeler des fonctions dans un compilé séparé programme en cours d'exécution?

Êtes-vous confus Signaux Qt en C/Unix signaux? Vous pourriez commencer à les séparer application à partir de votre application Qt, son PID et l'envoyer ensuite un " c " du signal.

Ou si vous avez la source de l'application, vous pouvez l'inclure du code dans votre application Qt et puis d'appeler des fonctions simplement en les enveloppant avec un Qt fente gestionnaire.

J'ai essayé cette approche, cependant, je ne semble pas avoir d'accès à la fonction que je veux déclencher lors d'un clic sur le bouton. J'ai ajouté plus de détails à ma question initiale.

OriginalL'auteur Martin Beckett
1

Il semble que votre problème n'est pas vraiment de le faire avec Qt ou interface de programmation, mais plutôt une conception générale de la question. D'autres ont dit comment être averti lorsque le bouton est pressé, c'est à vous de crochet de la notification jusqu'à ce que le code que vous souhaitez appeler. Quelques possibilités:
- Si vous avez juste besoin d'appeler une fonction d'inclure les fichier d'en-tête et de l'appeler.
- Si vous avez un objet que vous souhaitez appeler une méthode sur, alors vous aurez besoin de fournir une référence à cet objet à la classe qui reçoit la notification.
- Si votre console app est un programme distinct, vous pouvez utiliser QProcess de lancer et de communiquer avec lui.
OriginalL'auteur Dan Milburn
1

Je suppose que votre problème est que vous ne pouvez pas appeler la console de l'application de la fonction, parce qu'il n'a pas été défini pour être un logement. Donc, voici comment vous pourriez le faire.

Supposons que vous avez une console de la classe app qui pourrait ressembler à ceci:
```
class ConsoleApp
{
public:
   void run()
   {
      //Code which you want to trigger by a button in your UI.
   }
}
```
Ensuite, nous mettons en œuvre un Qt en fonction wrapper classe qui hérite de QObject de la classe et, par conséquent, est en mesure d'envoyer et de recevoir des signaux. Cette classe fournit simplement à un slot personnalisé qui en délègue l'exécution à la ConsoleApp classe.
```
class ConsoleAppWrapper : public QObject
{
   Q_OBJECT

public slots:
   void startProgram()
   {
      m_consoleApp.run();
   }

private:
   ConsoleApp m_consoleApp;
}
```
Ok, et maintenant, nous voulons un bouton qui, lorsqu'il est pressé, va déclencher un appel de la " run()' méthode.
```
int main(int argc, const char** argv)
{
   QApplication app(argc, argv);

   //Define wrapper for console app.
   ConsoleAppWrapper wrapper;

   //Define button and connect its 'clicked()' signal
   //to the wrapper's 'startProgram()' slot.
   QPushButton startProgramButton("Start Program");
   connect(&startProgramButton, SIGNAL(clicked()), &wrapper, SLOT(startProgram()));

   //Show the button.
   startProgramButton.setVisible(true);

   //Start Qt's event loop.
   app.exec();
}
```
Cela devrait vous donner un " Programme de Démarrage bouton qui, lorsqu'il est pressé, fera appel à ConsoleApp::méthode run ().

Bien que cet exemple n'est pas Qt Designer basée j'espère que cet exemple vous permet de hunderstand comment les signaux et les slots de travail dans Qt.

Cheers,
Jonny

OriginalL'auteur Jonny Dee
0

Si vous avez un bouton créé avec le Concepteur, vous pouvez utiliser on_myButton_clicked() fente dans le parent de la classe de widget, tout comme dans les WinForms.

OriginalL'auteur Georgiana Jora

Vous devez vous connecter pour publier un commentaire.