QWindowsOpenGLTester::Renderer QWindowsOpenGLTester::requestedGlesRenderer() { #ifndef Q_OS_WINCE const char platformVar[] = "QT_ANGLE_PLATFORM"; if (qEnvironmentVariableIsSet(platformVar)) { const QByteArray anglePlatform = qgetenv(platformVar); if (anglePlatform == "d3d11") return QWindowsOpenGLTester::AngleRendererD3d11; if (anglePlatform == "d3d9") return QWindowsOpenGLTester::AngleRendererD3d9; if (anglePlatform == "warp") return QWindowsOpenGLTester::AngleRendererD3d11Warp; qCWarning(lcQpaGl) << "Invalid value set for " << platformVar << ": " << anglePlatform; } #endif // !Q_OS_WINCE return QWindowsOpenGLTester::InvalidRenderer; }
void NPCStorage::prepare_dictionaries() { // client expects the indices of npcs to be taken from sorted by name array std::sort(std::begin(m_all_npcs),std::end(m_all_npcs),[](const Parse_NPC &a,const Parse_NPC &b)->bool { return a.m_Name.compare(b.m_Name,Qt::CaseInsensitive)<0; }); for(Parse_NPC &npc : m_all_npcs) { auto iter = m_name_to_npc_def.find(npc.m_Name.toLower()); if(iter!=m_name_to_npc_def.end()) { qCWarning(logNPCs) << "Duplicate NPC name" << npc.m_Name << "vs" << iter.value()->m_Name; continue; } m_name_to_npc_def[npc.m_Name.toLower()] = &npc; } }
quint32 Bundle::crcFile(enum Bundle::File file) const { quint32 ret = 0; switch (file) { case Bundle::BINARY: ret = b->manifest.value(type()).toObject().value("crc").toDouble(); break; case Bundle::RESOURCES: ret = b->manifest.value("resources").toObject().value("crc").toDouble(); break; default: qCWarning(l) << "Unsupported CRC for" << file; } return ret; }
const QVariant Konfiguration::WertHolen(const QString &name,const QVariant &standart) { if (K_Konfigpuffer.contains(name)) return K_Konfigpuffer[name]; else { if (K_Konfig->contains(name)) { qCDebug(qalarm_Konfiguration)<<tr("%1 nicht im Puffer, lade aus Datei bzw. Standart.").arg(name); K_Konfigpuffer.insert(name,K_Konfig->value(name,standart)); return K_Konfigpuffer[name]; } else qCWarning(qalarm_Konfiguration)<<tr("Wert %1 nicht gefunden.").arg(name); } return standart; }
void DevicesModel::refreshDeviceList() { if (!m_dbusInterface->isValid()) { clearDevices(); qCWarning(KDECONNECT_INTERFACES) << "dbus interface not valid"; return; } bool onlyPaired = (m_displayFilter & StatusPaired); bool onlyReachable = (m_displayFilter & StatusReachable); QDBusPendingReply<QStringList> pendingDeviceIds = m_dbusInterface->devices(onlyReachable, onlyPaired); QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingDeviceIds, this); QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), this, SLOT(receivedDeviceList(QDBusPendingCallWatcher*))); }
void QBluetoothSocketPrivate::connectToService(const QBluetoothAddress &address, const QBluetoothUuid &uuid, QIODevice::OpenMode openMode) { Q_Q(QBluetoothSocket); Q_UNUSED(openMode); qCDebug(QT_BT_QNX) << "Connecting socket"; m_peerAddress = address; #ifdef QT_QNX_BT_BLUETOOTH QByteArray b_uuid = uuid.toByteArray(); b_uuid = b_uuid.mid(1, b_uuid.length() - 2); socket = bt_spp_open(address.toString().toUtf8().data(), b_uuid.data(), false); if (socket == -1) { qCWarning(QT_BT_QNX) << "Could not connect to" << address.toString() << b_uuid << qt_error_string(errno); errorString = qt_error_string(errno); q->setSocketError(QBluetoothSocket::NetworkError); return; } delete readNotifier; delete connectWriteNotifier; readNotifier = new QSocketNotifier(socket, QSocketNotifier::Read); QObject::connect(readNotifier, SIGNAL(activated(int)), this, SLOT(_q_readNotify())); connectWriteNotifier = new QSocketNotifier(socket, QSocketNotifier::Write, q); QObject::connect(connectWriteNotifier, SIGNAL(activated(int)), this, SLOT(_q_writeNotify())); connecting = true; q->setOpenMode(openMode); #else m_uuid = uuid; if (isServerSocket) return; if (state != QBluetoothSocket::UnconnectedState) { qCDebug(QT_BT_QNX) << "Socket already connected"; return; } ppsSendControlMessage("connect_service", 0x1101, uuid, address.toString(), QString(), this, BT_SPP_CLIENT_SUBTYPE); ppsRegisterForEvent(QStringLiteral("service_connected"),this); ppsRegisterForEvent(QStringLiteral("get_mount_point_path"),this); #endif q->setSocketState(QBluetoothSocket::ConnectingState); }
QStringList AWDBusAdaptor::ActiveServices() const { QDBusMessage listServices = QDBusConnection::sessionBus().interface()->call( QDBus::BlockWithGui, "ListNames"); if (listServices.arguments().isEmpty()) { qCWarning(LOG_DBUS) << "Could not find any DBus service"; return {}; } QStringList arguments = listServices.arguments().first().toStringList(); return std::accumulate(arguments.cbegin(), arguments.cend(), QStringList(), [](QStringList &source, QString service) { if (service.startsWith(AWDBUS_SERVICE)) source.append(service); return source; }); }
void FramebufferBackend::map() { if (m_memory) { // already mapped; return; } if (m_fd < 0) { // not valid return; } void *mem = mmap(nullptr, m_bufferLength, PROT_WRITE, MAP_SHARED, m_fd, 0); if (mem == MAP_FAILED) { qCWarning(KWIN_FB) << "Failed to mmap frame buffer"; return; } m_memory = mem; }
chrono::milliseconds ConfigFile::remotePollInterval(const QString &connection) const { QString con(connection); if (connection.isEmpty()) con = defaultConnection(); QSettings settings(configFile(), QSettings::IniFormat); settings.beginGroup(con); auto defaultPollInterval = chrono::milliseconds(DEFAULT_REMOTE_POLL_INTERVAL); auto remoteInterval = millisecondsValue(settings, remotePollIntervalC, defaultPollInterval); if (remoteInterval < chrono::seconds(5)) { qCWarning(lcConfigFile) << "Remote Interval is less than 5 seconds, reverting to" << DEFAULT_REMOTE_POLL_INTERVAL; remoteInterval = defaultPollInterval; } return remoteInterval; }
/** * @fn convertOptionName */ QPair<QString, QString> QueuedPluginManager::convertOptionName(const QString &_key) { qCDebug(LOG_PL) << "Convert option name" << _key; QStringList fields = _key.split('.'); if (fields.count() < 3) { qCWarning(LOG_PL) << "Invalid option name" << _key; return {"", ""}; } // Plugin. fields.takeFirst(); // plugin name QString plugin = fields.takeFirst(); QString option = fields.join('.'); return {plugin, option}; }
void ppsRegisterControl() { count++; if (count == 1) { if (ppsCtrlFD != -1) { qCDebug(QT_BT_QNX) << "PPS control FD not properly deinitialized"; return; } ppsCtrlFD = qt_safe_open(btControlFDPath, O_RDWR | O_SYNC); if (ppsCtrlFD == -1) { qCWarning(QT_BT_QNX) << Q_FUNC_INFO << "ppsCtrlFD - failed to qt_safe_open" << btControlFDPath; } else { ppsCtrlNotifier = new QSocketNotifier(ppsCtrlFD, QSocketNotifier::Read); QObject::connect(ppsCtrlNotifier, SIGNAL(activated(int)), &bbSocketNotifier, SLOT(distribute())); } } }
/** * @fn tryGetUser */ QueuedUser *QueuedCorePrivateHelper::tryGetUser(const long long _id) { auto user = users()->user(_id); if (!user) { qCInfo(LOG_LIB) << "Try to get information about user" << _id << "from database"; auto data = database()->get(QueuedDB::USERS_TABLE, _id); if (data.isEmpty()) { qCWarning(LOG_LIB) << "Could not find user with ID" << _id; return nullptr; } auto defs = QueuedUserManager::parseDefinitions(data); user = new QueuedUser(this, defs, _id); } return user; }
/** Updates, creates or removes a blacklist entry for the given item. * * May adjust the status or item._errorString. */ static void blacklistUpdate(SyncJournalDb *journal, SyncFileItem &item) { SyncJournalErrorBlacklistRecord oldEntry = journal->errorBlacklistEntry(item._file); bool mayBlacklist = item._errorMayBeBlacklisted // explicitly flagged for blacklisting || ((item._status == SyncFileItem::NormalError || item._status == SyncFileItem::SoftError || item._status == SyncFileItem::DetailError) && item._httpErrorCode != 0 // or non-local error ); // No new entry? Possibly remove the old one, then done. if (!mayBlacklist) { if (oldEntry.isValid()) { journal->wipeErrorBlacklistEntry(item._file); } return; } auto newEntry = createBlacklistEntry(oldEntry, item); journal->setErrorBlacklistEntry(newEntry); // Suppress the error if it was and continues to be blacklisted. // An ignoreDuration of 0 mean we're tracking the error, but not actively // suppressing it. if (item._hasBlacklistEntry && newEntry._ignoreDuration > 0) { item._status = SyncFileItem::BlacklistedError; qCInfo(lcPropagator) << "blacklisting " << item._file << " for " << newEntry._ignoreDuration << ", retry count " << newEntry._retryCount; return; } // Some soft errors might become louder on repeat occurrence if (item._status == SyncFileItem::SoftError && newEntry._retryCount > 1) { qCWarning(lcPropagator) << "escalating soft error on " << item._file << " to normal error, " << item._httpErrorCode; item._status = SyncFileItem::NormalError; return; } }
quint64 ConfigFile::forceSyncInterval(const QString &connection) const { uint pollInterval = remotePollInterval(connection); QString con(connection); if (connection.isEmpty()) con = defaultConnection(); QSettings settings(configFile(), QSettings::IniFormat); settings.beginGroup(con); quint64 defaultInterval = 2 * 60 * 60 * 1000ull; // 2h quint64 interval = settings.value(QLatin1String(forceSyncIntervalC), defaultInterval).toULongLong(); if (interval < pollInterval) { qCWarning(lcConfigFile) << "Force sync interval is less than the remote poll inteval, reverting to" << pollInterval; interval = pollInterval; } return interval; }
QString ExtScript::applyFilters(QString _value) const { qCDebug(LOG_LIB) << "Value" << _value; for (auto filt : m_filters) { qCInfo(LOG_LIB) << "Found filter" << filt; QVariantMap filter = jsonFilters[filt].toMap(); if (filter.isEmpty()) { qCWarning(LOG_LIB) << "Could not find filter" << _value << "in the json"; continue; } for (auto f : filter.keys()) _value.replace(f, filter[f].toString()); } return _value; }
uint TypeRepository::indexForType(const AbstractType::Ptr input) { if(!input) return 0; uint i = typeRepository()->index(AbstractTypeDataRequest(*input)); #ifdef DEBUG_TYPE_REPOSITORY AbstractType::Ptr t = typeForIndex(i); if(!t->equals(input.data())) { qCWarning(LANGUAGE) << "found type in repository does not equal source type:" << input->toString() << t->toString(); t->equals(input.data()); } #ifdef ASSERT_ON_PROBLEM Q_ASSERT(t->equals(input.data())); Q_ASSERT(input->equals(t.data())); #endif #endif return i; }
void XWaylandManager::handleSurfaceId(XWaylandShellSurface *window, xcb_client_message_event_t *event) { if (window->surface()) { qCWarning(XWAYLAND_TRACE) << "Window" << window->window() << "already has a surface id"; return; } quint32 id = event->data.data32[0]; window->setSurfaceId(id); wl_resource *resource = wl_client_get_object(m_server->client(), id); if (resource) { window->setSurface(QWaylandSurface::fromResource(resource)); } else { window->setSurface(Q_NULLPTR); m_unpairedWindows.append(window); } }
chrono::milliseconds ConfigFile::updateCheckInterval(const QString &connection) const { QString con(connection); if (connection.isEmpty()) con = defaultConnection(); QSettings settings(configFile(), QSettings::IniFormat); settings.beginGroup(con); auto defaultInterval = chrono::hours(10); auto interval = millisecondsValue(settings, updateCheckIntervalC, defaultInterval); auto minInterval = chrono::minutes(5); if (interval < minInterval) { qCWarning(lcConfigFile) << "Update check interval less than five minutes, resetting to 5 minutes"; interval = minInterval; } return interval; }
static QByteArray read_data( archive* a ){ QByteArray raw; //Read chuncks const char *buff; size_t size; int64_t offset; while( true ){ switch( archive_read_data_block( a, (const void**)&buff, &size, &offset ) ){ case ARCHIVE_OK: raw += QByteArray( buff, size ); break; case ARCHIVE_EOF: return raw; default: qCWarning(LOG) << "Error while reading zip data:" << archive_error_string(a); return raw; } } }
LayoutSet X11Helper::getCurrentLayouts() { LayoutSet layoutSet; QList<LayoutUnit> currentLayouts = getLayoutsList(); layoutSet.layouts = currentLayouts; unsigned int group = X11Helper::getGroup(); if( group < (unsigned int)currentLayouts.size() ) { layoutSet.currentLayout = currentLayouts[group]; } else { qCWarning(KCM_KEYBOARD) << "Current group number" << group << "is outside of current layout list" << getLayoutsListAsString(currentLayouts); layoutSet.currentLayout = LayoutUnit(); } return layoutSet; }
void MoveJob::start() { QNetworkRequest req; req.setRawHeader("Destination", QUrl::toPercentEncoding(_destination, "/")); for (auto it = _extraHeaders.constBegin(); it != _extraHeaders.constEnd(); ++it) { req.setRawHeader(it.key(), it.value()); } if (_url.isValid()) { sendRequest("MOVE", _url, req); } else { sendRequest("MOVE", makeDavUrl(path()), req); } if (reply()->error() != QNetworkReply::NoError) { qCWarning(lcPropagateRemoteMove) << " Network error: " << reply()->errorString(); } AbstractNetworkJob::start(); }
chrono::milliseconds ConfigFile::forceSyncInterval(const QString &connection) const { auto pollInterval = remotePollInterval(connection); QString con(connection); if (connection.isEmpty()) con = defaultConnection(); QSettings settings(configFile(), QSettings::IniFormat); settings.beginGroup(con); auto defaultInterval = chrono::hours(2); auto interval = millisecondsValue(settings, forceSyncIntervalC, defaultInterval); if (interval < pollInterval) { qCWarning(lcConfigFile) << "Force sync interval is less than the remote poll inteval, reverting to" << pollInterval.count(); interval = pollInterval; } return interval; }
bool SqlDatabase::openReadOnly(const QString &filename) { if (isOpen()) { return true; } if (!openHelper(filename, SQLITE_OPEN_READONLY)) { return false; } if (checkDb() != CheckDbResult::Ok) { qCWarning(lcSql) << "Consistency check failed in readonly mode, giving up" << filename; close(); return false; } return true; }
int ConfigFile::updateCheckInterval(const QString &connection) const { QString con(connection); if (connection.isEmpty()) con = defaultConnection(); QSettings settings(configFile(), QSettings::IniFormat); settings.beginGroup(con); int defaultInterval = 1000 * 60 * 60 * 10; // ten hours int interval = settings.value(QLatin1String(updateCheckIntervalC), defaultInterval).toInt(); int minInterval = 1000 * 60 * 5; if (interval < minInterval) { qCWarning(lcConfigFile) << "Update check interval less than five minutes, setting " << minInterval; interval = minInterval; } return interval; }
QString TvDevice::printXmlData(const QByteArray &data) { QString xmlOut; QXmlStreamReader reader(data); QXmlStreamWriter writer(&xmlOut); writer.setAutoFormatting(true); while (!reader.atEnd()) { reader.readNext(); if(!reader.isWhitespace()) { writer.writeCurrentToken(reader); } } if(reader.hasError()) { qCWarning(dcLgSmartTv) << "error reading XML device information:" << reader.errorString(); } return xmlOut; }
bool DrmPlane::isCrtcSupported(uint32_t crtc) { ScopedDrmPointer<_drmModeRes, &drmModeFreeResources> res(drmModeGetResources(m_fd)); if (!res) { qCWarning(KWIN_DRM) << "Failed to get drm resources"; } for (int c = 0; c < res->count_crtcs; c++) { if (res->crtcs[c] != crtc) { continue; } qCDebug(KWIN_DRM) << "Mask " << m_possibleCrtcs << ", idx " << c; if (m_possibleCrtcs & (1 << c)) { return true; } } qCDebug(KWIN_DRM) << "CRTC" << crtc << "not supported"; return false; }
bool ConsolePlan::addPlane(float angle, QList<Plane2DCoordinate> coordinates) { QString str; if (m_planeSpots.contains(angle)) { // overwrite the existed plane m_planeSpots.insert(angle,coordinates); str = printLastAction(AddPlane) + printLastError(ErrorOverwriteExistingPlane); qCWarning(PlanGenerator()) << PlanGenerator().categoryName() << str; return false; }else { m_planeSpots.insert(angle,coordinates); str = printLastAction(AddPlane) + printLastError(NoError); qCDebug(PlanGenerator()) << PlanGenerator().categoryName() << str; return true; } }
void KFileItem::refresh() { if (!d) { qCWarning(KIO_CORE) << "null item"; return; } d->m_fileMode = KFileItem::Unknown; d->m_permissions = KFileItem::Unknown; d->m_hidden = KFileItemPrivate::Auto; refreshMimeType(); // Basically, we can't trust any information we got while listing. // Everything could have changed... // Clearing m_entry makes it possible to detect changes in the size of the file, // the time information, etc. d->m_entry.clear(); d->init(); // re-populates d->m_entry }
bool QBluetoothServer::listen(const QBluetoothAddress &address, quint16 port) { Q_UNUSED(address) Q_D(QBluetoothServer); if (serverType() != QBluetoothServiceInfo::RfcommProtocol) { d->m_lastError = UnsupportedProtocolError; emit error(d->m_lastError); return false; } // listen has already been called before if (d->socket && d->socket->state() == QBluetoothSocket::ListeningState) return true; d->socket = new QBluetoothSocket(QBluetoothServiceInfo::RfcommProtocol); //We can not register an actual Rfcomm port, because the platform does not allow it //but we need a way to associate a server with a service if (port == 0) { //Try to assign a non taken port id for (int i=1; ; i++){ if (__fakeServerPorts.key(i) == 0) { port = i; break; } } } if (__fakeServerPorts.key(port) == 0) { __fakeServerPorts[d] = port; qCDebug(QT_BT_QNX) << "Port" << port << "registered"; } else { qCWarning(QT_BT_QNX) << "server with port" << port << "already registered or port invalid"; d->m_lastError = ServiceAlreadyRegisteredError; emit error(d->m_lastError); return false; } d->socket->setSocketState(QBluetoothSocket::ListeningState); ppsRegisterForEvent(QStringLiteral("service_connected"),d); return true; }
void NotificationsModel::refreshNotificationList() { if (!m_dbusInterface) { return; } clearNotifications(); if (!m_dbusInterface->isValid()) { qCWarning(KDECONNECT_INTERFACES) << "dbus interface not valid"; return; } QDBusPendingReply<QStringList> pendingNotificationIds = m_dbusInterface->activeNotifications(); QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(pendingNotificationIds, this); QObject::connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), this, SLOT(receivedNotifications(QDBusPendingCallWatcher*))); }