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 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"));
}
bool QMirClientClientIntegration::hasCapability(QPlatformIntegration::Capability cap) const
{
switch (cap) {
case ThreadedPixmaps:
return true;
case OpenGL:
return true;
case ApplicationState:
return true;
case ThreadedOpenGL:
if (qEnvironmentVariableIsEmpty("QTUBUNTU_NO_THREADED_OPENGL")) {
return true;
} else {
DLOG("ubuntumirclient: disabled threaded OpenGL");
return false;
}
case MultipleWindows:
case NonFullScreenWindows:
return true;
default:
return QPlatformIntegration::hasCapability(cap);
}
}
QEventDispatcherGlibPrivate::QEventDispatcherGlibPrivate(GMainContext *context)
: mainContext(context)
{
#if GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION < 32
if (qEnvironmentVariableIsEmpty("QT_NO_THREADED_GLIB")) {
static QBasicMutex mutex;
QMutexLocker locker(&mutex);
if (!g_thread_supported())
g_thread_init(NULL);
}
#endif
if (mainContext) {
g_main_context_ref(mainContext);
} else {
QCoreApplication *app = QCoreApplication::instance();
if (app && QThread::currentThread() == app->thread()) {
mainContext = g_main_context_default();
g_main_context_ref(mainContext);
} else {
mainContext = g_main_context_new();
}
}
#if GLIB_CHECK_VERSION (2, 22, 0)
g_main_context_push_thread_default (mainContext);
#endif
// setup post event source
postEventSource = reinterpret_cast<GPostEventSource *>(g_source_new(&postEventSourceFuncs,
sizeof(GPostEventSource)));
postEventSource->serialNumber.store(1);
postEventSource->d = this;
g_source_set_can_recurse(&postEventSource->source, true);
g_source_attach(&postEventSource->source, mainContext);
// setup socketNotifierSource
socketNotifierSource =
reinterpret_cast<GSocketNotifierSource *>(g_source_new(&socketNotifierSourceFuncs,
sizeof(GSocketNotifierSource)));
(void) new (&socketNotifierSource->pollfds) QList<GPollFDWithQSocketNotifier *>();
g_source_set_can_recurse(&socketNotifierSource->source, true);
g_source_attach(&socketNotifierSource->source, mainContext);
// setup normal and idle timer sources
timerSource = reinterpret_cast<GTimerSource *>(g_source_new(&timerSourceFuncs,
sizeof(GTimerSource)));
(void) new (&timerSource->timerList) QTimerInfoList();
timerSource->processEventsFlags = QEventLoop::AllEvents;
timerSource->runWithIdlePriority = false;
g_source_set_can_recurse(&timerSource->source, true);
g_source_attach(&timerSource->source, mainContext);
idleTimerSource = reinterpret_cast<GIdleTimerSource *>(g_source_new(&idleTimerSourceFuncs,
sizeof(GIdleTimerSource)));
idleTimerSource->timerSource = timerSource;
g_source_set_can_recurse(&idleTimerSource->source, true);
g_source_set_priority(&idleTimerSource->source, G_PRIORITY_DEFAULT_IDLE);
g_source_attach(&idleTimerSource->source, mainContext);
}
static BreakpadEH *initBreakpad()
{
// On all platforms, Breakpad can be disabled by setting the
// environment variable PHANTOMJS_DISABLE_CRASH_DUMPS to any
// non-empty value. This is not a command line argument because
// we want to initialize Breakpad before parsing the command line.
if (!qEnvironmentVariableIsEmpty("PHANTOMJS_DISABLE_CRASH_DUMPS"))
return 0;
// Windows and Unix have different conventions for the environment
// variable naming the directory that should hold scratch files.
#ifdef Q_OS_WIN32
std::wstring dumpPath(L".");
QString varbuf = q_wgetenv(L"TEMP");
if (!varbuf.isEmpty())
dumpPath = varbuf.toStdWString();
#else
std::string dumpPath("/tmp");
QByteArray varbuf = qgetenv("TMPDIR");
if (!varbuf.isEmpty())
dumpPath = varbuf.constData();
#endif
return new BreakpadEH(dumpPath, NULL, minidumpCallback, NULL,
EHC_EXTRA_ARGS);
}
void QQuickImageBase::resolve2xLocalFile(const QUrl &url, qreal targetDevicePixelRatio, QUrl *sourceUrl, qreal *sourceDevicePixelRatio)
{
Q_ASSERT(sourceUrl);
Q_ASSERT(sourceDevicePixelRatio);
// Bail out if "@2x" image loading is disabled, don't change the source url or devicePixelRatio.
static const bool disable2xImageLoading = !qEnvironmentVariableIsEmpty("QT_HIGHDPI_DISABLE_2X_IMAGE_LOADING");
if (disable2xImageLoading)
return;
QString localFile = QQmlFile::urlToLocalFileOrQrc(url);
// Non-local file path: @2x loading is not supported.
if (localFile.isEmpty())
return;
// Special case: the url in the QML source refers directly to an "@2x" file.
int atLocation = localFile.lastIndexOf(QLatin1Char('@'));
if (atLocation > 0 && atLocation + 3 < localFile.size()) {
if (localFile[atLocation + 1].isDigit()
&& localFile[atLocation + 2] == QLatin1Char('x')
&& localFile[atLocation + 3] == QLatin1Char('.')) {
*sourceDevicePixelRatio = localFile[atLocation + 1].digitValue();
return;
}
}
// Look for an @2x version
QString localFileX = qt_findAtNxFile(localFile, targetDevicePixelRatio, sourceDevicePixelRatio);
if (localFileX != localFile)
*sourceUrl = QUrl::fromLocalFile(localFileX);
}
void QMinimalEglScreen::createAndSetPlatformContext()
{
QSurfaceFormat platformFormat;
QByteArray depthString = qgetenv("QT_QPA_EGLFS_DEPTH");
if (depthString.toInt() == 16) {
platformFormat.setDepthBufferSize(16);
platformFormat.setRedBufferSize(5);
platformFormat.setGreenBufferSize(6);
platformFormat.setBlueBufferSize(5);
m_depth = 16;
m_format = QImage::Format_RGB16;
} else {
platformFormat.setDepthBufferSize(24);
platformFormat.setStencilBufferSize(8);
platformFormat.setRedBufferSize(8);
platformFormat.setGreenBufferSize(8);
platformFormat.setBlueBufferSize(8);
m_depth = 32;
m_format = QImage::Format_RGB32;
}
if (!qEnvironmentVariableIsEmpty("QT_QPA_EGLFS_MULTISAMPLE"))
platformFormat.setSamples(4);
EGLConfig config = q_configFromGLFormat(m_dpy, platformFormat);
EGLNativeWindowType eglWindow = 0;
#ifdef Q_OPENKODE
if (kdInitializeNV() == KD_ENOTINITIALIZED) {
qFatal("Did not manage to initialize openkode");
}
KDWindow *window = kdCreateWindow(m_dpy,config,0);
kdRealizeWindow(window,&eglWindow);
#endif
#ifdef QEGL_EXTRA_DEBUG
q_printEglConfig(m_dpy, config);
#endif
m_surface = eglCreateWindowSurface(m_dpy, config, eglWindow, NULL);
if (m_surface == EGL_NO_SURFACE) {
qWarning("Could not create the egl surface: error = 0x%x\n", eglGetError());
eglTerminate(m_dpy);
qFatal("EGL error");
}
// qWarning("Created surface %dx%d\n", w, h);
QEGLPlatformContext *platformContext = new QMinimalEglContext(platformFormat, 0, m_dpy);
m_platformContext = platformContext;
EGLint w,h; // screen size detection
eglQuerySurface(m_dpy, m_surface, EGL_WIDTH, &w);
eglQuerySurface(m_dpy, m_surface, EGL_HEIGHT, &h);
m_geometry = QRect(0,0,w,h);
}
QEglFSImx6Hooks::QEglFSImx6Hooks()
{
int width, height;
bool multiBufferNotEnabledYet = qEnvironmentVariableIsEmpty("FB_MULTI_BUFFER");
bool multiBuffer = qEnvironmentVariableIsEmpty("QT_EGLFS_IMX6_NO_FB_MULTI_BUFFER");
if (multiBufferNotEnabledYet && multiBuffer) {
qWarning() << "QEglFSImx6Hooks will set environment variable FB_MULTI_BUFFER=2 to enable double buffering and vsync.\n"
<< "If this is not desired, you can override this via: export QT_EGLFS_IMX6_NO_FB_MULTI_BUFFER=1";
qputenv("FB_MULTI_BUFFER", "2");
}
mNativeDisplay = fbGetDisplayByIndex(framebufferIndex());
fbGetDisplayGeometry(mNativeDisplay, &width, &height);
mScreenSize.setHeight(height);
mScreenSize.setWidth(width);
}
bool Capabilities::uploadConflictFiles() const
{
static auto envIsSet = !qEnvironmentVariableIsEmpty("OWNCLOUD_UPLOAD_CONFLICT_FILES");
static int envValue = qEnvironmentVariableIntValue("OWNCLOUD_UPLOAD_CONFLICT_FILES");
if (envIsSet)
return envValue != 0;
return _capabilities[QStringLiteral("uploadConflictFiles")].toBool();
}
static bool qsg_useConsistentTiming()
{
static int use = -1;
if (use < 0) {
use = !qEnvironmentVariableIsEmpty("QSG_FIXED_ANIMATION_STEP") && qgetenv("QSG_FIXED_ANIMATION_STEP") != "no"
? 1 : 0;
qCDebug(QSG_LOG_INFO, "Using %s", bool(use) ? "fixed animation steps" : "sg animation driver");
}
return bool(use);
}
QT_END_NAMESPACE
int main(int argc, char *argv[])
{
// rcc uses a QHash to store files in the resource system.
// we must force a certain hash order when testing or tst_rcc will fail, see QTBUG-25078
if (!qEnvironmentVariableIsEmpty("QT_RCC_TEST") && !qt_qhash_seed.testAndSetRelaxed(-1, 0))
qFatal("Cannot force QHash seed for testing as requested");
return QT_PREPEND_NAMESPACE(runRcc)(argc, argv);
}
bool qdbus_loadLibDBus()
{
#ifndef QT_NO_LIBRARY
#ifdef QT_BUILD_INTERNAL
// this is to simulate a library load failure for our autotest suite.
if (!qEnvironmentVariableIsEmpty("QT_SIMULATE_DBUS_LIBFAIL"))
return false;
#endif
static bool triedToLoadLibrary = false;
#ifndef QT_NO_THREAD
QMutexLocker locker(QMutexPool::globalInstanceGet((void *)&qdbus_resolve_me));
#endif
QLibrary *&lib = qdbus_libdbus;
if (triedToLoadLibrary)
return lib && lib->isLoaded();
lib = new QLibrary;
lib->setLoadHints(QLibrary::ExportExternalSymbolsHint); // make libdbus symbols available for apps that need more advanced control over the dbus
triedToLoadLibrary = true;
static int majorversions[] = { 3, 2, -1 };
const QString baseNames[] = {
#ifdef Q_OS_WIN
QLatin1String("dbus-1"),
#endif
QLatin1String("libdbus-1")
};
lib->unload();
for (uint i = 0; i < sizeof(majorversions) / sizeof(majorversions[0]); ++i) {
for (uint j = 0; j < sizeof(baseNames) / sizeof(baseNames[0]); ++j) {
#ifdef Q_OS_WIN
QString suffix;
if (majorversions[i] != -1)
suffix = QString::number(- majorversions[i]); // negative so it prepends the dash
lib->setFileName(baseNames[j] + suffix);
#else
lib->setFileNameAndVersion(baseNames[j], majorversions[i]);
#endif
if (lib->load() && lib->resolve("dbus_connection_open_private"))
return true;
lib->unload();
}
}
delete lib;
lib = 0;
return false;
#else
return true;
#endif
}
QT_BEGIN_NAMESPACE
class QAbstractEventDispatcher *createUnixEventDispatcher()
{
#if !defined(QT_NO_GLIB) && !defined(Q_OS_WIN)
if (qEnvironmentVariableIsEmpty("QT_NO_GLIB") && QEventDispatcherGlib::versionSupported())
return new QPAEventDispatcherGlib();
else
#endif
return new QUnixEventDispatcherQPA();
}
static bool isFatal(QtMsgType msgType)
{
if (msgType == QtFatalMsg)
return true;
if (msgType == QtWarningMsg || msgType == QtCriticalMsg) {
static bool fatalWarnings = !qEnvironmentVariableIsEmpty("QT_FATAL_WARNINGS");
return fatalWarnings;
}
return false;
}
/*
* Some glsl compilers take their time compiling materials, and
* the way the scene graph is being processed, these materials
* get compiled when they are first taken into use. This can
* easily lead to skipped frames. By precompiling the most
* common materials, we potentially add a few milliseconds to the
* start up, and reduce the chance of avoiding skipped frames
* later on.
*/
void QSGContext::precompileMaterials()
{
if (qEnvironmentVariableIsEmpty("QSG_NO_MATERIAL_PRELOADING")) {
QSG_PRECOMPILE_MATERIAL(QSGVertexColorMaterial);
QSG_PRECOMPILE_MATERIAL(QSGFlatColorMaterial);
QSG_PRECOMPILE_MATERIAL(QSGOpaqueTextureMaterial);
QSG_PRECOMPILE_MATERIAL(QSGTextureMaterial);
QSG_PRECOMPILE_MATERIAL(QSGSmoothTextureMaterial);
QSG_PRECOMPILE_MATERIAL(QSGSmoothColorMaterial);
QSG_PRECOMPILE_MATERIAL(QSGDistanceFieldTextMaterial);
}
}
static inline QByteArray detectDesktopEnvironment()
{
const QByteArray xdgCurrentDesktop = qgetenv("XDG_CURRENT_DESKTOP");
if (!xdgCurrentDesktop.isEmpty())
return xdgCurrentDesktop.toUpper(); // KDE, GNOME, UNITY, LXDE, MATE, XFCE...
// Classic fallbacks
if (!qEnvironmentVariableIsEmpty("KDE_FULL_SESSION"))
return QByteArrayLiteral("KDE");
if (!qEnvironmentVariableIsEmpty("GNOME_DESKTOP_SESSION_ID"))
return QByteArrayLiteral("GNOME");
// Fallback to checking $DESKTOP_SESSION (unreliable)
const QByteArray desktopSession = qgetenv("DESKTOP_SESSION");
if (desktopSession == "gnome")
return QByteArrayLiteral("GNOME");
if (desktopSession == "xfce")
return QByteArrayLiteral("XFCE");
return QByteArrayLiteral("UNKNOWN");
}
static void setupEnvironment()
{
// Set defaults
if (qEnvironmentVariableIsEmpty("XDG_DATA_DIRS"))
qputenv("XDG_DATA_DIRS", QByteArrayLiteral("/usr/local/share/:/usr/share/"));
if (qEnvironmentVariableIsEmpty("XDG_CONFIG_DIRS"))
qputenv("XDG_CONFIG_DIRS", QByteArrayLiteral("/etc/xdg"));
// Environment
qputenv("QT_QPA_PLATFORMTHEME", QByteArrayLiteral("Papyros"));
qputenv("QT_QUICK_CONTROLS_STYLE", QByteArrayLiteral("Material"));
qputenv("QT_LABS_CONTROLS_STYLE", QByteArrayLiteral("material"));
qputenv("XCURSOR_THEME", QByteArrayLiteral("hawaii"));
qputenv("XCURSOR_SIZE", QByteArrayLiteral("16"));
qputenv("XDG_MENU_PREFIX", QByteArrayLiteral("papyros-"));
qputenv("XDG_CURRENT_DESKTOP", QByteArrayLiteral("X-Papyros"));
// TODO: Load input method
// Hawaii::QGSettings settings(QLatin1String("org.hawaiios.desktop.interface"),
// QLatin1String("/org/hawaiios/desktop/interface/"));
// qputenv("QT_IM_MODULE", settings.value(QLatin1String("inputMethod")).toByteArray());
}
static inline QByteArray detectDesktopEnvironment()
{
const QByteArray xdgCurrentDesktop = qgetenv("XDG_CURRENT_DESKTOP");
if (!xdgCurrentDesktop.isEmpty())
// See http://standards.freedesktop.org/menu-spec/latest/apb.html
return xdgCurrentDesktop.toUpper();
// Classic fallbacks
if (!qEnvironmentVariableIsEmpty("KDE_FULL_SESSION"))
return QByteArrayLiteral("KDE");
if (!qEnvironmentVariableIsEmpty("GNOME_DESKTOP_SESSION_ID"))
return QByteArrayLiteral("GNOME");
// Fallback to checking $DESKTOP_SESSION (unreliable)
const QByteArray desktopSession = qgetenv("DESKTOP_SESSION");
if (desktopSession == "gnome")
return QByteArrayLiteral("GNOME");
if (desktopSession == "xfce")
return QByteArrayLiteral("XFCE");
return QByteArrayLiteral("UNKNOWN");
}
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);
}
QMirClientClientIntegration::QMirClientClientIntegration()
: QPlatformIntegration()
, mNativeInterface(new QMirClientNativeInterface)
, mFontDb(new QGenericUnixFontDatabase)
, mServices(new QMirClientPlatformServices)
, mClipboard(new QMirClientClipboard)
, mScaleFactor(1.0)
{
setupOptions();
setupDescription();
// Create new application instance
mInstance = u_application_instance_new_from_description_with_options(mDesc, mOptions);
if (mInstance == nullptr)
qFatal("QMirClientClientIntegration: connection to Mir server failed. Check that a Mir server is\n"
"running, and the correct socket is being used and is accessible. The shell may have\n"
"rejected the incoming connection, so check its log file");
mNativeInterface->setMirConnection(u_application_instance_get_mir_connection(mInstance));
// Create default screen.
mScreen = new QMirClientScreen(u_application_instance_get_mir_connection(mInstance));
screenAdded(mScreen);
// Initialize input.
if (qEnvironmentVariableIsEmpty("QTUBUNTU_NO_INPUT")) {
mInput = new QMirClientInput(this);
mInputContext = QPlatformInputContextFactory::create();
} else {
mInput = nullptr;
mInputContext = nullptr;
}
// compute the scale factor
const int defaultGridUnit = 8;
int gridUnit = defaultGridUnit;
QByteArray gridUnitString = qgetenv("GRID_UNIT_PX");
if (!gridUnitString.isEmpty()) {
bool ok;
gridUnit = gridUnitString.toInt(&ok);
if (!ok) {
gridUnit = defaultGridUnit;
}
}
mScaleFactor = static_cast<qreal>(gridUnit) / defaultGridUnit;
}
/*! Adds an image from the file with the given \a fileName to the
icon, as a specialization for \a size, \a mode and \a state. The
file will be loaded on demand. Note: custom icon engines are free
to ignore additionally added pixmaps.
If \a fileName contains a relative path (e.g. the filename only)
the relevant file must be found relative to the runtime working
directory.
The file name can be either refer to an actual file on disk or to
one of the application's embedded resources. See the
\l{resources.html}{Resource System} overview for details on how to
embed images and other resource files in the application's
executable.
Use the QImageReader::supportedImageFormats() and
QImageWriter::supportedImageFormats() functions to retrieve a
complete list of the supported file formats.
If a high resolution version of the image exists (identified by
the suffix \c @2x on the base name), it is automatically loaded
and added with the \e{device pixel ratio} set to a value of 2.
This can be disabled by setting the environment variable
\c QT_HIGHDPI_DISABLE_2X_IMAGE_LOADING (see QImageReader).
\note When you add a non-empty filename to a QIcon, the icon becomes
non-null, even if the file doesn't exist or points to a corrupt file.
\sa addPixmap(), QPixmap::devicePixelRatio()
*/
void QIcon::addFile(const QString &fileName, const QSize &size, Mode mode, State state)
{
if (fileName.isEmpty())
return;
if (!d) {
#ifndef QT_NO_LIBRARY
QFileInfo info(fileName);
QString suffix = info.suffix();
if (!suffix.isEmpty()) {
// first try version 2 engines..
const int index = loader()->indexOf(suffix);
if (index != -1) {
if (QIconEnginePlugin *factory = qobject_cast<QIconEnginePlugin*>(loader()->instance(index))) {
if (QIconEngine *engine = factory->create(fileName)) {
d = new QIconPrivate;
d->engine = engine;
}
}
}
}
#endif
// ...then fall back to the default engine
if (!d) {
d = new QIconPrivate;
d->engine = new QPixmapIconEngine;
}
} else {
detach();
}
d->engine->addFile(fileName, size, mode, state);
// Check if a "@2x" file exists and add it.
static bool disable2xImageLoading = !qEnvironmentVariableIsEmpty("QT_HIGHDPI_DISABLE_2X_IMAGE_LOADING");
if (!disable2xImageLoading && qApp->devicePixelRatio() > 1.0) {
QString at2xfileName = fileName;
int dotIndex = fileName.lastIndexOf(QLatin1Char('.'));
if (dotIndex == -1) /* no dot */
dotIndex = fileName.size(); /* append */
at2xfileName.insert(dotIndex, QStringLiteral("@2x"));
if (QFile::exists(at2xfileName))
d->engine->addFile(at2xfileName, size, mode, state);
}
}
void LipstickCompositorWindow::touchEvent(QTouchEvent *event)
{
if (touchEventsEnabled() && surface()) {
handleTouchEvent(event);
#if QT_VERSION >= 0x050202
static bool lipstick_touch_interception = qEnvironmentVariableIsEmpty("LIPSTICK_NO_TOUCH_INTERCEPTION");
if (lipstick_touch_interception && event->type() == QEvent::TouchBegin) {
// On TouchBegin, start intercepting
if (event->isAccepted() && !m_interceptingTouch) {
m_interceptingTouch = true;
window()->installEventFilter(this);
}
}
#endif
} else {
event->ignore();
}
}
void QFileSelectorPrivate::updateSelectors()
{
if (!sharedData->staticSelectors.isEmpty())
return; //Already loaded
QLatin1Char pathSep(',');
QStringList envSelectors = QString::fromLatin1(qgetenv("QT_FILE_SELECTORS"))
.split(pathSep, QString::SkipEmptyParts);
if (envSelectors.count())
sharedData->staticSelectors << envSelectors;
if (!qEnvironmentVariableIsEmpty(env_override))
return;
sharedData->staticSelectors << sharedData->preloadedStatics; //Potential for static selectors from other modules
// TODO: Update on locale changed?
sharedData->staticSelectors << QLocale().name();
sharedData->staticSelectors << platformSelectors();
}
bool QMimeBinaryProvider::isValid()
{
#if defined(QT_USE_MMAP)
if (!qEnvironmentVariableIsEmpty("QT_NO_MIME_CACHE"))
return false;
Q_ASSERT(m_cacheFiles.isEmpty()); // this method is only ever called once
checkCache();
if (m_cacheFiles.count() > 1)
return true;
if (m_cacheFiles.isEmpty())
return false;
// We found exactly one file; is it the user-modified mimes, or a system file?
const QString foundFile = m_cacheFiles.first()->file.fileName();
const QString localCacheFile = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1String("/mime/mime.cache");
return foundFile != localCacheFile;
#else
return false;
#endif
}
int main(int argc, char *argv[])
{
// Application
QCoreApplication app(argc, argv);
app.setApplicationName(QStringLiteral("Hawaii Session"));
app.setApplicationVersion(QStringLiteral(HAWAII_VERSION_STRING));
app.setOrganizationName(QStringLiteral("Hawaii"));
app.setOrganizationDomain(QStringLiteral("org.hawaiios"));
// Command line parser
QCommandLineParser parser;
parser.setApplicationDescription(TR("Hawaii session manager"));
parser.addHelpOption();
parser.addVersionOption();
// Parse command line
parser.process(app);
// Restart with D-Bus session if necessary
if (qEnvironmentVariableIsEmpty("DBUS_SESSION_BUS_ADDRESS")) {
qDebug() << "No D-Bus session bus available, respawning with dbus-launch...";
QStringList args = QStringList()
<< QStringLiteral("--exit-with-session")
<< QCoreApplication::arguments();
char **const argv_pointers = new char *[args.count() + 2];
char **p = argv_pointers;
*p = ::strdup("dbus-launch");
++p;
Q_FOREACH (const QString &arg, args) {
*p = new char[arg.length() + 1];
::strcpy(*p, qPrintable(arg));
++p;
}
QSGContext::QSGContext(QObject *parent) :
QObject(*(new QSGContextPrivate), parent)
{
Q_D(QSGContext);
if (Q_UNLIKELY(!qEnvironmentVariableIsEmpty("QSG_DISTANCEFIELD_ANTIALIASING"))) {
const QByteArray mode = qgetenv("QSG_DISTANCEFIELD_ANTIALIASING");
d->distanceFieldAntialiasingDecided = true;
if (mode == "subpixel")
d->distanceFieldAntialiasing = QSGGlyphNode::HighQualitySubPixelAntialiasing;
else if (mode == "subpixel-lowq")
d->distanceFieldAntialiasing = QSGGlyphNode::LowQualitySubPixelAntialiasing;
else if (mode == "gray")
d->distanceFieldAntialiasing = QSGGlyphNode::GrayAntialiasing;
}
// Adds compatibility with Qt 5.3 and earlier's QSG_RENDER_TIMING
if (qEnvironmentVariableIsSet("QSG_RENDER_TIMING")) {
const_cast<QLoggingCategory &>(QSG_LOG_TIME_GLYPH()).setEnabled(QtDebugMsg, true);
const_cast<QLoggingCategory &>(QSG_LOG_TIME_TEXTURE()).setEnabled(QtDebugMsg, true);
const_cast<QLoggingCategory &>(QSG_LOG_TIME_RENDERER()).setEnabled(QtDebugMsg, true);
const_cast<QLoggingCategory &>(QSG_LOG_TIME_RENDERLOOP()).setEnabled(QtDebugMsg, true);
const_cast<QLoggingCategory &>(QSG_LOG_TIME_COMPILATION()).setEnabled(QtDebugMsg, true);
}
}
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qsgnode.h"
#include "qsgnode_p.h"
#include "qsgrenderer_p.h"
#include "qsgnodeupdater_p.h"
#include "qsgmaterial.h"
#include "limits.h"
QT_BEGIN_NAMESPACE
#ifndef QT_NO_DEBUG
static const bool qsg_leak_check = !qEnvironmentVariableIsEmpty("QML_LEAK_CHECK");
static int qt_node_count = 0;
static void qt_print_node_count()
{
qDebug("Number of leaked nodes: %i", qt_node_count);
qt_node_count = -1;
}
#endif
/*!
\group qtquick-scenegraph-nodes
\title Qt Quick Scene Graph Node classes
\brief Nodes that can be used as part of the scene graph.
This page lists the nodes in \l {Qt Quick}'s \l {scene graph}{Qt Quick Scene Graph}.
extern "C" Q_DECL_EXPORT int kdemain(int argc, char **argv)
{
#ifndef Q_OS_WIN
// Started via kdeinit.
int launcherFd;
if (argc != 2 || memcmp(argv[1], "--fd=", 5) || !(launcherFd = atoi(argv[1] + 5))) {
fprintf(stderr, "%s", i18n("klauncher: This program is not supposed to be started manually.\n"
"klauncher: It is started automatically by kdeinit5.\n").toLocal8Bit().data());
return 1;
}
#endif
#if defined(Q_OS_DARWIN)
CFBundleRef mainBundle = CFBundleGetMainBundle();
if (mainBundle) {
// get the application's Info Dictionary. For app bundles this would live in the bundle's Info.plist,
// for regular executables it is obtained in another way.
CFMutableDictionaryRef infoDict = (CFMutableDictionaryRef) CFBundleGetInfoDictionary(mainBundle);
if (infoDict) {
// Add or set the "LSUIElement" key with/to value "1". This can simply be a CFString.
CFDictionarySetValue(infoDict, CFSTR("LSUIElement"), CFSTR("1"));
// That's it. We're now considered as an "agent" by the window server, and thus will have
// neither menubar nor presence in the Dock or App Switcher.
}
}
mac_initialize_dbus();
#endif
// WABA: Make sure not to enable session management.
qunsetenv("SESSION_MANAGER");
// Disable the GLib event loop (rh#983110)
const bool wasQtNoGlibSet = !qEnvironmentVariableIsEmpty("QT_NO_GLIB");
if (!wasQtNoGlibSet) {
qputenv("QT_NO_GLIB", "1");
}
// We need a QGuiApplication as we use X11
QGuiApplication app(argc, argv);
app.setApplicationName(QStringLiteral("klauncher"));
// Now get rid of QT_NO_GLIB again so launched processes don't inherit it
if (!wasQtNoGlibSet) {
qunsetenv("QT_NO_GLIB");
}
int maxTry = 3;
while (true) {
QString service(QStringLiteral("org.kde.klauncher5")); // same as ktoolinvocation.cpp
if (!QDBusConnection::sessionBus().isConnected()) {
qWarning() << "No DBUS session-bus found. Check if you have started the DBUS server.";
return 1;
}
QDBusReply<QDBusConnectionInterface::RegisterServiceReply> reply =
QDBusConnection::sessionBus().interface()->registerService(service);
if (!reply.isValid()) {
qWarning() << "DBUS communication problem!";
return 1;
}
if (reply == QDBusConnectionInterface::ServiceRegistered) {
break;
}
if (--maxTry == 0) {
qWarning() << "Another instance of klauncher is already running!";
return 1;
}
// Wait a bit...
qWarning() << "Waiting for already running klauncher to exit.";
QThread::sleep(1);
// Try again...
}
#ifndef USE_KPROCESS_FOR_KIOSLAVES
KLauncher *launcher = new KLauncher(launcherFd);
#else
KLauncher *launcher = new KLauncher();
#endif
QDBusConnection::sessionBus().registerObject(QStringLiteral("/"), launcher);
#ifndef USE_KPROCESS_FOR_KIOSLAVES
if (pipe(sigpipe) != 0) {
perror("klauncher: pipe failed.");
return 1;
}
QSocketNotifier *signotif = new QSocketNotifier(sigpipe[ 0 ], QSocketNotifier::Read, launcher);
QObject::connect(signotif, SIGNAL(activated(int)), launcher, SLOT(destruct()));
KCrash::setEmergencySaveFunction(sig_handler);
signal(SIGHUP, sig_handler);
signal(SIGPIPE, SIG_IGN);
signal(SIGTERM, sig_handler);
#endif
return app.exec();
}
QT_BEGIN_NAMESPACE_CONTACTS
/*!
\class QContactManager
\brief The QContactManager class provides an interface which allows clients with access to contact information stored in a particular backend.
\inmodule QtContacts
\ingroup contacts-main
This class provides an abstraction of a datastore or aggregation of datastores which contains contact information.
It provides methods to retrieve and manipulate contact information and contact relationship information.
It also provides metadata and error information reporting.
The functions provided by QContactManager are purely synchronous; to access the same functionality in an
asynchronous manner, clients should use the use-case-specific classes derived from QContactAbstractRequest.
Some functionality provided by QContactManager directly is not accessible using the asynchronous API. See
the \l{Qt Contacts Synchronous API}{synchronous} and \l{Qt Contacts Asynchronous API}{asynchronous} API
information in the \l{Qt Contacts C++ API} documentation.
*/
/*!
\fn QContactManager::dataChanged()
This signal is emitted by the manager if its internal state changes, and it is unable to determine the changes
which occurred, or if the manager considers the changes to be radical enough to require clients to reload all data.
If this signal is emitted, no other signals will be emitted for the associated changes.
*/
/*!
\fn QContactManager::contactsAdded(const QList<QContactId>& contactIds)
This signal is emitted at some point once the contacts identified by \a contactIds have been added to a datastore managed by this manager.
This signal must not be emitted if the dataChanged() signal was previously emitted for these changes.
*/
/*!
\fn QContactManager::contactsChanged(const QList<QContactId>& contactIds)
This signal is emitted at some point once the contacts identified by \a contactIds have been modified in a datastore managed by this manager.
This signal must not be emitted if the dataChanged() signal was previously emitted for these changes.
*/
/*!
\fn QContactManager::contactsRemoved(const QList<QContactId>& contactIds)
This signal is emitted at some point once the contacts identified by \a contactIds have been removed from a datastore managed by this manager.
This signal must not be emitted if the dataChanged() signal was previously emitted for these changes.
*/
/*!
\fn QContactManager::relationshipsAdded(const QList<QContactId>& affectedContactIds)
This signal is emitted at some point after relationships have been added to the manager which involve the contacts identified by \a affectedContactIds.
This signal must not be emitted if the dataChanged() signal was previously emitted for these changes.
*/
/*!
\fn QContactManager::relationshipsRemoved(const QList<QContactId>& affectedContactIds)
This signal is emitted at some point after relationships have eben removed from the manager which involve the contacts identified by \a affectedContactIds.
This signal must not be emitted if the dataChanged() signal was previously emitted for these changes.
*/
/*!
\fn QContactManager::selfContactIdChanged(const QContactId& oldId, const QContactId& newId)
This signal is emitted at some point after the id of the self-contact is changed from \a oldId to \a newId in the manager.
If the \a newId is the invalid, then the self contact was deleted or no self contact exists.
This signal must not be emitted if the dataChanged() signal was previously emitted for this change.
*/
#define makestr(x) (#x)
#define makename(x) makestr(x)
/*!
Returns a list of available manager ids that can be used when constructing
a QContactManager. If an empty id is specified to the constructor, the
first value in this list will be used instead.
*/
QStringList QContactManager::availableManagers()
{
QStringList ret;
QContactManagerData::loadFactoriesMetadata();
ret = QContactManagerData::m_managerNames;
ret << QStringLiteral("invalid");
// now swizzle the default engine to pole position
#if defined(Q_CONTACTS_DEFAULT_ENGINE)
if (ret.removeAll(QLatin1String(makename(Q_CONTACTS_DEFAULT_ENGINE)))) {
ret.prepend(QLatin1String(makename(Q_CONTACTS_DEFAULT_ENGINE)));
}
#endif
// bump memory to the end of the list
if (ret.removeAll(QStringLiteral("memory")))
ret.append(QStringLiteral("memory"));
// if a plugin was specifically requested, put it first
if (!qEnvironmentVariableIsEmpty("QTCONTACTS_MANAGER_OVERRIDE")) {
QString managerName = qgetenv("QTCONTACTS_MANAGER_OVERRIDE");
if (ret.removeAll(managerName));
ret.prepend(managerName);
}
return ret;
}
HwComposerBackend *
HwComposerBackend::create()
{
hw_module_t *hwc_module = NULL;
hw_device_t *hwc_device = NULL;
// Some implementations insist on having the framebuffer module opened before loading
// the hardware composer one. Therefor we rely on using the fbdev HYBRIS_EGLPLATFORM
// here and use eglGetDisplay to initialize it.
if (qEnvironmentVariableIsEmpty("QT_QPA_NO_FRAMEBUFFER_FIRST")) {
eglGetDisplay(EGL_DEFAULT_DISPLAY);
}
// Open hardware composer
HWC_PLUGIN_ASSERT_ZERO(hw_get_module(HWC_HARDWARE_MODULE_ID, (const hw_module_t **)(&hwc_module)));
fprintf(stderr, "== hwcomposer module ==\n");
fprintf(stderr, " * Address: %p\n", hwc_module);
fprintf(stderr, " * Module API Version: %x\n", hwc_module->module_api_version);
fprintf(stderr, " * HAL API Version: %x\n", hwc_module->hal_api_version); /* should be zero */
fprintf(stderr, " * Identifier: %s\n", hwc_module->id);
fprintf(stderr, " * Name: %s\n", hwc_module->name);
fprintf(stderr, " * Author: %s\n", hwc_module->author);
fprintf(stderr, "== hwcomposer module ==\n");
// Open hardware composer device
HWC_PLUGIN_ASSERT_ZERO(hwc_module->methods->open(hwc_module, HWC_HARDWARE_COMPOSER, &hwc_device));
uint32_t version = hwc_device->version;
if ((version & 0xffff0000) == 0) {
// Assume header version is always 1
uint32_t header_version = 1;
// Legacy version encoding
version = (version << 16) | header_version;
}
fprintf(stderr, "== hwcomposer device ==\n");
fprintf(stderr, " * Version: %x (interpreted as %x)\n", hwc_device->version, version);
fprintf(stderr, " * Module: %p\n", hwc_device->module);
fprintf(stderr, "== hwcomposer device ==\n");
// Special-case for old hw adaptations that have the version encoded in
// legacy format, we have to check hwc_device->version directly, because
// the constants are actually encoded in the old format
if ((hwc_device->version == HWC_DEVICE_API_VERSION_0_1) ||
(hwc_device->version == HWC_DEVICE_API_VERSION_0_2) ||
(hwc_device->version == HWC_DEVICE_API_VERSION_0_3)) {
return new HwComposerBackend_v0(hwc_module, hwc_device);
}
// Determine which backend we use based on the supported module API version
switch (version) {
case HWC_DEVICE_API_VERSION_0_1:
case HWC_DEVICE_API_VERSION_0_2:
case HWC_DEVICE_API_VERSION_0_3:
return new HwComposerBackend_v0(hwc_module, hwc_device);
break;
#ifdef HWC_DEVICE_API_VERSION_1_0
case HWC_DEVICE_API_VERSION_1_0:
return new HwComposerBackend_v10(hwc_module, hwc_device);
break;
#endif /* HWC_DEVICE_API_VERSION_1_0 */
#ifdef HWC_PLUGIN_HAVE_HWCOMPOSER1_API
case HWC_DEVICE_API_VERSION_1_1:
return new HwComposerBackend_v11(hwc_module, hwc_device, HWC_NUM_DISPLAY_TYPES);
break;
#ifdef HWC_DEVICE_API_VERSION_1_2
case HWC_DEVICE_API_VERSION_1_2:
/* hwcomposer 1.2 and beyond have virtual displays */
return new HwComposerBackend_v11(hwc_module, hwc_device, HWC_NUM_DISPLAY_TYPES);
break;
#endif /* HWC_DEVICE_API_VERSION_1_2 */
#ifdef HWC_DEVICE_API_VERSION_1_3
case HWC_DEVICE_API_VERSION_1_3:
/* kitkat already takes virtual into account so no +1 required */
return new HwComposerBackend_v11(hwc_module, hwc_device, HWC_NUM_DISPLAY_TYPES /*+ 1*/);
break;
#endif /* HWC_DEVICE_API_VERSION_1_3 */
#endif /* HWC_PLUGIN_HAVE_HWCOMPOSER1_API */
default:
fprintf(stderr, "Unknown hwcomposer API: 0x%x/0x%x/0x%x\n",
hwc_module->module_api_version,
hwc_device->version,
version);
return NULL;
break;
}
}
