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;
43 NET::Properties properties;
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
121KWindowInfo::KWindowInfo(const KWindowInfo &other)
122 : d(other.d)
123{
124}
125
126KWindowInfo::~KWindowInfo()
127{
128}
129
130KWindowInfo &KWindowInfo::operator=(const KWindowInfo &other)
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
153WId KWindowInfo::win() const
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
164NET::States KWindowInfo::state() const
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
175bool KWindowInfo::hasState(NET::States s) const
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
193bool KWindowInfo::isMinimized() const
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
208NET::MappingState KWindowInfo::mappingState() const
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
219NETExtendedStrut KWindowInfo::extendedStrut() const
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
256NET::WindowType KWindowInfo::windowType(NET::WindowTypes supported_types) const
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
278QString KWindowInfo::visibleName() const
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
289QString KWindowInfo::visibleNameWithState() const
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
300QString KWindowInfo::name() const
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
311QString KWindowInfo::visibleIconName() const
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
331QString KWindowInfo::visibleIconNameWithState() const
332{
333 CHECK_X11
334 QString s = visibleIconName();
335 if (isMinimized()) {
336 s.prepend(QLatin1Char('('));
337 s.append(QLatin1Char(')'));
338 }
339 return s;
340}
341
342QString KWindowInfo::iconName() const
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
359bool KWindowInfo::isOnCurrentDesktop() const
360{
361 CHECK_X11
362 return isOnDesktop(KX11Extras::currentDesktop());
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
373 if (KX11Extras::mapViewport()) {
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
382bool KWindowInfo::onAllDesktops() const
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
390 if (KX11Extras::mapViewport()) {
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
400int KWindowInfo::desktop() const
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
408 if (KX11Extras::mapViewport()) {
409 if (onAllDesktops()) {
410 return NET::OnAllDesktops;
411 }
412 return KX11Extras::viewportWindowToDesktop(d->m_geometry);
413 }
414 return d->m_info->desktop();
415}
416
417QStringList KWindowInfo::activities() const
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
431QRect KWindowInfo::geometry() const
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
442QRect KWindowInfo::frameGeometry() const
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
453WId KWindowInfo::transientFor() const
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
464WId KWindowInfo::groupLeader() const
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
475QByteArray KWindowInfo::windowClassClass() const
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
486QByteArray KWindowInfo::windowClassName() const
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
497QByteArray KWindowInfo::windowRole() const
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
508QByteArray KWindowInfo::clientMachine() const
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
530bool KWindowInfo::actionSupported(NET::Action action) const
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
545QByteArray KWindowInfo::desktopFileName() const
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
556QByteArray KWindowInfo::gtkApplicationId() const
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
567QByteArray KWindowInfo::applicationMenuServiceName() const
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
578QByteArray KWindowInfo::applicationMenuObjectPath() const
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
589int KWindowInfo::pid() const
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}
KWindowInfo
This class provides information about a given X11 window.
Definition kwindowinfo.h:60
KWindowInfo::iconName
QString iconName() const
Returns the name of the window that should be shown in taskbar.
Definition kwindowinfo.cpp:342
KWindowInfo::extendedStrut
NETExtendedStrut extendedStrut() const
Returns the window extended (partial) strut.
Definition kwindowinfo.cpp:219
KWindowInfo::isMinimized
bool isMinimized() const
Returns true if the window is minimized.
Definition kwindowinfo.cpp:193
KWindowInfo::pid
int pid() const
Returns the process ID of the window's application if present.
Definition kwindowinfo.cpp:589
KWindowInfo::visibleName
QString visibleName() const
Returns the visible name of the window.
Definition kwindowinfo.cpp:278
KWindowInfo::valid
bool valid(bool withdrawn_is_valid=false) const
Returns false if this window info is not valid.
Definition kwindowinfo.cpp:138
KWindowInfo::actionSupported
bool actionSupported(NET::Action action) const
Returns true if the given action is currently supported for the window.
Definition kwindowinfo.cpp:530
KWindowInfo::gtkApplicationId
QByteArray gtkApplicationId() const
Returns the GTK application id of the window if present.
Definition kwindowinfo.cpp:556
KWindowInfo::windowClassName
QByteArray windowClassName() const
Returns the name component of the WM_CLASS X11 property for the window.
Definition kwindowinfo.cpp:486
KWindowInfo::windowRole
QByteArray windowRole() const
Returns the WM_WINDOW_ROLE X11 property for the window.
Definition kwindowinfo.cpp:497
KWindowInfo::visibleIconNameWithState
QString visibleIconNameWithState() const
Returns a visible icon name with state.
Definition kwindowinfo.cpp:331
KWindowInfo::isOnCurrentDesktop
bool isOnCurrentDesktop() const
Returns true if the window is on the currently active virtual desktop.
Definition kwindowinfo.cpp:359
KWindowInfo::visibleNameWithState
QString visibleNameWithState() const
Returns a visible name with state.
Definition kwindowinfo.cpp:289
KWindowInfo::state
NET::States state() const
Returns the window's state flags.
Definition kwindowinfo.cpp:164
KWindowInfo::isOnDesktop
bool isOnDesktop(int desktop) const
Returns true if the window is on the given virtual desktop.
Definition kwindowinfo.cpp:365
KWindowInfo::win
WId win() const
Returns the window identifier.
Definition kwindowinfo.cpp:153
KWindowInfo::hasState
bool hasState(NET::States s) const
Returns true if the window has the given state flag set.
Definition kwindowinfo.cpp:175
KWindowInfo::transientFor
WId transientFor() const
Returns the window identifier of the main window this window belongs to.
Definition kwindowinfo.cpp:453
KWindowInfo::applicationMenuServiceName
QByteArray applicationMenuServiceName() const
Returns service name of a window's application menu if present.
Definition kwindowinfo.cpp:567
KWindowInfo::operator=
KWindowInfo & operator=(const KWindowInfo &)
Assignment operator.
Definition kwindowinfo.cpp:130
KWindowInfo::visibleIconName
QString visibleIconName() const
Returns the visible name of the window that should be shown in a taskbar.
Definition kwindowinfo.cpp:311
KWindowInfo::groupLeader
WId groupLeader() const
Returns the leader window for the group the window is in, if any.
Definition kwindowinfo.cpp:464
KWindowInfo::onAllDesktops
bool onAllDesktops() const
Returns true if the window is on all desktops.
Definition kwindowinfo.cpp:382
KWindowInfo::geometry
QRect geometry() const
Returns the position and size of the window contents.
Definition kwindowinfo.cpp:431
KWindowInfo::windowType
NET::WindowType windowType(NET::WindowTypes supported_types) const
Returns the window type of this window.
Definition kwindowinfo.cpp:256
KWindowInfo::desktopFileName
QByteArray desktopFileName() const
Returns the desktop file name of the window's application if present.
Definition kwindowinfo.cpp:545
KWindowInfo::desktop
int desktop() const
Returns the virtual desktop this window is on.
Definition kwindowinfo.cpp:400
KWindowInfo::KWindowInfo
KWindowInfo(WId window, NET::Properties properties, NET::Properties2 properties2=NET::Properties2())
Reads all the info about the given window.
Definition kwindowinfo.cpp:55
KWindowInfo::windowClassClass
QByteArray windowClassClass() const
Returns the class component of the WM_CLASS X11 property for the window.
Definition kwindowinfo.cpp:475
KWindowInfo::mappingState
NET::MappingState mappingState() const
Returns the mapping state of the window.
Definition kwindowinfo.cpp:208
KWindowInfo::frameGeometry
QRect frameGeometry() const
Returns the frame geometry of the window, i.e.
Definition kwindowinfo.cpp:442
KWindowInfo::activities
QStringList activities() const
Returns the list of activity UUIDs this window belongs to.
Definition kwindowinfo.cpp:417
KWindowInfo::clientMachine
QByteArray clientMachine() const
Returns the WM_CLIENT_MACHINE property for the window.
Definition kwindowinfo.cpp:508
KWindowInfo::name
QString name() const
Returns the name of the window, as specified by the application.
Definition kwindowinfo.cpp:300
KWindowInfo::applicationMenuObjectPath
QByteArray applicationMenuObjectPath() const
Returns object path of a window's application menu if present.
Definition kwindowinfo.cpp:578
KX11Extras::mapViewport
static bool mapViewport()
Returns true if viewports are mapped to virtual desktops.
Definition kx11extras.cpp:1040
KX11Extras::readNameProperty
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,...
Definition kx11extras.cpp:1015
KX11Extras::currentDesktop
static int currentDesktop()
Returns the current virtual desktop.
Definition kx11extras.cpp:613
NETRootInfo
Common API for root window properties/protocols.
Definition netwm.h:41
NETWinInfo
Common API for application window properties/protocols.
Definition netwm.h:967
NETWinInfo::state
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:4607
NET::Sticky
@ Sticky
indicates that the Window Manager SHOULD keep the window's position fixed on the screen,...
Definition netwm_def.h:515
NET::Shaded
@ Shaded
indicates that the window is shaded (rolled-up).
Definition netwm_def.h:531
NET::Hidden
@ Hidden
indicates that a window should not be visible on the screen (e.g.
Definition netwm_def.h:549
NET::DialogMask
@ DialogMask
Definition netwm_def.h:459
NET::NormalMask
@ NormalMask
Definition netwm_def.h:454
NET::WindowType
WindowType
Window type.
Definition netwm_def.h:357
NET::Normal
@ Normal
indicates that this is a normal, top-level window
Definition netwm_def.h:365
NET::Dialog
@ Dialog
indicates that this is a dialog window
Definition netwm_def.h:388
NET::Action
Action
Actions that can be done with a window (_NET_WM_ALLOWED_ACTIONS).
Definition netwm_def.h:644
NET::MappingState
MappingState
Client window mapping state.
Definition netwm_def.h:623
NET::Iconic
@ Iconic
indicates that the client window is not visible, but its icon is.
Definition netwm_def.h:637
NET::Withdrawn
@ Withdrawn
indicates that neither the client window nor its icon is visible.
Definition netwm_def.h:631
KJobWidgets::window
QWidget * window(QObject *job)
KStandardGuiItem::properties
KGuiItem properties()
QString::fromLatin1
QString fromLatin1(QByteArrayView str)
QString::fromUtf8
QString fromUtf8(QByteArrayView str)
QString::split
QStringList split(QChar sep, Qt::SplitBehavior behavior, Qt::CaseSensitivity cs) const const
QStringList::contains
bool contains(QLatin1StringView str, Qt::CaseSensitivity cs) const const
Qt::SkipEmptyParts
SkipEmptyParts
NETExtendedStrut
Partial strut class for NET classes.
Definition netwm_def.h:180
NETExtendedStrut::bottom_width
int bottom_width
Bottom border of the strut, width and range.
Definition netwm_def.h:218
NETExtendedStrut::left_width
int left_width
Left border of the strut, width and range.
Definition netwm_def.h:203
NETExtendedStrut::right_width
int right_width
Right border of the strut, width and range.
Definition netwm_def.h:208
NETExtendedStrut::top_width
int top_width
Top border of the strut, width and range.
Definition netwm_def.h:213
NETPoint::x
int x
x coordinate.
Definition netwm_def.h:51
NETPoint::y
int y
y coordinate
Definition netwm_def.h:52
NETRect
Simple rectangle class for NET classes.
Definition netwm_def.h:105
NETRect::pos
NETPoint pos
Position of the rectangle.
Definition netwm_def.h:126
NETRect::size
NETSize size
Size of the rectangle.
Definition netwm_def.h:133
NETSize::height
int height
Height.
Definition netwm_def.h:92
NETSize::width
int width
Width.
Definition netwm_def.h:91
NETStrut::bottom
int bottom
Bottom border of the strut.
Definition netwm_def.h:262
NETStrut::left
int left
Left border of the strut.
Definition netwm_def.h:247
NETStrut::right
int right
Right border of the strut.
Definition netwm_def.h:252
NETStrut::top
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 Tue Mar 26 2024 11:15:04 by doxygen 1.10.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.