BioXASCarbonFilterFarmActuator::BioXASCarbonFilterFarmActuator(const QString &deviceName, QObject *parent) :
BioXASBeamlineComponent(deviceName, parent)
{
// Create actuator position control.
position_ = new BioXASCarbonFilterFarmActuatorPositionControl(name()+"Position", "mm", this);
addChildControl(position_);
connect( position_, SIGNAL(valueChanged(double)), this, SLOT(onPositionControlValueChanged()) );
connect( position_, SIGNAL(statusValueChanged(double)), this, SLOT(onPositionControlStatusValueChanged()) );
connect( position_, SIGNAL(motorChanged(CLSMAXvMotor*)), this, SIGNAL(motorChanged(CLSMAXvMotor*)) );
connect( position_, SIGNAL(statusChanged(AMControl*)), this, SIGNAL(positionStatusChanged(AMControl*)) );
// Create actuator window control.
window_ = new BioXASCarbonFilterFarmActuatorWindowControl(name()+"Window", this);
addChildControl(window_);
window_->setPositionControl(position_);
connect( window_, SIGNAL(valueChanged(double)), this, SLOT(onWindowControlValueChanged()) );
connect( window_, SIGNAL(windowsChanged()), this, SIGNAL(windowsChanged()) );
// Create actuator filter control.
filter_ = new BioXASCarbonFilterFarmActuatorFilterControl(name()+"Filter", "um", this);
addChildControl(filter_);
filter_->setWindowControl(window_);
connect( filter_, SIGNAL(valueChanged(double)), this, SLOT(onFilterControlValueChanged()) );
connect( filter_, SIGNAL(filtersChanged()), this, SIGNAL(filtersChanged()) );
connect( filter_, SIGNAL(windowPreferencesChanged()), this, SIGNAL(windowPreferencesChanged()) );
}
void ResourcesModel::setFilters(const QVariantMap &map) {
Q_D(ResourcesModel);
d->filters = map;
clear();
emit filtersChanged();
}
bool UserFiltersModel::Add (const RuleOptionDialog& dia)
{
const auto& itemRx = dia.GetType () == FilterOption::MTRegexp ?
Util::RegExp (dia.GetString (), dia.GetCase ()) :
Util::RegExp ();
FilterOption fo;
fo.Case_ = dia.GetCase ();
fo.MatchType_ = dia.GetType ();
fo.Domains_ = dia.GetDomains ();
fo.NotDomains_ = dia.GetNotDomains ();
const FilterItem_ptr item (new FilterItem
{
itemRx,
dia.GetString ().toUtf8 (),
fo
});
auto& container = dia.IsException () ? Filter_.Exceptions_ : Filter_.Filters_;
const int size = dia.IsException () ? Filter_.Exceptions_.size () : rowCount ();
beginInsertRows (QModelIndex (), size, size);
container << item;
endInsertRows ();
WriteSettings ();
emit filtersChanged ();
return !dia.IsException ();
}
void FileEdit::setFilters(QString arg)
{
if (filters != arg) {
filters = arg;
emit filtersChanged(arg);
}
}
/*!
Sets the list of \a filters to apply to incoming 3D mouse events
on widget().
\sa filters(), toggleFilter(), filtersChanged()
*/
void QMouse3DEventProvider::setFilters
(QMouse3DEventProvider::Filters filters)
{
Q_D(QMouse3DEventProvider);
if ((filters & (Translations | Rotations)) == 0)
filters |= Rotations; // Need at least 1 of these set.
if (d->filters != filters) {
d->filters = filters;
d->devices->updateFilters(this, filters);
emit filtersChanged();
}
}
QWidget *EventsWindow::createResultTitle()
{
m_resultTitle = new QLabel;
QFont font = m_resultTitle->font();
font.setPointSize(font.pointSize()+4);
m_resultTitle->setFont(font);
m_resultTitle->setWordWrap(true);
connect(m_resultsView->eventsModel(), SIGNAL(filtersChanged()), SLOT(updateResultTitle()));
updateResultTitle();
return m_resultTitle;
}
void UserFiltersModel::Remove (int index)
{
int pos = index;
bool isException = false;
SplitRow (&pos, &isException);
beginRemoveRows (QModelIndex (), index, index);
if (isException)
Filter_.Exceptions_.removeAt (pos);
else
Filter_.Filters_.removeAt (pos);
endRemoveRows ();
WriteSettings ();
emit filtersChanged ();
}
void BioXASFilterFlipper::setFilters(BioXASFilterFlipperFilters *newControl)
{
if (filters_ != newControl) {
removeChildControl(filters_);
filters_ = newControl;
addChildControl(filters_);
updateFilters(); // We want the filters control to be updated with our slides control.
emit filtersChanged(filters_);
}
}
void UserFiltersModel::WriteSettings ()
{
QSettings settings (QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_CleanWeb_Subscr");
settings.clear ();
auto writeItems = [&settings] (const QString& name, const QList<FilterItem_ptr>& from)
{
QList<FilterItem> saved;
saved.reserve (from.size ());
for (const auto& item : from)
saved << *item;
settings.setValue (name, QVariant::fromValue (saved));
};
writeItems ("ExceptionItems", Filter_.Exceptions_);
writeItems ("FilterItems", Filter_.Filters_);
emit filtersChanged ();
}
void UserFiltersModel::AddMultiFilters (QStringList lines)
{
std::for_each (lines.begin (), lines.end (),
[] (QString& str) { str = str.trimmed (); });
beginResetModel ();
auto p = std::for_each (lines.begin (), lines.end (),
LineParser (&Filter_));
endResetModel ();
if (p.GetSuccess () <= 0)
return;
WriteSettings ();
emit filtersChanged ();
emit gotEntity (Util::MakeNotification ("Poshuku CleanWeb",
tr ("Imported %1 user filters (%2 parsed successfully).")
.arg (p.GetSuccess ())
.arg (p.GetTotal ()),
PInfo_));
}
//----------------------------------------------------------------------
// SpawnShell
SpawnShell::SpawnShell(FilterMgr& filterMgr,
ZoneMgr* zoneMgr,
Player* player,
GuildMgr* guildMgr)
: QObject(NULL, "spawnshell"),
m_zoneMgr(zoneMgr),
m_player(player),
m_filterMgr(filterMgr),
m_guildMgr(guildMgr),
m_spawns(701),
m_drops(211),
m_doors(307),
m_players(2)
{
m_cntDeadSpawnIDs = 0;
m_posDeadSpawnIDs = 0;
for (int i = 0; i < MAX_DEAD_SPAWNIDS; i++)
m_deadSpawnID[i] = 0;
// these should auto delete
m_spawns.setAutoDelete(true);
m_drops.setAutoDelete(true);
m_doors.setAutoDelete(true);
// we don't want this one to auto-delete
m_players.setAutoDelete(false);
// bogus list
m_players.insert(0, m_player);
// connect the FilterMgr's signals to SpawnShells slots
connect(&m_filterMgr, SIGNAL(filtersChanged()),
this, SLOT(refilterSpawns()));
connect(&m_filterMgr, SIGNAL(runtimeFiltersChanged(uint8_t)),
this, SLOT(refilterSpawnsRuntime()));
// connect SpawnShell slots to ZoneMgr signals
connect(m_zoneMgr, SIGNAL(zoneBegin(const QString&)),
this, SLOT(clear(void)));
connect(m_zoneMgr, SIGNAL(zoneChanged(const QString&)),
this, SLOT(clear(void)));
// connect Player signals to SpawnShell signals
connect(m_player, SIGNAL(changeItem(const Item*, uint32_t)),
this, SIGNAL(changeItem(const Item*, uint32_t)));
// connect Player signals to SpawnShell slots
connect(m_player, SIGNAL(changedID(uint16_t)),
this, SLOT(playerChangedID(uint16_t)));
// restore the spawn list if necessary
if (showeq_params->restoreSpawns)
restoreSpawns();
// create the timer
m_timer = new QTimer(this);
// connect the timer
connect(m_timer, SIGNAL(timeout()),
this, SLOT(saveSpawns(void)));
// start the timer (changed to oneshot to help prevent a backlog on slower
// machines)
if (showeq_params->saveSpawns)
m_timer->start(showeq_params->saveSpawnsFrequency, true);
}
FiltersMenu::FiltersMenu(QWidget *parent)
: QMenu(parent)
{
// Loads the filter menu settings
KConfig config("apper");
KConfigGroup filterMenuGroup(&config, "FilterMenu");
QMenu *menuCollections = new QMenu(i18n("Collections"), this);
connect(menuCollections, SIGNAL(triggered(QAction*)),
this, SIGNAL(filtersChanged()));
connect(this, SIGNAL(enableCollections(bool)),
addMenu(menuCollections), SLOT(setVisible(bool)));
QActionGroup *collectionGroup = new QActionGroup(menuCollections);
collectionGroup->setExclusive(true);
QAction *collectionTrue = new QAction(i18n("Only collections"), collectionGroup);
collectionTrue->setCheckable(true);
m_filtersAction[collectionTrue] = Transaction::FilterCollections;
collectionGroup->addAction(collectionTrue);
menuCollections->addAction(collectionTrue);
m_actions << collectionTrue;
QAction *collectionFalse = new QAction(i18n("Exclude collections"), collectionGroup);
collectionFalse->setCheckable(true);
m_filtersAction[collectionFalse] = Transaction::FilterNotCollections;
collectionGroup->addAction(collectionFalse);
menuCollections->addAction(collectionFalse);
m_actions << collectionFalse;
// Installed
QMenu *menuInstalled = new QMenu(i18n("Installed"), this);
connect(menuInstalled, SIGNAL(triggered(QAction*)),
this, SIGNAL(filtersChanged()));
connect(this, SIGNAL(enableInstalled(bool)),
addMenu(menuInstalled), SLOT(setVisible(bool)));
addMenu(menuInstalled);
QActionGroup *installedGroup = new QActionGroup(menuInstalled);
installedGroup->setExclusive(true);
QAction *installedTrue = new QAction(i18n("Only installed"), installedGroup);
installedTrue->setCheckable(true);
m_filtersAction[installedTrue] = Transaction::FilterInstalled;
installedGroup->addAction(installedTrue);
menuInstalled->addAction(installedTrue);
m_actions << installedTrue;
QAction *installedFalse = new QAction(i18n("Only available"), installedGroup);
installedFalse->setCheckable(true);
m_filtersAction[installedFalse] = Transaction::FilterNotInstalled;
installedGroup->addAction(installedFalse);
menuInstalled->addAction(installedFalse);
m_actions << installedFalse;
QAction *installedNone = new QAction(i18n("No filter"), installedGroup);
installedNone->setCheckable(true);
installedNone->setChecked(true);
installedGroup->addAction(installedNone);
menuInstalled->addAction(installedNone);
m_actions << installedNone;
// Development
QMenu *menuDevelopment = new QMenu(i18n("Development"), this);
connect(menuDevelopment, SIGNAL(triggered(QAction*)),
this, SIGNAL(filtersChanged()));
connect(this, SIGNAL(enableDevelopment(bool)),
addMenu(menuDevelopment), SLOT(setVisible(bool)));
addMenu(menuDevelopment);
QActionGroup *developmentGroup = new QActionGroup(menuDevelopment);
developmentGroup->setExclusive(true);
QAction *developmentTrue = new QAction(i18n("Only development"), developmentGroup);
developmentTrue->setCheckable(true);
m_filtersAction[developmentTrue] = Transaction::FilterDevel;
developmentGroup->addAction(developmentTrue);
menuDevelopment->addAction(developmentTrue);
m_actions << developmentTrue;
QAction *developmentFalse = new QAction(i18n("Only end user files"), developmentGroup);
developmentFalse->setCheckable(true);
m_filtersAction[developmentFalse] = Transaction::FilterNotDevel;
developmentGroup->addAction(developmentFalse);
menuDevelopment->addAction(developmentFalse);
m_actions << developmentFalse;
QAction *developmentNone = new QAction(i18n("No filter"), developmentGroup);
developmentNone->setCheckable(true);
developmentNone->setChecked(true);
developmentGroup->addAction(developmentNone);
menuDevelopment->addAction(developmentNone);
m_actions << developmentNone;
// Graphical
QMenu *menuGui = new QMenu(i18n("Graphical"), this);
connect(menuGui, SIGNAL(triggered(QAction*)),
this, SIGNAL(filtersChanged()));
connect(this, SIGNAL(enableGraphical(bool)),
addMenu(menuGui), SLOT(setVisible(bool)));
addMenu(menuGui);
QActionGroup *guiGroup = new QActionGroup(menuGui);
guiGroup->setExclusive(true);
QAction *guiTrue = new QAction(i18n("Only graphical"), guiGroup);
guiTrue->setCheckable(true);
m_filtersAction[guiTrue] = Transaction::FilterGui;
guiGroup->addAction(guiTrue);
menuGui->addAction(guiTrue);
m_actions << guiTrue;
QAction *guiFalse = new QAction(i18n("Only text"), guiGroup);
guiFalse->setCheckable(true);
m_filtersAction[guiFalse] = Transaction::FilterNotGui;
guiGroup->addAction(guiFalse);
menuGui->addAction(guiFalse);
m_actions << guiFalse;
QAction *guiNone = new QAction(i18n("No filter"), guiGroup);
guiNone->setCheckable(true);
guiNone->setChecked(true);
guiGroup->addAction(guiNone);
menuGui->addAction(guiNone);
m_actions << guiNone;
// Free
QMenu *menuFree = new QMenu(i18nc("Filter for free packages", "Free"), this);
connect(menuFree, SIGNAL(triggered(QAction*)),
this, SIGNAL(filtersChanged()));
connect(this, SIGNAL(enableFree(bool)),
addMenu(menuFree), SLOT(setVisible(bool)));
addMenu(menuFree);
QActionGroup *freeGroup = new QActionGroup(menuFree);
freeGroup->setExclusive(true);
QAction *freeTrue = new QAction(i18n("Only free software"), freeGroup);
freeTrue->setCheckable(true);
m_filtersAction[freeTrue] = Transaction::FilterFree;
freeGroup->addAction(freeTrue);
menuFree->addAction(freeTrue);
m_actions << freeTrue;
QAction *freeFalse = new QAction(i18n("Only non-free software"), freeGroup);
freeFalse->setCheckable(true);
m_filtersAction[freeFalse] = Transaction::FilterNotFree;
freeGroup->addAction(freeFalse);
menuFree->addAction(freeFalse);
m_actions << freeFalse;
QAction *freeNone = new QAction(i18n("No filter"), freeGroup);
freeNone->setCheckable(true);
freeNone->setChecked(true);
freeGroup->addAction(freeNone);
menuFree->addAction(freeNone);
m_actions << freeNone;
// Supported
QMenu *menuSupported = new QMenu(i18nc("Filter for supported packages", "Supported"), this);
connect(menuSupported, SIGNAL(triggered(QAction*)),
this, SIGNAL(filtersChanged()));
connect(this, SIGNAL(enableSupported(bool)),
addMenu(menuSupported), SLOT(setVisible(bool)));
addMenu(menuSupported);
QActionGroup *supportedGroup = new QActionGroup(menuSupported);
supportedGroup->setExclusive(true);
QAction *supportedTrue = new QAction(i18n("Only supported software"), supportedGroup);
supportedTrue->setCheckable(true);
m_filtersAction[supportedTrue] = Transaction::FilterSupported;
supportedGroup->addAction(supportedTrue);
menuSupported->addAction(supportedTrue);
m_actions << supportedTrue;
QAction *supportedFalse = new QAction(i18n("Only non-supported software"), supportedGroup);
supportedFalse->setCheckable(true);
m_filtersAction[supportedFalse] = Transaction::FilterNotSupported;
supportedGroup->addAction(supportedFalse);
menuSupported->addAction(supportedFalse);
m_actions << supportedFalse;
QAction *supportedNone = new QAction(i18n("No filter"), supportedGroup);
supportedNone->setCheckable(true);
supportedNone->setChecked(true);
supportedGroup->addAction(supportedNone);
menuSupported->addAction(supportedNone);
m_actions << supportedNone;
// Source
QMenu *menuSource = new QMenu(i18nc("Filter for source packages", "Source"), this);
connect(menuSource, SIGNAL(triggered(QAction*)),
this, SIGNAL(filtersChanged()));
connect(this, SIGNAL(enableSource(bool)),
addMenu(menuSource), SLOT(setVisible(bool)));
addMenu(menuSource);
QActionGroup *sourceGroup = new QActionGroup(menuSource);
sourceGroup->setExclusive(true);
QAction *sourceTrue = new QAction(i18n("Only sourcecode"), sourceGroup);
sourceTrue->setCheckable(true);
m_filtersAction[sourceTrue] = Transaction::FilterSource;
sourceGroup->addAction(sourceTrue);
menuSource->addAction(sourceTrue);
m_actions << sourceTrue;
QAction *sourceFalse = new QAction(i18n("Only non-sourcecode"), sourceGroup);
sourceFalse->setCheckable(true);
m_filtersAction[sourceFalse] = Transaction::FilterNotSource;
sourceGroup->addAction(sourceFalse);
menuSource->addAction(sourceFalse);
m_actions << sourceFalse;
QAction *sourceNone = new QAction(i18n("No filter"), sourceGroup);
sourceNone->setCheckable(true);
sourceNone->setChecked(true);
sourceGroup->addAction(sourceNone);
menuSource->addAction(sourceNone);
m_actions << sourceNone;
// Basename, Newest, Arch separator
connect(this, SIGNAL(enableBasenameNewestArchSeparator(bool)),
addSeparator(), SLOT(setVisible(bool)));
QAction *basename = new QAction(i18n("Hide Subpackages"), this);
connect(basename, SIGNAL(triggered()),
this, SIGNAL(filtersChanged()));
connect(this, SIGNAL(enableBasename(bool)),
basename, SLOT(setVisible(bool)));
basename->setCheckable(true);
basename->setToolTip(i18n("Only show one package, not subpackages"));
m_filtersAction[basename] = Transaction::FilterBasename;
m_actions << basename;
QAction *newest = new QAction(i18n("Only Newest Packages"), this);
connect(newest, SIGNAL(triggered()),
this, SIGNAL(filtersChanged()));
connect(this, SIGNAL(enableNewest(bool)),
newest, SLOT(setVisible(bool)));
newest->setCheckable(true);
newest->setChecked(filterMenuGroup.readEntry("FilterNewest", true));
newest->setToolTip(i18n("Only show the newest available package"));
m_filtersAction[newest] = Transaction::FilterNewest;
m_actions << newest;
QAction *native = new QAction(i18n("Only Native Packages"), this);
connect(native, SIGNAL(triggered()),
this, SIGNAL(filtersChanged()));
connect(this, SIGNAL(enableArch(bool)),
native, SLOT(setVisible(bool)));
native->setCheckable(true);
native->setChecked(filterMenuGroup.readEntry("FilterNative", true));
native->setToolTip(i18n("Only show packages matching the machine architecture"));
m_filtersAction[native] = Transaction::FilterArch;
m_actions << native;
#ifdef HAVE_APPSTREAM
addSeparator();
m_applications = new QAction(i18n("Only Show Applications"), this);
m_applications->setCheckable(true);
m_applications->setChecked(filterMenuGroup.readEntry("HidePackages", false));
m_applications->setToolTip(i18n("Hide packages that are not applications"));
addAction(m_applications);
connect(m_applications, SIGNAL(triggered(bool)),
this, SIGNAL(filterApplications(bool)));
#endif // HAVE_APPSTREAM
}
void EventsModel::applyFilters(bool fromCache)
{
if (fromCache)
{
beginResetModel();
items.clear();
for (QHash<DVRServer*,QList<EventData*> >::Iterator it = cachedEvents.begin(); it != cachedEvents.end(); ++it)
{
if (!m_filter.sources.isEmpty() && !m_filter.sources.contains(it.key()))
continue;
for (QList<EventData*>::Iterator eit = it->begin(); eit != it->end(); ++eit)
{
if (m_filter(*eit))
items.append(*eit);
}
}
bool block = blockSignals(true);
resort();
blockSignals(block);
endResetModel();
}
else
{
/* Group contiguous removed rows together; provides a significant boost in performance */
int removeFirst = -1;
for (int i = 0; ; ++i)
{
if (i < items.size() && !m_filter(items[i]))
{
if (removeFirst < 0)
removeFirst = i;
}
else if (removeFirst >= 0)
{
beginRemoveRows(QModelIndex(), removeFirst, i-1);
items.erase(items.begin()+removeFirst, items.begin()+i);
i = removeFirst;
removeFirst = -1;
endRemoveRows();
}
if (i == items.size())
break;
}
#if 0
/* Experimental concurrent implementation; would later be extended to be nonblocking */
QList<EventData*> newItems = QtConcurrent::blockingFiltered(items, m_filter);
int oFirstRemove = -1;
for (int oI = 0, nI = 0; oI < items.size(); ++oI)
{
if (nI >= newItems.size())
{
if (oFirstRemove < 0)
oFirstRemove = oI;
beginRemoveRows(QModelIndex(), oFirstRemove, items.size()-1);
items.erase(items.begin()+oFirstRemove, items.end());
endRemoveRows();
break;
}
if (oFirstRemove < 0 && items[oI] != newItems[nI])
oFirstRemove = oI;
else if (oFirstRemove >= 0 && items[oI] == newItems[nI])
{
beginRemoveRows(QModelIndex(), oFirstRemove, oI-1);
items.erase(items.begin()+oFirstRemove, items.begin()+oI);
oI = oFirstRemove;
oFirstRemove = -1;
endRemoveRows();
}
if (oFirstRemove < 0)
{
++nI;
}
}
#endif
}
emit filtersChanged();
}
