void MainDialog::desktops_read_names() {
xmlNodePtr n;
gint i;
ui.desktop_names->clear();
i = 0;
n = tree_get_node("desktops/names", NULL)->children;
while(n) {
gchar* name;
if(!xmlStrcmp(n->name, (const xmlChar*)"name")) {
name = obt_xml_node_string(n);
QString desktop_name = QString::fromUtf8(name);
if(desktop_name.isEmpty())
desktop_name = tr("(Unnamed desktop)");
QListWidgetItem* item = new QListWidgetItem(desktop_name);
item->setFlags(item->flags() | Qt::ItemIsEditable);
ui.desktop_names->addItem(item);
++i;
}
n = n->next;
}
while(i < num_desktops) {
QListWidgetItem* item = new QListWidgetItem(tr("(Unnamed desktop)"));
item->setFlags(item->flags() | Qt::ItemIsEditable);
ui.desktop_names->addItem(item);
++i;
}
}
void CodeDependenciesDialog::itemChanged(QListWidgetItem* item)
{
QString code0 = ui.codes->currentText();
QString code1 = item->text();
switch (item->checkState())
{
case Qt::Unchecked:
graph->removeDependency(code0, code1);
break;
case Qt::PartiallyChecked:
break;
case Qt::Checked:
graph->addDependency(code0, code1);
break;
}
#if 0
disconnect(ui.dependsOn, SIGNAL(itemChanged(QListWidgetItem*)), this, SLOT(itemChanged(QListWidgetItem*)));
for (int i = 0; i < ui.dependsOn->count(); ++i)
{
QListWidgetItem* item = ui.dependsOn->item(i);
QString code1 = item->text();
if (graph->isDependencyValid(code0, code1) == true)
item->setFlags(item->flags() | Qt::ItemIsEnabled);
else
item->setFlags(item->flags() & ~Qt::ItemIsEnabled);
}
connect(ui.dependsOn, SIGNAL(itemChanged(QListWidgetItem*)), this, SLOT(itemChanged(QListWidgetItem*)));
#endif
updateCallOrder();
}
bool AnnotationConfigurationHandler::startElement(
const QString & /* namespaceURI */,
const QString & /* localName */,
const QString &qName,
const QXmlAttributes &attributes )
{
if ( !metAnnotationConfigurationTag && qName != "annotationConfiguration" )
{
errorStr = QObject::tr( "The file is not an Annotation Configuration file." );
return false;
}
if ( qName == "annotationConfiguration" )
{
metAnnotationConfigurationTag = true;
}
else if ( qName == "entity" )
{
QListWidgetItem *item = new QListWidgetItem(listWidget);
item->setFlags( item->flags() | Qt::ItemIsEditable );
if (m_isEditor)
{
item->setFlags( item->flags() | Qt::ItemIsUserCheckable);
}
item->setText( attributes.value( "name" ) );
QColor color( attributes.value( "color" ) );
QColor white( Qt::white );
QBrush brush( color );
colors->push_back( QColor( attributes.value( "color" ).toLower() ) );
(*colorNames2EntityTypes)[attributes.value( "color" ).toLower()] = attributes.value( "name" );
/// @todo setBackgroundColor is deprecated in QT 4.2, replace by
/// setBackground below after upgrading.
/// item->setBackgroundColor ( QColor( attributes.value( "color" ) ) );
if (attributes.value("recursive") == "true")
{
m_recursiveEntityTypes->push_back(attributes.value( "name" ));
QFont font = item->font();
font.setItalic(true);
font.setBold(true);
item->setFont(font);
if (m_isEditor)
{
item->setCheckState(Qt::Checked);
}
}
else
{
if (m_isEditor)
{
item->setCheckState(Qt::Unchecked);
}
}
item->setBackground ( brush );
item->setTextColor ( white );
}
return true;
}
void QtResourceViewPrivate::createResources(const QString &path)
{
const bool matchAll = m_filterPattern.isEmpty();
QDir dir(path);
QStringList fileNames = m_pathToContents.value(path);
QStringListIterator it(fileNames);
while (it.hasNext()) {
QString fileName = it.next();
const bool showProperty = matchAll || fileName.contains(m_filterPattern, Qt::CaseInsensitive);
if (showProperty) {
QString filePath = dir.absoluteFilePath(fileName);
QFileInfo fi(filePath);
if (fi.isFile()) {
QListWidgetItem *item = new QListWidgetItem(fi.fileName(), m_listWidget);
const QPixmap pix = QPixmap(filePath);
if (pix.isNull()) {
item->setToolTip(filePath);
} else {
item->setIcon(QIcon(makeThumbnail(pix)));
const QSize size = pix.size();
item->setToolTip(QtResourceView::tr("Size: %1 x %2\n%3").arg(size.width()).arg(size.height()).arg(filePath));
}
item->setFlags(item->flags() | Qt::ItemIsDragEnabled);
item->setData(Qt::UserRole, filePath);
m_itemToResource[item] = filePath;
m_resourceToItem[filePath] = item;
}
}
}
}
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);
}
void TreeWidgetEditor::fillContentsFromTreeWidget(QTreeWidget *treeWidget)
{
m_updating = true;
copyContents(treeWidget, ui.treeWidget);
ui.listWidget->clear();
QTreeWidgetItem *headerItem = ui.treeWidget->headerItem();
int colCount = ui.treeWidget->columnCount();
for (int col = 0; col < colCount; col++) {
QListWidgetItem *item = new QListWidgetItem(ui.listWidget);
item->setFlags(item->flags() | Qt::ItemIsEditable);
item->setText(headerItem->text(col));
item->setIcon(headerItem->icon(col));
item->setData(QAbstractFormBuilder::resourceRole(), headerItem->data(col, QAbstractFormBuilder::resourceRole()));
}
if (colCount > 0) {
ui.listWidget->setCurrentRow(0);
if (ui.treeWidget->topLevelItemCount() > 0)
ui.treeWidget->setCurrentItem(ui.treeWidget->topLevelItem(0));
}
m_updating = false;
updateEditor();
}
void PluginManager::init()
{
//
// initialize local shortcut table
// we need a deep copy to be able to rewind all
// changes on "Abort"
//
qDeleteAll(localShortcuts);
localShortcuts.clear();
foreach(const Shortcut* s, Shortcut::shortcuts())
localShortcuts[s->key()] = new Shortcut(*s);
shortcutsChanged = false;
preferences.updatePluginList();
int n = preferences.pluginList.size();
pluginList->clear();
for (int i = 0; i < n; ++i) {
PluginDescription& d = preferences.pluginList[i];
Shortcut* s = &d.shortcut;
localShortcuts[s->key()] = new Shortcut(*s);
QListWidgetItem* item = new QListWidgetItem(QFileInfo(d.path).completeBaseName(), pluginList);
item->setFlags(item->flags() | Qt::ItemIsEnabled);
item->setCheckState(d.load ? Qt::Checked : Qt::Unchecked);
item->setData(Qt::UserRole, i);
}
prefs = preferences;
if (n) {
pluginList->setCurrentRow(0);
pluginListItemChanged(pluginList->item(0), 0);
}
connect(pluginList, SIGNAL(itemChanged(QListWidgetItem*)), SLOT(pluginLoadToggled(QListWidgetItem*)));
connect(pluginList, SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)),
SLOT(pluginListItemChanged(QListWidgetItem*, QListWidgetItem*)));
}
void ModelView::add() {
QListWidgetItem* label = new QListWidgetItem ("New Author");
label->setFlags(label->flags () | Qt::ItemIsEditable);
ui->authorsList->addItem(label);
}
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 AddRemoveListWidget::addItem(QString itemText) {
QListWidgetItem *item = new QListWidgetItem();
item->setFlags(item->flags() | Qt::ItemIsEditable);
item->setText(itemText);
m_list->addItem(item);
m_list->editItem(item);
}
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 PreserveEntitiesWidget::addEntities()
{
QString list = QInputDialog::getText(this, tr("Add Entities"), tr("Entities:"));
if (list.isEmpty()) {
return;
}
list.replace(" ", ",");
list.replace(",", "\n");
QStringList names = list.split("\n");
// Add the entities to the list
foreach(QString name, names) {
if (!name.isEmpty()) {
if (XMLEntities::instance()->GetEntityCode(name) > 0) {
QListWidgetItem *item = new QListWidgetItem(name, ui.entityList);
item->setFlags(item->flags() | Qt::ItemIsEditable);
ui.entityList->addItem(item);
}
}
}
ui.entityList->sortItems(Qt::AscendingOrder);
m_isDirty = true;
}
/*
* 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();
}
void PoseEditor::addPoseItem(QString txt, Pose p) {
QListWidgetItem* add = new QListWidgetItem();
add->setText(txt);
add->setFlags(add->flags() | Qt::ItemIsEditable);
add->setData(Qt::UserRole, QVariant::fromValue(p));
posesList->addItem(add);
}
void HistoryElementModifyEvent::doEventPlace()
{
if(!m_scene)
return;
LvlScene* lvlScene;
if(!(lvlScene = qobject_cast<LvlScene*>(m_scene)))
return;
LevelSMBX64Event rmEvents = m_event;
MainWinConnect::pMainWin->dock_LvlEvents->setEventToolsLocked(true);
QListWidgetItem * item;
item = new QListWidgetItem;
item->setText(rmEvents.name);
item->setFlags(Qt::ItemIsEditable);
item->setFlags(item->flags() | Qt::ItemIsEnabled);
item->setFlags(item->flags() | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsSelectable);
item->setData(Qt::UserRole, QString::number(rmEvents.meta.array_id) );
QListWidget* evList = MainWinConnect::pMainWin->dock_LvlEvents->getEventList();
LevelSMBX64Event NewEvent = rmEvents;
lvlScene->m_data->events.push_back(NewEvent);
evList->addItem(item);
lvlScene->m_data->meta.modified = true;
MainWinConnect::pMainWin->EventListsSync();
MainWinConnect::pMainWin->dock_LvlEvents->setEventToolsLocked(false);
}
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);
}
QgsAttributeTypeDialog::QgsAttributeTypeDialog(QgsVectorLayer *vl , int fieldIdx )
: QDialog()
, mLayer( vl )
, mFieldIdx( fieldIdx )
{
setupUi( this );
connect( selectionListWidget, SIGNAL( currentRowChanged( int ) ), this, SLOT( setStackPage( int ) ) );
QMapIterator<QString, QgsEditorWidgetFactory*> it( QgsEditorWidgetRegistry::instance()->factories() );
while ( it.hasNext() )
{
it.next();
QListWidgetItem* item = new QListWidgetItem( selectionListWidget );
item->setText( it.value()->name() );
item->setData( Qt::UserRole, it.key() );
if ( !it.value()->supportsField( vl, fieldIdx ) )
item->setFlags( item->flags() & ~Qt::ItemIsEnabled );
selectionListWidget->addItem( item );
}
// Set required list width based on content + twice the border width
selectionListWidget->setMinimumWidth( selectionListWidget->sizeHintForColumn( 0 )
+ 2 );
selectionListWidget->setMaximumWidth( selectionListWidget->sizeHintForColumn( 0 )
+ 2 );
}
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);
}
}
}
}
void MainWindow::UpdateRecentContest(bool updateRecentListWidget)
{
QSettings set("ccr.ini", QSettings::IniFormat);
QStringList list = set.value("RecentContestList").toStringList();
lastContest = set.value("LastContest").toString();
int n = std::min(list.size(), Global::MAX_RECENT_CONTEST);
for (int i = 0; i < n; i++)
{
QString s = QString("&%1 %2").arg(i + 1).arg(list[i]);
action_recent_list[i]->setText(s);
action_recent_list[i]->setData(list[i]);
action_recent_list[i]->setVisible(true);
}
for (int i = n; i < Global::MAX_RECENT_CONTEST; i++) action_recent_list[i]->setVisible(false);
ui->menu_recent->setEnabled((bool)n);
if (!updateRecentListWidget) return;
ui->listWidget_recent->clear();
for (auto i : list)
{
QPixmap icon = Contest::CreateIcon(i + "/");
QListWidgetItem* item = new QListWidgetItem(QIcon(icon), i, ui->listWidget_recent);
item->setToolTip(item->text());
item->setFlags(item->flags()^Qt::ItemIsDragEnabled);
ui->listWidget_recent->addItem(item);
if (i == lastContest) ui->listWidget_recent->setCurrentItem(item);
}
}
void MainWindow::flickrCallback(void)
{
urlList = collector->list();
if(urlList.size()==0)
{
createFlickr();
cout << "something hacky" << endl;
}
else
{
allCollections.push_back(urlList);
QListWidgetItem *collectionItem = new QListWidgetItem();
collectionItem->setFlags(collectionItem->flags() | Qt::ItemIsEditable);
collectionItem->setText(collector->collectionName());
leftPanel->addItem(collectionItem);
QString url;
connect(bottom, SIGNAL(animationChanged(int)), this, SLOT(resetMainImage(int)));
int size = urlList.size();
for(int i=0; i<size; i++)
{
url = urlList.at(i);
image->loadImage(url);
}
}
currentCollection = leftPanel->count()-1;
}
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);
}
}
bool BCI2000Viewer::StateSelected() const
{
int currentRow = ui->channelList->currentRow();
bool isStateEntry = false;
if( currentRow > 0 )
{
int i = currentRow;
QListWidgetItem* p;
do
{
p = ui->channelList->item( i++ );
} while( p->flags() & Qt::ItemIsUserCheckable && i < ui->channelList->count() );
isStateEntry = ( i < ui->channelList->count() );
}
if( isStateEntry )
{
ui->actionState_Help->setText( QString( tr("Help on %1") ).arg( ui->channelList->currentItem()->text() ) );
ui->actionState_Help->setEnabled( true );
}
else
{
ui->actionState_Help->setText( tr("BCI2000 Help") );
ui->actionState_Help->setDisabled( true );
}
return isStateEntry;
}
void KbAnimWidget::refreshList(){
noReorder = true;
setCurrent(0);
ui->animList->clear();
animations.clear();
// Add the animations from the new lighting mode
if(!light){
ui->animList->setVisible(false);
ui->noAnimLabel->setVisible(true);
return;
}
QList<KbAnim*> newAnimations = light->animList();
if(newAnimations.count() == 0){
ui->animList->setVisible(false);
ui->noAnimLabel->setVisible(true);
return;
}
ui->animList->setVisible(true);
foreach(KbAnim* anim, newAnimations){
QListWidgetItem* item = new QListWidgetItem(anim->name(), ui->animList);
item->setData(Qt::UserRole, anim->guid());
item->setFlags(item->flags() | Qt::ItemIsEditable);
animations[anim->guid()] = anim;
ui->animList->addItem(item);
}
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 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());
}
}
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()));
}
//! [1]
void SubscriberDialog::subscriberChanged()
{
QStringList subPaths = subscriber->subPaths();
if (listWidget) {
listWidget->clear();
} else if (tableWidget) {
tableWidget->clearContents();
tableWidget->setRowCount(subPaths.count());
}
for (int i = 0; i < subPaths.count(); ++i) {
QVariant v = subscriber->value(subPaths.at(i));
if (listWidget) {
const QString itemTemplate("%1 (%2)\n%3");
QListWidgetItem *item =
new QListWidgetItem(itemTemplate.arg(subPaths.at(i), v.typeName(), v.toString()));
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
listWidget->addItem(item);
} else if (tableWidget) {
QTableWidgetItem *pathItem = new QTableWidgetItem(subPaths.at(i));
pathItem->setFlags(pathItem->flags() & ~Qt::ItemIsEditable);
QTableWidgetItem *valueItem = new QTableWidgetItem(v.toString());
valueItem->setFlags(valueItem->flags() & ~Qt::ItemIsEditable);
QTableWidgetItem *typeItem = new QTableWidgetItem(v.typeName());
typeItem->setFlags(typeItem->flags() & ~Qt::ItemIsEditable);
tableWidget->setItem(i, 0, pathItem);
tableWidget->setItem(i, 1, valueItem);
tableWidget->setItem(i, 2, typeItem);
}
}
}
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 TreeWidgetEditor::on_newColumnButton_clicked()
{
m_updating = true;
QListWidgetItem *currentColumn = ui.listWidget->currentItem();
int idx = ui.listWidget->count();
if (currentColumn)
idx = ui.listWidget->currentRow() + 1;
QString newColumnString = tr("New Column");
int columnCount = ui.treeWidget->columnCount();
ui.treeWidget->setColumnCount(columnCount + 1);
ui.treeWidget->headerItem()->setText(columnCount, newColumnString);
moveColumnsLeft(idx, columnCount);
QListWidgetItem *item = new QListWidgetItem();
item->setFlags(item->flags() | Qt::ItemIsEditable);
item->setText(newColumnString);
ui.listWidget->insertItem(idx, item);
ui.listWidget->setCurrentItem(item);
ui.treeWidget->setCurrentItem(ui.treeWidget->currentItem(), ui.listWidget->currentRow());
m_updating = false;
updateEditor();
ui.listWidget->editItem(item);
}
void ComboboxFieldWizard::loadField(const int fieldId, const int collectionId)
{
AbstractFieldWizard::loadField(fieldId, collectionId);
MetadataEngine *meta = &MetadataEngine::getInstance();
//display properties
QString displayProperties = meta->getFieldProperties(meta->DisplayProperty,
fieldId, collectionId);
MetadataPropertiesParser displayParser(displayProperties);
if (displayParser.getValue("markEmpty") == "1")
ui->requiredFieldCheckBox->setChecked(true);
//get items
if (displayProperties.size()) {
QStringList items = displayParser.getValue("items")
.split(',', QString::SkipEmptyParts);
foreach (QString s, items) {
//replace some escape codes
s.replace("\\comma", ",");
s.replace("\\colon", ":");
s.replace("\\semicolon", ";");
QListWidgetItem *item = new QListWidgetItem(s,
ui->itemsListWidget);
item->setFlags(item->flags() | Qt::ItemIsEditable);
}
