init

customcontrols/dmcheckbox.cpp

@@ -0,0 +1,13 @@
+#include "dmcheckbox.h"
+#include<QDebug>
+
+DMCheckBox::DMCheckBox(QWidget *parent):QCheckBox(parent)
+{
+    setFocusPolicy(Qt::TabFocus);
+}
+
+
+DMCheckBox::~DMCheckBox() {
+    qDebug() << "-----DMCheckBox destroying";
+    qDebug() << "-----DMCheckBox destroyed";
+}

customcontrols/dmcheckbox.h

@@ -0,0 +1,12 @@
+#ifndef DMCHECKBOX_H
+#define DMCHECKBOX_H
+
+#include <QCheckBox>
+
+class DMCheckBox : public QCheckBox {
+public:
+    DMCheckBox(QWidget *parent = nullptr);
+    ~DMCheckBox();
+};
+
+#endif // DMCHECKBOX_H

customcontrols/dmcombobox.cpp

@@ -0,0 +1,14 @@
+#include "dmcombobox.h"
+#include<QDebug>
+#include "eventfilterwheel.h"
+
+DMComboBox::DMComboBox(QWidget *parent) :
+QComboBox(parent) {
+    installEventFilter(new EventFilterWheel());
+    setFocusPolicy(Qt::TabFocus);
+}
+
+DMComboBox::~DMComboBox() {
+    qDebug() << "-----DMComboBox destroying";
+    qDebug() << "-----DMComboBox destroyed";
+}

customcontrols/dmcombobox.h

@@ -0,0 +1,13 @@
+#ifndef DMCOMBOBOX_H
+#define DMCOMBOBOX_H
+
+#include <QComboBox>
+
+class DMComboBox : public QComboBox {
+    Q_OBJECT
+public:
+    DMComboBox(QWidget *parent = nullptr);
+    ~DMComboBox();
+};
+
+#endif // DMCOMBOBOX_H

customcontrols/dmdoublespinbox.cpp

@@ -0,0 +1,33 @@
+#include "dmdoublespinbox.h"
+#include "eventfilterwheel.h"
+#include <QDebug>
+#include <QEvent>
+
+DMDoubleSpinBox::DMDoubleSpinBox(QWidget *parent) :
+        QDoubleSpinBox(parent)
+{
+    installEventFilter(new EventFilterWheel());
+    // 只有在鼠标点击或按下tab键时获取焦点
+    setFocusPolicy(Qt::StrongFocus);
+    setKeyboardTracking(false);
+    installEventFilter(this);
+}
+
+#ifdef QT_DEBUG
+bool DMDoubleSpinBox::eventFilter(QObject *watched, QEvent *event)
+{
+//    Q_UNUSED(watched)
+//    QDoubleSpinBox *castSBox = static_cast<QDoubleSpinBox*>(watched);
+    if(event->type()==QEvent::Timer)
+    {
+        QTimerEvent *tEvent = static_cast<QTimerEvent*>(event);
+        if(tEvent)
+            qDebug() << "<--QEvent::Timer-->" << tEvent->timerId();
+        return true;
+    }
+    return QObject::eventFilter(watched,event);
+}
+#endif
+
+
+

customcontrols/dmdoublespinbox.h

@@ -0,0 +1,20 @@
+#ifndef DMDOUBLESPINBOX_H
+#define DMDOUBLESPINBOX_H
+#include <QDoubleSpinBox>
+
+
+
+class DMDoubleSpinBox : public QDoubleSpinBox {
+    Q_OBJECT
+
+
+public:
+    DMDoubleSpinBox(QWidget *parent = nullptr);
+private:
+#ifdef QT_DEBUG
+    bool eventFilter(QObject *watched, QEvent *event) override;
+#endif
+};
+
+
+#endif // DMDOUBLESPINBOX_H

customcontrols/dmlabel.cpp

@@ -0,0 +1,163 @@
+
+#include "dmlabel.h"
+/*
+#include "view/epc_label.h"
+#include "view/dialog_ok.h"
+#include "view/dialog_yes_no.h"
+#include <QCursor>
+#include <QDebug>
+#include <QFileDialog>
+#include <QImage>
+#include <QPixmap>
+#include <QString>
+
+/// \addtogroup EpcLabel
+/// @{
+
+
+DMLabel::DMLabel(QWidget *parent) :
+QLabel(parent),
+rubberBand(QRubberBand::Rectangle, this) {
+    cursorCrosshair = QCursor(QPixmap(":/cursors/cursor_crosshair.png"));
+    selectROI = false;
+    this->setMouseTracking(true);
+    this->setMinimumSize(1,1);
+    selectEnable = true;
+    partType = PartType::EPC660;
+    ctrlKeyFlag = false;
+    altKeyFlag = false;
+    shiftKeyFlag = false;
+}
+
+DMLabel::~DMLabel() {
+    qDebug() << "-----EpcLabel destroying";
+    qDebug() << "-----EpcLabel destroyed";
+}
+
+void DMLabel::mousePressEvent ( QMouseEvent * event ) {
+    if(event->modifiers() == Qt::ControlModifier){  //for Pixel Info
+        ctrlKeyFlag = true;
+        altKeyFlag  = false;
+
+    }else if(event->modifiers() == Qt::AltModifier){    //for Time scope
+        altKeyFlag = true;
+        ctrlKeyFlag = false;
+
+    }else if(event->modifiers() == Qt::ShiftModifier){ //for ROI
+        if (partType == PartType::EPC635 || partType == PartType::EPC503){
+            return;
+        }
+        selectMarker(false);
+        shiftKeyFlag = true;
+        selectROI    = true;
+        rubberStartX = event->x();
+        rubberStartY = event->y();
+
+        if (!(partType == PartType::EPC635 || partType == PartType::EPC503)){
+            rubberStopY = height() - rubberStartY;
+        }
+    } else {
+        ctrlKeyFlag = false;
+        altKeyFlag  = false;
+        emit selectMarker(false);
+    }
+}
+
+
+void DMLabel::mouseMoveEvent ( QMouseEvent * event ) {
+
+    if (shiftKeyFlag && selectROI && selectEnable){
+        rubberStopX = event->x();
+        if (rubberStartX > rubberStopX){
+            x1 = rubberStopX;
+            x2 = rubberStartX;
+        }else{
+            x1 = rubberStartX;
+            x2 = rubberStopX;
+        }
+
+        if (partType == PartType::EPC635 || partType == PartType::EPC503){
+            return;
+        } else {
+            if (rubberStartY > rubberStopY){
+                y1 = rubberStopY;
+                y2 = rubberStartY;
+            }
+            else{
+                y1 = rubberStartY;
+                y2 = rubberStopY;
+            }
+        }
+
+        if(x1 < 0)        x1 = 0;
+        if(x2 > width())  x2 = width();
+        if(y1 < 0)        y1 = 0;
+        if(y2 > height()) y2 = height();
+
+        rubberBand.setGeometry(x1, y1, x2 - x1, y2 - y1);
+        rubberBand.show();
+
+    }
+
+    if(ctrlKeyFlag || altKeyFlag){
+        return;
+    }
+
+    emit mouseHover(event->x(), event->y());
+}
+
+
+void DMLabel::mouseReleaseEvent ( QMouseEvent * event ) {
+
+    if(event->button() == Qt::RightButton){
+        QPixmap pixmap= *this->pixmap();
+        QString filename = QFileDialog::getSaveFileName(this,"save image as", "", ".png");
+        if (!filename.isNull()){
+            pixmap.save(filename);
+        }
+    }else if(event->button() == Qt::LeftButton && selectEnable && shiftKeyFlag){
+
+        if (partType == PartType::EPC635 || partType == PartType::EPC503){
+            return;
+        }
+        shiftKeyFlag = false;
+        ctrlKeyFlag  = false;
+        altKeyFlag   = false;
+        selectROI = false;
+        rubberBand.hide();
+        selectMarker(false);
+        emit regionSelected(x1, x2, y1, y2);
+    }
+
+    if(altKeyFlag){
+        emit mouseHover(event->x(), event->y());
+        emit selectMarker(true);
+        emit checkTimeScope(true);
+    } else if(ctrlKeyFlag){
+        emit mouseHover(event->x(), event->y());
+        emit selectMarker(true);
+    }
+}
+
+void DMLabel::mouseDoubleClickEvent ( QMouseEvent * event ){
+    Q_UNUSED(event)
+    emit mouseDoubleClick();
+}
+
+void DMLabel::enterEvent ( QEvent* ) {
+    setCursor(EpcLabel::cursorCrosshair);
+}
+
+void DMLabel::leaveEvent ( QEvent*) {
+}
+
+void DMLabel::enableSelect(bool state){
+    selectEnable = state;
+    selectROI = false;
+}
+
+void DMLabel::setType(PartType value)
+{
+    partType = value;
+}*/
+

customcontrols/dmlabel.h

@@ -0,0 +1,49 @@
+#ifndef DMLABEL_H
+#define DMLABEL_H
+/*
+#include "data/constants.h"
+#include <QCursor>
+#include <QLabel>
+#include <QMouseEvent>
+#include <QKeyEvent>
+#include <QObject>
+#include <QPixmap>
+#include <QRubberBand>
+
+class DMLabel: public QLabel {
+    Q_OBJECT
+public:
+    DMLabel (QWidget *parent = nullptr);
+    ~DMLabel();
+    void enableSelect(bool state);
+    void setType(PartType value);
+
+signals:
+    void mouseHover(int x, int y);
+    void regionSelected(int x1, int x2, int y1, int y2);
+    void selectMarker(bool);
+    void checkTimeScope(bool);
+    void mouseDoubleClick();
+
+protected slots:
+    virtual void enterEvent ( QEvent*);
+    virtual void leaveEvent ( QEvent*);
+    virtual void mouseMoveEvent ( QMouseEvent * event );
+    virtual void mousePressEvent ( QMouseEvent * event );
+    virtual void mouseReleaseEvent ( QMouseEvent * event );
+    virtual void mouseDoubleClickEvent ( QMouseEvent * event );
+
+private:
+    int x,y;
+    PartType partType;
+    QCursor cursorCrosshair;
+    QRubberBand rubberBand;
+    int rubberStartX, rubberStartY, rubberStopX, rubberStopY;
+    int x1, x2, y1, y2;
+    bool selectROI;
+    bool selectEnable;
+    bool ctrlKeyFlag;
+    bool altKeyFlag;
+    bool shiftKeyFlag;
+};*/
+#endif // DMLABEL_H

customcontrols/dmspinbox.cpp

@@ -0,0 +1,30 @@
+#include "dmspinbox.h"
+#include "eventfilterwheel.h"
+#include <QDebug>
+#include <QEvent>
+
+
+DMSpinBox::DMSpinBox(QWidget *parent) :
+QSpinBox(parent) {
+    installEventFilter(new EventFilterWheel());
+    setFocusPolicy(Qt::StrongFocus);
+    setKeyboardTracking(false);
+    installEventFilter(this);
+}
+
+
+#ifdef QT_DEBUG
+bool DMSpinBox::eventFilter(QObject *watched, QEvent *event)
+{
+//    Q_UNUSED(watched)
+//    QDoubleSpinBox *castSBox = static_cast<QDoubleSpinBox*>(watched);
+    if(event->type()==QEvent::Timer)
+    {
+        QTimerEvent *tEvent = static_cast<QTimerEvent*>(event);
+        if(tEvent)
+            qDebug() << "<--QEvent::Timer-->" << tEvent->timerId();
+        return true;
+    }
+    return QObject::eventFilter(watched,event);
+}
+#endif

customcontrols/dmspinbox.h

@@ -0,0 +1,19 @@
+#ifndef DMSPINBOX_H
+#define DMSPINBOX_H
+
+
+#include <QSpinBox>
+
+class DMSpinBox : public QSpinBox {
+     Q_OBJECT
+public:
+     DMSpinBox(QWidget *parent = nullptr);
+
+private:
+#ifdef QT_DEBUG
+    bool eventFilter(QObject *watched, QEvent *event) override;
+#endif
+};
+
+
+#endif // DMSPINBOX_H

customcontrols/eventfilterwheel.cpp

@@ -0,0 +1,18 @@
+#include "eventfilterwheel.h"
+#include <QEvent>
+
+EventFilterWheel::EventFilterWheel(QObject *parent) :
+QObject(parent){
+}
+
+EventFilterWheel::~EventFilterWheel(){
+}
+
+bool EventFilterWheel::eventFilter(QObject *obj, QEvent *event){
+    Q_UNUSED(obj)
+    if(event->type() == QEvent::Wheel) {
+        event->ignore();
+        return true;
+    }
+    return false;
+}

customcontrols/eventfilterwheel.h

@@ -0,0 +1,13 @@
+#ifndef EVENTFILTERWHEEL_H
+#define EVENTFILTERWHEEL_H
+
+#include<QObject>
+
+class EventFilterWheel : public QObject {
+    Q_OBJECT
+public:
+    explicit EventFilterWheel(QObject *parent = nullptr);
+    ~EventFilterWheel();
+    bool eventFilter(QObject *obj, QEvent *event);
+};
+#endif // EVENTFILTERWHEEL_H

customcontrols/mipaddresseditor.cpp

@@ -0,0 +1,147 @@
+#include "mipaddresseditor.h"
+#include <QStyleOption>
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QEvent>
+#include <QKeyEvent>
+#include <QPainter>
+
+
+MIpAddressEditor::MIpAddressEditor(QWidget* parent) :
+    QWidget(parent), focused(false)
+{
+    setStyleSheet("* { background-color:white; }");
+    QHBoxLayout* lay = new QHBoxLayout();
+    lay->setContentsMargins(1, 1, 1, 1);
+    lay->setSpacing(0);
+    QLabel* label1 = new QLabel(".", this);
+    QLabel* label2 = new QLabel(".", this);
+    QLabel* label3 = new QLabel(".", this);
+    leIp1 = new QLineEdit(this);
+    leIp1->setStyleSheet("QLineEdit { border:none; }");
+    leIp1->setAlignment(Qt::AlignCenter);
+    leIp2 = new QLineEdit(this);
+    leIp2->setStyleSheet("QLineEdit { border:none; }");
+    leIp2->setAlignment(Qt::AlignCenter);
+    leIp3 = new QLineEdit(this);
+    leIp3->setStyleSheet("QLineEdit { border:none; }");
+    leIp3->setAlignment(Qt::AlignCenter);
+    leIp4 = new QLineEdit(this);
+    leIp4->setStyleSheet("QLineEdit { border:none; }");
+    leIp4->setAlignment(Qt::AlignCenter);
+    lay->addWidget(leIp1);
+    lay->addWidget(label1);
+    lay->addWidget(leIp2);
+    lay->addWidget(label2);
+    lay->addWidget(leIp3);
+    lay->addWidget(label3);
+    lay->addWidget(leIp4);
+    setLayout(lay);
+
+    QIntValidator* validator = new QIntValidator(this);
+    validator->setRange(0, 255);
+    leIp1->setValidator(validator);
+    leIp2->setValidator(validator);
+    leIp3->setValidator(validator);
+    leIp4->setValidator(validator);
+    leIp1->installEventFilter(this);
+    leIp2->installEventFilter(this);
+    leIp3->installEventFilter(this);
+    leIp4->installEventFilter(this);
+    connect(leIp1, &QLineEdit::textChanged, this, &MIpAddressEditor::leIpTextChanged);
+    connect(leIp2, &QLineEdit::textChanged, this, &MIpAddressEditor::leIpTextChanged);
+    connect(leIp3, &QLineEdit::textChanged, this, &MIpAddressEditor::leIpTextChanged);
+    connect(leIp4, &QLineEdit::textChanged, this, &MIpAddressEditor::leIpTextChanged);
+}
+
+void MIpAddressEditor::setIp(const QString& ip)
+{
+    QStringList nums = ip.split('.');
+    if (nums.size() == 4)
+    {
+        leIp1->setText(nums[0]);
+        leIp2->setText(nums[1]);
+        leIp3->setText(nums[2]);
+        leIp4->setText(nums[3]);
+    }
+}
+
+QString MIpAddressEditor::ip() const
+{
+    QString ipAddr = QString("%1.%2.%3.%4")
+        .arg(leIp1->text(), leIp2->text(), leIp3->text(), leIp4->text());
+    return ipAddr;
+}
+
+bool MIpAddressEditor::eventFilter(QObject *watched, QEvent *event)
+{
+    if (event->type() == QEvent::KeyPress)
+    {
+        const QVarLengthArray<QWidget*, 4> editors = { leIp1, leIp2, leIp3, leIp4 };
+        QKeyEvent* keyEvent = dynamic_cast<QKeyEvent*>(event);
+        QWidget* target = dynamic_cast<QWidget*>(watched);
+        if (keyEvent->key() == Qt::Key_Space)
+        {
+            if (target != editors.back())
+            {
+                editors[editors.indexOf(target) + 1]->setFocus();
+            }
+            return true;
+        }
+    }
+    else if (event->type() == QEvent::FocusIn)
+    {
+        focused = true;
+        update();
+    }
+    else if (event->type() == QEvent::FocusOut)
+    {
+        if (!leIp1->hasFocus() && !leIp2->hasFocus() &&
+            !leIp3->hasFocus() && !leIp4->hasFocus())
+        {
+            focused = false;
+            update();
+        }
+    }
+    return false;
+}
+
+void MIpAddressEditor::leIpTextChanged(const QString& text)
+{
+    if (text.size() >= 3)
+    {
+        const QVarLengthArray<QWidget*, 4> editors = { leIp1, leIp2, leIp3, leIp4 };
+        QWidget* src = dynamic_cast<QWidget*>(sender());
+        if (src != editors.back())
+        {
+            editors[editors.indexOf(src) + 1]->setFocus();
+        }
+    }
+
+    emit IPChanged(ip());
+}
+
+void MIpAddressEditor::paintEvent(QPaintEvent*)
+{
+    QStyleOption opt;
+    opt.init(this);
+    QPainter painter(this);
+    style()->drawPrimitive(QStyle::PE_Widget, &opt, &painter, this);
+    QPalette pale = palette();
+    painter.setBrush(Qt::NoBrush);
+    if (focused)
+    {
+        painter.setPen(QPen(pale.highlight(), 1));
+        painter.drawRect(0, 0, width() - 1, height() - 1);
+    }
+    else
+    {
+        painter.setPen(QPen(pale.mid(), 1));
+        painter.drawRect(0, 0, width() - 1, height() - 1);
+    }
+}
+
+QSize MIpAddressEditor::sizeHint() const
+{
+    return QSize(160, 24);
+}

customcontrols/mipaddresseditor.h

@@ -0,0 +1,34 @@
+#ifndef MIPADDRESSEDITOR_H
+#define MIPADDRESSEDITOR_H
+#include <QWidget>
+#include <QLineEdit>
+
+class QLineEdit;
+
+class MIpAddressEditor : public QWidget
+{
+    Q_OBJECT
+
+public:
+    MIpAddressEditor(QWidget* parent = nullptr);
+    void setIp(const QString& ip);
+    QString ip() const;
+
+private:
+    bool eventFilter(QObject *watched, QEvent *event) override;
+    void paintEvent(QPaintEvent*) override;
+    QSize sizeHint() const override;
+signals:
+    void IPChanged(QString value);
+private slots:
+    void leIpTextChanged(const QString& text);
+
+private:
+    bool focused;
+    QLineEdit *leIp1;
+    QLineEdit *leIp2;
+    QLineEdit *leIp3;
+    QLineEdit *leIp4;
+};
+
+#endif // MIPADDRESSEDITOR_H