void MainWindow::loadSettings()
{
QVariantHash settings;
QString settingsSavePath;
qDebug() << "loading settings";
settingsSavePath = QString("%1/Hussein.conf").arg(QCoreApplication::applicationDirPath());
JsonSerializer::deserializeSettings(settingsSavePath, settings);
if ( settings.contains(tr("geometry")) )
restoreGeometry(QByteArray::fromHex(settings.value(tr("geometry"), QByteArray()).toByteArray()));
if ( settings.contains(tr("state")) )
restoreState(QByteArray::fromHex(settings.value(tr("state"), QByteArray()).toByteArray()));
if ( settings.contains(tr("files")) )
openFiles(settings.value(tr("files"), QStringList()).toStringList());
if ( settings.contains(tr("current")) )
ui->tabWidget->setCurrentIndex( settings.value(tr("current"), -1).toInt() );
}
void AVEncoder::setOptions(const QVariantHash &dict)
{
DPTR_D(AVEncoder);
d.options = dict;
// if dict is empty, can not return here, default options will be set for AVCodecContext
// apply to AVCodecContext
d.applyOptionsForContext();
/* set AVEncoder meta properties.
* we do not check whether the property exists thus we can set dynamic properties.
*/
if (dict.isEmpty())
return;
if (name() == "avcodec")
return;
QVariant opt;
if (dict.contains(name()))
opt = dict.value(name());
else if (dict.contains(name().toLower()))
opt = dict.value(name().toLower());
else
return; // TODO: set property if no name() key found?
Internal::setOptionsForQObject(opt, this);
}
RssArticlePtr hashToRssArticle(RssFeed* parent, const QVariantHash& h) {
const QString guid = h.value("id").toString();
if (guid.isEmpty())
return RssArticlePtr();
RssArticlePtr art(new RssArticle(parent, guid));
art->m_title = h.value("title", "").toString();
art->m_torrentUrl = h.value("torrent_url", "").toString();
art->m_link = h.value("news_link", "").toString();
art->m_description = h.value("description").toString();
art->m_date = h.value("date").toDateTime();
art->m_author = h.value("author").toString();
art->m_read = h.value("read", false).toBool();
return art;
}
bool GeoIPDatabase::parseMetadata(const QVariantHash &metadata, QString &error)
{
const QString errMsgNotFound = tr("Metadata error: '%1' entry not found.");
const QString errMsgInvalid = tr("Metadata error: '%1' entry has invalid type.");
qDebug() << "Parsing MaxMindDB metadata...";
CHECK_METADATA_REQ(binary_format_major_version, UShort);
CHECK_METADATA_REQ(binary_format_minor_version, UShort);
uint versionMajor = metadata.value("binary_format_major_version").toUInt();
uint versionMinor = metadata.value("binary_format_minor_version").toUInt();
if (versionMajor != 2) {
error = tr("Unsupported database version: %1.%2").arg(versionMajor).arg(versionMinor);
return false;
}
CHECK_METADATA_REQ(ip_version, UShort);
m_ipVersion = metadata.value("ip_version").value<quint16>();
if (m_ipVersion != 6) {
error = tr("Unsupported IP version: %1").arg(m_ipVersion);
return false;
}
CHECK_METADATA_REQ(record_size, UShort);
m_recordSize = metadata.value("record_size").value<quint16>();
if (m_recordSize != 24) {
error = tr("Unsupported record size: %1").arg(m_recordSize);
return false;
}
m_nodeSize = m_recordSize / 4;
m_recordBytes = m_nodeSize / 2;
CHECK_METADATA_REQ(node_count, UInt);
m_nodeCount = metadata.value("node_count").value<quint32>();
m_indexSize = m_nodeCount * m_nodeSize;
CHECK_METADATA_REQ(database_type, QString);
QString dbType = metadata.value("database_type").toString();
if (dbType != DB_TYPE) {
error = tr("Invalid database type: %1").arg(dbType);
return false;
}
CHECK_METADATA_REQ(build_epoch, ULongLong);
m_buildEpoch = QDateTime::fromTime_t(metadata.value("build_epoch").toULongLong());
CHECK_METADATA_OPT(languages, QVariantList);
CHECK_METADATA_OPT(description, QVariantHash);
return true;
}
void DFMSideBarDeviceItem::doUnmountOrEject()
{
QVariantHash info = getExtensionPropertys();
if (info.value("isRemovable", false).toBool() && info.value("canEject", false).toBool()) {
gvfsMountManager->eject(info.value("deviceId").toString());
return;
}
if (info.value("canUnmount", false).toBool()) {
gvfsMountManager->unmount(info.value("deviceId").toString());
}
if (info.value("canStop", false).toBool()) {
DUrl deviceIdUrl;
deviceIdUrl.setQuery(info.value("deviceId").toString());
AppController::instance()->actionSafelyRemoveDrive(dMakeEventPointer<DFMUrlBaseEvent>(this, deviceIdUrl));
}
}
bool RegisterFileTypeOperation::undoOperation()
{
#ifdef Q_OS_WIN
ensureOptionalArgumentsRead();
QStringList args = arguments();
if (!checkArgumentCount(2, 5, tr("Register File Type: Invalid arguments")))
return false;
bool allUsers = false;
PackageManagerCore *const core = packageManager();
if (core && core->value(scAllUsers) == scTrue)
allUsers = true;
QSettingsWrapper settings(QLatin1String(allUsers ? "HKEY_LOCAL_MACHINE" : "HKEY_CURRENT_USER")
, QSettingsWrapper::NativeFormat);
const QString classesProgId = QString::fromLatin1("Software/Classes/") + m_progId;
const QString classesFileType = QString::fromLatin1("Software/Classes/.%2").arg(args.at(0));
const QString classesApplications = QString::fromLatin1("Software/Classes/Applications/") + m_progId;
// Quoting MSDN here: When uninstalling an application, the ProgIDs and most other registry information
// associated with that application should be deleted as part of the uninstallation.However, applications
// that have taken ownership of a file type (by setting the Default value of the file type's
// HKEY...\.extension subkey to the ProgID of the application) should not attempt to remove that value
// when uninstalling. Leaving the data in place for the Default value avoids the difficulty of
// determining whether another application has taken ownership of the file type and overwritten the
// Default value after the original application was installed. Windows respects the Default value only
// if the ProgID found there is a registered ProgID. If the ProgID is unregistered, it is ignored.
// if the hive didn't change since we touched it
if (value(QLatin1String("newType")).toHash() == readHive(&settings, classesFileType)) {
// reset to the values we found
settings.remove(classesFileType);
settings.beginGroup(classesFileType);
const QVariantHash keyValues = value(QLatin1String("oldType")).toHash();
foreach (const QString &key, keyValues.keys())
settings.setValue(key, keyValues.value(key));
settings.endGroup();
} else {
QSharedPointer<Jreen::Payload> JPersonMoodConverter::convertTo(const QVariantHash &map) const
{
QString mood = map.value(QLatin1String("mood")).toString();
QString text = map.value(QLatin1String("description")).toString();
return Jreen::Payload::Ptr(new Jreen::Mood(mood, text));
}
QVariantHash PlayerSource::getPlayerMprisInfo(const QString mpris) const
{
qCDebug(LOG_ESM) << "MPRIS" << mpris;
QVariantHash info = defaultInfo();
if (mpris.isEmpty())
return info;
QDBusConnection bus = QDBusConnection::sessionBus();
// comes from the following request:
// qdbus org.mpris.MediaPlayer2.vlc /org/mpris/MediaPlayer2
// org.freedesktop.DBus.Properties.Get org.mpris.MediaPlayer2.Player
// Metadata
// or the same but using dbus-send:
// dbus-send --print-reply --session --dest=org.mpris.MediaPlayer2.vlc
// /org/mpris/MediaPlayer2 org.freedesktop.DBus.Properties.Get
// string:'org.mpris.MediaPlayer2.Player' string:'Metadata'
QVariantList args = QVariantList()
<< QString("org.mpris.MediaPlayer2.Player")
<< QString("Metadata");
QDBusMessage request = QDBusMessage::createMethodCall(
QString("org.mpris.MediaPlayer2.%1").arg(mpris),
QString("/org/mpris/MediaPlayer2"), QString(""), QString("Get"));
request.setArguments(args);
QDBusMessage response = bus.call(request, QDBus::BlockWithGui);
if ((response.type() != QDBusMessage::ReplyMessage)
|| (response.arguments().isEmpty())) {
qCWarning(LOG_ESM) << "Error message" << response.errorMessage();
} else {
// another portion of dirty magic
QVariantHash map
= qdbus_cast<QVariantHash>(response.arguments()
.first()
.value<QDBusVariant>()
.variant()
.value<QDBusArgument>());
info[QString("player/album")]
= map.value(QString("xesam:album"), QString("unknown"));
// artist is array
info[QString("player/artist")]
= map.value(QString("xesam:artist"), QString("unknown")).toString();
info[QString("player/duration")]
= map.value(QString("mpris:length"), 0).toInt() / (1000 * 1000);
info[QString("player/title")]
= map.value(QString("xesam:title"), QString("unknown"));
}
// position
args[1] = QString("Position");
request.setArguments(args);
response = bus.call(request, QDBus::BlockWithGui);
if ((response.type() != QDBusMessage::ReplyMessage)
|| (response.arguments().isEmpty())) {
qCWarning(LOG_ESM) << "Error message" << response.errorMessage();
} else {
// this cast is simpler than the previous one ;)
info[QString("player/progress")] = response.arguments()
.first()
.value<QDBusVariant>()
.variant()
.toLongLong()
/ (1000 * 1000);
}
return info;
}
void start(const QVariant &vrequest, Mode mode)
{
outSeq = 0;
outCredits = 0;
quiet = false;
ZhttpRequestPacket request;
if(!request.fromVariant(vrequest))
{
log_warning("failed to parse zurl request");
QVariantHash vhash = vrequest.toHash();
rid = vhash.value("id").toByteArray();
toAddress = vhash.value("from").toByteArray();
QByteArray type = vhash.value("type").toByteArray();
if(!toAddress.isEmpty() && type != "error" && type != "cancel")
{
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
}
else
{
cleanup();
QMetaObject::invokeMethod(q, "finished", Qt::QueuedConnection);
}
return;
}
rid = request.id;
toAddress = request.from;
userData = request.userData;
sentHeader = false;
stuffToRead = false;
bytesReceived = 0;
ignorePolicies = request.ignorePolicies;
if(request.uri.isEmpty())
{
log_warning("missing request uri");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
QString scheme = request.uri.scheme();
if(scheme == "https" || scheme == "http")
{
transport = HttpTransport;
}
else if(scheme == "wss" || scheme == "ws")
{
transport = WebSocketTransport;
}
else
{
log_warning("unsupported scheme");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
if(transport == WebSocketTransport && mode != Worker::Stream)
{
log_warning("websocket must be used from stream interface");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
int defaultPort;
if(scheme == "https" || scheme == "wss")
defaultPort = 443;
else // http || wss
defaultPort = 80;
HttpHeaders headers = request.headers;
if(transport == HttpTransport)
{
// fire and forget
if(mode == Worker::Stream && (rid.isEmpty() || toAddress.isEmpty()))
quiet = true;
// streaming only allowed on streaming interface
if(mode == Worker::Stream)
outStream = request.stream;
else
outStream = false;
if(request.method.isEmpty())
{
log_warning("missing request method");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
log_info("IN id=%s, %s %s", request.id.data(), qPrintable(request.method), request.uri.toEncoded().data());
// inbound streaming must start with sequence number of 0
if(mode == Worker::Stream && request.more && request.seq != 0)
{
log_warning("streamed input must start with seq 0");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
// can't use these two together
if(mode == Worker::Single && request.more)
{
log_warning("cannot use streamed input on router interface");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
bodySent = false;
inSeq = request.seq;
if(!isAllowed(request.uri.host()) || (!request.connectHost.isEmpty() && !isAllowed(request.connectHost)))
{
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "policy-violation"));
return;
}
QByteArray hostHeader = request.uri.host().toUtf8();
// only tack on the port if it isn't being overridden
int port = request.uri.port(defaultPort);
if(request.connectPort == -1 && port != defaultPort)
hostHeader += ":" + QByteArray::number(port);
headers.removeAll("Host");
headers += HttpHeader("Host", hostHeader);
hreq = new HttpRequest(dns, this);
connect(hreq, SIGNAL(nextAddress(const QHostAddress &)), SLOT(req_nextAddress(const QHostAddress &)));
connect(hreq, SIGNAL(readyRead()), SLOT(req_readyRead()));
connect(hreq, SIGNAL(bytesWritten(int)), SLOT(req_bytesWritten(int)));
connect(hreq, SIGNAL(error()), SLOT(req_error()));
maxResponseSize = request.maxSize;
sessionTimeout = request.timeout;
if(!request.connectHost.isEmpty())
hreq->setConnectHost(request.connectHost);
if(request.connectPort != -1)
request.uri.setPort(request.connectPort);
hreq->setIgnoreTlsErrors(request.ignoreTlsErrors);
if(request.followRedirects)
hreq->setFollowRedirects(8);
if(request.credits != -1)
outCredits += request.credits;
}
else // WebSocketTransport
{
log_info("IN id=%s, %s", request.id.data(), request.uri.toEncoded().data());
// inbound streaming must start with sequence number of 0
if(request.seq != 0)
{
log_warning("websocket input must start with seq 0");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
if(toAddress.isEmpty())
{
log_warning("websocket input must provide from address");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
inSeq = request.seq;
if(!isAllowed(request.uri.host()) || (!request.connectHost.isEmpty() && !isAllowed(request.connectHost)))
{
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "policy-violation"));
return;
}
QByteArray hostHeader = request.uri.host().toUtf8();
// only tack on the port if it isn't being overridden
int port = request.uri.port(defaultPort);
if(request.connectPort == -1 && port != defaultPort)
hostHeader += ":" + QByteArray::number(port);
headers.removeAll("Host");
headers += HttpHeader("Host", hostHeader);
ws = new WebSocket(dns, this);
connect(ws, SIGNAL(nextAddress(const QHostAddress &)), SLOT(req_nextAddress(const QHostAddress &)));
connect(ws, SIGNAL(connected()), SLOT(ws_connected()));
connect(ws, SIGNAL(readyRead()), SLOT(ws_readyRead()));
connect(ws, SIGNAL(framesWritten(int)), SLOT(ws_framesWritten(int)));
connect(ws, SIGNAL(peerClosing()), SLOT(ws_peerClosing()));
connect(ws, SIGNAL(closed()), SLOT(ws_closed()));
connect(ws, SIGNAL(error()), SLOT(ws_error()));
if(!request.connectHost.isEmpty())
ws->setConnectHost(request.connectHost);
if(request.connectPort != -1)
request.uri.setPort(request.connectPort);
ws->setIgnoreTlsErrors(request.ignoreTlsErrors);
ws->setMaxFrameSize(config->sessionBufferSize);
if(request.credits != -1)
outCredits += request.credits;
}
httpActivityTimer = new QTimer(this);
connect(httpActivityTimer, SIGNAL(timeout()), SLOT(httpActivity_timeout()));
httpActivityTimer->setSingleShot(true);
httpActivityTimer->start(config->activityTimeout * 1000);
if(sessionTimeout != -1)
{
httpSessionTimer = new QTimer(this);
connect(httpSessionTimer, SIGNAL(timeout()), SLOT(httpSession_timeout()));
httpSessionTimer->setSingleShot(true);
httpSessionTimer->start(sessionTimeout);
}
if(transport == WebSocketTransport || (transport == HttpTransport && mode == Worker::Stream))
{
expireTimer = new QTimer(this);
connect(expireTimer, SIGNAL(timeout()), SLOT(expire_timeout()));
expireTimer->setSingleShot(true);
expireTimer->start(SESSION_EXPIRE);
keepAliveTimer = new QTimer(this);
connect(keepAliveTimer, SIGNAL(timeout()), SLOT(keepAlive_timeout()));
keepAliveTimer->start(SESSION_EXPIRE / 2);
}
if(transport == HttpTransport)
{
if(!request.body.isEmpty() && !request.more && !headers.contains("Content-Length"))
headers += HttpHeader("Content-Length", QByteArray::number(request.body.size()));
bool hasOrMightHaveBody = (!request.body.isEmpty() || request.more);
hreq->start(request.method, request.uri, headers, hasOrMightHaveBody);
if(hasOrMightHaveBody)
{
if(!request.body.isEmpty())
hreq->writeBody(request.body);
if(!request.more)
{
bodySent = true;
hreq->endBody();
}
}
else
bodySent = true;
if(mode == Stream)
{
if(request.more)
{
// send cts
ZhttpResponsePacket resp;
resp.type = ZhttpResponsePacket::Credit;
resp.credits = config->sessionBufferSize;
writeResponse(resp);
}
else
{
// send ack
ZhttpResponsePacket resp;
resp.type = ZhttpResponsePacket::KeepAlive;
writeResponse(resp);
}
}
}
else // WebSocketTransport
{
ws->start(request.uri, headers);
}
}
/**
* @brief Login::do_login
* Sets all UI parameters and calls a function to proceed according to the state of the login.
* @param username
* @param password
* @param proxy_hostname
* @param proxy_hostport
* @param proxy_username
* @param proxy_password
* @date
* Created: Filipe, 2 Jan 2014
* Modified: Filipe, 7 Mar 2014
*/
void Login::do_login(const QVariantHash &options)
{
//Password or user change, the process has to be repeted.
if(username != options.value("username").toString() || password != options.value("password").toString())
{
state = persistent;
username = options.value("username").toString();
password = options.value("password").toString();
}
//Set proxy settings.
if(options.value("proxy_hostname", "").toString() != "" || options.value("proxy_hostport", "").toString() != "")
{
network_manager->set_proxy(Helper::proxy_type(options.value("proxy_type").toString()),
options.value("proxy_hostname").toString(),
options.value("proxy_hostport").toInt(),
options.value("proxy_username").toString(),
options.value("proxy_password").toString());
}
else
{
network_manager->set_proxy(QNetworkProxy::NoProxy);
}
output(network_manager->print(), 3);
//Set captcha and steamguard code.
captcha_text = options.value("captcha").toString();
guard_code = options.value("guard_code").toString();
guard_name = options.value("guard_name").toString();
remember_login = options.value("remember_login").toBool();
//Proceed acording to state.
process_state();
}
void start(const QVariant &vrequest, Mode mode)
{
outSeq = 0;
ZurlRequestPacket request;
if(!request.fromVariant(vrequest))
{
log_warning("failed to parse zurl request");
QVariantHash vhash = vrequest.toHash();
rid = vhash.value("id").toByteArray();
assert(!rid.isEmpty()); // app layer ensures this
receiver = vhash.value("sender").toByteArray();
bool cancel = vhash.value("cancel").toBool();
if(!receiver.isEmpty() && !cancel)
{
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
}
else
{
cleanup();
QMetaObject::invokeMethod(q, "finished", Qt::QueuedConnection);
}
return;
}
rid = request.id;
receiver = request.sender;
outCredits = 0;
userData = request.userData;
quiet = false;
sentHeader = false;
stuffToRead = false;
bytesReceived = 0;
ignorePolicies = request.ignorePolicies;
// streaming only allowed on streaming interface
if(mode == Worker::Stream)
outStream = request.stream;
else
outStream = false;
// some required fields
if(request.method.isEmpty() || request.uri.isEmpty())
{
log_warning("missing request method or missing uri");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
log_info("IN id=%s, %s %s", request.id.data(), qPrintable(request.method), request.uri.toEncoded().data());
// inbound streaming must start with sequence number of 0
if(mode == Worker::Stream && request.more && request.seq != 0)
{
log_warning("streamed input must start with seq 0");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
// fire and forget
if(mode == Worker::Stream && receiver.isEmpty())
quiet = true;
// can't use these two together
if(mode == Worker::Single && request.more)
{
log_warning("cannot use streamed input on router interface");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
bodySent = false;
inSeq = request.seq;
if(!isAllowed(request.uri.host()) || (!request.connectHost.isEmpty() && !isAllowed(request.connectHost)))
{
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "policy-violation"));
return;
}
hreq = new HttpRequest(dns, this);
connect(hreq, SIGNAL(nextAddress(const QHostAddress &)), SLOT(req_nextAddress(const QHostAddress &)));
connect(hreq, SIGNAL(readyRead()), SLOT(req_readyRead()));
connect(hreq, SIGNAL(bytesWritten(int)), SLOT(req_bytesWritten(int)));
connect(hreq, SIGNAL(error()), SLOT(req_error()));
maxResponseSize = request.maxSize;
if(!request.connectHost.isEmpty())
hreq->setConnectHost(request.connectHost);
hreq->setIgnoreTlsErrors(request.ignoreTlsErrors);
if(request.credits != -1)
outCredits += request.credits;
HttpHeaders headers = request.headers;
// ensure content-length (or overwrite it, if not streaming input)
if((request.method == "POST" || request.method == "PUT") && (!headers.contains("content-length") || !request.more))
headers += HttpHeader("Content-Length", QByteArray::number(request.body.size()));
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), SLOT(timer_timeout()));
timer->setSingleShot(true);
timer->start(config->sessionTimeout * 1000);
hreq->start(request.method, request.uri, headers);
// note: unlike follow-up requests, the initial request is assumed to have a body.
// if no body field is present, we act as if it is present but empty.
if(!request.body.isEmpty())
{
if(request.more && !request.headers.contains("content-length"))
{
log_warning("streamed input requires content-length");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "length-required"));
return;
}
hreq->writeBody(request.body);
}
if(!request.more)
{
bodySent = true;
hreq->endBody();
}
else
{
// send cts
ZurlResponsePacket resp;
resp.credits = config->sessionBufferSize;
writeResponse(resp);
}
}
void GeometryReader::run() {
DependencyManager::get<StatTracker>()->decrementStat("PendingProcessing");
CounterStat counter("Processing");
PROFILE_RANGE_EX(resource_parse_geometry, "GeometryReader::run", 0xFF00FF00, 0, { { "url", _url.toString() } });
auto originalPriority = QThread::currentThread()->priority();
if (originalPriority == QThread::InheritPriority) {
originalPriority = QThread::NormalPriority;
}
QThread::currentThread()->setPriority(QThread::LowPriority);
Finally setPriorityBackToNormal([originalPriority]() {
QThread::currentThread()->setPriority(originalPriority);
});
if (!_resource.data()) {
return;
}
try {
if (_data.isEmpty()) {
throw QString("reply is NULL");
}
// Ensure the resource has not been deleted
auto resource = _resource.toStrongRef();
if (!resource) {
qCWarning(modelnetworking) << "Abandoning load of" << _url << "; could not get strong ref";
return;
}
if (_url.path().isEmpty()) {
throw QString("url is invalid");
}
HFMModel::Pointer hfmModel;
QVariantHash serializerMapping = _mapping.second;
serializerMapping["combineParts"] = _combineParts;
serializerMapping["deduplicateIndices"] = true;
if (_url.path().toLower().endsWith(".gz")) {
QByteArray uncompressedData;
if (!gunzip(_data, uncompressedData)) {
throw QString("failed to decompress .gz model");
}
// Strip the compression extension from the path, so the loader can infer the file type from what remains.
// This is okay because we don't expect the serializer to be able to read the contents of a compressed model file.
auto strippedUrl = _url;
strippedUrl.setPath(_url.path().left(_url.path().size() - 3));
hfmModel = _modelLoader.load(uncompressedData, serializerMapping, strippedUrl, "");
} else {
hfmModel = _modelLoader.load(_data, serializerMapping, _url, _webMediaType.toStdString());
}
if (!hfmModel) {
throw QString("unsupported format");
}
if (hfmModel->meshes.empty() || hfmModel->joints.empty()) {
throw QString("empty geometry, possibly due to an unsupported model version");
}
// Add scripts to hfmModel
if (!serializerMapping.value(SCRIPT_FIELD).isNull()) {
QVariantList scripts = serializerMapping.values(SCRIPT_FIELD);
for (auto &script : scripts) {
hfmModel->scripts.push_back(script.toString());
}
}
// Do processing on the model
baker::Baker modelBaker(hfmModel, _mapping.second, _mapping.first);
modelBaker.run();
auto processedHFMModel = modelBaker.getHFMModel();
auto materialMapping = modelBaker.getMaterialMapping();
QMetaObject::invokeMethod(resource.data(), "setGeometryDefinition",
Q_ARG(HFMModel::Pointer, processedHFMModel), Q_ARG(MaterialMapping, materialMapping));
} catch (const std::exception&) {
auto resource = _resource.toStrongRef();
if (resource) {
QMetaObject::invokeMethod(resource.data(), "finishedLoading",
Q_ARG(bool, false));
}
} catch (QString& e) {
qCWarning(modelnetworking) << "Exception while loading model --" << e;
auto resource = _resource.toStrongRef();
if (resource) {
QMetaObject::invokeMethod(resource.data(), "finishedLoading",
Q_ARG(bool, false));
}
}
}
QByteArray ViewEmail::render(Context *c) const
{
Q_D(const ViewEmail);
QVariantHash email = c->stash(d->stashKey).toHash();
if (email.isEmpty()) {
c->error(QStringLiteral("Cannot render template, template name or template stash key not defined"));
return QByteArray();
}
MimeMessage message;
QVariant value;
value = email.value(QStringLiteral("to"));
if (value.type() == QVariant::String && !value.toString().isEmpty()) {
message.addTo(value.toString());
}
value = email.value(QStringLiteral("cc"));
if (value.type() == QVariant::String && !value.toString().isEmpty()) {
message.addCc(value.toString());
}
value = email.value(QStringLiteral("from"));
if (value.type() == QVariant::String && !value.toString().isEmpty()) {
message.setSender(value.toString());
}
value = email.value(QStringLiteral("subject"));
if (value.type() == QVariant::String && !value.toString().isEmpty()) {
message.setSubject(value.toString());
}
QVariant body = email.value(QStringLiteral("body"));
QVariant parts = email.value(QStringLiteral("parts"));
if (body.isNull() && parts.isNull()) {
c->error(QStringLiteral("Can't send email without parts or body, check stash"));
return QByteArray();
}
if (!parts.isNull()) {
const QVariantList partsVariant = parts.toList();
Q_FOREACH (const QVariant &part, partsVariant) {
MimePart *mime = part.value<MimePart*>();
if (mime) {
message.addPart(mime);
} else {
qCCritical(CUTELYST_VIEW_EMAIL) << "Failed to cast MimePart";
}
}
auto contentTypeIt = email.constFind(QStringLiteral("content_type"));
if (contentTypeIt != email.constEnd()
&& !contentTypeIt.value().isNull()
&& !contentTypeIt.value().toString().isEmpty()) {
const QByteArray contentType = contentTypeIt.value().toString().toLatin1();
qCDebug(CUTELYST_VIEW_EMAIL) << "Using specified content_type" << contentType;
message.getContent().setContentType(contentType);
} else if (!d->defaultContentType.isEmpty()) {
qCDebug(CUTELYST_VIEW_EMAIL) << "Using default content_type" << d->defaultContentType;
message.getContent().setContentType(d->defaultContentType);
}
} else {
void AVDecoder::setOptions(const QVariantHash &dict)
{
DPTR_D(AVDecoder);
d.options = dict;
if (d.dict) {
av_dict_free(&d.dict);
d.dict = 0; //aready 0 in av_free
}
if (dict.isEmpty())
return;
// TODO: use QVariantMap only
QVariant opt;
if (dict.contains("avcodec"))
opt = dict.value("avcodec");
if (opt.type() == QVariant::Hash) {
QVariantHash avcodec_dict = opt.toHash();
// workaround for VideoDecoderFFmpeg. now it does not call av_opt_set_xxx, so set here in dict
// TODO: wrong if opt is empty
//if (dict.contains("FFmpeg"))
// avcodec_dict.unite(dict.value("FFmpeg").toHash());
QHashIterator<QString, QVariant> i(avcodec_dict);
while (i.hasNext()) {
i.next();
const QByteArray key(i.key().toLower().toUtf8());
switch (i.value().type()) {
case QVariant::Hash: // for example "vaapi": {...}
continue;
case QVariant::Bool:
case QVariant::Int: {
// QVariant.toByteArray(): "true" or "false", can not recognized by avcodec
av_dict_set(&d.dict, key.constData(), QByteArray::number(i.value().toInt()).constData(), 0);
if (d.codec_ctx)
av_opt_set_int(d.codec_ctx, key.constData(), i.value().toInt(), 0);
}
break;
case QVariant::ULongLong:
case QVariant::LongLong: {
av_dict_set(&d.dict, key.constData(), QByteArray::number(i.value().toLongLong()).constData(), 0);
if (d.codec_ctx)
av_opt_set_int(d.codec_ctx, key.constData(), i.value().toLongLong(), 0);
}
break;
default:
// avcodec key and value are in lower case
av_dict_set(&d.dict, i.key().toLower().toUtf8().constData(), i.value().toByteArray().toLower().constData(), 0);
break;
}
qDebug("avcodec option: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
}
} else if (opt.type() == QVariant::Map) {
QVariantMap avcodec_dict = opt.toMap();
// workaround for VideoDecoderFFmpeg. now it does not call av_opt_set_xxx, so set here in dict
//if (dict.contains("FFmpeg"))
// avcodec_dict.unite(dict.value("FFmpeg").toMap());
QMapIterator<QString, QVariant> i(avcodec_dict);
while (i.hasNext()) {
i.next();
const QByteArray key(i.key().toLower().toUtf8());
switch (i.value().type()) {
case QVariant::Map: // for example "vaapi": {...}
continue;
case QVariant::Bool:
case QVariant::UInt:
case QVariant::Int: {
// QVariant.toByteArray(): "true" or "false", can not recognized by avcodec
av_dict_set(&d.dict, key.constData(), QByteArray::number(i.value().toInt()), 0);
if (d.codec_ctx)
av_opt_set_int(d.codec_ctx, key.constData(), i.value().toInt(), 0);
}
break;
case QVariant::ULongLong:
case QVariant::LongLong: {
av_dict_set(&d.dict, key.constData(), QByteArray::number(i.value().toLongLong()).constData(), 0);
if (d.codec_ctx)
av_opt_set_int(d.codec_ctx, key.constData(), i.value().toLongLong(), 0);
}
break;
default:
// avcodec key and value are in lower case
av_dict_set(&d.dict, i.key().toLower().toUtf8().constData(), i.value().toByteArray().toLower().constData(), 0);
break;
}
qDebug("avcodec option: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
}
}
if (name() == "avcodec")
return;
if (dict.contains(name()))
opt = dict.value(name());
else if (dict.contains(name().toLower()))
opt = dict.value(name().toLower());
else
return;
if (opt.type() == QVariant::Hash) {
QVariantHash property_dict(opt.toHash());
if (property_dict.isEmpty())
return;
QHashIterator<QString, QVariant> i(property_dict);
while (i.hasNext()) {
i.next();
if (i.value().type() == QVariant::Hash) // for example "vaapi": {...}
continue;
setProperty(i.key().toUtf8().constData(), i.value());
qDebug("decoder property: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
}
} else if (opt.type() == QVariant::Map) {
QVariantMap property_dict(opt.toMap());
if (property_dict.isEmpty())
return;
QMapIterator<QString, QVariant> i(property_dict);
while (i.hasNext()) {
i.next();
if (i.value().type() == QVariant::Map) // for example "vaapi": {...}
continue;
setProperty(i.key().toUtf8().constData(), i.value());
qDebug("decoder property: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData());
}
}
}
/*!
Creates widget. \a params must include 'uri' for the desired widget type.
'preferences' is optional.
*/
bool HsContentService::createWidget(const QVariantHash ¶ms)
{
return addWidget(params.value(Hs::uri).toString(),
params.value(Hs::preferences).toHash(),
params.value(Hs::homescreenData));
}
QMenu *DFMSideBarDeviceItem::createStandardContextMenu() const
{
QMenu *menu = new QMenu();
const DAbstractFileInfoPointer infoPointer = fileService->createFileInfo(this, url());
DFileManagerWindow *wnd = qobject_cast<DFileManagerWindow *>(topLevelWidget());
bool shouldDisable = !WindowManager::tabAddableByWinId(wnd->windowId());
QVariantHash info = getExtensionPropertys();
DUrl deviceIdUrl;
deviceIdUrl.setQuery(info.value("deviceId").toString());
menu->addAction(QObject::tr("Open in new window"), [this, info, deviceIdUrl]() {
if (info.value("isMounted", false).toBool()) {
WindowManager::instance()->showNewWindow(url(), true);
} else {
appController->actionOpenDiskInNewWindow(dMakeEventPointer<DFMUrlBaseEvent>(this, deviceIdUrl));
}
});
menu->addAction(QObject::tr("Open in new tab"), [wnd, this, info, deviceIdUrl]() {
if (info.value("isMounted", false).toBool()) {
wnd->openNewTab(url());
} else {
appController->actionOpenDiskInNewTab(dMakeEventPointer<DFMUrlBaseEvent>(this, deviceIdUrl));
}
})->setDisabled(shouldDisable);
menu->addSeparator();
if (infoPointer->canRename()) {
menu->addAction(QObject::tr("Rename"), [this]() {
DFMSideBarDeviceItem *ccItem = const_cast<DFMSideBarDeviceItem *>(this);
ccItem->showRenameEditor();
});
}
// if (info.value("canEject", false).toBool()) {
// menu->addAction(QObject::tr("Eject"), [this, info]() {
// gvfsMountManager->eject(info.value("deviceId").toString());
// });
// }
if (info.value("canStop", false).toBool()) {
menu->addAction(QObject::tr("Safely Remove"), [this, info, deviceIdUrl]() {
AppController::instance()->actionSafelyRemoveDrive(dMakeEventPointer<DFMUrlBaseEvent>(this, deviceIdUrl));
});
}
if (info.value("canMount", false).toBool() && !info.value("isMounted", false).toBool()) {
menu->addAction(QObject::tr("Mount"), [info]() {
gvfsMountManager->mount(info.value("deviceId").toString());
});
}
// if (info.value("canUnmount", false).toBool()) {
// menu->addAction(QObject::tr("Unmount"), [this, info]() {
// gvfsMountManager->unmount(info.value("deviceId").toString());
// });
// }
// According to the designer and PM, we should use "Unmount" even we are actually doing *Eject* for removable device.
// This behavior should be discussed later.
if (info.value("canUnmount", false).toBool()) {
menu->addAction(QObject::tr("Unmount"), this, SLOT(doUnmountOrEject()));
}
if (info.value("mediaType", 0).toInt() == UDiskDeviceInfo::MediaType::removable) {
menu->addAction(QObject::tr("Format"), [this, info, deviceIdUrl]() {
AppController::instance()->actionFormatDevice(dMakeEventPointer<DFMUrlBaseEvent>(this, deviceIdUrl));
});
}
// Device can be a network scheme, like smb://, ftp:// and sftp://
QString devicePathScheme = DUrl::fromUserInput(info.value("deviceId").toString()).scheme();
if (devicePathScheme == SMB_SCHEME || devicePathScheme == FTP_SCHEME || devicePathScheme == SFTP_SCHEME || devicePathScheme == DAV_SCHEME) {
menu->addAction(QObject::tr("Log out and unmount"), [this, info, deviceIdUrl]() {
AppController::instance()->actionForgetPassword(dMakeEventPointer<DFMUrlBaseEvent>(this, deviceIdUrl));
});
}
menu->addSeparator();
QAction *propertyAction = new QAction(QObject::tr("Disk info"), menu);
connect(propertyAction, &QAction::triggered, this, [this, info]() {
DUrl mountPointUrl(info.value("mountPointUrl", QString()).toString());
mountPointUrl = mountPointUrl.isEmpty() ? url() : mountPointUrl;
mountPointUrl.setQuery(info.value("deviceId", "what?").toString());
fileSignalManager->requestShowPropertyDialog(DFMUrlListBaseEvent(this, {mountPointUrl}));
});
propertyAction->setDisabled(!info.value("isMounted", false).toBool());
menu->addAction(propertyAction);
return menu;
}
/*!
Validates the specified parameter \a hash by the set rules.
As default, TF::Required is set for all parameters. If not required,
set the rule to \a false like this:
setRule("xxx", Tf::Required, false);
*/
bool TFormValidator::validate(const QVariantHash &hash)
{
errors.clear();
// Add default rules, Tf::Required.
QString msg = Tf::app()->validationErrorMessage(Tf::Required);
for (QStringListIterator i(hash.keys()); i.hasNext(); ) {
const QString &k = i.next();
if (!containsRule(k, Tf::Required)) {
rules.append(RuleEntry(k, (int)Tf::Required, true, msg));
}
}
for (QListIterator<RuleEntry> i(rules); i.hasNext(); ) {
const RuleEntry &r = i.next();
QString str = hash.value(r.key).toString(); // value string
if (str.isEmpty()) {
bool req = r.value.toBool();
if (r.rule == Tf::Required && req) {
tSystemDebug("validation error: required parameter is empty, key:%s", qPrintable(r.key));
errors << qMakePair(r.key, r.rule);
}
} else {
bool ok1, ok2;
tSystemDebug("validating key:%s value: %s", qPrintable(r.key), qPrintable(str));
switch (r.rule) {
case Tf::Required:
break;
case Tf::MaxLength: {
int max = r.value.toInt(&ok2);
if (!ok2 || str.length() > max) {
errors << qMakePair(r.key, r.rule);
}
break; }
case Tf::MinLength: {
int min = r.value.toInt(&ok2);
if (!ok2 || str.length() < min) {
errors << qMakePair(r.key, r.rule);
}
break; }
case Tf::IntMax: {
qint64 n = str.toLongLong(&ok1);
qint64 max = r.value.toLongLong(&ok2);
if (!ok1 || !ok2 || n > max) {
errors << qMakePair(r.key, r.rule);
}
break; }
case Tf::IntMin: {
qint64 n = str.toLongLong(&ok1);
qint64 min = r.value.toLongLong(&ok2);
if (!ok1 || !ok2 || n < min) {
errors << qMakePair(r.key, r.rule);
}
break; }
case Tf::DoubleMax: {
double n = str.toDouble(&ok1);
double max = r.value.toLongLong(&ok2);
if (!ok1 || !ok2 || n > max) {
errors << qMakePair(r.key, r.rule);
}
break; }
case Tf::DoubleMin: {
double n = str.toDouble(&ok1);
double min = r.value.toDouble(&ok2);
if (!ok1 || !ok2 || n < min) {
errors << qMakePair(r.key, r.rule);
}
break; }
case Tf::EmailAddress: { // refer to RFC5321
if ( r.value.toBool() ) {
QRegExp reg("^" ADDR_SPEC "$");
if (!reg.exactMatch(str)) {
errors << qMakePair(r.key, r.rule);
}
}
break; }
case Tf::Url: {
if ( r.value.toBool() ) {
QUrl url(str, QUrl::StrictMode);
if (!url.isValid()) {
errors << qMakePair(r.key, r.rule);
}
}
break; }
case Tf::Date: {
if ( r.value.toBool() ) {
QDate date = QLocale().toDate(str, dateFormat());
if (!date.isValid()) {
errors << qMakePair(r.key, r.rule);
tSystemDebug("Validation error: Date format: %s", qPrintable(dateFormat()));
}
}
break; }
case Tf::Time: {
if ( r.value.toBool() ) {
QTime time = QLocale().toTime(str, timeFormat());
if (!time.isValid()) {
errors << qMakePair(r.key, r.rule);
tSystemDebug("Validation error: Time format: %s", qPrintable(timeFormat()));
}
}
break; }
case Tf::DateTime: {
if ( r.value.toBool() ) {
QDateTime dt = QLocale().toDateTime(str, dateTimeFormat());
if (!dt.isValid()) {
errors << qMakePair(r.key, r.rule);
tSystemDebug("Validation error: DateTime format: %s", qPrintable(dateTimeFormat()));
}
}
break; }
case Tf::Pattern: {
QRegExp rx = r.value.toRegExp();
if (rx.isEmpty() || !rx.exactMatch(str)) {
errors << qMakePair(r.key, r.rule);
}
break; }
default:
tSystemError("Internal Error, invalid rule: %d [%s:%d]", r.rule, __FILE__, __LINE__);
break;
}
}
}
return errors.isEmpty();
}
void RssParser::parseAtomArticle(QXmlStreamReader& xml, const QString& feedUrl, const QString& baseUrl)
{
QVariantHash article;
bool double_content = false;
while(!xml.atEnd()) {
xml.readNext();
if(xml.isEndElement() && xml.name() == "entry")
break;
if (xml.isStartElement()) {
if (xml.name() == "title") {
// Workaround for CDATA (QString cannot parse html escapes on it's own)
QTextDocument doc;
doc.setHtml(xml.readElementText());
article["title"] = doc.toPlainText();
}
else if (xml.name() == "link") {
QString theLink = ( xml.attributes().isEmpty() ?
xml.readElementText() :
xml.attributes().value("href").toString() );
// Atom feeds can have relative links, work around this and
// take the stress of figuring article full URI from UI
// Assemble full URI
article["news_link"] = ( baseUrl.isEmpty() ?
theLink :
baseUrl + theLink );
}
else if (xml.name() == "summary" || xml.name() == "content"){
if(double_content) { // Duplicate content -> ignore
xml.readNext();
while(xml.name() != "summary" && xml.name() != "content")
xml.readNext();
continue;
}
// Try to also parse broken articles, which don't use html '&' escapes
// Actually works great for non-broken content too
QString feedText = xml.readElementText(QXmlStreamReader::IncludeChildElements);
if (!feedText.isEmpty())
article["description"] = feedText;
double_content = true;
}
else if (xml.name() == "updated"){
// ATOM uses standard compliant date, don't do fancy stuff
QDateTime articleDate = QDateTime::fromString(xml.readElementText(), Qt::ISODate);
article["date"] = ( articleDate.isValid() ?
articleDate :
QDateTime::currentDateTime() );
}
else if (xml.name() == "author") {
xml.readNext();
while(xml.name() != "author") {
if(xml.name() == "name")
article["author"] = xml.readElementText();
xml.readNext();
}
}
else if (xml.name() == "id")
article["id"] = xml.readElementText();
}
}
if (!article.contains("id")) {
// Item does not have a guid, fall back to some other identifier
const QString link = article.value("news_link").toString();
if (!link.isEmpty())
article["id"] = link;
else {
const QString title = article.value("title").toString();
if (!title.isEmpty())
article["id"] = title;
else {
qWarning() << "Item has no guid, link or title, ignoring it...";
return;
}
}
}
emit newArticle(feedUrl, article);
}
WebsiteInformationDialog::WebsiteInformationDialog(WebWidget *widget, QWidget *parent) : Dialog(parent),
m_sslInformation(widget->getSslInformation()),
m_ui(new Ui::WebsiteInformationDialog)
{
m_ui->setupUi(this);
const QVariantHash statistics(widget->getStatistics());
const WindowsManager::ContentStates state(widget->getContentState());
const QString characterEncoding(widget->getCharacterEncoding());
QString host(widget->getUrl().host());
if (host.isEmpty())
{
host = (widget->getUrl().scheme() == QLatin1String("file") ? QLatin1String("localhost") : tr("(unknown)"));
}
if (state.testFlag(WindowsManager::FraudContentState))
{
m_ui->stateLabel->setText(tr("This website was marked as fraud."));
m_ui->stateIconLabel->setPixmap(ThemesManager::getIcon(QLatin1String("badge-fraud"), false).pixmap(16, 16));
}
else if (state.testFlag(WindowsManager::TrustedContentState))
{
m_ui->stateLabel->setText(tr("Your connection with this website is private."));
m_ui->stateIconLabel->setPixmap(ThemesManager::getIcon(QLatin1String("badge-trusted"), false).pixmap(16, 16));
}
else if (state.testFlag(WindowsManager::SecureContentState))
{
m_ui->stateLabel->setText(tr("Your connection with this website is private."));
m_ui->stateIconLabel->setPixmap(ThemesManager::getIcon(QLatin1String("badge-secure"), false).pixmap(16, 16));
}
else if (state.testFlag(WindowsManager::RemoteContentState))
{
m_ui->stateLabel->setText(tr("Your connection with this website is not private."));
m_ui->stateIconLabel->setPixmap(ThemesManager::getIcon(QLatin1String("badge-remote"), false).pixmap(16, 16));
}
else if (state.testFlag(WindowsManager::LocalContentState))
{
m_ui->stateLabel->setText(tr("You are viewing content from your local filesystem."));
m_ui->stateIconLabel->setPixmap(ThemesManager::getIcon(QLatin1String("badge-local"), false).pixmap(16, 16));
}
else if (state.testFlag(WindowsManager::ApplicationContentState))
{
m_ui->stateLabel->setText(tr("You are viewing safe page from Otter Browser."));
m_ui->stateIconLabel->setPixmap(ThemesManager::getIcon(QLatin1String("otter-browser"), false).pixmap(16, 16));
}
else
{
m_ui->stateLabel->setText(tr("No information."));
m_ui->stateIconLabel->setPixmap(ThemesManager::getIcon(QLatin1String("badge-unknown"), false).pixmap(16, 16));
}
m_ui->hostLabel->setText(host);
m_ui->addressLabelWidget->setText(widget->getUrl().toString());
m_ui->titleLabelWidget->setText(widget->getTitle());
m_ui->encodingLabelWidget->setText(characterEncoding.isEmpty() ? tr("unknown") : characterEncoding);
m_ui->sizeLabelWidget->setText(Utils::formatUnit(statistics.value(QLatin1String("bytesTotal")).toLongLong(), false, 1, true));
m_ui->elementsLabelWidget->setText((statistics.value(QLatin1String("requestsBlocked")).toInt() > 0) ? tr("%1 (%n blocked)", "", statistics.value(QLatin1String("requestsBlocked")).toInt()).arg(statistics.value(QLatin1String("requestsStarted")).toInt()) : QString::number(statistics.value(QLatin1String("requestsStarted")).toInt()));
m_ui->downloadDateLabelWidget->setText(Utils::formatDateTime(statistics.value(QLatin1String("dateDownloaded")).toDateTime()));
const QString cookiesPolicy(widget->getOption(QLatin1String("Network/CookiesPolicy")).toString());
if (cookiesPolicy == QLatin1String("acceptExisting"))
{
m_ui->cookiesValueLabel->setText(tr("Only existing"));
}
else if (cookiesPolicy == QLatin1String("readOnly"))
{
m_ui->cookiesValueLabel->setText(tr("Only read existing"));
}
else if (cookiesPolicy == QLatin1String("ignore"))
{
m_ui->cookiesValueLabel->setText(tr("Never"));
}
else
{
m_ui->cookiesValueLabel->setText(tr("Always"));
}
const QString thirdPartyCookiesPolicy(widget->getOption(QLatin1String("Network/ThirdPartyCookiesPolicy")).toString());
if (thirdPartyCookiesPolicy == QLatin1String("acceptExisting"))
{
m_ui->thirdPartyCookiesValueLabel->setText(tr("Only existing"));
}
else if (thirdPartyCookiesPolicy == QLatin1String("ignore"))
{
m_ui->thirdPartyCookiesValueLabel->setText(tr("Never"));
}
else
{
m_ui->thirdPartyCookiesValueLabel->setText(tr("Always"));
}
const QString pluginsPolicy(widget->getOption(QLatin1String("Browser/EnablePlugins")).toString());
if (pluginsPolicy == QLatin1String("enabled"))
{
m_ui->pluginsValueLabel->setText(tr("Always"));
}
else if (pluginsPolicy == QLatin1String("disabled"))
{
m_ui->pluginsValueLabel->setText(tr("Never"));
}
else
{
m_ui->pluginsValueLabel->setText(tr("On demand"));
}
const QString imagesPolicy(widget->getOption(QLatin1String("Browser/EnableImages")).toString());
if (imagesPolicy == QLatin1String("onlyCached"))
{
m_ui->imagesValueLabel->setText(tr("Only cached"));
}
else if (imagesPolicy == QLatin1String("disabled"))
{
m_ui->imagesValueLabel->setText(tr("Never"));
}
else
{
m_ui->imagesValueLabel->setText(tr("Always"));
}
m_ui->javascriptValueLabel->setText(widget->getOption(QLatin1String("Browser/EnableJavaScript")).toBool() ? tr("Always") : tr("Never"));
const QString geolocationPolicy(widget->getOption(QLatin1String("Browser/EnableGeolocation")).toString());
if (geolocationPolicy == QLatin1String("enabled"))
{
m_ui->geolocationValueLabel->setText(tr("Always"));
}
else if (geolocationPolicy == QLatin1String("disabled"))
{
m_ui->geolocationValueLabel->setText(tr("Never"));
}
else
{
m_ui->geolocationValueLabel->setText(tr("Always ask"));
}
const QString fullScreenPolicy(widget->getOption(QLatin1String("Browser/EnableFullScreen")).toString());
if (fullScreenPolicy == QLatin1String("enabled"))
{
m_ui->fullScreenValueLabel->setText(tr("Always"));
}
else if (fullScreenPolicy == QLatin1String("disabled"))
{
m_ui->fullScreenValueLabel->setText(tr("Never"));
}
else
{
m_ui->fullScreenValueLabel->setText(tr("Always ask"));
}
const QString notificationsPolicy(widget->getOption(QLatin1String("Browser/EnableNotifications")).toString());
if (notificationsPolicy == QLatin1String("enabled"))
{
m_ui->notificationsValueLabel->setText(tr("Always"));
}
else if (notificationsPolicy == QLatin1String("disabled"))
{
m_ui->notificationsValueLabel->setText(tr("Never"));
}
else
{
m_ui->notificationsValueLabel->setText(tr("Always ask"));
}
const QString popupsPolicy(widget->getOption(QLatin1String("Content/PopupsPolicy")).toString());
if (popupsPolicy == QLatin1String("openAll"))
{
m_ui->popupsValueLabel->setText(tr("Always"));
}
else if (popupsPolicy == QLatin1String("openAllInBackground"))
{
m_ui->popupsValueLabel->setText(tr("Always (open in backgound)"));
}
else if (popupsPolicy == QLatin1String("blockAll"))
{
m_ui->popupsValueLabel->setText(tr("Never"));
}
else
{
m_ui->popupsValueLabel->setText(tr("Ask"));
}
if (m_sslInformation.certificates.isEmpty())
{
m_ui->tabWidget->setTabEnabled(2, false);
}
else
{
const QSslCertificate certificate(m_sslInformation.certificates.first());
m_ui->certificateIssuedToLabelWidget->setText(certificate.subjectInfo(QSslCertificate::CommonName).join(QLatin1String(", ")));
m_ui->certificateIssuedByLabelWidget->setText(certificate.issuerInfo(QSslCertificate::CommonName).join(QLatin1String(", ")));
m_ui->certificateIssuedOnLabelWidget->setText(Utils::formatDateTime(certificate.effectiveDate()));
m_ui->certificateExpiresOnLabelWidget->setText(Utils::formatDateTime(certificate.expiryDate()));
m_ui->cipherProtocolLabelWidget->setText(m_sslInformation.cipher.protocolString());
m_ui->cipherAuthenticationMethodLabelWidget->setText(m_sslInformation.cipher.authenticationMethod());
m_ui->cipherEncryptionMethodLabelWidget->setText(m_sslInformation.cipher.encryptionMethod());
m_ui->cipherKeyExchangeMethodLabelWidget->setText(m_sslInformation.cipher.keyExchangeMethod());
}
if (m_sslInformation.errors.isEmpty())
{
m_ui->sslErrorsHeaderLabel->hide();
m_ui->sslErrorsViewWidget->hide();
}
else
{
QStandardItemModel *sslErrorsModel(new QStandardItemModel(this));
sslErrorsModel->setHorizontalHeaderLabels(QStringList({tr("Error Message"), tr("URL")}));
for (int i = 0; i < m_sslInformation.errors.count(); ++i)
{
QList<QStandardItem*> items({new QStandardItem(m_sslInformation.errors.at(i).second.errorString()), new QStandardItem(m_sslInformation.errors.at(i).first.toDisplayString())});
items[0]->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
items[0]->setToolTip(items[0]->text());
items[1]->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
items[1]->setToolTip(items[1]->text());
sslErrorsModel->appendRow(items);
}
m_ui->sslErrorsViewWidget->setModel(sslErrorsModel);
}
setWindowTitle(tr("Information for %1").arg(host));
connect(m_ui->preferencesDetailsButton, SIGNAL(clicked(bool)), this, SLOT(showPreferences()));
connect(m_ui->certificateDetailsButton, SIGNAL(clicked(bool)), this, SLOT(showCertificate()));
}
void ModelPackager::populateBasicMapping(QVariantHash& mapping, QString filename, const hfm::Model& hfmModel) {
// mixamo files - in the event that a mixamo file was edited by some other tool, it's likely the applicationName will
// be rewritten, so we detect the existence of several different blendshapes which indicate we're likely a mixamo file
bool likelyMixamoFile = hfmModel.applicationName == "mixamo.com" ||
(hfmModel.blendshapeChannelNames.contains("BrowsDown_Right") &&
hfmModel.blendshapeChannelNames.contains("MouthOpen") &&
hfmModel.blendshapeChannelNames.contains("Blink_Left") &&
hfmModel.blendshapeChannelNames.contains("Blink_Right") &&
hfmModel.blendshapeChannelNames.contains("Squint_Right"));
if (!mapping.contains(NAME_FIELD)) {
mapping.insert(NAME_FIELD, QFileInfo(filename).baseName());
}
if (!mapping.contains(FILENAME_FIELD)) {
QDir root(_modelFile.path());
mapping.insert(FILENAME_FIELD, root.relativeFilePath(filename));
}
if (!mapping.contains(TEXDIR_FIELD)) {
mapping.insert(TEXDIR_FIELD, ".");
}
if (!mapping.contains(SCRIPT_FIELD)) {
mapping.insert(SCRIPT_FIELD, ".");
}
// mixamo/autodesk defaults
if (!mapping.contains(SCALE_FIELD)) {
mapping.insert(SCALE_FIELD, 1.0);
}
QVariantHash joints = mapping.value(JOINT_FIELD).toHash();
if (!joints.contains("jointEyeLeft")) {
joints.insert("jointEyeLeft", hfmModel.jointIndices.contains("jointEyeLeft") ? "jointEyeLeft" :
(hfmModel.jointIndices.contains("EyeLeft") ? "EyeLeft" : "LeftEye"));
}
if (!joints.contains("jointEyeRight")) {
joints.insert("jointEyeRight", hfmModel.jointIndices.contains("jointEyeRight") ? "jointEyeRight" :
hfmModel.jointIndices.contains("EyeRight") ? "EyeRight" : "RightEye");
}
if (!joints.contains("jointNeck")) {
joints.insert("jointNeck", hfmModel.jointIndices.contains("jointNeck") ? "jointNeck" : "Neck");
}
if (!joints.contains("jointRoot")) {
joints.insert("jointRoot", "Hips");
}
if (!joints.contains("jointLean")) {
joints.insert("jointLean", "Spine");
}
if (!joints.contains("jointLeftHand")) {
joints.insert("jointLeftHand", "LeftHand");
}
if (!joints.contains("jointRightHand")) {
joints.insert("jointRightHand", "RightHand");
}
if (!joints.contains("jointHead")) {
const char* topName = likelyMixamoFile ? "HeadTop_End" : "HeadEnd";
joints.insert("jointHead", hfmModel.jointIndices.contains(topName) ? topName : "Head");
}
mapping.insert(JOINT_FIELD, joints);
if (!mapping.contains(FREE_JOINT_FIELD)) {
mapping.insertMulti(FREE_JOINT_FIELD, "LeftArm");
mapping.insertMulti(FREE_JOINT_FIELD, "LeftForeArm");
mapping.insertMulti(FREE_JOINT_FIELD, "RightArm");
mapping.insertMulti(FREE_JOINT_FIELD, "RightForeArm");
}
// If there are no blendshape mappings, and we detect that this is likely a mixamo file,
// then we can add the default mixamo to "faceshift" mappings
if (!mapping.contains(BLENDSHAPE_FIELD) && likelyMixamoFile) {
QVariantHash blendshapes;
blendshapes.insertMulti("BrowsD_L", QVariantList() << "BrowsDown_Left" << 1.0);
blendshapes.insertMulti("BrowsD_R", QVariantList() << "BrowsDown_Right" << 1.0);
blendshapes.insertMulti("BrowsU_C", QVariantList() << "BrowsUp_Left" << 1.0);
blendshapes.insertMulti("BrowsU_C", QVariantList() << "BrowsUp_Right" << 1.0);
blendshapes.insertMulti("BrowsU_L", QVariantList() << "BrowsUp_Left" << 1.0);
blendshapes.insertMulti("BrowsU_R", QVariantList() << "BrowsUp_Right" << 1.0);
blendshapes.insertMulti("ChinLowerRaise", QVariantList() << "Jaw_Up" << 1.0);
blendshapes.insertMulti("ChinUpperRaise", QVariantList() << "UpperLipUp_Left" << 0.5);
blendshapes.insertMulti("ChinUpperRaise", QVariantList() << "UpperLipUp_Right" << 0.5);
blendshapes.insertMulti("EyeBlink_L", QVariantList() << "Blink_Left" << 1.0);
blendshapes.insertMulti("EyeBlink_R", QVariantList() << "Blink_Right" << 1.0);
blendshapes.insertMulti("EyeOpen_L", QVariantList() << "EyesWide_Left" << 1.0);
blendshapes.insertMulti("EyeOpen_R", QVariantList() << "EyesWide_Right" << 1.0);
blendshapes.insertMulti("EyeSquint_L", QVariantList() << "Squint_Left" << 1.0);
blendshapes.insertMulti("EyeSquint_R", QVariantList() << "Squint_Right" << 1.0);
blendshapes.insertMulti("JawFwd", QVariantList() << "JawForeward" << 1.0);
blendshapes.insertMulti("JawLeft", QVariantList() << "JawRotateY_Left" << 0.5);
blendshapes.insertMulti("JawOpen", QVariantList() << "MouthOpen" << 0.7);
blendshapes.insertMulti("JawRight", QVariantList() << "Jaw_Right" << 1.0);
blendshapes.insertMulti("LipsFunnel", QVariantList() << "JawForeward" << 0.39);
blendshapes.insertMulti("LipsFunnel", QVariantList() << "Jaw_Down" << 0.36);
blendshapes.insertMulti("LipsFunnel", QVariantList() << "MouthNarrow_Left" << 1.0);
blendshapes.insertMulti("LipsFunnel", QVariantList() << "MouthNarrow_Right" << 1.0);
blendshapes.insertMulti("LipsFunnel", QVariantList() << "MouthWhistle_NarrowAdjust_Left" << 0.5);
blendshapes.insertMulti("LipsFunnel", QVariantList() << "MouthWhistle_NarrowAdjust_Right" << 0.5);
blendshapes.insertMulti("LipsFunnel", QVariantList() << "TongueUp" << 1.0);
blendshapes.insertMulti("LipsLowerClose", QVariantList() << "LowerLipIn" << 1.0);
blendshapes.insertMulti("LipsLowerDown", QVariantList() << "LowerLipDown_Left" << 0.7);
blendshapes.insertMulti("LipsLowerDown", QVariantList() << "LowerLipDown_Right" << 0.7);
blendshapes.insertMulti("LipsLowerOpen", QVariantList() << "LowerLipOut" << 1.0);
blendshapes.insertMulti("LipsPucker", QVariantList() << "MouthNarrow_Left" << 1.0);
blendshapes.insertMulti("LipsPucker", QVariantList() << "MouthNarrow_Right" << 1.0);
blendshapes.insertMulti("LipsUpperClose", QVariantList() << "UpperLipIn" << 1.0);
blendshapes.insertMulti("LipsUpperOpen", QVariantList() << "UpperLipOut" << 1.0);
blendshapes.insertMulti("LipsUpperUp", QVariantList() << "UpperLipUp_Left" << 0.7);
blendshapes.insertMulti("LipsUpperUp", QVariantList() << "UpperLipUp_Right" << 0.7);
blendshapes.insertMulti("MouthDimple_L", QVariantList() << "Smile_Left" << 0.25);
blendshapes.insertMulti("MouthDimple_R", QVariantList() << "Smile_Right" << 0.25);
blendshapes.insertMulti("MouthFrown_L", QVariantList() << "Frown_Left" << 1.0);
blendshapes.insertMulti("MouthFrown_R", QVariantList() << "Frown_Right" << 1.0);
blendshapes.insertMulti("MouthLeft", QVariantList() << "Midmouth_Left" << 1.0);
blendshapes.insertMulti("MouthRight", QVariantList() << "Midmouth_Right" << 1.0);
blendshapes.insertMulti("MouthSmile_L", QVariantList() << "Smile_Left" << 1.0);
blendshapes.insertMulti("MouthSmile_R", QVariantList() << "Smile_Right" << 1.0);
blendshapes.insertMulti("Puff", QVariantList() << "CheekPuff_Left" << 1.0);
blendshapes.insertMulti("Puff", QVariantList() << "CheekPuff_Right" << 1.0);
blendshapes.insertMulti("Sneer", QVariantList() << "NoseScrunch_Left" << 0.75);
blendshapes.insertMulti("Sneer", QVariantList() << "NoseScrunch_Right" << 0.75);
blendshapes.insertMulti("Sneer", QVariantList() << "Squint_Left" << 0.5);
blendshapes.insertMulti("Sneer", QVariantList() << "Squint_Right" << 0.5);
mapping.insert(BLENDSHAPE_FIELD, blendshapes);
}
}
void SessionEntryTunnel::IncomingData(const Request &request)
{
QVariantHash hash = request.GetData().toHash();
m_tunnel.IncomingData(hash.value("data").toByteArray());
}
