Merge branch 'release-1.6.4' of https://github.com/N3Roaster/typica into release-1.6.4

src/abouttypica.cpp

-/*260:*/
+/*265:*/
 #line 33 "./abouttypica.w"
 
 #include "abouttypica.h"
 
-/*261:*/
+/*266:*/
 #line 42 "./abouttypica.w"
 
 AboutTypica::AboutTypica():QMainWindow(NULL)
 setCentralWidget(banner);
 }
 
-#line 6340 "./typica.w"
+#line 6404 "./typica.w"
 
-/*:261*/
+/*:266*/
 #line 36 "./abouttypica.w"
 
 
-/*:260*/
+/*:265*/

src/abouttypica.h

-/*259:*/
+/*264:*/
 #line 14 "./abouttypica.w"
 
 #include <QMainWindow> 
 
 #endif
 
-/*:259*/
+/*:264*/

src/daterangeselector.cpp

-/*650:*/
-#line 68 "./daterangeselector.w"
+/*656:*/
+#line 70 "./daterangeselector.w"
 
 #include <QCalendarWidget> 
 #include <QPushButton> 
 
 #include "daterangeselector.h"
 
-/*652:*/
-#line 111 "./daterangeselector.w"
+/*658:*/
+#line 115 "./daterangeselector.w"
 
 CustomDateRangePopup::CustomDateRangePopup(QWidget*parent):
 QWidget(parent,Qt::Popup),startDateSelector(new QCalendarWidget),
 setLayout(outerLayout);
 }
 
-/*:652*//*653:*/
-#line 159 "./daterangeselector.w"
+/*:658*//*659:*/
+#line 163 "./daterangeselector.w"
 
 void CustomDateRangePopup::hideEvent(QHideEvent*)
 {
 emit hidingPopup();
 }
 
-/*:653*//*654:*/
-#line 168 "./daterangeselector.w"
+/*:659*//*660:*/
+#line 172 "./daterangeselector.w"
 
 void CustomDateRangePopup::applyRange()
 {
 hide();
 }
 
-/*:654*//*655:*/
-#line 185 "./daterangeselector.w"
+/*:660*//*661:*/
+#line 189 "./daterangeselector.w"
 
 void CustomDateRangePopup::validateRange()
 {
 }
 }
 
-/*:655*/
-#line 79 "./daterangeselector.w"
+/*:661*/
+#line 81 "./daterangeselector.w"
 
-/*656:*/
-#line 203 "./daterangeselector.w"
+/*662:*/
+#line 207 "./daterangeselector.w"
 
 DateRangeSelector::DateRangeSelector(QWidget*parent):
 QWidget(parent),quickSelector(new QComboBox(this)),
 QDate currentDate= QDate::currentDate();
 
 QHBoxLayout*layout= new QHBoxLayout;
-/*657:*/
-#line 232 "./daterangeselector.w"
+/*663:*/
+#line 236 "./daterangeselector.w"
 
 quickSelector->addItem("Yesterday",QVariant(QStringList()<<
 currentDate.addDays(-1).toString(Qt::ISODate)));
 quickSelector->addItem("Lifetime");
 quickSelector->addItem("Custom");
 
-/*:657*/
-#line 213 "./daterangeselector.w"
+/*:663*/
+#line 217 "./daterangeselector.w"
 
 QToolButton*customButton= new QToolButton;
 customButton->setIcon(QIcon::fromTheme("office-calendar",
 connect(customButton,SIGNAL(clicked()),this,SLOT(toggleCustom()));
 }
 
-/*:656*//*658:*/
-#line 315 "./daterangeselector.w"
+/*:662*//*664:*/
+#line 319 "./daterangeselector.w"
 
 void DateRangeSelector::updateRange(int index)
 {
 }
 }
 
-/*:658*//*659:*/
-#line 332 "./daterangeselector.w"
+/*:664*//*665:*/
+#line 336 "./daterangeselector.w"
 
 void DateRangeSelector::popupHidden()
 {
 quickSelector->setCurrentIndex(lastIndex);
 }
 
-/*:659*//*660:*/
-#line 343 "./daterangeselector.w"
+/*:665*//*666:*/
+#line 347 "./daterangeselector.w"
 
 void DateRangeSelector::setCustomRange(QVariant range)
 {
 quickSelector->setCurrentIndex(lastIndex);
 }
 
-/*:660*//*661:*/
-#line 358 "./daterangeselector.w"
+/*:666*//*667:*/
+#line 362 "./daterangeselector.w"
 
 void DateRangeSelector::toggleCustom()
 {
 }
 }
 
-/*:661*//*662:*/
-#line 400 "./daterangeselector.w"
+/*:667*//*668:*/
+#line 404 "./daterangeselector.w"
 
 QVariant DateRangeSelector::currentRange()
 {
 return quickSelector->itemData(lastIndex);
 }
 
-/*:662*//*663:*/
-#line 408 "./daterangeselector.w"
+/*:668*//*669:*/
+#line 412 "./daterangeselector.w"
 
 void DateRangeSelector::setCurrentIndex(int index)
 {
 quickSelector->setCurrentIndex(index);
 }
 
-/*:663*//*664:*/
-#line 423 "./daterangeselector.w"
+int DateRangeSelector::currentIndex()
+{
+return quickSelector->currentIndex();
+}
+
+/*:669*//*670:*/
+#line 432 "./daterangeselector.w"
 
 void DateRangeSelector::setLifetimeRange(QString startDate,QString endDate)
 {
 QVariant(QStringList()<<startDate<<endDate));
 }
 
-/*:664*//*665:*/
-#line 433 "./daterangeselector.w"
+/*:670*//*671:*/
+#line 442 "./daterangeselector.w"
 
 void DateRangeSelector::removeIndex(int index)
 {
 quickSelector->removeItem(index);
 }
 
-/*:665*/
-#line 80 "./daterangeselector.w"
+/*:671*/
+#line 82 "./daterangeselector.w"
 
 
+#if 0
 #include "moc_daterangeselector.cpp"
+#endif
 
-/*:650*/
+/*:656*/

src/daterangeselector.h

-/*649:*/
+/*655:*/
 #line 30 "./daterangeselector.w"
 
 
 #ifndef TypicaDateRangeSelectorHeader
 #define TypicaDateRangeSelectorHeader
 
-/*651:*/
-#line 87 "./daterangeselector.w"
+/*657:*/
+#line 91 "./daterangeselector.w"
 
 class CustomDateRangePopup:public QWidget
 {
 QPushButton*applyButton;
 };
 
-/*:651*/
+/*:657*/
 #line 39 "./daterangeselector.w"
 
 
 class DateRangeSelector:public QWidget
 {
 Q_OBJECT
+Q_PROPERTY(int currentIndex READ currentIndex WRITE setCurrentIndex)
 public:
 DateRangeSelector(QWidget*parent= NULL);
 void setCustomRange(QVariant range);
 Q_INVOKABLE QVariant currentRange();
+int currentIndex();
 public slots:
 void setCurrentIndex(int index);
 void setLifetimeRange(QString startDate,QString endDate);
 
 #endif
 
-/*:649*/
+/*:655*/

src/draglabel.cpp

-/*972:*/
+/*992:*/
 #line 33 "./scales.w"
 
 #include "draglabel.h"
 }
 }
 
-/*:972*/
+/*:992*/

src/draglabel.h

-/*971:*/
+/*991:*/
 #line 13 "./scales.w"
 
 #ifndef TypicaDragLabelInclude
 
 #endif
 
-/*:971*/
+/*:991*/

src/helpmenu.cpp

 /*194:*/
-#line 35 "./helpmenu.w"
+#line 36 "./helpmenu.w"
 
 #include "helpmenu.h"
 #include "abouttypica.h"
+#include "licensewindow.h"
 
 /*195:*/
-#line 47 "./helpmenu.w"
+#line 46 "./helpmenu.w"
 
 HelpMenu::HelpMenu():QMenu()
 {
 aboutTypicaAction->setObjectName("aboutTypicaAction");
 addAction(aboutTypicaAction);
 connect(aboutTypicaAction,SIGNAL(triggered()),this,SLOT(displayAboutTypica()));
+#if 0
+QAction*licenseAction= new QAction(tr("License Information"),this);
+licenseAction->setObjectName("licenseAction");
+addAction(licenseAction);
+connect(licenseAction,SIGNAL(triggered()),this,SLOT(displayLicenseWindow()));
+#endif
 }
 
 /*:195*//*196:*/
-#line 61 "./helpmenu.w"
+#line 66 "./helpmenu.w"
 
 void HelpMenu::displayAboutTypica()
 {
 aboutBox->show();
 }
 
-#line 4614 "./typica.w"
+/*:196*//*197:*/
+#line 76 "./helpmenu.w"
 
-#line 1 "./feedback.w"
-/*:196*/
-#line 39 "./helpmenu.w"
+void HelpMenu::displayLicenseWindow()
+{
+LicenseWindow*window= new LicenseWindow;
+window->show();
+}
+
+#line 4615 "./typica.w"
+
+#line 1 "./licensewindow.w"
+/*:197*/
+#line 41 "./helpmenu.w"
 
 
 /*:194*/

src/helpmenu.h

 HelpMenu();
 public slots:
 void displayAboutTypica();
+void displayLicenseWindow();
 };
 
 #endif

src/moc_daterangeselector.cpp

        0,       // classname
        0,    0, // classinfo
        8,   14, // methods
-       0,    0, // properties
+       1,   54, // properties
        0,    0, // enums/sets
        0,    0, // constructors
        0,       // flags
  // methods: signature, parameters, type, tag, flags
      193,   18,  184,   18, 0x02,
 
+ // properties: name, type, flags
+     212,  208, 0x02095103,
+
        0        // eod
 };
 
     "setLifetimeRange(QString,QString)\0"
     "removeIndex(int)\0toggleCustom()\0"
     "popupHidden()\0updateRange(int)\0QVariant\0"
-    "currentRange()\0"
+    "currentRange()\0int\0currentIndex\0"
 };
 
 void DateRangeSelector::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
             qt_static_metacall(this, _c, _id, _a);
         _id -= 8;
     }
+#ifndef QT_NO_PROPERTIES
+      else if (_c == QMetaObject::ReadProperty) {
+        void *_v = _a[0];
+        switch (_id) {
+        case 0: *reinterpret_cast< int*>(_v) = currentIndex(); break;
+        }
+        _id -= 1;
+    } else if (_c == QMetaObject::WriteProperty) {
+        void *_v = _a[0];
+        switch (_id) {
+        case 0: setCurrentIndex(*reinterpret_cast< int*>(_v)); break;
+        }
+        _id -= 1;
+    } else if (_c == QMetaObject::ResetProperty) {
+        _id -= 1;
+    } else if (_c == QMetaObject::QueryPropertyDesignable) {
+        _id -= 1;
+    } else if (_c == QMetaObject::QueryPropertyScriptable) {
+        _id -= 1;
+    } else if (_c == QMetaObject::QueryPropertyStored) {
+        _id -= 1;
+    } else if (_c == QMetaObject::QueryPropertyEditable) {
+        _id -= 1;
+    } else if (_c == QMetaObject::QueryPropertyUser) {
+        _id -= 1;
+    }
+#endif // QT_NO_PROPERTIES
     return _id;
 }
 

src/moc_typica.cpp

         return _id;
     return _id;
 }
+static const uint qt_meta_data_ScriptValidator[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       0,    0, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+       0,       // flags
+       0,       // signalCount
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_ScriptValidator[] = {
+    "ScriptValidator\0"
+};
+
+void ScriptValidator::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    Q_UNUSED(_o);
+    Q_UNUSED(_id);
+    Q_UNUSED(_c);
+    Q_UNUSED(_a);
+}
+
+const QMetaObjectExtraData ScriptValidator::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject ScriptValidator::staticMetaObject = {
+    { &QValidator::staticMetaObject, qt_meta_stringdata_ScriptValidator,
+      qt_meta_data_ScriptValidator, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &ScriptValidator::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *ScriptValidator::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *ScriptValidator::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_ScriptValidator))
+        return static_cast<void*>(const_cast< ScriptValidator*>(this));
+    return QValidator::qt_metacast(_clname);
+}
+
+int ScriptValidator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QValidator::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    return _id;
+}
 static const uint qt_meta_data_DAQ[] = {
 
  // content:
        0,       // classname
        0,    0, // classinfo
       18,   14, // methods
-       6,  104, // properties
+       7,  104, // properties
        0,    0, // enums/sets
        0,    0, // constructors
        0,       // flags
      370,  333, 0x0f095103,
      389,  381, 0x0a095103,
      403,  357, 0x01095103,
+     120,  381, 0x0a095001,
 
        0        // eod
 };
         case 3: *reinterpret_cast< QTime*>(_v) = resetValue(); break;
         case 4: *reinterpret_cast< QString*>(_v) = displayFormat(); break;
         case 5: *reinterpret_cast< bool*>(_v) = autoReset(); break;
+        case 6: *reinterpret_cast< QString*>(_v) = value(); break;
         }
-        _id -= 6;
+        _id -= 7;
     } else if (_c == QMetaObject::WriteProperty) {
         void *_v = _a[0];
         switch (_id) {
         case 4: setDisplayFormat(*reinterpret_cast< QString*>(_v)); break;
         case 5: setAutoReset(*reinterpret_cast< bool*>(_v)); break;
         }
-        _id -= 6;
+        _id -= 7;
     } else if (_c == QMetaObject::ResetProperty) {
-        _id -= 6;
+        _id -= 7;
     } else if (_c == QMetaObject::QueryPropertyDesignable) {
-        _id -= 6;
+        _id -= 7;
     } else if (_c == QMetaObject::QueryPropertyScriptable) {
-        _id -= 6;
+        _id -= 7;
     } else if (_c == QMetaObject::QueryPropertyStored) {
-        _id -= 6;
+        _id -= 7;
     } else if (_c == QMetaObject::QueryPropertyEditable) {
-        _id -= 6;
+        _id -= 7;
     } else if (_c == QMetaObject::QueryPropertyUser) {
-        _id -= 6;
+        _id -= 7;
     }
 #endif // QT_NO_PROPERTIES
     return _id;
     }
     return _id;
 }
+static const uint qt_meta_data_CoolingTimerConfWidget[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       1,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       1,   19, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      29,   24,   23,   23, 0x08,
+
+ // constructors: signature, parameters, type, tag, flags
+      64,   52,   23,   23, 0x0e,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_CoolingTimerConfWidget[] = {
+    "CoolingTimerConfWidget\0\0time\0"
+    "updateResetTime(QTime)\0model,index\0"
+    "CoolingTimerConfWidget(DeviceTreeModel*,QModelIndex)\0"
+};
+
+void CoolingTimerConfWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::CreateInstance) {
+        switch (_id) {
+        case 0: { CoolingTimerConfWidget *_r = new CoolingTimerConfWidget((*reinterpret_cast< DeviceTreeModel*(*)>(_a[1])),(*reinterpret_cast< const QModelIndex(*)>(_a[2])));
+            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
+        }
+    } else if (_c == QMetaObject::InvokeMetaMethod) {
+        Q_ASSERT(staticMetaObject.cast(_o));
+        CoolingTimerConfWidget *_t = static_cast<CoolingTimerConfWidget *>(_o);
+        switch (_id) {
+        case 0: _t->updateResetTime((*reinterpret_cast< QTime(*)>(_a[1]))); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData CoolingTimerConfWidget::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject CoolingTimerConfWidget::staticMetaObject = {
+    { &BasicDeviceConfigurationWidget::staticMetaObject, qt_meta_stringdata_CoolingTimerConfWidget,
+      qt_meta_data_CoolingTimerConfWidget, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &CoolingTimerConfWidget::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *CoolingTimerConfWidget::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *CoolingTimerConfWidget::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_CoolingTimerConfWidget))
+        return static_cast<void*>(const_cast< CoolingTimerConfWidget*>(this));
+    return BasicDeviceConfigurationWidget::qt_metacast(_clname);
+}
+
+int CoolingTimerConfWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = BasicDeviceConfigurationWidget::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        if (_id < 1)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 1;
+    }
+    return _id;
+}
+static const uint qt_meta_data_RangeTimerConfWidget[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       8,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       1,   54, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      27,   22,   21,   21, 0x08,
+      58,   22,   21,   21, 0x08,
+      88,   22,   21,   21, 0x08,
+     119,   22,   21,   21, 0x08,
+     149,   22,   21,   21, 0x08,
+     175,   22,   21,   21, 0x08,
+     207,  200,   21,   21, 0x08,
+     231,  200,   21,   21, 0x08,
+
+ // constructors: signature, parameters, type, tag, flags
+     266,  254,   21,   21, 0x0e,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_RangeTimerConfWidget[] = {
+    "RangeTimerConfWidget\0\0text\0"
+    "updateStartButtonText(QString)\0"
+    "updateStopButtonText(QString)\0"
+    "updateStartColumnName(QString)\0"
+    "updateStopColumnName(QString)\0"
+    "updateStartValue(QString)\0"
+    "updateStopValue(QString)\0option\0"
+    "updateStartTrigger(int)\0updateStopTrigger(int)\0"
+    "model,index\0"
+    "RangeTimerConfWidget(DeviceTreeModel*,QModelIndex)\0"
+};
+
+void RangeTimerConfWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::CreateInstance) {
+        switch (_id) {
+        case 0: { RangeTimerConfWidget *_r = new RangeTimerConfWidget((*reinterpret_cast< DeviceTreeModel*(*)>(_a[1])),(*reinterpret_cast< const QModelIndex(*)>(_a[2])));
+            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
+        }
+    } else if (_c == QMetaObject::InvokeMetaMethod) {
+        Q_ASSERT(staticMetaObject.cast(_o));
+        RangeTimerConfWidget *_t = static_cast<RangeTimerConfWidget *>(_o);
+        switch (_id) {
+        case 0: _t->updateStartButtonText((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 1: _t->updateStopButtonText((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 2: _t->updateStartColumnName((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 3: _t->updateStopColumnName((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 4: _t->updateStartValue((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 5: _t->updateStopValue((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 6: _t->updateStartTrigger((*reinterpret_cast< int(*)>(_a[1]))); break;
+        case 7: _t->updateStopTrigger((*reinterpret_cast< int(*)>(_a[1]))); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData RangeTimerConfWidget::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject RangeTimerConfWidget::staticMetaObject = {
+    { &BasicDeviceConfigurationWidget::staticMetaObject, qt_meta_stringdata_RangeTimerConfWidget,
+      qt_meta_data_RangeTimerConfWidget, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &RangeTimerConfWidget::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *RangeTimerConfWidget::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *RangeTimerConfWidget::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_RangeTimerConfWidget))
+        return static_cast<void*>(const_cast< RangeTimerConfWidget*>(this));
+    return BasicDeviceConfigurationWidget::qt_metacast(_clname);
+}
+
+int RangeTimerConfWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = BasicDeviceConfigurationWidget::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        if (_id < 8)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 8;
+    }
+    return _id;
+}
+static const uint qt_meta_data_MultiRangeTimerConfWidget[] = {
+
+ // content:
+       6,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       2,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       1,   24, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: signature, parameters, type, tag, flags
+      32,   27,   26,   26, 0x08,
+      58,   26,   26,   26, 0x08,
+
+ // constructors: signature, parameters, type, tag, flags
+      88,   76,   26,   26, 0x0e,
+
+       0        // eod
+};
+
+static const char qt_meta_stringdata_MultiRangeTimerConfWidget[] = {
+    "MultiRangeTimerConfWidget\0\0text\0"
+    "updateColumnName(QString)\0updateRangeData()\0"
+    "model,index\0"
+    "MultiRangeTimerConfWidget(DeviceTreeModel*,QModelIndex)\0"
+};
+
+void MultiRangeTimerConfWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::CreateInstance) {
+        switch (_id) {
+        case 0: { MultiRangeTimerConfWidget *_r = new MultiRangeTimerConfWidget((*reinterpret_cast< DeviceTreeModel*(*)>(_a[1])),(*reinterpret_cast< const QModelIndex(*)>(_a[2])));
+            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
+        }
+    } else if (_c == QMetaObject::InvokeMetaMethod) {
+        Q_ASSERT(staticMetaObject.cast(_o));
+        MultiRangeTimerConfWidget *_t = static_cast<MultiRangeTimerConfWidget *>(_o);
+        switch (_id) {
+        case 0: _t->updateColumnName((*reinterpret_cast< const QString(*)>(_a[1]))); break;
+        case 1: _t->updateRangeData(); break;
+        default: ;
+        }
+    }
+}
+
+const QMetaObjectExtraData MultiRangeTimerConfWidget::staticMetaObjectExtraData = {
+    0,  qt_static_metacall 
+};
+
+const QMetaObject MultiRangeTimerConfWidget::staticMetaObject = {
+    { &BasicDeviceConfigurationWidget::staticMetaObject, qt_meta_stringdata_MultiRangeTimerConfWidget,
+      qt_meta_data_MultiRangeTimerConfWidget, &staticMetaObjectExtraData }
+};
+
+#ifdef Q_NO_DATA_RELOCATION
+const QMetaObject &MultiRangeTimerConfWidget::getStaticMetaObject() { return staticMetaObject; }
+#endif //Q_NO_DATA_RELOCATION
+
+const QMetaObject *MultiRangeTimerConfWidget::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
+}
+
+void *MultiRangeTimerConfWidget::qt_metacast(const char *_clname)
+{
+    if (!_clname) return 0;
+    if (!strcmp(_clname, qt_meta_stringdata_MultiRangeTimerConfWidget))
+        return static_cast<void*>(const_cast< MultiRangeTimerConfWidget*>(this));
+    return BasicDeviceConfigurationWidget::qt_metacast(_clname);
+}
+
+int MultiRangeTimerConfWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = BasicDeviceConfigurationWidget::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        if (_id < 2)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 2;
+    }
+    return _id;
+}
 static const uint qt_meta_data_TranslationConfWidget[] = {
 
  // content:

src/scale.cpp

-/*978:*/
+/*998:*/
 #line 131 "./scales.w"
 
 #include "scale.h"
 connect(this,SIGNAL(readyRead()),this,SLOT(dataAvailable()));
 }
 
-/*:978*//*979:*/
+/*:998*//*999:*/
 #line 149 "./scales.w"
 
 void SerialScale::dataAvailable()
 }
 else
 {
-/*980:*/
+/*1000:*/
 #line 189 "./scales.w"
 
 QStringList responseParts= QString(responseBuffer.simplified()).split(' ');
 }
 emit newMeasurement(weight,unit);
 
-/*:980*/
+/*:1000*/
 #line 161 "./scales.w"
 
 responseBuffer.clear();
 }
 }
 
-/*:979*//*981:*/
+/*:999*//*1001:*/
 #line 220 "./scales.w"
 
 void SerialScale::tare()
 write("!KP\x0D");
 }
 
-/*:981*/
+/*:1001*/

src/scale.h

-/*977:*/
+/*997:*/
 #line 103 "./scales.w"
 
 #ifndef TypicaScaleInclude
 
 #endif
 
-/*:977*/
+/*:997*/

src/units.cpp

-/*264:*/
+/*269:*/
 #line 42 "./units.w"
 
 #include "units.h"
+#include <QtDebug> 
 
-/*:264*//*265:*/
-#line 52 "./units.w"
+/*:269*//*270:*/
+#line 53 "./units.w"
 
 bool Units::isTemperatureUnit(Unit unit)
 {
 unit==Rankine);
 }
 
-/*:265*//*266:*/
-#line 70 "./units.w"
+/*:270*//*271:*/
+#line 71 "./units.w"
 
 double Units::convertTemperature(double value,Unit fromUnit,Unit toUnit)
 {
 case Rankine:
 return value+459.67;
 break;
+default:
+qDebug()<<"Warning: Non-sensical unit conversion.";
+break;
 }
 break;
 case Celsius:
 case Rankine:
 return(value+273.15)*9.0/5.0;
 break;
+default:
+qDebug()<<"Warning: Non-sensical unit conversion.";
+break;
 }
 break;
 case Kelvin:
 case Rankine:
 return value*9.0/5.0;
 break;
+default:
+qDebug()<<"Warning: Non-sensical unit conversion.";
+break;
 }
 break;
 case Rankine:
 case Rankine:
 return value;
 break;
+default:
+qDebug()<<"Warning: Non-sensical unit conversion.";
+break;
 }
 break;
 default:
 return 0;
 }
 
-/*:266*//*267:*/
-#line 156 "./units.w"
+/*:271*//*272:*/
+#line 169 "./units.w"
 
 double Units::convertRelativeTemperature(double value,Unit fromUnit,Unit toUnit)
 {
 return 0;
 }
 
-/*:267*//*268:*/
-#line 254 "./units.w"
+/*:272*//*273:*/
+#line 267 "./units.w"
 
 double Units::convertWeight(double value,Unit fromUnit,Unit toUnit)
 {
 unit==Gram);
 }
 
-/*:268*/
+/*:273*/

src/units.h

-/*263:*/
+/*268:*/
 #line 8 "./units.w"
 
 #include <QObject> 
 
 #endif
 
-/*:263*/
+/*:268*/

src/webelement.cpp

-/*557:*/
+/*563:*/
 #line 368 "./webview.w"
 
 #include "webelement.h"
 
-/*555:*/
+/*561:*/
 #line 311 "./webview.w"
 
 TypicaWebElement::TypicaWebElement(QWebElement element):e(element)
 
 }
 
-/*:555*//*556:*/
+/*:561*//*562:*/
 #line 320 "./webview.w"
 
 void TypicaWebElement::appendInside(const QString&markup)
 e.setPlainText(text);
 }
 
-/*:556*/
+/*:562*/
 #line 371 "./webview.w"
 
 
-/*:557*/
+/*:563*/

src/webelement.h

-/*550:*/
+/*556:*/
 #line 248 "./webview.w"
 
 #include <QWebElement> 
 
 #endif
 
-/*:550*/
+/*:556*/

src/webview.cpp

-/*535:*/
+/*541:*/
 #line 50 "./webview.w"
 
 #include "webview.h"
 
-/*536:*/
+/*542:*/
 #line 57 "./webview.w"
 
 TypicaWebView::TypicaWebView():QWebView()
 connect(page(),SIGNAL(linkClicked(QUrl)),this,SLOT(linkDelegate(QUrl)));
 }
 
-/*:536*//*537:*/
+/*:542*//*543:*/
 #line 73 "./webview.w"
 
 void TypicaWebView::linkDelegate(const QUrl&url)
 if(url.scheme()=="typica")
 {
 QString address(url.toEncoded());
-/*538:*/
+/*544:*/
 #line 91 "./webview.w"
 
 if(address=="typica://aboutqt")
 return;
 }
 
-/*:538*/
+/*:544*/
 #line 79 "./webview.w"
 
-/*539:*/
+/*545:*/
 #line 100 "./webview.w"
 
 if(address.startsWith("typica://script/"))
 return;
 }
 
-/*:539*/
+/*:545*/
 #line 80 "./webview.w"
 
 }
 }
 }
 
-/*:537*//*540:*/
+/*:543*//*546:*/
 #line 112 "./webview.w"
 
 void TypicaWebView::load(const QString&url)
 return page()->currentFrame()->documentElement().toOuterXml();
 }
 
-/*:540*//*546:*/
+/*:546*//*552:*/
 #line 205 "./webview.w"
 
 QWebElement TypicaWebView::documentElement()
 return page()->mainFrame()->findFirstElement(selector);
 }
 
-/*:546*/
+/*:552*/
 #line 53 "./webview.w"
 
 
-/*:535*/
+/*:541*/

src/webview.h

-/*534:*/
+/*540:*/
 #line 14 "./webview.w"
 
 #include <QWebView> 
 
 #endif
 
-/*:534*/
+/*:540*/