C++ QStandardItem::setEnabled方法代码示例

void ProjectChangesModel::addProject(IProject* p)
{
    QStandardItem* it = new QStandardItem(p->name());
    it->setData(p->name(), ProjectChangesModel::ProjectNameRole);
    IPlugin* plugin = p->versionControlPlugin();
    if(plugin) {
        IBasicVersionControl* vcs = plugin->extension<IBasicVersionControl>();

        auto info = ICore::self()->pluginController()->pluginInfo(plugin);

        it->setIcon(QIcon::fromTheme(info.iconName()));
        it->setToolTip(vcs->name());

        IBranchingVersionControl* branchingExtension = plugin->extension<KDevelop::IBranchingVersionControl>();
        if(branchingExtension) {
            const auto pathUrl = p->path().toUrl();
            branchingExtension->registerRepositoryForCurrentBranchChanges(pathUrl);
            // can't use new signal slot syntax here, IBranchingVersionControl is not a QObject
            connect(plugin, SIGNAL(repositoryBranchChanged(QUrl)), this, SLOT(repositoryBranchChanged(QUrl)));
            repositoryBranchChanged(pathUrl);
        } else
            reload(QList<IProject*>() << p);
    } else {
        it->setEnabled(false);
    }
    
    appendRow(it);
}

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 SoundThemeSelector::fillModel(const SoundTheme &theme)
{
	QStringList headers;
	headers.append(QT_TRANSLATE_NOOP("Notifications", "Type"));
	headers.append(QT_TRANSLATE_NOOP("SoundTheme", "Preview"));
	m_model->setHorizontalHeaderLabels(headers);

	for (int i = 0; i <= Notification::LastType; ++i) {
		Notification::Type type = static_cast<Notification::Type>(i);
		QList<QStandardItem *> items;

		QStandardItem *item = new QStandardItem(Notification::typeString(type));
		item->setToolTip(QT_TRANSLATE_NOOP("SoundTheme","Type"));
		item->setSelectable(false);
		items << item;

		item = new QStandardItem();
		item->setEditable(false);
		item->setIcon(Icon("media-playback-start"));
		item->setToolTip(QT_TRANSLATE_NOOP("SoundTheme","Play"));
		item->setEnabled(!theme.path(type).isNull());
		item->setSelectable(false);
		items << item;

		m_model->appendRow(items);
	}
	ui->treeView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
}

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 DefaultFilterModel::addSeparator(const QString &caption)
{
    QList<QStandardItem *> newRow;
    QStandardItem *item = new QStandardItem(caption);
    item->setEnabled(false);
    item->setData(true, SeparatorRole);

    newRow << item;
    appendRow(newRow);
}

DirKnot * HPSKnotDirModel::creatNewDeactiveKnot(const QString &name, const bool isExpanded)
{
    DirKnot *newKnot = new DirKnot();
    newKnot->name = name;

    QStandardItem *newItem = new QStandardItem(name);
    newItem->setEnabled(false);
    newItem->setData(isExpanded,Qt::UserRole+1);
    newKnot->item = newItem;

    return newKnot;
}

FlightVisualization::FlightVisualization(QWidget * parent) :
    QWidget(parent), ui(new Ui::Form)
{
    ui->setupUi(this);
    popupPlaneSelector = new QListWidget();
    popupPlaneSelector->setWindowTitle(POPUP_SELECTOR_TITLE);
    QListWidgetItem * item = new QListWidgetItem(ALL_PLANES_LABEL,
            popupPlaneSelector);

    item->setCheckState(Qt::Checked);
    popupPlaneSelector->addItem(item);

    connect(ui -> flightPathCheckBox, SIGNAL(stateChanged(int)), this, SLOT(toggleFlightPath(int)));
    connect(ui -> wayPointCheckBox, SIGNAL(stateChanged(int)), this, SLOT(toggleWayPoints(int)));
    connect(ui -> webView, SIGNAL(loadFinished(bool)), this, SLOT(loadFinished(bool)));
    connect(ui -> autoCenterCheckBox, SIGNAL(stateChanged(int)), this, SLOT(toggleAutoCenter(int)));
    connect(ui -> autoFitCheckBox, SIGNAL(stateChanged(int)), this, SLOT(toggleAutoFit(int)));
    connect(ui->resetFlightPathButton, SIGNAL(clicked()), this,
            SLOT(resetFlightPaths()));
    connect(ui -> planeSelectorComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(setCurrentPlane(int)));
    connect(ui->selectPlaneButton, SIGNAL(clicked()), this,
            SLOT(showPlaneSelector()));
    connect(popupPlaneSelector, SIGNAL(itemClicked(QListWidgetItem*)), SLOT(togglePlaneVisibility(QListWidgetItem*)));
    QWebSettings::globalSettings()->setAttribute(QWebSettings::PluginsEnabled,
            true);
    ui->webView->setUrl(VIZ_MAP_URL);

    // http://stackoverflow.com/questions/12523753/sleep-inside-a-loop-that-uses-paintevent-in-qt-c
    connect(&_timer, SIGNAL(timeout()), this, SLOT(adjustMapCenter()));

    _timer.start(AUTO_CENTER_DURATION);

    //initialize everything in the active planes to the defaults. There is probably a better/more efficienct way to initialize the struct, but I was short on time.
    for (int i = 0; i < TOTAL_NUM_OF_PLANES; i++) {
        activePlanes[i].planeActive = false;
        activePlanes[i].latitude = 0;
        activePlanes[i].longitude = 0;
    }

    firstMessage = true;
    autoFitMap = false;
    currentPlane = INVALID_PLANE_ID;

    // prevent "select a plane" from being selectable
    QStandardItemModel * model = qobject_cast<QStandardItemModel *>(
                                     ui->planeSelectorComboBox->model());
    QModelIndex firstIndex = model->index(0,
                                          ui->planeSelectorComboBox->modelColumn(),
                                          ui->planeSelectorComboBox->rootModelIndex());
    QStandardItem * firstItem = model->itemFromIndex(firstIndex);
    firstItem->setEnabled(false);
}

void PluginDialog::addDefaultNodes()
{
    QList<QStandardItem *> rowItems;
    QStandardItem* scItem = new QStandardItem(QIcon(":/uploaders/screencloud.png"), "ScreenCloud");
    scItem->setData("screencloud", Qt::UserRole);
    //scItem->setEnabled(false);
    rowItems << scItem;
    QStandardItem* enableItem = new QStandardItem("");
    enableItem->setCheckable(true);
    enableItem->setCheckState(Qt::Checked);
    enableItem->setEnabled(false);
    rowItems << enableItem;
    categoryOnline->appendRow(rowItems);
}

InterceptWidget::InterceptWidget(IntercepSource * source, QWidget *parent) :
    QWidget(parent),
    source(source)
{
    currentBlockSource = NULL;
    currentGui = NULL;
    ui = new(std::nothrow) Ui::InterceptWidget;
    if (ui == NULL) {
        qFatal("Cannot allocate memory for Ui::InterceptWidget X{");
    }
    ui->setupUi(this);

    packetsTable = new(std::nothrow) QTableView(this);
    if (packetsTable == NULL) {
        qFatal("Cannot allocate memory for QTableView X{");
    }
    QAbstractItemModel *old = packetsTable->model();
    model = source->getModel();
    packetsTable->setModel(model);
    delete old;

    packetsTable->setSelectionMode(QAbstractItemView::ContiguousSelection);
    packetsTable->setSelectionBehavior(QAbstractItemView::SelectRows);
    packetsTable->verticalHeader()->setFont(RegularFont);
    packetsTable->horizontalHeader()->setFont(RegularFont);
    packetsTable->setColumnWidth(PayloadModel::TIMESPTAMP_COLUMN,TIMESTAMP_COLUMN_WIDTH);
    packetsTable->setColumnWidth(PayloadModel::DIRECTION_COLUMN,25);
    packetsTable->verticalHeader()->setDefaultSectionSize(20);
#if QT_VERSION >= 0x050000
    packetsTable->horizontalHeader()->setSectionsMovable( false );
#else
    packetsTable->horizontalHeader()->setMovable(true);
#endif
    connect(packetsTable->selectionModel(), SIGNAL(currentRowChanged(QModelIndex,QModelIndex)), SLOT(onCurrentSelectedChanged(QModelIndex,QModelIndex)));
    ui->listLayout->addWidget(packetsTable);

    updateColumns();

    sourceChoices << CHOOSE_TEXT << UDP_EXTERNAL_SOURCE_TEXT << TCP_EXTERNAL_SOURCE_TEXT << RAW_TCP_SOURCE_TEXT;
    ui->blockSourceComboBox->addItems(sourceChoices);
    ui->blockSourceComboBox->setCurrentIndex(0);
    QStandardItem * item = qobject_cast<QStandardItemModel *>(ui->blockSourceComboBox->model())->item(0);
    item->setEnabled( false );
    item->setTextAlignment(Qt::AlignCenter);
    item->setBackground(Qt::darkGray);
    item->setForeground(Qt::white);

    connect(ui->blockSourceComboBox, SIGNAL(currentIndexChanged(QString)), SLOT(onSourceChanged(QString)));
}

void BarPackageModel::load(const QVariantList &datas)
{
clear();
setHorizontalHeaderLabels(QStringList()<<"application"<<"version");


foreach ( QVariant item, datas)
{


    QString rawName =item.toMap().value("name").toString();
    QString id =item.toMap().value("id").toString();
    QString version =item.toMap().value("version").toString();


    QStringList names = rawName.remove(id.replace("-",".")).split(".");




    QString name = names[names.length()-2];

    QStandardItem * nameItem = new QStandardItem(0);
    nameItem->setData(item);
    nameItem->setText(name);
    nameItem->setIcon(QIcon(":app.png"));
    if (rawName.contains("sys"))
    nameItem->setEnabled(false);

    QStandardItem * versionItem = new QStandardItem(1);
    versionItem->setText(version);

    QList<QStandardItem*> items;
    items.append(nameItem);
    items.append(versionItem);

    appendRow(items);




}

OrchestratorChooser::OrchestratorChooser(GuiHelper *guiHelper, SourcesOrchestatorAbstract *orchestrator, QWidget *parent) :
    QComboBox(parent),
    orchestrator(orchestrator),
    guiHelper(guiHelper)
{

    addItem(tr("Select IO type"));
    QStandardItem * item = qobject_cast<QStandardItemModel *>(model())->item(0); // there is one and only one item right now
    item->setEnabled( false );
    addItems(SourcesOrchestatorAbstract::OrchestratorsList);

    setToolTip(tr("Select a configuration"));

    if (orchestrator != nullptr) {
        setCurrentIndex(orchestrator->getType());
    }

    //connect(this, qOverload<int>(&OrchestratorChooser::currentIndexChanged), this, &OrchestratorChooser::onSelection);
    connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(onSelection(int)));
}

void repo::gui::RepoDialogUserManager::addUser(const core::RepoUser &user)
{
    QList<QStandardItem *> row;
    //--------------------------------------------------------------------------
    // User object itself
    QVariant var;
    var.setValue(user);

    QStandardItem *item = new QStandardItem();
    item->setData(var);
    item->setEnabled(true);
    item->setCheckable(true);
    item->setCheckState(Qt::Checked);
    item->setTristate(false);
    item->setEditable(false);
    row.append(item);

    // Username
    row.append(createItem(QString::fromStdString(user.getUsername())));

    // First Name
    row.append(createItem(QString::fromStdString(user.getFirstName())));

    // Last Name
    row.append(createItem(QString::fromStdString(user.getLastName())));

    // Email
    row.append(createItem(QString::fromStdString(user.getEmail())));

    // Projects count
    row.append(createItem((qulonglong)(user.getProjectsList().size())));

    // Groups count
    row.append(createItem((qulonglong)(user.getGroupsList().size())));

    // Roles count
    row.append(createItem((qulonglong)(user.getRolesList().size())));

    //--------------------------------------------------------------------------
    model->invisibleRootItem()->appendRow(row);
}

QgsMilXLibrary::QgsMilXLibrary( QgisInterface *iface, QWidget *parent )
    : QWidget( parent ), mIface( iface ), mLoader( 0 )
{
  setWindowFlags( Qt::Popup );
  setObjectName( "QgsMilXLibrary" );
  setStyleSheet( "QWidget#QgsMilXLibrary { background-color: white;}" );

  QVBoxLayout* layout = new QVBoxLayout( this );
  layout->setMargin( 2 );
  layout->setSpacing( 2 );
  setLayout( layout );

  mFilterLineEdit = new QgsFilterLineEdit( this );
  mFilterLineEdit->setPlaceholderText( tr( "Filter..." ) );
  layout->addWidget( mFilterLineEdit );
  connect( mFilterLineEdit, SIGNAL( textChanged( QString ) ), this, SLOT( filterChanged( QString ) ) );

  mTreeView = new QTreeView( this );
  mTreeView->setFrameShape( QTreeView::NoFrame );
  mTreeView->setEditTriggers( QTreeView::NoEditTriggers );
  mTreeView->setHeaderHidden( true );
  mTreeView->setIconSize( QSize( 32, 32 ) );
  layout->addWidget( mTreeView );
  connect( mTreeView, SIGNAL( clicked( QModelIndex ) ), this, SLOT( itemClicked( QModelIndex ) ) );

  mGalleryModel = new QStandardItemModel( this );
  mFilterProxyModel = new TreeFilterProxyModel( this );
  mFilterProxyModel->setSourceModel( mGalleryModel );

  mLoadingModel = new QStandardItemModel( this );
  QStandardItem* loadingItem = new QStandardItem( tr( "Loading..." ) );
  loadingItem->setEnabled( false );
  mLoadingModel->appendRow( loadingItem );

  setCursor( Qt::WaitCursor );
  mTreeView->setModel( mLoadingModel );
  mLoader = new QgsMilXLibraryLoader( this );
  connect( mLoader, SIGNAL( finished() ), this, SLOT( loaderFinished() ) );
  mLoader->start();
}

QList<QStandardItem*> DkFileAssociationsPreference::getItems(const QString& filter, bool browse, bool reg) {

	QList<QStandardItem* > items;
	QStandardItem* item = new QStandardItem(filter);
	item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
	items.append(item);
	item = new QStandardItem("");
	//item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable);
	item->setCheckable(true);
	item->setCheckState(browse ? Qt::Checked : Qt::Unchecked);
	items.append(item);
	item = new QStandardItem("");
	//item->setFlags(Qt::Qt::ItemIsSelectable | Qt::ItemIsUserCheckable);
	item->setCheckable(true);
	item->setCheckState(reg ? Qt::Checked : Qt::Unchecked);
#ifndef Q_OS_WIN	// registering is windows only
	item->setEnabled(false);
#endif
	items.append(item);

	return items;

}

void TransformsGui::buildSavedCombo()
{
    ui->savedComboBox->blockSignals(true);
    ui->savedComboBox->clear();
    int row = 0;
    // first inactive element
    ui->savedComboBox->addItem(QString("User's chains"));
    QStandardItem * item = qobject_cast<QStandardItemModel *>(ui->savedComboBox->model())->item( row );
    item->setEnabled( false );
    item->setTextAlignment(Qt::AlignCenter);
    item->setBackground(Qt::darkGray);
    item->setForeground(Qt::white);
    // then the rest
    QHash<QString, QString> hash = transformFactory->getSavedConfs();
    QStringList list = hash.keys();
    if (list.isEmpty()) {
        ui->savedComboBox->setEnabled(false);
    } else {
        ui->savedComboBox->addItems(list);
        ui->savedComboBox->setEnabled(true);
    }

    ui->savedComboBox->blockSignals(false);
}