KWindowSystem

kwindowinfo.cpp
1/*
2 SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
3
4 SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
5*/
6
7#include "kwindowinfo.h"
8#include "kwindowsystem.h"
9#include "kwindowsystem_debug.h"
10#include "kx11extras.h"
11#include "netwm.h"
12
13#include <config-kwindowsystem.h>
14
15#include "private/qtx11extras_p.h"
16#include <QDebug>
17#include <QRect>
18
19#include "kxerrorhandler_p.h"
20#include <X11/Xatom.h>
21#include <X11/Xlib.h>
22#include <xcb/res.h>
23
24#include "cptr_p.h"
25
26static bool haveXRes()
27{
28 static bool s_checked = false;
29 static bool s_haveXRes = false;
30 if (!s_checked) {
31 auto cookie = xcb_res_query_version(QX11Info::connection(), XCB_RES_MAJOR_VERSION, XCB_RES_MINOR_VERSION);
32 UniqueCPointer<xcb_res_query_version_reply_t> reply(xcb_res_query_version_reply(QX11Info::connection(), cookie, nullptr));
33 s_haveXRes = reply != nullptr;
34 s_checked = true;
35 }
36 return s_haveXRes;
37}
38
39class Q_DECL_HIDDEN KWindowInfoPrivate : public QSharedData
40{
41public:
42 WId window;
44 NET::Properties2 properties2;
45
46 std::unique_ptr<NETWinInfo> m_info;
47 QString m_name;
48 QString m_iconic_name;
49 QRect m_geometry;
50 QRect m_frame_geometry;
51 int m_pid = -1; // real PID from XResources. Valid if > 0
52 bool m_valid = false;
53};
54
55KWindowInfo::KWindowInfo(WId window, NET::Properties properties, NET::Properties2 properties2)
56 : d(new KWindowInfoPrivate)
57{
58 d->window = window;
59 d->properties = properties;
60 d->properties2 = properties2;
61
62 if (!KWindowSystem::isPlatformX11()) {
63 return;
64 }
65
66 KXErrorHandler handler;
67 if (properties & NET::WMVisibleIconName) {
68 properties |= NET::WMIconName | NET::WMVisibleName; // force, in case it will be used as a fallback
69 }
70 if (properties & NET::WMVisibleName) {
71 properties |= NET::WMName; // force, in case it will be used as a fallback
72 }
73 if (properties2 & NET::WM2ExtendedStrut) {
74 properties |= NET::WMStrut; // will be used as fallback
75 }
76 if (properties & NET::WMWindowType) {
77 properties2 |= NET::WM2TransientFor; // will be used when type is not set
78 }
79 if ((properties & NET::WMDesktop) && KX11Extras::mapViewport()) {
80 properties |= NET::WMGeometry; // for viewports, the desktop (workspace) is determined from the geometry
81 }
82 properties |= NET::XAWMState; // force to get error detection for valid()
83 d->m_info.reset(new NETWinInfo(QX11Info::connection(), d->window, QX11Info::appRootWindow(), properties, properties2));
84 if (properties & NET::WMName) {
85 if (d->m_info->name() && d->m_info->name()[0] != '\0') {
86 d->m_name = QString::fromUtf8(d->m_info->name());
87 } else {
88 d->m_name = KX11Extras::readNameProperty(d->window, XA_WM_NAME);
89 }
90 }
91 if (properties & NET::WMIconName) {
92 if (d->m_info->iconName() && d->m_info->iconName()[0] != '\0') {
93 d->m_iconic_name = QString::fromUtf8(d->m_info->iconName());
94 } else {
95 d->m_iconic_name = KX11Extras::readNameProperty(d->window, XA_WM_ICON_NAME);
96 }
97 }
98 if (properties & (NET::WMGeometry | NET::WMFrameExtents)) {
99 NETRect frame;
100 NETRect geom;
101 d->m_info->kdeGeometry(frame, geom);
102 d->m_geometry.setRect(geom.pos.x, geom.pos.y, geom.size.width, geom.size.height);
103 d->m_frame_geometry.setRect(frame.pos.x, frame.pos.y, frame.size.width, frame.size.height);
104 }
105 d->m_valid = !handler.error(false); // no sync - NETWinInfo did roundtrips
106
107 if (haveXRes()) {
108 xcb_res_client_id_spec_t specs;
109 specs.client = win();
110 specs.mask = XCB_RES_CLIENT_ID_MASK_LOCAL_CLIENT_PID;
111 auto cookie = xcb_res_query_client_ids(QX11Info::connection(), 1, &specs);
112
113 UniqueCPointer<xcb_res_query_client_ids_reply_t> reply(xcb_res_query_client_ids_reply(QX11Info::connection(), cookie, nullptr));
114 if (reply && xcb_res_query_client_ids_ids_length(reply.get()) > 0) {
115 uint32_t pid = *xcb_res_client_id_value_value((xcb_res_query_client_ids_ids_iterator(reply.get()).data));
116 d->m_pid = pid;
117 }
118 }
119}
120
122 : d(other.d)
123{
124}
125
126KWindowInfo::~KWindowInfo()
127{
128}
129
131{
132 if (d != other.d) {
133 d = other.d;
134 }
135 return *this;
136}
137
138bool KWindowInfo::valid(bool withdrawn_is_valid) const
139{
140 if (!KWindowSystem::isPlatformX11()) {
141 return false;
142 }
143
144 if (!d->m_valid) {
145 return false;
146 }
147 if (!withdrawn_is_valid && mappingState() == NET::Withdrawn) {
148 return false;
149 }
150 return true;
151}
152
154{
155 return d->window;
156}
157
158#define CHECK_X11 \
159 if (!KWindowSystem::isPlatformX11()) { \
160 qCWarning(LOG_KWINDOWSYSTEM) << "KWindowInfo is only functional when running on X11"; \
161 return {}; \
162 }
163
165{
166 CHECK_X11
167#if !defined(KDE_NO_WARNING_OUTPUT)
168 if (!(d->m_info->passedProperties() & NET::WMState)) {
169 qWarning() << "Pass NET::WMState to KWindowInfo";
170 }
171#endif
172 return d->m_info->state();
173}
174
176{
177 CHECK_X11
178 return (state() & s) == s;
179}
180
181bool KWindowInfo::icccmCompliantMappingState() const
182{
183 CHECK_X11
184 static enum { noidea, yes, no } wm_is_1_2_compliant = noidea;
185 if (wm_is_1_2_compliant == noidea) {
186 NETRootInfo info(QX11Info::connection(), NET::Supported, NET::Properties2(), QX11Info::appScreen());
187 wm_is_1_2_compliant = info.isSupported(NET::Hidden) ? yes : no;
188 }
189 return wm_is_1_2_compliant == yes;
190}
191
192// see NETWM spec section 7.6
194{
195 CHECK_X11
196 if (mappingState() != NET::Iconic) {
197 return false;
198 }
199 // NETWM 1.2 compliant WM - uses NET::Hidden for minimized windows
200 if ((state() & NET::Hidden) != 0 && (state() & NET::Shaded) == 0) { // shaded may have NET::Hidden too
201 return true;
202 }
203 // older WMs use WithdrawnState for other virtual desktops
204 // and IconicState only for minimized
205 return icccmCompliantMappingState() ? false : true;
206}
207
209{
210 CHECK_X11
211#if !defined(KDE_NO_WARNING_OUTPUT)
212 if (!(d->m_info->passedProperties() & NET::XAWMState)) {
213 qWarning() << "Pass NET::XAWMState to KWindowInfo";
214 }
215#endif
216 return d->m_info->mappingState();
217}
218
220{
221 CHECK_X11
222#if !defined(KDE_NO_WARNING_OUTPUT)
223 if (!(d->m_info->passedProperties2() & NET::WM2ExtendedStrut)) {
224 qWarning() << "Pass NET::WM2ExtendedStrut to KWindowInfo";
225 }
226#endif
227 NETExtendedStrut ext = d->m_info->extendedStrut();
228 NETStrut str = d->m_info->strut();
229 if (ext.left_width == 0 && ext.right_width == 0 && ext.top_width == 0 && ext.bottom_width == 0
230 && (str.left != 0 || str.right != 0 || str.top != 0 || str.bottom != 0)) {
231 // build extended from simple
232 if (str.left != 0) {
233 ext.left_width = str.left;
234 ext.left_start = 0;
235 ext.left_end = XDisplayHeight(QX11Info::display(), DefaultScreen(QX11Info::display()));
236 }
237 if (str.right != 0) {
238 ext.right_width = str.right;
239 ext.right_start = 0;
240 ext.right_end = XDisplayHeight(QX11Info::display(), DefaultScreen(QX11Info::display()));
241 }
242 if (str.top != 0) {
243 ext.top_width = str.top;
244 ext.top_start = 0;
245 ext.top_end = XDisplayWidth(QX11Info::display(), DefaultScreen(QX11Info::display()));
246 }
247 if (str.bottom != 0) {
248 ext.bottom_width = str.bottom;
249 ext.bottom_start = 0;
250 ext.bottom_end = XDisplayWidth(QX11Info::display(), DefaultScreen(QX11Info::display()));
251 }
252 }
253 return ext;
254}
255
257{
258 CHECK_X11
259#if !defined(KDE_NO_WARNING_OUTPUT)
260 if (!(d->m_info->passedProperties() & NET::WMWindowType)) {
261 qWarning() << "Pass NET::WMWindowType to KWindowInfo";
262 }
263#endif
264 if (!d->m_info->hasWindowType()) { // fallback, per spec recommendation
265 if (transientFor() != XCB_WINDOW_NONE) { // dialog
266 if (supported_types & NET::DialogMask) {
267 return NET::Dialog;
268 }
269 } else {
270 if (supported_types & NET::NormalMask) {
271 return NET::Normal;
272 }
273 }
274 }
275 return d->m_info->windowType(supported_types);
276}
277
279{
280 CHECK_X11
281#if !defined(KDE_NO_WARNING_OUTPUT)
282 if (!(d->m_info->passedProperties() & NET::WMVisibleName)) {
283 qWarning() << "Pass NET::WMVisibleName to KWindowInfo";
284 }
285#endif
286 return d->m_info->visibleName() && d->m_info->visibleName()[0] != '\0' ? QString::fromUtf8(d->m_info->visibleName()) : name();
287}
288
290{
291 CHECK_X11
292 QString s = visibleName();
293 if (isMinimized()) {
294 s.prepend(QLatin1Char('('));
295 s.append(QLatin1Char(')'));
296 }
297 return s;
298}
299
301{
302 CHECK_X11
303#if !defined(KDE_NO_WARNING_OUTPUT)
304 if (!(d->m_info->passedProperties() & NET::WMName)) {
305 qWarning() << "Pass NET::WMName to KWindowInfo";
306 }
307#endif
308 return d->m_name;
309}
310
312{
313 CHECK_X11
314#if !defined(KDE_NO_WARNING_OUTPUT)
315 if (!(d->m_info->passedProperties() & NET::WMVisibleIconName)) {
316 qWarning() << "Pass NET::WMVisibleIconName to KWindowInfo";
317 }
318#endif
319 if (d->m_info->visibleIconName() && d->m_info->visibleIconName()[0] != '\0') {
320 return QString::fromUtf8(d->m_info->visibleIconName());
321 }
322 if (d->m_info->iconName() && d->m_info->iconName()[0] != '\0') {
323 return QString::fromUtf8(d->m_info->iconName());
324 }
325 if (!d->m_iconic_name.isEmpty()) {
326 return d->m_iconic_name;
327 }
328 return visibleName();
329}
330
332{
333 CHECK_X11
335 if (isMinimized()) {
336 s.prepend(QLatin1Char('('));
337 s.append(QLatin1Char(')'));
338 }
339 return s;
340}
341
343{
344 CHECK_X11
345#if !defined(KDE_NO_WARNING_OUTPUT)
346 if (!(d->m_info->passedProperties() & NET::WMIconName)) {
347 qWarning() << "Pass NET::WMIconName to KWindowInfo";
348 }
349#endif
350 if (d->m_info->iconName() && d->m_info->iconName()[0] != '\0') {
351 return QString::fromUtf8(d->m_info->iconName());
352 }
353 if (!d->m_iconic_name.isEmpty()) {
354 return d->m_iconic_name;
355 }
356 return name();
357}
358
360{
361 CHECK_X11
363}
364
365bool KWindowInfo::isOnDesktop(int desktop) const
366{
367 CHECK_X11
368#if !defined(KDE_NO_WARNING_OUTPUT)
369 if (!(d->m_info->passedProperties() & NET::WMDesktop)) {
370 qWarning() << "Pass NET::WMDesktop to KWindowInfo";
371 }
372#endif
374 if (onAllDesktops()) {
375 return true;
376 }
377 return KX11Extras::viewportWindowToDesktop(d->m_geometry) == desktop;
378 }
379 return d->m_info->desktop() == desktop || d->m_info->desktop() == NET::OnAllDesktops;
380}
381
383{
384 CHECK_X11
385#if !defined(KDE_NO_WARNING_OUTPUT)
386 if (!(d->m_info->passedProperties() & NET::WMDesktop)) {
387 qWarning() << "Pass NET::WMDesktop to KWindowInfo";
388 }
389#endif
391 if (d->m_info->passedProperties() & NET::WMState) {
392 return d->m_info->state() & NET::Sticky;
393 }
394 NETWinInfo info(QX11Info::connection(), win(), QX11Info::appRootWindow(), NET::WMState, NET::Properties2());
395 return info.state() & NET::Sticky;
396 }
397 return d->m_info->desktop() == NET::OnAllDesktops;
398}
399
401{
402 CHECK_X11
403#if !defined(KDE_NO_WARNING_OUTPUT)
404 if (!(d->m_info->passedProperties() & NET::WMDesktop)) {
405 qWarning() << "Pass NET::WMDesktop to KWindowInfo";
406 }
407#endif
409 if (onAllDesktops()) {
410 return NET::OnAllDesktops;
411 }
412 return KX11Extras::viewportWindowToDesktop(d->m_geometry);
413 }
414 return d->m_info->desktop();
415}
416
418{
419 CHECK_X11
420#if !defined(KDE_NO_WARNING_OUTPUT)
421 if (!(d->m_info->passedProperties2() & NET::WM2Activities)) {
422 qWarning() << "Pass NET::WM2Activities to KWindowInfo";
423 }
424#endif
425
426 const QStringList result = QString::fromLatin1(d->m_info->activities()).split(QLatin1Char(','), Qt::SkipEmptyParts);
427
428 return result.contains(QStringLiteral(KDE_ALL_ACTIVITIES_UUID)) ? QStringList() : result;
429}
430
432{
433 CHECK_X11
434#if !defined(KDE_NO_WARNING_OUTPUT)
435 if (!(d->m_info->passedProperties() & NET::WMGeometry)) {
436 qWarning() << "Pass NET::WMGeometry to KWindowInfo";
437 }
438#endif
439 return d->m_geometry;
440}
441
443{
444 CHECK_X11
445#if !defined(KDE_NO_WARNING_OUTPUT)
446 if (!(d->m_info->passedProperties() & NET::WMFrameExtents)) {
447 qWarning() << "Pass NET::WMFrameExtents to KWindowInfo";
448 }
449#endif
450 return d->m_frame_geometry;
451}
452
454{
455 CHECK_X11
456#if !defined(KDE_NO_WARNING_OUTPUT)
457 if (!(d->m_info->passedProperties2() & NET::WM2TransientFor)) {
458 qWarning() << "Pass NET::WM2TransientFor to KWindowInfo";
459 }
460#endif
461 return d->m_info->transientFor();
462}
463
465{
466 CHECK_X11
467#if !defined(KDE_NO_WARNING_OUTPUT)
468 if (!(d->m_info->passedProperties2() & NET::WM2GroupLeader)) {
469 qWarning() << "Pass NET::WM2GroupLeader to KWindowInfo";
470 }
471#endif
472 return d->m_info->groupLeader();
473}
474
476{
477 CHECK_X11
478#if !defined(KDE_NO_WARNING_OUTPUT)
479 if (!(d->m_info->passedProperties2() & NET::WM2WindowClass)) {
480 qWarning() << "Pass NET::WM2WindowClass to KWindowInfo";
481 }
482#endif
483 return d->m_info->windowClassClass();
484}
485
487{
488 CHECK_X11
489#if !defined(KDE_NO_WARNING_OUTPUT)
490 if (!(d->m_info->passedProperties2() & NET::WM2WindowClass)) {
491 qWarning() << "Pass NET::WM2WindowClass to KWindowInfo";
492 }
493#endif
494 return d->m_info->windowClassName();
495}
496
498{
499 CHECK_X11
500#if !defined(KDE_NO_WARNING_OUTPUT)
501 if (!(d->m_info->passedProperties2() & NET::WM2WindowRole)) {
502 qWarning() << "Pass NET::WM2WindowRole to KWindowInfo";
503 }
504#endif
505 return d->m_info->windowRole();
506}
507
509{
510 CHECK_X11
511#if !defined(KDE_NO_WARNING_OUTPUT)
512 if (!(d->m_info->passedProperties2() & NET::WM2ClientMachine)) {
513 qWarning() << "Pass NET::WM2ClientMachine to KWindowInfo";
514 }
515#endif
516 return d->m_info->clientMachine();
517}
518
519bool KWindowInfo::allowedActionsSupported() const
520{
521 CHECK_X11
522 static enum { noidea, yes, no } wm_supports_allowed_actions = noidea;
523 if (wm_supports_allowed_actions == noidea) {
524 NETRootInfo info(QX11Info::connection(), NET::Supported, NET::Properties2(), QX11Info::appScreen());
525 wm_supports_allowed_actions = info.isSupported(NET::WM2AllowedActions) ? yes : no;
526 }
527 return wm_supports_allowed_actions == yes;
528}
529
531{
532 CHECK_X11
533#if !defined(KDE_NO_WARNING_OUTPUT)
534 if (!(d->m_info->passedProperties2() & NET::WM2AllowedActions)) {
535 qWarning() << "Pass NET::WM2AllowedActions to KWindowInfo";
536 }
537#endif
538 if (allowedActionsSupported()) {
539 return d->m_info->allowedActions() & action;
540 } else {
541 return true; // no idea if it's supported or not -> pretend it is
542 }
543}
544
546{
547 CHECK_X11
548#if !defined(KDE_NO_WARNING_OUTPUT)
549 if (!(d->m_info->passedProperties2() & NET::WM2DesktopFileName)) {
550 qWarning() << "Pass NET::WM2DesktopFileName to KWindowInfo";
551 }
552#endif
553 return QByteArray(d->m_info->desktopFileName());
554}
555
557{
558 CHECK_X11
559#if !defined(KDE_NO_WARNING_OUTPUT)
560 if (!(d->m_info->passedProperties2() & NET::WM2DesktopFileName)) {
561 qWarning() << "Pass NET::WM2DesktopFileName to KWindowInfo";
562 }
563#endif
564 return QByteArray(d->m_info->gtkApplicationId());
565}
566
568{
569 CHECK_X11
570#if !defined(KDE_NO_WARNING_OUTPUT)
571 if (!(d->m_info->passedProperties2() & NET::WM2AppMenuServiceName)) {
572 qWarning() << "Pass NET::WM2AppMenuServiceName to KWindowInfo";
573 }
574#endif
575 return QByteArray(d->m_info->appMenuServiceName());
576}
577
579{
580 CHECK_X11
581#if !defined(KDE_NO_WARNING_OUTPUT)
582 if (!(d->m_info->passedProperties2() & NET::WM2AppMenuObjectPath)) {
583 qWarning() << "Pass NET::WM2AppMenuObjectPath to KWindowInfo";
584 }
585#endif
586 return QByteArray(d->m_info->appMenuObjectPath());
587}
588
590{
591 CHECK_X11
592 // If pid is found using the XRes extension use that instead.
593 // It is more reliable than the app reporting it's own PID as apps
594 // within an app namespace are unable to do so correctly
595 if (d->m_pid > 0) {
596 return d->m_pid;
597 }
598
599#if !defined(KDE_NO_WARNING_OUTPUT)
600 if (!(d->m_info->passedProperties() & NET::WMPid)) {
601 qWarning() << "Pass NET::WMPid to KWindowInfo";
602 }
603#endif
604
605 return d->m_info->pid();
606}
This class provides information about a given X11 window.
Definition kwindowinfo.h:60
QString iconName() const
Returns the name of the window that should be shown in taskbar.
NETExtendedStrut extendedStrut() const
Returns the window extended (partial) strut.
bool isMinimized() const
Returns true if the window is minimized.
int pid() const
Returns the process ID of the window's application if present.
QString visibleName() const
Returns the visible name of the window.
bool valid(bool withdrawn_is_valid=false) const
Returns false if this window info is not valid.
bool actionSupported(NET::Action action) const
Returns true if the given action is currently supported for the window.
QByteArray gtkApplicationId() const
Returns the GTK application id of the window if present.
QByteArray windowClassName() const
Returns the name component of the WM_CLASS X11 property for the window.
QByteArray windowRole() const
Returns the WM_WINDOW_ROLE X11 property for the window.
QString visibleIconNameWithState() const
Returns a visible icon name with state.
bool isOnCurrentDesktop() const
Returns true if the window is on the currently active virtual desktop.
QString visibleNameWithState() const
Returns a visible name with state.
NET::States state() const
Returns the window's state flags.
bool isOnDesktop(int desktop) const
Returns true if the window is on the given virtual desktop.
WId win() const
Returns the window identifier.
bool hasState(NET::States s) const
Returns true if the window has the given state flag set.
WId transientFor() const
Returns the window identifier of the main window this window belongs to.
QByteArray applicationMenuServiceName() const
Returns service name of a window's application menu if present.
KWindowInfo & operator=(const KWindowInfo &)
Assignment operator.
QString visibleIconName() const
Returns the visible name of the window that should be shown in a taskbar.
WId groupLeader() const
Returns the leader window for the group the window is in, if any.
bool onAllDesktops() const
Returns true if the window is on all desktops.
QRect geometry() const
Returns the position and size of the window contents.
NET::WindowType windowType(NET::WindowTypes supported_types) const
Returns the window type of this window.
QByteArray desktopFileName() const
Returns the desktop file name of the window's application if present.
int desktop() const
Returns the virtual desktop this window is on.
KWindowInfo(WId window, NET::Properties properties, NET::Properties2 properties2=NET::Properties2())
Reads all the info about the given window.
QByteArray windowClassClass() const
Returns the class component of the WM_CLASS X11 property for the window.
NET::MappingState mappingState() const
Returns the mapping state of the window.
QRect frameGeometry() const
Returns the frame geometry of the window, i.e.
QStringList activities() const
Returns the list of activity UUIDs this window belongs to.
QByteArray clientMachine() const
Returns the WM_CLIENT_MACHINE property for the window.
QString name() const
Returns the name of the window, as specified by the application.
QByteArray applicationMenuObjectPath() const
Returns object path of a window's application menu if present.
static bool mapViewport()
Returns true if viewports are mapped to virtual desktops.
static QString readNameProperty(WId window, unsigned long atom)
Function that reads and returns the contents of the given text property (WM_NAME, WM_ICON_NAME,...
static int currentDesktop()
Returns the current virtual desktop.
Common API for root window properties/protocols.
Definition netwm.h:41
Common API for application window properties/protocols.
Definition netwm.h:967
NET::States state() const
Returns the state of the window (see the NET base class documentation for a description of the variou...
Definition netwm.cpp:4608
@ Sticky
indicates that the Window Manager SHOULD keep the window's position fixed on the screen,...
Definition netwm_def.h:515
@ Shaded
indicates that the window is shaded (rolled-up).
Definition netwm_def.h:531
@ Hidden
indicates that a window should not be visible on the screen (e.g.
Definition netwm_def.h:549
@ DialogMask
Definition netwm_def.h:459
@ NormalMask
Definition netwm_def.h:454
WindowType
Window type.
Definition netwm_def.h:357
@ Normal
indicates that this is a normal, top-level window
Definition netwm_def.h:365
@ Dialog
indicates that this is a dialog window
Definition netwm_def.h:388
Action
Actions that can be done with a window (_NET_WM_ALLOWED_ACTIONS).
Definition netwm_def.h:644
MappingState
Client window mapping state.
Definition netwm_def.h:623
@ Iconic
indicates that the client window is not visible, but its icon is.
Definition netwm_def.h:637
@ Withdrawn
indicates that neither the client window nor its icon is visible.
Definition netwm_def.h:631
KGUIADDONS_EXPORT QWindow * window(QObject *job)
KGuiItem properties()
QString fromLatin1(QByteArrayView str)
QString fromUtf8(QByteArrayView str)
QStringList split(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const const
bool contains(QLatin1StringView str, Qt::CaseSensitivity cs) const const
SkipEmptyParts
Partial strut class for NET classes.
Definition netwm_def.h:180
int bottom_width
Bottom border of the strut, width and range.
Definition netwm_def.h:218
int left_width
Left border of the strut, width and range.
Definition netwm_def.h:203
int right_width
Right border of the strut, width and range.
Definition netwm_def.h:208
int top_width
Top border of the strut, width and range.
Definition netwm_def.h:213
int x
x coordinate.
Definition netwm_def.h:51
int y
y coordinate
Definition netwm_def.h:52
Simple rectangle class for NET classes.
Definition netwm_def.h:105
NETPoint pos
Position of the rectangle.
Definition netwm_def.h:126
NETSize size
Size of the rectangle.
Definition netwm_def.h:133
int height
Height.
Definition netwm_def.h:92
int width
Width.
Definition netwm_def.h:91
int bottom
Bottom border of the strut.
Definition netwm_def.h:262
int left
Left border of the strut.
Definition netwm_def.h:247
int right
Right border of the strut.
Definition netwm_def.h:252
int top
Top border of the strut.
Definition netwm_def.h:257
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Fri Jul 19 2024 11:59:12 by doxygen 1.11.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.