Interface de plug-in héritant de QObject ?

Version imprimable

08/02/2010, 16h33
kmedghaith

Interface de plug-in héritant de QObject ?

Salut à tous,

J'ai voulu créer une interface de plugins héritant de QObject pour l'équiper de signaux et slots mais ça ne marche pas à la compilation de l'interface. Sans hériter de QObject ça a toujours marché sans problèmes.

Quelqu'un aurait une idée sur le problème ?
08/02/2010, 18h50
Fabllot

Bonjour,

Un peu de code serait le bienvenue... Ou au moins l'erreur exact du compilateur...

L'interface :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
#include <qplugin.h>
class Interface2 : public QObject
{
	Q_OBJECT
public:
	Interface2(){}
	virtual ~Interface2(){}
	virtual void aFunction()=0;
};
Q_DECLARE_INTERFACE(Interface2,"Interface2")

Le plugin :

Code:

1
2
3
4
5
6
7
8
9
10
 
class Plugin2 : public Interface2
{
	Q_OBJECT
	Q_INTERFACES(Interface2)
public:
	Plugin2();
	virtual ~Plugin2();
	void aFunction();
};

Code:

1
2
3
4
5
6
 
Plugin2:: Plugin2(){}
Plugin2:: ~Plugin2(){}
void Plugin2::aFunction(){}
 
Q_EXPORT_PLUGIN2(Plugin2,Plugin2)

L'erreur dans Interface2 :

Code:

1
2
3
4
5
 
E:\Etudes\MVASpike_workspace\Testplugin\plugin2/../src/interface2.h:9: undefined reference to `vtable for Interface2'
debug/moc_plugin2.o:E:\Etudes\MVASpike_workspace\Testplugin\plugin2/debug/moc_plugin2.cpp:61: undefined reference to `Interface2::qt_metacast(char const*)'
debug/moc_plugin2.o:E:\Etudes\MVASpike_workspace\Testplugin\plugin2/debug/moc_plugin2.cpp:66: undefined reference to `Interface2::qt_metacall(QMetaObject::Call, int, void**)'
debug/moc_plugin2.o:moc_plugin2.cpp: (.rdata+0x0): undefined reference to `Interface2::staticMetaObject'

09/02/2010, 09h44
Fabllot

Merci d'utiliser les balises [ code ] [ / code ] pour afficher du code (icone '#') !

Il semblerait que le fichier moc ne soit pas compiler ou du moins pas lier dans le binaire... Quel IDE / Compilateur utilises-tu ? N'as-tu pas oublier de passer un coup de compilateur moc ?
09/02/2010, 11h35
kmedghaith

J'utilise eclipse / mingw. Même résultat avec Qt Creator.
Je ne pense avoir rien oublié. Ca compile quand Interface2 n'hérite pas de QObjet.
11/02/2010, 16h56
kmedghaith

Personne n'a eu le même problème ?
Au pire, je pourrais déléguer l'émission des signaux et les slots à un objet à l'intérieur du plugin mais bon, ce n'est pas très clean comme approche dans ce cas ...
12/02/2010, 10h14
Fabllot

Je crois que tu ne link pas le code de Interface2 avec ton plugin... D'après les erreurs du compilateurs, c'est le fichier moc de Interface2 qui n'est pas lié avec ton binaire... est-ce qu'il est bien généré ?
12/02/2010, 10h36
Niak74

Selon la doc concernant les plugins Qt, l'interface d'un plugin ne doit pas dériver de QObject (car ça pose ensuite des problèmes d'héritage multiple de QObject, il est en effet impossible de dériver deux fois de QObject).

Personnellement, pour contourner le problème, j'ai défini une fonction setObject(MonObjet*); dans mon interface qui permet de se servir de tout le stuff disponible via QObject (il me fallait en l'occurrence des signaux). Tu as juste à donner connaissance à ton plugin et à ton application du header de la classe que tu passes en paramètre à setObjet()
12/02/2010, 16h37
kmedghaith

Merci pour la réponse.
Je marque comme résolu.

Finalement, j'ai trouvé une solution plus simple et plus intéressante.
En effet, les plugins qui sont une implémentations de classes abstraites héritent de QObject sans pouvoir utiliser les signaux et slots (enfin si, mais l'application principale ne les connait pas). Du coup, au lieu d'écrire un plugin qui implémente une classe abstraire, je considère qu'un plugin est un objet qui fournit une instance d'une classe qui implémente une classe abstraite. Je m'explique, voici la classe dont les plugins devaient hériter :
Code:

1 2 3 4 5 6 7 8 class AbstractClass { public: AbstractClass(){} virtual ~AbstractClass(){} virtual void aFunction()=0; };
Après j'ajoute une seconde classe qui est la suivante :
Code:

1 2 3 4 5 6 7 8 9 class AbstractClassLoader { public: AbstractClassLoader(){} virtual ~AbstractClassLoader(){} virtual AbstractClass * load()=0; }; Q_DECLARE_INTERFACE(AbstractClassLoader,"AbstractClassLoader")
Comme on le voit, cette classe est une interface de plugins. Et maintenant du coté du plugin, on fait :
Code:

1 2 3 4 5 6 7 8 9 10 11 class AbstractClassImplementaion : public AbstractClass { public: AbstractClassImplementaion(){} virtual ~AbstractClassImplementaion(){} void aFunction() { qDebug()<<"It works"; } };
et
Code:

1 2 3 4 5 6 7 8 9 10 class MyLoader : public QObject, public AbstractClassLoader { Q_OBJECT Q_INTERFACES(AbstractClassLoader) public: MyLoader(); virtual ~MyLoader(); AbstractClass * load(); };
et
Code:

1 2 3 4 5 6 7 8 MyLoader::MyLoader() {} MyLoader::~MyLoader() {} AbstractClass * MyLoader::load() { return new AbstractClassImplementaion; } Q_EXPORT_PLUGIN2(MyLoader,MyLoader)
L'extension de l'application ici est donc MyLoader qui fournit une instance de AbstractClassImplementaion qui hérite de AbstractClass. Pour l'application principale, la vrai extension est bien sur AbstractClassImplementaion, MyLoader n'est qu'un moyen de l'obtenir. L'avantage avec cette méthode est que après, AbstractClass peut hériter de QObject sans problème et pourra donc être équipée de signaux et slots. Et si ce n'est pas le cas, AbstractClassImplementaion n'héritera pas de QObject pour rien.

Voilà, c'est à peu près tout.

Bonjour

Perso, j'utilise 2 classes : 1 interface qui hérite de QObject (commun au programme et au plugin) et mon plugin qui dérive du premier (et donc de QObject) :

Fichier iplugin_global.h

Code:

1
2
3
4
5
6
7
8
9
#ifndef IPLUGIN_GLOBAL_H
#define IPLUGIN_GLOBAL_H
#include <QtCore/qglobal.h>
#if defined(IPLUGIN_LIBRARY)
#  define IPLUGIN_EXPORT Q_DECL_EXPORT
#else
#  define IPLUGIN_EXPORT Q_DECL_IMPORT
#endif
#endif // IPLUGIN_GLOBAL_H

Fichier iplugin.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef IPLUGIN_H
#define IPLUGIN_H
#include "iplugin_global.h"
#include <QObject>
class IPLUGIN_EXPORT IPlugin : public QObject
  {
    Q_OBJECT
    public:
      IPlugin();
      virtual ~IPlugin() = 0;
      virtual bool initialize(QString* errorString) = 0;
  };
#endif // IPLUGIN_H

Fichier iplugin.cpp

Code:

1
2
3
4
5
#include "iplugin.h"
IPlugin::IPlugin()
  : QObject()
{
}

Il faut ajouter dans le fichier .pro du programme :

Code:

DEFINES += IPLUGIN_LIBRARY

Fichier plugin.h

Code:

1
2
3
4
5
6
7
8
9
10
#ifndef PLUGIN_H
#define PLUGIN_H
#include "plugin_global.h"
#include "iplugin.h"
  class Plugin : public IPlugin
  {
    Q_OBJECT
    public:
      bool initialize();
  };

Fichier plugin.cpp

Code:

1
2
3
4
5
6
7
8
#include "plugin.h"
#include <QtPlugin>
bool Plugin::initialize()
{
  // on initialise
  return true;
}
Q_EXPORT_PLUGIN(Plugin)

Pour charger le plugin, par exemple dans le main.cpp :

Code:

1
2
3
4
5
6
7
    QPluginLoader loader(name);
    QObject* object = loader.instance();
    if(object)
    {
      IPlugin* plugin = qobject_cast<IPlugin*>(object);
      if(plugin) plugin->initialize();
    }