Preparatory commit before moving framework to a better location.

ground/openpilotgcs/src/plugins/config/configstabilizationwidget.cpp

@@ -43,12 +43,12 @@ ConfigStabilizationWidget::ConfigStabilizationWidget(QWidget *parent) : ConfigTa
     QList<int> * rateGroup=new QList<int>();
     rateGroup->append(0);
      addApplySaveButtons(m_stabilization->saveStabilizationToRAM,m_stabilization->saveStabilizationToSD);
-    addUAVObjectToWidgetRelation("StabilizationSettings","RollRatePID",m_stabilization->rateRollKp,"Kp",1,false,rateGroup);
+    addUAVObjectToWidgetRelation("StabilizationSettings","RollRatePID",m_stabilization->rateRollKp,"Kp",1,true,rateGroup);
 
     addDefaultButton(m_stabilization->defaultButton,0);
     addReloadButton(m_stabilization->reloadButton,0);
     addWidgetToDefaultReloadGroups(m_stabilization->rateRollKp,rateGroup);
-    addShadowWidget("StabilizationSettings","RollRatePID",m_stabilization->rateRollKi,0,1,false,rateGroup);
+    addShadowWidget("StabilizationSettings","RollRatePID",m_stabilization->rateRollKi,0,1,true,rateGroup);
 }
 
 

ground/openpilotgcs/src/plugins/config/configtaskwidget.cpp

@@ -29,7 +29,7 @@
 #include "uavsettingsimportexport/uavsettingsimportexportfactory.h"
 #include "configgadgetwidget.h"
 
-ConfigTaskWidget::ConfigTaskWidget(QWidget *parent) : QWidget(parent),isConnected(false),smartsave(NULL),dirty(false)
+ConfigTaskWidget::ConfigTaskWidget(QWidget *parent) : QWidget(parent),isConnected(false),smartsave(NULL),dirty(false),outOfLimitsStyle("background-color: rgb(255, 0, 0);")
 {
     pm = ExtensionSystem::PluginManager::instance();
     objManager = pm->getObject<UAVObjectManager>();
@@ -89,6 +89,7 @@ void ConfigTaskWidget::addUAVObjectToWidgetRelation(QString object, QString fiel
     ow->widget=widget;
     ow->index=index;
     ow->scale=scale;
+    ow->isLimited=isLimited;
     objOfInterest.append(ow);
     if(obj)
     {
@@ -108,6 +109,7 @@ void ConfigTaskWidget::addUAVObjectToWidgetRelation(QString object, QString fiel
         if(defaultReloadGroups)
             addWidgetToDefaultReloadGroups(widget,defaultReloadGroups);
         shadowsList.insert(widget,ow);
+        loadWidgetLimits(widget,_field,index,isLimited,scale);
     }
 }
 
@@ -182,7 +184,7 @@ void ConfigTaskWidget::populateWidgets()
             // do nothing
         }
         else
-            setWidgetFromField(ow->widget,ow->field,ow->index,ow->scale);
+            setWidgetFromField(ow->widget,ow->field,ow->index,ow->scale,ow->isLimited);
     }
     setDirty(dirtyBack);
 }
@@ -198,7 +200,7 @@ void ConfigTaskWidget::refreshWidgetsValues()
         }
         else
         {
-            setWidgetFromField(ow->widget,ow->field,ow->index,ow->scale);
+            setWidgetFromField(ow->widget,ow->field,ow->index,ow->scale,ow->isLimited);
         }
 
     }
@@ -246,17 +248,21 @@ void ConfigTaskWidget::enableControls(bool enable)
 void ConfigTaskWidget::widgetsContentsChanged()
 {
     float scale;
+    objectToWidget * oTw= shadowsList.value((QWidget*)sender(),NULL);
+
+    /*
     qDebug()<<"sender:"<<(quint32)sender();
     foreach(QWidget * w,shadowsList.keys())
         qDebug()<<"in list:"<<(quint32)w;
-    objectToWidget * oTw= shadowsList.value((QWidget*)sender(),NULL);
     if(oTw)
         qDebug()<<"in oTw OK"<<(quint32)oTw->widget;
+        */
     if(oTw)
     {
         if(oTw->widget==(QWidget*)sender())
         {
             scale=oTw->scale;
+            checkWidgetsLimits((QWidget*)sender(),oTw->field,oTw->index,oTw->isLimited,getVariantFromWidget((QWidget*)sender(),oTw->scale),oTw->scale);
             qDebug()<<"sender was master";
         }
         else
@@ -266,18 +272,25 @@ void ConfigTaskWidget::widgetsContentsChanged()
                 if(sh->widget==(QWidget*)sender())
                 {
                     scale=sh->scale;
+                    checkWidgetsLimits((QWidget*)sender(),oTw->field,oTw->index,sh->isLimited,getVariantFromWidget((QWidget*)sender(),scale),scale);
                     qDebug()<<"sender was shadow";
                 }
             }
         }
         if(oTw->widget!=(QWidget *)sender())
+        {
+             checkWidgetsLimits(oTw->widget,oTw->field,oTw->index,oTw->isLimited,getVariantFromWidget((QWidget*)sender(),scale),oTw->scale);
             setWidgetFromVariant(oTw->widget,getVariantFromWidget((QWidget*)sender(),scale),oTw->scale);
+        }
         foreach (shadow * sh, oTw->shadowsList)
         {
             if(sh->widget!=(QWidget*)sender())
+            {
+                checkWidgetsLimits(sh->widget,oTw->field,oTw->index,sh->isLimited,getVariantFromWidget((QWidget*)sender(),scale),oTw->scale);
                 setWidgetFromVariant(sh->widget,getVariantFromWidget((QWidget*)sender(),scale),sh->scale);
             }
         }
+    }
     setDirty(true);
 }
 
@@ -540,7 +553,7 @@ void ConfigTaskWidget::defaultButtonClicked()
         if(!oTw->object)
             continue;
         UAVDataObject * temp=((UAVDataObject*)oTw->object)->dirtyClone();
-        setWidgetFromField(oTw->widget,temp->getField(oTw->field->getName()),oTw->index,oTw->scale);
+        setWidgetFromField(oTw->widget,temp->getField(oTw->field->getName()),oTw->index,oTw->scale,oTw->isLimited);
     }
 }
 
@@ -568,7 +581,7 @@ void ConfigTaskWidget::reloadButtonClicked()
             eventLoop->exec();
             if(timeOut->isActive())
             {
-                setWidgetFromField(oTw->widget,oTw->field,oTw->index,oTw->scale);
+                setWidgetFromField(oTw->widget,oTw->field,oTw->index,oTw->scale,oTw->isLimited);
             }
             timeOut->stop();
         }
@@ -699,16 +712,17 @@ bool ConfigTaskWidget::setWidgetFromVariant(QWidget *widget, QVariant value, flo
         return false;
 }
 
-bool ConfigTaskWidget::setWidgetFromField(QWidget * widget,UAVObjectField * field,int index,float scale)
+bool ConfigTaskWidget::setWidgetFromField(QWidget * widget,UAVObjectField * field,int index,float scale,bool hasLimits)
 {
     if(!widget || !field)
         return false;
     if(QComboBox * cb=qobject_cast<QComboBox *>(widget))
     {
         if(cb->count()==0)
-            cb->addItems(field->getOptions());
+            loadWidgetLimits(cb,field,index,hasLimits,scale);
     }
     QVariant var=field->getValue(index);
+    checkWidgetsLimits(widget,field,index,hasLimits,var,scale);
     bool ret=setWidgetFromVariant(widget,var,scale);
     if(ret)
         return true;
@@ -718,6 +732,129 @@ bool ConfigTaskWidget::setWidgetFromField(QWidget * widget,UAVObjectField * fiel
         return false;
     }
 }
+void ConfigTaskWidget::checkWidgetsLimits(QWidget * widget,UAVObjectField * field,int index,bool hasLimits, QVariant value, float scale)
+{
+    if(!hasLimits)
+        return;
+    qDebug()<<"check widget"<<widget->accessibleName()<<"value"<<value.toString()<<"result"<<field->isWithinLimits(value,index);
+    if(!field->isWithinLimits(value,index))
+    {
+        if(!widget->property("styleBackup").isValid())
+            widget->setProperty("styleBackup",widget->styleSheet());
+        widget->setStyleSheet(outOfLimitsStyle);
+        widget->setProperty("wasOverLimits",(bool)true);
+        if(QComboBox * cb=qobject_cast<QComboBox *>(widget))
+        {
+            if(cb->findText(value.toString())==-1)
+                cb->addItem(value.toString());
+        }
+        else if(QDoubleSpinBox * cb=qobject_cast<QDoubleSpinBox *>(widget))
+        {
+            if(value.toDouble()/scale>cb->maximum())
+            {
+                cb->setMaximum(value.toDouble()/scale);
+            }
+            else if(value.toDouble()/scale<cb->minimum())
+            {
+                cb->setMinimum(value.toDouble()/scale);
+            }
+
+        }
+        else if(QSpinBox * cb=qobject_cast<QSpinBox *>(widget))
+        {
+            if(value.toInt()/scale>cb->maximum())
+            {
+                cb->setMaximum(value.toInt()/scale);
+            }
+            else if(value.toInt()/scale<cb->minimum())
+            {
+                cb->setMinimum(value.toInt()/scale);
+            }
+        }
+        else if(QSlider * cb=qobject_cast<QSlider *>(widget))
+        {
+            if(value.toInt()/scale>cb->maximum())
+            {
+                cb->setMaximum(value.toInt()/scale);
+            }
+            else if(value.toInt()/scale<cb->minimum())
+            {
+                cb->setMinimum(value.toInt()/scale);
+            }
+        }
+
+    }
+    else if(widget->property("wasOverLimits").isValid())
+    {
+        qDebug()<<"1wasOverLimits";
+        if(widget->property("wasOverLimits").toBool())
+        {
+            qDebug()<<"2";
+            widget->setProperty("wasOverLimits",(bool)false);
+            if(widget->property("styleBackup").isValid())
+            {
+                qDebug()<<"3";
+                QString style=widget->property("styleBackup").toString();
+                qDebug()<<"STYLE"<<style;
+                widget->setStyleSheet(style);
+            }
+            loadWidgetLimits(widget,field,index,hasLimits,scale);
+        }
+    }
+}
+void ConfigTaskWidget::loadWidgetLimits(QWidget * widget,UAVObjectField * field,int index,bool hasLimits,float scale)
+{   
+    if(QComboBox * cb=qobject_cast<QComboBox *>(widget))
+    {
+        cb->clear();
+        QStringList option=field->getOptions();
+        if(hasLimits)
+        {
+            foreach(QString str,option)
+            {
+                if(field->isWithinLimits(str,index))
+                    cb->addItem(str);
+            }
+        }
+        else
+            cb->addItems(option);
+    }
+    if(!hasLimits)
+        return;
+    else if(QDoubleSpinBox * cb=qobject_cast<QDoubleSpinBox *>(widget))
+    {
+        if(field->getMaxLimit(index).isValid())
+        {
+            cb->setMaximum(field->getMaxLimit(index).toDouble()/scale);
+        }
+        if(field->getMinLimit(index).isValid())
+        {
+            cb->setMinimum(field->getMinLimit(index).toDouble()/scale);
+        }
+    }
+    else if(QSpinBox * cb=qobject_cast<QSpinBox *>(widget))
+    {
+        if(field->getMaxLimit(index).isValid())
+        {
+            cb->setMaximum((int)(field->getMaxLimit(index).toInt()/scale));
+        }
+        if(field->getMinLimit(index).isValid())
+        {
+            cb->setMinimum((int)(field->getMinLimit(index).toInt()/scale));
+        }
+    }
+    else if(QSlider * cb=qobject_cast<QSlider *>(widget))
+    {
+        if(field->getMaxLimit(index).isValid())
+        {
+            cb->setMaximum((int)(field->getMaxLimit(index).toInt()/scale));
+        }
+        if(field->getMinLimit(index).isValid())
+        {
+            cb->setMinimum((int)(field->getMinLimit(index).toInt()/scale));
+        }
+    }
+}
 
 /**
   @}

ground/openpilotgcs/src/plugins/config/configtaskwidget.h

@@ -111,7 +111,6 @@ void addUAVObjectToWidgetRelation(QString object, QString field, QWidget *widget
 
     bool allObjectsUpdated();
 
-
 public slots:
     void onAutopilotDisconnect();
     void onAutopilotConnect();
@@ -137,10 +136,12 @@ private:
     QMap<QWidget *,objectToWidget*> shadowsList;
     bool dirty;
     bool setFieldFromWidget(QWidget *widget, UAVObjectField *field, int index, float scale);
-    bool setWidgetFromField(QWidget *widget, UAVObjectField *field, int index, float scale);
+    bool setWidgetFromField(QWidget *widget, UAVObjectField *field, int index, float scale, bool hasLimits);
     QVariant getVariantFromWidget(QWidget *widget, float scale);
     bool setWidgetFromVariant(QWidget *widget,QVariant value,float scale);
     void connectWidgetUpdatesToSlot(QWidget *widget, const char *function);
+    void loadWidgetLimits(QWidget *widget, UAVObjectField *field, int index, bool hasLimits, float sclale);
+    QString outOfLimitsStyle;
 protected slots:
     virtual void disableObjUpdates();
     virtual void enableObjUpdates();
@@ -151,7 +152,7 @@ protected slots:
     virtual void updateObjectsFromWidgets();
 protected:
     virtual void enableControls(bool enable);
-
+    void checkWidgetsLimits(QWidget *widget, UAVObjectField *field, int index, bool hasLimits, QVariant value, float scale);
 };
 
 #endif // CONFIGTASKWIDGET_H

ground/openpilotgcs/src/plugins/config/stabilization.ui

@@ -111,6 +111,12 @@
              <string>Slowly raise Kp until you start seeing clear oscillations when you fly.
 Then lower the value by 20% or so.</string>
             </property>
+            <property name="autoFillBackground">
+             <bool>true</bool>
+            </property>
+            <property name="styleSheet">
+             <string notr="true"/>
+            </property>
             <property name="decimals">
              <number>6</number>
             </property>

ground/openpilotgcs/src/plugins/uavobjects/uavobjectfield.cpp

@@ -47,7 +47,7 @@ UAVObjectField::UAVObjectField(const QString& name, const QString& units, FieldT
     constructorInitialize(name, units, type, elementNames, options,limits);
 }
 
-void UAVObjectField::constructorInitialize(const QString& name, const QString& units, FieldType type, const QStringList& elementNames, const QStringList& options,QString &limits)
+void UAVObjectField::constructorInitialize(const QString& name, const QString& units, FieldType type, const QStringList& elementNames, const QStringList& options,const QString &limits)
 {
     // Copy params
     this->name = name;
@@ -92,9 +92,10 @@ void UAVObjectField::constructorInitialize(const QString& name, const QString& u
     default:
         numBytesPerElement = 0;
     }
+    limitsInitialize(limits);
 }
 
-void UAVObjectField::limitsInitialize(QString &limits)
+void UAVObjectField::limitsInitialize(const QString &limits)
 {
     /// format
     /// (TY)->type (EQ-equal;NE-not equal;BE-between;BI-bigger;SM-smaller)
@@ -102,6 +103,8 @@ void UAVObjectField::limitsInitialize(QString &limits)
     /// %TY:VAL1:VAL2:VAL3,%TY,VAL1,VAL2,VAL3
     /// example: first element bigger than 3 and second element inside [2.3,5]
     /// "%0BI:3,%1BE:2.3:5"
+    if(limits.isEmpty())
+        return;
     QStringList stringPerElement=limits.split(",");
     foreach (QString str, stringPerElement) {
         QStringList valuesPerElement=str.split(":");
@@ -124,13 +127,293 @@ void UAVObjectField::limitsInitialize(QString &limits)
             valuesPerElement.removeAt(0);
             foreach(QString value,valuesPerElement)
             {
-                lstruc.values.append(value);
+                switch (type)
+                {
+                case INT8:
+                case INT16:
+                case INT32:
+                case UINT8:
+                    lstruc.values.append((quint32)value.toULong());
+                    break;
+                case UINT16:
+                case UINT32:
+                    lstruc.values.append((qint32)value.toLong());
+                    break;
+                case FLOAT32:
+                    lstruc.values.append((float)value.toFloat());
+                    break;
+                case ENUM:
+                    lstruc.values.append((QString)value);
+                    break;
+                case STRING:
+                    lstruc.values.append((QString)value);
+                    break;
+                default:
+                    lstruc.values.append(QVariant());
+                }
             }
             elementLimits.insert(index,lstruc);
         }
+        else
+            qDebug()<<"limits parsing failed on UAVObjectField"<<name;
     }
 }
+bool UAVObjectField::isWithinLimits(QVariant var,quint32 index)
+{
+    if(!elementLimits.keys().contains(index))
+        return true;
+    LimitStruct struc=elementLimits.value(index);
+    switch(struc.type)
+    {
+    case EQUAL:
+        switch (type)
+        {
+        case INT8:
+        case INT16:
+        case INT32:
+            foreach (QVariant vars, struc.values) {
+                if(var.toInt()==vars.toInt())
+                    return true;
+            }
+            return false;
+            break;
+        case UINT8:
+        case UINT16:
+        case UINT32:
+            foreach (QVariant vars, struc.values) {
+                if(var.toUInt()==vars.toUInt())
+                    return true;
+            }
+            return false;
+            break;
+        case ENUM:
+        case STRING:
+            foreach (QVariant vars, struc.values) {
+                if(var.toString()==vars.toString())
+                    return true;
+            }
+            return false;
+            break;
+        case FLOAT32:
+            foreach (QVariant vars, struc.values) {
+                if(var.toFloat()==vars.toFloat())
+                    return true;
+            }
+            return false;
+            break;
+        default:
+            return true;
+        }
+        break;
+    case NOT_EQUAL:
+        switch (type)
+        {
+        case INT8:
+        case INT16:
+        case INT32:
+            foreach (QVariant vars, struc.values) {
+                if(var.toInt()==vars.toInt())
+                    return false;
+            }
+            return true;
+            break;
+        case UINT8:
+        case UINT16:
+        case UINT32:
+            foreach (QVariant vars, struc.values) {
+                if(var.toUInt()==vars.toUInt())
+                    return false;
+            }
+            return true;
+            break;
+        case ENUM:
+        case STRING:
+            foreach (QVariant vars, struc.values) {
+                if(var.toString()==vars.toString())
+                    return false;
+            }
+            return true;
+            break;
+        case FLOAT32:
+            foreach (QVariant vars, struc.values) {
+                if(var.toFloat()==vars.toFloat())
+                    return false;
+            }
+            return true;
+            break;
+        default:
+            return true;
+        }
+        break;
+    case BETWEEN:
+        if(struc.values.length()<2)
+        {
+            qDebug()<<__FUNCTION__<<"between limit with less than 1 pair, aborting; field:"<<name;
+            return true;
+        }
+        if(struc.values.length()>2)
+            qDebug()<<__FUNCTION__<<"between limit with more than 1 pair, using first; field"<<name;
+        switch (type)
+        {
+        case INT8:
+        case INT16:
+        case INT32:
+                if(!(var.toInt()>=struc.values.at(0).toInt() && var.toInt()<=struc.values.at(1).toInt()))
+                    return false;
+            return true;
+            break;
+        case UINT8:
+        case UINT16:
+        case UINT32:
+                if(!(var.toUInt()>=struc.values.at(0).toUInt() && var.toUInt()<=struc.values.at(1).toUInt()))
+                    return false;
+            return true;
+            break;
+        case ENUM:
+                if(!(options.indexOf(var.toString())>=options.indexOf(struc.values.at(0).toString()) && options.indexOf(var.toString())<=options.indexOf(struc.values.at(1).toString())))
+                    return false;
+            return true;
+            break;
+        case STRING:
+            return true;
+            break;
+        case FLOAT32:
+                if(!(var.toFloat()>=struc.values.at(0).toFloat() && var.toFloat()<=struc.values.at(1).toFloat()))
+                    return false;
+            return true;
+            break;
+        default:
+            return true;
+        }
+        break;
+    case BIGGER:
+        if(struc.values.length()<1)
+        {
+            qDebug()<<__FUNCTION__<<"BIGGER limit with less than 1 value, aborting; field:"<<name;
+            return true;
+        }
+        if(struc.values.length()>1)
+            qDebug()<<__FUNCTION__<<"BIGGER limit with more than 1 value, using first; field"<<name;
+        switch (type)
+        {
+        case INT8:
+        case INT16:
+        case INT32:
+                if(!(var.toInt()>=struc.values.at(0).toInt()))
+                    return false;
+            return true;
+            break;
+        case UINT8:
+        case UINT16:
+        case UINT32:
+                if(!(var.toUInt()>=struc.values.at(0).toUInt()))
+                    return false;
+            return true;
+            break;
+        case ENUM:
+                if(!(options.indexOf(var.toString())>=options.indexOf(struc.values.at(0).toString())))
+                    return false;
+            return true;
+            break;
+        case STRING:
+            return true;
+            break;
+        case FLOAT32:
+                if(!(var.toFloat()>=struc.values.at(0).toFloat()))
+                    return false;
+            return true;
+            break;
+        default:
+            return true;
+        }
+        break;
+    case SMALLER:
+        switch (type)
+        {
+        case INT8:
+        case INT16:
+        case INT32:
+                if(!(var.toInt()<=struc.values.at(0).toInt()))
+                    return false;
+            return true;
+            break;
+        case UINT8:
+        case UINT16:
+        case UINT32:
+                if(!(var.toUInt()<=struc.values.at(0).toUInt()))
+                    return false;
+            return true;
+            break;
+        case ENUM:
+                if(!(options.indexOf(var.toString())<=options.indexOf(struc.values.at(0).toString())))
+                    return false;
+            return true;
+            break;
+        case STRING:
+            return true;
+            break;
+        case FLOAT32:
+                if(!(var.toFloat()<=struc.values.at(0).toFloat()))
+                    return false;
+            return true;
+            break;
+        default:
+            return true;
+        }
+    }
+    return true;
+}
 
+QVariant UAVObjectField::getMaxLimit(quint32 index)
+{
+    if(!elementLimits.keys().contains(index))
+        return QVariant();
+    LimitStruct struc=elementLimits.value(index);
+    switch(struc.type)
+    {
+    case EQUAL:
+    case NOT_EQUAL:
+    case BIGGER:
+        return QVariant();
+        break;
+        break;
+    case BETWEEN:
+        return struc.values.at(1);
+        break;
+    case SMALLER:
+        return struc.values.at(0);
+        break;
+    default:
+        return QVariant();
+        break;
+    }
+     return QVariant();
+}
+QVariant UAVObjectField::getMinLimit(quint32 index)
+{
+    if(!elementLimits.keys().contains(index))
+        return QVariant();
+    LimitStruct struc=elementLimits.value(index);
+    switch(struc.type)
+    {
+    case EQUAL:
+    case NOT_EQUAL:
+    case SMALLER:
+        return QVariant();
+        break;
+        break;
+    case BETWEEN:
+        return struc.values.at(0);
+        break;
+    case BIGGER:
+        return struc.values.at(0);
+        break;
+    default:
+        return QVariant();
+        break;
+    }
+     return QVariant();
+}
 void UAVObjectField::initialize(quint8* data, quint32 dataOffset, UAVObject* obj)
 {
     this->data = data;
@@ -566,6 +849,7 @@ bool UAVObjectField::checkValue(const QVariant& value, quint32 index)
             break;
         }
     }
+    return true;
 }
 
 void UAVObjectField::setValue(const QVariant& value, quint32 index)

ground/openpilotgcs/src/plugins/uavobjects/uavobjectfield.h

@@ -75,6 +75,9 @@ public:
     bool isText();
     QString toString();
 
+    bool isWithinLimits(QVariant var, quint32 index);
+    QVariant getMaxLimit(quint32 index);
+    QVariant getMinLimit(quint32 index);
 signals:
     void fieldUpdated(UAVObjectField* field);
 
@@ -91,8 +94,8 @@ protected:
     UAVObject* obj;
     QMap<quint32,LimitStruct> elementLimits;
     void clear();
-    void constructorInitialize(const QString& name, const QString& units, FieldType type, const QStringList& elementNames, const QStringList& options, QString &limits);
+    void constructorInitialize(const QString& name, const QString& units, FieldType type, const QStringList& elementNames, const QStringList& options, const QString &limits);
-    void limitsInitialize(QString &limits);
+    void limitsInitialize(const QString &limits);
 
 
 };