void ResourceManager::on_twResources_customContextMenuRequested(const QPoint &pos)
{
QTreeWidgetItem *item = twResources->itemAt(pos);
if (item != NULL)
{
if (item->childCount() > 0)
{
QMenu *popupMenu = new QMenu(this);
QAction *action;
popupMenu->addAction(aCheckAll);
popupMenu->addAction(aCheckAllRecursively);
popupMenu->addAction(aUncheckAll);
popupMenu->addAction(aUncheckAllRecursively);
action = popupMenu->exec(QCursor::pos());
if (action == aCheckAll)
setCheckState(item, Qt::Checked);
else if (action == aCheckAllRecursively)
setCheckStateRecursively(item, Qt::Checked);
else if (action == aUncheckAll)
setCheckState(item, Qt::Unchecked);
else if (action == aUncheckAllRecursively)
setCheckStateRecursively(item, Qt::Unchecked);
}
}
}
void MenuCheckBox::nextCheckState()
{
if(this->checkState() == Qt::Checked)
setCheckState(Qt::Unchecked);
else
setCheckState(Qt::Checked);
}
void CLabel::setChecked(bool checked){
if( checked ){
setCheckState(Qt::Checked);
} else {
setCheckState(Qt::Unchecked);
}
}
FlagsComboBox::FlagsComboBox(QWidget *parent):
QComboBox(parent)
{
setModel(new QStandardItemModel(this));
setEditable(false);
setItemDelegate(new QStyledItemDelegate(this));
auto item = new QStandardItem;
item->setFlags(Qt::ItemIsEnabled);
standardItemModel()->appendRow(item);
connect(view(), &QListView::pressed, this, [this](const QModelIndex &index)
{
auto item = standardItemModel()->itemFromIndex(index);
if(!(item->flags() & Qt::ItemIsUserCheckable))
return;
if(item->checkState() == Qt::Checked)
item->setCheckState(Qt::Unchecked);
else
item->setCheckState(Qt::Checked);
});
connect(standardItemModel(), &QStandardItemModel::dataChanged, this, [this]()
{
updateText();
emit flagsChanged(flags());
});
}
void OpenMediaFolderDialog::updateList() {
const auto folder = d->ui.folder->text();
if (!folder.isEmpty()) {
d->ui.list->clear();
QDir dir(folder);
static const auto filters = Info::mediaNameFilter();
const QFileInfoList files = dir.entryInfoList(filters, QDir::Files, QDir::Name);
for (int i=0; i<files.size(); ++i) {
auto item = new QListWidgetItem(files[i].fileName(), d->ui.list);
QCheckBox *box = nullptr;
item->setCheckState(Qt::Unchecked);
const QString suffix = files[i].suffix();
if (Info::videoExt().contains(suffix, Qt::CaseInsensitive))
box = d->ui.videos;
else if (Info::videoExt().contains(suffix, Qt::CaseInsensitive))
box = d->ui.audios;
else if (Info::readableImageExt().contains(suffix, Qt::CaseInsensitive))
box = d->ui.images;
Q_ASSERT(box);
item->setIcon(d->icons.icon(files[i]));
item->setData(Type, QVariant::fromValue(box));
item->setData(Path, files[i].absoluteFilePath());
item->setCheckState(box->isChecked() ? Qt::Checked : Qt::Unchecked);
}
updateOpenButton();
}
}
void ResourceItem::setOn( bool checked )
{
if ( checked ) {
setCheckState( 0, Qt::Checked );
} else {
setCheckState( 0, Qt::Unchecked );
}
mActive = checked;
}
void WAbstractToggleButton::setValueText(const WT_USTRING& text)
{
if (text == "yes")
setCheckState(Checked);
else if (text == "no")
setCheckState(Unchecked);
else if (text == "maybe")
setCheckState(PartiallyChecked);
}
void VisibleCheckBox::nextCheckState()
{
if(m_item->isVisible())
setCheckState(Qt::Unchecked);
else if(m_item->wouldBeVisibleRecursive())
setCheckState(Qt::Checked);
else
setCheckState(Qt::PartiallyChecked);
}
void _k9ItemWidget::titleChanged() {
if (title->isSelected()) {
setCheckState(0,Qt::Checked);
astTitle->titleSelected(title);
} else {
setCheckState(0,Qt::Unchecked);
astTitle->titleUnSelected(title);
}
}
void KexiDBCheckBox::setValueInternal(const QVariant &add, bool removeOld)
{
Q_UNUSED(add);
Q_UNUSED(removeOld);
if (isTristateInternal())
setCheckState(m_origValue.isNull()
? Qt::PartiallyChecked : (m_origValue.toBool() ? Qt::Checked : Qt::Unchecked));
else
setCheckState(m_origValue.toBool() ? Qt::Checked : Qt::Unchecked);
}
KateDocItem( KTextEditor::Document *doc, const QString &status, QTreeWidget *tw )
: QTreeWidgetItem( tw ),
document( doc )
{
setText( 0, doc->url().prettyUrl() );
setText( 1, status );
if ( ! doc->isModified() )
setCheckState( 0, Qt::Checked );
else
setCheckState( 0, Qt::Unchecked );
}
void updateInterfaceColumns(interface_t *device)
{
if (!device) return;
QString default_str = QObject::tr("default");
QString linkname = QObject::tr("DLT %1").arg(device->active_dlt);
for (GList *list = device->links; list != NULL; list = g_list_next(list)) {
link_row *linkr = (link_row*)(list->data);
// XXX ...and if they're both -1?
if (linkr->dlt == device->active_dlt) {
linkname = linkr->name;
break;
}
}
setText(col_link_, linkname);
#ifdef HAVE_EXTCAP
if (device->if_info.type == IF_EXTCAP) {
/* extcap interfaces does not have this settings */
setData(col_pmode_, Qt::CheckStateRole, QVariant());
setApplicable(col_pmode_, false);
setApplicable(col_snaplen_, false);
#ifdef SHOW_BUFFER_COLUMN
setApplicable(col_buffer_, false);
#endif
} else {
#endif
setApplicable(col_pmode_, true);
setCheckState(col_pmode_, device->pmode ? Qt::Checked : Qt::Unchecked);
QString snaplen_string = device->has_snaplen ? QString::number(device->snaplen) : default_str;
setText(col_snaplen_, snaplen_string);
#ifdef SHOW_BUFFER_COLUMN
setText(col_buffer_, QString::number(device->buffer));
#endif
#ifdef HAVE_EXTCAP
}
#endif
setText(col_filter_, device->cfilter);
#ifdef SHOW_MONITOR_COLUMN
if (device->monitor_mode_supported) {
setApplicable(col_monitor_, true);
setCheckState(col_monitor_, device->monitor_mode_enabled ? Qt::Checked : Qt::Unchecked);
} else {
setApplicable(col_monitor_, false);
}
#endif
}
BracketStackItem::BracketStackItem(QTreeWidget* const parent)
: QTreeWidgetItem(parent)
{
setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
setCheckState(0, Qt::Unchecked);
setThumbnail(SmallIcon("image-x-generic", treeWidget()->iconSize().width(), KIconLoader::DisabledState));
}
void QtPropertyItem::ApplyDataFlags()
{
if(NULL != itemData)
{
int dataFlags = itemData->GetFlags();
if(dataFlags & QtPropertyData::FLAG_IS_CHECKABLE)
{
setCheckable(true);
if(itemData->GetValue().toBool())
{
setCheckState(Qt::Checked);
}
}
if(dataFlags & QtPropertyData::FLAG_IS_DISABLED)
{
setEnabled(false);
}
if(dataFlags & QtPropertyData::FLAG_IS_NOT_EDITABLE)
{
setEditable(false);
}
}
}
UIBootTableItem::UIBootTableItem(KDeviceType type)
: m_type(type)
{
setCheckState(Qt::Unchecked);
switch(type)
{
case KDeviceType_Floppy:
{
setIcon(QIcon(":fd_16px.png"));
break;
}
case KDeviceType_DVD:
{
setIcon(QIcon(":cd_16px.png"));
break;
}
case KDeviceType_HardDisk:
{
setIcon(QIcon(":hd_16px.png"));
break;
}
case KDeviceType_Network:
{
setIcon(QIcon(":nw_16px.png"));
break;
}
}
retranslateUi();
}
void QgsLegendGroup::updateCheckState()
{
std::list<QgsLegendLayerFile*> llfiles = legendLayerFiles();
if ( llfiles.size() < 1 )
{
return;
}
std::list<QgsLegendLayerFile*>::iterator iter = llfiles.begin();
Qt::CheckState theState = ( *iter )->checkState( 0 );
for ( ; iter != llfiles.end(); ++iter )
{
if ( theState != ( *iter )->checkState( 0 ) )
{
theState = Qt::PartiallyChecked;
break;
}
}
if ( theState != checkState( 0 ) )
{
treeWidget()->blockSignals( true );
setCheckState( 0, theState );
treeWidget()->blockSignals( false );
}
}
QgsLegendLayerFile::QgsLegendLayerFile( QTreeWidgetItem * theLegendItem, QString theString, QgsMapLayer* theLayer )
: QgsLegendItem( theLegendItem, theString ), mLyr( theLayer )
{
// Set the initial visibility flag for layers
// This user option allows the user to turn off inital drawing of
// layers when they are added to the map. This is useful when adding
// many layers and the user wants to adjusty symbology, etc prior to
// actually viewing the layer.
QSettings settings;
bool visible = settings.value( "/qgis/new_layers_visible", true ).toBool();
mLyr.setVisible( visible );
// not in overview by default
mLyr.setInOverview( FALSE );
mType = LEGEND_LAYER_FILE;
setFlags( Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable );
setCheckState( 0, Qt::Checked );
setText( 0, theString );
// Add check if vector layer when connecting to selectionChanged slot
// Ticket #811 - racicot
QgsMapLayer *currentLayer = mLyr.layer();
QgsVectorLayer *isVectLyr = dynamic_cast < QgsVectorLayer * >( currentLayer );
if ( isVectLyr )
{
connect( mLyr.layer(), SIGNAL( editingStarted() ), this, SLOT( updateLegendItem() ) );
connect( mLyr.layer(), SIGNAL( editingStopped() ), this, SLOT( updateLegendItem() ) );
}
connect( mLyr.layer(), SIGNAL( layerNameChanged() ), this, SLOT( layerNameChanged() ) );
}
FolderTreeItem::FolderTreeItem( QTreeWidgetItem* parent, Folder* folder, Preferences& prefs, PropertiesPanel* propsPanel )
: TreeItem( parent ), folder( folder ), prefs( prefs ), propsPanel( propsPanel ) {
// It's important to setCheckState() first. Otherwise, if a change is made too soon,
// it may reset the markedForStudy property by an event.
setCheckState( 0, folder->isMarkedForStudy() ? Qt::Checked : Qt::Unchecked );
setText( 0, folder->getTitle() );
}
AlcasFunction::AlcasFunction(QString str, QListWidget *listwidget) {
setText(str);
setCheckState(Qt::Checked);
listwidget->addItem(this);
}
CWizTagListWidgetItem(const WIZTAGDATA& tag, QListWidget* parent = 0)
: QListWidgetItem(parent)
, m_tag(tag)
{
setText(WizDatabase::tagNameToDisplayName(tag.strName));
setFlags(flags() | Qt::ItemIsUserCheckable);
setCheckState(Qt::Unchecked);
}
LinkedCheckBox::LinkedCheckBox(const QString& str, const BitFieldWrapper& bitfield) : QCheckBox(str), bitfield(bitfield)
{
// assert(bitfield.NumBits() == 1);//TODO: Enable!
setCheckState((bitfield != 0) ? Qt::Checked : Qt::Unchecked);
connect(this, SIGNAL(stateChanged(int)), this, SLOT(OnStateChanged(int)));
}
KatePluginListItem::KatePluginListItem(bool checked, KatePluginInfo *info)
: QTreeWidgetItem()
, mInfo(info)
{
setCheckState(0, checked ? Qt::Checked : Qt::Unchecked);
// skip plugins that will be loaded always!
setDisabled (info->alwaysLoad);
}
_k9ItemWidget::_k9ItemWidget(k9DVDChapter *_chapter,QTreeWidgetItem *_treeWidget,int _type):QObject(0),QTreeWidgetItem(_treeWidget,_type) {
chapter=_chapter;
setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsSelectable);
setCheckState(0,Qt::Unchecked);
connect (chapter,SIGNAL(selectionChanged()),this,SLOT(chapterChanged()));
setTextAlignment(2,Qt::AlignRight);
setTextAlignment(3,Qt::AlignRight);
}
AbstractKateSaveModifiedDialogCheckListItem(const QString& title, const QString& url): QTreeWidgetItem()
{
setFlags(flags() | Qt::ItemIsUserCheckable);
setText(0, title);
setText(1, url);
setCheckState(0, Qt::Checked);
setState(InitialState);
}
Background::Background() : m_backgroundColor(Preferences::BackgroundColor()),
m_foregroundColor(Preferences::ForegroundColor()), m_configurator(*this)
{
setText("Background");
setCheckState(Qt::Checked);
setConfigurator(&m_configurator);
connect(newAction("Edit Color"), SIGNAL(triggered()), this, SLOT(configure()));
}
void VarUnit::buildVarTree(QTreeWidgetItem* p, TVar* var, bool showHidden)
{
QList<QTreeWidgetItem*> cList;
QListIterator<TVar*> it(var->getChildren(true));
while (it.hasNext()) {
TVar* child = it.next();
if (showHidden || !isHidden(child)) {
QStringList s1;
s1 << child->getName();
auto pItem = new QTreeWidgetItem(s1);
pItem->setText(0, child->getName());
pItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDropEnabled | Qt::ItemIsDragEnabled | Qt::ItemIsTristate | Qt::ItemIsUserCheckable);
pItem->setToolTip(0, "Checked variables will be saved and loaded with your profile.");
pItem->setCheckState(0, Qt::Unchecked);
if (isSaved(child)) {
pItem->setCheckState(0, Qt::Checked);
}
if (!shouldSave(child)) { // 6 is lua_tfunction, parent must be saveable as well if not global
pItem->setFlags(pItem->flags() & ~(Qt::ItemIsDropEnabled | Qt::ItemIsDragEnabled | Qt::ItemIsUserCheckable));
pItem->setForeground(0, QBrush(QColor("grey")));
pItem->setToolTip(0, "");
}
pItem->setData(0, Qt::UserRole, child->getValueType());
QIcon icon;
switch (child->getValueType()) {
case 5:
icon.addPixmap(QPixmap(QStringLiteral(":/icons/table.png")), QIcon::Normal, QIcon::Off);
break;
case 6:
icon.addPixmap(QPixmap(QStringLiteral(":/icons/function.png")), QIcon::Normal, QIcon::Off);
break;
default:
icon.addPixmap(QPixmap(QStringLiteral(":/icons/variable.png")), QIcon::Normal, QIcon::Off);
break;
}
pItem->setIcon(0, icon);
wVars.insert(pItem, child);
cList.append(pItem);
if (child->getValueType() == 5) {
buildVarTree((QTreeWidgetItem*)pItem, child, showHidden);
}
}
}
p->addChildren(cList);
}
tag_lvitem::tag_lvitem(tag_lvitem* parent, message_tag* mt,
tags_box_widget* owner) :
QTreeWidgetItem(parent, QStringList(mt->getName()))
{
m_id=mt->id();
m_owner=owner;
setCheckState(0, Qt::Unchecked);
last_known_state=Qt::Unchecked;
}
QgsLegendGroup::QgsLegendGroup( QTreeWidget* theListView, QString theString )
: QgsLegendItem( theListView, theString )
{
mType = LEGEND_GROUP;
setFlags( Qt::ItemIsEditable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable );
setCheckState( 0, Qt::Checked );
QIcon myIcon = QgsApplication::getThemeIcon( "/mActionFolder.png" );
setIcon( 0, myIcon );
}
EfpFragmentList::EfpFragmentList(Layer::Base* parent) : Base("EFP Fragments"), m_atomScale(0.5),
m_bondScale(0.5), m_drawMode(Primitive::Tubes), m_configurator(*this)
{
setConfigurator(&m_configurator);
setPersistentParent(parent);
setProperty(RemoveWhenChildless);
setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled );
setCheckState(Qt::Checked);
}
QgsLegendGroup::QgsLegendGroup( QString name ): QgsLegendItem()
{
mType = LEGEND_GROUP;
setFlags( Qt::ItemIsEditable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable );
setCheckState( 0, Qt::Checked );
QIcon myIcon = QgsApplication::getThemeIcon( + "/mActionFolder.png" );
setText( 0, name );
setIcon( 0, myIcon );
}
