CookieManager::CookieManager(QWidget* parent)
: QWidget(parent)
, ui(new Ui::CookieManager)
, m_refreshCookieJar(true)
{
ui->setupUi(this);
qz_centerWidgetOnScreen(this);
// Stored Cookies
connect(ui->cookieTree, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)), this, SLOT(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)));
connect(ui->removeAll, SIGNAL(clicked()), this, SLOT(removeAll()));
connect(ui->removeOne, SIGNAL(clicked()), this, SLOT(removeCookie()));
connect(ui->close, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->close2, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->search, SIGNAL(textChanged(QString)), ui->cookieTree, SLOT(filterString(QString)));
// Cookie Filtering
connect(ui->whiteAdd, SIGNAL(clicked()), this, SLOT(addWhitelist()));
connect(ui->whiteRemove, SIGNAL(clicked()), this, SLOT(removeWhitelist()));
connect(ui->blackAdd, SIGNAL(clicked()), this, SLOT(addBlacklist()));
connect(ui->blackRemove, SIGNAL(clicked()), this, SLOT(removeBlacklist()));
ui->search->setPlaceholderText(tr("Search"));
ui->cookieTree->setDefaultItemShowMode(TreeWidget::ItemsCollapsed);
ui->cookieTree->sortItems(0, Qt::AscendingOrder);
ui->cookieTree->header()->setDefaultSectionSize(220);
ui->cookieTree->setFocus();
QShortcut* removeShortcut = new QShortcut(QKeySequence("Del"), this);
connect(removeShortcut, SIGNAL(activated()), this, SLOT(deletePressed()));
}
CookieManager::CookieManager(QWidget* parent)
: QDialog(parent)
, ui(new Ui::CookieManager)
, m_refreshCookieJar(true)
{
ui->setupUi(this);
QzTools::centerWidgetOnScreen(this);
if (isRightToLeft()) {
ui->cookieTree->headerItem()->setTextAlignment(0, Qt::AlignRight | Qt::AlignVCenter);
ui->cookieTree->headerItem()->setTextAlignment(1, Qt::AlignRight | Qt::AlignVCenter);
ui->cookieTree->setLayoutDirection(Qt::LeftToRight);
ui->whiteList->setLayoutDirection(Qt::LeftToRight);
ui->blackList->setLayoutDirection(Qt::LeftToRight);
}
// Stored Cookies
connect(ui->cookieTree, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)), this, SLOT(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)));
connect(ui->removeAll, SIGNAL(clicked()), this, SLOT(removeAll()));
connect(ui->removeOne, SIGNAL(clicked()), this, SLOT(removeCookie()));
connect(ui->close, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->close2, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->close3, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->search, SIGNAL(textChanged(QString)), this, SLOT(filterString(QString)));
// Cookie Filtering
connect(ui->whiteAdd, SIGNAL(clicked()), this, SLOT(addWhitelist()));
connect(ui->whiteRemove, SIGNAL(clicked()), this, SLOT(removeWhitelist()));
connect(ui->blackAdd, SIGNAL(clicked()), this, SLOT(addBlacklist()));
connect(ui->blackRemove, SIGNAL(clicked()), this, SLOT(removeBlacklist()));
// Cookie Settings
Settings settings;
settings.beginGroup("Cookie-Settings");
ui->saveCookies->setChecked(settings.value("allowCookies", true).toBool());
if (!ui->saveCookies->isChecked()) {
ui->deleteCookiesOnClose->setEnabled(false);
}
ui->deleteCookiesOnClose->setChecked(settings.value("deleteCookiesOnClose", false).toBool());
ui->allowThirdPartyCookies->setCurrentIndex(settings.value("allowThirdPartyCookies", 0).toInt());
ui->filterTracking->setChecked(settings.value("filterTrackingCookie", false).toBool());
settings.endGroup();
connect(ui->saveCookies, SIGNAL(toggled(bool)), this, SLOT(saveCookiesChanged(bool)));
ui->search->setPlaceholderText(tr("Search"));
ui->cookieTree->setDefaultItemShowMode(TreeWidget::ItemsCollapsed);
ui->cookieTree->sortItems(0, Qt::AscendingOrder);
ui->cookieTree->header()->setDefaultSectionSize(220);
ui->cookieTree->setFocus();
QShortcut* removeShortcut = new QShortcut(QKeySequence("Del"), this);
connect(removeShortcut, SIGNAL(activated()), this, SLOT(deletePressed()));
QzTools::setWmClass("Cookies", this);
refreshTable();
}
FCM_Dialog::FCM_Dialog(FCM_Plugin* manager, QWidget* parent)
: QDialog(parent, Qt::WindowStaysOnTopHint)
, ui(new Ui::FCM_Dialog)
, m_manager(manager)
{
ui->setupUi(this);
QzTools::centerWidgetOnScreen(this);
ui->path->hide();
ui->labelPath->hide();
if (isRightToLeft()) {
ui->flashCookieTree->headerItem()->setTextAlignment(0, Qt::AlignRight | Qt::AlignVCenter);
ui->flashCookieTree->setLayoutDirection(Qt::LeftToRight);
ui->whiteList->setLayoutDirection(Qt::LeftToRight);
ui->blackList->setLayoutDirection(Qt::LeftToRight);
}
connect(ui->flashCookieTree, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)), this, SLOT(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)));
connect(ui->removeAll, SIGNAL(clicked()), this, SLOT(removeAll()));
connect(ui->removeOne, SIGNAL(clicked()), this, SLOT(removeCookie()));
connect(ui->close, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->close2, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->close3, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->search, SIGNAL(textChanged(QString)), this, SLOT(filterString(QString)));
connect(ui->reloadFromDisk, SIGNAL(clicked()), this, SLOT(reloadFromDisk()));
connect(ui->whiteAdd, SIGNAL(clicked()), this, SLOT(addWhitelist()));
connect(ui->whiteRemove, SIGNAL(clicked()), this, SLOT(removeWhitelist()));
connect(ui->blackAdd, SIGNAL(clicked()), this, SLOT(addBlacklist()));
connect(ui->blackRemove, SIGNAL(clicked()), this, SLOT(removeBlacklist()));
connect(ui->autoMode, SIGNAL(toggled(bool)), ui->notification, SLOT(setEnabled(bool)));
connect(ui->autoMode, SIGNAL(toggled(bool)), ui->labelNotification, SLOT(setEnabled(bool)));
connect(ui->browseFlashDataPath, SIGNAL(clicked()), this, SLOT(selectFlashDataPath()));
ui->autoMode->setChecked(m_manager->readSettings().value("autoMode").toBool());
ui->notification->setEnabled(m_manager->readSettings().value("autoMode").toBool());
ui->notification->setChecked(m_manager->readSettings().value("notification").toBool());
ui->deleteAllOnStartExit->setChecked(m_manager->readSettings().value("deleteAllOnStartExit").toBool());
ui->flashDataPath->setText(m_manager->flashPlayerDataPath());
ui->labelNotification->setEnabled(ui->autoMode->isChecked());
ui->search->setPlaceholderText(tr("Search"));
ui->flashCookieTree->setDefaultItemShowMode(TreeWidget::ItemsCollapsed);
ui->flashCookieTree->sortItems(0, Qt::AscendingOrder);
ui->flashCookieTree->header()->setDefaultSectionSize(220);
ui->flashCookieTree->setFocus();
QShortcut* removeShortcut = new QShortcut(QKeySequence("Del"), this);
connect(removeShortcut, SIGNAL(activated()), this, SLOT(deletePressed()));
QzTools::setWmClass("FlashCookies", this);
}
QDate AccountingForm::getFirstUnaccMonth()
{
QString filterString("");
filterString.append("accounted = 0");
m_treats->setFilter(filterString);
m_treats->select();
QSqlRecord latestTreat = m_treats->record(0);
QString dateString = latestTreat.value("dateoftreat").toString();
QDate date = QDate::fromString(dateString, "yyyy-MM-dd");
date.setDate(date.year(), date.month(), 1);
return date;
}
QString FormatFilter::Private::filterString(QString string)
{
QRegExp rx(mainPattern.arg(allTagsPattern));
rx.setMinimal(true);
int pos = 0;
while ((pos = string.indexOf(rx, pos)) != -1) {
string = string.replace(rx.cap(3), filterString(rx.cap(3)));
pos += rx.matchedLength();
}
Q_FOREACH(const FormatTag &tag, tags) {
string = string.replace(tag.first, tag.second);
}
bool RosoutTextFilter::filterVector(const std::vector<std::string>& strs) const
{
std::vector<std::string>::const_iterator it = strs.begin();
std::vector<std::string>::const_iterator end = strs.end();
for (; it != end; ++it)
{
if (filterString(*it))
{
return true;
}
}
return false;
}
bool RosoutTextFilter::doFilter(const rosgraph_msgs::LogConstPtr& msg) const
{
if (text_.empty())
{
return true;
}
bool match = false;
if (field_mask_ & Message)
{
match = match || filterString(msg->msg);
}
if (field_mask_ & Node)
{
match = match || filterString(msg->name);
}
if (field_mask_ & Location)
{
if (!match)
{
std::stringstream ss;
ss << msg->file << ":" << msg->function << ":" << msg->line;
match = match || filterString(ss.str());
}
}
if (field_mask_ & Topics)
{
match = match || filterVector(msg->topics);
}
return type_ == Include ? match : !match;
}
ColumnPtr ColumnArray::filter(const Filter & filt, ssize_t result_size_hint) const
{
if (typeid_cast<const ColumnUInt8 *>(data.get())) return filterNumber<UInt8>(filt, result_size_hint);
if (typeid_cast<const ColumnUInt16 *>(data.get())) return filterNumber<UInt16>(filt, result_size_hint);
if (typeid_cast<const ColumnUInt32 *>(data.get())) return filterNumber<UInt32>(filt, result_size_hint);
if (typeid_cast<const ColumnUInt64 *>(data.get())) return filterNumber<UInt64>(filt, result_size_hint);
if (typeid_cast<const ColumnInt8 *>(data.get())) return filterNumber<Int8>(filt, result_size_hint);
if (typeid_cast<const ColumnInt16 *>(data.get())) return filterNumber<Int16>(filt, result_size_hint);
if (typeid_cast<const ColumnInt32 *>(data.get())) return filterNumber<Int32>(filt, result_size_hint);
if (typeid_cast<const ColumnInt64 *>(data.get())) return filterNumber<Int64>(filt, result_size_hint);
if (typeid_cast<const ColumnFloat32 *>(data.get())) return filterNumber<Float32>(filt, result_size_hint);
if (typeid_cast<const ColumnFloat64 *>(data.get())) return filterNumber<Float64>(filt, result_size_hint);
if (typeid_cast<const ColumnString *>(data.get())) return filterString(filt, result_size_hint);
return filterGeneric(filt, result_size_hint);
}
QVariant Resource::data(int role) const
{
switch(role) {
case IdRole:
return (unsigned int)id();
case NameRole:
return name();
case TypeRole:
return type();
case QuantityRole:
return (unsigned int)quantity();
case FilterStringRole:
return filterString();
default:
return QVariant();
}
}
AutoFillManager::AutoFillManager(QWidget* parent)
: QWidget(parent)
, ui(new Ui::AutoFillManager)
, m_passwordManager(mApp->autoFill()->passwordManager())
, m_passwordsShown(false)
{
ui->setupUi(this);
if (isRightToLeft()) {
ui->treePass->headerItem()->setTextAlignment(0, Qt::AlignRight | Qt::AlignVCenter);
ui->treePass->headerItem()->setTextAlignment(1, Qt::AlignRight | Qt::AlignVCenter);
ui->treePass->headerItem()->setTextAlignment(2, Qt::AlignRight | Qt::AlignVCenter);
ui->treePass->setLayoutDirection(Qt::LeftToRight);
ui->treeExcept->setLayoutDirection(Qt::LeftToRight);
}
connect(ui->removePass, SIGNAL(clicked()), this, SLOT(removePass()));
connect(ui->removeAllPass, SIGNAL(clicked()), this, SLOT(removeAllPass()));
connect(ui->editPass, SIGNAL(clicked()), this, SLOT(editPass()));
connect(ui->showPasswords, SIGNAL(clicked()), this, SLOT(showPasswords()));
connect(ui->search, SIGNAL(textChanged(QString)), ui->treePass, SLOT(filterString(QString)));
connect(ui->changeBackend, SIGNAL(clicked()), this, SLOT(changePasswordBackend()));
connect(ui->backendOptions, SIGNAL(clicked()), this, SLOT(showBackendOptions()));
connect(m_passwordManager, SIGNAL(passwordBackendChanged()), this, SLOT(currentPasswordBackendChanged()));
connect(ui->removeExcept, SIGNAL(clicked()), this, SLOT(removeExcept()));
connect(ui->removeAllExcept, SIGNAL(clicked()), this, SLOT(removeAllExcept()));
QMenu* menu = new QMenu(this);
menu->addAction(tr("Import Passwords from File..."), this, SLOT(importPasswords()));
menu->addAction(tr("Export Passwords to File..."), this, SLOT(exportPasswords()));
ui->importExport->setMenu(menu);
ui->importExport->setPopupMode(QToolButton::InstantPopup);
ui->search->setPlaceholderText(tr("Search"));
// Password backends
ui->currentBackend->setText(QString("<b>%1</b>").arg(m_passwordManager->activeBackend()->name()));
ui->backendOptions->setVisible(m_passwordManager->activeBackend()->hasSettings());
// Load passwords
QTimer::singleShot(0, this, SLOT(loadPasswords()));
}
bool FilteredSpawnModel::filterAcceptsRow(int sourceRow, const QModelIndex& parent) const
{
if (m_currentCategory == NULL)
return true;
const Item* item = m_spawnModel->item(sourceRow);
if (item == NULL)
return false;
uint8_t level = 0;
// skip filtered spawns
if ((item->filterFlags() & FILTER_FLAG_FILTERED)
&& !m_currentCategory->isFilteredFilter())
return false;
if ((item->type() == tSpawn) || (item->type() == tPlayer))
level = ((Spawn*)item)->level();
// does this spawn match the category?
return m_currentCategory->isFiltered(filterString(item), level);
}
BookmarksSideBar::BookmarksSideBar(QupZilla* mainClass, QWidget* parent)
: QWidget(parent)
, m_isRefreshing(false)
, ui(new Ui::BookmarksSideBar)
, p_QupZilla(mainClass)
, m_bookmarksModel(mApp->bookmarksModel())
{
ui->setupUi(this);
ui->bookmarksTree->setViewType(BookmarksTree::SideBarView);
ui->bookmarksTree->setSelectionBehavior(QAbstractItemView::SelectRows);
ui->bookmarksTree->setDragDropReceiver(true, m_bookmarksModel);
ui->bookmarksTree->setMimeType(QLatin1String("application/qupzilla.treewidgetitem.bookmarks"));
ui->expandAll->setIcon(QIcon::fromTheme("view-sort-ascending", QIcon(":/icons/faenza/expand.png")));
ui->collapseAll->setIcon(QIcon::fromTheme("view-sort-descending", QIcon(":/icons/faenza/collapse.png")));
ui->bookmarksTree->setDefaultItemShowMode(TreeWidget::ItemsExpanded);
connect(ui->bookmarksTree, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextMenuRequested(QPoint)));
connect(ui->bookmarksTree, SIGNAL(itemControlClicked(QTreeWidgetItem*)), this, SLOT(itemControlClicked(QTreeWidgetItem*)));
connect(ui->bookmarksTree, SIGNAL(itemMiddleButtonClicked(QTreeWidgetItem*)), this, SLOT(itemControlClicked(QTreeWidgetItem*)));
connect(ui->bookmarksTree, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)), this, SLOT(itemDoubleClicked(QTreeWidgetItem*)));
connect(ui->search, SIGNAL(textChanged(QString)), ui->bookmarksTree, SLOT(filterString(QString)));
connect(ui->collapseAll, SIGNAL(clicked()), ui->bookmarksTree, SLOT(collapseAll()));
connect(ui->expandAll, SIGNAL(clicked()), ui->bookmarksTree, SLOT(expandAll()));
connect(m_bookmarksModel, SIGNAL(bookmarkAdded(BookmarksModel::Bookmark)), this, SLOT(addBookmark(BookmarksModel::Bookmark)));
connect(m_bookmarksModel, SIGNAL(bookmarkDeleted(BookmarksModel::Bookmark)), this, SLOT(removeBookmark(BookmarksModel::Bookmark)));
connect(m_bookmarksModel, SIGNAL(bookmarkEdited(BookmarksModel::Bookmark,BookmarksModel::Bookmark)),
this, SLOT(bookmarkEdited(BookmarksModel::Bookmark,BookmarksModel::Bookmark)));
connect(m_bookmarksModel, SIGNAL(folderAdded(QString)), this, SLOT(addFolder(QString)));
connect(m_bookmarksModel, SIGNAL(folderDeleted(QString)), this, SLOT(removeFolder(QString)));
connect(m_bookmarksModel, SIGNAL(folderRenamed(QString,QString)), this, SLOT(renameFolder(QString,QString)));
connect(m_bookmarksModel, SIGNAL(folderParentChanged(QString,bool)), this, SLOT(changeFolderParent(QString,bool)));
connect(m_bookmarksModel, SIGNAL(bookmarkParentChanged(QString,QByteArray,int,QUrl,QString,QString)),
this, SLOT(changeBookmarkParent(QString,QByteArray,int,QUrl,QString,QString)));
QTimer::singleShot(0, this, SLOT(refreshTable()));
}
QVariant NeutralMob::data(int role) const
{
switch(role) {
case IdRole:
return (unsigned int)id();
case FilterStringRole:
return filterString();
case TypeRole:
return type();
case PosXRole:
return posX();
case PosYRole:
return posY();
case PosZRole:
return posZ();
case RotationRole:
return rotation();
default:
return QVariant();
}
}
void BayesianClass::calculateHistogram(string file_path)
{
fstream file(file_path,ios_base::in);
if (!file.is_open())
exit(errno);
char word[256]={0};
while (!file.eof())
{
char line[1024]={0};
file.getline(line,1024);
if(line[0]==0)
break;
}
fileCount++;
while (!file.eof())
{
int res=0;
file>>word;
res = filterString(word,256);
if(res)
continue;
stringstream ss;
ss<<word;
while (!ss.eof())
{
ss>>word;
if(word[0] && word[1])
{
if(blacklist.find(word)==-1)
wi[word]++;
}
}
}
file.close();
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
bool MEmailPlugin::init(const Config::Config& cfg) {
if ( !MonitorPluginInterface::init(cfg) ) return false;
try {
std::vector<std::string> recipients = cfg.getStrings(name() + ".recipients");
addRecipients(recipients);
}
catch( Config::Exception& e ) {
SEISCOMP_ERROR("MEmailPlugin could not be initialized due to missing recipients list: %s", e.what());
setOperational(false);
}
try {
_template = cfg.getString(name() + ".template");
}
catch ( Config::Exception& e ) {
SEISCOMP_DEBUG("%s", e.what());
}
try {
std::vector<std::string> requiredClients = cfg.getStrings(name() + ".requiredClients");
for (size_t i = 0; i < requiredClients.size(); ++i) {
_requiredClients.insert(std::make_pair(requiredClients[i], false));
}
}
catch ( Config::Exception& e ) {
SEISCOMP_DEBUG("%s", e.what());
}
try {
_reportSilentClients = cfg.getBool(name() + ".reportSilentClients");
}
catch ( Config::Exception& e ) {
SEISCOMP_DEBUG("%s", e.what());
}
try {
_reportSilentClientsTimeSpan =
Core::TimeSpan(cfg.getDouble(name() + ".reportSilentClientsTimeSpan") * 60);
}
catch ( Config::Exception& e ) {
SEISCOMP_DEBUG("%s", e.what());
}
try {
double filterMeanInterval = cfg.getDouble(name() + ".filterMeanInterval");
setFilterMeanInterval(filterMeanInterval);
}
catch (Config::Exception& e) {
SEISCOMP_DEBUG("%s", e.what());
}
try {
_reportRequiredClientsTimeSpan = cfg.getDouble(name() + ".reportRequiredClients") * 60;
}
catch ( Config::Exception& e ) {
SEISCOMP_DEBUG("%s", e.what());
}
try {
_sendEmail = cfg.getBool(name() + ".sendEmail");
}
catch ( Config::Exception& e ) {
SEISCOMP_DEBUG("%s", e.what());
}
_sender= std::auto_ptr<EmailSender>(EmailSender::Create());
if ( !_sender.get() ) {
SEISCOMP_ERROR("MEmailPlugin could not be initialized. Email service not available!");
setOperational(false);
}
std::stringstream ss;
ss << "This message has been automatically generated by scm on host: "
<< Core::getHostname() << " for master: master@" << SCCoreApp->connection()->masterAddress() << std::endl;
_message.setHeader(ss.str());
ss.str(std::string());
ss << "The following clients match the given filter condition:" << std::endl;
ss << filterString();
_message.setHeaderFilteredClients(ss.str());
ss.str(std::string());
ss << "Some of the connected have been silent for more than "
<< _reportRequiredClientsTimeSpan << " seconds" << std::endl;
ss << "'-' denotes a silent and '+' a recovered client.";
_message.setHeaderSilentClients(ss.str());
ss.str(std::string());
ss << "Some required clients are disconnected (-) or reconnected (+)" << std::endl;
ss << "Required clients: ";
RequiredClients::iterator it = _requiredClients.begin();
for ( ; it != _requiredClients.end(); ++it ) {
if ( it != _requiredClients.begin() )
ss << ", ";
ss << it->first;
}
_message.setHeaderRequiredClients(ss.str());
return true;
}
bool AuditMessageTypeFilterNotification::checkNotification(AuditMessage* message){
if (message->type == filterString())
return true;
else
return false;
}
void AuditMessageTypeFilterNotification::writeExtraAttributes(QXmlStreamWriter* xml_writer){
xml_writer->writeAttribute("type", filterString());
}
QVariant Human::data(int role) const
{
switch(role) {
case IdRole:
return (unsigned int)id();
case FilterStringRole:
return filterString();
case ProfessionRole:
return profession();
case PosXRole:
return posX();
case PosYRole:
return posY();
case PosZRole:
return posZ();
case NameRole:
return name();
case ArcherLevelRole:
return archerLevel();
case BlacksmithLevelRole:
return blacksmithLevel();
case BuilderLevelRole:
return builderLevel();
case CarpenterLevelRole:
return carpenterLevel();
case EngineerLeveRole:
return engineerLevel();
case FarmerLevelRole:
return farmerLevel();
case FishermanLevelRole:
return fishermanLevel();
case ForagerLevelRole:
return foragerLevel();
case InfantryLevelRole:
return infantryLevel();
case MinerLevelRole:
return minerLevel();
case StoneMasonLevelRole:
return stoneMasonLevel();
case WoodChopperLevelRole:
return woodChopperLevel();
case TailorLevelRole:
return tailorLevel();
case TraderLevelRole:
return traderLevel();
case HerderLevelRole:
return herderLevel();
case AdventurerLevelRole:
return adventurerLevel();
case Unknown1Role:
return unknown1Level();
case Unknown2Role:
return unknown2Level();
case Unknown3Role:
return unknown3Level();
case Unknown4Role:
return unknown4Level();
case ExperienceRole:
return experience();
case AutoChopTreesRole:
return autoChop();
case GatherBerriesRole:
return gatherBerries();
case HuntChickenRole:
return huntChicken();
case HuntBoarRole:
return huntBoar();
case ShowBowRangeRole:
return showBowRange();
case TrainNearTargetRole:
return trainNearTarget();
case RotationRole:
return rotation();
case EquipHandRole:
return equipHand();
case EquipOffhandRole:
return equipOffhand();
case EquipHeadRole:
return equipHead();
case EquipBodyRole:
return equipBody();
case EquipFeetRole:
return equipFeet();
case HealthRole:
return health();
case MoraleRole:
return morale();
case FatigueRole:
return fatigue();
case HungerRole:
return hunger();
default:
return QVariant();
}
}
QString Item::dumpString() const
{
return QString("ID:") + QString::number(id()) + ":" + filterString();
}
CookieManager::CookieManager(QWidget *parent)
: QDialog(parent)
, ui(new Ui::CookieManager)
{
setAttribute(Qt::WA_DeleteOnClose);
ui->setupUi(this);
QzTools::centerWidgetOnScreen(this);
if (isRightToLeft()) {
ui->cookieTree->headerItem()->setTextAlignment(0, Qt::AlignRight | Qt::AlignVCenter);
ui->cookieTree->headerItem()->setTextAlignment(1, Qt::AlignRight | Qt::AlignVCenter);
ui->cookieTree->setLayoutDirection(Qt::LeftToRight);
ui->whiteList->setLayoutDirection(Qt::LeftToRight);
ui->blackList->setLayoutDirection(Qt::LeftToRight);
}
// Stored Cookies
connect(ui->cookieTree, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)), this, SLOT(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)));
connect(ui->removeAll, SIGNAL(clicked()), this, SLOT(removeAll()));
connect(ui->removeOne, SIGNAL(clicked()), this, SLOT(remove()));
connect(ui->close, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->close2, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->close3, SIGNAL(clicked(QAbstractButton*)), this, SLOT(close()));
connect(ui->search, SIGNAL(textChanged(QString)), this, SLOT(filterString(QString)));
// Cookie Filtering
connect(ui->whiteAdd, SIGNAL(clicked()), this, SLOT(addWhitelist()));
connect(ui->whiteRemove, SIGNAL(clicked()), this, SLOT(removeWhitelist()));
connect(ui->blackAdd, SIGNAL(clicked()), this, SLOT(addBlacklist()));
connect(ui->blackRemove, SIGNAL(clicked()), this, SLOT(removeBlacklist()));
// Cookie Settings
Settings settings;
settings.beginGroup("Cookie-Settings");
ui->saveCookies->setChecked(settings.value("allowCookies", true).toBool());
ui->filter3rdParty->setChecked(settings.value("filterThirdPartyCookies", false).toBool());
ui->filterTracking->setChecked(settings.value("filterTrackingCookie", false).toBool());
ui->deleteCookiesOnClose->setChecked(settings.value("deleteCookiesOnClose", false).toBool());
ui->whiteList->addItems(settings.value("whitelist", QStringList()).toStringList());
ui->blackList->addItems(settings.value("blacklist", QStringList()).toStringList());
settings.endGroup();
#if QT_VERSION < QT_VERSION_CHECK(5, 11, 0)
ui->filter3rdParty->hide();
#endif
ui->search->setPlaceholderText(tr("Search"));
ui->cookieTree->setDefaultItemShowMode(TreeWidget::ItemsCollapsed);
ui->cookieTree->sortItems(0, Qt::AscendingOrder);
ui->cookieTree->header()->setDefaultSectionSize(220);
ui->cookieTree->setFocus();
QShortcut* removeShortcut = new QShortcut(QKeySequence("Del"), this);
connect(removeShortcut, SIGNAL(activated()), this, SLOT(deletePressed()));
connect(ui->search, SIGNAL(textChanged(QString)), this, SLOT(filterString(QString)));
connect(mApp->cookieJar(), &CookieJar::cookieAdded, this, &CookieManager::addCookie);
connect(mApp->cookieJar(), &CookieJar::cookieRemoved, this, &CookieManager::removeCookie);
// Load cookies
foreach (const QNetworkCookie &cookie, mApp->cookieJar()->getAllCookies())
addCookie(cookie);
QzTools::setWmClass("Cookies", this);
}
MStatus AbcImport::doIt(const MArgList & args)
{
MStatus status;
MArgParser argData(syntax(), args, &status);
MString filename("");
MString connectRootNodes("");
MString filterString("");
MString excludeFilterString("");
MObject reparentObj = MObject::kNullObj;
bool swap = false;
bool createIfNotFound = false;
bool removeIfNoUpdate = false;
bool debugOn = false;
if (argData.isFlagSet("help"))
{
MGlobal::displayInfo(usage);
return status;
}
if (argData.isFlagSet("debug"))
debugOn = true;
if (argData.isFlagSet("reparent"))
{
MString parent("");
MDagPath reparentDagPath;
status = argData.getFlagArgument("reparent", 0, parent);
if (status == MS::kSuccess
&& getDagPathByName(parent, reparentDagPath) == MS::kSuccess)
{
reparentObj = reparentDagPath.node();
}
else
{
MString theWarning = parent;
theWarning += MString(" is not a valid DagPath");
printWarning(theWarning);
}
}
if (!argData.isFlagSet("connect") && argData.isFlagSet("mode"))
{
MString modeStr;
argData.getFlagArgument("mode", 0, modeStr);
if (modeStr == "replace")
deleteCurrentSelection();
else if (modeStr == "open")
{
MFileIO fileIo;
fileIo.newFile(true);
}
}
else if (argData.isFlagSet("connect"))
{
swap = true;
argData.getFlagArgument("connect", 0, connectRootNodes);
if (argData.isFlagSet("createIfNotFound"))
{
createIfNotFound = true;
}
if (argData.isFlagSet("removeIfNoUpdate"))
removeIfNoUpdate = true;
}
if (argData.isFlagSet("filterObjects"))
{
argData.getFlagArgument("filterObjects", 0, filterString);
}
if (argData.isFlagSet("excludeFilterObjects"))
{
argData.getFlagArgument("excludeFilterObjects", 0, excludeFilterString);
}
// if the flag isn't specified we'll only do stuff marked with the Maya
// meta data
bool recreateColorSets = false;
if (argData.isFlagSet("recreateAllColorSets"))
{
recreateColorSets = true;
}
status = argData.getCommandArgument(0, filename);
MString abcNodeName;
if (status == MS::kSuccess)
{
{
MString fileRule, expandName;
MString alembicFileRule = "alembicCache";
MString alembicFilePath = "cache/alembic";
MString queryFileRuleCmd;
queryFileRuleCmd.format("workspace -q -fre \"^1s\"",
alembicFileRule);
MString queryFolderCmd;
queryFolderCmd.format("workspace -en `workspace -q -fre \"^1s\"`",
alembicFileRule);
// query the file rule for alembic cache
MGlobal::executeCommand(queryFileRuleCmd, fileRule);
if (fileRule.length() > 0)
{
// we have alembic file rule, query the folder
MGlobal::executeCommand(queryFolderCmd, expandName);
}
// resolve the expanded file rule
if (expandName.length() == 0)
{
expandName = alembicFilePath;
}
// get the path to the alembic file rule
MFileObject directory;
directory.setRawFullName(expandName);
MString directoryName = directory.resolvedFullName();
// resolve the relative path
MFileObject absoluteFile;
absoluteFile.setRawFullName(filename);
absoluteFile.setResolveMethod(MFileObject::kInputFile);
#if MAYA_API_VERSION < 201300
if (absoluteFile.resolvedFullName() !=
absoluteFile.expandedFullName())
{
#else
if (!MFileObject::isAbsolutePath(filename)) {
#endif
// this is a relative path
MString absoluteFileName = directoryName + "/" + filename;
absoluteFile.setRawFullName(absoluteFileName);
filename = absoluteFile.resolvedFullName();
}
else
{
filename = absoluteFile.resolvedFullName();
}
}
MFileObject fileObj;
status = fileObj.setRawFullName(filename);
if (status == MS::kSuccess && fileObj.exists())
{
ArgData inputData(filename, debugOn, reparentObj,
swap, connectRootNodes, createIfNotFound, removeIfNoUpdate,
recreateColorSets, filterString, excludeFilterString);
abcNodeName = createScene(inputData);
if (inputData.mSequenceStartTime != inputData.mSequenceEndTime &&
inputData.mSequenceStartTime != -DBL_MAX &&
inputData.mSequenceEndTime != DBL_MAX)
{
if (argData.isFlagSet("fitTimeRange"))
{
MTime sec(1.0, MTime::kSeconds);
setPlayback(
inputData.mSequenceStartTime * sec.as(MTime::uiUnit()),
inputData.mSequenceEndTime * sec.as(MTime::uiUnit()) );
}
if (argData.isFlagSet("setToStartFrame"))
{
MTime sec(1.0, MTime::kSeconds);
MGlobal::viewFrame( inputData.mSequenceStartTime *
sec.as(MTime::uiUnit()) );
}
}
}
else
{
MString theError("In AbcImport::doIt(), ");
theError += filename;
theError += MString(" doesn't exist");
printError(theError);
}
}
MPxCommand::setResult(abcNodeName);
return status;
}
void SortFilterProxyModel::setFilterSyntax(SortFilterProxyModel::FilterSyntax syntax)
{
setFilterRegExp(QRegExp(filterString(), filterCaseSensitivity(), static_cast<QRegExp::PatternSyntax>(syntax)));
}
