Finish modularization. Other FFB APIs can now be added

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 512ee97ea7d0dd1040a90fb5581d11ec21f5762f..4cf7a25779ba1381e11ce2bbfb8e41cdbdce0250 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -25,19 +25,20 @@ set(FFBChecker_SRCS
     constanteffectsettings.cpp
     effectsettings.cpp
     envelopesettings.cpp
-    ffbconditioneffect.cpp
+    linuxffbconditioneffect.cpp
     ffbconditioneffectparameters.cpp
-    ffbconstanteffect.cpp
+    linuxffbconstanteffect.cpp
     ffbconstanteffectparameters.cpp
     ffbdevice.cpp
     ffbeffect.cpp
-    ffbeffectfactory.cpp
+    linuxffbeffect.cpp
+    linuxffbeffectfactory.cpp
     ffbeffectparameters.cpp
     ffbenvelopeparameters.cpp
     ffbnulleffect.cpp
-    ffbperiodiceffect.cpp
+    linuxffbperiodiceffect.cpp
     ffbperiodiceffectparameters.cpp
-    ffbrampeffect.cpp
+    linuxffbrampeffect.cpp
     ffbrampeffectparameters.cpp
     ffbrumbleeffect.cpp
     ffbrumbleeffectparameters.cpp

diff --git a/ffbdevice.cpp b/ffbdevice.cpp
index a2424af227dd8eb98c72d401a2b0bbce18b6ad62..822dfe52a9a63c44bf2b3dc3267ec7268655ebfa 100644 (file)
--- a/ffbdevice.cpp
+++ b/ffbdevice.cpp
@@ -1,5 +1,4 @@
 #include "ffbdevice.h"
-#include "ffbeffectfactory.h"
 
 const std::vector<ConditionSubtypes>& FFBDevice::availableConditionSubtypesList() const
 {

diff --git a/ffbeffect.cpp b/ffbeffect.cpp
index 21fa75a2893bc25da4ba810c236fb33df907f056..a496094bb55ee757d6fc981028e5acce153f5ed6 100644 (file)
--- a/ffbeffect.cpp
+++ b/ffbeffect.cpp
@@ -1,60 +1,12 @@
 #include "ffbeffect.h"
 #include "globalsettings.h"
-#include <QtWidgets/QMessageBox>
 
 FFBEffect::FFBEffect(FFBEffectTypes type)
 {
-  m_internalIdx = -1;
   m_status = FFBEffectStatus::NOT_LOADED;
   m_type = type;
 }
 
-struct ff_effect* FFBEffect::createFFStruct(const std::shared_ptr<FFBEffectParameters> params)
-{
-  struct ff_effect* eff = new struct ff_effect;
-  memset(eff, 0, sizeof(struct ff_effect));
-
-  eff->id = m_internalIdx;
-  eff->direction = params->direction;
-  eff->replay.delay = params->replayDelay;
-  eff->replay.length = params->replayLength;
-
-  return eff;
-}
-
-void FFBEffect::reportError(const QString& errorMsg) const
-{
-  QMessageBox::warning(nullptr, "FFB effect error", errorMsg);
-}
-
-bool FFBEffect::checkGenericParameters(const std::shared_ptr<FFBEffectParameters> params)
-{
-  if (!GlobalSettings::GS()->doSanityChecks)
-    return true;
-
-  if (params->repeat < 1) {
-    reportError("Effect must be played back at least once.");
-    return false;
-  }
-
-  if (!checkBoundsInclusive(params->direction, 0, 0xFFFF)) {
-    reportError("Direction out of bounds.");
-    return false;
-  }
-
-  if (!checkBoundsInclusive(params->replayDelay, 0, 0x7FFF)) {
-    reportError("Replay delay out of bounds.");
-    return false;
-  }
-
-  if (!checkBoundsInclusive(params->replayLength, 0, 0x7FFF)) {
-    reportError("Replay length out of bounds.");
-    return false;
-  }
-
-  return true;
-}
-
 bool FFBEffect::operator==(const FFBEffect& other) const
 {
   return this->type() == other.type();

diff --git a/ffbeffect.h b/ffbeffect.h
index 36bb5d6e99ed179d365e1b9644bacf5d4fda33cb..aa294aeb1835c72d7ec2777f803f479e58948e70 100644 (file)
--- a/ffbeffect.h
+++ b/ffbeffect.h
@@ -4,18 +4,13 @@
 #include "ffbeffectparameters.h"
 #include "globals.h"
 #include <memory>
-#include <linux/input.h>
 
 class FFBEffect {
 public:
   enum class FFBEffectStatus { PLAYING, UPLOADED, NOT_LOADED };
 
   explicit FFBEffect(FFBEffectTypes type);
-  virtual struct ff_effect* createFFStruct() = 0;
-  inline int internalIdx() const { return m_internalIdx; }
   virtual const std::shared_ptr<FFBEffectParameters> parameters() const = 0;
-  void reportError(const QString& errorMsg) const;
-  inline void setInternalIdx(int idx) { m_internalIdx = idx; }
   virtual bool setParameters(const std::shared_ptr<FFBEffectParameters> params) = 0;
   inline void setStatus(FFBEffectStatus status) { m_status = status; }
   inline FFBEffectStatus status() const { return m_status; }
@@ -25,18 +20,12 @@ public:
   virtual bool operator!=(const FFBEffect&) const;
 
 protected:
-  struct ff_effect* createFFStruct(const std::shared_ptr<FFBEffectParameters> params);
-  bool checkGenericParameters(const std::shared_ptr<FFBEffectParameters> params);
+  virtual bool checkGenericParameters(const std::shared_ptr<FFBEffectParameters> params) = 0;
 
 private:
-  int m_internalIdx;
   FFBEffectStatus m_status;
   FFBEffectTypes m_type;
 
-signals:
-
-public slots:
-
 };
 
 #endif // FFBEFFECT_H

diff --git a/ffbeffectfactory.cpp b/ffbeffectfactory.cpp
deleted file mode 100644 (file)
index 41462cf..0000000
--- a/ffbeffectfactory.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "ffbeffectfactory.h"
-
-FFBEffectFactory::FFBEffectFactory()
-{
-}
-
-std::shared_ptr<FFBEffect> FFBEffectFactory::createEffect(FFBEffectTypes type)
-{
-  switch (type) {
-    case FFBEffectTypes::NONE:
-      return std::shared_ptr<FFBEffect>(new FFBNullEffect());
-    case FFBEffectTypes::CONSTANT:
-      return std::shared_ptr<FFBEffect>(new FFBConstantEffect());
-    case FFBEffectTypes::PERIODIC:
-      return std::shared_ptr<FFBEffect>(new FFBPeriodicEffect());
-    case FFBEffectTypes::CONDITION:
-      return std::shared_ptr<FFBEffect>(new FFBConditionEffect());
-    case FFBEffectTypes::RAMP:
-      return std::shared_ptr<FFBEffect>(new FFBRampEffect());
-    case FFBEffectTypes::RUMBLE:
-      return std::shared_ptr<FFBEffect>(new FFBRumbleEffect());
-    default:
-      return nullptr;
-  }
-}

diff --git a/ffbeffectfactory.h b/ffbeffectfactory.h
deleted file mode 100644 (file)
index a276be9..0000000
--- a/ffbeffectfactory.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef FFBEFFECTFACTORY_H
-#define FFBEFFECTFACTORY_H
-
-#include "globals.h"
-#include "ffbconditioneffect.h"
-#include "ffbconstanteffect.h"
-#include "ffbnulleffect.h"
-#include "ffbperiodiceffect.h"
-#include "ffbrampeffect.h"
-#include "ffbrumbleeffect.h"
-
-class FFBEffectFactory
-{
-public:
-  static std::shared_ptr<FFBEffect> createEffect(FFBEffectTypes type);
-
-private:
-  FFBEffectFactory();
-
-};
-
-#endif // FFBEFFECTFACTORY_H

diff --git a/ffbnulleffect.h b/ffbnulleffect.h
index 582957404bbe94ac096193543acdaa1c9448b62c..2aa896c347af81ce7549a75b485680e05ad7e4b7 100644 (file)
--- a/ffbnulleffect.h
+++ b/ffbnulleffect.h
@@ -7,9 +7,11 @@ class FFBNullEffect : public FFBEffect
 {
 public:
   explicit FFBNullEffect();
-  inline struct ff_effect* createFFStruct() { return nullptr; }
   inline const std::shared_ptr<FFBEffectParameters> parameters() const { return nullptr; }
   inline bool setParameters(const std::shared_ptr<FFBEffectParameters> params) { (void)(params); return false; }
+
+protected:
+  bool checkGenericParameters(const std::shared_ptr<FFBEffectParameters> params) { Q_UNUSED(params); return false; }
 };
 
 #endif // FFBNULLEFFECT_H

diff --git a/ffbrumbleeffect.cpp b/ffbrumbleeffect.cpp
index 8a1ab82eed38139082712c0fa3a9c1bef6f4208d..e6f58f4f589f9ca6f0bbe78896a6c8764feed23d 100644 (file)
--- a/ffbrumbleeffect.cpp
+++ b/ffbrumbleeffect.cpp
@@ -1,13 +1,13 @@
-#include "ffbrumbleeffect.h"
+#include "linuxffbrumbleeffect.h"
 
-FFBRumbleEffect::FFBRumbleEffect() :
-  FFBEffect(FFBEffectTypes::RUMBLE)
+LinuxFFBRumbleEffect::LinuxFFBRumbleEffect() :
+  LinuxFFBEffect(FFBEffectTypes::RUMBLE)
 {
 }
 
-struct ff_effect* FFBRumbleEffect::createFFStruct()
+struct ff_effect* LinuxFFBRumbleEffect::createFFStruct()
 {
-  struct ff_effect* eff = FFBEffect::createFFStruct(m_params);
+  struct ff_effect* eff = LinuxFFBEffect::createFFStruct(m_params);
 
   eff->type = FF_RUMBLE;
 
@@ -17,7 +17,7 @@ struct ff_effect* FFBRumbleEffect::createFFStruct()
   return eff;
 }
 
-bool FFBRumbleEffect::setParameters(const std::shared_ptr<FFBEffectParameters> params)
+bool LinuxFFBRumbleEffect::setParameters(const std::shared_ptr<FFBEffectParameters> params)
 {
   try {
     return setParameters(std::dynamic_pointer_cast<FFBRumbleEffectParameters>(params));
@@ -27,7 +27,7 @@ bool FFBRumbleEffect::setParameters(const std::shared_ptr<FFBEffectParameters> p
   }
 }
 
-bool FFBRumbleEffect::setParameters(const std::shared_ptr<FFBRumbleEffectParameters> params)
+bool LinuxFFBRumbleEffect::setParameters(const std::shared_ptr<FFBRumbleEffectParameters> params)
 {
   if (!checkGenericParameters(params))
     return false;

diff --git a/ffbconditioneffect.cpp b/linuxffbconditioneffect.cpp
similarity index 87%
rename from ffbconditioneffect.cpp
rename to linuxffbconditioneffect.cpp
index 7e6ef2138de29fc6b3040c74f27cd05546ec8e86..9b3d5fd999b3c86cb1b8cf946aaf56401bf7801c 100644 (file)
--- a/ffbconditioneffect.cpp
+++ b/linuxffbconditioneffect.cpp
@@ -1,13 +1,13 @@
-#include "ffbconditioneffect.h"
+#include "linuxffbconditioneffect.h"
 #include "globalsettings.h"
 
-FFBConditionEffect::FFBConditionEffect() :
-  FFBEffect(FFBEffectTypes::CONDITION)
+LinuxFFBConditionEffect::LinuxFFBConditionEffect() :
+  LinuxFFBEffect(FFBEffectTypes::CONDITION)
 {}
 
-struct ff_effect* FFBConditionEffect::createFFStruct()
+struct ff_effect* LinuxFFBConditionEffect::createFFStruct()
 {
-  struct ff_effect* eff = FFBEffect::createFFStruct(m_params);
+  struct ff_effect* eff = LinuxFFBEffect::createFFStruct(m_params);
 
   eff->u.condition[0].center = m_params->center[FFBConditionEffectParameters::Axis::X];
   eff->u.condition[0].deadband = m_params->deadband[FFBConditionEffectParameters::Axis::X];
@@ -45,7 +45,7 @@ struct ff_effect* FFBConditionEffect::createFFStruct()
   return eff;
 }
 
-bool FFBConditionEffect::setParameters(const std::shared_ptr<FFBEffectParameters> params)
+bool LinuxFFBConditionEffect::setParameters(const std::shared_ptr<FFBEffectParameters> params)
 {
   try {
     return setParameters(std::dynamic_pointer_cast<FFBConditionEffectParameters>(params));
@@ -56,7 +56,7 @@ bool FFBConditionEffect::setParameters(const std::shared_ptr<FFBEffectParameters
   return false;
 }
 
-bool FFBConditionEffect::setParameters(const std::shared_ptr<FFBConditionEffectParameters> params)
+bool LinuxFFBConditionEffect::setParameters(const std::shared_ptr<FFBConditionEffectParameters> params)
 {
   if (!checkGenericParameters(params))
     return false;
@@ -126,13 +126,13 @@ bool FFBConditionEffect::setParameters(const std::shared_ptr<FFBConditionEffectP
   return true;
 }
 
-bool FFBConditionEffect::operator==(const FFBEffect& other) const
+bool LinuxFFBConditionEffect::operator==(const FFBEffect& other) const
 {
   if (this->type() != other.type())
     return false;
   else {
     try {
-      const FFBConditionEffect& cother = dynamic_cast<const FFBConditionEffect&>(other);
+      const LinuxFFBConditionEffect& cother = dynamic_cast<const LinuxFFBConditionEffect&>(other);
       return this->m_params->subtype == cother.m_params->subtype;
     } catch (std::bad_cast&) {
       return false;

diff --git a/ffbconditioneffect.h b/linuxffbconditioneffect.h
similarity index 67%
rename from ffbconditioneffect.h
rename to linuxffbconditioneffect.h
index 8bc78698150ee35c6762d7d1cff3042a82fcc2ae..ea7adccb781b7b0af636eb6212ac963f37455ec1 100644 (file)
--- a/ffbconditioneffect.h
+++ b/linuxffbconditioneffect.h
@@ -1,13 +1,13 @@
-#ifndef FFBCONDITIONEFFECT_H
-#define FFBCONDITIONEFFECT_H
+#ifndef LINUXFFBCONDITIONEFFECT_H
+#define LINUXFFBCONDITIONEFFECT_H
 
-#include "ffbeffect.h"
+#include "linuxffbeffect.h"
 #include "ffbconditioneffectparameters.h"
 
-class FFBConditionEffect : public FFBEffect
+class LinuxFFBConditionEffect : public LinuxFFBEffect
 {
 public:
-  explicit FFBConditionEffect();
+  explicit LinuxFFBConditionEffect();
   struct ff_effect* createFFStruct();
   inline const std::shared_ptr<FFBEffectParameters> parameters() const { return m_params; }
   bool setParameters(const std::shared_ptr<FFBEffectParameters> params);
@@ -18,4 +18,4 @@ private:
   std::shared_ptr<FFBConditionEffectParameters> m_params;
 };
 
-#endif // FFBCONDITIONEFFECT_H
+#endif // FFBCONDITIONEFFECT_H
\ No newline at end of file

diff --git a/ffbconstanteffect.cpp b/linuxffbconstanteffect.cpp
similarity index 75%
rename from ffbconstanteffect.cpp
rename to linuxffbconstanteffect.cpp
index 879dd1125264b8b40f6f81fee5a3423522507a33..347d96f96836dbd770f744ce995cb80b5e7749f7 100644 (file)
--- a/ffbconstanteffect.cpp
+++ b/linuxffbconstanteffect.cpp
@@ -1,15 +1,14 @@
-#include "ffbconstanteffect.h"
+#include "linuxffbconstanteffect.h"
 #include "globalsettings.h"
 
-FFBConstantEffect::FFBConstantEffect() :
-  FFBEffect(FFBEffectTypes::CONSTANT)
-{
-}
+LinuxFFBConstantEffect::LinuxFFBConstantEffect() :
+  LinuxFFBEffect(FFBEffectTypes::CONSTANT)
+{}
 
-struct ff_effect* FFBConstantEffect::createFFStruct()
+struct ff_effect* LinuxFFBConstantEffect::createFFStruct()
 {
   /* Set up generic effect parameters */
-  struct ff_effect* eff = FFBEffect::createFFStruct(m_params);
+  struct ff_effect* eff = LinuxFFBEffect::createFFStruct(m_params);
 
   eff->type = FF_CONSTANT;
 
@@ -23,7 +22,7 @@ struct ff_effect* FFBConstantEffect::createFFStruct()
   return eff;
 }
 
-bool FFBConstantEffect::setParameters(const std::shared_ptr<FFBEffectParameters> params)
+bool LinuxFFBConstantEffect::setParameters(const std::shared_ptr<FFBEffectParameters> params)
 {
   try {
     return setParameters(std::dynamic_pointer_cast<FFBConstantEffectParameters>(params));
@@ -33,7 +32,7 @@ bool FFBConstantEffect::setParameters(const std::shared_ptr<FFBEffectParameters>
   return false;
 }
 
-bool FFBConstantEffect::setParameters(const std::shared_ptr<FFBConstantEffectParameters> params)
+bool LinuxFFBConstantEffect::setParameters(const std::shared_ptr<FFBConstantEffectParameters> params)
 {
   if (!checkGenericParameters(params))
     return false;

diff --git a/ffbconstanteffect.h b/linuxffbconstanteffect.h
similarity index 65%
rename from ffbconstanteffect.h
rename to linuxffbconstanteffect.h
index 05a907e0f9d09624e83b889358a1748abf691066..4d6d0ab9346b756566ae14153fdb8af9692babec 100644 (file)
--- a/ffbconstanteffect.h
+++ b/linuxffbconstanteffect.h
@@ -1,13 +1,13 @@
-#ifndef FFBCONSTANTEFFECT_H
-#define FFBCONSTANTEFFECT_H
+#ifndef LINUXFFBCONSTANTEFFECT_H
+#define LINUXFFBCONSTANTEFFECT_H
 
-#include "ffbeffect.h"
+#include "linuxffbeffect.h"
 #include "ffbconstanteffectparameters.h"
 
-class FFBConstantEffect : public FFBEffect
+class LinuxFFBConstantEffect : public LinuxFFBEffect
 {
 public:
-  explicit FFBConstantEffect();
+  explicit LinuxFFBConstantEffect();
   struct ff_effect* createFFStruct();
   inline const std::shared_ptr<FFBEffectParameters> parameters() const { return m_params; }
   bool setParameters(const std::shared_ptr<FFBEffectParameters> params);
@@ -17,4 +17,4 @@ private:
   std::shared_ptr<FFBConstantEffectParameters> m_params;
 };
 
-#endif // FFBCONSTANTEFFECT_H
+#endif // LINUXFFBCONSTANTEFFECT_H
\ No newline at end of file

diff --git a/linuxffbdevice.cpp b/linuxffbdevice.cpp
index c20804cf4f4a1c5c8200a2fcdbefa11c88edd016..6b9187d6e412d8c0a88deefcc033836775543fdd 100644 (file)
--- a/linuxffbdevice.cpp
+++ b/linuxffbdevice.cpp
@@ -1,5 +1,5 @@
 #include "linuxffbdevice.h"
-#include "ffbeffectfactory.h"
+#include "linuxffbeffectfactory.h"
 #include <QtWidgets/QMessageBox>
 #include <QDebug>
 #include <fcntl.h>
@@ -17,7 +17,7 @@ LinuxFFBDevice::LinuxFFBDevice(const int fd, const int maxEffectCount, const QSt
   c_path(path)
 {
   for (int i = 0; i < maxEffectCount; i++)
-    m_effects.push_back(FFBEffectFactory::createEffect(FFBEffectTypes::NONE));
+    m_effects.push_back(LinuxFFBEffectFactory::createEffect(FFBEffectTypes::NONE));
 }
 
 void LinuxFFBDevice::close()
@@ -83,7 +83,7 @@ bool LinuxFFBDevice::removeAndEraseEffect(const int idx)
     return true;
 
   if (removeEffect(idx)) {
-    m_effects[idx] = FFBEffectFactory::createEffect(FFBEffectTypes::NONE);
+    m_effects[idx] = LinuxFFBEffectFactory::createEffect(FFBEffectTypes::NONE);
     if (m_effects[idx]->type() != FFBEffectTypes::NONE) {
       qCritical("Unable to empty the effect slot.");
       return false;
@@ -99,10 +99,16 @@ bool LinuxFFBDevice::removeAndEraseEffect(const int idx)
 
 bool LinuxFFBDevice::removeEffect(const int idx)
 {
+  std::shared_ptr<LinuxFFBEffect> linEff;
   if (!stopEffect(idx))
     return false;
 
-  int internalIdx = m_effects[idx]->internalIdx();
+  if (m_effects[idx]->type() == FFBEffectTypes::NONE)
+    return true;
+
+  linEff = std::static_pointer_cast<LinuxFFBEffect>(m_effects[idx]);
+
+  int internalIdx = linEff->internalIdx();
   int ret = ioctl(c_fd, EVIOCRMFF, internalIdx);
   if (ret < 0)
     return false;
@@ -111,6 +117,7 @@ bool LinuxFFBDevice::removeEffect(const int idx)
 
 bool LinuxFFBDevice::startEffect(const int idx, const FFBEffectTypes type, std::shared_ptr<FFBEffectParameters> parameters)
 {
+  std::shared_ptr<LinuxFFBEffect> linEff;
   int ret;
 
   CHECK_EFFECT_IDX(idx);
@@ -122,11 +129,13 @@ bool LinuxFFBDevice::startEffect(const int idx, const FFBEffectTypes type, std::
   if (m_effects[idx]->status() == FFBEffect::FFBEffectStatus::PLAYING)
     return true;
 
+  linEff = std::static_pointer_cast<LinuxFFBEffect>(m_effects[idx]);
+
   /* Start playback */
   struct input_event evt;
   evt.type = EV_FF;
-  evt.code = m_effects[idx]->internalIdx();
-  evt.value = m_effects[idx]->parameters()->repeat;
+  evt.code = linEff->internalIdx();
+  evt.value = linEff->parameters()->repeat;
 
   ret = write(c_fd, &evt, sizeof(struct input_event));
   if (ret != sizeof(struct input_event)) {
@@ -135,13 +144,15 @@ bool LinuxFFBDevice::startEffect(const int idx, const FFBEffectTypes type, std::
     return false;
   }
 
-  m_effects[idx]->setStatus(FFBEffect::FFBEffectStatus::PLAYING);
+  linEff->setStatus(FFBEffect::FFBEffectStatus::PLAYING);
 
   return true;
 }
 
 bool LinuxFFBDevice::stopEffect(const int idx)
 {
+  std::shared_ptr<LinuxFFBEffect> linEff;
+
   CHECK_EFFECT_IDX(idx);
 
   if (m_effects[idx] == nullptr)
@@ -150,7 +161,9 @@ bool LinuxFFBDevice::stopEffect(const int idx)
   if (m_effects[idx]->status() != FFBEffect::FFBEffectStatus::PLAYING)
     return true;
 
-  int internalIdx = m_effects[idx]->internalIdx();
+  linEff = std::static_pointer_cast<LinuxFFBEffect>(m_effects[idx]);
+
+  int internalIdx = linEff->internalIdx();
 
   struct input_event evt;
   evt.type = EV_FF;
@@ -161,22 +174,28 @@ bool LinuxFFBDevice::stopEffect(const int idx)
   if (ret != sizeof(struct input_event))
     return false;
 
-  m_effects[idx]->setStatus(FFBEffect::FFBEffectStatus::UPLOADED);
+  linEff->setStatus(FFBEffect::FFBEffectStatus::UPLOADED);
   return true;
 }
 
 bool LinuxFFBDevice::uploadEffect(const int idx, const FFBEffectTypes type, std::shared_ptr<FFBEffectParameters> parameters)
 {
   struct ff_effect* kernelEff = nullptr;
-  std::shared_ptr<FFBEffect> effect = FFBEffectFactory::createEffect(type);
+  std::shared_ptr<FFBEffect> effect = LinuxFFBEffectFactory::createEffect(type);
+  std::shared_ptr<LinuxFFBEffect> linEff;
+
+  if (type != FFBEffectTypes::NONE)
+    linEff = std::static_pointer_cast<LinuxFFBEffect>(effect);
+  else
+    return false;
 
   CHECK_EFFECT_IDX(idx);
 
-  if (effect == nullptr) {
+  if (linEff == nullptr) {
     qDebug() << "Unable to create effect";
     return false;
   }
-  if (!effect->setParameters(parameters)) {
+  if (!linEff->setParameters(parameters)) {
     qDebug() << "Unable to set effect parameters, some values are probably invalid.";
     return false;
   }
@@ -188,32 +207,31 @@ bool LinuxFFBDevice::uploadEffect(const int idx, const FFBEffectTypes type, std:
 
   /* There is no effect in the selected slot */
   if (m_effects[idx]->type() == FFBEffectTypes::NONE) {
-    effect->setStatus(FFBEffect::FFBEffectStatus::UPLOADED);
+    linEff->setStatus(FFBEffect::FFBEffectStatus::UPLOADED);
     qDebug() << "Creating new effect";
   } else {
-    if (*m_effects[idx] != *effect) {
+
+    if (*m_effects[idx] != *linEff) {
       if (!removeEffect(idx)) {
         QMessageBox::critical(nullptr, "FFB Device", "Unable to remove effect");
         return false;
       }
-      effect->setStatus(FFBEffect::FFBEffectStatus::UPLOADED);
+      linEff->setStatus(FFBEffect::FFBEffectStatus::UPLOADED);
       qDebug() << "Recreating effect" << idx;
     } else {
-      effect->setInternalIdx(m_effects[idx]->internalIdx());
-      effect->setStatus(m_effects[idx]->status());
+      linEff->setInternalIdx(std::static_pointer_cast<LinuxFFBEffect>(m_effects[idx])->internalIdx());
+      linEff->setStatus(m_effects[idx]->status());
       qDebug() << "Updating effect" << idx;
     }
   }
 
-  kernelEff = effect->createFFStruct();
+  kernelEff = linEff->createFFStruct();
   if (kernelEff == nullptr) {
     QMessageBox::critical(nullptr, "FFB Device", "ff_effect struct could not have been created. Effect not uploaded.");
     qDebug() << "struct ff_effect not created";
     return false;
   }
 
-  qDebug() << kernelEff->u.condition[0].center << kernelEff->u.condition[0].deadband << kernelEff->u.condition[1].center << kernelEff->u.condition[1].deadband;
-
   int ret = ioctl(c_fd, EVIOCSFF, kernelEff);
   if (ret < 0) {
     QMessageBox::critical(nullptr, "FFB Device", "Effect could not have been uploaded, error code: " + QString::number(ret));
@@ -222,9 +240,9 @@ bool LinuxFFBDevice::uploadEffect(const int idx, const FFBEffectTypes type, std:
     return false;
   }
 
-  effect->setInternalIdx(kernelEff->id);
+  linEff->setInternalIdx(kernelEff->id);
   delete kernelEff;
 
-  m_effects[idx] = effect;
+  m_effects[idx] = linEff;
   return true;
 }

diff --git a/linuxffbeffect.cpp b/linuxffbeffect.cpp
new file mode 100644 (file)
index 0000000..26e0e29
--- /dev/null
+++ b/linuxffbeffect.cpp
@@ -0,0 +1,55 @@
+#include "linuxffbeffect.h"
+#include "globalsettings.h"
+#include <QtWidgets/QMessageBox>
+
+LinuxFFBEffect::LinuxFFBEffect(FFBEffectTypes type) :
+  FFBEffect(type)
+{
+  m_internalIdx = -1;
+}
+
+struct ff_effect* LinuxFFBEffect::createFFStruct(const std::shared_ptr<FFBEffectParameters> params)
+{
+  struct ff_effect* eff = new struct ff_effect;
+  memset(eff, 0, sizeof(struct ff_effect));
+
+  eff->id = m_internalIdx;
+  eff->direction = params->direction;
+  eff->replay.delay = params->replayDelay;
+  eff->replay.length = params->replayLength;
+
+  return eff;
+}
+
+void LinuxFFBEffect::reportError(const QString& errorMsg) const
+{
+  QMessageBox::warning(nullptr, "FFB effect error", errorMsg);
+}
+
+bool LinuxFFBEffect::checkGenericParameters(const std::shared_ptr<FFBEffectParameters> params)
+{
+  if (!GlobalSettings::GS()->doSanityChecks)
+    return true;
+
+  if (params->repeat < 1) {
+    reportError("Effect must be played back at least once.");
+    return false;
+  }
+
+  if (!checkBoundsInclusive(params->direction, 0, 0xFFFF)) {
+    reportError("Direction out of bounds.");
+    return false;
+  }
+
+  if (!checkBoundsInclusive(params->replayDelay, 0, 0x7FFF)) {
+    reportError("Replay delay out of bounds.");
+    return false;
+  }
+
+  if (!checkBoundsInclusive(params->replayLength, 0, 0x7FFF)) {
+    reportError("Replay length out of bounds.");
+    return false;
+  }
+
+  return true;
+}
\ No newline at end of file

diff --git a/linuxffbeffect.h b/linuxffbeffect.h
new file mode 100644 (file)
index 0000000..3f83094
--- /dev/null
+++ b/linuxffbeffect.h
@@ -0,0 +1,25 @@
+#ifndef LINUXFFBEFFECT_H
+#define LINUXFFBEFFECT_H
+
+#include "ffbeffect.h"
+#include <linux/input.h>
+
+class LinuxFFBEffect : public FFBEffect {
+public:
+  explicit LinuxFFBEffect(FFBEffectTypes type);
+  virtual struct ff_effect* createFFStruct() = 0;
+  inline int internalIdx() const { return m_internalIdx; }
+  inline void setInternalIdx(int idx) { m_internalIdx = idx; }
+
+protected:
+  struct ff_effect* createFFStruct(const std::shared_ptr<FFBEffectParameters> params);
+  bool checkGenericParameters(const std::shared_ptr<FFBEffectParameters> params);
+  void reportError(const QString& errorMsg) const;
+
+private:
+
+  int m_internalIdx;
+
+};
+
+#endif // LINUXFFBEFFECT_H

diff --git a/linuxffbeffectfactory.cpp b/linuxffbeffectfactory.cpp
new file mode 100644 (file)
index 0000000..37161be
--- /dev/null
+++ b/linuxffbeffectfactory.cpp
@@ -0,0 +1,21 @@
+#include "linuxffbeffectfactory.h"
+
+std::shared_ptr<FFBEffect> LinuxFFBEffectFactory::createEffect(FFBEffectTypes type)
+{
+  switch (type) {
+    case FFBEffectTypes::NONE:
+      return std::shared_ptr<FFBEffect>(new FFBNullEffect());
+    case FFBEffectTypes::CONSTANT:
+      return std::shared_ptr<LinuxFFBEffect>(new LinuxFFBConstantEffect());
+    case FFBEffectTypes::PERIODIC:
+      return std::shared_ptr<LinuxFFBEffect>(new LinuxFFBPeriodicEffect());
+    case FFBEffectTypes::CONDITION:
+      return std::shared_ptr<LinuxFFBEffect>(new LinuxFFBConditionEffect());
+    case FFBEffectTypes::RAMP:
+      return std::shared_ptr<LinuxFFBEffect>(new LinuxFFBRampEffect());
+    case FFBEffectTypes::RUMBLE:
+      return std::shared_ptr<LinuxFFBEffect>(new LinuxFFBRumbleEffect());
+    default:
+      return nullptr;
+  }
+}

diff --git a/linuxffbeffectfactory.h b/linuxffbeffectfactory.h
new file mode 100644 (file)
index 0000000..2f3d219
--- /dev/null
+++ b/linuxffbeffectfactory.h
@@ -0,0 +1,22 @@
+#ifndef LinuxFFBEFFECTFACTORY_H
+#define FFBEFFECTFACTORY_H
+
+#include "globals.h"
+#include "linuxffbconditioneffect.h"
+#include "linuxffbconstanteffect.h"
+#include "ffbnulleffect.h"
+#include "linuxffbperiodiceffect.h"
+#include "linuxffbrampeffect.h"
+#include "linuxffbrumbleeffect.h"
+
+class LinuxFFBEffectFactory
+{
+public:
+  static std::shared_ptr<FFBEffect> createEffect(FFBEffectTypes type);
+
+private:
+  LinuxFFBEffectFactory() {};
+
+};
+
+#endif // FFBEFFECTFACTORY_H

diff --git a/ffbperiodiceffect.cpp b/linuxffbperiodiceffect.cpp
similarity index 82%
rename from ffbperiodiceffect.cpp
rename to linuxffbperiodiceffect.cpp
index 0dea0d6f5513cff1f4b49524f56b5557158c2e35..4602c9f640affb8349e82f5028f20bd698fb6bbf 100644 (file)
--- a/ffbperiodiceffect.cpp
+++ b/linuxffbperiodiceffect.cpp
@@ -1,14 +1,14 @@
-#include "ffbperiodiceffect.h"
+#include "linuxffbperiodiceffect.h"
 #include "globalsettings.h"
 #include <QDebug>
 
-FFBPeriodicEffect::FFBPeriodicEffect() :
-  FFBEffect(FFBEffectTypes::PERIODIC)
+LinuxFFBPeriodicEffect::LinuxFFBPeriodicEffect() :
+  LinuxFFBEffect(FFBEffectTypes::PERIODIC)
 {}
 
-struct ff_effect* FFBPeriodicEffect::createFFStruct()
+struct ff_effect* LinuxFFBPeriodicEffect::createFFStruct()
 {
-  struct ff_effect* eff = FFBEffect::createFFStruct(m_params);
+  struct ff_effect* eff = LinuxFFBEffect::createFFStruct(m_params);
   if (eff == nullptr)
     return nullptr;
 
@@ -48,7 +48,7 @@ struct ff_effect* FFBPeriodicEffect::createFFStruct()
   return eff;
 }
 
-bool FFBPeriodicEffect::setParameters(const std::shared_ptr<FFBEffectParameters> params)
+bool LinuxFFBPeriodicEffect::setParameters(const std::shared_ptr<FFBEffectParameters> params)
 {
   try {
     return setParameters(std::dynamic_pointer_cast<FFBPeriodicEffectParameters>(params));
@@ -58,7 +58,7 @@ bool FFBPeriodicEffect::setParameters(const std::shared_ptr<FFBEffectParameters>
   }
 }
 
-bool FFBPeriodicEffect::setParameters(const std::shared_ptr<FFBPeriodicEffectParameters> params)
+bool LinuxFFBPeriodicEffect::setParameters(const std::shared_ptr<FFBPeriodicEffectParameters> params)
 {
   if (!checkGenericParameters(params))
     return false;
@@ -114,13 +114,13 @@ bool FFBPeriodicEffect::setParameters(const std::shared_ptr<FFBPeriodicEffectPar
   return true;
 }
 
-bool FFBPeriodicEffect::operator==(const FFBEffect& other) const
+bool LinuxFFBPeriodicEffect::operator==(const FFBEffect& other) const
 {
   if (this->type() != other.type())
     return false;
   else {
     try {
-      const FFBPeriodicEffect& eff = dynamic_cast<const FFBPeriodicEffect&>(other);
+      const LinuxFFBPeriodicEffect& eff = dynamic_cast<const LinuxFFBPeriodicEffect&>(other);
       return this->m_params->waveform == eff.m_params->waveform;
     } catch(std::bad_cast&) {
       return false;
@@ -128,6 +128,3 @@ bool FFBPeriodicEffect::operator==(const FFBEffect& other) const
   }
 }
 
-FFBPeriodicEffect::~FFBPeriodicEffect()
-{
-}

diff --git a/ffbperiodiceffect.h b/linuxffbperiodiceffect.h
similarity index 68%
rename from ffbperiodiceffect.h
rename to linuxffbperiodiceffect.h
index 14891b0943ed6d72fff319126b52580905bba14e..5cea06c66afeb0fc786400595d4ada1df46bc053 100644 (file)
--- a/ffbperiodiceffect.h
+++ b/linuxffbperiodiceffect.h
@@ -1,14 +1,13 @@
-#ifndef FFBPERIODICEFFECT_H
-#define FFBPERIODICEFFECT_H
+#ifndef LINUXFFBPERIODICEFFECT_H
+#define LINUXFFBPERIODICEFFECT_H
 
-#include "ffbeffect.h"
+#include "linuxffbeffect.h"
 #include "ffbperiodiceffectparameters.h"
 
-class FFBPeriodicEffect : public FFBEffect
+class LinuxFFBPeriodicEffect : public LinuxFFBEffect
 {
 public:
-  FFBPeriodicEffect();
-  ~FFBPeriodicEffect();
+  LinuxFFBPeriodicEffect();
   struct ff_effect* createFFStruct();
   inline const std::shared_ptr<FFBEffectParameters> parameters() const { return m_params; }
   bool setParameters(const std::shared_ptr<FFBEffectParameters> params);
@@ -19,4 +18,4 @@ private:
   std::shared_ptr<FFBPeriodicEffectParameters> m_params;
 };
 
-#endif // FFBPERIODICEFFECT_H
+#endif // LINUXFFBPERIODICEFFECT_H

diff --git a/ffbrampeffect.cpp b/linuxffbrampeffect.cpp
similarity index 80%
rename from ffbrampeffect.cpp
rename to linuxffbrampeffect.cpp
index 3428b26787f6623441b9ca516eefd47b25d9b69f..f93cd5140fe1df742c12452614bf77012082645d 100644 (file)
--- a/ffbrampeffect.cpp
+++ b/linuxffbrampeffect.cpp
@@ -1,14 +1,14 @@
-#include "ffbrampeffect.h"
+#include "linuxffbrampeffect.h"
 #include "globalsettings.h"
 
-FFBRampEffect::FFBRampEffect() :
-  FFBEffect(FFBEffectTypes::RAMP)
+LinuxFFBRampEffect::LinuxFFBRampEffect() :
+  LinuxFFBEffect(FFBEffectTypes::RAMP)
 {
 }
 
-struct ff_effect* FFBRampEffect::createFFStruct()
+struct ff_effect* LinuxFFBRampEffect::createFFStruct()
 {
-  struct ff_effect* eff = FFBEffect::createFFStruct(m_params);
+  struct ff_effect* eff = LinuxFFBEffect::createFFStruct(m_params);
   if (eff == nullptr)
     return nullptr;
 
@@ -26,7 +26,7 @@ struct ff_effect* FFBRampEffect::createFFStruct()
 }
 
 
-bool FFBRampEffect::setParameters(const std::shared_ptr<FFBEffectParameters> params)
+bool LinuxFFBRampEffect::setParameters(const std::shared_ptr<FFBEffectParameters> params)
 {
   try {
     return setParameters(std::dynamic_pointer_cast<FFBRampEffectParameters>(params));
@@ -36,7 +36,7 @@ bool FFBRampEffect::setParameters(const std::shared_ptr<FFBEffectParameters> par
   }
 }
 
-bool FFBRampEffect::setParameters(const std::shared_ptr<FFBRampEffectParameters> params)
+bool LinuxFFBRampEffect::setParameters(const std::shared_ptr<FFBRampEffectParameters> params)
 {
   if (!checkGenericParameters(params))
     return false;
@@ -76,7 +76,3 @@ bool FFBRampEffect::setParameters(const std::shared_ptr<FFBRampEffectParameters>
   m_params = params;
   return true;
 }
-
-FFBRampEffect::~FFBRampEffect()
-{
-}

diff --git a/ffbrampeffect.h b/linuxffbrampeffect.h
similarity index 72%
rename from ffbrampeffect.h
rename to linuxffbrampeffect.h
index b4ab26e880730f633650aed713adc03dfa983734..79c8f44c204fbc8cc7bad8462245de87edc21f2a 100644 (file)
--- a/ffbrampeffect.h
+++ b/linuxffbrampeffect.h
@@ -1,14 +1,13 @@
-#ifndef FFBRAMPEFFECT_H
-#define FFBRAMPEFFECT_H
+#ifndef LINUXFFBRAMPEFFECT_H
+#define LINUXFFBRAMPEFFECT_H
 
-#include "ffbeffect.h"
+#include "linuxffbeffect.h"
 #include "ffbrampeffectparameters.h"
 
-class FFBRampEffect : public FFBEffect
+class LinuxFFBRampEffect : public LinuxFFBEffect
 {
 public:
-  FFBRampEffect();
-  ~FFBRampEffect();
+  LinuxFFBRampEffect();
   struct ff_effect* createFFStruct();
   inline const std::shared_ptr<FFBEffectParameters> parameters() const { return m_params; }
   bool setParameters(const std::shared_ptr<FFBEffectParameters> params);

diff --git a/ffbrumbleeffect.h b/linuxffbrumbleeffect.h
similarity index 72%
rename from ffbrumbleeffect.h
rename to linuxffbrumbleeffect.h
index e0075c36d09fff545433e39632eb4b7ed458289f..77171570dc60b13e515a653f5909bee15f4e9c79 100644 (file)
--- a/ffbrumbleeffect.h
+++ b/linuxffbrumbleeffect.h
@@ -1,13 +1,13 @@
-#ifndef FFBRUMBLEEFFECT_H
-#define FFBRUMBLEEFFECT_H
+#ifndef LINUXFFBRUMBLEEFFECT_H
+#define LINUXFFBRUMBLEEFFECT_H
 
-#include "ffbeffect.h"
+#include "linuxffbeffect.h"
 #include "ffbrumbleeffectparameters.h"
 
-class FFBRumbleEffect : public FFBEffect
+class LinuxFFBRumbleEffect : public LinuxFFBEffect
 {
 public:
-  FFBRumbleEffect();
+  LinuxFFBRumbleEffect();
   struct ff_effect* createFFStruct();
   inline const std::shared_ptr<FFBEffectParameters> parameters() const { return m_params; }
   bool setParameters(const std::shared_ptr<FFBEffectParameters> params);