void DownloadManager::load()
{
//m_downloads.clear();
QSettings settings;
settings.beginGroup(QLatin1String("downloadmanager"));
QSize size = settings.value(QLatin1String("size")).toSize();
if (size.isValid())
resize(size);
QByteArray value = settings.value(QLatin1String("removeDownloadsPolicy"), QLatin1String("Never")).toByteArray();
QMetaEnum removePolicyEnum = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("RemovePolicy"));
m_removePolicy = removePolicyEnum.keyToValue(value) == -1 ?
Never :
static_cast<RemovePolicy>(removePolicyEnum.keyToValue(value));
if (!m_iconProvider)
m_iconProvider = new QFileIconProvider();
int i = 0;
QString key = QString(QLatin1String("download_%1_")).arg(i);
while (settings.contains(key + QLatin1String("url"))) {
QUrl url = settings.value(key + QLatin1String("url")).toUrl();
QString fileName = settings.value(key + QLatin1String("location")).toString();
bool done = settings.value(key + QLatin1String("done"), true).toBool();
if (!url.isEmpty() && !fileName.isEmpty())
{
addItem( url, fileName, done );
}
key = QString(QLatin1String("download_%1_")).arg(++i);
}
cleanupButton->setEnabled(m_downloads.count() - activeDownloads() > 0);
}
void DownloadManager::load()
{
QSettings settings;
settings.beginGroup(QLatin1String("downloadmanager"));
QSize size = settings.value(QLatin1String("size")).toSize();
if (size.isValid())
resize(size);
QByteArray value = settings.value(QLatin1String("removeDownloadsPolicy"), QLatin1String("Never")).toByteArray();
QMetaEnum removePolicyEnum = staticMetaObject.enumerator(staticMetaObject.indexOfEnumerator("RemovePolicy"));
m_removePolicy = removePolicyEnum.keyToValue(value) == -1 ?
Never :
static_cast<RemovePolicy>(removePolicyEnum.keyToValue(value));
int i = 0;
QString key = QString(QLatin1String("download_%1_")).arg(i);
while (settings.contains(key + QLatin1String("url"))) {
QUrl url = settings.value(key + QLatin1String("url")).toUrl();
QString fileName = settings.value(key + QLatin1String("location")).toString();
bool done = settings.value(key + QLatin1String("done"), true).toBool();
if (!url.isEmpty() && !fileName.isEmpty()) {
DownloadItem *item = new DownloadItem(0, this);
item->m_output.setFileName(fileName);
item->fileNameLabel->setText(QFileInfo(item->m_output.fileName()).fileName());
item->m_url = url;
item->stopButton->setVisible(false);
item->stopButton->setEnabled(false);
item->tryAgainButton->setVisible(!done);
item->tryAgainButton->setEnabled(!done);
item->progressBar->setVisible(!done);
addItem(item);
}
key = QString(QLatin1String("download_%1_")).arg(++i);
}
cleanupButton->setEnabled(m_downloads.count() - activeDownloads() > 0);
}
void UIMenuBarEditorWidget::setRestrictionsOfMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType restrictions)
{
/* Cache passed restrictions: */
m_restrictionsOfMenuHelp = restrictions;
/* Get static meta-object: */
const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
/* We have UIExtraDataMetaDefs::MenuHelpActionType enum registered, so we can enumerate it: */
const int iEnumIndex = smo.indexOfEnumerator("MenuHelpActionType");
QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
/* Handle other enum-values: */
for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
{
/* Get iterated enum-value: */
const UIExtraDataMetaDefs::MenuHelpActionType enumValue =
static_cast<const UIExtraDataMetaDefs::MenuHelpActionType>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
/* Skip MenuHelpActionType_Invalid & MenuHelpActionType_All enum-value: */
if (enumValue == UIExtraDataMetaDefs::MenuHelpActionType_Invalid ||
enumValue == UIExtraDataMetaDefs::MenuHelpActionType_All)
continue;
/* Which key required action registered under? */
const QString strKey = gpConverter->toInternalString(enumValue);
if (!m_actions.contains(strKey))
continue;
/* Update action 'checked' state: */
m_actions.value(strKey)->setChecked(!(m_restrictionsOfMenuHelp & enumValue));
}
}
TorcPlayer::PlayerProperty TorcPlayer::StringToProperty(const QString &Property)
{
const QMetaObject &mo = TorcPlayer::staticMetaObject;
int enum_index = mo.indexOfEnumerator("PlayerProperty");
QMetaEnum metaEnum = mo.enumerator(enum_index);
return (PlayerProperty)metaEnum.keyToValue(Property.toLatin1());
}
GestureDirectionEnum::GestureDirection GestureDirectionEnum::getEnum(
const QString &gdString)
{
GestureDirectionEnum GestureDirectionEnum;
int index = GestureDirectionEnum.metaObject()->indexOfEnumerator("GestureDirection");
QMetaEnum metaEnum = GestureDirectionEnum.metaObject()->enumerator(index);
return (GestureDirectionEnum::GestureDirection)metaEnum.keyToValue(gdString.toStdString().c_str());
}
void BtLineEdit::setForcedScale( QString forcedScale )
{
const QMetaObject &mo = Unit::staticMetaObject;
int index = mo.indexOfEnumerator("unitScale");
QMetaEnum unitEnum = mo.enumerator(index);
_forceScale = (Unit::unitScale)unitEnum.keyToValue(forcedScale.toStdString().c_str());
}
// previous comment about qt5.5 applies
void BtLineEdit::setForcedUnit( QString forcedUnit )
{
const QMetaObject &mo = Unit::staticMetaObject;
int index = mo.indexOfEnumerator("unitDisplay");
QMetaEnum unitEnum = mo.enumerator(index);
_forceUnit = (Unit::unitDisplay)unitEnum.keyToValue(forcedUnit.toStdString().c_str());
}
AkVideoCaps::PixelFormat AkVideoCaps::pixelFormatFromString(const QString &pixelFormat)
{
AkVideoCaps caps;
QString format = "Format_" + pixelFormat;
int enumIndex = caps.metaObject()->indexOfEnumerator("PixelFormat");
QMetaEnum enumType = caps.metaObject()->enumerator(enumIndex);
int enumValue = enumType.keyToValue(format.toStdString().c_str());
return static_cast<PixelFormat>(enumValue);
}
MainWindow::Task MainWindow::taskByName(const QByteArray &name)
{
Task task;
const QMetaObject &metaObject = MainWindow::staticMetaObject;
int index = metaObject.indexOfEnumerator("Task");
QMetaEnum metaEnum = metaObject.enumerator(index);
int value = metaEnum.keyToValue(name);
task = static_cast<Task>(value);
return task;
}
int BookStyleItem::indexForFormat(Format::Type type)
{
static const int foregroundsIndex = staticMetaObject.indexOfEnumerator("ForegroundColorType");
static const QMetaEnum foregrounds = staticMetaObject.enumerator(foregroundsIndex);
static const int typesIndex = Format::staticMetaObject.indexOfEnumerator("Type");
static const QMetaEnum types = Format::staticMetaObject.enumerator(typesIndex);
const char *key = types.valueToKey(type);
return foregrounds.keyToValue(key);
}
static core::WorldRules::Type rulesTypeFromString(const char* str)
{
const QMetaEnum metaEnum{QMetaEnum::fromType<core::WorldRules::Type>()};
bool ok{true};
auto e = metaEnum.keyToValue(str, &ok);
if (!ok)
throw utils::ValueError("Failed to unserialize RulesType");
return static_cast<core::WorldRules::Type>(e);
}
QScriptClass::QueryFlags
QDeclarativeTypeNameScriptClass::queryProperty(Object *obj, const Identifier &name,
QScriptClass::QueryFlags flags)
{
Q_UNUSED(flags);
TypeNameData *data = (TypeNameData *)obj;
object = 0;
type = 0;
QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);
if (data->typeNamespace) {
QDeclarativeTypeNameCache::Data *d = data->typeNamespace->data(name);
if (d && d->type) {
type = d->type;
return QScriptClass::HandlesReadAccess;
} else {
return 0;
}
} else {
Q_ASSERT(data->type);
QString strName = toString(name);
if (strName.at(0).isUpper()) {
// Must be an enum
if (data->mode == IncludeEnums) {
// ### Optimize
QByteArray enumName = strName.toUtf8();
const QMetaObject *metaObject = data->type->baseMetaObject();
for (int ii = metaObject->enumeratorCount() - 1; ii >= 0; --ii) {
QMetaEnum e = metaObject->enumerator(ii);
int value = e.keyToValue(enumName.constData());
if (value != -1) {
enumValue = value;
return QScriptClass::HandlesReadAccess;
}
}
}
return 0;
} else if (data->object) {
// Must be an attached property
object = qmlAttachedPropertiesObjectById(data->type->index(), data->object);
if (!object) return 0;
return ep->objectClass->queryProperty(object, name, flags, 0);
}
}
return 0;
}
template<class T> int DebconfFrontend::enumFromString(const QString &str, const char *enumName)
{
QString realName(str);
realName.replace(0, 1, str.at(0).toUpper());
int pos;
while ((pos = realName.indexOf('_')) != -1) {
if (pos + 1 > realName.size()) {
realName.chop(pos);
} else{
realName.replace(pos, 2, realName.at(pos + 1).toUpper());
}
}
int id = T::staticMetaObject.indexOfEnumerator(enumName);
QMetaEnum e = T::staticMetaObject.enumerator(id);
int enumValue = e.keyToValue(realName.toAscii().data());
if(enumValue == -1) {
enumValue = e.keyToValue(QString("Unknown").append(enumName).toAscii().data());
qDebug() << "enumFromString (" << enumName << ") : converted" << realName << "to" << QString("Unknown").append(enumName) << ", enum value" << enumValue;
}
return enumValue;
}
template<class T> int DebconfFrontend::enumFromString(const QString &str, const char *enumName)
{
QString realName(str);
realName.replace(0, 1, str.at(0).toUpper());
int pos;
while ((pos = realName.indexOf(QLatin1Char( '_' ))) != -1) {
if (pos + 1 >= realName.size()) { // pos is from 0, size from 1, mustn't go off-by-one
realName.chop(1);
} else{
realName.replace(pos, 2, realName.at(pos + 1).toUpper());
}
}
int id = T::staticMetaObject.indexOfEnumerator(enumName);
QMetaEnum e = T::staticMetaObject.enumerator(id);
int enumValue = e.keyToValue(realName.toLatin1().data());
if(enumValue == -1) {
enumValue = e.keyToValue(QString(QStringLiteral( "Unknown" )).append(QLatin1String( enumName )).toLatin1().data());
qCDebug(DEBCONF) << "enumFromString (" <<QLatin1String( enumName ) << ") : converted" << realName << "to" << QString(QStringLiteral( "Unknown" )).append(QLatin1String( enumName )) << ", enum value" << enumValue;
}
return enumValue;
}
void UpdateInfoPlugin::loadSettings() const
{
QSettings *settings = ICore::settings();
const QString updaterKey = QLatin1String(UpdaterGroup) + QLatin1Char('/');
d->m_maintenanceTool = settings->value(updaterKey + QLatin1String(MaintenanceToolKey)).toString();
d->m_lastCheckDate = settings->value(updaterKey + QLatin1String(LastCheckDateKey), QDate()).toDate();
d->m_automaticCheck = settings->value(updaterKey + QLatin1String(AutomaticCheckKey), true).toBool();
const QString checkInterval = settings->value(updaterKey + QLatin1String(CheckIntervalKey)).toString();
const QMetaObject *mo = metaObject();
const QMetaEnum me = mo->enumerator(mo->indexOfEnumerator(CheckIntervalKey));
if (me.isValid()) {
bool ok = false;
const int newValue = me.keyToValue(checkInterval.toUtf8(), &ok);
if (ok)
d->m_checkInterval = static_cast<CheckUpdateInterval>(newValue);
}
}
Flags QGeoServiceProviderPrivate::features(const char *enumName)
{
const QMetaObject *mo = &QGeoServiceProvider::staticMetaObject;
const QMetaEnum en = mo->enumerator(
mo->indexOfEnumerator(enumName));
/* We need the typename keyword here, or Flags::enum_type will be parsed
* as a non-type and lead to an error */
Flags ret = typename Flags::enum_type(0);
if (this->metaData.contains(QStringLiteral("Features"))
&& this->metaData.value(QStringLiteral("Features")).isArray()) {
QJsonArray features = this->metaData.value(QStringLiteral("Features")).toArray();
foreach (const QJsonValue &v, features) {
int val = en.keyToValue(v.toString().toLatin1().constData());
if (v.isString() && val != -1) {
ret |= typename Flags::enum_type(val);
}
}
QColor *BookStyleItem::colorByName(const QString &name) const
{
QByteArray key = name.toLatin1();
key[0] = name[0].toUpper().toLatin1();
const QMetaObject *meta = metaObject();
for (int i = 0; i < meta->enumeratorCount(); ++i) {
const QMetaEnum enumerator = meta->enumerator(i);
bool ok;
int result = enumerator.keyToValue(key, &ok);
if (ok) {
return &m_formats[result];
}
}
return NULL;
}
// Dynamic properties need to be evaluated late, so we do it this way
void BtLineEdit::initializeProperties()
{
QVariant unitName = property("forcedUnit");
_property = property("editField").toString();
if ( unitName.isValid() )
{
const QMetaObject &mo = Unit::staticMetaObject;
int index = mo.indexOfEnumerator("unitDisplay");
QMetaEnum unitEnum = mo.enumerator(index);
_forceUnit = (Unit::unitDisplay)unitEnum.keyToValue(unitName.toString().toStdString().c_str());
}
else
{
_forceUnit = Unit::noUnit;
}
}
bool HbXmlLoaderBaseSyntax::toSizePolicy( const QString& policyS, QSizePolicy::Policy &policy ) const
{
if ( policyS.isEmpty() ) {
return false;
}
const QMetaObject *meta = &QSizePolicy::staticMetaObject;
const int enumIndex = meta->indexOfEnumerator("Policy");
Q_ASSERT( enumIndex != -1 );
QMetaEnum metaEnum = meta->enumerator(enumIndex);
const QByteArray byteArray = policyS.toUtf8();
const int policyI = metaEnum.keyToValue(byteArray.data());
if ( policyI == -1 ) {
return false;
}
policy = (QSizePolicy::Policy)policyI;
return true;
}
void IsuCompetition::AddAction(OsisAction* newAction)
{
if (!newAction)
{
return;
}
if (Current_Action)
{
delete Current_Action;
}
Current_Action = newAction;
const QMetaObject &mo = Actions::staticMetaObject;
int index = mo.indexOfEnumerator("ObsAction");
QMetaEnum metaEnum = mo.enumerator(index);
QString elementName = newAction->GetAttribute(OsisAction::Command);
elementName = elementName.toUpper();
elementName.prepend("ACTION_");
int xmlElementTag = metaEnum.keyToValue(&elementName.toStdString()[0]);
ProcessAction(xmlElementTag);
}
/* Method for setting enum values from Strings. */
void Customer::setType(QString newType) { /* Overloaded version
that accepts a string as an argument.
Sets value to -1 if unknown. */
static const QMetaObject* meta = metaObject(); /* Because
they are static locals, the initializations happen
only once. */
static int propindex = meta->indexOfProperty("type");
static const QMetaProperty mp = meta->property(propindex);
QMetaEnum menum = mp.enumerator(); /* This code gets
executed each time. */
const char* ntyp = newType.toLatin1().data();
CustomerType theType =
static_cast<CustomerType>(menum.keyToValue(ntyp));
if (theType != m_type) { /* Always check if valueChanged signal is needed. */
CustomerType oldType = m_type;
m_type = theType;
emit valueChanged("type", theType, oldType);
}
}
/******************************************************************************
* Loads the settings from the given settings store.
******************************************************************************/
void ViewportSettings::load(QSettings& store)
{
_upDirection = (UpDirection)store.value("UpDirection", qVariantFromValue((int)_upDirection)).toInt();
_restrictVerticalRotation = store.value("RestrictVerticalRotation", qVariantFromValue(_restrictVerticalRotation)).toBool();
store.beginGroup("Colors");
QMetaEnum colorEnum;
for(int i = 0; i < ViewportSettings::staticMetaObject.enumeratorCount(); i++) {
if(qstrcmp(ViewportSettings::staticMetaObject.enumerator(i).name(), "ViewportColor") == 0) {
colorEnum = ViewportSettings::staticMetaObject.enumerator(i);
break;
}
}
OVITO_ASSERT(colorEnum.isValid());
for(const QString& key : store.childKeys()) {
QColor c = store.value(key).value<QColor>();
bool ok;
int index = colorEnum.keyToValue(key.toLatin1().constData(), &ok);
if(ok && index >= 0 && index < NUMBER_OF_COLORS) {
_viewportColors[index] = Color(c);
}
}
store.endGroup();
}
//writeEnumProperty MIRRORS the relelvant bit of QMetaProperty::write AND MUST BE KEPT IN SYNC!
bool QDeclarativePropertyPrivate::writeEnumProperty(const QMetaProperty &prop, int idx, QObject *object, const QVariant &value, int flags)
{
if (!object || !prop.isWritable())
return false;
QVariant v = value;
if (prop.isEnumType()) {
QMetaEnum menum = prop.enumerator();
if (v.userType() == QVariant::String
#ifdef QT3_SUPPORT
|| v.userType() == QVariant::CString
#endif
) {
if (prop.isFlagType())
v = QVariant(menum.keysToValue(value.toByteArray()));
else
v = QVariant(menum.keyToValue(value.toByteArray()));
} else if (v.userType() != QVariant::Int && v.userType() != QVariant::UInt) {
int enumMetaTypeId = QMetaType::type(QByteArray(menum.scope()) + "::" + menum.name());
if ((enumMetaTypeId == 0) || (v.userType() != enumMetaTypeId) || !v.constData())
return false;
v = QVariant(*reinterpret_cast<const int *>(v.constData()));
}
v.convert(QVariant::Int);
}
// the status variable is changed by qt_metacall to indicate what it did
// this feature is currently only used by QtDBus and should not be depended
// upon. Don't change it without looking into QDBusAbstractInterface first
// -1 (unchanged): normal qt_metacall, result stored in argv[0]
// changed: result stored directly in value, return the value of status
int status = -1;
void *argv[] = { v.data(), &v, &status, &flags };
QMetaObject::metacall(object, QMetaObject::WriteProperty, idx, argv);
return status;
}
void DynamicConnectionPageWindow::createForm(QFormLayout *form)
{
const QList<DynamicWidgetInfo*> &widgetInfos = windowInfo->widgetInfos;
const QMetaObject &mo = DynamicConnectionPageWindow::staticMetaObject;
int enumIx = mo.indexOfEnumerator("WidgetType");
QMetaEnum metaEnum = mo.enumerator(enumIx);
for(int i=0; i<widgetInfos.size(); ++i){
DynamicWidgetInfo *widgetInfo = widgetInfos.at(i);
QHash<QString,QString> attributes = widgetInfo->attributes;
int widgetType = metaEnum.keyToValue(attributes["type"].toStdString().c_str());
Q_ASSERT(widgetType != -1);
QWidget *dynamicWidget = createDynamicWidget((WidgetType) widgetType, widgetInfo);
QString caption = attributes.value("caption");
if(caption.isEmpty()){
form->addRow(dynamicWidget);
form->setAlignment(dynamicWidget, Qt::AlignCenter);
}else{
form->addRow(caption, dynamicWidget);
}
scriptRunner.setProperty(dynamicWidget->objectName(), dynamicWidget);
}
}
bool WidgetInfo::checkEnumerator(const QMetaEnum &metaEnum, const QString &name)
{
return metaEnum.keyToValue(name.toLatin1()) != -1;
}
void SettingsDialog::loadFromSettings()
{
QSettings settings;
settings.beginGroup(QLatin1String("MainWindow"));
QString defaultHome = QLatin1String("about:home");
homeLineEdit->setText(settings.value(QLatin1String("home"), defaultHome).toString());
startupBehavior->setCurrentIndex(settings.value(QLatin1String("startupBehavior"), 0).toInt());
settings.endGroup();
settings.beginGroup(QLatin1String("history"));
int historyExpire = settings.value(QLatin1String("historyLimit")).toInt();
int idx = 0;
switch (historyExpire) {
case 1: idx = 0; break;
case 7: idx = 1; break;
case 14: idx = 2; break;
case 30: idx = 3; break;
case 365: idx = 4; break;
case -1: idx = 5; break;
case -2: idx = 6; break;
default:
idx = 5;
}
expireHistory->setCurrentIndex(idx);
settings.endGroup();
settings.beginGroup(QLatin1String("urlloading"));
bool search = settings.value(QLatin1String("searchEngineFallback"), false).toBool();
searchEngineFallback->setChecked(search);
settings.endGroup();
settings.beginGroup(QLatin1String("downloadmanager"));
bool alwaysPromptForFileName = settings.value(QLatin1String("alwaysPromptForFileName"), false).toBool();
downloadAsk->setChecked(alwaysPromptForFileName);
QString downloadDirectory = settings.value(QLatin1String("downloadDirectory"), downloadsLocation->text()).toString();
downloadsLocation->setText(downloadDirectory);
settings.endGroup();
// Appearance
settings.beginGroup(QLatin1String("websettings"));
m_fixedFont = qVariantValue<QFont>(settings.value(QLatin1String("fixedFont"), m_fixedFont));
m_standardFont = qVariantValue<QFont>(settings.value(QLatin1String("standardFont"), m_standardFont));
standardLabel->setText(QString(QLatin1String("%1 %2")).arg(m_standardFont.family()).arg(m_standardFont.pointSize()));
fixedLabel->setText(QString(QLatin1String("%1 %2")).arg(m_fixedFont.family()).arg(m_fixedFont.pointSize()));
blockPopupWindows->setChecked(settings.value(QLatin1String("blockPopupWindows"), blockPopupWindows->isChecked()).toBool());
enableJavascript->setChecked(settings.value(QLatin1String("enableJavascript"), enableJavascript->isChecked()).toBool());
enablePlugins->setChecked(settings.value(QLatin1String("enablePlugins"), enablePlugins->isChecked()).toBool());
enableImages->setChecked(settings.value(QLatin1String("enableImages"), enableImages->isChecked()).toBool());
userStyleSheet->setText(QString::fromUtf8(settings.value(QLatin1String("userStyleSheet")).toUrl().toEncoded()));
clickToFlash->setChecked(settings.value(QLatin1String("enableClickToFlash"), clickToFlash->isChecked()).toBool());
settings.endGroup();
// Privacy
settings.beginGroup(QLatin1String("cookies"));
CookieJar *jar = BrowserApplication::cookieJar();
QByteArray value = settings.value(QLatin1String("acceptCookies"), QLatin1String("AcceptOnlyFromSitesNavigatedTo")).toByteArray();
QMetaEnum acceptPolicyEnum = jar->staticMetaObject.enumerator(jar->staticMetaObject.indexOfEnumerator("AcceptPolicy"));
CookieJar::AcceptPolicy acceptCookies = acceptPolicyEnum.keyToValue(value) == -1 ?
CookieJar::AcceptOnlyFromSitesNavigatedTo :
static_cast<CookieJar::AcceptPolicy>(acceptPolicyEnum.keyToValue(value));
switch (acceptCookies) {
case CookieJar::AcceptAlways:
acceptCombo->setCurrentIndex(0);
break;
case CookieJar::AcceptNever:
acceptCombo->setCurrentIndex(1);
break;
case CookieJar::AcceptOnlyFromSitesNavigatedTo:
acceptCombo->setCurrentIndex(2);
break;
}
value = settings.value(QLatin1String("keepCookiesUntil"), QLatin1String("Expire")).toByteArray();
QMetaEnum keepPolicyEnum = jar->staticMetaObject.enumerator(jar->staticMetaObject.indexOfEnumerator("KeepPolicy"));
CookieJar::KeepPolicy keepCookies = keepPolicyEnum.keyToValue(value) == -1 ?
CookieJar::KeepUntilExpire :
static_cast<CookieJar::KeepPolicy>(keepPolicyEnum.keyToValue(value));
switch (keepCookies) {
case CookieJar::KeepUntilExpire:
keepUntilCombo->setCurrentIndex(0);
break;
case CookieJar::KeepUntilExit:
keepUntilCombo->setCurrentIndex(1);
break;
case CookieJar::KeepUntilTimeLimit:
keepUntilCombo->setCurrentIndex(2);
break;
}
filterTrackingCookiesCheckbox->setChecked(settings.value(QLatin1String("filterTrackingCookies"), true).toBool());
settings.endGroup();
// Network
settings.beginGroup(QLatin1String("network"));
m_cacheEnabled = settings.value(QLatin1String("cacheEnabled"), true).toBool();
networkCache->setChecked(m_cacheEnabled);
networkCacheMaximumSizeSpinBox->setValue(settings.value(QLatin1String("maximumCacheSize"), 50).toInt());
settings.endGroup();
// Proxy
settings.beginGroup(QLatin1String("proxy"));
proxySupport->setChecked(settings.value(QLatin1String("enabled"), false).toBool());
proxyType->setCurrentIndex(settings.value(QLatin1String("type"), 0).toInt());
proxyHostName->setText(settings.value(QLatin1String("hostName")).toString());
proxyPort->setValue(settings.value(QLatin1String("port"), 1080).toInt());
proxyUserName->setText(settings.value(QLatin1String("userName")).toString());
proxyPassword->setText(settings.value(QLatin1String("password")).toString());
settings.endGroup();
// Tabs
settings.beginGroup(QLatin1String("tabs"));
selectTabsWhenCreated->setChecked(settings.value(QLatin1String("selectNewTabs"), false).toBool());
confirmClosingMultipleTabs->setChecked(settings.value(QLatin1String("confirmClosingMultipleTabs"), true).toBool());
oneCloseButton->setChecked(settings.value(QLatin1String("oneCloseButton"),false).toBool());
quitAsLastTabClosed->setChecked(settings.value(QLatin1String("quitAsLastTabClosed"), true).toBool());
openTargetBlankLinksIn->setCurrentIndex(settings.value(QLatin1String("openTargetBlankLinksIn"), TabWidget::NewSelectedTab).toInt());
openLinksFromAppsIn->setCurrentIndex(settings.value(QLatin1String("openLinksFromAppsIn"), TabWidget::NewSelectedTab).toInt());
settings.endGroup();
}
TorrentFileGuard::AutoDeleteMode TorrentFileGuard::autoDeleteMode()
{
QMetaEnum meta {modeMetaEnum()};
return static_cast<AutoDeleteMode>(meta.keyToValue(SettingsStorage::instance()->loadValue(
KEY_AUTO_DELETE_ENABLED, meta.valueToKey(Never)).toByteArray()));
}
ReturnedValue QmlTypeWrapper::get(Managed *m, String *name, bool *hasProperty)
{
Q_ASSERT(m->as<QmlTypeWrapper>());
QV4::ExecutionEngine *v4 = static_cast<QmlTypeWrapper *>(m)->engine();
QV4::Scope scope(v4);
Scoped<QmlTypeWrapper> w(scope, static_cast<QmlTypeWrapper *>(m));
if (hasProperty)
*hasProperty = true;
QQmlContextData *context = v4->v8Engine->callingContext();
QObject *object = w->d()->object;
if (w->d()->type) {
QQmlType *type = w->d()->type;
// singleton types are handled differently to other types.
if (type->isSingleton()) {
QQmlEngine *e = v4->qmlEngine();
QQmlType::SingletonInstanceInfo *siinfo = type->singletonInstanceInfo();
siinfo->init(e);
QObject *qobjectSingleton = siinfo->qobjectApi(e);
if (qobjectSingleton) {
// check for enum value
if (name->startsWithUpper()) {
if (w->d()->mode == Heap::QmlTypeWrapper::IncludeEnums) {
// ### Optimize
QByteArray enumName = name->toQString().toUtf8();
const QMetaObject *metaObject = qobjectSingleton->metaObject();
for (int ii = metaObject->enumeratorCount() - 1; ii >= 0; --ii) {
QMetaEnum e = metaObject->enumerator(ii);
bool ok;
int value = e.keyToValue(enumName.constData(), &ok);
if (ok)
return QV4::Primitive::fromInt32(value).asReturnedValue();
}
}
}
// check for property.
return QV4::QObjectWrapper::getQmlProperty(v4, context, qobjectSingleton, name, QV4::QObjectWrapper::IgnoreRevision, hasProperty);
} else if (!siinfo->scriptApi(e).isUndefined()) {
// NOTE: if used in a binding, changes will not trigger re-evaluation since non-NOTIFYable.
QV4::ScopedObject o(scope, QJSValuePrivate::convertedToValue(v4, siinfo->scriptApi(e)));
if (!!o)
return o->get(name);
}
// Fall through to base implementation
} else {
if (name->startsWithUpper()) {
bool ok = false;
int value = type->enumValue(name, &ok);
if (ok)
return QV4::Primitive::fromInt32(value).asReturnedValue();
// Fall through to base implementation
} else if (w->d()->object) {
QObject *ao = qmlAttachedPropertiesObjectById(type->attachedPropertiesId(), object);
if (ao)
return QV4::QObjectWrapper::getQmlProperty(v4, context, ao, name, QV4::QObjectWrapper::IgnoreRevision, hasProperty);
// Fall through to base implementation
}
// Fall through to base implementation
}
// Fall through to base implementation
} else if (w->d()->typeNamespace) {
Q_ASSERT(w->d()->importNamespace);
QQmlTypeNameCache::Result r = w->d()->typeNamespace->query(name, w->d()->importNamespace);
if (r.isValid()) {
if (r.type) {
return create(scope.engine, object, r.type, w->d()->mode);
} else if (r.scriptIndex != -1) {
QV4::ScopedObject scripts(scope, context->importedScripts.valueRef());
return scripts->getIndexed(r.scriptIndex);
} else if (r.importNamespace) {
return create(scope.engine, object, context->imports, r.importNamespace);
}
return QV4::Encode::undefined();
}
// Fall through to base implementation
} else {
Q_ASSERT(!"Unreachable");
}
if (hasProperty)
*hasProperty = false;
return Object::get(m, name, hasProperty);
}
VideoFrame VideoDecoderVAAPI::frame()
{
DPTR_D(VideoDecoderVAAPI);
if (!d.frame->opaque || !d.frame->data[0])
return VideoFrame();
VASurfaceID surface_id = (VASurfaceID)(uintptr_t)d.frame->data[3];
VAStatus status = VA_STATUS_SUCCESS;
if (display() == GLX) {
surface_ptr p;
std::list<surface_ptr>::iterator it = d.surfaces_used.begin();
for (; it != d.surfaces_used.end() && !p; ++it) {
if((*it)->get() == surface_id) {
p = *it;
break;
}
}
if (!p) {
for (it = d.surfaces_free.begin(); it != d.surfaces_free.end() && !p; ++it) {
if((*it)->get() == surface_id) {
p = *it;
break;
}
}
}
if (!p) {
qWarning("VAAPI - Unable to find surface");
return VideoFrame();
}
((SurfaceInteropVAAPI*)d.surface_interop.data())->setSurface(p);
VideoFrame f(d.surface_width, d.surface_height, VideoFormat::Format_RGB32); //p->width()
f.setBytesPerLine(d.surface_width*4); //used by gl to compute texture size
f.setMetaData("surface_interop", QVariant::fromValue(d.surface_interop));
return f;
}
#if VA_CHECK_VERSION(0,31,0)
if ((status = vaSyncSurface(d.display->get(), surface_id)) != VA_STATUS_SUCCESS) {
qWarning("vaSyncSurface(VADisplay:%p, VASurfaceID:%#x) == %#x", d.display->get(), surface_id, status);
#else
if (vaSyncSurface(d.display->get(), d.context_id, surface_id)) {
qWarning("vaSyncSurface(VADisplay:%#x, VAContextID:%#x, VASurfaceID:%#x) == %#x", d.display, d.context_id, surface_id, status);
#endif
return VideoFrame();
}
if (!d.disable_derive && d.supports_derive) {
/*
* http://web.archiveorange.com/archive/v/OAywENyq88L319OcRnHI
* vaDeriveImage is faster than vaGetImage. But VAImage is uncached memory and copying from it would be terribly slow
* TODO: copy from USWC, see vlc and https://github.com/OpenELEC/OpenELEC.tv/pull/2937.diff
* https://software.intel.com/en-us/articles/increasing-memory-throughput-with-intel-streaming-simd-extensions-4-intel-sse4-streaming-load
*/
status = vaDeriveImage(d.display->get(), surface_id, &d.image);
if (status != VA_STATUS_SUCCESS) {
qWarning("vaDeriveImage(VADisplay:%p, VASurfaceID:%#x, VAImage*:%p) == %#x", d.display->get(), surface_id, &d.image, status);
return VideoFrame();
}
} else {
status = vaGetImage(d.display->get(), surface_id, 0, 0, d.surface_width, d.surface_height, d.image.image_id);
if (status != VA_STATUS_SUCCESS) {
qWarning("vaGetImage(VADisplay:%p, VASurfaceID:%#x, 0,0, %d, %d, VAImageID:%#x) == %#x", d.display->get(), surface_id, d.surface_width, d.surface_height, d.image.image_id, status);
return VideoFrame();
}
}
void *p_base;
if ((status = vaMapBuffer(d.display->get(), d.image.buf, &p_base)) != VA_STATUS_SUCCESS) {
qWarning("vaMapBuffer(VADisplay:%p, VABufferID:%#x, pBuf:%p) == %#x", d.display->get(), d.image.buf, &p_base, status);
return VideoFrame();
}
VideoFormat::PixelFormat pixfmt = VideoFormat::Format_Invalid;
bool swap_uv = false;
switch (d.image.format.fourcc) {
case VA_FOURCC_YV12:
swap_uv |= d.disable_derive || !d.supports_derive;
pixfmt = VideoFormat::Format_YUV420P;
break;
case VA_FOURCC_IYUV:
swap_uv = true;
pixfmt = VideoFormat::Format_YUV420P;
break;
case VA_FOURCC_NV12:
pixfmt = VideoFormat::Format_NV12;
break;
default:
break;
}
if (pixfmt == VideoFormat::Format_Invalid) {
qWarning("unsupported vaapi pixel format: %#x", d.image.format.fourcc);
return VideoFrame();
}
const VideoFormat fmt(pixfmt);
uint8_t *src[3];
int pitch[3];
for (int i = 0; i < fmt.planeCount(); ++i) {
src[i] = (uint8_t*)p_base + d.image.offsets[i];
pitch[i] = d.image.pitches[i];
}
if (swap_uv) {
std::swap(src[1], src[2]);
std::swap(pitch[1], pitch[2]);
}
VideoFrame frame;
if (d.copy_uswc && d.gpu_mem.isReady()) {
int yuv_size = 0;
if (pixfmt == VideoFormat::Format_NV12)
yuv_size = pitch[0]*d.surface_height*3/2;
else
yuv_size = pitch[0]*d.surface_height + pitch[1]*d.surface_height/2 + pitch[2]*d.surface_height/2;
// additional 15 bytes to ensure 16 bytes aligned
QByteArray buf(15 + yuv_size, 0);
const int offset_16 = (16 - ((uintptr_t)buf.data() & 0x0f)) & 0x0f;
// plane 1, 2... is aligned?
uchar* plane_ptr = (uchar*)buf.data() + offset_16;
QVector<uchar*> dst(fmt.planeCount(), 0);
for (int i = 0; i < dst.size(); ++i) {
dst[i] = plane_ptr;
// TODO: add VideoFormat::planeWidth/Height() ?
const int plane_w = pitch[i];//(i == 0 || pixfmt == VideoFormat::Format_NV12) ? d.surface_width : fmt.chromaWidth(d.surface_width);
const int plane_h = i == 0 ? d.surface_height : fmt.chromaHeight(d.surface_height);
plane_ptr += pitch[i] * plane_h;
d.gpu_mem.copyFrame(src[i], dst[i], plane_w, plane_h, pitch[i]);
}
frame = VideoFrame(buf, d.width, d.height, fmt);
frame.setBits(dst);
frame.setBytesPerLine(pitch);
} else {
frame = VideoFrame(d.width, d.height, fmt);
frame.setBits(src);
frame.setBytesPerLine(pitch);
// TODO: why clone is faster()?
frame = frame.clone();
}
if ((status = vaUnmapBuffer(d.display->get(), d.image.buf)) != VA_STATUS_SUCCESS) {
qWarning("vaUnmapBuffer(VADisplay:%p, VABufferID:%#x) == %#x", d.display->get(), d.image.buf, status);
return VideoFrame();
}
if (!d.disable_derive && d.supports_derive) {
vaDestroyImage(d.display->get(), d.image.image_id);
d.image.image_id = VA_INVALID_ID;
}
return frame;
}
void VideoDecoderVAAPI::setDisplayPriority(const QStringList &priority)
{
DPTR_D(VideoDecoderVAAPI);
d.display_priority.clear();
int idx = staticMetaObject.indexOfEnumerator("DisplayType");
const QMetaEnum me = staticMetaObject.enumerator(idx);
foreach (const QString& disp, priority) {
d.display_priority.push_back((DisplayType)me.keyToValue(disp.toUtf8().constData()));
}
// Convert complex DOM types with the help of QAbstractFormBuilder
QVariant domPropertyToVariant(QAbstractFormBuilder *afb,const QMetaObject *meta,const DomProperty *p)
{
// Complex types that need functions from QAbstractFormBuilder
switch(p->kind()) {
case DomProperty::String: {
const int index = meta->indexOfProperty(p->attributeName().toUtf8());
if (index != -1 && meta->property(index).type() == QVariant::KeySequence)
return QVariant::fromValue(QKeySequence(p->elementString()->text()));
}
break;
case DomProperty::Palette: {
const DomPalette *dom = p->elementPalette();
QPalette palette;
if (dom->elementActive())
afb->setupColorGroup(palette, QPalette::Active, dom->elementActive());
if (dom->elementInactive())
afb->setupColorGroup(palette, QPalette::Inactive, dom->elementInactive());
if (dom->elementDisabled())
afb->setupColorGroup(palette, QPalette::Disabled, dom->elementDisabled());
palette.setCurrentColorGroup(QPalette::Active);
return QVariant::fromValue(palette);
}
case DomProperty::Set: {
const QByteArray pname = p->attributeName().toUtf8();
const int index = meta->indexOfProperty(pname);
if (index == -1) {
uiLibWarning(QCoreApplication::translate("QFormBuilder", "The set-type property %1 could not be read.").arg(p->attributeName()));
return QVariant();
}
const QMetaEnum e = meta->property(index).enumerator();
Q_ASSERT(e.isFlag() == true);
return QVariant(e.keysToValue(p->elementSet().toUtf8()));
}
case DomProperty::Enum: {
const QByteArray pname = p->attributeName().toUtf8();
const int index = meta->indexOfProperty(pname);
QString enumValue = p->elementEnum();
// Triggers in case of objects in Designer like Spacer/Line for which properties
// are serialized using language introspection. On preview, however, these objects are
// emulated by hacks in the formbuilder (size policy/orientation)
fixEnum(enumValue);
if (index == -1) {
// ### special-casing for Line (QFrame) -- fix for 4.2. Jambi hack for enumerations
if (!qstrcmp(meta->className(), "QFrame")
&& (pname == QByteArray("orientation"))) {
return QVariant(enumValue == QFormBuilderStrings::instance().horizontalPostFix ? QFrame::HLine : QFrame::VLine);
} else {
uiLibWarning(QCoreApplication::translate("QFormBuilder", "The enumeration-type property %1 could not be read.").arg(p->attributeName()));
return QVariant();
}
}
const QMetaEnum e = meta->property(index).enumerator();
return QVariant(e.keyToValue(enumValue.toUtf8()));
}
case DomProperty::Brush:
return QVariant::fromValue(afb->setupBrush(p->elementBrush()));
default:
if (afb->resourceBuilder()->isResourceProperty(p)) {
return afb->resourceBuilder()->loadResource(afb->workingDirectory(), p);
}
break;
}
// simple type
return domPropertyToVariant(p);
}