//-------------------------------------------------------------------------
void GMapDialog::treeDoubleClicked(const QModelIndex &idx)
{
QStandardItem *it = model->itemFromIndex(idx);
int i = waypointIndex(it);
if (i >= 0) {
it->setCheckState(Qt::Checked);
gpx.getWaypoints()[i].setVisible(true);
mapWidget->panTo(gpx.getWaypoints()[i].getLocation());
mapWidget->setWaypointVisibility(i, true);
return;
}
i = trackIndex(it);
if (i >= 0) {
mapWidget->frameTrack(i);
it->setCheckState(Qt::Checked);
gpx.getTracks()[i].setVisible(true);
mapWidget->setTrackVisibility(i, true);
return;
}
i = routeIndex(it);
if (i >= 0) {
mapWidget->frameRoute(i);
it->setCheckState(Qt::Checked);
gpx.getRoutes()[i].setVisible(true);
mapWidget->setRouteVisibility(i, true);
return;
}
}
QStandardItem* getColumnItem(QStandardItem* parent, QString name, T& proxy)
{
QStandardItem* item = NULL;
QList<QStandardItem*> items = findChildItems(parent, name);
if (items.count() == 0)
{
// Create a new item because we did not find this item already
item = new QStandardItem(proxy.name);
item->setCheckState( (proxy.flag == 2 ? Qt::Checked : Qt::Unchecked) );
item->setCheckable(true);
parent->appendRow(item);
}
else if (items.count() > 1)
{
item = NULL;
}
else
{
item = items.at(0);
item->setCheckState( (proxy.flag == 2 ? Qt::Checked : Qt::Unchecked) );
item->setCheckable(true);
}
return item;
}
foreach(QStandardItem *item, mFunctionItems) {
// Only show selected curves
AbstractFunctionPtr function = static_cast<AbstractFunctionPtr>(item->data(Qt::UserRole).value<AbstractFunctionPtr>());
if(function != 0) {
FunctionCurve *c = function->getCurve();
if(c != 0) {
if( c->isAttached(mPlotId) ) {
qDebug() << "curve " << c->getId() << " enabled";
item->setCheckState(Qt::Checked);
} else {
item->setCheckState(Qt::Unchecked);
}
}
}
// Handle item children (subfunctions)
QStandardItem *child = 0;
int i = 0;
while ((child = item->child(i++)) != 0) {
function = child->data(Qt::UserRole).value<AbstractFunctionPtr>();
if(function != 0) {
FunctionCurve *c = function->getCurve();
if(c != 0) {
if( c->isAttached(mPlotId) ) {
qDebug() << "curve " << c->getId() << " enabled";
child->setCheckState(Qt::Checked);
} else {
child->setCheckState(Qt::Unchecked);
}
}
}
}
}
void TrackListView::updateCheck()/*{{{*/
{
for(int i = 0; i < m_model->rowCount(); ++i)
{
QStandardItem* item = m_model->item(i, 0);
if(item)
{
int type = item->data(TrackRole).toInt();
qint64 tid = item->data(TrackIdRole).toLongLong();
QString trackName = item->data(TrackNameRole).toString();
if(type == 1)
{//TrackMode
m_model->blockSignals(true);
if(m_selectedTracks.contains(tid))
item->setCheckState(Qt::Checked);
else
item->setCheckState(Qt::Unchecked);
m_model->blockSignals(false);
}
else
{//PartMode
int sn = item->data(PartRole).toInt();
//printf("Serial no. item: %d, part: %d\n", sn, psn);
m_model->blockSignals(true);
if(m_editor->hasPart(sn))
item->setCheckState(Qt::Checked);
else
item->setCheckState(Qt::Unchecked);
m_model->blockSignals(false);
}
}
}
}/*}}}*/
void SchemaEditorDialog::syncMessageViewWithFieldView()
{
QStandardItem *item;
QBaseEntry * qbe;
if (fieldItems.count() < 1) {
qWarning() << "Nothing to do for FieldView Sync " << __FILE__ << __LINE__;
return;
}
disconnect(fieldsModel,SIGNAL(itemChanged(QStandardItem*)),
this,SLOT(fieldCheckedSlot(QStandardItem *)));
QListIterator <QStandardItem *> iter(fieldItems);
setUpdatesEnabled(false);
while(iter.hasNext()) {
item = iter.next();
item->setCheckState(Qt::Unchecked);
}
QListIterator <QBaseEntry *> iter2(selectedBaseEntryList);
while(iter2.hasNext()) {
qbe = iter2.next();
if (qbe) {
item = fieldItemsMap.find(qbe->name).value();
if (item) {
item->setCheckState(Qt::Checked);
}
}
}
connect(fieldsModel,SIGNAL(itemChanged(QStandardItem*)),
this,SLOT(fieldCheckedSlot(QStandardItem *)));
setUpdatesEnabled(true);
}
void PluginsDialog::appendInfo(const LiteApi::PluginInfo *info)
{
if (!info) {
return;
}
QList<QStandardItem*> items;
items.append(new QStandardItem(info->name()));
QStandardItem *load = new QStandardItem();
load->setCheckable(true);
load->setData(info->id());
if (info->isMustLoad()) {
load->setEnabled(false);
}
bool b = m_liteApp->settings()->value(QString("liteapp/%1_load").arg(info->id()),true).toBool();
if (b) {
load->setCheckState(Qt::Checked);
} else {
load->setCheckState(Qt::Unchecked);
}
items.append(load);
items.append(new QStandardItem(info->info()));
items.append(new QStandardItem(info->author()));
items.append(new QStandardItem(info->ver()));
items.append(new QStandardItem(QFileInfo(info->filePath()).fileName()));
items.at(5)->setToolTip(info->filePath());
m_model->appendRow(items);
}
void KrePropertyListWidget::load(int limit, int offset)
{
//We are not using limits here because usually the number of properties
//in the database will be low, even for large databases.
Q_UNUSED(limit)
Q_UNUSED(offset)
IngredientPropertyList propList;
int numberOfProps = m_database->loadProperties( &propList );
m_sourceModel->setRowCount( numberOfProps );
KConfigGroup config( KGlobal::config(), "Formatting");
QStringList hiddenList = config.readEntry("HiddenProperties", QStringList());
//PropDisplayedDelegate * propDisplayedDelegate = new PropDisplayedDelegate;
//ui->m_treeView->setItemDelegateForColumn(5, propDisplayedDelegate);
kDebug() << hiddenList;
int current_row = 0;
QModelIndex index;
for ( IngredientPropertyList::const_iterator it = propList.constBegin(); it != propList.constEnd(); ++it ) {
// Write the database id in the model.
index = m_sourceModel->index( current_row, 0 );
m_sourceModel->setData( index, QVariant(it->id), Qt::EditRole );
m_sourceModel->itemFromIndex( index )->setEditable( false );
// Write the name of the property in the model.
index = m_sourceModel->index( current_row, 1 );
m_sourceModel->setData( index, QVariant(it->name), Qt::EditRole );
m_sourceModel->itemFromIndex( index )->setEditable( true );
// Write the units the property is using in the model.
index = m_sourceModel->index( current_row, 2 );
m_sourceModel->setData( index, QVariant(it->units), Qt::EditRole );
//FIXME: Property units cannot be edited, this is a bug the database design.
m_sourceModel->itemFromIndex( index )->setEditable( false );
// Item showing if the property is displayed in "show recipe" and printing
QStandardItem * checkItem = new QStandardItem;
checkItem->setCheckable( true );
if ( hiddenList.contains(it->name) ) {
checkItem->setCheckState( Qt::Unchecked );
} else {
checkItem->setCheckState( Qt::Checked );
}
m_sourceModel->setItem( current_row, 3, checkItem );
// Increment the row counter.
++current_row;
}
//For some reason the list isn't ordered after adding that QStandardItem's
//to the model (see above).
m_proxyModel->sort(1);
emit loadFinishedPrivate();
}
void updateModel(QStandardItem* parentItem, ReflectableClass& object, Node* node, const std::string& propertyPrefix = "") {
vector<IClassProperty*> properties = object.getProperties();
for (unsigned i = 0, gridPos = 0; i < properties.size(); ++i) {
if (properties[i]->getAttribute<HideAttribute>())
continue;
QStandardItem* value = parentItem->child(gridPos, 1);
if (!value) {
string keyName = properties[i]->getName();
ShortNameAttribute* shortName = properties[i]->getAttribute<ShortNameAttribute>();
if (shortName)
keyName = keyName + " (" + shortName->getName() + ")";
QStandardItem* key = new QStandardItem(keyName.c_str());
value = new QStandardItem();
parentItem->setChild(gridPos, 0, key);
parentItem->setChild(gridPos, 1, value);
}
IReflectableAttribute* reflectable = properties[i]->getAttribute<IReflectableAttribute>();
if (reflectable) {
ReflectableClass* subObject = reflectable->getValuePtr(object, properties[i]);
// If the type of the reflectable object has changed, the subtree needs to be rebuild.
// You need to know the previous type in order to detect a change. ScalarAttributes are
// no longer supported in order to guarantee, that the string value is always set to the
// previous type name.
if (subObject) {
std::string oldClassName(value->text().toStdString());
if (oldClassName.compare(subObject->getClassName())) {
value->setText(subObject->getClassName().c_str());
buildModel(parentItem->child(gridPos, 0), subObject, node, propertyPrefix + properties[i]->getName() + ".");
} else {
updateModel(parentItem->child(gridPos, 0), *subObject, node, propertyPrefix + properties[i]->getName() + ".");
}
} else {
value->setText(properties[i]->getStringValue(object).c_str());
}
} else if (properties[i]->getAttribute<FlagAttribute>()) {
ClassProperty<bool>* boolProperty = dynamic_cast<ClassProperty<bool>* >(properties[i]);
// properties tagged as Flag() must be of type bool
assert(boolProperty);
if (boolProperty->getValue(object))
value->setCheckState(Qt::Checked);
else
value->setCheckState(Qt::Unchecked);
} else{
value->setText(properties[i]->getStringValue(object).c_str());
}
++gridPos;
}
}
void GlobalSettingsConfig::populateInputs()/*{{{*/
{
m_inputsModel->clear();
QStringList alsaList;
QStringList jackList;
if(gInputList.size())
{
//Select the rows
for(int i = 0; i < gInputList.size(); ++i)
{
QPair<int, QString> input = gInputList.at(i);
if(input.first == MidiDevice::JACK_MIDI)
jackList.append(input.second);
else
alsaList.append(input.second);
}
}
for (iMidiDevice i = midiDevices.begin(); i != midiDevices.end(); ++i)
{
if ((*i)->deviceType() == MidiDevice::ALSA_MIDI)
{
if ((*i)->rwFlags() & 0x2)
{
QStandardItem* item = new QStandardItem(QString((*i)->name()).append(" (ALSA)"));
item->setData((*i)->name(), Qt::UserRole+1);
item->setData(MidiDevice::ALSA_MIDI, Qt::UserRole+2);
item->setEditable(false);
item->setCheckable(true);
if(alsaList.contains((*i)->name()))
item->setCheckState(Qt::Checked);
m_inputsModel->appendRow(item);
}
}
}
if(audioDevice->deviceType() != AudioDevice::JACK_AUDIO)
return;
std::list<QString> sl = audioDevice->outputPorts(true, false);//No aliases
for (std::list<QString>::iterator ip = sl.begin(); ip != sl.end(); ++ip)
{
QStandardItem* item = new QStandardItem(QString(*ip).append(" (JACK)"));
item->setData(*ip, Qt::UserRole+1);
item->setData(MidiDevice::JACK_MIDI, Qt::UserRole+2);
item->setEditable(false);
item->setCheckable(true);
if(jackList.contains(*ip))
item->setCheckState(Qt::Checked);
m_inputsModel->appendRow(item);
}
}/*}}}*/
void TrackListView::updateCheck(PartList* list, bool on)/*{{{*/
{
for(iPart i = list->begin(); i != list->end(); ++i)
{
Part* part = i->second;
//QList<QStandardItem*> found = m_model->findItems(part->name(), Qt::MatchExactly, 1);
for(int r = 0; r < m_model->rowCount(); ++r)
{
QStandardItem* item = m_model->item(r);
if(item)
{
int type = item->data(TrackRole).toInt();
if(type == 1)
continue;
int sn = item->data(PartRole).toInt();
int psn = part->sn();
//printf("Serial no. item: %d, part: %d\n", sn, psn);
if(sn == psn)
{
//printf("Updating item\n");
m_model->blockSignals(true);
item->setCheckState(on ? Qt::Checked : Qt::Unchecked);
m_model->blockSignals(false);
break;
}
}
}
}
m_table->update();
}/*}}}*/
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);
}
}
QStandardItem *GoodsTVStandardItemModel::createCheckedItem() {
QStandardItem* item = new QStandardItem(true);
item->setCheckable(true);
item->setCheckState(Qt::Unchecked);
item->setEditable(false);
return item;
}
/////////////////////////////////////////
// add new item
void CComDlg::on_pushButton_6_clicked()
/////////////////////////////////////////
{
comet_t a;
CComEdit dlg(this, true, &a);
if (dlg.exec() == DL_OK)
{
if (a.perihelionDate < minJD) minJD = a.perihelionDate;
if (a.perihelionDate > maxJD) maxJD = a.perihelionDate;
QStandardItemModel *model = (QStandardItemModel *)ui->listView->model();
QStandardItem *item = new QStandardItem;
a.selected = true;
item->setText(a.name);
item->setCheckable(true);
item->setCheckState(a.selected ? Qt::Checked : Qt::Unchecked);
item->setEditable(false);
model->appendRow(item);
tComets.append(a);
}
}
void ShowConfigDialog::reloadSettings ()
{
QSettings settings (QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_Sidebar");
settings.beginGroup (Context_);
const int size = settings.beginReadArray ("Actions");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex (i);
const auto& icon = settings.value ("Icon").value<QIcon> ();
QStandardItem *item = new QStandardItem (icon,
settings.value ("Text").toString ());
item->setCheckState (settings.value ("Enabled").toBool () ?
Qt::Checked :
Qt::Unchecked);
item->setToolTip (settings.value ("Tooltip").toString ());
item->setData (settings.value ("ID"), Roles::ActionID);
item->setCheckable (true);
item->setEditable (false);
Model_->appendRow (item);
}
settings.endArray ();
settings.endGroup ();
}
void ImageContainerWidget::addImage(const cv::Mat& image)
{
qDebug() << "saving image";
// push back image towards container
_images.push_back(image);
// save image to file
QString filename;
filename = "cali_images/image_" + QString::number(_images.size()) + ".png";
cv::imwrite(filename.toStdString(), image);
QStandardItemModel *model = static_cast<QStandardItemModel*>(_ui->tableView->model());
QStandardItem* item = new QStandardItem(filename);
item->setCheckable(true);
item->setCheckState(Qt::Checked);
model->setItem(_images.size(), 0, item);
for(unsigned int i=0 ; i<model->rowCount() ; i++)
{
QStandardItem* itemToCheck = model->item(i);
}
}
void PluginDialog::parsePluginNode(QDomNode node)
{
QString name = node.firstChildElement("name").text();
QString shortname = node.firstChildElement("shortname").text();
QString iconUrl = node.firstChildElement("icon").text();
QString category = node.firstChildElement("category").text();
QString downloadUrl = node.firstChildElement("download").text();
QString version = node.firstChildElement("version").text();
QIcon icon = NetworkUtils::getIconFromUrl(QUrl(iconUrl));
QList<QStandardItem *> rowItems;
QStandardItem* pluginItem = new QStandardItem(icon, name);
pluginItem->setData(shortname, Qt::UserRole);
pluginItem->setData(downloadUrl, Qt::UserRole + 1);
pluginItem->setData(version, Qt::UserRole + 2);
rowItems << pluginItem;
QStandardItem* enableItem = new QStandardItem("");
enableItem->setCheckable(true);
if(pluginManager->isInstalled(shortname))
{
enableItem->setCheckState(Qt::Checked);
}
rowItems << enableItem;
if(category != "local")
{
categoryOnline->appendRow(rowItems);
}else
{
categoryLocal->appendRow(rowItems);
}
}
void CComDlg::fillList()
//////////////////////////
{
QStandardItemModel *model = (QStandardItemModel *)ui->listView->model();
model->removeRows(0, model->rowCount());
setCursor(Qt::WaitCursor);
QApplication::processEvents();
for (int i = 0; i < tComets.count(); i++)
{
comet_t *a = &tComets[i];
QStandardItem *item = new QStandardItem;
item->setText(a->name);
item->setCheckable(true);
item->setCheckState(a->selected ? Qt::Checked : Qt::Unchecked);
item->setEditable(false);
model->appendRow(item);
if ((i % 10000) == 0)
QApplication::processEvents();
}
setCursor(Qt::ArrowCursor);
}
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 tCZoneModesModel::OnDataChanged()
{
bool modeChanged = false;
for ( int row=0; row < rowCount(); ++row )
{
QStandardItem* pItem = item( row );
if (pItem != 0)
{
bool ok;
int index = pItem->data( INDEX_ROLE ).toInt( &ok );
if ( ok )
{
tDigitalData state( tDataId( DATA_TYPE_SWITCH_STATE, index, DATA_ENGINE_CZONE_SELECTION ) );
Qt::CheckState checkState = Qt::Unchecked;
if ( state.Value() > 0 )
{
checkState = Qt::Checked;
}
Qt::CheckState oldCheckState = pItem->checkState();
pItem->setCheckState( checkState );
if ( oldCheckState != checkState )
{
modeChanged = true;
}
}
}
}
if ( modeChanged )
{
emit ModeChanged();
}
}
void PluginChoooserWidget::onItemClicked(QModelIndex index)
{
QStandardItem *item = m_model->itemFromIndex(index);
if (item) {
item->setCheckState(item->checkState() == Qt::Unchecked ? Qt::Checked : Qt::Unchecked);
}
}
QStandardItem *ResultsTree::CreateCheckboxItem(bool checked)
{
QStandardItem *item = new QStandardItem;
item->setCheckable(true);
item->setCheckState(checked ? Qt::Checked : Qt::Unchecked);
item->setEnabled(false);
return item;
}
void ActionModel::setItems(QDesignerFormEditorInterface *core, QAction *action,
const QIcon &defaultIcon,
QStandardItemList &sl)
{
// Tooltip, mostly for icon view mode
QString firstTooltip = action->objectName();
const QString text = action->text();
if (!text.isEmpty()) {
firstTooltip += QLatin1Char('\n');
firstTooltip += text;
}
Q_ASSERT(sl.size() == NumColumns);
QStandardItem *item = sl[NameColumn];
item->setText(action->objectName());
QIcon icon = action->icon();
if (icon.isNull())
icon = defaultIcon;
item->setIcon(icon);
item->setToolTip(firstTooltip);
item->setWhatsThis(firstTooltip);
// Used
const QWidgetList associatedDesignerWidgets = associatedWidgets(action);
const bool used = !associatedDesignerWidgets.empty();
item = sl[UsedColumn];
item->setCheckState(used ? Qt::Checked : Qt::Unchecked);
if (used) {
QString usedToolTip;
const QString separator = QLatin1String(", ");
const int count = associatedDesignerWidgets.size();
for (int i = 0; i < count; i++) {
if (i)
usedToolTip += separator;
usedToolTip += associatedDesignerWidgets.at(i)->objectName();
}
item->setToolTip(usedToolTip);
} else {
item->setToolTip(QString());
}
// text
item = sl[TextColumn];
item->setText(action->text());
item->setToolTip(action->text());
// shortcut
const QString shortcut = actionShortCut(core, action).value().toString(QKeySequence::NativeText);
item = sl[ShortCutColumn];
item->setText(shortcut);
item->setToolTip(shortcut);
// checkable
sl[CheckedColumn]->setCheckState(action->isCheckable() ? Qt::Checked : Qt::Unchecked);
// ToolTip. This might be multi-line, rich text
QString toolTip = action->toolTip();
item = sl[ToolTipColumn];
item->setToolTip(toolTip);
item->setText(toolTip.replace(QLatin1Char('\n'), QLatin1Char(' ')));
}
QList<QStandardItem *> TreeItem::get_list_representation(const TreeItemViewFormat & view_format)
{
// http://www.qtforum.org/article/34069/store-user-data-void-with-qstandarditem-in-qstandarditemmodel.html
QList<QStandardItem *> items;
QVariant variant;
const QString tooltip = this->get_tooltip();
for (const TreeItemViewColumn & col : view_format.columns) {
QStandardItem * item = NULL;
switch (col.id) {
case TreeItemPropertyID::TheItem:
item = new QStandardItem(this->name);
item->setToolTip(tooltip);
item->setEditable(this->editable);
variant = QVariant::fromValue(this);
item->setData(variant, RoleLayerData);
if (!this->icon.isNull()) { /* Icon can be set with ::apply_tree_item_icon(). */
item->setIcon(this->icon);
}
//item->moveToThread(QApplication::instance()->thread())
items << item;
break;
case TreeItemPropertyID::Visibility:
item = new QStandardItem();
item->setCheckable(true);
item->setCheckState(this->visible ? Qt::Checked : Qt::Unchecked);
//item->moveToThread(QApplication::instance()->thread())
items << item;
break;
case TreeItemPropertyID::Editable:
item = new QStandardItem();
variant = QVariant::fromValue(this->editable);
item->setData(variant, RoleLayerData);
//item->moveToThread(QApplication::instance()->thread())
items << item;
break;
case TreeItemPropertyID::Timestamp:
/* Value in this column can be set with ::apply_tree_item_timestamp(). */
item = new QStandardItem(this->timestamp.get_value());
//item->moveToThread(QApplication::instance()->thread())
items << item;
break;
default:
qDebug() << SG_PREFIX_N << "Unexpected tree item column id" << (int) col.id;
break;
}
}
return items;
}
// Returns the root tree item containing the whole datapack information
QStandardItem *packToItem(const QString &absPathToDescriptionFile, const PackCreationQueue &queue)
{
// Read datapack description file
DataPack::Pack pack;
pack.fromXmlFile(absPathToDescriptionFile);
// Create datapack items
QStandardItem *packItem = new QStandardItem(pack.name());
QFont bold;
bold.setBold(true);
packItem->setFont(bold);
packItem->setCheckable(true);
packItem->setCheckState(Qt::Checked);
QStandardItem *item = 0;
item = new QStandardItem(tkTr(Trans::Constants::_1_COLON_2)
.arg(tkTr(Trans::Constants::TYPE))
.arg(pack.dataTypeName()));
item->setToolTip(item->text());
packItem->appendRow(item);
item = new QStandardItem(tkTr(Trans::Constants::_1_COLON_2)
.arg(tkTr(Trans::Constants::LICENSE))
.arg(pack.description().data(PackDescription::LicenseName).toString()));
item->setToolTip(item->text());
packItem->appendRow(item);
item = new QStandardItem(tkTr(Trans::Constants::_1_COLON_2)
.arg(tkTr(Trans::Constants::VERSION))
.arg(pack.version()));
item->setToolTip(item->text());
packItem->appendRow(item);
item = new QStandardItem(tkTr(Trans::Constants::_1_COLON_2)
.arg(tkTr(Trans::Constants::VENDOR))
.arg(pack.vendor()));
item->setToolTip(item->text());
packItem->appendRow(item);
item = new QStandardItem(tkTr(Trans::Constants::_1_COLON_2)
.arg(tkTr(Trans::Constants::CREATION_DATE_TIME))
.arg(QLocale().toString(pack.description().data(PackDescription::CreationDate).toDate())));
item->setToolTip(item->text());
packItem->appendRow(item);
item = new QStandardItem(tkTr(Trans::Constants::_1_COLON_2)
.arg(tkTr(Trans::Constants::LAST_MODIFICATION))
.arg(QLocale().toString(pack.description().data(PackDescription::LastModificationDate).toDate())));
item->setToolTip(item->text());
packItem->appendRow(item);
if (_format == PackCreationModel::ShowByServer) {
item = new QStandardItem(tkTr(Trans::Constants::_1_COLON_2)
.arg(tkTr(Trans::Constants::QUEUE))
.arg(queue.sourceAbsolutePathFile()));
item->setToolTip(item->text());
packItem->appendRow(item);
}
_packItems.insert(pack.originalXmlConfigFileName(), packItem);
return packItem;
}
void updateModel(QStandardItem* parentItem, const std::string& propertyPrefix = "") {
// Go throw keys of parentItem
for (int iRow = 0; iRow < parentItem->rowCount(); ++iRow) {
QStandardItem* valueItem = parentItem->child(iRow, 1);
if (valueItem && valueItem->data(Qt::UserRole).canConvert<PropertyReference>()) {
PropertyReference ref = valueItem->data(Qt::UserRole).value<PropertyReference>();
IReflectableAttribute* reflectable = ref.getProperty()->getAttribute<IReflectableAttribute>();
if (reflectable) {
ReflectableClass* subObject = reflectable->getValuePtr(*ref.getObject(), ref.getProperty());
// If the type of the reflectable object has changed, the subtree needs to be rebuild.
// You need to know the previous type in order to detect a change. ScalarAttributes are
// no longer supported in order to guarantee, that the string value is always set to the
// previous type name.
if (subObject) {
std::string oldClassName(valueItem->text().toStdString());
if (oldClassName.compare(subObject->getClassName())) {
valueItem->setText(subObject->getClassName().c_str());
buildModel(parentItem->child(iRow, 0), subObject, ref.getNode().get(), propertyPrefix + ref.getProperty()->getName() + ".");
} else {
updateModel(parentItem->child(iRow, 0), propertyPrefix + ref.getProperty()->getName() + ".");
}
} else {
valueItem->setText(ref.getProperty()->getStringValue(*ref.getObject()).c_str());
}
} else if (ref.getProperty()->getAttribute<FlagAttribute>()) {
ClassProperty<bool>* boolProperty = dynamic_cast<ClassProperty<bool>* >(ref.getProperty());
// properties tagged as Flag() must be of type bool
assert(boolProperty);
if (boolProperty->getValue(*ref.getObject()))
valueItem->setCheckState(Qt::Checked);
else
valueItem->setCheckState(Qt::Unchecked);
} else{
valueItem->setText(ref.getProperty()->getStringValue(*ref.getObject()).c_str());
}
} else {
if (parentItem->child(iRow, 0)->hasChildren()) {
updateModel(parentItem->child(iRow, 0), propertyPrefix);
}
}
}
}
AcceptRIEXDialog::AcceptRIEXDialog (const QList<RIEXItem>& items,
QObject *entryObj, QString message, QWidget *parent)
: QDialog (parent)
, Model_ (new QStandardItemModel (this))
{
Ui_.setupUi (this);
Model_->setHorizontalHeaderLabels ({ tr ("Action"), tr ("ID"), tr ("Name"), tr ("Groups") });
for (const RIEXItem& item : items)
{
QList<QStandardItem*> row;
QStandardItem *action = new QStandardItem;
action->setCheckState (Qt::Checked);
action->setCheckable (true);
switch (item.Action_)
{
case RIEXItem::AAdd:
action->setText (tr ("add"));
break;
case RIEXItem::ADelete:
action->setText (tr ("delete"));
break;
case RIEXItem::AModify:
action->setText (tr ("modify"));
break;
default:
action->setText (tr ("(unknown)"));
break;
}
action->setData (QVariant::fromValue<RIEXItem> (item));
row << action;
row << new QStandardItem (item.ID_);
row << new QStandardItem (item.Nick_);
row << new QStandardItem (item.Groups_.join ("; "));
Model_->appendRow (row);
}
Ui_.ItemsTree_->setModel (Model_);
ICLEntry *entry = qobject_cast<ICLEntry*> (entryObj);
const QString& id = entry->GetEntryName ().isEmpty () ?
entry->GetHumanReadableID () :
entry->GetEntryName () + " (" + entry->GetHumanReadableID () + ")";
const QString& text = message.isEmpty () ?
tr ("%1 has suggested to modify your contact list:")
.arg (id) :
tr ("%1 has suggested to modify your contact list:\n%2")
.arg (id)
.arg (message);
Ui_.MessageLabel_->setText (text);
}
void CleanDialog::selectAllItems(bool checked)
{
if (const int rowCount = mpCleanFilesModel->rowCount()) {
for (int r = 0; r < rowCount; ++r) {
QStandardItem *item = mpCleanFilesModel->item(r, 0);
item->setCheckState(checked ? Qt::Checked : Qt::Unchecked);
}
}
}
void SaveChangesDialog::addRow(ConnectionPageTab *tab, const QIcon &icon, const QString &title)
{
QStandardItem *tabItem = new QStandardItem(icon, title);
tabItem->setCheckable(true);
tabItem->setCheckState(Qt::Checked);
tabItem->setData(QVariant::fromValue((void*)tab));
tabItem->setData(1, Qt::UserRole + 2);
currentParentItem->appendRow(tabItem);
}
void VcsFileChangesModel::setAllChecked(bool checked)
{
if(!d->allowSelection)
return;
QStandardItem* parent = invisibleRootItem();
for(int i = 0; i < parent->rowCount(); i++) {
QStandardItem* item = parent->child(i);
item->setCheckState(checked ? Qt::Checked : Qt::Unchecked);
}
}
// check QStandardItem and its decendants
void AbstractCameraManager::cameraTree_recursiveCheck(QStandardItem* parent, Qt::CheckState checked) {
qDebug() << "recursivecheck(" << checked << ") on " << parent->text();
for(int i=0; i<parent->rowCount(); ++i) {
QStandardItem* currItem = parent->child(i);
if(currItem->checkState() != checked)
currItem->setCheckState(checked);
else
cameraTree_recursiveCheck(currItem, checked);
}
}