HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/PeripheralWidget Commit - r13:8ee59f35313b

removed warnings

Jeandet Alexis -

r13:8ee59f35313b default

parent child

Context file:

r13:8ee59f35313b

Collapse all files

src/peripheralwidget.cpp +1 -1

             #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());
                             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;
                         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 +12 -9

             #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();
-                int h=p_boundingRect.height();
-                int y=p_boundingRect.y();
                 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)
             {
                 this->p_value = value;
                 this->p_fieldsEl->setValue(QString("%1").arg((uint)p_value,32,2).replace(" ","0"));
                 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);
                 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))
                 {
                     p_value |= 1<<index;
                     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_cursorBlinkEnable = 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-p_cursorIndex) != ((i*4)+l))
+                        if(p_cursorBlinkEnable == false || (31-(int)p_cursorIndex) != ((i*4)+l))
                         {
-                            if(p_startSelectionIndex!=-1 && p_stopSelectionIndex!=-1 && p_startSelectionIndex <=31-((i*4)+l) && p_stopSelectionIndex >=31-((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;
                 }
                 painter->drawRect(0,0,p_boundingRec.width(),p_boundingRec.height());
                 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(p_cursorIndex!=-1)
+                if((int)p_cursorIndex!=-1)
                 {
-                    if(p_startSelectionIndex!=-1 && p_stopSelectionIndex!= -1)
+                    if((int)p_startSelectionIndex!=-1 && (int)p_stopSelectionIndex!= -1)
                     {
-                        if(index>=p_stopSelectionIndex)
+                        if((uint)index>=p_stopSelectionIndex)
                         {
                             p_stopSelectionIndex = index;
                             p_cursorIndex = index;
                         }
                         else
                         {
                             p_startSelectionIndex = index;
                             p_cursorIndex = index;
                         }
                     }
                     else
                     {
-                        if(index>p_cursorIndex)
+                        if((uint)index>p_cursorIndex)
                         {
                             p_startSelectionIndex = p_cursorIndex;
                             p_stopSelectionIndex = index;
                         }
                         else
                         {
                             p_startSelectionIndex = index;
                             p_stopSelectionIndex = p_cursorIndex;
                         }
                     }
                 }
             }

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