devs/foxbox
1
0
Fork 0
forked from len0rd/rockbox
Code Pull requests Activity
foxbox/utils/regtools/qeditor/utils.cpp
Amaury Pouly 6b9610fb90 regtoosl/qeditor: port to the new description format 
This big commit port qeditor from v1 to v2 register file format. Although
the display code was much simplified, the edit code had to be rewritten.
The new code also brings many improvement to the register display widget.

The new code also compiles with both Qt4 and Qt5, although it is recommended
to use Qt5 to get some improvements, especially in the layout of editor.

Change-Id: I24633ac37a144f25d9e705b565654269ec9cfbd3
2016-02-06 15:20:48 +00:00

1721 lines
48 KiB
C++
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2014 by Amaury Pouly
*
* This program 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 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "utils.h"
#include <QFontMetrics>
#include <QPainter>
#include <QTextDocument>
#include <QAbstractTextDocumentLayout>
#include <QHeaderView>
#include <QDebug>
#include <QElapsedTimer>
#include <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QTextBlock>
#include <QApplication>
/**
* SocBitRangeValidator
*/
SocBitRangeValidator::SocBitRangeValidator(QObject *parent)
:QValidator(parent)
{
m_width = 32;
}
void SocBitRangeValidator::fixup(QString& input) const
{
input = input.trimmed();
}
QValidator::State SocBitRangeValidator::validate(QString& input, int& pos) const
{
Q_UNUSED(pos);
int first, last;
State state = parse(input, last, first);
return state;
}
QValidator::State SocBitRangeValidator::parse(const QString& input, int& last, int& first) const
{
// the empty string is always intermediate
if(input.size() == 0)
return Intermediate;
// check if there is ':'
int pos = input.indexOf(':');
if(pos == -1)
pos = input.size();
// if field start with ':', the last bit is implicit and is 31
if(pos > 0)
{
// parse last bit and check it's between 0 and 31
bool ok = false;
last = input.left(pos).toInt(&ok);
if(!ok || last < 0 || last >= m_width)
return Invalid;
}
else
last = m_width - 1;
// parse first bit
if(pos < input.size() - 1)
{
bool ok = false;
first = input.mid(pos + 1).toInt(&ok);
if(!ok || first < 0 || first > last)
return Invalid;
}
// if input ends with ':', first bit is implicit and is 0
else if(pos == input.size() - 1)
first = 0;
// if there no ':', first=last
else
first = last;
return Acceptable;
}
void SocBitRangeValidator::setWidth(int nr_bits)
{
m_width = nr_bits;
}
QString SocBitRangeValidator::generate(int last_bit, int first_bit) const
{
if(last_bit == first_bit)
return QString("%1").arg(first_bit);
else
return QString("%1:%2").arg(last_bit).arg(first_bit);
}
/**
* SocFieldValidator
*/
SocFieldValidator::SocFieldValidator(QObject *parent)
:QValidator(parent)
{
m_field.pos = 0;
m_field.width = 32;
}
SocFieldValidator::SocFieldValidator(const soc_desc::field_t& field, QObject *parent)
:QValidator(parent), m_field(field)
{
}
void SocFieldValidator::fixup(QString& input) const
{
input = input.trimmed();
}
QValidator::State SocFieldValidator::validate(QString& input, int& pos) const
{
Q_UNUSED(pos);
soc_word_t val;
State state = parse(input, val);
return state;
}
QValidator::State SocFieldValidator::parse(const QString& input, soc_word_t& val) const
{
// the empty string is always intermediate
if(input.size() == 0)
return Intermediate;
// first check named values
State state = Invalid;
foreach(const soc_desc::enum_t& value, m_field.enum_)
{
QString name = QString::fromLocal8Bit(value.name.c_str());
// cannot be a substring if too long or empty
if(input.size() > name.size())
continue;
// check equal string
if(input == name)
{
state = Acceptable;
val = value.value;
break;
}
// check substring
if(name.startsWith(input))
state = Intermediate;
}
// early return for exact match
if(state == Acceptable)
return state;
// do a few special cases for convenience
if(input.compare("0x", Qt::CaseInsensitive) == 0 ||
input.compare("0b", Qt::CaseInsensitive) == 0)
return Intermediate;
// try by parsing
unsigned basis, pos;
if(input.size() >= 2 && input.startsWith("0x", Qt::CaseInsensitive))
{
basis = 16;
pos = 2;
}
else if(input.size() >= 2 && input.startsWith("0b", Qt::CaseInsensitive))
{
basis = 2;
pos = 2;
}
else if(input.size() >= 2 && input.startsWith("0"))
{
basis = 8;
pos = 1;
}
else
{
basis = 10;
pos = 0;
}
bool ok = false;
unsigned long v = input.mid(pos).toULong(&ok, basis);
// if not ok, return result of name parsing
if(!ok)
return state;
// if ok, check if it fits in the number of bits
unsigned nr_bits = m_field.width;
unsigned long max = nr_bits == 32 ? 0xffffffff : (1 << nr_bits) - 1;
if(v <= max)
{
val = v;
return Acceptable;
}
return state;
}
/**
* RegLineEdit
*/
RegLineEdit::RegLineEdit(QWidget *parent)
:QWidget(parent)
{
m_layout = new QHBoxLayout(this);
m_button = new QToolButton(this);
m_button->setCursor(Qt::ArrowCursor);
m_button->setStyleSheet("QToolButton { font-weight: bold; color: white; background: black; }");
m_button->setPopupMode(QToolButton::InstantPopup);
m_edit = new QLineEdit(this);
m_layout->addWidget(m_button);
m_layout->addWidget(m_edit);
m_menu = new QMenu(this);
connect(m_menu->addAction("Write"), SIGNAL(triggered()), this, SLOT(OnWriteAct()));
connect(m_menu->addAction("Set"), SIGNAL(triggered()), this, SLOT(OnSetAct()));
connect(m_menu->addAction("Clear"), SIGNAL(triggered()), this, SLOT(OnClearAct()));
connect(m_menu->addAction("Toggle"), SIGNAL(triggered()), this, SLOT(OnToggleAct()));
EnableSCT(false);
SetReadOnly(false);
ShowMode(true);
SetMode(Write);
}
void RegLineEdit::SetReadOnly(bool ro)
{
m_edit->setReadOnly(ro);
m_readonly = ro;
ShowMode(!ro);
}
void RegLineEdit::EnableSCT(bool en)
{
m_has_sct = en;
if(!m_has_sct)
{
m_button->setMenu(0);
SetMode(Write);
}
else
m_button->setMenu(m_menu);
}
RegLineEdit::~RegLineEdit()
{
}
QLineEdit *RegLineEdit::GetLineEdit()
{
return m_edit;
}
void RegLineEdit::ShowMode(bool show)
{
if(show)
m_button->show();
else
m_button->hide();
}
void RegLineEdit::OnWriteAct()
{
SetMode(Write);
}
void RegLineEdit::OnSetAct()
{
SetMode(Set);
}
void RegLineEdit::OnClearAct()
{
SetMode(Clear);
}
void RegLineEdit::OnToggleAct()
{
SetMode(Toggle);
}
void RegLineEdit::SetMode(EditMode mode)
{
m_mode = mode;
switch(m_mode)
{
case Write: m_button->setText("WR"); break;
case Set: m_button->setText("SET"); break;
case Clear: m_button->setText("CLR"); break;
case Toggle: m_button->setText("TOG"); break;
default: break;
}
}
RegLineEdit::EditMode RegLineEdit::GetMode()
{
return m_mode;
}
void RegLineEdit::setText(const QString& text)
{
m_edit->setText(text);
}
QString RegLineEdit::text() const
{
return m_edit->text();
}
/**
* SocFieldItemDelegate
*/
QString SocFieldItemDelegate::displayText(const QVariant& value, const QLocale& locale) const
{
if(value.type() == QVariant::UInt)
return QString("0x%1").arg(value.toUInt(), (m_bitcount + 3) / 4, 16, QChar('0'));
else
return QStyledItemDelegate::displayText(value, locale);
}
void SocFieldItemDelegate::setWidth(int bitcount)
{
m_bitcount = bitcount;
}
/**
* SocFieldEditor
*/
SocFieldEditor::SocFieldEditor(const soc_desc::field_t& field, QWidget *parent)
:QLineEdit(parent), m_reg_field(field)
{
m_validator = new SocFieldValidator(field);
setValidator(m_validator);
connect(this, SIGNAL(editingFinished()), this, SLOT(editDone()));
setAlignment(Qt::AlignCenter);
setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Minimum);
}
SocFieldEditor::~SocFieldEditor()
{
delete m_validator;
}
void SocFieldEditor::editDone()
{
emit editingFinished(field());
}
uint SocFieldEditor::field() const
{
soc_word_t v;
/* in case validator fails to parse, return old value */
if(m_validator->parse(text(), v) == QValidator::Acceptable)
return v;
else
return m_field;
}
void SocFieldEditor::setField(uint field)
{
m_field = field;
int digits = (m_reg_field.width + 3) / 4;
setText(QString("0x%1").arg(field, digits, 16, QChar('0')));
}
void SocFieldEditor::SetRegField(const soc_desc::field_t& field)
{
setValidator(0);
delete m_validator;
m_validator = new SocFieldValidator(field);
setValidator(m_validator);
m_reg_field = field;
}
/**
* SocFieldCachedValue
*/
SocFieldCachedValue::SocFieldCachedValue(const soc_desc::field_t& field, uint value)
:m_field(field), m_value(value)
{
int idx = field.find_value(value);
if(idx != -1)
m_name = QString::fromStdString(field.enum_[idx].name);
}
bool SocFieldCachedValue::operator<(const SocFieldCachedValue& o) const
{
return m_value < o.m_value;
}
/**
* SocFieldBitRange
*/
bool SocFieldBitRange::operator<(const SocFieldBitRange& o) const
{
if(m_first_bit < o.m_first_bit)
return true;
if(m_first_bit > o.m_first_bit)
return false;
return m_last_bit < o.m_last_bit;
}
/**
* SocFieldCachedItemDelegate
*/
SocFieldCachedItemDelegate::SocFieldCachedItemDelegate(QObject *parent)
:QStyledItemDelegate(parent)
{
m_mode = DisplayValueAndName;
}
QString SocFieldCachedItemDelegate::displayText(const QVariant& value, const QLocale& locale) const
{
if(isUserType< SocFieldCachedValue >(value))
{
const SocFieldCachedValue& v = value.value< SocFieldCachedValue >();
int bitcount = v.field().width;
QString name = v.value_name();
QString strval = QString("0x%1").arg(v.value(), (bitcount + 3) / 4, 16, QChar('0'));
switch(m_mode)
{
case DisplayName:
if(name.size() > 0)
return name;
/* fallthrough */
case DisplayValueAndName:
if(name.size() > 0)
return QString("%1 (%2)").arg(strval).arg(name);
/* fallthrough */
case DisplayValue:
default:
return strval;
}
}
else if(value.type() == QVariant::UserType && value.userType() == qMetaTypeId< SocFieldBitRange >())
{
const SocFieldBitRange& br = value.value< SocFieldBitRange >();
if(br.GetFirstBit() == br.GetLastBit())
return QString("%1").arg(br.GetFirstBit());
else
return QString("%1:%2").arg(br.GetLastBit()).arg(br.GetFirstBit());
}
else
return QStyledItemDelegate::displayText(value, locale);
}
/**
* SocFieldCachedEditor
*/
SocFieldCachedEditor::SocFieldCachedEditor(QWidget *parent)
:SocFieldEditor(soc_desc::field_t(), parent)
{
}
SocFieldCachedEditor::~SocFieldCachedEditor()
{
}
SocFieldCachedValue SocFieldCachedEditor::value() const
{
return SocFieldCachedValue(m_value.field(), field());
}
void SocFieldCachedEditor::setValue(SocFieldCachedValue val)
{
m_value = val;
SetRegField(m_value.field());
setField(m_value.value());
}
/**
* SocFieldEditorCreator
*/
QWidget *SocFieldEditorCreator::createWidget(QWidget *parent) const
{
return new SocFieldEditor(m_field, parent);
}
QByteArray SocFieldEditorCreator::valuePropertyName() const
{
return QByteArray("field");
}
void SocFieldEditorCreator::setWidth(int bitcount)
{
m_field.width = bitcount;
}
/**
* SocFieldCachedEditorCreator
*/
QWidget *SocFieldCachedEditorCreator::createWidget(QWidget *parent) const
{
return new SocFieldCachedEditor(parent);
}
QByteArray SocFieldCachedEditorCreator::valuePropertyName() const
{
return QByteArray("value");
}
/**
* RegFieldTableModel
*/
RegFieldTableModel::RegFieldTableModel(QObject *parent)
:QAbstractTableModel(parent)
{
m_read_only = true;
}
int RegFieldTableModel::rowCount(const QModelIndex& /* parent */) const
{
return m_reg.field.size();
}
int RegFieldTableModel::columnCount(const QModelIndex& /* parent */) const
{
return ColumnCountOffset + m_value.size();
}
QVariant RegFieldTableModel::data(const QModelIndex& index, int role) const
{
if(index.row() < 0 || (size_t)index.row() >= m_reg.field.size())
return QVariant();
int section = index.column();
const soc_desc::field_t& field = m_reg.field[index.row()];
/* column independent code */
const RegThemeGroup *theme = 0;
switch(m_status[index.row()])
{
case Normal: theme = &m_theme.normal; break;
case Diff: theme = &m_theme.diff; break;
case Error: theme = &m_theme.error; break;
case None: default: break;
}
if(role == Qt::FontRole)
return theme ? QVariant(theme->font) : QVariant();
if(role == Qt::BackgroundRole)
return theme ? QVariant(theme->background) : QVariant();
if(role == Qt::ForegroundRole)
return theme ? QVariant(theme->foreground) : QVariant();
/* column dependent code */
if(section == BitRangeColumn)
{
if(role == Qt::DisplayRole)
return QVariant::fromValue(SocFieldBitRange(field));
else if(role == Qt::TextAlignmentRole)
return QVariant(Qt::AlignVCenter | Qt::AlignHCenter);
else
return QVariant();
}
if(section == NameColumn)
{
if(role == Qt::DisplayRole)
return QVariant(QString::fromStdString(field.name));
else
return QVariant();
}
if(section < FirstValueColumn + m_value.size())
{
int idx = section - FirstValueColumn;
if(role == Qt::DisplayRole)
{
if(!m_value[idx].isValid())
return QVariant("<error>");
return QVariant::fromValue(SocFieldCachedValue(field,
field.extract(m_value[idx].value< soc_word_t >())));
}
else if(role == Qt::EditRole)
{
if(!m_value[idx].isValid())
return QVariant();
return QVariant::fromValue(SocFieldCachedValue(field,
field.extract(m_value[idx].value< soc_word_t >())));
}
else if(role == Qt::TextAlignmentRole)
return QVariant(Qt::AlignVCenter | Qt::AlignHCenter);
else
return QVariant();
}
section -= m_value.size();
if(section == DescColumnOffset)
{
if(role == Qt::DisplayRole)
return QVariant(QString::fromStdString(field.desc));
else
return QVariant();
}
return QVariant();
}
bool RegFieldTableModel::setData(const QModelIndex& idx, const QVariant& value, int role)
{
if(role != Qt::EditRole)
return false;
int section = idx.column();
if(section < FirstValueColumn || section >= FirstValueColumn + m_value.size())
return false;
section -= FirstValueColumn;
const SocFieldCachedValue& v = value.value< SocFieldCachedValue >();
if(!m_value[section].isValid())
return false;
soc_word_t old_val = m_value[section].value< soc_word_t >();
m_value[section] = QVariant(v.field().replace(old_val, v.value()));
// update column
RecomputeTheme();
emit dataChanged(index(0, section), index(rowCount() - 1, section));
emit OnValueModified(section);
return true;
}
Qt::ItemFlags RegFieldTableModel::flags(const QModelIndex& index) const
{
Qt::ItemFlags flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
int section = index.column();
if(section < FirstValueColumn || section >= FirstValueColumn + m_value.size())
return flags;
section -= FirstValueColumn;
if(m_value[section].isValid() && !m_read_only)
flags |= Qt::ItemIsEditable;
return flags;
}
QVariant RegFieldTableModel::headerData(int section, Qt::Orientation orientation,
int role) const
{
if(orientation == Qt::Vertical)
return QVariant();
if(role != Qt::DisplayRole)
return QVariant();
if(section == BitRangeColumn)
return QVariant("Bits");
if(section == NameColumn)
return QVariant("Name");
if(section < FirstValueColumn + m_value.size())
{
int idx = section - FirstValueColumn;
if(m_value.size() == 1)
return QVariant("Value");
else
return QVariant(QString("Value %1").arg((QChar)('A' + idx)));
}
section -= m_value.size();
if(section == DescColumnOffset)
return QVariant("Description");
return QVariant();
}
void RegFieldTableModel::SetReadOnly(bool en)
{
if(en == m_read_only)
return;
m_read_only = en;
}
void RegFieldTableModel::SetRegister(const soc_desc::register_t& reg)
{
/* remove all rows */
beginResetModel();
m_reg.field.clear();
endResetModel();
/* add them all */
beginInsertRows(QModelIndex(), 0, reg.field.size() - 1);
m_reg = reg;
RecomputeTheme();
endInsertRows();
}
void RegFieldTableModel::UpdateRegister(const soc_desc::register_t& reg)
{
m_reg = reg;
RecomputeTheme();
emit dataChanged(index(0, 0), index(rowCount() - 1, columnCount() - 1));
}
soc_desc::register_t RegFieldTableModel::GetRegister() const
{
return m_reg;
}
void RegFieldTableModel::SetValues(const QVector< QVariant >& values)
{
/* remove all value columns */
beginRemoveColumns(QModelIndex(), FirstValueColumn,
FirstValueColumn + m_value.size() - 1);
m_value.clear();
endRemoveColumns();
/* add them back */
beginInsertColumns(QModelIndex(), FirstValueColumn,
FirstValueColumn + values.size() - 1);
m_value = values;
RecomputeTheme();
endInsertColumns();
}
QVariant RegFieldTableModel::GetValue(int index)
{
return m_value[index];
}
void RegFieldTableModel::SetTheme(const RegTheme& theme)
{
m_theme = theme;
RecomputeTheme();
emit dataChanged(index(0, 0), index(rowCount() - 1, columnCount() - 1));
}
void RegFieldTableModel::RecomputeTheme()
{
m_status.resize(m_reg.field.size());
for(size_t i = 0; i < m_reg.field.size(); i++)
{
m_status[i] = None;
if(!m_theme.valid || m_value.size() == 0)
continue;
m_status[i] = Normal;
const soc_desc::field_t& field = m_reg.field[i];
QVariant val;
for(int j = 0; j < m_value.size(); j++)
{
QVariant val2 = m_value[j];
if(!val2.isValid())
continue;
val2 = QVariant(field.extract(val2.value< soc_word_t >()));
if(!val.isValid())
val = val2;
else if(val != val2)
m_status[i] = Diff;
}
}
}
/**
* RegFieldProxyModel
*/
bool RegFieldProxyModel::lessThan(const QModelIndex& left,
const QModelIndex& right) const
{
QVariant ldata = sourceModel()->data(left);
QVariant rdata = sourceModel()->data(right);
if(isUserType< SocFieldBitRange >(ldata) &&
isUserType< SocFieldBitRange >(rdata))
{
return ldata.value< SocFieldBitRange >() <
rdata.value< SocFieldBitRange >();
}
else if(isUserType< SocFieldCachedValue >(ldata) &&
isUserType< SocFieldCachedValue >(rdata))
{
return ldata.value< SocFieldCachedValue >() <
rdata.value< SocFieldCachedValue >();
}
else
return QSortFilterProxyModel::lessThan(left, right);
}
/**
* YRegDisplayItemDelegate
*/
YRegDisplayItemDelegate::YRegDisplayItemDelegate(QObject *parent)
:QStyledItemDelegate(parent)
{
}
void YRegDisplayItemDelegate::paint(QPainter *painter,
const QStyleOptionViewItem& option, const QModelIndex& index) const
{
QStyleOptionViewItemV4 opt = option;
// default alignment is centered unless specified
opt.displayAlignment = Qt::AlignHCenter | Qt::AlignVCenter;
initStyleOption(&opt, index);
painter->save();
// draw everything rotated, requires careful manipulation of the
// rects involved
painter->translate(opt.rect.bottomLeft());
painter->rotate(-90);
opt.rect = QRect(0, 0, opt.rect.height(), opt.rect.width());
QStyle *style = opt.widget ? opt.widget->style() : QApplication::style();
style->drawControl(QStyle::CE_ItemViewItem, &opt, painter, opt.widget);
painter->restore();
}
QSize YRegDisplayItemDelegate::sizeHint(const QStyleOptionViewItem& option,
const QModelIndex& index) const
{
Q_UNUSED(option);
Q_UNUSED(index);
return QSize();
}
/**
* YRegDisplay
*/
YRegDisplay::YRegDisplay(QWidget *parent)
:QAbstractItemView(parent)
{
m_is_dirty = true;
m_range_col = 0;
m_data_col = 1;
m_nr_bits = 32;
// the frame around the register is ugly, disable it
setFrameShape(QFrame::NoFrame);
setSelectionMode(SingleSelection);
setItemDelegate(new YRegDisplayItemDelegate());
}
void YRegDisplay::setWidth(int nr_bits)
{
m_nr_bits = nr_bits;
m_is_dirty = true;
recomputeGeometry();
updateGeometries();
}
int YRegDisplay::bitColumnAt(const QPoint& point, bool closest) const
{
int wx = point.x() + horizontalScrollBar()->value();
for(int bit = 0; bit < m_nr_bits; bit++)
{
int off = columnOffset(bitToColumn(bit));
int w = columnWidth(bitToColumn(bit));
if(wx >= off && wx < off + w)
return bit;
if(wx >= off + w && closest)
return bit;
}
return closest ? m_nr_bits - 1 : -1;
}
QModelIndex YRegDisplay::indexAt(const QPoint& point) const
{
if(!model())
return QModelIndex();
int wx = point.x() + horizontalScrollBar()->value();
int wy = point.y() + verticalScrollBar()->value();
for(int i = 0; i < model()->rowCount(); i++)
{
QModelIndex index = model()->index(i, m_data_col, rootIndex());
QRect r = itemRect(index);
if(!r.isValid())
continue;
if(r.contains(wx, wy))
return index;
}
return QModelIndex();
}
void YRegDisplay::scrollTo(const QModelIndex& index, ScrollHint hint)
{
Q_UNUSED(index);
Q_UNUSED(hint);
}
QRect YRegDisplay::visualRect(const QModelIndex &index) const
{
QRect rect = itemRect(index);
if(rect.isValid())
return QRect(rect.left() - horizontalScrollBar()->value(),
rect.top() - verticalScrollBar()->value(),
rect.width(), rect.height());
else
return rect;
}
bool YRegDisplay::isIndexHidden(const QModelIndex& index) const
{
Q_UNUSED(index);
return false;
}
QModelIndex YRegDisplay::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers)
{
Q_UNUSED(cursorAction);
Q_UNUSED(modifiers);
return QModelIndex();
}
void YRegDisplay::setSelection(const QRect& r, QItemSelectionModel::SelectionFlags flags)
{
if(!model())
return;
QRect rect = r.translated(horizontalScrollBar()->value(),
verticalScrollBar()->value()).normalized();
QItemSelection sel;
for(int i = 0; i < model()->rowCount(); i++)
{
QModelIndex index = model()->index(i, m_data_col, rootIndex());
QRect r = itemRect(index);
if(!r.isValid())
continue;
if(r.intersects(rect))
sel.select(index, index);
}
selectionModel()->select(sel, flags);
}
int YRegDisplay::verticalOffset() const
{
return verticalScrollBar()->value();
}
int YRegDisplay::horizontalOffset() const
{
return horizontalScrollBar()->value();
}
void YRegDisplay::scrollContentsBy(int dx, int dy)
{
viewport()->scroll(dx, dy);
}
void YRegDisplay::setModel(QAbstractItemModel *model)
{
QAbstractItemView::setModel(model);
m_is_dirty = true;
}
void YRegDisplay::dataChanged(const QModelIndex &topLeft,
const QModelIndex &bottomRight)
{
m_is_dirty = true;
QAbstractItemView::dataChanged(topLeft, bottomRight);
}
void YRegDisplay::rowsInserted(const QModelIndex &parent, int start, int end)
{
m_is_dirty = true;
QAbstractItemView::rowsInserted(parent, start, end);
}
void YRegDisplay::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
{
m_is_dirty = true;
QAbstractItemView::rowsAboutToBeRemoved(parent, start, end);
}
int YRegDisplay::separatorSize() const
{
return 1;
}
int YRegDisplay::marginSize() const
{
return viewOptions().fontMetrics.height() / 3;
}
int YRegDisplay::headerTextSep() const
{
return marginSize() / 2;
}
int YRegDisplay::headerHeight() const
{
return 2 * marginSize() + headerTextSep() + 2 * viewOptions().fontMetrics.height();
}
int YRegDisplay::minColumnWidth() const
{
return 2 * marginSize() + viewOptions().fontMetrics.height();
}
int YRegDisplay::maxColumnWidth() const
{
return 2 * minColumnWidth();
}
int YRegDisplay::columnWidth(int col) const
{
int avail = width() - (m_nr_bits + 1) * separatorSize();
int small_w = qMin(avail / m_nr_bits, maxColumnWidth());
int nr_big = avail - small_w * m_nr_bits;
if(col < nr_big)
return small_w + 1;
else
return small_w;
}
int YRegDisplay::columnOffset(int col) const
{
int off = separatorSize();
for(int i = 0; i < col; i++)
off += columnWidth(i) + separatorSize();
int all_w = off;
for(int i = col; i < m_nr_bits; i++)
all_w += columnWidth(i) + separatorSize();
return off + (width() - all_w) / 2;
}
int YRegDisplay::maxContentHeight() const
{
int max = 0;
QFontMetrics metrics = viewOptions().fontMetrics;
if(model())
{
for(int i = 0; i < model()->rowCount(); i++)
{
QModelIndex index = model()->index(i, m_data_col, rootIndex());
QString s = model()->data(index).toString();
max = qMax(max, metrics.boundingRect(s).width());
}
}
return 2 * marginSize() + max;
}
int YRegDisplay::gapHeight() const
{
return marginSize() / 2;
}
int YRegDisplay::bitToColumn(int bit) const
{
return m_nr_bits - 1 - bit;
}
QRegion YRegDisplay::visualRegionForSelection(const QItemSelection& selection) const
{
QRegion region;
foreach(const QItemSelectionRange &range, selection)
{
for(int row = range.top(); row <= range.bottom(); ++row)
{
for(int column = range.left(); column < range.right(); ++column)
{
QModelIndex index = model()->index(row, column, rootIndex());
region += visualRect(index);
}
}
}
return region;
}
QRect YRegDisplay::itemRect(const QModelIndex& index) const
{
if(!index.isValid())
return QRect();
QVariant vrange = model()->data(model()->index(index.row(), m_range_col, rootIndex()));
if(!vrange.canConvert< SocFieldBitRange >())
return QRect();
SocFieldBitRange range = vrange.value< SocFieldBitRange >();
return itemRect(range, index.column());
}
QRect YRegDisplay::itemRect(const SocFieldBitRange& range, int col) const
{
int top, bot;
if(col == m_range_col)
{
top = separatorSize();
bot = separatorSize() + headerHeight() - 1;
}
else if(col == m_data_col)
{
top = headerHeight() + 3 * separatorSize() + gapHeight();
bot = height() - separatorSize() - 1;
}
else
return QRect();
int first_col = bitToColumn(range.GetFirstBit());
return QRect(QPoint(columnOffset(bitToColumn(range.GetLastBit())), top),
QPoint(columnOffset(first_col) + columnWidth(first_col) - 1, bot));
}
void YRegDisplay::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
QPainter painter(viewport());
painter.setRenderHints(QPainter::Antialiasing | QPainter::TextAntialiasing);
painter.translate(-horizontalScrollBar()->value(), -verticalScrollBar()->value());
QStyleOptionViewItem option = viewOptions();
int txt_h = option.fontMetrics.height();
int grid_hint = style()->styleHint(QStyle::SH_Table_GridLineColor, &option, this);
QBrush grid_brush(static_cast< QRgb >(grid_hint));
QBrush back_brush = option.palette.base();
int sep_sz = separatorSize();
QItemSelectionModel *selections = selectionModel();
// paint header
for(int bit = 0; bit < m_nr_bits; bit++)
{
QRect r = itemRect(SocFieldBitRange(bit, bit), m_range_col);
// paint background
painter.fillRect(r, back_brush);
// paint top digit
r.setTop(r.top() + marginSize());
r.setBottom(r.top() + txt_h);
style()->drawItemText(&painter, r, Qt::AlignHCenter, option.palette,
true, QString("%1").arg(bit / 10), foregroundRole());
// paint bottom digit
r.setTop(r.bottom() + headerTextSep());
r.setBottom(r.top() + txt_h);
style()->drawItemText(&painter, r, Qt::AlignHCenter, option.palette,
true, QString("%1").arg(bit % 10), foregroundRole());
}
// paint header grid
for(int bit = 1; bit < m_nr_bits; bit++)
{
QRect r = itemRect(SocFieldBitRange(bit, bit), m_range_col);
r.setCoords(r.right() + 1, r.top(), r.right() + sep_sz, r.bottom());
if((bit % 4) == 0)
r.setCoords(r.left() - sep_sz, r.top(), r.right() + sep_sz, r.bottom());
painter.fillRect(r, grid_brush);
}
QRect hdr_r = itemRect(SocFieldBitRange(0, m_nr_bits - 1), m_range_col);
painter.fillRect(QRect(hdr_r.left(), hdr_r.top() - sep_sz, hdr_r.width(), sep_sz), grid_brush);
painter.fillRect(QRect(hdr_r.left(), hdr_r.bottom() + 1, hdr_r.width(), sep_sz), grid_brush);
// paint header gap
QRect gap_r(hdr_r.left(), hdr_r.bottom() + sep_sz + 1, hdr_r.width(), gapHeight());
painter.fillRect(gap_r, back_brush);
// paint header bottom line
painter.fillRect(QRect(gap_r.left(), gap_r.bottom() + 1, gap_r.width(), sep_sz), grid_brush);
// paint background
QRect data_r = itemRect(SocFieldBitRange(0, m_nr_bits - 1), m_data_col);
//painter.fillRect(data_r, back_brush);
// paint data bottom line
painter.fillRect(QRect(data_r.left(), data_r.bottom() + 1, data_r.width(), sep_sz), grid_brush);
// paint left/right lines
painter.fillRect(QRect(hdr_r.left() - sep_sz, hdr_r.top() - sep_sz, sep_sz, height()), grid_brush);
painter.fillRect(QRect(hdr_r.right() + 1, hdr_r.top() - sep_sz, sep_sz, height()), grid_brush);
// paint model
if(!model())
return;
for(int i = 0; i < model()->rowCount(); i++)
{
QModelIndex index = model()->index(i, m_data_col, rootIndex());
QRect r = itemRect(index);
if(!r.isValid())
continue;
QString name = index.data().toString();
// paint background
QStyleOptionViewItem opt = viewOptions();
opt.rect = r;
//opt.showDecorationSelected = true;
style()->drawPrimitive(QStyle::PE_PanelItemViewRow, &opt, &painter, this);
if(selections->isSelected(index))
opt.state |= QStyle::State_Selected;
if(currentIndex() == index)
opt.state |= QStyle::State_HasFocus;
if(m_hover == index)
opt.state |= QStyle::State_MouseOver;
itemDelegate(index)->paint(&painter, opt, index);
// paint left/right lines
painter.fillRect(QRect(r.left() - sep_sz, r.top(), sep_sz, r.height()), grid_brush);
painter.fillRect(QRect(r.right() + 1, r.top(), sep_sz, r.height()), grid_brush);
}
}
void YRegDisplay::recomputeGeometry()
{
if(!m_is_dirty)
return;
/* height: header + gap + sep + content + sep */
m_minimum_height = 0;
m_minimum_height += headerHeight() + gapHeight();
m_minimum_height += 2 * separatorSize() + maxContentHeight();
/* width: sep + (col + sep) * n */
m_minimum_width = separatorSize() * (m_nr_bits + 1) + minColumnWidth() * m_nr_bits;
m_is_dirty = false;
viewport()->update();
}
void YRegDisplay::resizeEvent(QResizeEvent*)
{
m_is_dirty = true;
recomputeGeometry();
updateGeometries();
}
void YRegDisplay::updateGeometries()
{
horizontalScrollBar()->setSingleStep(1);
horizontalScrollBar()->setPageStep(viewport()->width());
horizontalScrollBar()->setRange(0, qMax(0, m_minimum_width - viewport()->width()));
verticalScrollBar()->setSingleStep(1);
verticalScrollBar()->setPageStep(viewport()->height());
verticalScrollBar()->setRange(0, qMax(0, m_minimum_height - viewport()->height()));
}
bool YRegDisplay::viewportEvent(QEvent *event)
{
/* FIXME Apparently QAbstractItemView tracks the hovered index but keeps it
* in its private part which is not accessible, which makes it useless...
* This code reimplements it */
switch (event->type())
{
case QEvent::HoverEnter:
m_hover = indexAt(static_cast<QHoverEvent*>(event)->pos());
update(m_hover);
break;
case QEvent::HoverLeave:
update(m_hover); // update old
m_hover = QModelIndex();
break;
case QEvent::HoverMove:
{
QModelIndex old = m_hover;
m_hover = indexAt(static_cast<QHoverEvent*>(event)->pos());
if(m_hover != old)
viewport()->update(visualRect(old)|visualRect(m_hover));
break;
}
default:
break;
}
return QAbstractItemView::viewportEvent(event);
}
/**
* GrowingTableView
*/
GrowingTableView::GrowingTableView(QWidget *parent)
:QTableView(parent)
{
}
void GrowingTableView::setModel(QAbstractItemModel *m)
{
if(model())
disconnect(model(), SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
this, SLOT(DataChanged(const QModelIndex&, const QModelIndex&)));
QTableView::setModel(m);
connect(model(), SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
this, SLOT(DataChanged(const QModelIndex&, const QModelIndex&)));
DataChanged(QModelIndex(), QModelIndex());
}
void GrowingTableView::DataChanged(const QModelIndex& tl, const QModelIndex& br)
{
Q_UNUSED(tl);
Q_UNUSED(br);
resizeColumnsToContents();
int h = contentsMargins().top() + contentsMargins().bottom();
h += horizontalHeader()->height();
for(int i = 0; i < model()->rowCount(); i++)
h += rowHeight(i);
setMinimumHeight(h);
}
/**
* MyTextEditor
*/
MyTextEditor::MyTextEditor(QWidget *parent)
:QWidget(parent)
{
QVBoxLayout *layout = new QVBoxLayout;
m_toolbar = new QToolBar(this);
m_edit = new QTextEdit(this);
#if QT_VERSION >= QT_VERSION_CHECK(5, 2, 0)
/* Qt 5.2 have a hardcoded sizeHint for QAbstractScrollArea which makes it
* hard to have a good behaviour for the text editor. Fortunately 5.2 introduces
* a new option to adjust this to the content. */
m_edit->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContents);
#endif
layout->addWidget(m_toolbar, 0);
layout->addWidget(m_edit, 1);
setLayout(layout);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
m_edit->setAcceptRichText(false);
m_edit->setAutoFormatting(QTextEdit::AutoAll);
m_bold_button = new QToolButton(this);
m_bold_button->setIcon(QIcon::fromTheme("format-text-bold"));
m_bold_button->setText("bold");
m_bold_button->setCheckable(true);
m_italic_button = new QToolButton(this);
m_italic_button->setIcon(QIcon::fromTheme("format-text-italic"));
m_italic_button->setText("italic");
m_italic_button->setCheckable(true);
m_underline_button = new QToolButton(this);
m_underline_button->setIcon(QIcon::fromTheme("format-text-underline"));
m_underline_button->setText("underline");
m_underline_button->setCheckable(true);
m_toolbar->addWidget(m_bold_button);
m_toolbar->addWidget(m_italic_button);
m_toolbar->addWidget(m_underline_button);
connect(m_bold_button, SIGNAL(toggled(bool)), this, SLOT(OnTextBold(bool)));
connect(m_italic_button, SIGNAL(toggled(bool)), this, SLOT(OnTextItalic(bool)));
connect(m_underline_button, SIGNAL(toggled(bool)), this, SLOT(OnTextUnderline(bool)));
connect(m_edit, SIGNAL(textChanged()), this, SLOT(OnInternalTextChanged()));
connect(m_edit, SIGNAL(currentCharFormatChanged(const QTextCharFormat&)),
this, SLOT(OnCharFormatChanged(const QTextCharFormat&)));
m_edit->installEventFilter(this);
SetGrowingMode(false);
SetReadOnly(false);
m_toolbar->hide();
}
void MyTextEditor::SetReadOnly(bool en)
{
m_read_only = en;
if(en)
m_toolbar->hide();
else
m_toolbar->show();
m_edit->setReadOnly(en);
}
void MyTextEditor::SetGrowingMode(bool en)
{
m_growing_mode = en;
if(en)
{
m_edit->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
m_edit->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
OnInternalTextChanged();
}
else
{
m_edit->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
m_edit->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
}
}
void MyTextEditor::OnInternalTextChanged()
{
if(m_growing_mode)
{
int content_size = m_edit->document()->documentLayout()->documentSize().height();
content_size = qMax(content_size, m_edit->fontMetrics().height());
m_edit->setMinimumHeight(content_size + m_edit->contentsMargins().top() +
m_edit->contentsMargins().bottom());
}
emit OnTextChanged();
emit OnTextChanged(GetTextHtml());
}
void MyTextEditor::OnTextBold(bool checked)
{
QTextCursor cursor = m_edit->textCursor();
QTextCharFormat fmt = cursor.charFormat();
fmt.setFontWeight(checked ? QFont::Bold : QFont::Normal);
cursor.setCharFormat(fmt);
m_edit->setTextCursor(cursor);
}
void MyTextEditor::OnTextItalic(bool checked)
{
QTextCursor cursor = m_edit->textCursor();
QTextCharFormat fmt = cursor.charFormat();
fmt.setFontItalic(checked);
cursor.setCharFormat(fmt);
m_edit->setTextCursor(cursor);
}
void MyTextEditor::OnTextUnderline(bool checked)
{
QTextCursor cursor = m_edit->textCursor();
QTextCharFormat fmt = cursor.charFormat();
fmt.setFontUnderline(checked);
cursor.setCharFormat(fmt);
m_edit->setTextCursor(cursor);
}
void MyTextEditor::OnCharFormatChanged(const QTextCharFormat& fmt)
{
/* NOTE: changing the button states programmaticaly doesn't trigger
* the toggled() signals, otherwise it would result in a loop
* between this function and OnText{Bold,Italic,Underline,...} */
m_bold_button->setChecked(fmt.fontWeight() > QFont::Normal);
m_italic_button->setChecked(fmt.fontItalic());
m_underline_button->setChecked(fmt.fontUnderline());
}
void MyTextEditor::SetTextHtml(const QString& text)
{
m_edit->setHtml(text);
}
QString MyTextEditor::GetTextHtml()
{
return m_edit->toPlainText();
}
bool MyTextEditor::IsModified()
{
return m_edit->document()->isModified();
}
bool MyTextEditor::eventFilter(QObject *object, QEvent *event)
{
if(object != m_edit)
return false;
if(m_read_only)
return false;
if(event->type() == QEvent::FocusIn)
m_toolbar->show();
else if(event->type() == QEvent::FocusOut)
m_toolbar->hide();
return false;
}
/**
* BackendSelector
*/
BackendSelector::BackendSelector(Backend *backend, QWidget *parent)
:QWidget(parent), m_backend(backend)
{
m_data_selector = new QComboBox(this);
m_data_selector->addItem(QIcon::fromTheme("text-x-generic"), "Nothing...", QVariant(DataSelNothing));
m_data_selector->addItem(QIcon::fromTheme("document-open"), "File...", QVariant(DataSelFile));
#ifdef HAVE_HWSTUB
m_data_selector->addItem(QIcon::fromTheme("multimedia-player"), "Device...", QVariant(DataSelDevice));
#endif
m_data_sel_edit = new QLineEdit(this);
m_data_sel_edit->setReadOnly(true);
m_nothing_text = new QLabel(this);
m_nothing_text->setTextFormat(Qt::RichText);
QHBoxLayout *data_sel_layout = new QHBoxLayout(this);
data_sel_layout->addWidget(m_data_selector);
data_sel_layout->addWidget(m_data_sel_edit, 1);
data_sel_layout->addWidget(m_nothing_text, 1);
data_sel_layout->addStretch(0);
#ifdef HAVE_HWSTUB
m_dev_selector = new QComboBox;
data_sel_layout->addWidget(m_dev_selector, 1);
#endif
m_io_backend = m_backend->CreateDummyIoBackend();
connect(m_data_selector, SIGNAL(activated(int)),
this, SLOT(OnDataSelChanged(int)));
#ifdef HAVE_HWSTUB
connect(m_dev_selector, SIGNAL(currentIndexChanged(int)),
this, SLOT(OnDevChanged(int)));
connect(&m_hwstub_helper, SIGNAL(OnDevListChanged(bool, struct libusb_device *)),
this, SLOT(OnDevListChanged2(bool, struct libusb_device *)));
#endif
OnDataSelChanged(0);
}
BackendSelector::~BackendSelector()
{
#ifdef HAVE_HWSTUB
ClearDevList();
#endif
delete m_io_backend;
}
void BackendSelector::SetNothingMessage(const QString& msg)
{
m_nothing_text->setText(msg);
}
void BackendSelector::OnDataSelChanged(int index)
{
if(index == -1)
return;
QVariant var = m_data_selector->itemData(index);
if(var == DataSelFile)
{
m_nothing_text->hide();
m_data_sel_edit->show();
#ifdef HAVE_HWSTUB
m_dev_selector->hide();
#endif
QFileDialog *fd = new QFileDialog(m_data_selector);
QStringList filters;
filters << "Textual files (*.txt)";
filters << "All files (*)";
fd->setNameFilters(filters);
fd->setDirectory(Settings::Get()->value("regtab/loaddatadir", QDir::currentPath()).toString());
if(fd->exec())
{
QStringList filenames = fd->selectedFiles();
ChangeBackend(m_backend->CreateFileIoBackend(filenames[0]));
m_data_sel_edit->setText(filenames[0]);
}
Settings::Get()->setValue("regtab/loaddatadir", fd->directory().absolutePath());
}
#ifdef HAVE_HWSTUB
else if(var == DataSelDevice)
{
m_nothing_text->hide();
m_data_sel_edit->hide();
m_dev_selector->show();
OnDevListChanged();
}
#endif
else
{
m_data_sel_edit->hide();
m_nothing_text->show();
#ifdef HAVE_HWSTUB
m_dev_selector->hide();
#endif
ChangeBackend(m_backend->CreateDummyIoBackend());
}
}
#ifdef HAVE_HWSTUB
void BackendSelector::OnDevListChanged2(bool arrived, struct libusb_device *dev)
{
Q_UNUSED(arrived);
Q_UNUSED(dev);
OnDevListChanged();
}
void BackendSelector::OnDevListChanged()
{
ClearDevList();
QList< HWStubDevice* > list = m_hwstub_helper.GetDevList();
foreach(HWStubDevice *dev, list)
{
QString name = QString("Bus %1 Device %2: %3").arg(dev->GetBusNumber())
.arg(dev->GetDevAddress()).arg(dev->GetTargetInfo().bName);
m_dev_selector->addItem(QIcon::fromTheme("multimedia-player"), name,
QVariant::fromValue((void *)dev));
}
if(list.size() > 0)
m_dev_selector->setCurrentIndex(0);
}
void BackendSelector::OnDevChanged(int index)
{
if(index == -1)
return;
HWStubDevice *dev = reinterpret_cast< HWStubDevice* >(m_dev_selector->itemData(index).value< void* >());
delete m_io_backend;
/* NOTE: make a copy of the HWStubDevice device because the one in the list
* might get destroyed when clearing the list while the backend is still
* active: this would result in a double free when the backend is also destroyed */
m_io_backend = m_backend->CreateHWStubIoBackend(new HWStubDevice(dev));
emit OnSelect(m_io_backend);
}
void BackendSelector::ClearDevList()
{
while(m_dev_selector->count() > 0)
{
HWStubDevice *dev = reinterpret_cast< HWStubDevice* >(m_dev_selector->itemData(0).value< void* >());
delete dev;
m_dev_selector->removeItem(0);
}
}
#endif
IoBackend *BackendSelector::GetBackend()
{
return m_io_backend;
}
void BackendSelector::ChangeBackend(IoBackend *new_backend)
{
/* WARNING: delete old backend *after* calling the signal, otherwise the old backend
* might get used after delete */
emit OnSelect(new_backend);
delete m_io_backend;
m_io_backend = new_backend;
}
/**
* YTabWidget
*/
YTabWidget::YTabWidget(QTabBar *bar, QWidget *parent)
:QTabWidget(parent)
{
if(bar != 0)
setTabBar(bar);
m_tab_open_button = new QToolButton(this);
m_tab_open_button->setIcon(QIcon::fromTheme("list-add"));
m_tab_open_button->setAutoRaise(true);
m_tab_open_button->setPopupMode(QToolButton::InstantPopup);
/* the arrow with an icon only is pretty ugly and QToolButton has no way
* to remove the arrow programmaticaly, so use the CSS to do that */
m_tab_open_button->setStyleSheet("QToolButton::menu-indicator { image: none; }");
setCornerWidget(m_tab_open_button, Qt::TopLeftCorner);
setTabOpenable(false);
connect(m_tab_open_button, SIGNAL(clicked(bool)), this, SLOT(OnOpenButton(bool)));
/* there is a quirk in the default QStyle: if the tab bar is empty, it
* returns the minimum size of the corner widget, which is 0 for tool buttons */
//setMinimumHeight(m_tab_open_button->height());
//m_tab_open_button->setMinimumHeight(m_tab_open_button->sizeHint().height());
}
void YTabWidget::setTabOpenable(bool openable)
{
m_tab_openable = openable;
m_tab_open_button->setVisible(openable);
}
void YTabWidget::OnOpenButton(bool checked)
{
Q_UNUSED(checked);
emit tabOpenRequested();
}
void YTabWidget::setTabOpenMenu(QMenu *menu)
{
m_tab_open_button->setMenu(menu);
}
/**
* MessageWidget
*/
MessageWidget::MessageWidget(QWidget *parent)
:QFrame(parent)
{
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
m_icon = new QLabel(this);
m_icon->hide();
m_text = new QLabel(this);
m_text->setTextFormat(Qt::RichText);
m_close = new QToolButton(this);
m_close->setText("close");
m_close->setIcon(style()->standardIcon(QStyle::SP_DialogCloseButton));
m_close->setAutoRaise(true);
QHBoxLayout *layout = new QHBoxLayout(this);
layout->addWidget(m_icon, 0);
layout->addWidget(m_text, 1);
layout->addWidget(m_close, 0);
m_id = 0;
connect(m_close, SIGNAL(clicked(bool)), this, SLOT(OnClose(bool)));
hide();
}
MessageWidget::~MessageWidget()
{
}
void MessageWidget::UpdateType()
{
/* style stolen from KMessageWidget */
QColor bg, border;
switch(m_type)
{
case Positive:
bg.setRgb(140, 228, 124);
border.setRgb(56, 175, 58);
break;
case Information:
bg.setRgb(161, 178, 202);
border.setRgb(59, 79, 175);
break;
case Warning:
bg.setRgb(228, 227, 127);
border.setRgb(175, 169, 61);
break;
case Error:
bg.setRgb(233, 199, 196);
border.setRgb(175, 74, 60);
break;
default:
break;
}
setStyleSheet(QString(
"QFrame { background-color: %1;"
"border-radius: 5px;"
"border: 1px solid %2;"
"}"
"QLabel { border: none; }")
.arg(bg.name())
.arg(border.name()));
}
int MessageWidget::SetMessage(MessageType type, const QString& msg)
{
m_type = type;
m_text->setText(msg);
UpdateType();
show();
return ++m_id;
}
void MessageWidget::HideMessage(int id)
{
if(m_id == id)
OnClose(true);
}
void MessageWidget::OnClose(bool clicked)
{
Q_UNUSED(clicked);
hide();
}
/**
* Misc
*/
QGroupBox *Misc::EncloseInBox(const QString& name, QWidget *widget)
{
QVBoxLayout *layout = new QVBoxLayout;
layout->addWidget(widget);
return Misc::EncloseInBox(name, layout);
}
QGroupBox *Misc::EncloseInBox(const QString& name, QLayout *layout)
{
QGroupBox *group = new QGroupBox(name);
group->setLayout(layout);
return group;
}
View git blame Copy permalink