Russian Qt Forum

C++ (Qt)
virtual QObject* pluginObject() { return this; }
 

C++ (Qt)
QPluginLoader loader("plugin");
connect(loader.instance(), SIGNAL(pluginSignal()), SLOT(appSlot()));
 

C++ (Qt)
#ifndef INTERFACES_H
#define INTERFACES_H
#include <QObject>
 
class QString;
class CameraInterface : public QObject
{
    Q_OBJECT
public:
    virtual ~CameraInterface() {}
    virtual void powerOn();
    ...
    virtual void extendedCommand(QString command);
 
signals:
    void powerStateCahnged(bool state);
    void backlightStateChanged(bool state);
};
 
Q_DECLARE_INTERFACE(CameraInterface, "ru.myCompany.myApp.cameraInterface/1.0")
 
#endif // INTERFACES_H
 

C++ (Qt)
virtual BaseCameraWorker * createWorkerObject() = 0;

C++ (Qt)
class CameraInterface
{
//Q_SIGNALS:
//   void initDone();
// Если тут не будут описаны сигналы
};
 
class SonyCamera : public QObject, public CameraInterface
{
  void doInit()
  {
    ...
   emit initDone();
    // то тут ты не сможешь испускать этот сигнал.
  }
 
// и тогда тебе надо будет описывать его тут:
Q_SIGNALS:
   void initDone();
};
 
class AxisCamera : public QObject, public CameraInterface
{
...
// и еще тут:
Q_SIGNALS:
   void initDone();
};
 
class TandbergCamera : public QObject, public CameraInterface
{
...
// и еще тут:
Q_SIGNALS:
   void initDone();
};
 
//И во всех остальных классах придется делать копипасту.
 
 

C++ (Qt)
class CameraInterface
{
};
 
class CommonCamera : public QObject, public CameraInterface
{
signals:
  initDone();
};
 
class SonyCamera : public CommonCamera
{
  void doInit()
  {
    ...
   emit initDone();
  }
};
 

C++ (Qt)
#ifndef IPLUGIN_H
#define IPLUGIN_H
 
#include <QtCore>
 
class CameraInterface
{
public:
    virtual ~CameraInterface() {}
 
    virtual void powerOn() = 0;
    virtual void powerOff() = 0;
};
 
Q_DECLARE_INTERFACE(CameraInterface, "ru.prog.test.CameraInterface/1.0")
 
#endif // IPLUGIN_H
 

C++ (Qt)
class CameraInterface : public QObject
{
    Q_OBJECT
public:
    virtual ~CameraInterface() {}
    virtual void powerOn();
};
 
Q_DECLARE_INTERFACE(CameraInterface, "ru.myCompany.myApp.cameraInterface/1.0")
 

C++ (Qt)
class CameraInterface
{
};
 
class CommonCamera : public QObject, public CameraInterface
{
signals:
  initDone();
};

C++ (Qt)
class CameraInterface : public QObject
{
signals:
  initDone();
};

C++ (Qt)
#  define Q_DECLARE_INTERFACE(IFace, IId) \
    template <> inline const char *qobject_interface_iid<IFace *>() \
    { return IId; } \
    template <> inline IFace *qobject_cast<IFace *>(QObject *object) \
    { return reinterpret_cast<IFace *>((object ? object->qt_metacast(IId) : 0)); } \
    template <> inline IFace *qobject_cast<IFace *>(const QObject *object) \
    { return reinterpret_cast<IFace *>((object ? const_cast<QObject *>(object)->qt_metacast(IId) : 0)); }

C++ (Qt)
template <class T>
inline T qobject_cast(QObject *object)
{
#if !defined(QT_NO_QOBJECT_CHECK)
    reinterpret_cast<T>(object)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(object));
#endif
    return static_cast<T>(reinterpret_cast<T>(object)->staticMetaObject.cast(object));
}
 
template <class T>
inline T qobject_cast(const QObject *object)
{
#if !defined(QT_NO_QOBJECT_CHECK)
    reinterpret_cast<T>(object)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(const_cast<QObject *>(object)));
#endif
    return static_cast<T>(reinterpret_cast<T>(object)->staticMetaObject.cast(object));
}
 
 
template <class T> inline const char * qobject_interface_iid()
{ return 0; }
 

C++ (Qt)
template <class T> inline const char * qobject_interface_iid()
{ return 0; }

C++ (Qt)
#ifndef TESTINTERFACE_H
#define TESTINTERFACE_H
 
#include <QObject>
 
class QString;
class QStringList;
 
class TestInterface : QObject{
    Q_OBJECT
public:
    virtual ~TestInterface() {}
    virtual QStringList operations() const = 0;
    virtual QString operation(const QString& strOperation ) = 0;
signals:
    void operationSelected(QString oper);
};
 
Q_DECLARE_INTERFACE(TestInterface, "ru.prog.PluginTest.TestInterface/1.1")
 
#endif // TESTINTERFACE_H
 

C++ (Qt)
#ifndef FRUITS_H
#define FRUITS_H
 
#include <QtCore>
#include "fruits_global.h"
#include "../TestInterface.h"
 
class FRUITSSHARED_EXPORT Fruits : public QObject, public TestInterface {
    Q_OBJECT
    Q_INTERFACES(TestInterface)
 
public:
    explicit Fruits(QObject *parent = 0);
    virtual ~Fruits();
 
    QStringList operations() const;
    QString operation(const QString &strOperation);
 
signals:
    void operationSelected(QString oper);
};
 
#endif // FRUITS_H
 

C++ (Qt)
#include "fruits.h"
#include <QDebug>
 
Fruits::Fruits(QObject *parent) : QObject(parent)
{
}
 
Fruits::~Fruits()
{
 
}
 
QStringList Fruits::operations() const
{
    return QStringList() << "apple" << "grape" << "banana" << "kiwi";
}
 
QString Fruits::operation(const QString &strOperation)
{
    emit operationSelected(strOperation);
    if (strOperation == "apple") {return QString("i'm a Apple");}
    else if (strOperation == "grape") {return QString("i'm a Grape");}
    else if (strOperation == "banana") {return QString("i'm a Banana");}
    else if (strOperation == "kiwi") {return QString("i'm a Kiwi");}
    else {qDebug() << "unsupported operation"; return QString();}
}
 
Q_EXPORT_PLUGIN2(TestInterface, Fruits)
 

C++ (Qt)
class FRUITSSHARED_EXPORT Fruits : public TestInterface {
    Q_OBJECT
    Q_INTERFACES(TestInterface)
 

C++ (Qt)
class FRUITSSHARED_EXPORT Fruits : public TestInterface {
    Q_OBJECT
    Q_INTERFACES(TestInterface)

C++ (Qt)
#include "fruits.h"
 
Fruits::Fruits()
{
}
 
Fruits::~Fruits()
{
}
 
...
 
Q_EXPORT_PLUGIN2(TestInterface, Fruits)