qeglfsintegration.cpp

Jenkins

Absolute File Name:

/home/qt/qt5_coco/qt5/qtbase/src/plugins/platforms/eglfs/qeglfsintegration.cpp

Line

Source

Count

/****************************************************************************

** Contact: https://www.qt.io/licensing/

** This file is part of the plugins of the Qt Toolkit.

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

** $QT_END_LICENSE$

****************************************************************************/

#include <QtCore/qtextstream.h>

#include <QtGui/private/qguiapplication_p.h>

#include <qpa/qplatformwindow.h>

#include <QtGui/QSurfaceFormat>

#include <QtGui/QOpenGLContext>

#include <QtGui/QScreen>

#include <QtGui/QOffscreenSurface>

#include <QtGui/QWindow>

#include <QtCore/QLoggingCategory>

#include <qpa/qwindowsysteminterface.h>

#include <qpa/qplatforminputcontextfactory_p.h>

#include <private/qgenericunixthemes_p.h>

#include "qeglfsintegration.h"

#include "qeglfswindow.h"

#include "qeglfshooks.h"

#include "qeglfscontext.h"

#include "qeglfsoffscreenwindow.h"

#include "qeglfscursor.h"

#include <QtPlatformSupport/private/qeglconvenience_p.h>

#include <QtPlatformSupport/private/qeglplatformcontext_p.h>

#include <QtPlatformSupport/private/qeglpbuffer_p.h>

#include <QtPlatformSupport/private/qgenericunixfontdatabase_p.h>

#include <QtPlatformSupport/private/qgenericunixservices_p.h>

#include <QtPlatformSupport/private/qgenericunixeventdispatcher_p.h>

#include <QtPlatformSupport/private/qfbvthandler_p.h>

#include <QtPlatformSupport/private/qopenglcompositorbackingstore_p.h>

#include <QtPlatformHeaders/QEGLNativeContext>

#ifndef QT_NO_LIBINPUT

#include <QtPlatformSupport/private/qlibinputhandler_p.h>

#endif

#if !defined(QT_NO_EVDEV) && (!!defined(Q_OS_ANDROID)

|| defined(Q_OS_ANDROID_NO_SDK))#include <QtPlatformSupport/private/qevdevmousemanager_p.h>

#include <QtPlatformSupport/private/qevdevkeyboardmanager_p.h>

#include <QtPlatformSupport/private/qevdevtouchmanager_p.h>

#endif

#if !defined(QT_NO_TSLIB) && (!!defined(Q_OS_ANDROID)

|| defined(Q_OS_ANDROID_NO_SDK))#include <QtPlatformSupport/private/qtslib_p.h>

#endif

#include <QtPlatformHeaders/qeglfsfunctions.h>

static void initResources()

{

#ifndef QT_NO_CURSOR

Q_INIT_RESOURCE(cursor);

#endif

}

QT_BEGIN_NAMESPACE

QEglFSIntegration::QEglFSIntegration()

: m_display(EGL_NO_DISPLAY),

100

m_inputContext(0),

101

m_fontDb(new QGenericUnixFontDatabase),

102

m_services(new QGenericUnixServices),

103

m_kbdMgr(0),

104

m_disableInputHandlers(false)

105

{

106

m_disableInputHandlers = qEnvironmentVariableIntValue("QT_QPA_EGLFS_DISABLE_INPUT");

initResources();

}

void QEglFSIntegration::addScreen(QPlatformScreen *screen)

{

screenAdded(screen);

}

void QEglFSIntegration::removeScreen(QPlatformScreen *screen)

117

{

118

destroyScreen(screen);

119

}

120

121

void QEglFSIntegration::initialize()

122

{

123

qt_egl_device_integration()->platformInit();

124

125

m_display = qt_egl_device_integration()->createDisplay(nativeDisplay());

126

if (Q_UNLIKELY(m_display == EGL_NO_DISPLAY)))

__builtin_expe...ay)0)), false)	Description
TRUE	never evaluated
FALSE	never evaluated

127

qFatal("Could not open egl display");

never executed: QMessageLogger(__FILE__, 127, __PRETTY_FUNCTION__).fatal("Could not open egl display");

128

129

EGLint major, minor;

130

if (Q_UNLIKELY(!eglInitialize(m_display, &major, &minor)))))

__builtin_expe...inor)), false)	Description
TRUE	never evaluated
FALSE	never evaluated

131

qFatal("Could not initialize egl display");

never executed: QMessageLogger(__FILE__, 131, __PRETTY_FUNCTION__).fatal("Could not initialize egl display");

132

133

m_inputContext = QPlatformInputContextFactory::create();

134

135

m_vtHandler.reset(new QFbVtHandler);

136

137

if (qt_egl_device_integration()->usesDefaultScreen())

qt_egl_device_...efaultScreen()	Description
TRUE	never evaluated
FALSE	never evaluated

138

addScreen(new QEglFSScreen(display()));

never executed: addScreen(new QEglFSScreen(display()));

139

else

140

qt_egl_device_integration()->screenInit();

never executed: qt_egl_device_integration()->screenInit();

141

142

// Input code may rely on the screens, so do it only after the screen init.

143

if (!m_disableInputHandlers)

!m_disableInputHandlers	Description
TRUE	never evaluated
FALSE	never evaluated

144

createInputHandlers();

never executed: createInputHandlers();

145

}

never executed: end of block

146

147

void QEglFSIntegration::destroy()

148

{

149

foreach (QWindow *w, qGuiApp->topLevelWindows())

150

w->destroy();

151

152

qt_egl_device_integration()->screenDestroy();

153

154

if (m_display != EGL_NO_DISPLAY)

155

eglTerminate(m_display);

156

157

qt_egl_device_integration()->platformDestroy();

158

}

159

160

QAbstractEventDispatcher *QEglFSIntegration::createEventDispatcher() const

161

{

162

return createUnixEventDispatcher();

163

}

164

165

QPlatformServices *QEglFSIntegration::services() const

166

{

167

return m_services.data();

168

}

169

170

QPlatformFontDatabase *QEglFSIntegration::fontDatabase() const

171

{

172

return m_fontDb.data();

173

}

174

175

QPlatformTheme *QEglFSIntegration::createPlatformTheme(const QString &name) const

176

{

177

return QGenericUnixTheme::createUnixTheme(name);

never executed: return QGenericUnixTheme::createUnixTheme(name);

178

}

179

180

QPlatformBackingStore *QEglFSIntegration::createPlatformBackingStore(QWindow *window) const

181

{

182

QOpenGLCompositorBackingStore *bs = new QOpenGLCompositorBackingStore(window);

183

if (!window->handle())

184

window->create();

185

static_cast<QEglFSWindow *>(window->handle())->setBackingStore(bs);

return bs;

}

QPlatformWindow *QEglFSIntegration::createPlatformWindow(QWindow *window) const

190

{

191

QWindowSystemInterface::flushWindowSystemEvents(QEventLoop::ExcludeUserInputEvents);

192

QEglFSWindow *w = qt_egl_device_integration()->createWindow(window);

193

w->create();

194

if (window->type() != Qt::ToolTip)

195

w->requestActivateWindow();

return w;

}

QPlatformOpenGLContext *QEglFSIntegration::createPlatformOpenGLContext(QOpenGLContext *context) const

200

{

201

EGLDisplay dpy = context->screen() ? static_cast<QEglFSScreen *>(context->screen()->handle())->display() : display();

202

QPlatformOpenGLContext *share = context->shareHandle();

203

QVariant nativeHandle = context->nativeHandle();

204

205

QEglFSContext *ctx;

206

QSurfaceFormat adjustedFormat = qt_egl_device_integration()->surfaceFormatFor(context->format());

207

if (nativeHandle.isNull()) {

208

EGLConfig config = QEglFSIntegration::chooseConfig(dpy, adjustedFormat);

209

ctx = new QEglFSContext(adjustedFormat, share, dpy, &config, QVariant());

210

} else {

211

ctx = new QEglFSContext(adjustedFormat, share, dpy, 0, nativeHandle);

212

}

213

nativeHandle = QVariant::fromValue<QEGLNativeContext>(QEGLNativeContext(ctx->eglContext(), dpy));

214

215

context->setNativeHandle(nativeHandle);

return ctx;

}

QPlatformOffscreenSurface *QEglFSIntegration::createPlatformOffscreenSurface(QOffscreenSurface *surface) const

220

{

221

EGLDisplay dpy = surface->screen() ? static_cast<QEglFSScreen *>(surface->screen()->handle())->display() : display();

222

QSurfaceFormat fmt = qt_egl_device_integration()->surfaceFormatFor(surface->requestedFormat());

223

if (qt_egl_device_integration()->supportsPBuffers()) {

224

QEGLPlatformContext::Flags flags = 0;

225

if (!qt_egl_device_integration()->supportsSurfacelessContexts())

226

flags |= QEGLPlatformContext::NoSurfaceless;

227

return new QEGLPbuffer(dpy, fmt, surface, flags);

228

} else {

229

return new QEglFSOffscreenWindow(dpy, fmt, surface);

230

}

231

// Never return null. Multiple QWindows are not supported by this plugin.

232

}

233

234

bool QEglFSIntegration::hasCapability(QPlatformIntegration::Capability cap) const

235

{

236

// We assume that devices will have more and not less capabilities

237

if (qt_egl_device_integration()->hasCapability(cap))

return true;

switch (cap) {

case ThreadedPixmaps: return true;

242

case OpenGL: return true;

243

case ThreadedOpenGL: return true;

244

case WindowManagement: return false;

245

case RasterGLSurface: return true;

246

default: return QPlatformIntegration::hasCapability(cap);

}

}

QPlatformNativeInterface *QEglFSIntegration::nativeInterface() const

251

{

252

return const_cast<QEglFSIntegration *>(this);

}

enum ResourceType {

EglDisplay,

EglWindow,

EglContext,

EglConfig,

NativeDisplay,

XlibDisplay,

WaylandDisplay

};

static int resourceType(const QByteArray &key)

266

{

267

static const QByteArray names[] = { // match ResourceType

268

QByteArrayLiteral("egldisplay"),

269

QByteArrayLiteral("eglwindow"),

270

QByteArrayLiteral("eglcontext"),

271

QByteArrayLiteral("eglconfig"),

272

QByteArrayLiteral("nativedisplay"),

273

QByteArrayLiteral("display"),

274

QByteArrayLiteral("server_wl_display")

275

};

276

const QByteArray *end = names + sizeof(names) / sizeof(names[0]);

277

const QByteArray *result = std::find(names, end, key);

278

if (result == end)

279

result = std::find(names, end, key.toLower());

280

return int(result - names);

281

}

282

283

void *QEglFSIntegration::nativeResourceForIntegration(const QByteArray &resource)

{

void *result = 0;

switch (resourceType(resource)) {

case EglDisplay:

result = display();

break;

case NativeDisplay:

result = reinterpret_cast<void*>(nativeDisplay());

293

break;

294

case WaylandDisplay:

295

result = qt_egl_device_integration()->wlDisplay();

break;

default:

break;

}

return result;

}

void *QEglFSIntegration::nativeResourceForScreen(const QByteArray &resource, QScreen *)

{

void *result = 0;

switch (resourceType(resource)) {

309

case XlibDisplay:

310

// Play nice when using the x11 hooks: Be compatible with xcb that allows querying

311

// the X Display pointer, which is nothing but our native display.

312

result = reinterpret_cast<void*>(nativeDisplay());

break;

default:

break;

}

return result;

}

void *QEglFSIntegration::nativeResourceForWindow(const QByteArray &resource, QWindow *window)

{

void *result = 0;

switch (resourceType(resource)) {

326

case EglDisplay:

327

if (window && window->handle())

328

result = static_cast<QEglFSScreen *>(window->handle()->screen())->display();

else

result = display();

break;

case EglWindow:

if (window && window->handle())

334

result = reinterpret_cast<void*>(static_cast<QEglFSWindow *>(window->handle())->eglWindow());

break;

default:

break;

}

return result;

}

void *QEglFSIntegration::nativeResourceForContext(const QByteArray &resource, QOpenGLContext *context)

{

void *result = 0;

switch (resourceType(resource)) {

348

case EglContext:

349

if (context->handle())

350

result = static_cast<QEglFSContext *>(context->handle())->eglContext();

351

break;

352

case EglConfig:

353

if (context->handle())

354

result = static_cast<QEglFSContext *>(context->handle())->eglConfig();

355

break;

356

case EglDisplay:

357

if (context->handle())

358

result = static_cast<QEglFSContext *>(context->handle())->eglDisplay();

break;

default:

break;

}

return result;

}

static void *eglContextForContext(QOpenGLContext *context)

{

Q_ASSERT(context);

QEglFSContext *handle = static_cast<QEglFSContext *>(context->handle());

if (!handle)

return 0;

return handle->eglContext();

376

}

377

378

QPlatformNativeInterface::NativeResourceForContextFunction QEglFSIntegration::nativeResourceFunctionForContext(const QByteArray &resource)

379

{

380

QByteArray lowerCaseResource = resource.toLower();

381

if (lowerCaseResource == "get_egl_context")

382

return NativeResourceForContextFunction(eglContextForContext);

return 0;

}

QFunctionPointer QEglFSIntegration::platformFunction(const QByteArray &function) const

388

{

389

#if !defined(QT_NO_EVDEV) && (!!defined(Q_OS_ANDROID)

390

|| defined(Q_OS_ANDROID_NO_SDK))if (function == QEglFSFunctions::loadKeymapTypeIdentifier())

function == QE...peIdentifier()	Description
TRUE	never evaluated
FALSE	never evaluated

391

return QFunctionPointer(loadKeymapStatic);

never executed: return QFunctionPointer(loadKeymapStatic);

#else

Q_UNUSED(function)

#endif

return 0;

never executed: return 0;

397

}

398

399

void QEglFSIntegration::loadKeymapStatic(const QString &filename)

400

{

401

#if !defined(QT_NO_EVDEV) && (!!defined(Q_OS_ANDROID)

402

|| defined(Q_OS_ANDROID_NO_SDK))QEglFSIntegration *self = static_cast<QEglFSIntegration *>(QGuiApplicationPrivate::platformIntegration());

403

if (self->m_kbdMgr)

self->m_kbdMgr	Description
TRUE	never evaluated
FALSE	never evaluated

404

self->m_kbdMgr->loadKeymap(filename);

never executed: self->m_kbdMgr->loadKeymap(filename);

405

else

406

qWarning("QEglFSIntegration: Cannot load keymap, no keyboard handler found");

never executed:

QMessageLogger(__FILE__, 406, __PRETTY_FUNCTION__).warning("QEglFSIntegration: Cannot load keymap, no keyboard handler found");

#else

Q_UNUSED(filename);

#endif

}

void QEglFSIntegration::createInputHandlers()

413

{

414

#ifndef QT_NO_LIBINPUT

415

if (!qEnvironmentVariableIntValue("QT_QPA_EGLFS_NO_LIBINPUT")) {

416

new QLibInputHandler(QLatin1String("libinput"), QString());

return;

}

#endif

bool useTslib = false;

422

#ifndef QT_NO_TSLIB

423

useTslib = qEnvironmentVariableIntValue("QT_QPA_EGLFS_TSLIB");

424

if (useTslib)

425

new QTsLibMouseHandler(QLatin1String("TsLib"), QString() /* spec */);

426

#endif

427

428

#if !defined(QT_NO_EVDEV) && (!!defined(Q_OS_ANDROID)|| defined(Q_OS_ANDROID_NO_SDK))

429

m_kbdMgr = new QEvdevKeyboardManager(QLatin1String("EvdevKeyboard"), QString() /* spec */, this);

430

new QEvdevMouseManager(QLatin1String("EvdevMouse"), QString() /* spec */, this);

431

if (!useTslib)

!useTslib	Description
TRUE	never evaluated
FALSE	never evaluated

432

new QEvdevTouchManager(QLatin1String("EvdevTouch"), QString() /* spec */, this);

never executed: new QEvdevTouchManager(QLatin1String("EvdevTouch"), QString() , this);

433

#endif

434

}

never executed: end of block

435

436

EGLNativeDisplayType QEglFSIntegration::nativeDisplay() const

437

{

438

return qt_egl_device_integration()->platformDisplay();

439

}

440

441

EGLConfig QEglFSIntegration::chooseConfig(EGLDisplay display, const QSurfaceFormat &format)

442

{

443

class Chooser : public QEglConfigChooser {

444

public:

445

Chooser(EGLDisplay display)

446

: QEglConfigChooser(display) { }

447

bool filterConfig(EGLConfig config) const Q_DECL_OVERRIDE {

448

return qt_egl_device_integration()->filterConfig(display(), config)

449

&& QEglConfigChooser::filterConfig(config);

}

};

Chooser chooser(display);

454

chooser.setSurfaceType(qt_egl_device_integration()->surfaceType());

455

chooser.setSurfaceFormat(format);

456

return chooser.chooseConfig();

457

}

458

459

QT_END_NAMESPACE

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9