static void insertItem(QListWidget *list, const char *text, int hints)
{
QListWidgetItem *lwi = new QListWidgetItem(QLatin1String(text), list);
lwi->setData(Qt::UserRole, hints);
lwi->setFlags(lwi->flags() | Qt::ItemIsUserCheckable);
lwi->setCheckState(Qt::Unchecked);
}
void SettingsDialog::extractionCompleted(const QString &filePath)
{
QString docsetName;
/// FIXME: Come up with a better approach
for (const QString &key : m_tmpFiles.keys()) {
if (m_tmpFiles[key]->fileName() == filePath) {
docsetName = key;
break;
}
}
const QDir dataDir(m_application->settings()->docsetPath);
const QString docsetPath = dataDir.absoluteFilePath(docsetName + QLatin1String(".docset"));
// Write metadata about docset
DocsetMetadata metadata = m_availableDocsets.contains(docsetName)
? m_availableDocsets[docsetName]
: m_userFeeds[docsetName];
metadata.save(docsetPath, metadata.latestVersion());
m_docsetRegistry->addDocset(docsetPath);
QListWidgetItem *listItem = findDocsetListItem(metadata.title());
if (listItem) {
listItem->setHidden(true);
listItem->setCheckState(Qt::Unchecked);
listItem->setData(ProgressItemDelegate::ShowProgressRole, false);
}
resetProgress();
delete m_tmpFiles.take(docsetName);
}
void LinkResourceDialog::setUpGui()
{
QVBoxLayout* vbLayout = new QVBoxLayout(mainWidget());
QLabel *resourceName = new QLabel(mainWidget());
resourceName->setText(m_mainResource.genericLabel()+" : "+m_mainResource.className());
m_resourceSearch = new KLineEdit(mainWidget());
m_resourceSearch->setPlaceholderText(i18n("Search for resources"));
vbLayout->addWidget(resourceName);
vbLayout->addWidget(m_resourceSearch);
connect(m_resourceSearch,SIGNAL(textChanged(QString)),this,SLOT(slotTriggerSearch(QString)));
m_resourceList = new QListWidget(mainWidget());
vbLayout->addWidget(m_resourceList);
//m_resourceList->setViewMode(m_resourceList->IconMode);
Q_FOREACH(Nepomuk::Resource resource, getLinkedResources()) {
QListWidgetItem* item = new QListWidgetItem(resource.genericLabel(),m_resourceList);
item->setCheckState(Qt::Checked);
item->setToolTip(resource.uri());
if(!resource.genericIcon().isEmpty()) {
item->setIcon(KIcon(resource.genericIcon()));
}
else {
item->setIcon(KIcon("nepomuk"));
}
}
void ZealSettingsDialog::updateDocsets()
{
ui->downloadableGroup->show();
QStringList docsetNames = docsets->names();
bool missingMetadata = false;
foreach(auto name, docsetNames){
ZealDocsetMetadata metadata = docsets->meta(name);
if(!metadata.isValid()){
missingMetadata = true;
}
QString feedUrl = metadata.getFeedURL();
if(!feedUrl.isEmpty()){
auto reply = startDownload(feedUrl);
QList<QListWidgetItem*> items = ui->docsetsList->findItems( QString(name), Qt::MatchFixedString);
if(items.count() > 0){
reply->setProperty("listItem", ui->docsetsList->row( items[0] ));
} else {
QListWidgetItem *item = new QListWidgetItem( name, ui->docsetsList );
item->setCheckState( Qt::Checked );
item->setHidden(true);
ui->docsetsList->addItem( item );
reply->setProperty("listItem", ui->docsetsList->row( item ));
}
reply->setProperty("metadata", QVariant::fromValue(metadata));
connect(reply, SIGNAL(finished()), SLOT(extractDocset()));
}
}
void searchArtist::getArtists(int song)
{
qDebug() << "Musica a editar: " << song;
_song = _songs[song];
_newartists.clear();
ui->List_ALL->clear();
ui->List_NEW->clear();
_song->getAutor(&_newartists);
//Lista de Autores a adicionar e Remover
for (int i = 0; i < _newartists.size(); ++i)
{
// Adicionar e remover items
QListWidgetItem* item = new QListWidgetItem(_newartists[i]->getNome(), ui->List_NEW);
item->setData(Qt::UserRole,_newartists[i]->getIdBD());
item->setText(_newartists[i]->getNome());
item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(Qt::Unchecked);
}
for (int i = 0; i < _artists.size(); ++i)
{
QListWidgetItem* item = new QListWidgetItem(_artists[i]->getNome(), ui->List_ALL);
item->setData(Qt::UserRole,_artists[i]->getIdBD()); //Associar ID do Artista
item->setText(_artists[i]->getNome());
}
}
void AutomatedRssDownloader::createRuleItem(const RSS::AutoDownloadRule &rule)
{
QListWidgetItem *item = new QListWidgetItem(rule.name(), m_ui->listRules);
m_itemsByRuleName.insert(rule.name(), item);
item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(rule.isEnabled() ? Qt::Checked : Qt::Unchecked);
}
bool wxListBox::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
int n, const wxString choices[],
long style,
const wxValidator& validator,
const wxString& name)
{
Init();
QListWidgetItem* item;
m_qtWindow = m_qtListWidget = new wxQtListWidget( parent, this );
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
while ( n-- > 0 )
{
item = new QListWidgetItem();
item->setText(wxQtConvertString( *choices++ ));
if ( m_hasCheckBoxes )
{
item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable);
item->setCheckState(Qt::Unchecked);
}
m_qtListWidget->addItem(item);
}
return wxListBoxBase::Create( parent, id, pos, size, style, validator, name );
}
void Stage0::loadValuesFromStage() {
loadParams();
for(int i = 0; i < ui.listWidget_ECTypes->count(); i++) {
ui.listWidget_ECTypes->item(i)->setCheckState(Qt::Unchecked);
}
int ecTypesCount = controller->stage0.initialECTypes.size();
allECTypes = controller->stage0.initialECTypes;
std::vector<AxiomLib::ElemCondPlus> &ecs = allECTypes;
ui.listWidget_ECTypes->clear();
for(int i = 0; i < ecTypesCount; i++)
{
QString name = QString(ecs[i].elemCondition->name().c_str());
if(ecs[i].sign == false) {
name.prepend("not ");
}
QListWidgetItem *item = new QListWidgetItem(name, ui.listWidget_ECTypes);
item->setFlags(
Qt::ItemIsUserCheckable | Qt::ItemIsEnabled
);
item->setTextAlignment(Qt::AlignRight);
item->setCheckState(
controller->stage0.checkedECTypes[i] ?
Qt::Checked :
Qt::Unchecked
);
}
}
/*
* Add highlighted entries into main data store
*/
void UploadImpl::add()
{
// checked rather than selected seems more intuitive
// QList<QListWidgetItem *> items;
// items = listWidget->selectedItems();
for (int n=0; n< listWidget->count(); ++n)
{
QListWidgetItem* i = listWidget->item(n);
if ( (i->checkState() == Qt::Checked) &&
(i->flags() & Qt::ItemIsEnabled) )
{
// userrole data contains location exercise list
unsigned int pos = i->data(Qt::UserRole).toInt();
//Disable once uploaded
i->setFlags(0);
i->setCheckState(Qt::Checked);
// TODO add session ids to remove this date grouping hack.
QDateTime initial(exdata[pos].date, exdata[pos].time);
std::vector<ExerciseSet> sets;
while (pos < exdata.size() &&
QDateTime(exdata[pos].date, exdata[pos].time) == initial)
{
sets.push_back(exdata[pos++]);
}
if (sets.size())
ds->add(sets);
}
}
close();
}
GraphExport::GraphExport(std::vector<GraphCurveInfo*> *curves, QWidget *parent) :
QDialog(parent), ui(new Ui::GraphExport)
{
ui->setupUi(this);
ui->progress->hide();
m_curves = curves;
ui->colList->item(0)->setData(Qt::UserRole, -1);
for(quint32 i = 0; i < curves->size(); ++i)
{
QString text = curves->at(i)->curve->title().text();
ui->curveBox->addItem(text, QVariant(i));
QListWidgetItem *item = new QListWidgetItem(ui->colList);
item->setText(text);
item->setData(Qt::UserRole, i);
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
item->setCheckState(Qt::Checked);
}
connect(ui->colNamesBox, SIGNAL(clicked()), SLOT(updatePreview()));
connect(ui->endBox, SIGNAL(currentIndexChanged(int)), SLOT(updatePreview()));
connect(ui->sepEdit, SIGNAL(textChanged(QString)), SLOT(updatePreview()));
connect(ui->colList, SIGNAL(itemChanged(QListWidgetItem*)), SLOT(updatePreview()), Qt::QueuedConnection);
updatePreview();
}
void Stage0::deselectAll() {
int count = ui.listWidget_ECTypes->count();
for(int i = 0; i < count; i++) {
QListWidgetItem *item = ui.listWidget_ECTypes->item(i);
item->setCheckState(Qt::Unchecked);
}
}
void Preferences::disableAllClicked()
{
for (int i = 0; i < ui_.enabledFormatsList->count(); i++) {
QListWidgetItem* item = ui_.enabledFormatsList->item(i);
item->setCheckState(Qt::Unchecked);
}
}
AddGroupToFlowDialog::AddGroupToFlowDialog(QWidget *parent) :
QDialog(parent)
, groupsListWidget(new QListWidget())
, addButton(new QPushButton(QString("&Добавить")))
, exitButton(new QPushButton(QString("&Отмена")))
{
qDebug() << __FUNCTION__;
setWindowTitle("Выбор групп");
groupsListWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
QList<Group> groups = DbService::getInstance()->getAllGroups();
for (auto group : groups)
{
QListWidgetItem* item = new QListWidgetItem(groupsListWidget);
item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(Qt::Unchecked);
item->setText(group.getName());
item->setData(Qt::UserRole, group.getId());
groupsListWidget->addItem(item);
}
connect(addButton, SIGNAL(clicked()), this, SLOT(setSelectedIds()));
connect(exitButton, SIGNAL(clicked()), this, SLOT(close()));
QFormLayout *formLayout = new QFormLayout(this);
formLayout->addRow(new QLabel(QString("Список групп:")));
formLayout->addRow(groupsListWidget);
formLayout->addRow(exitButton, addButton);
setLayout(formLayout);
}
void AStylePreferences::init()
{
// setup list widget to have checked items
for(int i = 0; i < listIdentObjects->count(); i++) {
QListWidgetItem *item = listIdentObjects->item(i);
item->setFlags(Qt::ItemIsUserCheckable|Qt::ItemIsEnabled);
item->setCheckState(Qt::Checked);
}
connect(tabWidget, SIGNAL(currentChanged(QWidget*)), this, SLOT(currentTabChanged()));
connect(cbIndentType, SIGNAL(currentIndexChanged(int)), this, SLOT(indentChanged()));
connect(inpNuberSpaces, SIGNAL(valueChanged(int)), this, SLOT(indentChanged()));
connect(chkConvertTabs, SIGNAL(stateChanged(int)), this, SLOT(indentChanged()));
connect(chkFillEmptyLines, SIGNAL(stateChanged(int)), this, SLOT(indentChanged()));
connect(listIdentObjects, SIGNAL(itemChanged(QListWidgetItem*)),
this, SLOT(indentObjectsChanged(QListWidgetItem*)));
connect(inpMaxStatement, SIGNAL(valueChanged(int)), this, SLOT(minMaxValuesChanged()));
connect(inpMinConditional, SIGNAL(valueChanged(int)), this, SLOT(minMaxValuesChanged()));
connect(cbBrackets, SIGNAL(currentIndexChanged(int)), this, SLOT(bracketsChanged()));
connect(chkBracketsCloseHeaders, SIGNAL(stateChanged(int)), this, SLOT(bracketsChanged()));
connect(chkBlockBreak, SIGNAL(stateChanged(int)), this, SLOT(blocksChanged()));
connect(chkBlockBreakAll, SIGNAL(stateChanged(int)), this, SLOT(blocksChanged()));
connect(chkBlockIfElse, SIGNAL(stateChanged(int)), this, SLOT(blocksChanged()));
connect(cbParenthesisPadding, SIGNAL(currentIndexChanged(int)), this, SLOT(paddingChanged()));
connect(chkPadOperators, SIGNAL(stateChanged(int)), this, SLOT(paddingChanged()));
connect(chkKeepStatements, SIGNAL(stateChanged(int)), this, SLOT(onelinersChanged()));
connect(chkKeepBlocks, SIGNAL(stateChanged(int)), this, SLOT(onelinersChanged()));
}
/******************************************************************************
addPlayer
******************************************************************************/
void
WizardSelectPluginPage::addPlayer()
{
Q_ASSERT(mpPlayerVector != NULL);
AddPlayerDialog dlg(*mpPlayerVector, this);
if (dlg.exec() == QDialog::Accepted)
{
int nIdx = dlg.GetSelected();
if (nIdx == -1)
{
return;
}
CPluginInfo& added = mpPlayerVector->at(nIdx);
QString name = added.GetPlayerName();
//name += " " + tr("(plugin not installed)");
QListWidgetItem* item = new QListWidgetItem(name, ui.pluginList);
item->setCheckState(Qt::Checked);
// Store its position in players vector
item->setData(1, nIdx);
}
}
void RemoveDuplicates::loadDuplicates()
{
Soprano::Model* model = Nepomuk::ResourceManager::instance()->mainModel();
QString query
= QString( "select distinct ?u1 where { "
"?r1 a %1 . ?r2 a %1. ?r1 %2 ?h. ?r2 %2 ?h. "
"?r1 %3 ?u1. ?r2 %3 ?u2. filter(?r1!=?r2) . }order by ?h limit 50")
.arg( Soprano::Node::resourceToN3(Nepomuk::Vocabulary::NFO::FileDataObject()))
.arg( Soprano::Node::resourceToN3(Nepomuk::Vocabulary::NFO::hasHash()))
.arg( Soprano::Node::resourceToN3(Nepomuk::Vocabulary::NIE::url()));
Soprano::QueryResultIterator it
= model->executeQuery( query,
Soprano::Query::QueryLanguageSparql );
Nepomuk::File tempRsc;
while( it.next() ) {
tempRsc = it.binding("u1").uri() ;
QString usagecount = QString::number(tempRsc.usageCount());
QListWidgetItem* item = new QListWidgetItem(tempRsc.genericLabel() + ":: Usage Count:" + usagecount,m_resourceList);
item->setCheckState(Qt::Unchecked);
item->setToolTip(tempRsc.url().path());
qDebug()<<tempRsc.url().path();
}
}
foreach( const MailCommon::Tag::Ptr &tag, tagList ) {
if(tag->tagStatus)
continue;
QListWidgetItem *item = new QListWidgetItem(KIcon(tag->iconName), tag->tagName, mListTag );
item->setData(UrlTag, tag->nepomukResourceUri.toString());
item->setFlags( Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable );
item->setCheckState( Qt::Unchecked );
mListTag->addItem( item );
if ( numberOfSelectedMessages == 1 ) {
const bool hasTag = itemResource.tags().contains( Nepomuk2::Tag( tag->tagName ) );
item->setCheckState( hasTag ? Qt::Checked : Qt::Unchecked );
} else {
item->setCheckState( Qt::Unchecked );
}
}
bool wxListBox::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
int n, const wxString choices[],
long style,
const wxValidator& validator,
const wxString& name)
{
Init();
QListWidgetItem* item;
m_qtWindow = m_qtListWidget = new wxQtListWidget( parent, this );
while ( n-- > 0 )
{
item = new QListWidgetItem();
item->setText(wxQtConvertString( *choices++ ));
if ( m_hasCheckBoxes )
{
item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable);
item->setCheckState(Qt::Unchecked);
}
m_qtListWidget->addItem(item);
}
return wxListBoxBase::Create( parent, id, pos, size, style, validator, name );
}
void PropertySelector::readSettings(QList<Property::Type> propertyList, QList<bool> checkList)
{
QSettings settings;
QList<QVariant> propertySettings = settings.value(m_settingsKey + "/properties").toList();
QList<QVariant> checkSettings = settings.value(m_settingsKey + "/checks").toList();
// Read settings
if ((propertySettings.size() == propertyList.size()) && (checkSettings.size() == checkList.size()))
{
propertyList.clear();
checkList.clear();
for (int i = 0; i < propertySettings.size(); i++)
{
propertyList << Property::Type(propertySettings[i].toInt());
checkList << checkSettings[i].toBool();
}
}
m_propertyListWidget->clear();
for (int i = 0; i < propertyList.size(); i++)
{
QListWidgetItem* widgetItem = new QListWidgetItem;
QString text = Property::fullName[propertyList[i]];
if (Property::fullName[propertyList[i]] != Property::shortName[propertyList[i]])
text += " (" + Property::shortName[propertyList[i]] + ")";
widgetItem->setText(text);
widgetItem->setCheckState(checkList[i] ? Qt::Checked : Qt::Unchecked);
widgetItem->setData(Qt::UserRole, propertyList[i]);
m_propertyListWidget->addItem(widgetItem);
}
m_symbolCheck->setCheckState(Qt::CheckState(settings.value(m_settingsKey + "/fullName", Qt::Checked).toInt()));
}
void SubtotalDialog::fillColumnBoxes()
{
Sheet *const sheet = d->selection->lastSheet();
const QRect range = d->selection->lastRange();
int r = range.right();
int row = range.top();
Cell cell;
QListWidgetItem * item;
QString text;
int index = 0;
for (int i = range.left(); i <= r; ++i) {
cell = Cell(sheet, i, row);
text = cell.displayText();
//if ( text.length() > 0 )
{
text = i18n("Column '%1' ", Cell::columnName(i));
}
d->mainWidget.m_columnBox->insertItem(index++, text);
item = new QListWidgetItem(text);
item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(Qt::Unchecked);
d->mainWidget.m_columnList->addItem(item);
}
}
void MConfig::buildListGroups(){
char line[130];
FILE *fp;
int i;
listGroups->clear();
//read /etc/group and add all the groups in the listGroups
fp = popen("cat /etc/group | cut -f 1 -d :", "r");
if (fp != NULL) {
while (fgets(line, sizeof line, fp) != NULL) {
i = strlen(line);
line[--i] = '\0';
if (line != NULL && strlen(line) > 1) {
QListWidgetItem *item = new QListWidgetItem;
item->setText(line);
item->setCheckState(Qt::Unchecked);
listGroups->addItem(item);
}
}
pclose(fp);
}
//check the boxes for the groups that the current user belongs to
QString cmd = QString("id -nG %1").arg(userComboMembership->currentText());
QString out = getCmdOut(cmd);
QStringList out_tok = out.split(" ");
while (!out_tok.isEmpty()) {
QString text = out_tok.takeFirst();
QList<QListWidgetItem*> list = listGroups->findItems(text, Qt::MatchExactly);
while (!list.isEmpty()) {
list.takeFirst()->setCheckState(Qt::Checked);
}
}
}
void NewWakuSettingsWindow::on_tag_add_clicked()
{
QListWidgetItem* item = new QListWidgetItem(ui->tags_list);
item->setText(QStringLiteral("タグ名"));
item->setFlags(item->flags() | Qt::ItemIsEditable | Qt::ItemIsUserCheckable);
item->setCheckState(Qt::Unchecked);
}
void IgnoreListEditor::readIgnoreFile(const QString &file, bool readOnly)
{
MirallConfigFile cfgFile;
const QString disabledTip(tr("This entry is provided by the system at '%1' "
"and cannot be modified in this view.")
.arg(QDir::toNativeSeparators(cfgFile.excludeFile(MirallConfigFile::SystemScope))));
QFile ignores(file);
if (ignores.open(QIODevice::ReadOnly)) {
while (!ignores.atEnd()) {
QString line = QString::fromUtf8(ignores.readLine());
line.chop(1);
if (!line.isEmpty() && !line.startsWith("#")) {
QListWidgetItem *item = new QListWidgetItem;
setupItemFlags(item);
if (line.startsWith("]")) {
line = line.mid(1);
item->setCheckState(Qt::Checked);
}
item->setText(line);
if (readOnly) {
item->setFlags(item->flags() ^ Qt::ItemIsEnabled);
item->setToolTip(disabledTip);
}
ui->listWidget->addItem(item);
}
}
}
}
MakeStepConfigWidget::MakeStepConfigWidget(MakeStep *makeStep)
: m_makeStep(makeStep)
{
QFormLayout *fl = new QFormLayout(this);
fl->setMargin(0);
fl->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
setLayout(fl);
m_additionalArguments = new QLineEdit(this);
fl->addRow(tr("Additional arguments:"), m_additionalArguments);
m_additionalArguments->setText(m_makeStep->additionalArguments());
m_buildTargetsList = new QListWidget;
m_buildTargetsList->setMinimumHeight(200);
fl->addRow(tr("Targets:"), m_buildTargetsList);
// TODO update this list also on rescans of the CMakeLists.txt
// TODO shouldn't be accessing project
CMakeProject *pro = m_makeStep->cmakeBuildConfiguration()->cmakeTarget()->cmakeProject();
foreach(const QString& buildTarget, pro->buildTargetTitles()) {
QListWidgetItem *item = new QListWidgetItem(buildTarget, m_buildTargetsList);
item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(m_makeStep->buildsBuildTarget(item->text()) ? Qt::Checked : Qt::Unchecked);
}
updateDetails();
connect(m_additionalArguments, SIGNAL(textEdited(const QString &)), this, SLOT(additionalArgumentsEdited()));
connect(m_buildTargetsList, SIGNAL(itemChanged(QListWidgetItem*)), this, SLOT(itemChanged(QListWidgetItem*)));
connect(ProjectExplorer::ProjectExplorerPlugin::instance(), SIGNAL(settingsChanged()),
this, SLOT(updateDetails()));
connect(pro, SIGNAL(buildTargetsChanged()),
this, SLOT(buildTargetsChanged()));
}
void searchArtist::on_bt_add_clicked()
{
//Verificar se existe algum artista já adicionado igual
QList<QListWidgetItem*> items = ui->List_ALL->selectedItems();
bool exist =false;
int ID;
QString Nome;
for (int i = 0; i < items.count(); ++i)
{
exist = false;
ID=items[i]->data(Qt::UserRole).toInt();
Nome=items[i]->data(Qt::DisplayRole).toString();
for (int j = 0; j < ui->List_NEW->count(); ++j)
{
if(ID == ui->List_NEW->item(j)->data(Qt::UserRole).toInt())
{
exist=true;
}
}
if(!exist)
{
QListWidgetItem* item = new QListWidgetItem(Nome, ui->List_NEW);
item->setData(Qt::UserRole,ID);
item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(Qt::Unchecked);
}
}
}
void QPhotorec::formats_reset()
{
for (int i = 0; i < formats->count(); i++) {
QListWidgetItem *item = formats->item(i);
item->setCheckState (Qt::Unchecked);
}
}
void SettingsDialog::processDocsetList(const QJsonArray &list)
{
for (const QJsonValue &v : list) {
QJsonObject docsetJson = v.toObject();
DocsetMetadata metadata(docsetJson);
m_availableDocsets.insert(metadata.name(), metadata);
}
/// TODO: Move into dedicated method
for (const DocsetMetadata &metadata : m_availableDocsets) {
QListWidgetItem *listItem
= new QListWidgetItem(metadata.icon(), metadata.title(), ui->availableDocsetList);
listItem->setData(ListModel::DocsetNameRole, metadata.name());
listItem->setCheckState(Qt::Unchecked);
if (m_docsetRegistry->contains(metadata.name())) {
listItem->setHidden(true);
Docset *docset = m_docsetRegistry->docset(metadata.name());
if (metadata.latestVersion() != docset->version()
|| (metadata.latestVersion() == docset->version()
&& metadata.revision() > docset->revision())) {
docset->hasUpdate = true;
ui->updateAllDocsetsButton->setEnabled(true);
}
}
}
ui->installedDocsetList->reset();
if (!m_availableDocsets.isEmpty())
ui->downloadableGroup->show();
}
GenericMakeStepConfigWidget::GenericMakeStepConfigWidget(GenericMakeStep *makeStep)
: m_makeStep(makeStep)
{
m_ui = new Ui::GenericMakeStep;
m_ui->setupUi(this);
// TODO update this list also on rescans of the GenericLists.txt
GenericProject *pro = m_makeStep->genericBuildConfiguration()->genericTarget()->genericProject();
foreach (const QString &target, pro->buildTargets()) {
QListWidgetItem *item = new QListWidgetItem(target, m_ui->targetsList);
item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
item->setCheckState(m_makeStep->buildsTarget(item->text()) ? Qt::Checked : Qt::Unchecked);
}
m_ui->makeLineEdit->setText(m_makeStep->m_makeCommand);
m_ui->makeArgumentsLineEdit->setText(m_makeStep->m_makeArguments);
updateMakeOverrrideLabel();
updateDetails();
connect(m_ui->targetsList, SIGNAL(itemChanged(QListWidgetItem*)),
this, SLOT(itemChanged(QListWidgetItem*)));
connect(m_ui->makeLineEdit, SIGNAL(textEdited(QString)),
this, SLOT(makeLineEditTextEdited()));
connect(m_ui->makeArgumentsLineEdit, SIGNAL(textEdited(QString)),
this, SLOT(makeArgumentsLineEditTextEdited()));
connect(ProjectExplorer::ProjectExplorerPlugin::instance(), SIGNAL(settingsChanged()),
this, SLOT(updateMakeOverrrideLabel()));
connect(ProjectExplorer::ProjectExplorerPlugin::instance(), SIGNAL(settingsChanged()),
this, SLOT(updateDetails()));
}
//显示"秘密事项"
void SecurityChange::showsecurityListWidget()
{
int fileNum_size = xml.m_vec_fileNum.count();
St_Default_Size.secret_Size = 0;
for(int index = 0;index < fileNum_size;index++)
{
if(xml.m_vec_fileNum[index].arrtIsDefault == "1")
{
int security_size = xml.m_vec_fileNum[index].vec_securitys.count();
for(int i = 0;i < security_size;i++)
{
if(xml.m_vec_fileNum[index].vec_securitys[i].name.compare("秘密") == 0)
{
int reason_size = xml.m_vec_fileNum[index].vec_securitys[i].vec_reason.count();
for(int j = 0;j < reason_size;j++)
{
QListWidgetItem *securityitem = new QListWidgetItem;
securityitem->setText(xml.m_vec_fileNum[index].vec_securitys[i].vec_reason[j].name);
securityitem->setCheckState(Qt::Unchecked);
ui->secretListWidget->addItem(securityitem);
St_Default_Size.secret_Size = St_Default_Size.secret_Size + 1;
}
}
}
}
}
connect(ui->secretListWidget,SIGNAL(itemChanged(QListWidgetItem*)),this,SLOT(everyListWidgetSlot(QListWidgetItem*)));
}
void KDMConvenienceWidget::slotAddUsers(const QMap<QString, int> &users)
{
QMap<QString, int>::const_iterator it;
for (it = users.begin(); it != users.end(); ++it) {
if (it.value() > 0) {
if (it.key() != autoUser)
userlb->addItem(it.key());
if (it.key() != preselUser)
puserlb->addItem(it.key());
}
if (it.value() != 0) {
QListWidgetItem *item = new QListWidgetItem(it.key(), npuserlv);
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled |
Qt::ItemIsUserCheckable);
item->setCheckState(noPassUsers.contains(it.key()) ?
Qt::Checked : Qt::Unchecked);
}
}
if (userlb->model())
userlb->model()->sort(0);
if (puserlb->model())
puserlb->model()->sort(0);
npuserlv->sortItems();
userlb->setCurrentItem(autoUser);
puserlb->setCurrentItem(preselUser);
}
