void MainInterface::tableRollUpdate()
{
unsigned int row = 0;
unsigned int column = 0;
if(table_state == TABLE_SHOW){
if(spark_info->b_array[B_SELECT]){
for(row = 0;row < abs(model->rowCount());row++){
QBrush brush;
if(row == spark_info->uint_array[UINT_CURRENT_ROM]){
brush = QBrush(SELECT_COLOR);
}
else if(row < spark_info->uint_array[UINT_START_ROW]){
brush = QBrush(UNSELECT_COLOR);
}
else if(row < spark_info->uint_array[UINT_CURRENT_ROM]){
brush = QBrush(OK_COLOR);
}
else if(row <= spark_info->uint_array[UINT_END_ROW]){
brush = QBrush(UNOK_COLOR);
}
else{
brush = QBrush(UNSELECT_COLOR);
}
for(column = 0;column < 11;column ++){
QStandardItem* item = model->item(row ,column);
item->setBackground(brush);
}
}
}
/*没有加工选择 */
else{
for(row = 0;row < abs(model->rowCount());row++){
QBrush brush;
brush = QBrush(UNSELECT_COLOR);
for(column = 0;column < 11;column ++){
QStandardItem* item = model->item(row ,column);
item->setBackground(brush);
}
}
}
}
else if(table_state == TABLE_SELECT||table_state == TABLE_DELETE||table_state == TABLE_EDIT||table_state == TABLE_ADD){
for(row = 0;row < abs(model->rowCount());row++){
QBrush brush;
if(row < spark_info->uint_array[UINT_START_ROW]){
brush = QBrush(UNSELECT_COLOR);
}
else if(row <= spark_info->uint_array[UINT_END_ROW]){
brush = QBrush(UNOK_COLOR);
}
else{
brush = QBrush(UNSELECT_COLOR);
}
for(column = 0;column < 11;column ++){
QStandardItem* item = model->item(row ,column);
item->setBackground(brush);
}
}
}
}
void QNode::updateTimes()
{
double time;
QStandardItem* node;
if(m_currentTabText == "System Info")
{
for(int i = 0; i < m_safeSpeedModel.rowCount(); i++)
{
if( (node = m_safeSpeedModel.item(i,2)) == 0 || !node->data().isValid())
{
ROS_ERROR("Invalid safespeed child");
} else
{
time = ros::Time::now().toSec()-node->data().toDouble();
node->setText(QString::number(time, 'g', 4));
//set colors for stale
if(time > m_safeSpeedTimeout)
{
node->setBackground(Qt::magenta);
} else
{
node->setBackground(m_safeSpeedModel.item(i,1)->background());
}
}
}
}
}
QStandardItem *EquipmentColumn::build_cell(Dwarf *d){
QStandardItem *item = init_cell(d);
QColor rating_color = QColor(69,148,21);
float rating = d->get_uniform_rating();
float coverage = d->get_coverage_rating();
if(coverage < 100){ //prioritize coverage
rating = coverage;
rating_color = Item::color_uncovered();
}else{
if(rating < 100) //missing uniform items
rating_color = Item::color_missing();
}
float sort_val = rating - d->get_inventory_wear();
item->setData(d->get_inventory_wear(),DwarfModel::DR_SPECIAL_FLAG);
item->setBackground(QBrush(rating_color));
item->setData(CT_EQUIPMENT, DwarfModel::DR_COL_TYPE);
item->setData(rating, DwarfModel::DR_RATING); //other drawing 0-100
item->setData(sort_val, DwarfModel::DR_SORT_VALUE);
set_export_role(DwarfModel::DR_RATING);
QString tooltip = QString("<center><h3>%1</h3></center>%2%3")
.arg(m_title)
.arg(build_tooltip_desc(d))
.arg(tooltip_name_footer(d));
item->setToolTip(tooltip);
return item;
}
bool ProgramsModel::AddProgram(int groupNum, QModelIndex &index, int row)
{
QStandardItem *groupItem = item(groupNum);
//if the group was disabled re-enable it
if(groupItem->rowCount()==0) {
groupItem->setBackground(Qt::transparent);
groupItem->setToolTip("");
}
int progId = myHost->programsModel->GetNextProgId();
QString name("New prog");
//create the program item
QStandardItem *prgItem = new QStandardItem( name );
prgItem->setData(ProgramNode,NodeType);
prgItem->setData(progId,ProgramId);
#ifndef QT_NO_DEBUG
prgItem->setData(progId,Qt::ToolTipRole);
#endif
prgItem->setDragEnabled(true);
prgItem->setDropEnabled(false);
prgItem->setEditable(true);
if(row==-1)
row=groupItem->rowCount();
groupItem->insertRow(row, prgItem);
index = prgItem->index();
// ValidateProgChange(index);
return true;
}
void m_table::addStandardItemWithCss(int line, int coll,QString val,QString css){
QStandardItem * tmpItem = new QStandardItem(QString(val));
//tmpItem->setForeground(Qt::gray);
tmpItem->setBackground(Qt::gray);
model->setItem(line, coll, tmpItem);
}
void ChannelConfigModel::updateChannelConfig(const SongFormat *currentFormat)
{
this->removeRows(0, this->rowCount());
this->currentFormat = currentFormat;
if(currentFormat == nullptr)
{
return;
}
this->setRowCount(currentFormat->Voices);
for (int i = 0; i < currentFormat->Voices; i++)
{
const std::string &voiceName = currentFormat->VoiceName[i];
QStandardItem *item = new QStandardItem(QString::fromStdString(voiceName));
QBrush b(currentFormat->VoiceIsMuted[i] ? Qt::red : Qt::green);
item->setBackground(b);
QBrush f(currentFormat->VoiceIsMuted[i] ? Qt::white : Qt::black);
item->setForeground(f);
item->setTextAlignment(Qt::AlignCenter);
item->setCheckable(false);
item->setCheckState(currentFormat->VoiceIsMuted[i] ? Qt::Unchecked : Qt::Checked);
this->setItem(i, 0, item);
}
}
void tst_QStandardItem::clone()
{
QStandardItem item;
item.setText(QLatin1String("text"));
item.setToolTip(QLatin1String("toolTip"));
item.setStatusTip(QLatin1String("statusTip"));
item.setWhatsThis(QLatin1String("whatsThis"));
item.setSizeHint(QSize(64, 48));
item.setFont(QFont());
item.setTextAlignment(Qt::AlignLeft|Qt::AlignVCenter);
item.setBackground(QColor(Qt::blue));
item.setForeground(QColor(Qt::green));
item.setCheckState(Qt::PartiallyChecked);
item.setAccessibleText(QLatin1String("accessibleText"));
item.setAccessibleDescription(QLatin1String("accessibleDescription"));
item.setFlags(Qt::ItemIsEnabled | Qt::ItemIsDropEnabled);
QStandardItem *clone = item.clone();
QCOMPARE(clone->text(), item.text());
QCOMPARE(clone->toolTip(), item.toolTip());
QCOMPARE(clone->statusTip(), item.statusTip());
QCOMPARE(clone->whatsThis(), item.whatsThis());
QCOMPARE(clone->sizeHint(), item.sizeHint());
QCOMPARE(clone->font(), item.font());
QCOMPARE(clone->textAlignment(), item.textAlignment());
QCOMPARE(clone->background(), item.background());
QCOMPARE(clone->foreground(), item.foreground());
QCOMPARE(clone->checkState(), item.checkState());
QCOMPARE(clone->accessibleText(), item.accessibleText());
QCOMPARE(clone->accessibleDescription(), item.accessibleDescription());
QCOMPARE(clone->flags(), item.flags());
QVERIFY(!(*clone < item));
delete clone;
}
void RegistersModel::addItems(int startAddress, int noOfItems, bool valueIsEditable)
{
int row;
int col;
m_startAddress = startAddress;
m_noOfItems = noOfItems;
m_offset = (startAddress % 10);
m_firstRow = startAddress / 10;
m_lastRow = (startAddress + noOfItems - 1) / 10;
qDebug()<< "RegistersModel : address " << startAddress << " ,noOfItems " << noOfItems
<< " ,offset " << m_offset << " ,first row " << m_firstRow << " ,last row " << m_lastRow;
//Format Vertical - Horizontal Header
clear();
if (noOfItems > 1) {
model->setHorizontalHeaderLabels(QStringList()<<RegModelHeaderLabels[0]<<RegModelHeaderLabels[1]
<<RegModelHeaderLabels[2]<<RegModelHeaderLabels[3]
<<RegModelHeaderLabels[4]<<RegModelHeaderLabels[5]
<<RegModelHeaderLabels[6]<<RegModelHeaderLabels[7]
<<RegModelHeaderLabels[8]<<RegModelHeaderLabels[9]);
QStringList vertHeader;
for (int i = m_firstRow; i <= m_lastRow ; i++) {
vertHeader<<QString("%1").arg(i * 10, 2, 10, QLatin1Char('0'));
}
model->setVerticalHeaderLabels(vertHeader);
}
else {
model->setHorizontalHeaderLabels(QStringList()<<RegModelHeaderLabels[0]);
model->setVerticalHeaderLabels(QStringList()<<QString("%1").arg(startAddress, 2, 10, QLatin1Char('0')));
}
//Add data to model
if (noOfItems == 1){
QStandardItem *valueItem = new QStandardItem("-");model->setItem(0, 0, valueItem);
valueItem->setEditable(valueIsEditable);
}
else {
for (int i = 0; i < ((m_offset + noOfItems - 1) / 10 + 1) * 10 ; i++) {
row = i / 10;
col = i % 10;
//Address
if (i >= m_offset + noOfItems || i < m_offset){//not used cells
QStandardItem *valueItem = new QStandardItem("x");model->setItem(row, col, valueItem);
valueItem->setEditable(false);
valueItem->setForeground(QBrush(Qt::red));
valueItem->setBackground(QBrush(Qt::lightGray));
}
else {
QStandardItem *valueItem = new QStandardItem("-");model->setItem(row, col, valueItem);
valueItem->setEditable(valueIsEditable);
}
}
}
emit(refreshView());
}
void TableView::disableMouseOver()
{
QStandardItemModel _model = static_cast<QStandardItemModel>(model());
for ( int col = 0; col < _model->columnCount(); col++ )
{
QStandardItem *item = _model->item(currHovered, col);
item->setBackground(QBrush(QColor("white")));
}
}
DirKnot * HPSKnotDirModel::creatNewActiveKnot(const QString &name,bool hasFiles, const QString &path, const bool isExpanded)
{
DirKnot *newKnot = new DirKnot();
newKnot->name = name;
qDebug() << Q_FUNC_INFO << hasFiles;
QStandardItem *newItem = new QStandardItem(name);
newItem->setEnabled(true);
newItem->setToolTip(QDir::toNativeSeparators(path));
newItem->setData(isExpanded,Qt::UserRole+1);
newItem->setData(QDir::fromNativeSeparators(path),Qt::UserRole);
if(hasFiles){
newKnot->hasFiles = true;
newItem->setBackground(QBrush(QColor(0,255,0,40)));
} else {
newKnot->hasFiles = false;
newItem->setBackground(QBrush(QColor(0,0,0,0)));
}
newKnot->item = newItem;
return newKnot;
}
InterceptWidget::InterceptWidget(IntercepSource * source, QWidget *parent) :
QWidget(parent),
source(source)
{
currentBlockSource = NULL;
currentGui = NULL;
ui = new(std::nothrow) Ui::InterceptWidget;
if (ui == NULL) {
qFatal("Cannot allocate memory for Ui::InterceptWidget X{");
}
ui->setupUi(this);
packetsTable = new(std::nothrow) QTableView(this);
if (packetsTable == NULL) {
qFatal("Cannot allocate memory for QTableView X{");
}
QAbstractItemModel *old = packetsTable->model();
model = source->getModel();
packetsTable->setModel(model);
delete old;
packetsTable->setSelectionMode(QAbstractItemView::ContiguousSelection);
packetsTable->setSelectionBehavior(QAbstractItemView::SelectRows);
packetsTable->verticalHeader()->setFont(RegularFont);
packetsTable->horizontalHeader()->setFont(RegularFont);
packetsTable->setColumnWidth(PayloadModel::TIMESPTAMP_COLUMN,TIMESTAMP_COLUMN_WIDTH);
packetsTable->setColumnWidth(PayloadModel::DIRECTION_COLUMN,25);
packetsTable->verticalHeader()->setDefaultSectionSize(20);
#if QT_VERSION >= 0x050000
packetsTable->horizontalHeader()->setSectionsMovable( false );
#else
packetsTable->horizontalHeader()->setMovable(true);
#endif
connect(packetsTable->selectionModel(), SIGNAL(currentRowChanged(QModelIndex,QModelIndex)), SLOT(onCurrentSelectedChanged(QModelIndex,QModelIndex)));
ui->listLayout->addWidget(packetsTable);
updateColumns();
sourceChoices << CHOOSE_TEXT << UDP_EXTERNAL_SOURCE_TEXT << TCP_EXTERNAL_SOURCE_TEXT << RAW_TCP_SOURCE_TEXT;
ui->blockSourceComboBox->addItems(sourceChoices);
ui->blockSourceComboBox->setCurrentIndex(0);
QStandardItem * item = qobject_cast<QStandardItemModel *>(ui->blockSourceComboBox->model())->item(0);
item->setEnabled( false );
item->setTextAlignment(Qt::AlignCenter);
item->setBackground(Qt::darkGray);
item->setForeground(Qt::white);
connect(ui->blockSourceComboBox, SIGNAL(currentIndexChanged(QString)), SLOT(onSourceChanged(QString)));
}
void Peers::enable_persistent(int id)
{
if (model.rowCount() == 0)
return;
QModelIndexList lst = model.match(model.index(0, 0),
peer_role_network_id, id);
for (int i = 0; i < lst.size(); i++) {
QStandardItem *item = model.itemFromIndex(lst[i]);
int type = item->data(peer_role_type).toInt();
if (type == PEER_TYPE_P2P_PERSISTENT_GROUP_GO ||
type == PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT)
item->setBackground(Qt::NoBrush);
}
}
void TableView::setMouseOver(const int row)
{
if ( row == currHovered) return;
QStandardItemModel *_model = static_cast<QStandardItemModel*>(model());
for ( int col = 0; col < _model->columnCount(); col++ )
{
QStandardItem *item = _model->item(row, col);
item->setBackground(QBrush(QColor("red")));
}
if ( currHovered != -1 )
{
disableMouseOver();
}
currHovered = row;
}
void tst_QStandardItem::streamItem()
{
QStandardItem item;
item.setText(QLatin1String("text"));
item.setToolTip(QLatin1String("toolTip"));
item.setStatusTip(QLatin1String("statusTip"));
item.setWhatsThis(QLatin1String("whatsThis"));
item.setSizeHint(QSize(64, 48));
item.setFont(QFont());
item.setTextAlignment(Qt::AlignLeft|Qt::AlignVCenter);
item.setBackground(QColor(Qt::blue));
item.setForeground(QColor(Qt::green));
item.setCheckState(Qt::PartiallyChecked);
item.setAccessibleText(QLatin1String("accessibleText"));
item.setAccessibleDescription(QLatin1String("accessibleDescription"));
QByteArray ba;
{
QDataStream ds(&ba, QIODevice::WriteOnly);
ds << item;
}
{
QStandardItem streamedItem;
QDataStream ds(&ba, QIODevice::ReadOnly);
ds >> streamedItem;
QCOMPARE(streamedItem.text(), item.text());
QCOMPARE(streamedItem.toolTip(), item.toolTip());
QCOMPARE(streamedItem.statusTip(), item.statusTip());
QCOMPARE(streamedItem.whatsThis(), item.whatsThis());
QCOMPARE(streamedItem.sizeHint(), item.sizeHint());
QCOMPARE(streamedItem.font(), item.font());
QCOMPARE(streamedItem.textAlignment(), item.textAlignment());
QCOMPARE(streamedItem.background(), item.background());
QCOMPARE(streamedItem.foreground(), item.foreground());
QCOMPARE(streamedItem.checkState(), item.checkState());
QCOMPARE(streamedItem.accessibleText(), item.accessibleText());
QCOMPARE(streamedItem.accessibleDescription(), item.accessibleDescription());
QCOMPARE(streamedItem.flags(), item.flags());
}
}
void QgsFieldConditionalFormatWidget::setPresets( QList<QgsConditionalStyle> styles )
{
mPresets.clear();
mPresetsModel->clear();
Q_FOREACH ( const QgsConditionalStyle& style, styles )
{
if ( style.isValid() )
{
QStandardItem* item = new QStandardItem( "abc - 123" );
if ( style.backgroundColor().isValid() )
item->setBackground( style.backgroundColor() );
if ( style.textColor().isValid() )
item->setForeground( style.textColor() );
if ( style.symbol() )
item->setIcon( style.icon() );
item->setFont( style.font() );
mPresetsModel->appendRow( item );
mPresets.append( style );
}
}
mPresetsList->setCurrentIndex( 0 );
}
void MyShareFilesDialog::initListView(){
QList<ShareFileEntity> shareFiles = ResourcesManager::getShareFileList();
itemModel = new QStandardItemModel(this);
int size = shareFiles.size();
if(size > 0){
for(int i = 0; i < size; i++){
ShareFileEntity entity = shareFiles.at(i);
QString fileEntityStr = entity.getFileName().append("(").append(entity.getFilePath()).append(")");
QStandardItem* item = new QStandardItem(fileEntityStr);
if(i % 2 == 1){
QLinearGradient linearGrad(QPointF(0, 0), QPointF(200, 200));
linearGrad.setColorAt(0, Qt::darkGreen);
linearGrad.setColorAt(1, Qt::yellow);
QBrush brush(linearGrad);
item->setBackground(brush);
}
itemModel->appendRow(item);
}
}else{
itemModel->clear();
}
ui->shareList->setModel(itemModel);
}
void Demo::list_view(){
standard_item = new QStandardItemModel(this);
/*****************初始化Item数组************************************/
QStringList strList;
strList.append("a");
strList.append("b");
strList.append("c");
strList.append("d");
strList.append("e");
strList.append("f");
strList.append("g");
strList << "h";
strList += "i";
int nCount = strList.size();//获取strList的大小
/****************初始化model*************************************/
for(int i = 0; i < nCount; i++)
{
QString string = static_cast<QString>(strList.at(i));
QStandardItem *item = new QStandardItem(string);
if(i %2 == 1)
{
QLinearGradient linearGrad(QPointF(0, 0), QPointF(200, 200));
linearGrad.setColorAt(0, Qt::darkGreen);
linearGrad.setColorAt(1, Qt::yellow);
QBrush brush(linearGrad);
item->setBackground(brush);
}
standard_item->appendRow(item);
}
ui->listView->setModel(standard_item);//显示model中的内容
connect(ui->listView,SIGNAL(doubleClicked(const QModelIndex&)),\
this,SLOT(on_listView_doubleClicked(const QModelIndex&)));
}
void Peers::add_persistent(int id, const char *ssid, const char *bssid)
{
char cmd[100];
char reply[100];
size_t reply_len;
int mode;
snprintf(cmd, sizeof(cmd), "GET_NETWORK %d mode", id);
if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0)
return;
reply[reply_len] = '\0';
mode = atoi(reply);
QString name = ssid;
name = '[' + name + ']';
QStandardItem *item = new QStandardItem(*group_icon, name);
if (!item)
return;
int type;
if (mode == 3)
type = PEER_TYPE_P2P_PERSISTENT_GROUP_GO;
else
type = PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT;
item->setData(type, peer_role_type);
item->setToolTip(ItemType(type));
item->setData(ssid, peer_role_ssid);
if (bssid && strcmp(bssid, "any") == 0)
bssid = NULL;
if (bssid)
item->setData(bssid, peer_role_address);
item->setData(id, peer_role_network_id);
item->setBackground(Qt::BDiagPattern);
model.appendRow(item);
}
void TransformsGui::buildSavedCombo()
{
ui->savedComboBox->blockSignals(true);
ui->savedComboBox->clear();
int row = 0;
// first inactive element
ui->savedComboBox->addItem(QString("User's chains"));
QStandardItem * item = qobject_cast<QStandardItemModel *>(ui->savedComboBox->model())->item( row );
item->setEnabled( false );
item->setTextAlignment(Qt::AlignCenter);
item->setBackground(Qt::darkGray);
item->setForeground(Qt::white);
// then the rest
QHash<QString, QString> hash = transformFactory->getSavedConfs();
QStringList list = hash.keys();
if (list.isEmpty()) {
ui->savedComboBox->setEnabled(false);
} else {
ui->savedComboBox->addItems(list);
ui->savedComboBox->setEnabled(true);
}
ui->savedComboBox->blockSignals(false);
}
void SelectSiteDialog::initializeTable()
{
model = new QStandardItemModel(importedSites.size(), 1, this);
QStandardItem *item;
QStringList verticalHeader;
int row = 0;
foreach(QSharedPointer<Site> site, importedSites)
{
verticalHeader.append(QString::number(row + 1));
item = new QStandardItem(site.data()->siteDetails.Csc);
item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
item->setData(QVariant(QString::number(site.data()->siteDetails.SwpId)), DataType::SWP_ID);
item->setCheckable(true);
item->setTextAlignment(Qt::AlignJustify);
item->setCheckState(Qt::Unchecked);
item->setBackground(QColor(Qt::white));
item->setForeground(QColor(Qt::black));
model->setItem(row, 0, item);
row++;
}
void tst_QStandardItem::getSetData()
{
QStandardItem item;
for (int x = 0; x < 2; ++x) {
for (int i = 1; i <= 2; ++i) {
QString text = QString("text %0").arg(i);
item.setText(text);
QCOMPARE(item.text(), text);
QPixmap pixmap(32, 32);
pixmap.fill((i == 1) ? Qt::red : Qt::green);
QIcon icon(pixmap);
item.setIcon(icon);
QCOMPARE(item.icon(), icon);
QString toolTip = QString("toolTip %0").arg(i);
item.setToolTip(toolTip);
QCOMPARE(item.toolTip(), toolTip);
QString statusTip = QString("statusTip %0").arg(i);
item.setStatusTip(statusTip);
QCOMPARE(item.statusTip(), statusTip);
QString whatsThis = QString("whatsThis %0").arg(i);
item.setWhatsThis(whatsThis);
QCOMPARE(item.whatsThis(), whatsThis);
QSize sizeHint(64*i, 48*i);
item.setSizeHint(sizeHint);
QCOMPARE(item.sizeHint(), sizeHint);
QFont font;
item.setFont(font);
QCOMPARE(item.font(), font);
Qt::Alignment textAlignment((i == 1)
? Qt::AlignLeft|Qt::AlignVCenter
: Qt::AlignRight);
item.setTextAlignment(textAlignment);
QCOMPARE(item.textAlignment(), textAlignment);
QColor backgroundColor((i == 1) ? Qt::blue : Qt::yellow);
item.setBackground(backgroundColor);
QCOMPARE(item.background().color(), backgroundColor);
QColor textColor((i == i) ? Qt::green : Qt::cyan);
item.setForeground(textColor);
QCOMPARE(item.foreground().color(), textColor);
Qt::CheckState checkState((i == 1) ? Qt::PartiallyChecked : Qt::Checked);
item.setCheckState(checkState);
QCOMPARE(item.checkState(), checkState);
QString accessibleText = QString("accessibleText %0").arg(i);
item.setAccessibleText(accessibleText);
QCOMPARE(item.accessibleText(), accessibleText);
QString accessibleDescription = QString("accessibleDescription %0").arg(i);
item.setAccessibleDescription(accessibleDescription);
QCOMPARE(item.accessibleDescription(), accessibleDescription);
QCOMPARE(item.text(), text);
QCOMPARE(item.icon(), icon);
QCOMPARE(item.toolTip(), toolTip);
QCOMPARE(item.statusTip(), statusTip);
QCOMPARE(item.whatsThis(), whatsThis);
QCOMPARE(item.sizeHint(), sizeHint);
QCOMPARE(item.font(), font);
QCOMPARE(item.textAlignment(), textAlignment);
QCOMPARE(item.background().color(), backgroundColor);
QCOMPARE(item.foreground().color(), textColor);
QCOMPARE(item.checkState(), checkState);
QCOMPARE(item.accessibleText(), accessibleText);
QCOMPARE(item.accessibleDescription(), accessibleDescription);
QCOMPARE(qvariant_cast<QString>(item.data(Qt::DisplayRole)), text);
QCOMPARE(qvariant_cast<QIcon>(item.data(Qt::DecorationRole)), icon);
QCOMPARE(qvariant_cast<QString>(item.data(Qt::ToolTipRole)), toolTip);
QCOMPARE(qvariant_cast<QString>(item.data(Qt::StatusTipRole)), statusTip);
QCOMPARE(qvariant_cast<QString>(item.data(Qt::WhatsThisRole)), whatsThis);
QCOMPARE(qvariant_cast<QSize>(item.data(Qt::SizeHintRole)), sizeHint);
QCOMPARE(qvariant_cast<QFont>(item.data(Qt::FontRole)), font);
QCOMPARE(qvariant_cast<int>(item.data(Qt::TextAlignmentRole)), int(textAlignment));
QCOMPARE(qvariant_cast<QBrush>(item.data(Qt::BackgroundColorRole)), QBrush(backgroundColor));
QCOMPARE(qvariant_cast<QBrush>(item.data(Qt::BackgroundRole)), QBrush(backgroundColor));
QCOMPARE(qvariant_cast<QBrush>(item.data(Qt::TextColorRole)), QBrush(textColor));
QCOMPARE(qvariant_cast<QBrush>(item.data(Qt::ForegroundRole)), QBrush(textColor));
QCOMPARE(qvariant_cast<int>(item.data(Qt::CheckStateRole)), int(checkState));
QCOMPARE(qvariant_cast<QString>(item.data(Qt::AccessibleTextRole)), accessibleText);
QCOMPARE(qvariant_cast<QString>(item.data(Qt::AccessibleDescriptionRole)), accessibleDescription);
item.setBackground(pixmap);
QCOMPARE(item.background().texture(), pixmap);
QCOMPARE(qvariant_cast<QBrush>(item.data(Qt::BackgroundRole)).texture(), pixmap);
}
item.setData(QVariant(), Qt::DisplayRole);
item.setData(QVariant(), Qt::DecorationRole);
item.setData(QVariant(), Qt::ToolTipRole);
item.setData(QVariant(), Qt::StatusTipRole);
item.setData(QVariant(), Qt::WhatsThisRole);
item.setData(QVariant(), Qt::SizeHintRole);
item.setData(QVariant(), Qt::FontRole);
item.setData(QVariant(), Qt::TextAlignmentRole);
item.setData(QVariant(), Qt::BackgroundRole);
item.setData(QVariant(), Qt::ForegroundRole);
item.setData(QVariant(), Qt::CheckStateRole);
item.setData(QVariant(), Qt::AccessibleTextRole);
item.setData(QVariant(), Qt::AccessibleDescriptionRole);
QCOMPARE(item.data(Qt::DisplayRole), QVariant());
QCOMPARE(item.data(Qt::DecorationRole), QVariant());
QCOMPARE(item.data(Qt::ToolTipRole), QVariant());
QCOMPARE(item.data(Qt::StatusTipRole), QVariant());
QCOMPARE(item.data(Qt::WhatsThisRole), QVariant());
QCOMPARE(item.data(Qt::SizeHintRole), QVariant());
QCOMPARE(item.data(Qt::FontRole), QVariant());
QCOMPARE(item.data(Qt::TextAlignmentRole), QVariant());
QCOMPARE(item.data(Qt::BackgroundColorRole), QVariant());
QCOMPARE(item.data(Qt::BackgroundRole), QVariant());
QCOMPARE(item.data(Qt::TextColorRole), QVariant());
QCOMPARE(item.data(Qt::ForegroundRole), QVariant());
QCOMPARE(item.data(Qt::CheckStateRole), QVariant());
QCOMPARE(item.data(Qt::AccessibleTextRole), QVariant());
QCOMPARE(item.data(Qt::AccessibleDescriptionRole), QVariant());
}
}
void PreferencesDialog::InitWaveInfo()
{
QHash<MachineType, int> toprows;
waveModel->clear();
machlevel.clear();
toprows.clear();
QStringList headers;
headers.append(tr("Name"));
headers.append(tr("Color"));
headers.append(tr("Overview"));
headers.append(tr("Lower"));
headers.append(tr("Upper"));
headers.append(tr("Label"));
headers.append(tr("Details"));
waveModel->setHorizontalHeaderLabels(headers);
ui->waveView->setColumnWidth(0, 200);
ui->waveView->setColumnWidth(1, 40);
ui->waveView->setColumnWidth(2, 60);
ui->waveView->setColumnWidth(3, 50);
ui->waveView->setColumnWidth(4, 50);
ui->waveView->setColumnWidth(5, 100);
ui->waveView->setSelectionMode(QAbstractItemView::SingleSelection);
ui->waveView->setSelectionBehavior(QAbstractItemView::SelectItems);
waveModel->setColumnCount(7);
QStandardItem *hdr = nullptr;
QMap<MachineType, QString> Section;
Section[MT_CPAP] = tr("CPAP Waveforms");
Section[MT_OXIMETER] = tr("Oximeter Waveforms");
Section[MT_POSITION] = tr("Positional Waveforms");
Section[MT_SLEEPSTAGE] = tr("Sleep Stage Waveforms");
QMap<MachineType, QString>::iterator it;
for (it = Section.begin(); it != Section.end(); ++it) {
machlevel[it.key()] = hdr = new QStandardItem(it.value());
hdr->setEditable(false);
QList<QStandardItem *> list;
list.append(hdr);
for (int i=0; i<6; i++) {
QStandardItem *it = new QStandardItem();
it->setEnabled(false);
list.append(it);
}
waveModel->appendRow(list);
}
ui->waveView->setAlternatingRowColors(true);
// ui->graphView->setFirstColumnSpanned(0,daily->index(),true); // Crashes on windows.. Why do I need this again?
QHash<QString, schema::Channel *>::iterator ci;
SpinBoxDelegate * spinbox = new SpinBoxDelegate(ui->waveView);
ui->waveView->setItemDelegateForColumn(3,spinbox);
ui->waveView->setItemDelegateForColumn(4,spinbox);
int row = 0;
for (ci = schema::channel.names.begin(); ci != schema::channel.names.end(); ci++) {
schema::Channel * chan = ci.value();
if (chan->type() != schema::WAVEFORM) continue;
QList<QStandardItem *> items;
QStandardItem *it = new QStandardItem(chan->fullname());
it->setCheckable(true);
it->setCheckState(chan->enabled() ? Qt::Checked : Qt::Unchecked);
it->setEditable(true);
it->setData(chan->id(), Qt::UserRole);
it->setToolTip(tr("Double click to change the descriptive name this channel."));
items.push_back(it);
it = new QStandardItem();
it->setBackground(QBrush(chan->defaultColor()));
it->setEditable(false);
it->setData(chan->defaultColor().rgba(), Qt::UserRole);
it->setToolTip(tr("Double click to change the default color for this channel plot/flag/data."));
it->setSelectable(false);
items.push_back(it);
it = new QStandardItem();
it->setCheckable(true);
it->setCheckState(chan->showInOverview() ? Qt::Checked : Qt::Unchecked);
it->setEditable(true);
it->setData(chan->id(), Qt::UserRole);
it->setToolTip(tr("Whether a breakdown of this waveform displays in overview."));
items.push_back(it);
it = new QStandardItem(QString::number(chan->lowerThreshold(),'f',1));
it->setToolTip(tr("Here you can set the <b>lower</b> threshold used for certain calculations on the %1 waveform").arg(chan->fullname()));
it->setEditable(true);
items.push_back(it);
it = new QStandardItem(QString::number(chan->upperThreshold(),'f',1));
it->setToolTip(tr("Here you can set the <b>upper</b> threshold used for certain calculations on the %1 waveform").arg(chan->fullname()));
it->setEditable(true);
items.push_back(it);
it = new QStandardItem(chan->label());
it->setToolTip(tr("This is the short-form label to indicate this channel on screen."));
it->setEditable(true);
items.push_back(it);
it = new QStandardItem(chan->description());
it->setToolTip(tr("This is a description of what this channel does."));
it->setEditable(true);
items.push_back(it);
row = toprows[chan->machtype()]++;
machlevel[chan->machtype()]->insertRow(row, items);
}
for(QHash<MachineType, QStandardItem *>::iterator i = machlevel.begin(); i != machlevel.end(); ++i) {
if (i.value()->rowCount() == 0) {
waveModel->removeRow(i.value()->row());
}
}
ui->waveView->expandAll();
ui->waveView->setSortingEnabled(true);
}
void Peers::event_notify(WpaMsg msg)
{
QString text = msg.getMsg();
if (text.startsWith(WPS_EVENT_PIN_NEEDED)) {
/*
* WPS-PIN-NEEDED 5a02a5fa-9199-5e7c-bc46-e183d3cb32f7
* 02:2a:c4:18:5b:f3
* [Wireless Client|Company|cmodel|123|12345|1-0050F204-1]
*/
QStringList items = text.split(' ');
QString uuid = items[1];
QString addr = items[2];
QString name = "";
QStandardItem *item = find_addr(addr);
if (item)
return;
int pos = text.indexOf('[');
if (pos >= 0) {
int pos2 = text.lastIndexOf(']');
if (pos2 >= pos) {
items = text.mid(pos + 1, pos2 - pos - 1).
split('|');
name = items[0];
items.append(addr);
}
}
item = new QStandardItem(*laptop_icon, name);
if (item) {
item->setData(addr, peer_role_address);
item->setData(PEER_TYPE_WPS_PIN_NEEDED,
peer_role_type);
item->setToolTip(ItemType(PEER_TYPE_WPS_PIN_NEEDED));
item->setData(items.join("\n"), peer_role_details);
item->setData(items[5], peer_role_pri_dev_type);
model.appendRow(item);
}
return;
}
if (text.startsWith(AP_STA_CONNECTED)) {
/* AP-STA-CONNECTED 02:2a:c4:18:5b:f3 */
QStringList items = text.split(' ');
QString addr = items[1];
QStandardItem *item = find_addr(addr);
if (item == NULL || item->data(peer_role_type).toInt() !=
PEER_TYPE_ASSOCIATED_STATION)
add_single_station(addr.toAscii().constData());
return;
}
if (text.startsWith(AP_STA_DISCONNECTED)) {
/* AP-STA-DISCONNECTED 02:2a:c4:18:5b:f3 */
QStringList items = text.split(' ');
QString addr = items[1];
if (model.rowCount() == 0)
return;
QModelIndexList lst = model.match(model.index(0, 0),
peer_role_address, addr, -1);
for (int i = 0; i < lst.size(); i++) {
QStandardItem *item = model.itemFromIndex(lst[i]);
if (item && item->data(peer_role_type).toInt() ==
PEER_TYPE_ASSOCIATED_STATION) {
model.removeRow(lst[i].row());
break;
}
}
return;
}
if (text.startsWith(P2P_EVENT_DEVICE_FOUND)) {
/*
* P2P-DEVICE-FOUND 02:b5:64:63:30:63
* p2p_dev_addr=02:b5:64:63:30:63 pri_dev_type=1-0050f204-1
* name='Wireless Client' config_methods=0x84 dev_capab=0x21
* group_capab=0x0
*/
QStringList items =
text.split(QRegExp(" (?=[^']*('[^']*'[^']*)*$)"));
QString addr = items[1];
QString name = "";
QString pri_dev_type;
int config_methods = 0;
for (int i = 0; i < items.size(); i++) {
QString str = items.at(i);
if (str.startsWith("name='"))
name = str.section('\'', 1, -2);
else if (str.startsWith("config_methods="))
config_methods =
str.section('=', 1).toInt(0, 0);
else if (str.startsWith("pri_dev_type="))
pri_dev_type = str.section('=', 1);
}
QStandardItem *item = find_addr(addr);
if (item) {
int type = item->data(peer_role_type).toInt();
if (type == PEER_TYPE_P2P)
return;
}
item = new QStandardItem(*default_icon, name);
if (item) {
item->setData(addr, peer_role_address);
item->setData(config_methods,
peer_role_config_methods);
item->setData(PEER_TYPE_P2P, peer_role_type);
if (!pri_dev_type.isEmpty())
item->setData(pri_dev_type,
peer_role_pri_dev_type);
item->setData(items.join(QString("\n")),
peer_role_details);
item->setToolTip(ItemType(PEER_TYPE_P2P));
model.appendRow(item);
}
item = find_addr_type(addr,
PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT);
if (item)
item->setBackground(Qt::NoBrush);
}
if (text.startsWith(P2P_EVENT_GROUP_STARTED)) {
/* P2P-GROUP-STARTED wlan0-p2p-0 GO ssid="DIRECT-3F"
* passphrase="YOyTkxID" go_dev_addr=02:40:61:c2:f3:b7
* [PERSISTENT] */
QStringList items = text.split(' ');
if (items.size() < 4)
return;
int pos = text.indexOf(" ssid=\"");
if (pos < 0)
return;
QString ssid = text.mid(pos + 7);
pos = ssid.indexOf(" passphrase=\"");
if (pos < 0)
pos = ssid.indexOf(" psk=");
if (pos >= 0)
ssid.truncate(pos);
pos = ssid.lastIndexOf('"');
if (pos >= 0)
ssid.truncate(pos);
QStandardItem *item = new QStandardItem(*group_icon, ssid);
if (item) {
item->setData(PEER_TYPE_P2P_GROUP, peer_role_type);
item->setData(items[1], peer_role_ifname);
QString details;
if (items[2] == "GO") {
details = tr("P2P GO for interface ") +
items[1];
} else {
details = tr("P2P client for interface ") +
items[1];
}
if (text.contains(" [PERSISTENT]"))
details += "\nPersistent group";
item->setData(details, peer_role_details);
item->setToolTip(ItemType(PEER_TYPE_P2P_GROUP));
model.appendRow(item);
}
}
if (text.startsWith(P2P_EVENT_GROUP_REMOVED)) {
/* P2P-GROUP-REMOVED wlan0-p2p-0 GO */
QStringList items = text.split(' ');
if (items.size() < 2)
return;
if (model.rowCount() == 0)
return;
QModelIndexList lst = model.match(model.index(0, 0),
peer_role_ifname, items[1]);
for (int i = 0; i < lst.size(); i++)
model.removeRow(lst[i].row());
return;
}
if (text.startsWith(P2P_EVENT_PROV_DISC_SHOW_PIN)) {
/* P2P-PROV-DISC-SHOW-PIN 02:40:61:c2:f3:b7 12345670 */
QStringList items = text.split(' ');
if (items.size() < 3)
return;
QString addr = items[1];
QString pin = items[2];
QStandardItem *item = find_addr_type(addr, PEER_TYPE_P2P);
if (item == NULL)
return;
item->setData(SEL_METHOD_PIN_LOCAL_DISPLAY,
peer_role_selected_method);
item->setData(pin, peer_role_selected_pin);
QVariant var = item->data(peer_role_requested_method);
if (var.isValid() &&
var.toInt() == SEL_METHOD_PIN_LOCAL_DISPLAY) {
ctx_item = item;
ctx_p2p_display_pin_pd();
}
return;
}
if (text.startsWith(P2P_EVENT_PROV_DISC_ENTER_PIN)) {
/* P2P-PROV-DISC-ENTER-PIN 02:40:61:c2:f3:b7 */
QStringList items = text.split(' ');
if (items.size() < 2)
return;
QString addr = items[1];
QStandardItem *item = find_addr_type(addr, PEER_TYPE_P2P);
if (item == NULL)
return;
item->setData(SEL_METHOD_PIN_PEER_DISPLAY,
peer_role_selected_method);
QVariant var = item->data(peer_role_requested_method);
if (var.isValid() &&
var.toInt() == SEL_METHOD_PIN_PEER_DISPLAY) {
ctx_item = item;
ctx_p2p_connect();
}
return;
}
if (text.startsWith(P2P_EVENT_INVITATION_RECEIVED)) {
/* P2P-INVITATION-RECEIVED sa=02:f0:bc:44:87:62 persistent=4 */
QStringList items = text.split(' ');
if (items.size() < 3)
return;
if (!items[1].startsWith("sa=") ||
!items[2].startsWith("persistent="))
return;
QString addr = items[1].mid(3);
int id = items[2].mid(11).toInt();
char cmd[100];
char reply[100];
size_t reply_len;
snprintf(cmd, sizeof(cmd), "GET_NETWORK %d ssid", id);
reply_len = sizeof(reply) - 1;
if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0)
return;
reply[reply_len] = '\0';
QString name;
char *pos = strrchr(reply, '"');
if (pos && reply[0] == '"') {
*pos = '\0';
name = reply + 1;
} else
name = reply;
QStandardItem *item;
item = find_addr_type(addr, PEER_TYPE_P2P_INVITATION);
if (item)
model.removeRow(item->row());
item = new QStandardItem(*invitation_icon, name);
if (!item)
return;
item->setData(PEER_TYPE_P2P_INVITATION, peer_role_type);
item->setToolTip(ItemType(PEER_TYPE_P2P_INVITATION));
item->setData(addr, peer_role_address);
item->setData(id, peer_role_network_id);
model.appendRow(item);
enable_persistent(id);
return;
}
if (text.startsWith(P2P_EVENT_INVITATION_RESULT)) {
/* P2P-INVITATION-RESULT status=1 */
/* TODO */
return;
}
if (text.startsWith(WPS_EVENT_ER_AP_ADD)) {
/*
* WPS-ER-AP-ADD 87654321-9abc-def0-1234-56789abc0002
* 02:11:22:33:44:55 pri_dev_type=6-0050F204-1 wps_state=1
* |Very friendly name|Company|Long description of the model|
* WAP|http://w1.fi/|http://w1.fi/hostapd/
*/
QStringList items = text.split(' ');
if (items.size() < 5)
return;
QString uuid = items[1];
QString addr = items[2];
QString pri_dev_type = items[3].mid(13);
int wps_state = items[4].mid(10).toInt();
int pos = text.indexOf('|');
if (pos < 0)
return;
items = text.mid(pos + 1).split('|');
if (items.size() < 1)
return;
QStandardItem *item = find_uuid(uuid);
if (item)
return;
item = new QStandardItem(*ap_icon, items[0]);
if (item) {
item->setData(uuid, peer_role_uuid);
item->setData(addr, peer_role_address);
int type = wps_state == 2 ? PEER_TYPE_WPS_ER_AP:
PEER_TYPE_WPS_ER_AP_UNCONFIGURED;
item->setData(type, peer_role_type);
item->setToolTip(ItemType(type));
item->setData(pri_dev_type, peer_role_pri_dev_type);
item->setData(items.join(QString("\n")),
peer_role_details);
model.appendRow(item);
}
return;
}
if (text.startsWith(WPS_EVENT_ER_AP_REMOVE)) {
/* WPS-ER-AP-REMOVE 87654321-9abc-def0-1234-56789abc0002 */
QStringList items = text.split(' ');
if (items.size() < 2)
return;
if (model.rowCount() == 0)
return;
QModelIndexList lst = model.match(model.index(0, 0),
peer_role_uuid, items[1]);
for (int i = 0; i < lst.size(); i++) {
QStandardItem *item = model.itemFromIndex(lst[i]);
if (item &&
(item->data(peer_role_type).toInt() ==
PEER_TYPE_WPS_ER_AP ||
item->data(peer_role_type).toInt() ==
PEER_TYPE_WPS_ER_AP_UNCONFIGURED))
model.removeRow(lst[i].row());
}
return;
}
if (text.startsWith(WPS_EVENT_ER_ENROLLEE_ADD)) {
/*
* WPS-ER-ENROLLEE-ADD 2b7093f1-d6fb-5108-adbb-bea66bb87333
* 02:66:a0:ee:17:27 M1=1 config_methods=0x14d dev_passwd_id=0
* pri_dev_type=1-0050F204-1
* |Wireless Client|Company|cmodel|123|12345|
*/
QStringList items = text.split(' ');
if (items.size() < 3)
return;
QString uuid = items[1];
QString addr = items[2];
QString pri_dev_type = items[6].mid(13);
int config_methods = -1;
int dev_passwd_id = -1;
for (int i = 3; i < items.size(); i++) {
int pos = items[i].indexOf('=') + 1;
if (pos < 1)
continue;
QString val = items[i].mid(pos);
if (items[i].startsWith("config_methods=")) {
config_methods = val.toInt(0, 0);
} else if (items[i].startsWith("dev_passwd_id=")) {
dev_passwd_id = val.toInt();
}
}
int pos = text.indexOf('|');
if (pos < 0)
return;
items = text.mid(pos + 1).split('|');
if (items.size() < 1)
return;
QString name = items[0];
if (name.length() == 0)
name = addr;
remove_enrollee_uuid(uuid);
QStandardItem *item;
item = new QStandardItem(*laptop_icon, name);
if (item) {
item->setData(uuid, peer_role_uuid);
item->setData(addr, peer_role_address);
item->setData(PEER_TYPE_WPS_ER_ENROLLEE,
peer_role_type);
item->setToolTip(ItemType(PEER_TYPE_WPS_ER_ENROLLEE));
item->setData(items.join(QString("\n")),
peer_role_details);
item->setData(pri_dev_type, peer_role_pri_dev_type);
if (config_methods >= 0)
item->setData(config_methods,
peer_role_config_methods);
if (dev_passwd_id >= 0)
item->setData(dev_passwd_id,
peer_role_dev_passwd_id);
model.appendRow(item);
}
return;
}
if (text.startsWith(WPS_EVENT_ER_ENROLLEE_REMOVE)) {
/*
* WPS-ER-ENROLLEE-REMOVE 2b7093f1-d6fb-5108-adbb-bea66bb87333
* 02:66:a0:ee:17:27
*/
QStringList items = text.split(' ');
if (items.size() < 2)
return;
remove_enrollee_uuid(items[1]);
return;
}
if (text.startsWith(WPS_EVENT_ENROLLEE_SEEN)) {
/* TODO: need to time out this somehow or remove on successful
* WPS run, etc. */
/*
* WPS-ENROLLEE-SEEN 02:00:00:00:01:00
* 572cf82f-c957-5653-9b16-b5cfb298abf1 1-0050F204-1 0x80 4 1
* [Wireless Client]
* (MAC addr, UUID-E, pri dev type, config methods,
* dev passwd id, request type, [dev name])
*/
QStringList items = text.split(' ');
if (items.size() < 7)
return;
QString addr = items[1];
QString uuid = items[2];
QString pri_dev_type = items[3];
int config_methods = items[4].toInt(0, 0);
int dev_passwd_id = items[5].toInt();
QString name;
QStandardItem *item = find_addr(addr);
if (item) {
int type = item->data(peer_role_type).toInt();
if (type == PEER_TYPE_ASSOCIATED_STATION)
return; /* already associated */
}
int pos = text.indexOf('[');
if (pos >= 0) {
int pos2 = text.lastIndexOf(']');
if (pos2 >= pos) {
QStringList items2 =
text.mid(pos + 1, pos2 - pos - 1).
split('|');
name = items2[0];
}
}
if (name.isEmpty())
name = addr;
item = find_uuid(uuid);
if (item) {
QVariant var = item->data(peer_role_config_methods);
QVariant var2 = item->data(peer_role_dev_passwd_id);
if ((var.isValid() && config_methods != var.toInt()) ||
(var2.isValid() && dev_passwd_id != var2.toInt()))
remove_enrollee_uuid(uuid);
else
return;
}
item = new QStandardItem(*laptop_icon, name);
if (item) {
item->setData(uuid, peer_role_uuid);
item->setData(addr, peer_role_address);
item->setData(PEER_TYPE_WPS_ENROLLEE,
peer_role_type);
item->setToolTip(ItemType(PEER_TYPE_WPS_ENROLLEE));
item->setData(items.join(QString("\n")),
peer_role_details);
item->setData(pri_dev_type, peer_role_pri_dev_type);
item->setData(config_methods,
peer_role_config_methods);
item->setData(dev_passwd_id, peer_role_dev_passwd_id);
model.appendRow(item);
}
return;
}
if (text.startsWith(WPA_EVENT_BSS_ADDED)) {
/* CTRL-EVENT-BSS-ADDED 34 00:11:22:33:44:55 */
QStringList items = text.split(' ');
if (items.size() < 2)
return;
char cmd[20];
snprintf(cmd, sizeof(cmd), "BSS ID-%d", items[1].toInt());
add_bss(cmd);
return;
}
if (text.startsWith(WPA_EVENT_BSS_REMOVED)) {
/* CTRL-EVENT-BSS-REMOVED 34 00:11:22:33:44:55 */
QStringList items = text.split(' ');
if (items.size() < 2)
return;
remove_bss(items[1].toInt());
return;
}
}
void TrackListView::populateTable()/*{{{*/
{
if(debugMsg)
printf("TrackListView::populateTable\n");
QScrollBar *bar = m_table->verticalScrollBar();
int barPos = 0;
if(bar)
barPos = bar->sliderPosition();
m_model->clear();
for(iMidiTrack i = song->artracks()->begin(); i != song->artracks()->end(); ++i)
{
MidiTrack* track = (MidiTrack*)(*i);
PartList* pl = track->parts();
if(m_displayRole == PartRole && pl->empty())
{
continue;
}
QStandardItem* trackName = new QStandardItem();
trackName->setForeground(QBrush(QColor(205,209,205)));
trackName->setBackground(QBrush(QColor(20,20,20)));
trackName->setFont(QFont("fixed-width", 10, QFont::Bold));
trackName->setText(track->name());
trackName->setCheckable(true);
trackName->setCheckState(m_selectedTracks.contains(track->id()) ? Qt::Checked : Qt::Unchecked);
trackName->setTextAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
trackName->setData(1, TrackRole);
trackName->setData(track->name(), TrackNameRole);
trackName->setData(track->id(), TrackIdRole);
trackName->setEditable(true);
m_model->appendRow(trackName);
for(iPart ip = pl->begin(); ip != pl->end(); ++ip)
{
Part* part = ip->second;
QStandardItem* partName = new QStandardItem();
partName->setFont(QFont("fixed-width", 9, QFont::Bold));
partName->setText(part->name());
partName->setData(part->sn(), PartRole);
partName->setData(2, TrackRole);
partName->setData(track->name(), TrackNameRole);
partName->setData(part->name(), PartNameRole);
partName->setData(part->tick(), TickRole);
partName->setData(track->id(), TrackIdRole);
partName->setEditable(true);
partName->setCheckable(true);
partName->setCheckState(m_editor->hasPart(part->sn()) ? Qt::Checked : Qt::Unchecked);
if(!partColorIcons.isEmpty() && part->colorIndex() < partColorIcons.size())
partName->setIcon(partColorIcons.at(part->colorIndex()));
m_model->appendRow(partName);
}
}
m_model->setHorizontalHeaderLabels(m_headers);
if(m_selectedIndex < m_model->rowCount())
{
m_table->selectRow(m_selectedIndex);
m_table->scrollTo(m_model->index(m_selectedIndex, 0));
}
if(bar)
bar->setSliderPosition(barPos);
}/*}}}*/
void PreferencesDialog::InitChanInfo()
{
QHash<MachineType, int> toprows;
chanModel->clear();
toplevel.clear();
toprows.clear();
QStringList headers;
headers.append(tr("Name"));
headers.append(tr("Color"));
headers.append(tr("Overview"));
headers.append(tr("Flag Type"));
headers.append(tr("Label"));
headers.append(tr("Details"));
chanModel->setHorizontalHeaderLabels(headers);
ui->chanView->setColumnWidth(0, 200);
ui->chanView->setColumnWidth(1, 40);
ui->chanView->setColumnWidth(2, 60);
ui->chanView->setColumnWidth(3, 100);
ui->chanView->setColumnWidth(4, 100);
ui->chanView->setSelectionMode(QAbstractItemView::SingleSelection);
ui->chanView->setSelectionBehavior(QAbstractItemView::SelectItems);
chanModel->setColumnCount(6);
QStandardItem *hdr = nullptr;
QMap<MachineType, QString> Section;
Section[MT_CPAP] = tr("CPAP Events");
Section[MT_OXIMETER] = tr("Oximeter Events");
Section[MT_POSITION] = tr("Positional Events");
Section[MT_SLEEPSTAGE] = tr("Sleep Stage Events");
Section[MT_UNCATEGORIZED] = tr("Unknown Events");
QMap<MachineType, QString>::iterator it;
QHash<QString, schema::Channel *>::iterator ci;
for (it = Section.begin(); it != Section.end(); ++it) {
toplevel[it.key()] = hdr = new QStandardItem(it.value());
hdr->setEditable(false);
QList<QStandardItem *> list;
list.append(hdr);
for (int i=0; i<5; i++) {
QStandardItem *it = new QStandardItem();
it->setEnabled(false);
list.append(it);
}
chanModel->appendRow(list);
}
ui->chanView->setAlternatingRowColors(true);
// ui->graphView->setFirstColumnSpanned(0,daily->index(),true); // Crashes on windows.. Why do I need this again?
ComboBoxDelegate * combobox = new ComboBoxDelegate(ui->waveView);
ui->chanView->setItemDelegateForColumn(3,combobox);
int row = 0;
for (ci = schema::channel.names.begin(); ci != schema::channel.names.end(); ci++) {
schema::Channel * chan = ci.value();
if ((chan->type() == schema::DATA) || (chan->type() == schema::SETTING) || chan->type() == schema::WAVEFORM) continue;
QList<QStandardItem *> items;
QStandardItem *it = new QStandardItem(chan->fullname());
it->setCheckable(true);
it->setCheckState(chan->enabled() ? Qt::Checked : Qt::Unchecked);
it->setEditable(true);
it->setData(chan->id(), Qt::UserRole);
// Dear translators: %1 is a unique ascii english string used to indentify channels in the code, I'd like feedback on how this goes..
// It's here in case users mess up which field is which.. it will always show the Channel Code underneath in the tooltip.
it->setToolTip(tr("Double click to change the descriptive name the '%1' channel.").arg(chan->code()));
items.push_back(it);
it = new QStandardItem();
it->setBackground(QBrush(chan->defaultColor()));
it->setEditable(false);
it->setData(chan->defaultColor().rgba(), Qt::UserRole);
it->setToolTip(tr("Double click to change the default color for this channel plot/flag/data."));
it->setSelectable(false);
items.push_back(it);
it = new QStandardItem(QString());
it->setToolTip(tr("Whether this flag has a dedicated overview chart."));
it->setCheckable(true);
it->setCheckState(chan->showInOverview() ? Qt::Checked : Qt::Unchecked);
it->setTextAlignment(Qt::AlignCenter);
it->setData(chan->id(), Qt::UserRole);
items.push_back(it);
schema::ChanType type = chan->type();
it = new QStandardItem(channeltype[type]);
it->setToolTip(tr("Here you can change the type of flag shown for this event"));
it->setEditable(type != schema::UNKNOWN);
items.push_back(it);
it = new QStandardItem(chan->label());
it->setToolTip(tr("This is the short-form label to indicate this channel on screen."));
it->setEditable(true);
items.push_back(it);
it = new QStandardItem(chan->description());
it->setToolTip(tr("This is a description of what this channel does."));
it->setEditable(true);
items.push_back(it);
MachineType mt = chan->machtype();
if (chan->type() == schema::UNKNOWN) mt = MT_UNCATEGORIZED;
row = toprows[mt]++;
toplevel[mt]->insertRow(row, items);
}
for(QHash<MachineType, QStandardItem *>::iterator i = toplevel.begin(); i != toplevel.end(); ++i) {
if (i.value()->rowCount() == 0) {
chanModel->removeRow(i.value()->row());
}
}
ui->chanView->expandAll();
ui->chanView->setSortingEnabled(true);
}