matthew/ostinato
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
a8069bbb39
ostinato/client/variablefieldswidget.cpp

439 lines
14 KiB
C++
Raw Blame History

/*
Copyright (C) 2015 Srivats P.
This file is part of "Ostinato"
This is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
*/
#include "variablefieldswidget.h"
#include "abstractprotocol.h"
#include "protocollistiterator.h"
#include "stream.h"
#include <QListWidgetItem>
#include <QMetaType>
#include <QStringList>
Q_DECLARE_METATYPE(AbstractProtocol*);
Q_DECLARE_METATYPE(OstProto::VariableField);
QStringList typeNames = QStringList()
<< "Counter8"
<< "Counter16"
<< "Counter32";
QStringList modeNames = QStringList()
<< "Increment"
<< "Decrement"
<< "Random";
#define uintToHexStr(num, bytes) \
QString("%1").arg(num, bytes*2, BASE_HEX, QChar('0')).toUpper()
#define hexStrToUInt(str) \
str.toUInt(NULL, BASE_HEX)
/*
* NOTES:
* 1. We use a QSpinBox for all numeric values except for 'value' because
* QSpinBox value is of type 'int' - we would like the ability to store
* quint32
* 2. This widget will keep the stream always updated - every editing change
* of a attribute is immediately updated in the stream; the consequence
* of this design is that an explicit 'store' of widget contents to the
* stream is no longer required - we still define a store() method in
* case we need to change the design later
*/
VariableFieldsWidget::VariableFieldsWidget(QWidget *parent)
: QWidget(parent)
{
stream_ = NULL;
isProgLoad_ = false;
lastSelectedProtocolIndex_ = 0;
lastSelectedVariableFieldIndex_ = 0;
setupUi(this);
attribGroup->setHidden(true);
type->addItems(typeNames);
mode->addItems(modeNames);
valueRange_ = new QIntValidator(this);
// FIXME: we can't use QIntValidator - since we want value to be able
// to enter a quint32
//value->setValidator(valueRange_);
connect(type, SIGNAL(currentIndexChanged(int)),
SLOT(updateCurrentVariableField()));
connect(offset, SIGNAL(valueChanged(int)),
SLOT(updateCurrentVariableField()));
connect(bitmask, SIGNAL(textChanged(QString)),
SLOT(updateCurrentVariableField()));
connect(mode, SIGNAL(currentIndexChanged(int)),
SLOT(updateCurrentVariableField()));
connect(value, SIGNAL(textChanged(QString)),
SLOT(updateCurrentVariableField()));
connect(count, SIGNAL(valueChanged(int)),
SLOT(updateCurrentVariableField()));
connect(step, SIGNAL(valueChanged(int)),
SLOT(updateCurrentVariableField()));
}
void VariableFieldsWidget::setStream(Stream *stream)
{
stream_ = stream;
}
void VariableFieldsWidget::load()
{
Q_ASSERT(stream_);
Q_ASSERT(protocolList->count() == 0);
Q_ASSERT(variableFieldList->count() == 0);
ProtocolListIterator *iter = stream_->createProtocolListIterator();
while (iter->hasNext()) {
AbstractProtocol *proto = iter->next();
QListWidgetItem *protoItem = new QListWidgetItem;
protoItem->setData(Qt::UserRole, QVariant::fromValue(proto));
protoItem->setText(proto->shortName());
protocolList->addItem(protoItem);
}
delete iter;
if (lastSelectedProtocolIndex_ < protocolList->count())
protocolList->setCurrentRow(lastSelectedProtocolIndex_);
// XXX: protocolList->setCurrentRow() above will emit currentItemChanged
// which will load variableFieldsList - no need to load it explicitly
if (lastSelectedVariableFieldIndex_ < variableFieldList->count())
variableFieldList->setCurrentRow(lastSelectedVariableFieldIndex_);
}
void VariableFieldsWidget::store()
{
/* Do Nothing - see Notes at the top of the file */
}
void VariableFieldsWidget::clear()
{
protocolList->clear();
variableFieldList->clear();
}
void VariableFieldsWidget::on_protocolList_currentItemChanged(
QListWidgetItem *current,
QListWidgetItem *previous)
{
AbstractProtocol *proto;
qDebug("%s: curr = %p, prev = %p", __FUNCTION__, current, previous);
if (current == NULL)
goto _exit;
proto = current->data(Qt::UserRole).value<AbstractProtocol*>();
loadProtocolFields(proto);
variableFieldList->clear();
for (int i = 0; i < proto->variableFieldCount(); i++) {
OstProto::VariableField vf = proto->variableField(i);
QListWidgetItem *vfItem = new QListWidgetItem;
setVariableFieldItem(vfItem, proto, vf);
variableFieldList->addItem(vfItem);
}
// While switching protocols, we want to setup the attrib group
// validation/ranges/masks for the current protocol, which is done
// by the field/type signal handlers - so clear field/type index
// now so that signals are emitted when we add/select a VF
field->setCurrentIndex(-1);
type->setCurrentIndex(-1);
lastSelectedProtocolIndex_ = protocolList->currentRow();
_exit:
addButton->setEnabled(current != NULL);
}
void VariableFieldsWidget::on_variableFieldList_currentItemChanged(
QListWidgetItem *current,
QListWidgetItem *previous)
{
AbstractProtocol *proto;
OstProto::VariableField vf;
QListWidgetItem *protoItem = protocolList->currentItem();
qDebug("%s: curr = %p, prev = %p, proto = %p",
__FUNCTION__, current, previous, protoItem);
if (current == NULL)
goto _exit;
Q_ASSERT(protoItem);
proto = protoItem->data(Qt::UserRole).value<AbstractProtocol*>();
vf = current->data(Qt::UserRole).value<OstProto::VariableField>();
isProgLoad_ = true;
field->setCurrentIndex(fieldIndex(vf));
type->setCurrentIndex(vf.type());
offset->setValue(vf.offset());
bitmask->setText(uintToHexStr(vf.mask(), typeSize(vf.type())));
value->setText(QString().setNum(vf.value()));
mode->setCurrentIndex(vf.mode());
count->setValue(vf.count());
step->setValue(vf.step());
isProgLoad_ = false;
lastSelectedVariableFieldIndex_ = variableFieldList->currentRow();
_exit:
attribGroup->setHidden(current == NULL);
deleteButton->setEnabled(current != NULL);
}
void VariableFieldsWidget::on_addButton_clicked()
{
QListWidgetItem *protoItem = protocolList->currentItem();
if (!protoItem)
return;
AbstractProtocol *proto = protoItem->data(Qt::UserRole)
.value<AbstractProtocol*>();
OstProto::VariableField vf;
QListWidgetItem *vfItem = new QListWidgetItem;
proto->appendVariableField(vf);
setVariableFieldItem(vfItem, proto, vf);
variableFieldList->addItem(vfItem);
}
void VariableFieldsWidget::on_deleteButton_clicked()
{
QListWidgetItem *protoItem = protocolList->currentItem();
int vfIdx = variableFieldList->currentRow();
if (!protoItem || (vfIdx < 0))
return;
AbstractProtocol *proto = protoItem->data(Qt::UserRole)
.value<AbstractProtocol*>();
proto->removeVariableField(vfIdx);
delete variableFieldList->takeItem(vfIdx);
}
void VariableFieldsWidget::on_field_currentIndexChanged(int index)
{
if (index < 0)
return;
QVariantMap vm = field->itemData(index).toMap();
if (index) { // standard frame fields
offset->setValue(vm["offset"].toUInt());
offset->setDisabled(true);
type->setCurrentIndex(vm["type"].toUInt());
type->setDisabled(true);
bitmask->setText(uintToHexStr(
vm["mask"].toUInt(),
typeSize(OstProto::VariableField::Type(
vm["type"].toUInt()))));
bitmask->setDisabled(true);
}
else { // custom field
offset->setEnabled(true);
type->setEnabled(true);
bitmask->setEnabled(true);
}
}
void VariableFieldsWidget::on_type_currentIndexChanged(int index)
{
if ((index < 0) || !protocolList->currentItem())
return;
AbstractProtocol *proto = protocolList->currentItem()->data(Qt::UserRole)
.value<AbstractProtocol*>();
int protoSize = proto->protocolFrameSize();
switch (index)
{
case OstProto::VariableField::kCounter8:
offset->setRange(0, protoSize - 1);
bitmask->setInputMask("HH");
bitmask->setText("FF");
valueRange_->setRange(0, 0xFF);
count->setRange(0, 0xFF);
step->setRange(0, 0xFF);
break;
case OstProto::VariableField::kCounter16:
offset->setRange(0, protoSize - 2);
bitmask->setInputMask("HHHH");
bitmask->setText("FFFF");
valueRange_->setRange(0, 0xFFFF);
count->setRange(0, 0xFFFF);
step->setRange(0, 0xFFFF);
break;
case OstProto::VariableField::kCounter32:
offset->setRange(0, protoSize - 4);
bitmask->setInputMask("HHHHHHHH");
bitmask->setText("FFFFFFFF");
valueRange_->setRange(0, 0xFFFFFFFF);
count->setRange(0, 0xFFFF);
step->setRange(0, 0xFFFF);
break;
default:
Q_ASSERT(false); // unreachable
break;
}
}
void VariableFieldsWidget::updateCurrentVariableField()
{
// Prevent recursion
if (isProgLoad_)
return;
if (!protocolList->currentItem())
return;
if (!variableFieldList->currentItem())
return;
OstProto::VariableField vf;
vf.set_type(OstProto::VariableField::Type(type->currentIndex()));
vf.set_offset(offset->value());
vf.set_mask(hexStrToUInt(bitmask->text()));
vf.set_value(value->text().toUInt());
vf.set_mode(OstProto::VariableField::Mode(mode->currentIndex()));
vf.set_count(count->value());
vf.set_step(step->value());
QListWidgetItem *protoItem = protocolList->currentItem();
AbstractProtocol *proto = protoItem->data(Qt::UserRole)
.value<AbstractProtocol*>();
proto->mutableVariableField(variableFieldList->currentRow())->CopyFrom(vf);
setVariableFieldItem(variableFieldList->currentItem(), proto, vf);
}
void VariableFieldsWidget::loadProtocolFields(
const AbstractProtocol *protocol)
{
QVariantMap vm;
field->clear();
field->addItem("Custom");
for (int i = 0; i < protocol->fieldCount(); i++) {
if (!protocol->fieldFlags(i).testFlag(AbstractProtocol::FrameField))
continue;
QString name = protocol->fieldData(i, AbstractProtocol::FieldName)
.toString();
int bitOfs = protocol->fieldFrameBitOffset(i);
int byteOfs = bitOfs >> 3;
uint bitSize = protocol->fieldData(i, AbstractProtocol::FieldBitSize)
.toInt();
vm["offset"] = byteOfs;
if (bitSize <= 8) {
vm["type"] = int(OstProto::VariableField::kCounter8);
vm["mask"] = ((0xFF << (8 - bitSize)) & 0xFF)
>> (bitOfs & 0x7);
}
else if (bitSize <= 16) {
vm["type"] = int(OstProto::VariableField::kCounter16);
vm["mask"] = ((0xFFFF << (16 - bitSize)) & 0xFFFF)
>> (bitOfs & 0x7);
}
else if (bitSize <= 32) {
vm["type"] = int(OstProto::VariableField::kCounter32);
vm["mask"] = ((0xFFFFFFFF << (32 - bitSize)) & 0xFFFFFFFF)
>> (bitOfs & 0x7);
}
else {
vm["type"] = int(OstProto::VariableField::kCounter32);
vm["mask"] = 0xFFFFFFFF;
}
field->addItem(name, vm);
}
}
/*! Given a VariableField::Type, return corresponding size in bytes */
int VariableFieldsWidget::typeSize(OstProto::VariableField::Type type)
{
switch(type) {
case OstProto::VariableField::kCounter8 : return 1;
case OstProto::VariableField::kCounter16: return 2;
case OstProto::VariableField::kCounter32: return 4;
default: break;
}
return 4;
}
/*! Given a variableField, return corresponding index in the field ComboBox */
int VariableFieldsWidget::fieldIndex(const OstProto::VariableField &vf)
{
QVariantMap vm;
vm["type"] = int(vf.type());
vm["offset"] = vf.offset();
vm["mask"] = vf.mask();
int index = field->findData(vm);
qDebug("vm %d %d 0x%x => index %d", vf.type(), vf.offset(), vf.mask(), index);
// Not found? Use 'Custom'
if (index < 0)
index = 0;
return index;
}
void VariableFieldsWidget::setVariableFieldItem(
QListWidgetItem *item,
const AbstractProtocol *protocol,
const OstProto::VariableField &vf)
{
uint from = vf.value() & vf.mask();
uint to;
QString fieldName = field->itemText(fieldIndex(vf));
QString itemText;
if (vf.mode() == OstProto::VariableField::kDecrement)
to = (vf.value() - (vf.count()-1)*vf.step()) & vf.mask();
else
to = (vf.value() + (vf.count()-1)*vf.step()) & vf.mask();
item->setData(Qt::UserRole, QVariant::fromValue(vf));
itemText = QString("%1 %2 %3 from %4 to %5")
.arg(protocol->shortName())
.arg(fieldName)
.arg(modeNames.at(vf.mode()))
.arg(from)
.arg(to);
if (vf.step() != 1)
itemText.append(QString(" step %1").arg(vf.step()));
item->setText(itemText);
}
Reference in New Issue View Git Blame Copy Permalink