HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/PeripheralWidget Commit - r14:9180c6ebb055

added outdated marker for registers

jeandet -

r14:9180c6ebb055 default

parent child

Context file:

r14:9180c6ebb055

Collapse all files

src/peripheralwidget.cpp +12 0

             #include "peripheralwidget.h"
             peripheralWidget::peripheralWidget(const QString &name, qint32 baseAddress, QWidget *parent) :
                 QWidget(parent)
             {
                 p_name = name;
                 p_timer = new QTimer(this);
                 p_timer->setInterval(500);
                 p_baseAddress = baseAddress;
                 p_header = p_name + QString(" @0x%1").arg((uint)p_baseAddress,8,16);
                 setAttribute(Qt::WA_AlwaysShowToolTips);
                 setMouseTracking(true);
                 setFocusPolicy(Qt::StrongFocus);
                 selectedReg = -1;
                 registersWdgts.clear();
                 connect(p_timer,SIGNAL(timeout()),this,SLOT(blinkCursor()));
                 setFont(QFont("Utopia", 14,QFont::Bold));
             }
             void peripheralWidget::blinkCursor()
             {
                 if(selectedReg!=-1)
                     registersWdgts.at(selectedReg)->blinkCursor();
                 repaint();
             }
             void peripheralWidget::addRegister(const QString &name, qint32 address)
             {
                 /*TODO  Should regs by address*/
                 registersWdgts.append(new registerWidget(name,address));
                 connect(registersWdgts.last(),SIGNAL(repaint()),this,SLOT(repaint()));
             }
             void peripheralWidget::leave()
             {
                 if(selectedReg!=-1)
                 {
                     p_timer->stop();
                     registersWdgts.at(selectedReg)->leave();
                     selectedReg = -1;
                     repaint();
                 }
             }
             void peripheralWidget::enter(int cursorIndex, bool fromTop)
             {
                 if(cursorIndex>=0 && cursorIndex<32)
                 {
                     if(fromTop)
                     {
                         registersWdgts.at(0)->enter(cursorIndex);
                         selectedReg = 0;
                     }
                     else
                     {
                         registersWdgts.at(registersWdgts.count()-1)->enter(cursorIndex);
                         selectedReg = registersWdgts.count()-1;
                     }
                     p_timer->start();
                     this->setFocus();
                 }
             }
             void peripheralWidget::mousePressEvent(QMouseEvent *event)
             {
                 p_timer->stop();
                 if(selectedReg!=-1)
                 {
                     registersWdgts.at(selectedReg)->leave();
                     selectedReg = -1;
                 }
                 for(int i=0; i<registersWdgts.count();i++)
                 {
                     if(registersWdgts.at(i)->contains(event->pos()))
                     {
                         registersWdgts.at(i)->enter(registersWdgts.at(i)->cursorIndex(event->pos().x()));
                         selectedReg = i;
                         p_timer->start();
                         emit clicked(this);
                     }
                 }
                 repaint();
             }
             void peripheralWidget::mouseMoveEvent(QMouseEvent *event)
             {
                 bool match=false;
                 if(event->buttons()==Qt::LeftButton)
                 {
                     for(int i=0; i<registersWdgts.count();i++)
                     {
                         if(registersWdgts.at(i)->contains(event->pos()))
                         {
                             registersWdgts.at(i)->updateSelection(registersWdgts.at(i)->cursorIndex(event->pos().x()));
                         }
                     }
                 }
                 else
                 {
                     for(int i=0; i<registersWdgts.count();i++)
                     {
                         if(registersWdgts.at(i)->contains(event->pos()))
                         {
                             match = true;
                             int bitfieldIndex=registersWdgts.at(i)->cursorIndex(event->pos().x());
                             QString toolTipText ="<b>< font color='Black'>"+registersWdgts.at(i)->bitFieldName(bitfieldIndex) +"</b><br />";
                             toolTipText+= "Hexadecimal=<b>< font color='Blue'>"+registersWdgts.at(i)->bitFieldToHex(bitfieldIndex)+"</b>";
                             toolTipText+= "    Decimal=<b>< font color='BlueViolet'>"+registersWdgts.at(i)->bitFieldToDec(bitfieldIndex)+"</b><br />";
                             toolTipText+= registersWdgts.at(i)->bitFieldDesc(bitfieldIndex);
                             QToolTip::showText(event->globalPos(),toolTipText,(QWidget*)this);
                         }
                     }
                     if(!match)QToolTip::hideText();
                 }
             }
             void peripheralWidget::mouseReleaseEvent(QMouseEvent *event)
             {
                 Q_UNUSED(event)
             }
             void peripheralWidget::keyPressEvent(QKeyEvent *event)
             {
                 if(this->selectedReg!=-1){
                     if(event->modifiers()==Qt::ControlModifier)
                     {
                         switch(event->key())
                         {
                         case Qt::Key_Up:
                             registersWdgts.at(selectedReg)->set(registersWdgts.at(selectedReg)->cursorIndex());
                             break;
                         case Qt::Key_Down:
                             registersWdgts.at(selectedReg)->clear(registersWdgts.at(selectedReg)->cursorIndex());
                             break;
                         case Qt::Key_W:
                             emit writeRegSig(registersWdgts.at(selectedReg)->address(),registersWdgts.at(selectedReg)->value());
+                            registersWdgts.at(selectedReg)->setUpdated(true);
+                            registersWdgts.at(selectedReg)->repaint();
                             break;
                         case Qt::Key_R:
                             qint32 value;
                             value = emit readRegSig(registersWdgts.at(selectedReg)->address());
                             registersWdgts.at(selectedReg)->setValue(value);
                             break;
                         default:
                             break;
                         }
                     }
                     else
                     {
                         switch(event->key())
                         {
                         case Qt::Key_0:
                             registersWdgts.at(selectedReg)->clear(registersWdgts.at(selectedReg)->cursorIndex());
                             registersWdgts.at(selectedReg)->moveCursorRight(1);
                             break;
                         case Qt::Key_1:
                             registersWdgts.at(selectedReg)->set(registersWdgts.at(selectedReg)->cursorIndex());
                             registersWdgts.at(selectedReg)->moveCursorRight(1);
                             break;
                         case Qt::Key_Right:
                             registersWdgts.at(selectedReg)->moveCursorRight(1);
                             this->repaint();
                             break;
                         case Qt::Key_Left:
                             registersWdgts.at(selectedReg)->moveCursorLeft(1);
                             this->repaint();
                             break;
                         case Qt::Key_Up:
                             up();
                             break;
                         case Qt::Key_Down:
                             down();
                             break;
+                        case Qt::Key_W:
+                            emit writeRegSig(registersWdgts.at(selectedReg)->address(),registersWdgts.at(selectedReg)->value());
+                            registersWdgts.at(selectedReg)->setUpdated(true);
+                            registersWdgts.at(selectedReg)->repaint();
+                            break;
+                        case Qt::Key_R:
+                            qint32 value;
+                            value = emit readRegSig(registersWdgts.at(selectedReg)->address());
+                            registersWdgts.at(selectedReg)->setValue(value);
+                            break;
                         default:
                             break;
                         }
                     }
                 }
             }
             void peripheralWidget::paintEvent(QPaintEvent *event)
             {
                 Q_UNUSED(event)
                 QPainter painter(this);
                 QPoint offset=QPoint(0,0);
                 int nameWidth = fontMetrics().width(p_header);
                 if(registersWdgts.count()==0)
                 {
                     setMinimumSize(2*nameWidth+10,fontMetrics().height()+10);
                 }
                 painter.drawText((this->minimumWidth()/2)-nameWidth,4,fontMetrics().width(p_header),fontMetrics().height()+4,Qt::AlignCenter,p_header);
                 offset+=QPoint(0,fontMetrics().height()+8);
                 for(int i=0;i<registersWdgts.count();i++)
                 {
                     offset = registersWdgts.at(i)->paint(&painter,offset);
                 }
                 if(registersWdgts.count()>0)
                 {
                     setMinimumSize(registersWdgts.first()->boundingRect().width(),offset.y());
                 }
                 updateGeometry();
             }
             void peripheralWidget::up()
             {
                 if(selectedReg!=-1)
                 {
                     if(selectedReg >0)
                     {
                         registersWdgts.at(selectedReg-1)->enter(registersWdgts.at(selectedReg)->cursorIndex());
                         registersWdgts.at(selectedReg)->leave();
                         selectedReg-=1;
                         repaint();
                     }
                     else
                     {
                         emit upSig(this,registersWdgts.at(selectedReg)->cursorIndex());
                     }
                 }
             }
             void peripheralWidget::down()
             {
                 if(selectedReg!=-1)
                 {
                     if(selectedReg <(registersWdgts.count()-1))
                     {
                         registersWdgts.at(selectedReg+1)->enter(registersWdgts.at(selectedReg)->cursorIndex());
                         registersWdgts.at(selectedReg)->leave();
                         selectedReg+=1;
                         repaint();
                     }
                     else
                     {
                         emit downSig(this,registersWdgts.at(selectedReg)->cursorIndex());
                     }
                 }
             }

src/registerwidget.cpp +22 -4

             #include "registerwidget.h"
             #include <QPaintEvent>
             #include <QPainter>
             registerWidget::registerWidget(const QString &name, qint32 address, QObject *parent) :
                 QObject(parent)
             {
                 p_address = address;
                 p_value = 0;
                 p_addressEl = new regWidgetElement(QString("0x%1").arg((uint)p_address,8,16).replace(" ","0"),QFont("Utopia", 12),10,4);
                 p_fieldsEl = new bitfieldsElement(QString("%1").arg((uint)p_value,32,2).replace(" ","0"),QFont("Utopia", 12),4,4);
                 p_nameEl = new regWidgetElement(name,QFont("Utopia", 12,QFont::Bold),4,4);
                 p_xMargins = 4;
                 p_yMargins = 6;
                 updateBoundingRect();
             }
             registerWidget::~registerWidget()
             {
                 delete p_addressEl;
                 delete p_fieldsEl;
                 delete p_nameEl;
             }
             int registerWidget::contains(const QPointF &point)
             {
                 return p_boundingRect.contains(point.x(),point.y());
             }
             QPoint registerWidget::paint(QPainter* painter, QPoint offset)
             {
                 painter->save();
                 painter->translate(offset);
                 p_boundingRect.moveTopLeft(offset);
                 painter->translate(p_addressEl->paint(painter));
                 painter->translate(p_fieldsEl->paint(painter));
                 p_nameEl->paint(painter);
                 painter->restore();
                 return QPoint(0,p_boundingRect.height()+p_boundingRect.y()+p_yMargins);
             }
             QRect registerWidget::boundingRect()
             {
                 return p_boundingRect;
             }
             uint registerWidget::cursorIndex()
             {
                 return p_fieldsEl->cursorIndex();
             }
             uint registerWidget::cursorIndex(int xPos)
             {
                 if(xPos>p_addressEl->boundingRect().width() && xPos<(p_addressEl->boundingRect().width()+p_fieldsEl->boundingRect().width()))
                 {
                     return p_fieldsEl->cursorIndex(xPos-p_addressEl->boundingRect().width());
                 }
                 return 0;
             }
             void registerWidget::updateSelection(int index)
             {
                 p_fieldsEl->updateSelection(index);
                 emit this->repaint();
             }
             qint32 registerWidget::address()
             {
                 return p_address;
             }
             qint32 registerWidget::value()
             {
                 return p_value;
             }
             void registerWidget::setBitFieldAttribute(uint startIndex, uint stopIndex, const QString &name, const QString &description, bool rw)
             {
                 if(startIndex<=stopIndex && stopIndex<32)
                 {
                     int index= p_fieldsEl->addAttribute(name,description,rw );
                     for(uint i=startIndex;i<=stopIndex;i++)
                     {
                         p_fieldsEl->setAttribute(i,index);
                     }
                 }
             }
             QString registerWidget::bitFieldDesc(int bitIndex)
             {
                 if(bitIndex>=0 && bitIndex<32)
                 {
                     return p_fieldsEl->description(bitIndex);
                 }
                 return QString("Out of range");
             }
             QString registerWidget::bitFieldName(int bitIndex)
             {
                 if(bitIndex>=0 && bitIndex<32)
                 {
                     return p_fieldsEl->name(bitIndex);
                 }
                 return QString("Out of range");
             }
             QString registerWidget::bitFieldToHex(int bitIndex)
             {
                 if(bitIndex>=0 && bitIndex<32)
                 {
                     return p_fieldsEl->valueHex(bitIndex);
                 }
                 return QString("Out of range");
             }
             QString registerWidget::bitFieldToDec(int bitIndex)
             {
                 if(bitIndex>=0 && bitIndex<32)
                 {
                     return p_fieldsEl->valueDec(bitIndex);
                 }
                 return QString("Out of range");
             }
             QString registerWidget::bitFieldToBin(int bitIndex)
             {
                 if(bitIndex>=0 && bitIndex<32)
                 {
                     // TODO do the convertion
                     return p_fieldsEl->valueDec(bitIndex);
                 }
                 return QString("Out of range");
             }
-            void registerWidget::setValue(qint32 value)
+            void registerWidget::setValue(qint32 value, bool updated)
             {
                 this->p_value = value;
                 this->p_fieldsEl->setValue(QString("%1").arg((uint)p_value,32,2).replace(" ","0"));
+                this->p_fieldsEl->setUpdated(updated);
                 emit this->repaint();
             }
             void registerWidget::blinkCursor()
             {
                 p_fieldsEl->blinkCursor();
                 //repaint();
             }
             void registerWidget::moveCursorLeft(int count)
             {
                 p_fieldsEl->moveCursorLeft(count);
                 p_fieldsEl->blinkCursor();
             }
             void registerWidget::moveCursorRight(int count)
             {
                 p_fieldsEl->moveCursorRight(count);
                 p_fieldsEl->blinkCursor();
             }
             void registerWidget::enter(int index)
             {
                 p_fieldsEl->enter(index);
             }
             void registerWidget::leave()
             {
                 p_fieldsEl->leave();
             }
             void registerWidget::clear(int index)
             {
-                p_value &= ~(1<<index);
+                if(!this->p_fieldsEl->readonly(index))
-                this->p_fieldsEl->setValue(QString("%1").arg((uint)p_value,32,2).replace(" ","0"));
-                emit this->repaint();
+                    qint32 old = p_value;
+                    p_value &= ~(1<<index);
+                    if(old!=p_value)
+                        p_fieldsEl->setUpdated(false);
+                    this->p_fieldsEl->setValue(QString("%1").arg((uint)p_value,32,2).replace(" ","0"));
+                    emit this->repaint();
+                }
             }
             void registerWidget::set(int index)
             {
                 if(!this->p_fieldsEl->readonly(index))
                 {
+                    qint32 old = p_value;
                     p_value |= 1<<index;
+                    if(old!=p_value)
+                        p_fieldsEl->setUpdated(false);
                     this->p_fieldsEl->setValue(QString("%1").arg((uint)p_value,32,2).replace(" ","0"));
                     emit this->repaint();
                 }
             }
             void registerWidget::updateBoundingRect()
             {
                 p_boundingRect.setHeight(p_fieldsEl->boundingRect().height()+(p_yMargins*2));
                 p_boundingRect.setWidth(p_fieldsEl->boundingRect().width()+p_addressEl->boundingRect().width()+p_nameEl->boundingRect().width()+(p_xMargins*2));
             }
             bitfieldsElement::bitfieldsElement(const QString &value, QFont font, int xMargin, int yMargin)
                 :regWidgetElement(value,font,xMargin,yMargin)
             {
                 this->attributesLUT.append(new bitFieldAttribute(false,"UNSUSED","UNSUSED"));
                 for(int i=0;i<32;i++)
                 {
                     attributesIndex[i] = 0;
                 }
                 p_startSelectionIndex = -1;
                 p_stopSelectionIndex = -1;
                 p_cursorIndex = -1;
                 p_dx=QFontMetrics(p_font).width("0")+4;
                 p_blinkTextBgColor = QColor(Qt::black);
                 p_blinkTextColor = QColor(Qt::white);
+                p_outdated = QColor(Qt::red);
                 p_cursorBlinkEnable = false;
+                p_changed = false;
                 updateBoundingRect();
             }
             QPoint bitfieldsElement::paint(QPainter *painter)
             {
                 painter->fillRect(4,4,p_boundingRec.width(),p_boundingRec.height(),Qt::darkGray);
                 painter->fillRect(0,0,p_boundingRec.width(),p_boundingRec.height(),Qt::white);
                 painter->setFont(p_font);
                 int lastAttributeIndex = attributesIndex[31];
                 int xpos=p_xMargins;
                 for(int i=0;i<(32/4);i++)
                 {
                     for(int l = 0;l<4;l++)
                     {
                         if(p_cursorBlinkEnable == false || (31-(int)p_cursorIndex) != ((i*4)+l))
                         {
                             if((int)p_startSelectionIndex!=-1 && (int)p_stopSelectionIndex!=-1 && p_startSelectionIndex <=(uint)31-(uint)((i*4)+l) && p_stopSelectionIndex >=(uint)31-(uint)((i*4)+l))
                             {
                                 QPen svg = painter->pen();
                                 painter->setPen(p_blinkTextColor);
                                 painter->fillRect(xpos-1,0,p_dx,p_boundingRec.height(),Qt::blue);
                                 painter->drawText(xpos,QFontMetrics(p_font).ascent()+p_yMargins,p_valueStr.at((i*4)+l));
                                 painter->setPen(svg);
                             }
                             else
                             {
                                 if(attributesLUT[attributesIndex[31-((i*4)+l)]]->rw==false)
                                 {
                                     painter->fillRect(xpos-1,0,p_dx,p_boundingRec.height(),Qt::lightGray);
                                 }
                                 else
                                 {
                                     painter->fillRect(xpos-1,0,p_dx,p_boundingRec.height(),Qt::white);
                                 }
                                 painter->drawText(xpos,QFontMetrics(p_font).ascent()+p_yMargins,p_valueStr.at((i*4)+l));
                             }
                         }
                         else
                         {
                             QPen svg = painter->pen();
                             painter->setPen(p_blinkTextColor);
                             painter->fillRect(xpos-1,0,p_dx,p_boundingRec.height(),p_blinkTextBgColor);
                             painter->drawText(xpos,QFontMetrics(p_font).ascent()+p_yMargins,p_valueStr.at((i*4)+l));
                             painter->setPen(svg);
                         }
                         if(lastAttributeIndex!=attributesIndex[31-((i*4)+l)])
                             painter->drawLine(xpos-(p_xMargins/2),0,xpos-(p_xMargins/2),p_boundingRec.height());
                         lastAttributeIndex=attributesIndex[31-((i*4)+l)];
                         xpos+=p_dx;
                     }
                     if(i==3)
                         painter->drawLine(xpos+(p_xMargins/2),p_boundingRec.height()-6,xpos+(p_xMargins/2),p_boundingRec.height()+12);
                     else if(i<7)
                         painter->drawLine(xpos+(p_xMargins/2),p_boundingRec.height()-6,xpos+(p_xMargins/2),p_boundingRec.height()+6);
                     xpos+=p_xMargins;
                 }
+                QPen svg = painter->pen();
+                if(p_changed)
+                {
+                    painter->setPen(p_outdated);
+                }
                 painter->drawRect(0,0,p_boundingRec.width(),p_boundingRec.height());
+                painter->setPen(svg);
                 return QPoint(p_boundingRec.width()+4+p_xMargins,0);
             }
             void bitfieldsElement::updateBoundingRect()
             {
                 p_boundingRec.setHeight(QFontMetrics(p_font).boundingRect(p_valueStr).height()+(p_yMargins*2));
                 int width = (((4*(p_dx)) + p_xMargins) * 8) + (p_xMargins);
                 p_boundingRec.setWidth(width);
             }
             void bitfieldsElement::setValue(const QString &value)
             {
                 p_valueStr = value;
                 updateBoundingRect();
             }
             void bitfieldsElement::blinkCursor()
             {
                 p_cursorBlinkEnable = !p_cursorBlinkEnable;
             }
             void bitfieldsElement::moveCursorLeft(int count)
             {
                 p_cursorIndex+=count;
                 if(31<p_cursorIndex)
                 {
                     p_cursorIndex = 31;
                 }
                 p_startSelectionIndex = p_cursorIndex;
                 p_stopSelectionIndex = p_cursorIndex;
             }
             void bitfieldsElement::moveCursorRight(int count)
             {
                 p_cursorIndex -= count;
                 if(31<p_cursorIndex)
                 {
                     p_cursorIndex = 0;
                 }
                 p_startSelectionIndex = p_cursorIndex;
                 p_stopSelectionIndex = p_cursorIndex;
             }
             void bitfieldsElement::enter(int index)
             {
                 p_cursorIndex = index;
                 p_cursorBlinkEnable = true;
                 p_startSelectionIndex = -1;
                 p_stopSelectionIndex = -1;
             }
             void bitfieldsElement::leave()
             {
                 p_cursorBlinkEnable = false;
                 p_cursorIndex = -1;
                 p_startSelectionIndex = -1;
                 p_stopSelectionIndex = -1;
             }
             uint bitfieldsElement::cursorIndex()
             {
                 return p_cursorIndex;
             }
             uint bitfieldsElement::cursorIndex(int xPos)
             {
                 uint index=0;
                 xPos-=p_xMargins;
                 if(xPos<p_boundingRec.width())
                 {
                     index = 31 - ((4*xPos)/((4*p_dx)+p_xMargins));
                 }
                 return index;
             }
             void bitfieldsElement::setFont(QFont font)
             {
                 p_font = font;
                 p_dx=QFontMetrics(p_font).width("0")+2;
                 updateBoundingRect();
             }
             void bitfieldsElement::updateSelection(int index)
             {
                 if((int)p_cursorIndex!=-1)
                 {
                     if((int)p_startSelectionIndex!=-1 && (int)p_stopSelectionIndex!= -1)
                     {
                         if((uint)index>=p_stopSelectionIndex)
                         {
                             p_stopSelectionIndex = index;
                             p_cursorIndex = index;
                         }
                         else
                         {
                             p_startSelectionIndex = index;
                             p_cursorIndex = index;
                         }
                     }
                     else
                     {
                         if((uint)index>p_cursorIndex)
                         {
                             p_startSelectionIndex = p_cursorIndex;
                             p_stopSelectionIndex = index;
                         }
                         else
                         {
                             p_startSelectionIndex = index;
                             p_stopSelectionIndex = p_cursorIndex;
                         }
                     }
                 }
             }

src/registerwidget.h +11 -2

             #ifndef REGISTERWIDGET_H
             #define REGISTERWIDGET_H
             #include <QtWidgets>
             #include <QWidget>
             #include <QTimer>
             #if defined(LPPMON_SDK_BUILD)
             #  define LPPMON_SDK_EXPORT Q_DECL_EXPORT
             #else
             #  define LPPMON_SDK_EXPORT Q_DECL_IMPORT
             #endif
             class LPPMON_SDK_EXPORT regWidgetElement
             {
             public:
                 regWidgetElement(const QString& value,QFont font,int xMargin,int yMargin)
                 {
                     p_valueStr = value;
                     p_font = font;
                     p_xMargins = xMargin;
                     p_yMargins = yMargin;
                     updateBoundingRect();
                 }
                 void setValue(const QString& value)
                 {
                     p_valueStr = value;
                     updateBoundingRect();
                 }
                 void setFont(QFont font)
                 {
                     p_font = font;
                     updateBoundingRect();
                 }
                 QSize boundingRect(){return p_boundingRec;}
                 QString value(){return p_valueStr;}
                 const QChar	at ( int position ) const{return p_valueStr.at(position);}
                 QFont font(){return p_font;}
                 int xMargin(){return p_xMargins;}
                 int yMargin(){return p_yMargins;}
                 QFontMetrics fontMetrics(){return QFontMetrics(p_font);}
                 QPoint paint(QPainter* painter)
                 {
                     painter->setFont(p_font);
                     painter->drawText(0,QFontMetrics(p_font).ascent()+p_yMargins,p_valueStr);
                     return QPoint(p_boundingRec.width(),0);
                 }
                 void updateBoundingRect()
                 {
                     p_boundingRec.setHeight(QFontMetrics(p_font).boundingRect(p_valueStr).height()+(p_yMargins*2));
                     p_boundingRec.setWidth(QFontMetrics(p_font).boundingRect(p_valueStr).width()+(p_xMargins*2));
                 }
             protected:
                 QString p_valueStr;
                 QFont p_font;
                 QSize p_boundingRec;
                 int p_xMargins;
                 int p_yMargins;
             };
             class LPPMON_SDK_EXPORT bitfieldsElement: public regWidgetElement
             {
                 class bitFieldAttribute
                 {
                 public:
                     bitFieldAttribute(bool rw,QString name,QString description)
                     {
                         this->rw = rw;
                         this->Name = name;
                         this->description = description;
                     }
                     bool rw;
                     QString description;
                     QString Name;
                 };
             public:
                 bitfieldsElement(const QString& value,QFont font,int xMargin,int yMargin);
                 QPoint paint(QPainter* painter);
                 void updateBoundingRect();
                 void setValue(const QString& value);
                 void blinkCursor();
                 void moveCursorLeft(int count);
                 void moveCursorRight(int count);
                 void enter(int index);
                 void leave();
                 uint cursorIndex();
                 uint cursorIndex(int xPos);
                 void setFont(QFont font);
                 void updateSelection(int index);
                 int addAttribute(const QString& name,const QString& description,bool rw)
                 {
                     attributesLUT.append(new bitFieldAttribute(rw,name,description));
                     return attributesLUT.count()-1;
                 }
                 int setAttribute(int bitIndex,int attributeIndex)
                 {
                     if(bitIndex>=0 && bitIndex<32 && attributeIndex>=0 && attributeIndex<(attributesLUT.count()))
                     {
                         attributesIndex[bitIndex]=attributeIndex;
                         return 0;
                     }
                     return -1;
                 }
                 QString description(int bitIndex)
                 {
                     if(bitIndex>=0 && bitIndex<32)
                         return attributesLUT.at(attributesIndex[bitIndex])->description;
                     return QString("");
                 }
                 QString name(int bitIndex)
                 {
                     if(bitIndex>=0 && bitIndex<32)
                         return attributesLUT.at(attributesIndex[bitIndex])->Name;
                     return QString("");
                 }
                 bool readonly(int bitIndex)
                 {
                     if(bitIndex>=0 && bitIndex<32)
                         return  !attributesLUT.at(attributesIndex[bitIndex])->rw;
                     return false;
                 }
                 QString valueHex(int index)
                 {
                     if(index>=0 && index<32)
                     {
                         return "0x" + QString::number(p_valueUint(index),16);
                     }
                     return QString("");
                 }
                 QString valueDec(int index)
                 {
                     if(index>=0 && index<32)
                     {
                         return  QString::number(p_valueUint(index),10);
                     }
                     return QString("");
                 }
+                void setUpdated(bool updated=true)
+                {
+                    this->p_changed =  !updated;
+                }
             private:
                 uint p_valueUint(int index)
                 {
                     uint value;
                     int attributeIndex = attributesIndex[index];
                     int startIndex = index;
                     int stopIndex=0;
                     while (startIndex>0)
                     {
                         if(attributesIndex[startIndex-1]==attributeIndex)
                             startIndex--;
                         else
                             break;
                     }
                     stopIndex = startIndex;
                     while (stopIndex<32)
                     {
                         if(attributesIndex[stopIndex+1]==attributeIndex)
                             stopIndex++;
                         else
                             break;
                     }
                     bool ok;
                     value =  p_valueStr.toUInt(&ok,2);
                     value = (uint)0xFFFFFFFF & (value<<(31-stopIndex));
                     value = (uint)0xFFFFFFFF & (value>>(31-stopIndex+startIndex));
                     return value;
                 }
                 int attributesIndex[32];
                 uint p_cursorIndex;
                 uint p_startSelectionIndex;
                 uint p_stopSelectionIndex;
                 bool p_cursorBlinkEnable;
+                bool p_changed;
                 int p_dx;
                 QList<bitFieldAttribute*> attributesLUT;
-                QColor p_blinkTextColor,p_blinkTextBgColor;
+                QColor p_blinkTextColor,p_blinkTextBgColor,p_outdated;
             };
             class LPPMON_SDK_EXPORT registerWidget : public QObject
             {
                 Q_OBJECT
             public:
                 explicit registerWidget(const QString& name,qint32 address,QObject *parent = 0);
                 ~registerWidget();
                 int contains(const QPointF &point);
                 QPoint paint(QPainter* painter,QPoint offset);
                 QRect boundingRect();
                 uint cursorIndex();
                 uint cursorIndex(int xPos);
                 void updateSelection(int index);
                 qint32 address();
                 qint32 value();
                 void setBitFieldAttribute(uint startIndex,uint stopIndex,const QString& name,const QString& description,bool rw);
                 QString bitFieldDesc(int bitIndex);
                 QString bitFieldName(int bitIndex);
                 QString bitFieldToHex(int bitIndex);
                 QString bitFieldToDec(int bitIndex);
                 QString bitFieldToBin(int bitIndex);
+                void setUpdated(bool updated=true)
+                {
+                    this->p_fieldsEl->setUpdated(updated);
+                }
             signals:
                 void cursorUp(int pos);
                 void cursorDown(int pos);
                 void valueChanged(qint32 value);
                 void repaint();
             public slots:
-                void setValue(qint32 value);
+                void setValue(qint32 value,bool updated=true);
                 void blinkCursor();
                 void moveCursorLeft(int count);
                 void moveCursorRight(int count);
                 void enter(int index=0);
                 void leave();
                 void clear(int index);
                 void set(int index);
             private:
                 void updateBoundingRect();
                 qint32 p_address;
                 qint32 p_value;
                 QRect p_boundingRect;
                 int p_xMargins;
                 int p_yMargins;
                 regWidgetElement* p_addressEl,*p_nameEl;
                 bitfieldsElement* p_fieldsEl;
             };
             #endif // REGISTERWIDGET_H

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages