1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qplatformintegration_qpa.h"
#include <QtGui/QPlatformFontDatabase>
QT_BEGIN_NAMESPACE
QPixmap QPlatformIntegration::grabWindow(WId window, int x, int y, int width, int height) const
{
Q_UNUSED(window);
Q_UNUSED(x);
Q_UNUSED(y);
Q_UNUSED(width);
Q_UNUSED(height);
return QPixmap();
}
/*!
Factory function for the eventloop integration interface.
Default implementation returns 0, which causes the eventloop to run in a single thread mode.
\sa QPlatformEventLoopIntegration
*/
QPlatformEventLoopIntegration *QPlatformIntegration::createEventLoopIntegration() const
{
return 0;
}
/*!
Returns whether the given platform integration supports OpenGL.
Default implementation returns false,
*/
bool QPlatformIntegration::hasOpenGL() const
{
return false;
}
/*!
Accessor for the platform integrations fontdatabase.
Default implementation returns a default QPlatformFontDatabase.
\sa QPlatformFontDatabase
*/
QPlatformFontDatabase *QPlatformIntegration::fontDatabase() const
{
static QPlatformFontDatabase *db = 0;
if (!db) {
db = new QPlatformFontDatabase;
}
return db;
}
/*!
\class QPlatformIntegration
\since 4.8
\internal
\preliminary
\ingroup qpa
\brief The QPlatformIntegration class is the entry for WindowSystem specific functionality.
QPlatformIntegration is the single entry point for windowsystem specific functionality when
using the QPA platform. It has factory functions for creating platform specific pixmaps and
windows. The class also controls the font subsystem.
QPlatformIntegration is a singelton class which gets instansiated in the QApplication
constructor. The QPlatformIntegration instance do not have ownership of objects it creates in
functions where the name starts with create. However, functions which don't have a name
starting with create acts as assessors to member variables.
It is not trivial to create or build a platform plugin outside of the Qt source tree. Therefor
the recommended approach for making new platform plugin is to copy an existing plugin inside
the QTSRCTREE/src/plugins/platform and develop the plugin inside the source tree.
The minimal platformintegration is the smallest platform integration it is possible to make,
which makes it an ideal starting point for new plugins. For a slightly more advanced plugin,
consider reviewing the directfb plugin, or the testlite plugin.
*/
/*!
\fn QPixmapData *createPixmapData(QPixmapData::PixelType type) const
Factory function for QPixmapData. PixelType can be either PixmapType or BitmapType.
\sa QPixmapData
*/
/*!
\fn QPlatformWindow *createPlatformWindow(QWidget *widget, WId winId = 0) const
Factory function for QPlatformWindow. The widget parameter is a pointer to the top level
widget(tlw) which the QPlatformWindow is suppose to be created for. The WId handle is actually
never used, but there for future reference. Its purpose is if it is going to be possible to
create QPlatformWindows on existing WId.
All tlw has to have a QPlatformWindow, and it will be created when the QPlatformWindow is set
to be visible for the first time. If the tlw's window flags are changed, or if the tlw's
QPlatformWindowFormat is changed, then the tlw's QPlatformWindow is deleted and a new one is
created.
\sa QPlatformWindow, QPlatformWindowFormat
\sa createWindowSurface(QWidget *widget, WId winId) const
*/
/*!
\fn QWindowSurface *createWindowSurface(QWidget *widget, WId winId) const
Factory function for QWindowSurface. The QWidget parameter is a pointer to the
top level widget(tlw) the window surface is created for. A QPlatformWindow is always created
before the QWindowSurface for tlw where the widget also requires a WindowSurface. It is
possible to create top level QWidgets without a QWindowSurface by specifying
QPlatformWindowFormat::setWindowSurface(false) for the tlw QPlatformWindowFormat.
\sa QWindowSurface
\sa createPlatformWindow(QWidget *widget, WId winId = 0) const
*/
/*!
\fn void moveToScreen(QWidget *window, int screen)
This function is called when a QWidget is displayed on screen, or the QWidget is to be
displayed on a new screen. The QWidget parameter is a pointer to the top level widget and
the int parameter is the index to the screen in QList<QPlatformScreen *> screens() const.
Default implementation does nothing.
\sa screens() const
*/
/*!
\fn QList<QPlatformScreen *> screens() const
Accessor function to a list of all the screens on the current system. The screen with the
index == 0 is the default/main screen.
*/
/*!
\fn bool isVirtualDesktop()
Returns if the current windowing system configuration defines all the screens to be one
desktop(virtual desktop), or if each screen is a desktop of its own.
Default implementation returns false.
*/
/*!
\fn QPixmap grabWindow(WId window, int x, int y, int width, int height) const
This function is called when Qt needs to be able to grab the content of a window.
Returnes the content of the window specified with the WId handle within the boundaries of
QRect(x,y,width,height).
*/
QT_END_NAMESPACE
|
