void tst_QGetPutEnv::getSetCheck() { const char varName[] = "should_not_exist"; QVERIFY(!qEnvironmentVariableIsSet(varName)); QVERIFY(qEnvironmentVariableIsEmpty(varName)); QByteArray result = qgetenv(varName); QCOMPARE(result, QByteArray()); #ifndef Q_OS_WIN QVERIFY(qputenv(varName, "")); // deletes varName instead of making it empty, on Windows QVERIFY(qEnvironmentVariableIsSet(varName)); QVERIFY(qEnvironmentVariableIsEmpty(varName)); #endif QVERIFY(qputenv(varName, QByteArray("supervalue"))); QVERIFY(qEnvironmentVariableIsSet(varName)); QVERIFY(!qEnvironmentVariableIsEmpty(varName)); result = qgetenv(varName); QVERIFY(result == "supervalue"); qputenv(varName,QByteArray()); // Now test qunsetenv QVERIFY(qunsetenv(varName)); QVERIFY(!qEnvironmentVariableIsSet(varName)); QVERIFY(qEnvironmentVariableIsEmpty(varName)); result = qgetenv(varName); QCOMPARE(result, QByteArray()); }
void QXcbConnection::initializeXInput2() { // TODO Qt 6 (or perhaps earlier): remove these redundant env variables if (qEnvironmentVariableIsSet("KIS_QT_XCB_DEBUG_XINPUT")) const_cast<QLoggingCategory&>(lcQpaXInput()).setEnabled(QtDebugMsg, true); if (qEnvironmentVariableIsSet("KIS_QT_XCB_DEBUG_XINPUT_DEVICES")) const_cast<QLoggingCategory&>(lcQpaXInputDevices()).setEnabled(QtDebugMsg, true); Display *xDisplay = static_cast<Display *>(m_xlib_display); if (XQueryExtension(xDisplay, "XInputExtension", &m_xiOpCode, &m_xiEventBase, &m_xiErrorBase)) { int xiMajor = 2; m_xi2Minor = 2; // try 2.2 first, needed for TouchBegin/Update/End if (XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) == BadRequest) { m_xi2Minor = 1; // for smooth scrolling 2.1 is enough if (XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) == BadRequest) { m_xi2Minor = 0; // for tablet support 2.0 is enough m_xi2Enabled = XIQueryVersion(xDisplay, &xiMajor, &m_xi2Minor) != BadRequest; } else m_xi2Enabled = true; } else m_xi2Enabled = true; if (m_xi2Enabled) { #ifdef XCB_USE_XINPUT22 qCDebug(lcQpaXInputDevices, "XInput version %d.%d is available and Qt supports 2.2 or greater", xiMajor, m_xi2Minor); #else qCDebug(lcQpaXInputDevices, "XInput version %d.%d is available and Qt supports 2.0", xiMajor, m_xi2Minor); #endif } xi2SetupDevices(); } }
/** * Program entry point. * * @param argc amount of command line arguments * @param argv command line arguments * @return @c 0 on successful exit */ int main(int argc, char** argv) { #if !defined(Q_OS_MAC) if (!qEnvironmentVariableIsSet("QT_DEVICE_PIXEL_RATIO") && !qEnvironmentVariableIsSet("QT_AUTO_SCREEN_SCALE_FACTOR") && !qEnvironmentVariableIsSet("QT_SCALE_FACTOR") && !qEnvironmentVariableIsSet("QT_SCREEN_SCALE_FACTORS")) { QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling); } #endif QApplication app(argc, argv); app.setApplicationName("Simsu"); app.setApplicationVersion(VERSIONSTR); app.setApplicationDisplayName(Window::tr("Simsu")); app.setOrganizationDomain("gottcode.org"); app.setOrganizationName("GottCode"); #if !defined(Q_OS_WIN) && !defined(Q_OS_MAC) app.setWindowIcon(QIcon::fromTheme("simsu", QIcon(":/simsu.png"))); app.setDesktopFileName("simsu"); #endif app.setAttribute(Qt::AA_UseHighDpiPixmaps, true); LocaleDialog::loadTranslator("simsu_"); Window window; window.show(); return app.exec(); }
QPCSC::QPCSC() : d( new QPCSCPrivate ) { const_cast<QLoggingCategory&>(SCard()).setEnabled(QtDebugMsg, qEnvironmentVariableIsSet("PCSC_DEBUG")); const_cast<QLoggingCategory&>(APDU()).setEnabled(QtDebugMsg, qEnvironmentVariableIsSet("APDU_DEBUG")); serviceRunning(); }
void CompositorLauncher::detectMode() { // Can't detect mode when it was forced by arguments if (m_mode != UnknownMode) return; // Detect Wayland if (qEnvironmentVariableIsSet("WAYLAND_DISPLAY")) { m_mode = WaylandMode; return; } // Detect X11 if (qEnvironmentVariableIsSet("DISPLAY")) { m_mode = X11Mode; return; } // Detect eglfs since Qt 5.5 if (qEnvironmentVariableIsSet("QT_QPA_EGLFS_INTEGRATION") || m_hardware != UnknownHardware) { m_mode = EglFSMode; return; } // Default to unknown mode m_mode = UnknownMode; }
static const char *setHighDpiEnvironmentVariable() { const char *envVarName = 0; static const char ENV_VAR_QT_DEVICE_PIXEL_RATIO[] = "QT_DEVICE_PIXEL_RATIO"; #ifdef Q_OS_WIN bool isWindows = true; #else bool isWindows = false; #endif #if (QT_VERSION < QT_VERSION_CHECK(5, 6, 0)) if (isWindows && !qEnvironmentVariableIsSet(ENV_VAR_QT_DEVICE_PIXEL_RATIO)) { envVarName = ENV_VAR_QT_DEVICE_PIXEL_RATIO; qputenv(envVarName, "auto"); } #else if (isWindows && !qEnvironmentVariableIsSet(ENV_VAR_QT_DEVICE_PIXEL_RATIO) // legacy in 5.6, but still functional && !qEnvironmentVariableIsSet("QT_AUTO_SCREEN_SCALE_FACTOR") && !qEnvironmentVariableIsSet("QT_SCALE_FACTOR") && !qEnvironmentVariableIsSet("QT_SCREEN_SCALE_FACTORS")) { QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling); } #endif // < Qt 5.6 return envVarName; }
bool MainWindow::mobileMode() const { #ifdef Q_OS_ANDROID static bool mobile_mode = qEnvironmentVariableIsSet("MAPPER_MOBILE_GUI") ? (qgetenv("MAPPER_MOBILE_GUI") != "0") : 1; #else static bool mobile_mode = qEnvironmentVariableIsSet("MAPPER_MOBILE_GUI") ? (qgetenv("MAPPER_MOBILE_GUI") != "0") : 0; #endif return mobile_mode; }
/*! Creates and returns a source with the specified \a parent that reads from the system's default source of satellite update information, or the highest priority available plugin. Returns 0 if the system has no default satellite source, no valid plugins could be found or the user does not have the permission to access the satellite data. */ QGeoSatelliteInfoSource *QGeoSatelliteInfoSource::createDefaultSource(QObject *parent) { QList<QJsonObject> plugins = QGeoPositionInfoSourcePrivate::pluginsSorted(); foreach (const QJsonObject &obj, plugins) { if (obj.value(QStringLiteral("Satellite")).isBool() && obj.value(QStringLiteral("Satellite")).toBool()) { const QString testableKey = QStringLiteral("Testable"); if (obj.contains(testableKey) && !obj.value(testableKey).toBool()) { static bool inTest = qEnvironmentVariableIsSet("QT_QTESTLIB_RUNNING"); if (inTest) continue; } QGeoPositionInfoSourcePrivate d; d.metaData = obj; d.loadPlugin(); QGeoSatelliteInfoSource *s = 0; if (d.factory) s = d.factory->satelliteInfoSource(parent); if (s) s->d->providerName = d.metaData.value(QStringLiteral("Provider")).toString(); return s; } } return 0; }
void KCrash::initialize() { if (s_launchDrKonqi == 0) { // disabled by the program itself return; } const QStringList args = QCoreApplication::arguments(); if (!qEnvironmentVariableIsSet("KDE_DEBUG") && !qEnvironmentVariableIsSet("KCRASH_AUTO_RESTARTED")) { // enable drkonqi KCrash::setDrKonqiEnabled(true); } KCrash::setApplicationFilePath(QCoreApplication::applicationFilePath()); s_coreConfig(); // Initialize. }
OpenFileResult showOpenFile() const { QUrl dir; if ( controller->activeDocument() ) { dir = controller->activeDocument()->url().adjusted(QUrl::RemoveFilename); } else { const auto cfg = KSharedConfig::openConfig()->group("Open File"); dir = cfg.readEntry( "Last Open File Directory", Core::self()->projectController()->projectsBaseDirectory() ); } const auto caption = i18n("Open File"); const auto filter = i18n("*|Text File\n"); auto parent = Core::self()->uiControllerInternal()->defaultMainWindow(); // use special dialogs in a KDE session, native dialogs elsewhere if (qEnvironmentVariableIsSet("KDE_FULL_SESSION")) { const auto result = KEncodingFileDialog::getOpenUrlsAndEncoding(QString(), dir, filter, parent, caption); return {result.URLs, result.encoding}; } // note: can't just filter on text files using the native dialog, just display all files // see https://phabricator.kde.org/D622#11679 const auto urls = QFileDialog::getOpenFileUrls(parent, caption, dir); return {urls, QString()}; }
FileInfo RemoteFileInfoGatherer::getInfo(const QString &path) { QFileInfo finfo(path); FileInfo info = toFileInfo(finfo); #if 0 info.icon = m_iconProvider->icon(path); info.displayType = m_iconProvider->type(path); #endif #ifndef QT_NO_FILESYSTEMWATCHER // ### Not ready to listen all modifications by default static const bool watchFiles = qEnvironmentVariableIsSet("QT_FILESYSTEMMODEL_WATCH_FILES"); if (watchFiles) { if (!finfo.exists() && !finfo.isSymLink()) { watcher->removePath(finfo.absoluteFilePath()); } else { const QString path = finfo.absoluteFilePath(); if (!path.isEmpty() && finfo.exists() && finfo.isFile() && finfo.isReadable() && !watcher->files().contains(path)) { watcher->addPath(path); } } } #endif #ifdef Q_OS_WIN if (m_resolveSymlinks && info.isSymLink(/* ignoreNtfsSymLinks = */ true)) { QFileInfo resolvedInfo(finfo.symLinkTarget()); resolvedInfo = resolvedInfo.canonicalFilePath(); if (resolvedInfo.exists()) { emit nameResolved(finfo.filePath(), resolvedInfo.fileName()); } } #endif return info; }
// We have the a11y registry on the session bus. // Subscribe to updates about a11y enabled state. // Find out the bus address void DBusConnection::serviceRegistered() { // listen to enabled changes QDBusConnection c = QDBusConnection::sessionBus(); OrgA11yStatusInterface *a11yStatus = new OrgA11yStatusInterface(A11Y_SERVICE, A11Y_PATH, c, this); //The variable was introduced because on some embedded platforms there are custom accessibility //clients which don't set Status.ScreenReaderEnabled to true. The variable is also useful for //debugging. static const bool a11yAlwaysOn = qEnvironmentVariableIsSet("QT_LINUX_ACCESSIBILITY_ALWAYS_ON"); // a11yStatus->isEnabled() returns always true (since Gnome 3.6) bool enabled = a11yAlwaysOn || a11yStatus->screenReaderEnabled(); if (enabled != m_enabled) { m_enabled = enabled; if (m_a11yConnection.isConnected()) { emit enabledChanged(m_enabled); } else { QDBusConnection c = QDBusConnection::sessionBus(); QDBusMessage m = QDBusMessage::createMethodCall(QLatin1String("org.a11y.Bus"), QLatin1String("/org/a11y/bus"), QLatin1String("org.a11y.Bus"), QLatin1String("GetAddress")); c.callWithCallback(m, this, SLOT(connectA11yBus(QString)), SLOT(dbusError(QDBusError))); } } // connect(a11yStatus, ); QtDbus doesn't support notifications for property changes yet }
void QWaylandIntegration::initializeServerBufferIntegration() { mServerBufferIntegrationInitialized = true; QString targetKey; bool disableHardwareIntegration = qEnvironmentVariableIsSet("QT_WAYLAND_DISABLE_HW_INTEGRATION"); disableHardwareIntegration = disableHardwareIntegration || !mDisplay->hardwareIntegration(); if (disableHardwareIntegration) { QByteArray serverBufferIntegrationName = qgetenv("QT_WAYLAND_SERVER_BUFFER_INTEGRATION"); QString targetKey = QString::fromLocal8Bit(serverBufferIntegrationName); } else { targetKey = mDisplay->hardwareIntegration()->serverBufferIntegration(); } if (targetKey.isEmpty()) { qWarning("Failed to determine what server buffer integration to use"); return; } QStringList keys = QWaylandServerBufferIntegrationFactory::keys(); if (keys.contains(targetKey)) { mServerBufferIntegration = QWaylandServerBufferIntegrationFactory::create(targetKey, QStringList()); } if (mServerBufferIntegration) mServerBufferIntegration->initialize(mDisplay); else qWarning("Failed to load server buffer integration %s\n", qPrintable(targetKey)); }
QString TableGenerator::findComposeFile() { // check if XCOMPOSEFILE points to a Compose file if (qEnvironmentVariableIsSet("XCOMPOSEFILE")) { const QString path = QFile::decodeName(qgetenv("XCOMPOSEFILE")); if (QFile::exists(path)) return path; else qWarning("$XCOMPOSEFILE doesn't point to an existing file"); } // check if user’s home directory has a file named .XCompose if (cleanState()) { QString path = qgetenv("HOME") + QLatin1String("/.XCompose"); if (QFile::exists(path)) return path; } // check for the system provided compose files if (cleanState()) { QString table = composeTableForLocale(); if (cleanState()) { if (table.isEmpty()) // no table mappings for the system's locale in the compose.dir m_state = UnsupportedLocale; else { QString path = QDir(systemComposeDir()).filePath(table); if (QFile::exists(path)) return path; } } } return QString(); }
void QWaylandIntegration::initializeClientBufferIntegration() { mClientBufferIntegrationInitialized = true; QString targetKey; bool disableHardwareIntegration = qEnvironmentVariableIsSet("QT_WAYLAND_DISABLE_HW_INTEGRATION"); disableHardwareIntegration = disableHardwareIntegration || !mDisplay->hardwareIntegration(); if (disableHardwareIntegration) { QByteArray clientBufferIntegrationName = qgetenv("QT_WAYLAND_CLIENT_BUFFER_INTEGRATION"); if (clientBufferIntegrationName.isEmpty()) clientBufferIntegrationName = QByteArrayLiteral("wayland-egl"); targetKey = QString::fromLocal8Bit(clientBufferIntegrationName); } else { targetKey = mDisplay->hardwareIntegration()->clientBufferIntegration(); } if (targetKey.isEmpty()) { qWarning("Failed to determine what client buffer integration to use"); return; } QStringList keys = QWaylandClientBufferIntegrationFactory::keys(); if (keys.contains(targetKey)) { mClientBufferIntegration = QWaylandClientBufferIntegrationFactory::create(targetKey, QStringList()); } if (mClientBufferIntegration) mClientBufferIntegration->initialize(mDisplay); else qWarning("Failed to load client buffer integration: %s\n", qPrintable(targetKey)); }
QByteArray QXcbIntegration::wmClass() const { if (m_wmClass.isEmpty()) { // Instance name according to ICCCM 4.1.2.5 QString name; if (m_instanceName) name = QString::fromLocal8Bit(m_instanceName); if (name.isEmpty() && qEnvironmentVariableIsSet(resourceNameVar)) name = QString::fromLocal8Bit(qgetenv(resourceNameVar)); if (name.isEmpty()) name = argv0BaseName(); // Note: QCoreApplication::applicationName() cannot be called from the QGuiApplication constructor, // hence this delayed initialization. QString className = QCoreApplication::applicationName(); if (className.isEmpty()) { className = argv0BaseName(); if (!className.isEmpty() && className.at(0).isLower()) className[0] = className.at(0).toUpper(); } if (!name.isEmpty() && !className.isEmpty()) { m_wmClass = name.toLocal8Bit(); m_wmClass.append('\0'); m_wmClass.append(className.toLocal8Bit()); m_wmClass.append('\0'); } } return m_wmClass; }
QWindowsOpenGLTester::Renderer QWindowsOpenGLTester::requestedRenderer() { #ifndef Q_OS_WINCE const char openGlVar[] = "QT_OPENGL"; if (QCoreApplication::testAttribute(Qt::AA_UseOpenGLES)) { const Renderer glesRenderer = QWindowsOpenGLTester::requestedGlesRenderer(); return glesRenderer != InvalidRenderer ? glesRenderer : Gles; } if (QCoreApplication::testAttribute(Qt::AA_UseDesktopOpenGL)) return QWindowsOpenGLTester::DesktopGl; if (QCoreApplication::testAttribute(Qt::AA_UseSoftwareOpenGL)) return QWindowsOpenGLTester::SoftwareRasterizer; if (qEnvironmentVariableIsSet(openGlVar)) { const QByteArray requested = qgetenv(openGlVar); if (requested == "angle") { const Renderer glesRenderer = QWindowsOpenGLTester::requestedGlesRenderer(); return glesRenderer != InvalidRenderer ? glesRenderer : Gles; } if (requested == "desktop") return QWindowsOpenGLTester::DesktopGl; if (requested == "software") return QWindowsOpenGLTester::SoftwareRasterizer; qCWarning(lcQpaGl) << "Invalid value set for " << openGlVar << ": " << requested; } #endif // !Q_OS_WINCE return QWindowsOpenGLTester::InvalidRenderer; }
bool uwsgiProcess::run(const QString &appFilename, int port, bool restart) { QDir projectDir; if (!uwsgiProcess::findProjectDir(QDir::current(), &projectDir)) { qDebug() << "Error: failed to find project"; return false; } QString localFilename = appFilename; if (localFilename.isEmpty()) { localFilename = findApplication(projectDir); } QFileInfo fileInfo(localFilename); if (!fileInfo.exists()) { qDebug() << "Error: Application file not found"; return false; } QStringList args; args.append(QStringLiteral("--http-socket")); args.append(QLatin1String(":") % QString::number(port)); args.append(QStringLiteral("--chdir")); args.append(projectDir.absolutePath()); args.append(QStringLiteral("-M")); args.append(QStringLiteral("--plugin")); args.append(QStringLiteral("cutelyst")); args.append(QStringLiteral("--cutelyst-app")); args.append(localFilename); if (restart) { args.append(QStringLiteral("--lazy")); args.append(QStringLiteral("--touch-reload")); args.append(localFilename); } #ifdef Q_OS_UNIX if (setup_unix_signal_handlers()) { return false; } #endif qDebug() << "Running: uwsgi" << args.join(QStringLiteral(" ")).toLatin1().data(); // Enable loggin if restart is set if (restart && !qEnvironmentVariableIsSet("QT_LOGGING_RULES")) { QProcessEnvironment env = QProcessEnvironment::systemEnvironment(); env.insert(QStringLiteral("QT_LOGGING_RULES"), QStringLiteral("cutelyst.*=true")); m_proc->setProcessEnvironment(env); } m_proc->start(QStringLiteral("uwsgi"), args); return true; }
static QString resolveHandler(const QString &scheme) { QString candidatePath = QStringLiteral(CMAKE_INSTALL_FULL_LIBEXECDIR_KF5 "/kpackagehandlers/%1handler").arg(scheme); if (qEnvironmentVariableIsSet("KPACKAGE_DEP_RESOLVERS_PATH")) { candidatePath = QStringLiteral("%1/%2handler").arg(qgetenv("KPACKAGE_DEP_RESOLVERS_PATH"), scheme); } return QFile::exists(candidatePath) ? candidatePath : QString(); }
Widget::Widget(QWidget *parent) : QWidget(parent) { QVBoxLayout *layout = new QVBoxLayout; QSplitter *vsplit = new QSplitter(Qt::Vertical); layout->addWidget(vsplit); QSplitter *hsplit = new QSplitter; QVBoxLayout *settingsLayout = new QVBoxLayout; addVersions(settingsLayout); addProfiles(settingsLayout); addOptions(settingsLayout); addRenderableTypes(settingsLayout); hsplit->addWidget(widgetWithLayout(settingsLayout)); QVBoxLayout *outputLayout = new QVBoxLayout; m_output = new QTextEdit; m_output->setReadOnly(true); outputLayout->addWidget(m_output); m_extensions = new QTextEdit; m_extensions->setReadOnly(true); outputLayout->addWidget(m_extensions); hsplit->addWidget(widgetWithLayout(outputLayout)); hsplit->setStretchFactor(0, 4); hsplit->setStretchFactor(1, 6); vsplit->addWidget(hsplit); m_renderWindowLayout = new QVBoxLayout; vsplit->addWidget(widgetWithLayout(m_renderWindowLayout)); vsplit->setStretchFactor(1, 5); m_renderWindowContainer = new QWidget; addRenderWindow(); QString description; QTextStream str(&description); str << "Qt " << QT_VERSION_STR << ' ' << QGuiApplication::platformName(); const char *openGlVariables[] = {"QT_ANGLE_PLATFORM", "QT_OPENGL", "QT_OPENGL_BUGLIST", "QT_OPENGL_DLL"}; const size_t variableCount = sizeof(openGlVariables) / sizeof(openGlVariables[0]); for (size_t v = 0; v < variableCount; ++v) { if (qEnvironmentVariableIsSet(openGlVariables[v])) str << ' ' << openGlVariables[v] << '=' << qgetenv(openGlVariables[v]); } if (QCoreApplication::testAttribute(Qt::AA_UseOpenGLES)) str << " Qt::AA_UseOpenGLES"; if (QCoreApplication::testAttribute(Qt::AA_UseSoftwareOpenGL)) str << " Qt::AA_UseSoftwareOpenGL"; if (QCoreApplication::testAttribute(Qt::AA_UseDesktopOpenGL)) str << " Qt::AA_UseSoftwareOpenGL"; layout->addWidget(new QLabel(description)); setLayout(layout); }
QT_BEGIN_NAMESPACE static float qt_sg_envFloat(const char *name, float defaultValue) { if (Q_LIKELY(!qEnvironmentVariableIsSet(name))) return defaultValue; bool ok = false; const float value = qgetenv(name).toFloat(&ok); return ok ? value : defaultValue; }
bool QPCSCReader::isPinPad() const { if(d->reader.contains("HID Global OMNIKEY 3x21 Smart Card Reader") || d->reader.contains("HID Global OMNIKEY 6121 Smart Card Reader")) return false; if(qEnvironmentVariableIsSet("SMARTCARDPP_NOPINPAD")) return false; QHash<DRIVER_FEATURES,quint32> features = d->features(); return features.contains(FEATURE_VERIFY_PIN_DIRECT) || features.contains(FEATURE_VERIFY_PIN_START); }
void qdbus_unloadLibDBus() { if (qdbus_libdbus) { if (qEnvironmentVariableIsSet("QDBUS_FORCE_SHUTDOWN")) qdbus_libdbus->resolve("dbus_shutdown")(); qdbus_libdbus->unload(); } delete qdbus_libdbus; qdbus_libdbus = 0; }
QMinimal_i2cIntegration::QMinimal_i2cIntegration(const QStringList &) : m_fontDb(new QGenericUnixFontDatabase()) { if (qEnvironmentVariableIsSet(debugBackingStoreEnvironmentVariable) && qgetenv(debugBackingStoreEnvironmentVariable).toInt() > 0) { m_options |= DebugBackingStore; } mPrimaryScreen = new QMinimal_i2cScreen(); screenAdded(mPrimaryScreen); }
bool QQuickControlSettings::isMobile() const { #if defined(Q_OS_IOS) || defined(Q_OS_ANDROID) || defined(Q_OS_BLACKBERRY) || defined(Q_OS_QNX) || defined(Q_OS_WINRT) return true; #else if (qEnvironmentVariableIsSet("QT_QUICK_CONTROLS_MOBILE")) { return true; } return false; #endif }
void QSGContext::renderContextInitialized(QSGRenderContext *renderContext) { Q_D(QSGContext); d->mutex.lock(); if (d->antialiasingMethod == UndecidedAntialiasing) { if (Q_UNLIKELY(qEnvironmentVariableIsSet("QSG_ANTIALIASING_METHOD"))) { const QByteArray aaType = qgetenv("QSG_ANTIALIASING_METHOD"); if (aaType == "msaa") d->antialiasingMethod = MsaaAntialiasing; else if (aaType == "vertex") d->antialiasingMethod = VertexAntialiasing; } if (d->antialiasingMethod == UndecidedAntialiasing) { if (renderContext->openglContext()->format().samples() > 0) d->antialiasingMethod = MsaaAntialiasing; else d->antialiasingMethod = VertexAntialiasing; } } // With OpenGL ES, except for Angle on Windows, use GrayAntialiasing, unless // some value had been requested explicitly. This could not be decided // before without a context. Now the context is ready. if (!d->distanceFieldAntialiasingDecided) { d->distanceFieldAntialiasingDecided = true; #ifndef Q_OS_WIN32 if (renderContext->openglContext()->isOpenGLES()) d->distanceFieldAntialiasing = QSGGlyphNode::GrayAntialiasing; #endif } static bool dumped = false; if (!dumped && QSG_LOG_INFO().isDebugEnabled()) { dumped = true; QSurfaceFormat format = renderContext->openglContext()->format(); QOpenGLFunctions *funcs = QOpenGLContext::currentContext()->functions(); qCDebug(QSG_LOG_INFO) << "R/G/B/A Buffers: " << format.redBufferSize() << format.greenBufferSize() << format.blueBufferSize() << format.alphaBufferSize(); qCDebug(QSG_LOG_INFO) << "Depth Buffer: " << format.depthBufferSize(); qCDebug(QSG_LOG_INFO) << "Stencil Buffer: " << format.stencilBufferSize(); qCDebug(QSG_LOG_INFO) << "Samples: " << format.samples(); qCDebug(QSG_LOG_INFO) << "GL_VENDOR: " << (const char *) funcs->glGetString(GL_VENDOR); qCDebug(QSG_LOG_INFO) << "GL_RENDERER: " << (const char *) funcs->glGetString(GL_RENDERER); qCDebug(QSG_LOG_INFO) << "GL_VERSION: " << (const char *) funcs->glGetString(GL_VERSION); QSet<QByteArray> exts = renderContext->openglContext()->extensions(); QByteArray all; foreach (const QByteArray &e, exts) all += ' ' + e; qCDebug(QSG_LOG_INFO) << "GL_EXTENSIONS: " << all.constData(); qCDebug(QSG_LOG_INFO) << "Max Texture Size: " << renderContext->maxTextureSize(); qCDebug(QSG_LOG_INFO) << "Debug context: " << format.testOption(QSurfaceFormat::DebugContext); }
void KSecretServiceTest::setupKeyring() { const char* KSS_TEST_USER = "******"; QVERIFY(qEnvironmentVariableIsSet(KSS_TEST_USER)); QVERIFY(!qEnvironmentVariableIsEmpty(KSS_TEST_USER)); auto testUser = qgetenv(KSS_TEST_USER); const char* KSS_TEST_PASSWORD = "******"; QVERIFY(qEnvironmentVariableIsSet(KSS_TEST_PASSWORD)); QVERIFY(!qEnvironmentVariableIsEmpty(KSS_TEST_PASSWORD)); auto testPass = qgetenv(KSS_TEST_PASSWORD); const char* KEYNAME_ENCRYPTING = "ksecrets-test:encrypting"; const char* KEYNAME_MAC = "ksecrets-test:mac"; /* second prevention measure - change keyring keynames */ sharedConfig->group(QLatin1String("keyring")) .writeEntry("keyname_encrypt", KEYNAME_ENCRYPTING); sharedConfig->group(QLatin1String("keyring")) .writeEntry("keyname_mac", KEYNAME_MAC); /* third prevention measure - the encrypting key should not be present * into the kernel keyring */ key_serial_t key; key = request_key("user", KEYNAME_ENCRYPTING, 0, KEY_SPEC_SESSION_KEYRING); QVERIFY(-1 == key); /* now go setup user's keyring */ QVERIFY(1 == kss_set_credentials(testUser.constData(), testPass.constData(), secretsFilePath.toLocal8Bit().constData())); // the right keys should be present into the kernel keyring key = request_key("user", KEYNAME_ENCRYPTING, 0, KEY_SPEC_SESSION_KEYRING); QVERIFY(-1 != key); key = request_key("user", KEYNAME_MAC, 0, KEY_SPEC_SESSION_KEYRING); QVERIFY(-1 != key); }
// Suggest a scale factor by checking monitor sizes. int QWindowsScaling::determineUiScaleFactor() { if (!qEnvironmentVariableIsSet(devicePixelRatioEnvVar)) return 1; const QByteArray envDevicePixelRatioEnv = qgetenv(devicePixelRatioEnvVar); // Auto: Suggest a scale factor by checking monitor resolution. if (envDevicePixelRatioEnv == "auto") { const int maxResolution = QWindowsScreen::maxMonitorHorizResolution(); return maxResolution > 180 ? maxResolution / 96 : 1; } // Get factor from environment bool ok = false; const int envFactor = envDevicePixelRatioEnv.toInt(&ok); return ok && envFactor > 0 ? envFactor : 1; }
void TableGenerator::findComposeFile() { bool found = false; // check if XCOMPOSEFILE points to a Compose file if (qEnvironmentVariableIsSet("XCOMPOSEFILE")) { QString composeFile(qgetenv("XCOMPOSEFILE")); if (composeFile.endsWith(QLatin1String("Compose"))) found = processFile(composeFile); else qWarning("Qt Warning: XCOMPOSEFILE doesn't point to a valid Compose file"); #ifdef DEBUG_GENERATOR if (found) qDebug() << "Using Compose file from: " << composeFile; #endif } // check if user’s home directory has a file named .XCompose if (!found && cleanState()) { QString composeFile = qgetenv("HOME") + QStringLiteral("/.XCompose"); if (QFile(composeFile).exists()) found = processFile(composeFile); #ifdef DEBUG_GENERATOR if (found) qDebug() << "Using Compose file from: " << composeFile; #endif } // check for the system provided compose files if (!found && cleanState()) { QString table = composeTableForLocale(); if (cleanState()) { if (table.isEmpty()) // no table mappings for the system's locale in the compose.dir m_state = UnsupportedLocale; else found = processFile(systemComposeDir() + QLatin1Char('/') + table); #ifdef DEBUG_GENERATOR if (found) qDebug() << "Using Compose file from: " << systemComposeDir() + QLatin1Char('/') + table; #endif } } if (found && m_composeTable.isEmpty()) m_state = EmptyTable; if (!found) m_state = MissingComposeFile; }
void SessionManager::setupEnvironment() { // Set paths only if we are installed onto a non standard location QString path; if (qEnvironmentVariableIsSet("PATH")) { path = QStringLiteral("%1:%2").arg(INSTALL_BINDIR).arg(QString(qgetenv("PATH"))); qputenv("PATH", path.toUtf8()); } if (qEnvironmentVariableIsSet("QT_PLUGIN_PATH")) { path = QStringLiteral("%1:%2").arg(INSTALL_PLUGINDIR).arg(QString(qgetenv("QT_PLUGIN_PATH"))); qputenv("QT_PLUGIN_PATH", path.toUtf8()); } if (qEnvironmentVariableIsSet("QML2_IMPORT_PATH")) { path = QStringLiteral("%1:%2").arg(INSTALL_QMLDIR).arg(QString(qgetenv("QML2_IMPORT_PATH"))); qputenv("QML2_IMPORT_PATH", path.toUtf8()); } if (qEnvironmentVariableIsSet("XDG_DATA_DIRS")) { path = QStringLiteral("%1:%2").arg(INSTALL_DATADIR).arg(QString(qgetenv("XDG_DATA_DIRS"))); qputenv("XDG_DATA_DIRS", path.toUtf8()); } if (qEnvironmentVariableIsSet("XDG_CONFIG_DIRS")) { path = QStringLiteral("%1:%2:/etc/xdg").arg(INSTALL_CONFIGDIR).arg(QString(qgetenv("XDG_CONFIG_DIRS"))); qputenv("XDG_CONFIG_DIRS", path.toUtf8()); } if (qEnvironmentVariableIsSet("XCURSOR_PATH")) { path = QStringLiteral("%1:%2").arg(INSTALL_DATADIR "/icons").arg(QString(qgetenv("XCURSOR_PATH"))); qputenv("XCURSOR_PATH", path.toUtf8()); } // Set XDG environment variables if (qEnvironmentVariableIsEmpty("XDG_DATA_HOME")) { QString path = QStringLiteral("%1/.local/share").arg(QString(qgetenv("HOME"))); qputenv("XDG_DATA_HOME", path.toUtf8()); } if (qEnvironmentVariableIsEmpty("XDG_CONFIG_HOME")) { QString path = QStringLiteral("%1/.config").arg(QString(qgetenv("HOME"))); qputenv("XDG_CONFIG_HOME", path.toUtf8()); } // Set platform integration qputenv("SAL_USE_VCLPLUGIN", QByteArray("kde")); // qputenv("QT_PLATFORM_PLUGIN", QByteArray("Material")); // qputenv("QT_QPA_PLATFORMTHEME", QByteArray("Material")); // qputenv("QT_QUICK_CONTROLS_STYLE", QByteArray("Material")); // qputenv("QT_WAYLAND_DISABLE_WINDOWDECORATION", QByteArray("1")); // qputenv("XDG_CURRENT_DESKTOP", QByteArray("U2T")); // qputenv("XCURSOR_THEME", QByteArray("Adwaita")); // qputenv("XCURSOR_SIZE", QByteArray("16")); }