void MessagesModel::addMessage(const QString &id, const QString &parentId, const QString &subject, const QString &from, const QDateTime &received, bool read)
{
QStandardItem *stdItem = findItem(id);
if (stdItem) {
return;
}
QList<QStandardItem*> items;
stdItem = new QStandardItem;
QFont font = stdItem->font();
font.setBold(true);
if (!read) {
stdItem->setFont(font);
}
stdItem->setText(from);
stdItem->setData(id, RoleMessageId);
stdItem->setData(parentId, RoleParentFolderId);
items << stdItem;
stdItem = new QStandardItem(subject);
if (!read) {
stdItem->setFont(font);
}
items << stdItem;
stdItem = new QStandardItem;
if (!read) {
stdItem->setFont(font);
}
stdItem->setData(received, Qt::DisplayRole);
items << stdItem;
appendRow(items);
}
void MangaListWidget::checkIfMangaAreRead(void) {
for (int k = 0; k < _model->rowCount(); k++) {
QStandardItem* currManga = _model->itemFromIndex(_model->index(k, 0));
QList<bool> areChaptersRead = Utils::areChaptersRead(currManga->text());
if (!Utils::isMangaRead(areChaptersRead))
currManga->setFont(QFont("", -1, 99));
else
currManga->setFont(QFont());
}
}
void ConfigurationContentsWidget::optionChanged(const QString &option, const QVariant &value)
{
for (int i = 0; i < m_model->rowCount(); ++i)
{
QStandardItem *groupItem = m_model->item(i, 0);
if (!groupItem || !QString(option).startsWith(groupItem->text()))
{
continue;
}
for (int j = 0; j < groupItem->rowCount(); ++j)
{
QStandardItem *optionItem = groupItem->child(j, 0);
if (optionItem && option == QStringLiteral("%1/%2").arg(groupItem->text()).arg(optionItem->text()))
{
QFont font = optionItem->font();
font.setBold(value != SettingsManager::getDefaultValue(option));
optionItem->setFont(font);
groupItem->child(j, 2)->setText(value.toString());
break;
}
}
}
}
AjoutPrecedence::AjoutPrecedence(QWidget *parent) :
QDialog(parent),
ui(new Ui::AjoutPrecedence), nbTachesAjoutees(0)
{
ui->setupUi(this);
this->setModal(true);
ui->treeView->setEditTriggers(0);
EditeurTache::predecesseurs.clear();
for(QMap<QString, Projet*>::const_iterator it= ProjetManager::getInstance().getProjets().cbegin();
it!=ProjetManager::getInstance().getProjets().cend();
it++){//parcours des projets
QStandardItem* item = new QStandardItem((*it)->getNom());
QFont f = QFont();
f.setBold(true);
f.setUnderline(true);
item->setFont(f);
modele.appendRow(item);
for(QMap<QString, Tache*>::const_iterator it2 = (*it)->getTaches().cbegin();
it2!=(*it)->getTaches().cend();
it2++){//parcours des taches de chaque projet
QStandardItem* item2 = new QStandardItem((*it2)->getId());//création de l'identifiant de la tache
item2->setCheckable(true); //ajout de la checkbox
item->appendRow(item2); //ajout de item2 au projet
nbTachesAjoutees++;
}
}
ui->treeView->setModel(&modele);
QObject::connect(ui->pushButtonAnnuler, SIGNAL(clicked()),this,SLOT(close()));
QObject::connect(ui->pushButtonOK, SIGNAL(clicked()),this,SLOT(EnregistrerPred()));
}
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;
}
// Returns a heading item with the given text. Will create and add a new heading under \c parentIndex at \c position if no heading with that text exists yet. (Use -1 for \c position to append at the bottom.) If \c text is empty, will return the top-level (invisible root) item.
QStandardItem* AMWindowPaneModel::headingItem(const QString& text, QModelIndex parentIndex, int position) {
if(text.isEmpty())
return invisibleRootItem();
QList<QStandardItem*> searchItems = this->findItems(text);
foreach(QStandardItem* i, searchItems) {
if(isHeading(i->index()))
return i;
}
// Didn't find it... time to make it:
QStandardItem* newHeading = new QStandardItem(text);
newHeading->setFlags(Qt::ItemIsEnabled); // enabled, but should not be selectable
// graphics defaults:
QFont font = QFont("Lucida Grande", 10, QFont::Bold);
font.setCapitalization(QFont::AllUppercase);
newHeading->setFont(font);
newHeading->setData(QBrush(QColor::fromRgb(100, 109, 125)), Qt::ForegroundRole);
QStandardItem* parent = itemFromIndex(parentIndex);
if(parent) {
if(position < 0 || position > parent->rowCount())
position = parent->rowCount();
parent->insertRow(position, newHeading);
}
else {
if(position < 0 || position > rowCount())
position = rowCount();
insertRow(position, newHeading);
}
return newHeading;
}
foreach (QComboBox *comboBox, comboBoxes) {
// insert title
int titleIndex = comboBox->count();
if (dimensionality != std::numeric_limits<int>::max())
comboBox->addItem(tr("%1D Descriptors").arg(dimensionality));
else
comboBox->addItem(tr("Other Descriptors"));
// set bold font for title and make it non-selectable
QStandardItem *item =
qobject_cast<QStandardItemModel *>(comboBox->model())->item(titleIndex);
if (item) {
QFont font_ = item->font();
font_.setBold(true);
item->setFont(font_);
item->setFlags(Qt::ItemIsEnabled);
}
// add a separator
comboBox->insertSeparator(comboBox->count());
// insert name of each descriptor
foreach (const QString &name, names)
comboBox->addItem(name);
}
void resetModel()
{
q->clear();
QFont bold;
bold.setBold(true);
// Create one item for each day of week
for(int day = Qt::Monday; day <= Qt::Sunday; ++day) {
QStandardItem *dayItem = new QStandardItem(QDate::longDayName(day));
dayItem->setFont(bold);
dayItem->setData(day, WeekDayRole);
// Add availabilities to items
const QVector<DayAvailability> &avail = m_UserCalendar->availabilities(day);
for(int availabilityId = 0; availabilityId < avail.count(); ++availabilityId) {
for(int timeRangeId = 0; timeRangeId < avail.at(availabilityId).timeRangeCount(); ++timeRangeId) {
TimeRange range = avail.at(availabilityId).timeRangeAt(timeRangeId);
QStandardItem *time = new QStandardItem(tkTr(Trans::Constants::FROM_1_TO_2).arg(range.from.toString()).arg(range.to.toString()));
time->setData(day, WeekDayRole);
time->setData(range.from, HourFromRole);
time->setData(range.to, HourToRole);
time->setData(timeRangeId, TimeRangeIdRole);
time->setData(availabilityId, AvailIdRole);
time->setToolTip(time->text());
dayItem->appendRow(time);
}
}
if (dayItem->rowCount() > 0) {
dayItem->sortChildren(0);
}
q->invisibleRootItem()->appendRow(dayItem);
}
}
QList<QStandardItem*> QDatabaseTableViewController::makeStandardItemListFromStringList(const QList<QString>& szStringList)
{
QList<QStandardItem*> listStandardItemList;
QStandardItem* pStandardItem;
QFont font;
QPalette palette = QApplication::palette(m_pDatabaseTableView);
QBrush nullbrush = palette.brush(QPalette::Disabled, QPalette::Text);
QList<QString>::const_iterator iter = szStringList.begin();
while(iter != szStringList.end())
{
//Getting an item from QList<QString> to add it to a QList<QStandardItem>
if((*iter).isNull()){
pStandardItem = new QStandardItem(QString("NULL"));
font = pStandardItem->font();
font.setItalic(true);
pStandardItem->setFont(font);
pStandardItem->setForeground(nullbrush);
} else {
pStandardItem = new QStandardItem(*iter);
}
pStandardItem->setEditable(true);
listStandardItemList.append(pStandardItem);
iter++;
}
return listStandardItemList;
}
void fillTitle(QComboBox* combo, const QString& s) {
combo->addItem(s);
QStandardItem* item = lastItem(combo);
QFont f;
f.setBold(true);
item->setFont(f);
item->setSelectable(false);
}
// 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 createTreeModel(const int treeItemReference, bool forceUpdate = false)
{
if (!forceUpdate && (m_ActualTreeModelColumn == treeItemReference))
return;
m_ActualTreeModelColumn = treeItemReference;
QFont bold;
bold.setBold(true);
if (!m_TreeModel) {
m_TreeModel = new QStandardItemModel;
} else {
m_TreeModel->clear();
}
QStandardItem *parentItem = m_TreeModel->invisibleRootItem();
QHash<QString, QStandardItem *> categories;
for(int i=0; i < m_FormDescr.count(); ++i) {
Form::FormIODescription *descr = m_FormDescr.at(i);
// Do not manage excluded forms
if (_excludeUids.contains(descr->data(Form::FormIODescription::UuidOrAbsPath).toString(), Qt::CaseInsensitive))
continue;
const QString &cat = descr->data(treeItemReference).toString();
QStandardItem *catItem = 0;
if (!categories.contains(cat)) {
QString catName = descr->data(treeItemReference).toString();
if (catName.isEmpty()) {
catName = QCoreApplication::translate("FormFilesSelectorWidget", "Default Forms");
}
catItem = new QStandardItem(catName);
catItem->setFont(bold);
categories.insert(cat, catItem);
parentItem->appendRow(catItem);
} else {
catItem = categories.value(cat);
}
QStandardItem *item = new QStandardItem(descr->data(FormIODescription::ShortDescription).toString());
item->setData(i, IndexRole);
catItem->appendRow(item);
// highlight ?
if (!m_HightlightUuid.isEmpty()) {
if (descr->data(FormIODescription::UuidOrAbsPath).toString()==m_HightlightUuid) {
item->setFont(bold);
}
}
}
}
QStandardItem* FontManagerDialog::CreateFontItem(QString itemText, QString fontName, QString defaultFontName)
{
QStandardItem *item = new QStandardItem(itemText);
if (!defaultFontName.isNull() && !defaultFontName.isEmpty() && defaultFontName.contains(fontName))
{
QFont itemFont = item->font();
itemFont.setBold(true);
item->setFont(itemFont);
}
return item;
}
/*
Update the contents for the message pointed to by 'msg', if it's in the
model, otherwise ignore the request. Currently the contents are the
status (icon) and the priority. Other changes such as in the subject
or the date could be visually reflected by this function if the UI
permitted those changes.
*/
void
mail_item_model::update_msg(const mail_msg* msg)
{
DBG_PRINTF(4, "update_msg of " MAIL_ID_FMT_STRING, msg->get_id());
QStandardItem* item=item_from_id(msg->get_id());
if (!item)
return;
QModelIndex index=item->index();
QStandardItem* isubject = itemFromIndex(index);
bool bold=isubject->font().bold();
DBG_PRINTF(5, "mail_id=" MAIL_ID_FMT_STRING ", status=%d, bold=%d",
msg->get_id(), msg->status(), bold);
if ((msg->status()!=0 && bold) || (msg->status()==0 && !bold)) {
// reverse bold attribute
QFont f=isubject->font();
f.setBold(!bold);
isubject->setFont(f);
itemFromIndex(index.sibling(index.row(), column_sender))->setFont(f);
itemFromIndex(index.sibling(index.row(), column_date))->setFont(f);
itemFromIndex(index.sibling(index.row(), column_pri))->setFont(f);
itemFromIndex(index.sibling(index.row(), column_recipient))->setFont(f);
}
// status icon
QIcon* icon = icon_status(msg->status());
QStandardItem* istatus = itemFromIndex(index.sibling(index.row(), column_status));
if (istatus) {
if (icon)
istatus->setIcon(*icon);
else
istatus->setIcon(QIcon());
}
// priority
QStandardItem* ipri = itemFromIndex(index.sibling(index.row(), column_pri));
if (ipri) {
if (msg->priority()!=0)
ipri->setText(QString("%1").arg(msg->priority()));
else
ipri->setText("");
}
// note
QStandardItem* inote = itemFromIndex(index.sibling(index.row(), column_note));
if (inote) {
inote->setData(msg->has_note());
if (msg->has_note())
inote->setIcon(STATUS_ICON(FT_ICON16_EDIT_NOTE));
else
inote->setIcon(QIcon());
}
}
bool QgsStyleExportImportDialog::populateStyles( QgsStyle *style )
{
// load symbols and color ramps from file
if ( mDialogMode == Import )
{
// NOTE mTempStyle is style here
if ( !style->importXml( mFileName ) )
{
QMessageBox::warning( this, tr( "Import error" ),
tr( "An error occurred during import:\n%1" ).arg( style->errorString() ) );
return false;
}
}
QStandardItemModel *model = qobject_cast<QStandardItemModel *>( listItems->model() );
model->clear();
// populate symbols
QStringList styleNames = style->symbolNames();
QString name;
for ( int i = 0; i < styleNames.count(); ++i )
{
name = styleNames[i];
QStringList tags = style->tagsOfSymbol( QgsStyle::SymbolEntity, name );
QgsSymbol *symbol = style->symbol( name );
QStandardItem *item = new QStandardItem( name );
QIcon icon = QgsSymbolLayerUtils::symbolPreviewIcon( symbol, listItems->iconSize(), 15 );
item->setIcon( icon );
item->setToolTip( QString( "<b>%1</b><br><i>%2</i>" ).arg( name, tags.count() > 0 ? tags.join( ", " ) : tr( "Not tagged" ) ) );
// Set font to 10points to show reasonable text
QFont itemFont = item->font();
itemFont.setPointSize( 10 );
item->setFont( itemFont );
model->appendRow( item );
delete symbol;
}
// and color ramps
styleNames = style->colorRampNames();
for ( int i = 0; i < styleNames.count(); ++i )
{
name = styleNames[i];
std::unique_ptr< QgsColorRamp > ramp( style->colorRamp( name ) );
QStandardItem *item = new QStandardItem( name );
QIcon icon = QgsSymbolLayerUtils::colorRampPreviewIcon( ramp.get(), listItems->iconSize(), 15 );
item->setIcon( icon );
model->appendRow( item );
}
return true;
}
void addItem(const QIcon &icon, const QString &text, const QString &data = QString()) {
QFont itemFont;
itemFont.setPointSize(20);
QStandardItem *item = new QStandardItem(icon, text);
item->setData(data);
item->setFont(itemFont);
model.setItem(row, col, item);
col += 1;
if (col >= numCols) {
col = 0;
row ++;
}
}
// ------------------------------------------------------------------
void
JcnModel::markEntry(int r, int markCol)
{
if (jcndbg)
std::cout << "JcnModel::markEntry r c" << std::endl;
QStandardItem * itm = item(r,markCol);
QFont f = itm->font();
f.setBold(true);
f.setUnderline(true);
f.setPixelSize(13);
itm->setFont(f);
}
// Create the ATC tree items
bool getTree(AtcTableModel *sourceModel)
{
clearInternalCache();
_sourceModel = sourceModel;
// Fetch all data in the source model
while (_sourceModel->canFetchMore(_sourceModel->index(0, _sourceModel->rowCount())))
_sourceModel->fetchMore(_sourceModel->index(0, _sourceModel->rowCount()));
// Source model should be correctly sorted, so we don't need to sort.
// Read line by line
QStandardItem *lastOne = 0;
QStandardItem *lastThree = 0;
QStandardItem *lastFour = 0;
QStandardItem *lastFive = 0;
QStandardItem *parent = 0;
QList<QStandardItem*> cols;
for(int i=0; i < _sourceModel->rowCount(); ++i) {
cols.clear();
QModelIndex code = _sourceModel->index(i, AtcTableModel::Code);
QModelIndex fr = _sourceModel->index(i, AtcTableModel::LabelFr);
QModelIndex en = _sourceModel->index(i, AtcTableModel::LabelEn);
QModelIndex de = _sourceModel->index(i, AtcTableModel::LabelDe);
QStandardItem *item = new QStandardItem(_sourceModel->data(code).toString());
_toSourceIndex.insert(item, code);
cols << item;
cols << new QStandardItem(_sourceModel->data(en).toString());
cols << new QStandardItem(_sourceModel->data(fr).toString());
cols << new QStandardItem(_sourceModel->data(de).toString());
if (_sourceModel->data(code).toString().size() == 1) {
foreach(QStandardItem *item, cols)
item->setFont(bold);
}
// Find the parent item
switch (_sourceModel->data(code).toString().count()) {
case 1: parent = 0; lastOne = item; break;
case 3: parent = lastOne; lastThree = item; break;
case 4: parent = lastThree; lastFour = item; break;
case 5: parent = lastFour; lastFive = item; break;
case 7: parent = lastFive; break;
}
// need to be reparented
if (!parent)
parent = q->invisibleRootItem();
parent->appendRow(cols);
parent = 0;
}
return true;
}
void Ui_pluginManagerWindow::clearDefaultRow(int defaultRow)
{
QStandardItemModel *model = (QStandardItemModel*)ui.pluginTableView->model();
QStandardItem *item = model->item(defaultRow, 0);
item->setData(false, PLUGIN_IS_DEFAULT);
for (int column = 0; column < model->columnCount(); column++)
{
QStandardItem *item = model->item(defaultRow, column);
QFont font = item->font();
font.setBold(false);
item->setFont(font);
}
}
void ActionView::addAction(QAction * action)
{
QStandardItem * item = new QStandardItem;
item->setData(QVariant::fromValue<QAction *>(action), ActionRole);
item->setFont(action->font());
//Note: XdgCachedMenuAction has delayed icon loading... we are loading the icon
//in QStyledItemDelegate:sizeHint if necessary
item->setIcon(action->icon());
item->setText(action->text());
item->setToolTip(action->toolTip());
QString all = action->text();
all += '\n';
all += action->toolTip();
item->setData(all, FilterRole);
mModel->appendRow(item);
connect(action, &QObject::destroyed, this, &ActionView::onActionDestroyed);
}
bool LogChangeWidget::populateLog(const QString &repository, const QString &commit, LogFlags flags)
{
const QString currentCommit = this->commit();
int selected = currentCommit.isEmpty() ? 0 : -1;
if (const int rowCount = m_model->rowCount())
m_model->removeRows(0, rowCount);
// Retrieve log using a custom format "Sha1:Subject [(refs)]"
GitClient *client = GitPlugin::instance()->gitClient();
QStringList arguments;
arguments << QLatin1String("--max-count=1000") << QLatin1String("--format=%h:%s %d");
arguments << (commit.isEmpty() ? QLatin1String("HEAD") : commit);
if (!(flags & IncludeRemotes))
arguments << QLatin1String("--not") << QLatin1String("--remotes");
QString output;
if (!client->synchronousLog(repository, arguments, &output, 0, VcsBasePlugin::NoOutput))
return false;
foreach (const QString &line, output.split(QLatin1Char('\n'))) {
const int colonPos = line.indexOf(QLatin1Char(':'));
if (colonPos != -1) {
QList<QStandardItem *> row;
for (int c = 0; c < ColumnCount; ++c) {
QStandardItem *item = new QStandardItem;
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
if (line.endsWith(QLatin1Char(')'))) {
QFont font = item->font();
font.setBold(true);
item->setFont(font);
}
row.push_back(item);
}
const QString sha1 = line.left(colonPos);
row[Sha1Column]->setText(sha1);
row[SubjectColumn]->setText(line.right(line.size() - colonPos - 1));
m_model->appendRow(row);
if (selected == -1 && currentCommit == sha1)
selected = m_model->rowCount() - 1;
}
}
setCurrentIndex(m_model->index(selected, 0));
return true;
}
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 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 MidiInstrument::populatePatchModel(QStandardItemModel* model, int chan, MidiType songType)
{
model->clear();
int mask = 0;
bool drumchan = chan == 9;
switch (songType)
{
case MIDI_TYPE_XG:
mask = 4;
break;
case MIDI_TYPE_GS:
mask = 2;
break;
case MIDI_TYPE_GM:
if (drumchan)
return;
mask = 1;
break;
case MIDI_TYPE_NULL:
mask = 7;
break;
}
if (pg.size() > 1)
{
for (ciPatchGroup i = pg.begin(); i != pg.end(); ++i)
{
PatchGroup* pgp = *i;
QList<QStandardItem*> folder;
QStandardItem* noop = new QStandardItem("");
QStandardItem *dir = new QStandardItem(pgp->name);
QFont f = dir->font();
f.setBold(true);
dir->setFont(f);
const PatchList& pl = pgp->patches;
for (ciPatch ipl = pl.begin(); ipl != pl.end(); ++ipl)
{
const Patch* mp = *ipl;
if (mp->typ & mask)
{
int id = ((mp->hbank & 0xff) << 16) + ((mp->lbank & 0xff) << 8) + (mp->prog & 0xff);
QList<QStandardItem*> row;
QString strId = QString::number(id);
QStandardItem* idItem = new QStandardItem(strId);
QStandardItem* nItem = new QStandardItem(mp->name);
nItem->setToolTip(QString(pgp->name+":\n "+mp->name));
row.append(nItem);
row.append(idItem);
dir->appendRow(row);
}
}
folder.append(dir);
folder.append(noop);
model->appendRow(folder);
}
}
else if (pg.size() == 1)
{
// no groups
const PatchList& pl = pg.front()->patches;
QStandardItem* root = model->invisibleRootItem();
for (ciPatch ipl = pl.begin(); ipl != pl.end(); ++ipl)
{
const Patch* mp = *ipl;
if (mp->typ & mask)
{
int id = ((mp->hbank & 0xff) << 16) + ((mp->lbank & 0xff) << 8) + (mp->prog & 0xff);
QList<QStandardItem*> row;
QString strId = QString::number(id);
QStandardItem* idItem = new QStandardItem(strId);
QStandardItem* nItem = new QStandardItem(mp->name);
nItem->setToolTip(QString(mp->name));
row.append(nItem);
row.append(idItem);
root->appendRow(row);
}
}
}
}
/** Constructor */
BlogsDialog::BlogsDialog(QWidget *parent)
: MainPage (parent)
{
/* Invoke the Qt Designer generated object setup routine */
setupUi(this);
connect(actionCreate_Blog, SIGNAL(triggered()), this, SLOT(createBlog()));
connect(postButton, SIGNAL(clicked()), this, SLOT(createMsg()));
connect(subscribeButton, SIGNAL( clicked( void ) ), this, SLOT( subscribeBlog ( void ) ) );
connect(unsubscribeButton, SIGNAL( clicked( void ) ), this, SLOT( unsubscribeBlog ( void ) ) );
connect(treeView, SIGNAL(clicked(const QModelIndex &)), this, SLOT(selectBlog(const QModelIndex &)));
connect(treeView, SIGNAL(activated(const QModelIndex &)), this, SLOT(toggleSelection(const QModelIndex &)));
connect(treeView, SIGNAL(customContextMenuRequested( QPoint ) ), this, SLOT( blogListCustomPopupMenu( QPoint ) ) );
mBlogId = "";
mPeerId = rsPeers->getOwnId(); // add your id
model = new QStandardItemModel(0, 2, this);
model->setHeaderData(0, Qt::Horizontal, tr("Name"), Qt::DisplayRole);
model->setHeaderData(1, Qt::Horizontal, tr("ID"), Qt::DisplayRole);
treeView->setModel(model);
treeView->setEditTriggers(QAbstractItemView::NoEditTriggers);
treeView->setItemDelegate(new ChanGroupDelegate());
// hide header and id column
treeView->setHeaderHidden(true);
treeView->hideColumn(1);
itemFont = QFont("ARIAL", 10);
itemFont.setBold(true);
QStandardItem *OwnBlogs = new QStandardItem(tr("My Blogs"));
OwnBlogs->setForeground(QBrush(QColor(79, 79, 79)));
OwnBlogs->setFont(itemFont);
QStandardItem *SubscribedBlogs = new QStandardItem(tr("Subscribed Blogs"));
SubscribedBlogs->setForeground(QBrush(QColor(79, 79, 79)));
SubscribedBlogs->setFont(itemFont);
QStandardItem *PopularBlogs = new QStandardItem(tr("Popular Blogs"));
PopularBlogs->setForeground(QBrush(QColor(79, 79, 79)));
PopularBlogs->setFont(itemFont);
QStandardItem *OtherBlogs = new QStandardItem(tr("Other Blogs"));
OtherBlogs->setForeground(QBrush(QColor(79, 79, 79)));
OtherBlogs->setFont(itemFont);
model->appendRow(OwnBlogs);
model->appendRow(SubscribedBlogs);
model->appendRow(PopularBlogs);
model->appendRow(OtherBlogs);
//added from ahead
updateBlogList();
mBlogFont = QFont("MS SANS SERIF", 22);
nameLabel->setFont(mBlogFont);
nameLabel->setMinimumWidth(20);
QMenu *blogmenu = new QMenu();
blogmenu->addAction(actionCreate_Blog);
blogmenu->addSeparator();
blogpushButton->setMenu(blogmenu);
QTimer *timer = new QTimer(this);
timer->connect(timer, SIGNAL(timeout()), this, SLOT(checkUpdate()));
timer->start(1000);
}
bool QmitkViewNavigatorWidget::FillTreeList()
{
// active workbench window available?
if (m_Window.IsNull())
return false;
// active page available?
berry::IWorkbenchPage::Pointer page = m_Window->GetActivePage();
if (page.IsNull())
return false;
// everything is fine and we can remove the window listener
if (m_WindowListener != nullptr)
berry::PlatformUI::GetWorkbench()->RemoveWindowListener(m_WindowListener.data());
// initialize tree model
m_TreeModel->clear();
QStandardItem *treeRootItem = m_TreeModel->invisibleRootItem();
// get all available perspectives
berry::IPerspectiveRegistry* perspRegistry = berry::PlatformUI::GetWorkbench()->GetPerspectiveRegistry();
QList<berry::IPerspectiveDescriptor::Pointer> perspectiveDescriptors(perspRegistry->GetPerspectives());
qSort(perspectiveDescriptors.begin(), perspectiveDescriptors.end(), comparePerspectives);
// get all Keywords
KeywordRegistry keywordRegistry;
berry::IPerspectiveDescriptor::Pointer currentPersp = page->GetPerspective();
//QStringList perspectiveExcludeList = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetPerspectiveExcludeList();
std::vector< QStandardItem* > categoryItems;
QStandardItem *perspectiveRootItem = new QStandardItem("Perspectives");
perspectiveRootItem->setEditable(false);
perspectiveRootItem->setFont(QFont("", 12, QFont::Normal));
treeRootItem->appendRow(perspectiveRootItem);
for (int i=0; i<perspectiveDescriptors.size(); i++)
{
berry::IPerspectiveDescriptor::Pointer p = perspectiveDescriptors.at(i);
/*
bool skipPerspective = false;
for(int e=0; e<perspectiveExcludeList.size(); e++)
if(perspectiveExcludeList.at(e)==p->GetId())
{
skipPerspective = true;
break;
}
if (skipPerspective)
continue;
*/
//QIcon* pIcon = static_cast<QIcon*>(p->GetImageDescriptor()->CreateImage());
mitk::QtPerspectiveItem* pItem = new mitk::QtPerspectiveItem(p->GetLabel());
pItem->m_Perspective = p;
pItem->m_Description = p->GetDescription();
QStringList keylist = p->GetKeywordReferences();
pItem->m_Tags = keywordRegistry.GetKeywords(keylist);
pItem->setEditable(false);
QFont font; font.setBold(true);
if (currentPersp.IsNotNull() && currentPersp->GetId()==p->GetId())
pItem->setFont(font);
QStringList catPath = p->GetCategoryPath();
if (catPath.isEmpty())
{
perspectiveRootItem->appendRow(pItem);
}
else
{
QStandardItem* categoryItem = nullptr;
for (unsigned int c=0; c<categoryItems.size(); c++)
{
if (categoryItems.at(c)->text() == catPath.front())
{
categoryItem = categoryItems.at(c);
break;
}
}
if (categoryItem==nullptr)
{
categoryItem = new QStandardItem(QIcon(),catPath.front());
categoryItems.push_back(categoryItem);
}
categoryItem->setEditable(false);
categoryItem->appendRow(pItem);
categoryItem->setFont(QFont("", 12, QFont::Normal));
}
}
std::sort(categoryItems.begin(), categoryItems.end(), compareQStandardItems);
for (unsigned int i=0; i<categoryItems.size(); i++)
perspectiveRootItem->appendRow(categoryItems.at(i));
// get all available views
berry::IViewRegistry* viewRegistry = berry::PlatformUI::GetWorkbench()->GetViewRegistry();
QList<berry::IViewDescriptor::Pointer> viewDescriptors(viewRegistry->GetViews());
QList<berry::IViewPart::Pointer> viewParts(page->GetViews());
qSort(viewDescriptors.begin(), viewDescriptors.end(), compareViews);
auto emptyItem = new QStandardItem();
emptyItem->setFlags(Qt::ItemIsEnabled);
treeRootItem->appendRow(emptyItem);
//QStringList viewExcludeList = berry::PlatformUI::GetWorkbench()->GetActiveWorkbenchWindow()->GetViewExcludeList();
//There currently is no way to get the list of excluded views at application start
QStringList viewExcludeList;
// internal view used for the intro screen, will crash when opened directly, see T22352
viewExcludeList.append(QString("org.blueberry.ui.internal.introview"));
viewExcludeList.append(QString("org.mitk.views.controlvisualizationpropertiesview"));
viewExcludeList.append(QString("org.mitk.views.modules"));
viewExcludeList.append(QString("org.mitk.views.viewnavigatorview"));
QStandardItem* viewRootItem = new QStandardItem(QIcon(),"Views");
viewRootItem->setFont(QFont("", 12, QFont::Normal));
viewRootItem->setEditable(false);
treeRootItem->appendRow(viewRootItem);
categoryItems.clear();
QStandardItem* noCategoryItem = new QStandardItem(QIcon(),"Miscellaneous");
noCategoryItem->setEditable(false);
noCategoryItem->setFont(QFont("", 12, QFont::Normal));
for (int i = 0; i < viewDescriptors.size(); ++i)
{
berry::IViewDescriptor::Pointer v = viewDescriptors[i];
bool skipView = false;
for(int e=0; e<viewExcludeList.size(); e++)
if(viewExcludeList.at(e)==v->GetId())
{
skipView = true;
break;
}
if (skipView)
continue;
QStringList catPath = v->GetCategoryPath();
QIcon icon = v->GetImageDescriptor();
mitk::QtViewItem* vItem = new mitk::QtViewItem(icon, v->GetLabel());
vItem->m_View = v;
vItem->setToolTip(v->GetDescription());
vItem->m_Description = v->GetDescription();
QStringList keylist = v->GetKeywordReferences();
vItem->m_Tags = keywordRegistry.GetKeywords(keylist);
vItem->setEditable(false);
for (int i=0; i<viewParts.size(); i++)
if(viewParts[i]->GetPartName()==v->GetLabel())
{
QFont font; font.setBold(true);
vItem->setFont(font);
break;
}
if (catPath.empty())
noCategoryItem->appendRow(vItem);
else
{
QStandardItem* categoryItem = nullptr;
for (unsigned int c=0; c<categoryItems.size(); c++)
if (categoryItems.at(c)->text() == catPath.front())
{
categoryItem = categoryItems.at(c);
break;
}
if (categoryItem==nullptr)
{
categoryItem = new QStandardItem(QIcon(),catPath.front());
categoryItems.push_back(categoryItem);
}
categoryItem->setEditable(false);
categoryItem->appendRow(vItem);
categoryItem->setFont(QFont("", 12, QFont::Normal));
}
}
std::sort(categoryItems.begin(), categoryItems.end(), compareQStandardItems);
for (unsigned int i=0; i<categoryItems.size(); i++)
viewRootItem->appendRow(categoryItems.at(i));
if (noCategoryItem->hasChildren())
viewRootItem->appendRow(noCategoryItem);
m_Controls.m_PluginTreeView->expandAll();
return true;
}
void
mail_item_model::create_row(mail_msg* msg, QList<QStandardItem*>& items)
{
bool bold = ((msg->status() & mail_msg::statusRead)==0);
QStandardItem* isubject = new QStandardItem(msg->Subject());
if (bold) {
QFont f=isubject->font();
f.setBold(true);
isubject->setFont(f);
}
// store mail_msg* into the data of the first item (mail's subject at column 0)
QVariant v;
v.setValue(msg);
isubject->setData(v, mail_item_model::mail_msg_role);
QStandardItem* ifrom = new QStandardItem();
if (m_display_sender_mode!="name" || msg->sender_name().isEmpty())
ifrom->setText(msg->From());
else
ifrom->setText(msg->sender_name());
if (bold) {
QFont f=ifrom->font();
f.setBold(true);
ifrom->setFont(f);
}
items.append(isubject);
items.append(ifrom);
QIcon* icon = icon_status(msg->status());
if (icon)
items.append(new QStandardItem(*icon,"")); // status
else
items.append(new QStandardItem()); // empty (shouldn't happen)
// priority (number)
QStandardItem* ipri = new QStandardItem();
if (msg->priority()!=0)
ipri->setText(QString("%1").arg(msg->priority()));
if (bold) {
QFont f=ipri->font();
f.setBold(true);
ipri->setFont(f);
}
items.append(ipri);
// Attachment
flag_item* a_item;
if (msg->has_attachments()) {
a_item = new flag_item(STATUS_ICON(FT_ICON16_ATTACH));
a_item->setData(QVariant(true));
}
else {
a_item = new flag_item();
a_item->setData(QVariant(false));
}
items.append(a_item);
// Note
flag_item* n_item;
if (msg->has_note()) {
n_item = new flag_item(STATUS_ICON(FT_ICON16_EDIT_NOTE));
n_item->setData(QVariant(true));
}
else {
n_item = new flag_item();
n_item->setData(QVariant(false));
}
items.append(n_item);
// Date
date_item* idate = new date_item(msg->msg_date(), m_date_format);
if (bold) {
QFont f=idate->font();
f.setBold(true);
idate->setFont(f);
}
items.append(idate);
QStandardItem* irecipient = new QStandardItem();
QList<QString> emails;
QList<QString> names;
QString recipients;
mail_address::ExtractAddresses(msg->recipients(), emails, names);
QList<QString>::const_iterator iter1 = emails.begin();
QList<QString>::const_iterator iter2 = names.begin();
for (; iter1!=emails.end() && iter2!=names.end(); ++iter1,++iter2) {
if (!recipients.isEmpty())
recipients.append(", ");
if (iter2->isEmpty())
recipients.append(*iter1);
else
recipients.append(*iter2);
}
irecipient->setText(recipients);
if (bold) {
QFont f=irecipient->font();
f.setBold(true);
irecipient->setFont(f);
}
items.append(irecipient);
}
void MpcImportWindow::populateCandidateObjects(QList<SsoElements> objects)
{
candidatesForAddition.clear();
//Get a list of the current objects
QHash<QString,QString> defaultSsoIdentifiers = ssoManager->getDefaultSsoIdentifiers();
QHash<QString,QString> loadedSsoIdentifiers = ssoManager->listAllLoadedSsoIdentifiers();
//Separating the objects into visual groups in the list
int newDefaultSsoIndex = 0;
int newLoadedSsoIndex = 0;
int newNovelSsoIndex = 0;
int insertionIndex = 0;
QStandardItemModel * model = candidateObjectsModel;
model->clear();
model->setColumnCount(1);
foreach (SsoElements object, objects)
{
QString name = object.value("name").toString();
if (name.isEmpty())
continue;
QString group = object.value("section_name").toString();
if (group.isEmpty())
continue;
//Prevent name conflicts between asteroids and moons
if (loadedSsoIdentifiers.contains(name))
{
if (loadedSsoIdentifiers.value(name) != group)
{
name.append('*');
object.insert("name", name);
}
}
QStandardItem * item = new QStandardItem();
item->setText(name);
item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
item->setCheckState(Qt::Unchecked);
if (defaultSsoIdentifiers.contains(name))
{
//Duplicate of a default solar system object
QFont itemFont(item->font());
itemFont.setBold(true);
item->setFont(itemFont);
candidatesForUpdate.append(object);
insertionIndex = newDefaultSsoIndex;
newDefaultSsoIndex++;
newLoadedSsoIndex++;
newNovelSsoIndex++;
}
else if (loadedSsoIdentifiers.contains(name))
{
//Duplicate of another existing object
QFont itemFont(item->font());
itemFont.setItalic(true);
item->setFont(itemFont);
candidatesForUpdate.append(object);
insertionIndex = newLoadedSsoIndex;
newLoadedSsoIndex++;
newNovelSsoIndex++;
}
else
{
candidatesForAddition.append(object);
insertionIndex = newNovelSsoIndex;
newNovelSsoIndex++;
}
model->insertRow(insertionIndex, item);
}
void MangaListWidget::initModel(QString mangaSelected) {
_scansDirectory.setFilter(QDir::Dirs);
QStringList dirsList = Utils::dirList(_scansDirectory);
_model->removeRows(0, _model->rowCount());
QModelIndex indexMangaSelected;
for (const QString& mangaName: dirsList) {
QString currDirStr = _scansDirectory.path() + "/" + mangaName;
QStandardItem* currItem = new QStandardItem(mangaName);
currItem->setEditable(false);
_model->appendRow(currItem);
QDir currDir(currDirStr);
QStringList currDirsList = Utils::dirList(currDir, true);
QList<bool> areChaptersRead = Utils::areChaptersRead(mangaName);
if (!Utils::isMangaRead(areChaptersRead))
currItem->setFont(QFont("", -1, 99));
else
currItem->setFont(QFont());
if (mangaName == mangaSelected) {
indexMangaSelected = _model->indexFromItem(currItem);
}
int k = 0;
for (const QString& currChStr: currDirsList) {
if (k >= areChaptersRead.size()) {
QMessageBox::critical(this, "List error", "Error while tempting to edit manga read flags whithin MangaListWidget::initModel.");
return;
}
bool isChapterRead = areChaptersRead.at(k);
QStandardItem* currChItem = new QStandardItem(currChStr);
currChItem->setEditable(false);
setTextAccordingToRead(currChItem, isChapterRead);
currItem->appendRow(currChItem);
k++;
}
}
if (indexMangaSelected.isValid()) {
_view->selectionModel()->setCurrentIndex(indexMangaSelected, QItemSelectionModel::Current);
}
decorateMangaNames();
}