#include <qt_x11_p.h>

Classes
struct	PatternFills

struct	ScrollInProgress

struct	SolidFills

Public Types
enum	{ FM_Unknown = -1, FM_Other = 0, FM_PointerRoot = 1 }

enum	{ solid_fill_count = 16 }

enum	{ pattern_fill_count = 16 }

enum	X11Atom { WM_PROTOCOLS, WM_DELETE_WINDOW, WM_TAKE_FOCUS, _NET_WM_PING, _NET_WM_CONTEXT_HELP, _NET_WM_SYNC_REQUEST, _NET_WM_SYNC_REQUEST_COUNTER, WM_STATE, WM_CHANGE_STATE, WM_CLIENT_LEADER, WM_WINDOW_ROLE, SM_CLIENT_ID, CLIPBOARD, INCR, TARGETS, MULTIPLE, TIMESTAMP, SAVE_TARGETS, CLIP_TEMPORARY, _QT_SELECTION, _QT_CLIPBOARD_SENTINEL, _QT_SELECTION_SENTINEL, CLIPBOARD_MANAGER, RESOURCE_MANAGER, _XSETROOT_ID, _QT_SCROLL_DONE, _QT_INPUT_ENCODING, _MOTIF_WM_HINTS, DTWM_IS_RUNNING, ENLIGHTENMENT_DESKTOP, _DT_SAVE_MODE, _SGI_DESKS_MANAGER, _NET_SUPPORTED, _NET_VIRTUAL_ROOTS, _NET_WORKAREA, _NET_MOVERESIZE_WINDOW, _NET_WM_MOVERESIZE, _NET_WM_NAME, _NET_WM_ICON_NAME, _NET_WM_ICON, _NET_WM_PID, _NET_WM_WINDOW_OPACITY, _NET_WM_STATE, _NET_WM_STATE_ABOVE, _NET_WM_STATE_BELOW, _NET_WM_STATE_FULLSCREEN, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT, _NET_WM_STATE_MODAL, _NET_WM_STATE_STAYS_ON_TOP, _NET_WM_STATE_DEMANDS_ATTENTION, _NET_WM_USER_TIME, _NET_WM_USER_TIME_WINDOW, _NET_WM_FULL_PLACEMENT, _NET_WM_WINDOW_TYPE, _NET_WM_WINDOW_TYPE_DESKTOP, _NET_WM_WINDOW_TYPE_DOCK, _NET_WM_WINDOW_TYPE_TOOLBAR, _NET_WM_WINDOW_TYPE_MENU, _NET_WM_WINDOW_TYPE_UTILITY, _NET_WM_WINDOW_TYPE_SPLASH, _NET_WM_WINDOW_TYPE_DIALOG, _NET_WM_WINDOW_TYPE_DROPDOWN_MENU, _NET_WM_WINDOW_TYPE_POPUP_MENU, _NET_WM_WINDOW_TYPE_TOOLTIP, _NET_WM_WINDOW_TYPE_NOTIFICATION, _NET_WM_WINDOW_TYPE_COMBO, _NET_WM_WINDOW_TYPE_DND, _NET_WM_WINDOW_TYPE_NORMAL, _KDE_NET_WM_WINDOW_TYPE_OVERRIDE, _KDE_NET_WM_FRAME_STRUT, _NET_STARTUP_INFO, _NET_STARTUP_INFO_BEGIN, _NET_SUPPORTING_WM_CHECK, _NET_WM_CM_S0, _NET_SYSTEM_TRAY_VISUAL, _NET_ACTIVE_WINDOW, COMPOUND_TEXT, TEXT, UTF8_STRING, XdndEnter, XdndPosition, XdndStatus, XdndLeave, XdndDrop, XdndFinished, XdndTypelist, XdndActionList, XdndSelection, XdndAware, XdndProxy, XdndActionCopy, XdndActionLink, XdndActionMove, XdndActionPrivate, _MOTIF_DRAG_AND_DROP_MESSAGE, _MOTIF_DRAG_INITIATOR_INFO, _MOTIF_DRAG_RECEIVER_INFO, _MOTIF_DRAG_WINDOW, _MOTIF_DRAG_TARGETS, XmTRANSFER_SUCCESS, XmTRANSFER_FAILURE, _XKB_RULES_NAMES, _XEMBED, _XEMBED_INFO, XWacomStylus, XWacomCursor, XWacomEraser, XTabletStylus, XTabletEraser, XTablet, NPredefinedAtoms, _QT_SETTINGS_TIMESTAMP = NPredefinedAtoms, NAtoms }

Public Functions
QByteArray	clipboardReadIncrementalProperty (Window win, Atom property, int nbytes, bool nullterm)

bool	clipboardReadProperty (Window win, Atom property, bool deleteProperty, QByteArray buffer, int size, Atom type, int format)

bool	clipboardWaitForEvent (Window win, int type, XEvent *event, int timeout, bool checkManager=false)

bool	dndEnable (QWidget *w, bool on)

Window	findClientWindow (Window, Atom, bool)

Picture	getSolidFill (int screen, const QColor &c)

bool	isSupportedByWM (Atom atom)

void	motifdndEnable (QWidget *, bool)

QByteArray	motifdndFormat (int n)

void	motifdndHandle (QWidget , const XEvent , bool)

QVariant	motifdndObtainData (const char *format)

XRenderColor	preMultiply (const QColor &c)

QByteArray	xdndAtomToString (Atom a)

void	xdndHandleDrop (QWidget , const XEvent , bool)

void	xdndHandleEnter (QWidget , const XEvent , bool)

void	xdndHandleFinished (QWidget , const XEvent , bool)

void	xdndHandleLeave (QWidget , const XEvent , bool)

void	xdndHandlePosition (QWidget , const XEvent , bool)

void	xdndHandleSelectionRequest (const XSelectionRequestEvent *)

void	xdndHandleStatus (QWidget , const XEvent , bool)

Atom	xdndMimeAtomForFormat (const QString &format, QVariant::Type requestedType, const QList< Atom > &atoms, QByteArray *requestedEncoding)

QList< Atom >	xdndMimeAtomsForFormat (const QString &format)

QString	xdndMimeAtomToString (Atom a)

QVariant	xdndMimeConvertToFormat (Atom a, const QByteArray &data, const QString &format, QVariant::Type requestedType, const QByteArray &encoding)

bool	xdndMimeDataForAtom (Atom a, QMimeData mimeData, QByteArray data, Atom atomFormat, int dataFormat)

QStringList	xdndMimeFormatsForAtom (Atom a)

Atom	xdndMimeStringToAtom (const QString &mimeType)

Atom	xdndStringToAtom (const char *)

Static Public Functions
static bool	badwindow ()

static void	ignoreBadwindow ()

static Qt::KeyboardModifiers	translateModifiers (int s)

static bool	xdndHandleBadwindow ()

static void	xdndSetup ()

Public Variables
Colormap *	argbColormaps

Visual **	argbVisuals

Atom	atoms [NAtoms]

QHash< int, int >	bppForDepth

int	color_count

Colormap	colormap

bool	compositingManagerRunning

bool	custom_cmap

QString	default_im

int	defaultScreen

QList< QWidget * >	deferred_map

DesktopEnvironment	desktopEnvironment: 8

uint	desktopVersion: 8

Display *	display

char *	displayName

QList< QXdndDropTransaction >	dndDropTransactions

bool	fc_antialias

int	fc_hint_style

qreal	fc_scale

int	focus_model

bool	foreignDisplay

bool	has_fontconfig

bool	ignore_badwindow

int	mitshm_major

bool	motifdnd_active

Atom *	net_supported_list

Window *	net_virtual_root_list

struct QX11Data::PatternFills	pattern_fills [pattern_fill_count]

PtrXCloseDevice	ptrXCloseDevice

PtrXcursorLibraryLoadCursor	ptrXcursorLibraryLoadCursor

PtrXFixesQueryExtension	ptrXFixesQueryExtension

PtrXFixesQueryVersion	ptrXFixesQueryVersion

PtrXFixesSelectSelectionInput	ptrXFixesSelectSelectionInput

PtrXFixesSetCursorName	ptrXFixesSetCursorName

PtrXFreeDeviceList	ptrXFreeDeviceList

PtrXineramaIsActive	ptrXineramaIsActive

PtrXineramaQueryExtension	ptrXineramaQueryExtension

PtrXineramaQueryScreens	ptrXineramaQueryScreens

PtrXListInputDevices	ptrXListInputDevices

PtrXOpenDevice	ptrXOpenDevice

PtrXRRQueryExtension	ptrXRRQueryExtension

PtrXRRRootToScreen	ptrXRRRootToScreen

PtrXRRSelectInput	ptrXRRSelectInput

PtrXRRUpdateConfiguration	ptrXRRUpdateConfiguration

PtrXSelectExtensionEvent	ptrXSelectExtensionEvent

int	screenCount

QX11InfoData *	screens

bool	seen_badwindow

QList< ScrollInProgress >	sip_list

long	sip_serial

struct QX11Data::SolidFills	solid_fills [solid_fill_count]

char *	startupId

Time	time

bool	use_mitshm

bool	use_mitshm_pixmaps

bool	use_xfixes

bool	use_xinput

bool	use_xkb

bool	use_xrandr

bool	use_xrender

Time	userTime

Visual *	visual

int	visual_class

int	visual_id

Window	wm_client_leader

int	xfixes_errorbase

int	xfixes_eventbase

int	xfixes_major

int	xinput_errorbase

int	xinput_eventbase

int	xinput_major

int	xkb_errorbase

int	xkb_eventbase

int	xkb_major

int	xrandr_errorbase

int	xrandr_eventbase

int	xrandr_major

int	xrender_major

int	xrender_version

Detailed Description

Definition at line 349 of file qt_x11_p.h.

Enumerations

◆ anonymous enum

anonymous enum

Enumerator
FM_Unknown
FM_Other
FM_PointerRoot

Definition at line 396 of file qt_x11_p.h.

          {
         FM_Unknown = -1,
         FM_Other = 0,
         FM_PointerRoot = 1
     };

◆ anonymous enum

anonymous enum

Enumerator
solid_fill_count

Definition at line 507 of file qt_x11_p.h.

507 { solid_fill_count = 16 };

QX11Data::solid_fill_count

Definition: qt_x11_p.h:507

◆ anonymous enum

anonymous enum

Enumerator
pattern_fill_count

Definition at line 513 of file qt_x11_p.h.

513 { pattern_fill_count = 16 };

QX11Data::pattern_fill_count

Definition: qt_x11_p.h:513

◆ X11Atom

enum QX11Data::X11Atom

Enumerator
WM_PROTOCOLS
WM_DELETE_WINDOW
WM_TAKE_FOCUS
_NET_WM_PING
_NET_WM_CONTEXT_HELP
_NET_WM_SYNC_REQUEST
_NET_WM_SYNC_REQUEST_COUNTER
WM_STATE
WM_CHANGE_STATE
WM_CLIENT_LEADER
WM_WINDOW_ROLE
SM_CLIENT_ID
CLIPBOARD
INCR
TARGETS
MULTIPLE
TIMESTAMP
SAVE_TARGETS
CLIP_TEMPORARY
_QT_SELECTION
_QT_CLIPBOARD_SENTINEL
_QT_SELECTION_SENTINEL
CLIPBOARD_MANAGER
RESOURCE_MANAGER
_XSETROOT_ID
_QT_SCROLL_DONE
_QT_INPUT_ENCODING
_MOTIF_WM_HINTS
DTWM_IS_RUNNING
ENLIGHTENMENT_DESKTOP
_DT_SAVE_MODE
_SGI_DESKS_MANAGER
_NET_SUPPORTED
_NET_VIRTUAL_ROOTS
_NET_WORKAREA
_NET_MOVERESIZE_WINDOW
_NET_WM_MOVERESIZE
_NET_WM_NAME
_NET_WM_ICON_NAME
_NET_WM_ICON
_NET_WM_PID
_NET_WM_WINDOW_OPACITY
_NET_WM_STATE
_NET_WM_STATE_ABOVE
_NET_WM_STATE_BELOW
_NET_WM_STATE_FULLSCREEN
_NET_WM_STATE_MAXIMIZED_HORZ
_NET_WM_STATE_MAXIMIZED_VERT
_NET_WM_STATE_MODAL
_NET_WM_STATE_STAYS_ON_TOP
_NET_WM_STATE_DEMANDS_ATTENTION
_NET_WM_USER_TIME
_NET_WM_USER_TIME_WINDOW
_NET_WM_FULL_PLACEMENT
_NET_WM_WINDOW_TYPE
_NET_WM_WINDOW_TYPE_DESKTOP
_NET_WM_WINDOW_TYPE_DOCK
_NET_WM_WINDOW_TYPE_TOOLBAR
_NET_WM_WINDOW_TYPE_MENU
_NET_WM_WINDOW_TYPE_UTILITY
_NET_WM_WINDOW_TYPE_SPLASH
_NET_WM_WINDOW_TYPE_DIALOG
_NET_WM_WINDOW_TYPE_DROPDOWN_MENU
_NET_WM_WINDOW_TYPE_POPUP_MENU
_NET_WM_WINDOW_TYPE_TOOLTIP
_NET_WM_WINDOW_TYPE_NOTIFICATION
_NET_WM_WINDOW_TYPE_COMBO
_NET_WM_WINDOW_TYPE_DND
_NET_WM_WINDOW_TYPE_NORMAL
_KDE_NET_WM_WINDOW_TYPE_OVERRIDE
_KDE_NET_WM_FRAME_STRUT
_NET_STARTUP_INFO
_NET_STARTUP_INFO_BEGIN
_NET_SUPPORTING_WM_CHECK
_NET_WM_CM_S0
_NET_SYSTEM_TRAY_VISUAL
_NET_ACTIVE_WINDOW
COMPOUND_TEXT
TEXT
UTF8_STRING
XdndEnter
XdndPosition
XdndStatus
XdndLeave
XdndDrop
XdndFinished
XdndTypelist
XdndActionList
XdndSelection
XdndAware
XdndProxy
XdndActionCopy
XdndActionLink
XdndActionMove
XdndActionPrivate
_MOTIF_DRAG_AND_DROP_MESSAGE
_MOTIF_DRAG_INITIATOR_INFO
_MOTIF_DRAG_RECEIVER_INFO
_MOTIF_DRAG_WINDOW
_MOTIF_DRAG_TARGETS
XmTRANSFER_SUCCESS
XmTRANSFER_FAILURE
_XKB_RULES_NAMES
_XEMBED
_XEMBED_INFO
XWacomStylus
XWacomCursor
XWacomEraser
XTabletStylus
XTabletEraser
XTablet
NPredefinedAtoms
_QT_SETTINGS_TIMESTAMP
NAtoms

Definition at line 537 of file qt_x11_p.h.

                  {
         // window-manager <-> client protocols
         WM_PROTOCOLS,
         WM_DELETE_WINDOW,
         WM_TAKE_FOCUS,
         _NET_WM_PING,
         _NET_WM_CONTEXT_HELP,
         _NET_WM_SYNC_REQUEST,
         _NET_WM_SYNC_REQUEST_COUNTER,
 
         // ICCCM window state
         WM_STATE,
         WM_CHANGE_STATE,
 
         // Session management
         WM_CLIENT_LEADER,
         WM_WINDOW_ROLE,
         SM_CLIENT_ID,
 
         // Clipboard
         CLIPBOARD,
         INCR,
         TARGETS,
         MULTIPLE,
         TIMESTAMP,
         SAVE_TARGETS,
         CLIP_TEMPORARY,
         _QT_SELECTION,
         _QT_CLIPBOARD_SENTINEL,
         _QT_SELECTION_SENTINEL,
         CLIPBOARD_MANAGER,
 
         RESOURCE_MANAGER,
 
         _XSETROOT_ID,
 
         _QT_SCROLL_DONE,
         _QT_INPUT_ENCODING,
 
         _MOTIF_WM_HINTS,
 
         DTWM_IS_RUNNING,
         ENLIGHTENMENT_DESKTOP,
         _DT_SAVE_MODE,
         _SGI_DESKS_MANAGER,
 
         // EWMH (aka NETWM)
         _NET_SUPPORTED,
         _NET_VIRTUAL_ROOTS,
         _NET_WORKAREA,
 
         _NET_MOVERESIZE_WINDOW,
         _NET_WM_MOVERESIZE,
 
         _NET_WM_NAME,
         _NET_WM_ICON_NAME,
         _NET_WM_ICON,
 
         _NET_WM_PID,
 
         _NET_WM_WINDOW_OPACITY,
 
         _NET_WM_STATE,
         _NET_WM_STATE_ABOVE,
         _NET_WM_STATE_BELOW,
         _NET_WM_STATE_FULLSCREEN,
         _NET_WM_STATE_MAXIMIZED_HORZ,
         _NET_WM_STATE_MAXIMIZED_VERT,
         _NET_WM_STATE_MODAL,
         _NET_WM_STATE_STAYS_ON_TOP,
         _NET_WM_STATE_DEMANDS_ATTENTION,
 
         _NET_WM_USER_TIME,
         _NET_WM_USER_TIME_WINDOW,
         _NET_WM_FULL_PLACEMENT,
 
         _NET_WM_WINDOW_TYPE,
         _NET_WM_WINDOW_TYPE_DESKTOP,
         _NET_WM_WINDOW_TYPE_DOCK,
         _NET_WM_WINDOW_TYPE_TOOLBAR,
         _NET_WM_WINDOW_TYPE_MENU,
         _NET_WM_WINDOW_TYPE_UTILITY,
         _NET_WM_WINDOW_TYPE_SPLASH,
         _NET_WM_WINDOW_TYPE_DIALOG,
         _NET_WM_WINDOW_TYPE_DROPDOWN_MENU,
         _NET_WM_WINDOW_TYPE_POPUP_MENU,
         _NET_WM_WINDOW_TYPE_TOOLTIP,
         _NET_WM_WINDOW_TYPE_NOTIFICATION,
         _NET_WM_WINDOW_TYPE_COMBO,
         _NET_WM_WINDOW_TYPE_DND,
         _NET_WM_WINDOW_TYPE_NORMAL,
         _KDE_NET_WM_WINDOW_TYPE_OVERRIDE,
 
         _KDE_NET_WM_FRAME_STRUT,
 
         _NET_STARTUP_INFO,
         _NET_STARTUP_INFO_BEGIN,
 
         _NET_SUPPORTING_WM_CHECK,
 
         _NET_WM_CM_S0,
 
         _NET_SYSTEM_TRAY_VISUAL,
 
         _NET_ACTIVE_WINDOW,
 
         // Property formats
         COMPOUND_TEXT,
         TEXT,
         UTF8_STRING,
 
         // Xdnd
         XdndEnter,
         XdndPosition,
         XdndStatus,
         XdndLeave,
         XdndDrop,
         XdndFinished,
         XdndTypelist,
         XdndActionList,
 
         XdndSelection,
 
         XdndAware,
         XdndProxy,
 
         XdndActionCopy,
         XdndActionLink,
         XdndActionMove,
         XdndActionPrivate,
 
         // Motif DND
         _MOTIF_DRAG_AND_DROP_MESSAGE,
         _MOTIF_DRAG_INITIATOR_INFO,
         _MOTIF_DRAG_RECEIVER_INFO,
         _MOTIF_DRAG_WINDOW,
         _MOTIF_DRAG_TARGETS,
 
         XmTRANSFER_SUCCESS,
         XmTRANSFER_FAILURE,
 
         // Xkb
         _XKB_RULES_NAMES,
 
         // XEMBED
         _XEMBED,
         _XEMBED_INFO,
 
         XWacomStylus,
         XWacomCursor,
         XWacomEraser,
 
         XTabletStylus,
         XTabletEraser,
         XTablet,
 
         NPredefinedAtoms,
 
         _QT_SETTINGS_TIMESTAMP = NPredefinedAtoms,
         NAtoms
     };

Functions

◆ badwindow()

static bool QX11Data::badwindow ( )

inlinestatic

Definition at line 488 of file qt_x11_p.h.

                                    {
         qt_x11Data->ignore_badwindow = false;
         return qt_x11Data->seen_badwindow;
     }

◆ clipboardReadIncrementalProperty()

QByteArray QX11Data::clipboardReadIncrementalProperty	(	Window	win,
		Atom	property,
		int	nbytes,
		bool	nullterm
	)

Definition at line 725 of file qclipboard_x11.cpp.

 {
     XEvent event;
 
     QByteArray buf;
     QByteArray tmp_buf;
     bool alloc_error = false;
     int  length;
     int  offset = 0;
 
     if (nbytes > 0) {
         // Reserve buffer + zero-terminator (for text data)
         // We want to complete the INCR transfer even if we cannot
         // allocate more memory
         buf.resize(nbytes+1);
         alloc_error = buf.size() != nbytes+1;
     }
 
     for (;;) {
         XFlush(display);
         if (!clipboardWaitForEvent(win,PropertyNotify,&event,clipboard_timeout))
             break;
         if (event.xproperty.atom != property ||
              event.xproperty.state != PropertyNewValue)
             continue;
         if (X11->clipboardReadProperty(win, property, true, &tmp_buf, &length, 0, 0)) {
             if (length == 0) {                // no more data, we're done
                 if (nullterm) {
                     buf.resize(offset+1);
                     buf[offset] = '\0';
                 } else {
                     buf.resize(offset);
                 }
                 return buf;
             } else if (!alloc_error) {
                 if (offset+length > (int)buf.size()) {
                     buf.resize(offset+length+65535);
                     if (buf.size() != offset+length+65535) {
                         alloc_error = true;
                         length = buf.size() - offset;
                     }
                 }
                 memcpy(buf.data()+offset, tmp_buf.constData(), length);
                 tmp_buf.resize(0);
                 offset += length;
             }
         } else {
             break;
         }
     }
 
     // timed out ... create a new requestor window, otherwise the requestor
     // could consider next request to be still part of this timed out request
     delete requestor;
     requestor = new QWidget(0);
     requestor->setObjectName(QLatin1String("internal clipboard requestor"));
     // We don't need this internal widget to appear in QApplication::topLevelWidgets()
     if (QWidgetPrivate::allWidgets)
         QWidgetPrivate::allWidgets->remove(requestor);
 
     return QByteArray();
 }

◆ clipboardReadProperty()

bool QX11Data::clipboardReadProperty	(	Window	win,
		Atom	property,
		bool	deleteProperty,
		QByteArray *	buffer,
		int *	size,
		Atom *	type,
		int *	format
	)

Definition at line 606 of file qclipboard_x11.cpp.

 {
     int           maxsize = maxSelectionIncr(display);
     ulong  bytes_left; // bytes_after
     ulong  length;     // nitems
     uchar *data;
     Atom   dummy_type;
     int    dummy_format;
     int    r;
 
     if (!type)                                // allow null args
         type = &dummy_type;
     if (!format)
         format = &dummy_format;
 
     // Don't read anything, just get the size of the property data
     r = XGetWindowProperty(display, win, property, 0, 0, False,
                             AnyPropertyType, type, format,
                             &length, &bytes_left, &data);
     if (r != Success || (type && *type == XNone)) {
         buffer->resize(0);
         return false;
     }
     XFree((char*)data);
 
     int  offset = 0, buffer_offset = 0, format_inc = 1, proplen = bytes_left;
 
     VDEBUG("QClipboard: read_property(): initial property length: %d", proplen);
 
     switch (*format) {
     case 8:
     default:
         format_inc = sizeof(char) / 1;
         break;
 
     case 16:
         format_inc = sizeof(short) / 2;
         proplen *= sizeof(short) / 2;
         break;
 
     case 32:
         format_inc = sizeof(long) / 4;
         proplen *= sizeof(long) / 4;
         break;
     }
 
     int newSize = proplen;
     buffer->resize(newSize);
 
     bool ok = (buffer->size() == newSize);
     VDEBUG("QClipboard: read_property(): buffer resized to %d", buffer->size());
 
     if (ok && newSize) {
         // could allocate buffer
 
         while (bytes_left) {
             // more to read...
 
             r = XGetWindowProperty(display, win, property, offset, maxsize/4,
                                    False, AnyPropertyType, type, format,
                                    &length, &bytes_left, &data);
             if (r != Success || (type && *type == XNone))
                 break;
 
             offset += length / (32 / *format);
             length *= format_inc * (*format) / 8;
 
             // Here we check if we get a buffer overflow and tries to
             // recover -- this shouldn't normally happen, but it doesn't
             // hurt to be defensive
             if ((int)(buffer_offset + length) > buffer->size()) {
                 length = buffer->size() - buffer_offset;
 
                 // escape loop
                 bytes_left = 0;
             }
 
             memcpy(buffer->data() + buffer_offset, data, length);
             buffer_offset += length;
 
             XFree((char*)data);
         }
 
         if (*format == 8 && *type == ATOM(COMPOUND_TEXT)) {
             // convert COMPOUND_TEXT to a multibyte string
             XTextProperty textprop;
             textprop.encoding = *type;
             textprop.format = *format;
             textprop.nitems = buffer_offset;
             textprop.value = (unsigned char *) buffer->data();
 
             char **list_ret = 0;
             int count;
             if (XmbTextPropertyToTextList(display, &textprop, &list_ret,
                          &count) == Success && count && list_ret) {
                 offset = buffer_offset = strlen(list_ret[0]);
                 buffer->resize(offset);
                 memcpy(buffer->data(), list_ret[0], offset);
             }
             if (list_ret) XFreeStringList(list_ret);
         }
     }
 
     // correct size, not 0-term.
     if (size)
         *size = buffer_offset;
 
     VDEBUG("QClipboard: read_property(): buffer size %d, buffer offset %d, offset %d",
            buffer->size(), buffer_offset, offset);
 
     if (deleteProperty)
         XDeleteProperty(display, win, property);
 
     XFlush(display);
 
     return ok;
 }

◆ clipboardWaitForEvent()

bool QX11Data::clipboardWaitForEvent	(	Window	win,
		int	type,
		XEvent *	event,
		int	timeout,
		bool	checkManager = `false`
	)

Definition at line 518 of file qclipboard_x11.cpp.

 {
     QElapsedTimer started;
     started.start();
     QElapsedTimer now = started;
 
     if (QAbstractEventDispatcher::instance()->inherits("QtMotif")
         || QApplication::clipboard()->property("useEventLoopWhenWaiting").toBool()) {
         if (waiting_for_data) {
             Q_ASSERT(!"QClipboard: internal error, qt_xclb_wait_for_event recursed");
             return false;
         }
         waiting_for_data = true;
 
 
         has_captured_event = false;
         capture_event_win = win;
         capture_event_type = type;
 
         QApplication::EventFilter old_event_filter =
             qApp->setEventFilter(qt_x11_clipboard_event_filter);
 
         do {
             if (XCheckTypedWindowEvent(display, win, type, event)) {
                 waiting_for_data = false;
                 qApp->setEventFilter(old_event_filter);
                 return true;
             }
 
             if (checkManager && XGetSelectionOwner(X11->display, ATOM(CLIPBOARD_MANAGER)) == XNone)
                 return false;
 
             XSync(X11->display, false);
             usleep(50000);
 
             now.start();
 
             QEventLoop::ProcessEventsFlags flags(QEventLoop::ExcludeUserInputEvents
                                                  | QEventLoop::ExcludeSocketNotifiers
                                                  | QEventLoop::WaitForMoreEvents
                                                  | QEventLoop::X11ExcludeTimers);
             QAbstractEventDispatcher *eventDispatcher = QAbstractEventDispatcher::instance();
             eventDispatcher->processEvents(flags);
 
             if (has_captured_event) {
                 waiting_for_data = false;
                 *event = captured_event;
                 qApp->setEventFilter(old_event_filter);
                 return true;
             }
         } while (started.msecsTo(now) < timeout);
 
         waiting_for_data = false;
         qApp->setEventFilter(old_event_filter);
     } else {
         do {
             if (XCheckTypedWindowEvent(X11->display,win,type,event))
                 return true;
 
             if (checkManager && XGetSelectionOwner(X11->display, ATOM(CLIPBOARD_MANAGER)) == XNone)
                 return false;
 
             // process other clipboard events, since someone is probably requesting data from us
             XEvent e;
             // Pass the event through the event dispatcher filter so that applications
             // which install an event filter on the dispatcher get to handle it first.
             if (XCheckIfEvent(X11->display, &e, checkForClipboardEvents, 0) &&
                 !QAbstractEventDispatcher::instance()->filterEvent(&e))
                 qApp->x11ProcessEvent(&e);
 
             now.start();
 
             XFlush(X11->display);
 
             // sleep 50 ms, so we don't use up CPU cycles all the time.
             struct timeval usleep_tv;
             usleep_tv.tv_sec = 0;
             usleep_tv.tv_usec = 50000;
             select(0, 0, 0, 0, &usleep_tv);
         } while (started.msecsTo(now) < timeout);
     }
     return false;
 }

◆ dndEnable()

bool QX11Data::dndEnable	(	QWidget *	w,
		bool	on
	)

Definition at line 1954 of file qdnd_x11.cpp.

 {
     w = w->window();
 
     if (bool(((QExtraWidget*)w)->topData()->dnd) == on)
         return true; // been there, done that
     ((QExtraWidget*)w)->topData()->dnd = on ? 1 : 0;
 
     motifdndEnable(w, on);
     return xdndEnable(w, on);
 }

◆ findClientWindow()

Window QX11Data::findClientWindow	(	Window	win,
		Atom	property,
		bool	leaf
	)

Definition at line 2940 of file qapplication_x11.cpp.

 {
     Atom   type = XNone;
     int           format, i;
     ulong  nitems, after;
     uchar *data = 0;
     Window root, parent, target=0, *children=0;
     uint   nchildren;
     if (XGetWindowProperty(X11->display, win, property, 0, 0, false, AnyPropertyType,
                              &type, &format, &nitems, &after, &data) == Success) {
         if (data)
             XFree((char *)data);
         if (type)
             return win;
     }
     if (!XQueryTree(X11->display,win,&root,&parent,&children,&nchildren)) {
         if (children)
             XFree((char *)children);
         return 0;
     }
     for (i=nchildren-1; !target && i >= 0; i--)
         target = X11->findClientWindow(children[i], property, leaf);
     if (children)
         XFree((char *)children);
     return target;
 }

◆ getSolidFill()

Picture QX11Data::getSolidFill	(	int	screen,
		const QColor &	c
	)

Definition at line 3071 of file qwidget_x11.cpp.

 {
     if (!X11->use_xrender)
         return XNone;
 
     XRenderColor color = preMultiply(c);
     for (int i = 0; i < X11->solid_fill_count; ++i) {
         if (X11->solid_fills[i].screen == screen
             && X11->solid_fills[i].color.alpha == color.alpha
             && X11->solid_fills[i].color.red == color.red
             && X11->solid_fills[i].color.green == color.green
             && X11->solid_fills[i].color.blue == color.blue)
             return X11->solid_fills[i].picture;
     }
     // none found, replace one
     int i = qrand() % 16;
 
     if (X11->solid_fills[i].screen != screen && X11->solid_fills[i].picture) {
         XRenderFreePicture (X11->display, X11->solid_fills[i].picture);
         X11->solid_fills[i].picture = 0;
     }
 
     if (!X11->solid_fills[i].picture) {
         Pixmap pixmap = XCreatePixmap (X11->display, RootWindow (X11->display, screen), 1, 1, 32);
         XRenderPictureAttributes attrs;
         attrs.repeat = True;
         X11->solid_fills[i].picture = XRenderCreatePicture (X11->display, pixmap,
                                                             XRenderFindStandardFormat(X11->display, PictStandardARGB32),
                                                             CPRepeat, &attrs);
         XFreePixmap (X11->display, pixmap);
     }
 
     X11->solid_fills[i].color = color;
     X11->solid_fills[i].screen = screen;
     XRenderFillRectangle (X11->display, PictOpSrc, X11->solid_fills[i].picture, &color, 0, 0, 1, 1);
     return X11->solid_fills[i].picture;
 }

◆ ignoreBadwindow()

static void QX11Data::ignoreBadwindow ( )

inlinestatic

Definition at line 482 of file qt_x11_p.h.

                                          {
         qt_x11Data->ignore_badwindow = true;
         qt_x11Data->seen_badwindow = false;
     }

◆ isSupportedByWM()

bool QX11Data::isSupportedByWM ( Atom atom )

Definition at line 1438 of file qapplication_x11.cpp.

 {
     if (!X11->net_supported_list)
         return false;
 
     bool supported = false;
     int i = 0;
     while (X11->net_supported_list[i] != 0) {
         if (X11->net_supported_list[i++] == atom) {
             supported = true;
             break;
         }
     }
 
     return supported;
 }

◆ motifdndEnable()

void QX11Data::motifdndEnable	(	QWidget *	widget,
		bool
	)

Definition at line 791 of file qmotifdnd_x11.cpp.

 {
     DndWriteReceiverProperty(display, widget->internalWinId(), DND_DRAG_DYNAMIC);
 }

◆ motifdndFormat()

QByteArray QX11Data::motifdndFormat ( int n )

Definition at line 696 of file qmotifdnd_x11.cpp.

 {
     if (!motifdnd_active)
         return 0; // should not happen
 
     if (n >= num_src_targets)
         return 0;
 
     Atom target = src_targets[n];
 
     if (target == XA_STRING)
         return "text/plain;charset=ISO-8859-1";
     if (target == ATOM(UTF8_STRING))
         return "text/plain;charset=UTF-8";
     if (target == ATOM(COMPOUND_TEXT))
         return QByteArray("text/plain;charset=") + QTextCodec::codecForLocale()->name();
     if (target == ATOM(TEXT))
         return "text/plain";
 
     return ("x-motif-dnd/" + X11->xdndAtomToString(target));
 }

◆ motifdndHandle()

void QX11Data::motifdndHandle	(	QWidget *	widget,
		const XEvent *	xe,
		bool
	)

Definition at line 797 of file qmotifdnd_x11.cpp.

 {
     XEvent event = *xe;
     XClientMessageEvent cm ;
     DndData dnd_data ;
     char receiver ;
 
     if (!(DndParseClientMessage ((XClientMessageEvent*)&event,
                                  &dnd_data, &receiver))) {
         return;
     }
 
     switch (dnd_data.reason) {
 
     case DND_DRAG_MOTION:
         {
             QPoint p = widget->mapFromGlobal(QPoint(dnd_data.x, dnd_data.y));
             QWidget *c = widget->childAt(p);
 
             if (!c || !c->acceptDrops()) {
                 // not over a drop site
                 if (dropWidget) {
                     QDragLeaveEvent dragLeaveEvent;
                     QApplication::sendEvent(dropWidget, &dragLeaveEvent);
 
                     dropWidget = 0;
                     lastAcceptedAction = Qt::IgnoreAction;
 
                     dnd_data.reason = DND_DROP_SITE_LEAVE;
                     dnd_data.time = X11->time;
                     DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
                     XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm) ;
                 } else {
                     dnd_data.reason = DND_DRAG_MOTION;
                     dnd_data.status = DND_NO_DROP_SITE;
                     dnd_data.time = X11->time;
                     dnd_data.operation = DND_NOOP;
                     dnd_data.operations = DND_NOOP;
                     DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
                     XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm) ;
                 }
             } else {
                 Q_ASSERT(c != 0);
                 p = c->mapFrom(widget, p);
 
                 if (dropWidget != c) {
                     if (dropWidget) {
                         QDragLeaveEvent le;
                         QApplication::sendEvent(dropWidget, &le);
                     }
 
                     dropWidget = c;
                     lastAcceptedAction = Qt::IgnoreAction;
 
                     const Qt::DropActions possibleActions =
                         DndOperationsToQtDropActions(dnd_data.operations);
                     QDragEnterEvent de(p, possibleActions, QDragManager::self()->dropData,
                                        QApplication::mouseButtons(), QApplication::keyboardModifiers());
                     QApplication::sendEvent(dropWidget, &de);
 
                     dnd_data.reason = DND_DROP_SITE_ENTER;
                     dnd_data.time = X11->time;
                     if (de.isAccepted()) {
                         lastAcceptedAction = de.dropAction();
 
                         dnd_data.status = DND_VALID_DROP_SITE;
                         dnd_data.operation = QtDropActionToDndOperation(lastAcceptedAction);
                     } else {
                         dnd_data.status = DND_INVALID_DROP_SITE;
                         dnd_data.operation = DND_NOOP;
                         dnd_data.operations = DND_NOOP;
                     }
                     DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
                     XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
                 } else {
                     const Qt::DropActions possibleActions =
                         DndOperationsToQtDropActions(dnd_data.operations);
                     QDragMoveEvent me(p, possibleActions, QDragManager::self()->dropData,
                                       QApplication::mouseButtons(), QApplication::keyboardModifiers());
                     if (lastAcceptedAction != Qt::IgnoreAction) {
                         me.setDropAction(lastAcceptedAction);
                         me.accept();
                     }
                     QApplication::sendEvent(dropWidget, &me);
 
                     dnd_data.reason = DND_DRAG_MOTION;
                     dnd_data.time = X11->time;
 
                     if (me.isAccepted()) {
                         lastAcceptedAction = me.dropAction();
 
                         dnd_data.status = DND_VALID_DROP_SITE;
                         dnd_data.operation = QtDropActionToDndOperation(lastAcceptedAction);
                     } else {
                         dnd_data.status = DND_INVALID_DROP_SITE;
                         dnd_data.operation = DND_NOOP;
                         dnd_data.operations = DND_NOOP;
                     }
 
                     DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, receiver);
                     XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
                 }
             }
 
             break;
         }
 
     case DND_TOP_LEVEL_ENTER:
         {
             /* get the size of our drop site for later use */
 
             motifdnd_active = true;
             sourceWindow = dnd_data.src_window;
 
             /* no answer needed, just read source property */
             DndReadSourceProperty (event.xclient.display,
                                    sourceWindow,
                                    dnd_data.property,
                                    &src_targets, &num_src_targets);
 
             break;
         }
 
     case DND_TOP_LEVEL_LEAVE:
         {
             XEvent nextEvent;
             if (XCheckTypedWindowEvent(X11->display, widget->winId(), ClientMessage, &nextEvent)) {
                 // we just want to check, not eat (should use XPeekIfEvent)
                 XPutBackEvent(X11->display, &nextEvent);
 
                 if (DndParseClientMessage (&nextEvent.xclient, &dnd_data, &receiver)
                     && dnd_data.reason == DND_DROP_START) {
                     // expecting drop next, keeping DnD alive
                     break;
                 }
             }
 
             // not expecting drop, need to send drag leave events and such here
             if (dropWidget) {
                 QDragLeaveEvent le;
                 QApplication::sendEvent(dropWidget, &le);
             }
 
             sourceWindow = XNone;
             dropWidget = 0;
             lastAcceptedAction = Qt::IgnoreAction;
 
             motifdnd_active = false;
 
             break;
         }
 
     case DND_OPERATION_CHANGED:
         // ### need to echo
         break;
 
     case DND_DROP_START:
         {
             Q_ASSERT(motifdnd_active);
             Q_ASSERT(sourceWindow == dnd_data.src_window);
 
             if (!dropWidget || lastAcceptedAction == Qt::IgnoreAction) {
                 // echo DROP_START
                 dnd_data.reason = DND_DROP_START;
                 dnd_data.status = DND_NO_DROP_SITE;
                 dnd_data.operation = DND_NOOP;
                 dnd_data.operations = DND_NOOP;
                 DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, 0);
                 XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
 
                 // we have to convert selection in order to indicate failure to the initiator
                 XConvertSelection (X11->display, dnd_data.property, ATOM(XmTRANSFER_FAILURE),
                                    dnd_data.property, dnd_data.src_window, dnd_data.time);
 
                 if (dropWidget) {
                     QDragLeaveEvent e;
                     QApplication::sendEvent(dropWidget, &e);
                 }
 
                 motifdnd_active = false;
                 sourceWindow = XNone;
                 dropWidget = 0;
                 lastAcceptedAction = Qt::IgnoreAction;
 
                 return;
             }
 
             // store selection and its time
             Dnd_selection = dnd_data.property;
             Dnd_selection_time = dnd_data.time;
 
             QPoint p(dnd_data.x, dnd_data.y);
             QDropEvent de(dropWidget->mapFromGlobal(p), Qt::CopyAction, QDragManager::self()->dropData,
                           QApplication::mouseButtons(), QApplication::keyboardModifiers());
             if (lastAcceptedAction != Qt::IgnoreAction) {
                 de.setDropAction(lastAcceptedAction);
                 de.accept();
             }
             QApplication::sendEvent(dropWidget, &de);
 
             // reset
             Dnd_selection = XNone;
             Dnd_selection_time = 0;
 
             // echo DROP_START depending on the result of the dropEvent
             if (de.isAccepted()) {
                 dnd_data.reason = DND_DROP_START;
                 dnd_data.status = DND_VALID_DROP_SITE;
                 dnd_data.operation = QtDropActionToDndOperation(de.dropAction());
             } else {
                 dnd_data.reason = DND_DROP_START;
                 dnd_data.status = DND_NO_DROP_SITE;
                 dnd_data.operation = DND_NOOP;
                 dnd_data.operations = DND_NOOP;
             }
             DndFillClientMessage (event.xclient.display, sourceWindow, &cm, &dnd_data, 0);
             XSendEvent(event.xbutton.display, sourceWindow, False, 0, (XEvent *)&cm);
 
             sourceWindow = XNone;
             dropWidget = 0;
             lastAcceptedAction = Qt::IgnoreAction;
 
             motifdnd_active = false;
 
             break;
         }
 
     default:
         break;
     }   //  end of switch (dnd_data.reason)
 }

◆ motifdndObtainData()

QVariant QX11Data::motifdndObtainData ( const char * format )

Definition at line 719 of file qmotifdnd_x11.cpp.

 {
     QByteArray result;
 
     if (Dnd_selection == 0 || !dropWidget)
         return result;
 
     // try to convert the selection to the requested property
     // qDebug("trying to convert to '%s'", mimeType);
 
     int n=0;
     QByteArray f;
     do {
         f = motifdndFormat(n);
         if (f.isEmpty())
             return result;
         n++;
     } while(qstricmp(mimeType, f.data()));
 
     Atom conversion_type = XNone;
     if (f == "text/plain;charset=ISO-8859-1") {
         conversion_type = XA_STRING;
     } else if (f == "text/plain;charset=UTF-8") {
         conversion_type = ATOM(UTF8_STRING);
     } else if (f == (QByteArray("text/plain;charset=") + QTextCodec::codecForLocale()->name())) {
         conversion_type = ATOM(COMPOUND_TEXT);
     } else if (f == "text/plain") {
         conversion_type = ATOM(TEXT);
     } else if (f.startsWith("x-motif-dnd/")) {
         // strip off the "x-motif-dnd/" prefix
         conversion_type = X11->xdndStringToAtom(f.remove(0, 12));
     }
 
     if (XGetSelectionOwner(X11->display, Dnd_selection) == XNone) {
         return result; // should never happen?
     }
 
     QWidget* tw = dropWidget;
     if ((dropWidget->windowType() == Qt::Desktop)) {
         tw = new QWidget;
     }
 
     // convert selection to the appropriate type
     XConvertSelection (X11->display, Dnd_selection, conversion_type,
                        Dnd_selection, tw->internalWinId(), Dnd_selection_time);
 
     XFlush(X11->display);
 
     XEvent xevent;
     bool got=X11->clipboardWaitForEvent(tw->internalWinId(), SelectionNotify, &xevent, 5000);
     if (got) {
         Atom type;
 
         if (X11->clipboardReadProperty(tw->internalWinId(), Dnd_selection, true, &result, 0, &type, 0)) {
         }
     }
 
     //   we have to convert selection in order to indicate success to the initiator
     XConvertSelection (X11->display, Dnd_selection, ATOM(XmTRANSFER_SUCCESS),
                        Dnd_selection, tw->internalWinId(), Dnd_selection_time);
 
     // wait again for SelectionNotify event
     X11->clipboardWaitForEvent(tw->internalWinId(), SelectionNotify, &xevent, 5000);
 
     if ((dropWidget->windowType() == Qt::Desktop)) {
         delete tw;
     }
 
     return result;
 }

◆ preMultiply()

XRenderColor QX11Data::preMultiply ( const QColor & c )

Definition at line 3058 of file qwidget_x11.cpp.

 {
     XRenderColor color;
     const uint A = c.alpha(),
                R = c.red(),
                G = c.green(),
                B = c.blue();
     color.alpha = (A | A << 8);
     color.red   = (R | R << 8) * color.alpha / 0x10000;
     color.green = (G | G << 8) * color.alpha / 0x10000;
     color.blue  = (B | B << 8) * color.alpha / 0x10000;
     return color;
 }

◆ translateModifiers()

Qt::KeyboardModifiers QX11Data::translateModifiers ( int s )

static

Definition at line 4198 of file qapplication_x11.cpp.

 {
     Qt::KeyboardModifiers ret = 0;
     if (s & ShiftMask)
         ret |= Qt::ShiftModifier;
     if (s & ControlMask)
         ret |= Qt::ControlModifier;
     if (s & qt_alt_mask)
         ret |= Qt::AltModifier;
     if (s & qt_meta_mask)
         ret |= Qt::MetaModifier;
     if (s & qt_mode_switch_mask)
         ret |= Qt::GroupSwitchModifier;
     return ret;
 }

◆ xdndAtomToString()

QByteArray QX11Data::xdndAtomToString ( Atom a )

Definition at line 412 of file qdnd_x11.cpp.

 {
     if (!a) return 0;
 
     if (a == XA_STRING || a == ATOM(UTF8_STRING)) {
         return "text/plain"; // some Xdnd clients are dumb
     }
     char *atom = XGetAtomName(display, a);
     QByteArray result = atom;
     XFree(atom);
     return result;
 }

◆ xdndHandleBadwindow()

bool QX11Data::xdndHandleBadwindow ( )

static

Definition at line 1782 of file qdnd_x11.cpp.

 {
     if (qt_xdnd_current_target) {
         QDragManager *manager = QDragManager::self();
         if (manager->object) {
             qt_xdnd_current_target = 0;
             qt_xdnd_current_proxy_target = 0;
             manager->object->deleteLater();
             manager->object = 0;
             xdnd_data.deco->deleteLater(); //delay freeing to avoid crash QTBUG-19363
             xdnd_data.deco = 0;
             return true;
         }
     }
     if (qt_xdnd_dragsource_xid) {
         qt_xdnd_dragsource_xid = 0;
         if (qt_xdnd_current_widget) {
             QApplication::postEvent(qt_xdnd_current_widget, new QDragLeaveEvent);
             qt_xdnd_current_widget = 0;
         }
         return true;
     }
     return false;
 }

◆ xdndHandleDrop()

void QX11Data::xdndHandleDrop	(	QWidget *	,
		const XEvent *	xe,
		bool	passive
	)

Definition at line 1120 of file qdnd_x11.cpp.

 {
     DEBUG("xdndHandleDrop");
     if (!qt_xdnd_current_widget) {
         qt_xdnd_dragsource_xid = 0;
         return; // sanity
     }
 
     if (!passive && checkEmbedded(qt_xdnd_current_widget, xe)){
         current_embedding_widget = 0;
         qt_xdnd_dragsource_xid = 0;
         qt_xdnd_current_widget = 0;
         return;
     }
     const unsigned long *l = (const unsigned long *)xe->xclient.data.l;
 
     QDragManager *manager = QDragManager::self();
     DEBUG("xdnd drop");
 
     if (l[0] != qt_xdnd_dragsource_xid) {
         DEBUG("xdnd drop from unexpected source (%08lx not %08lx", l[0], qt_xdnd_dragsource_xid);
         return;
     }
 
     // update the "user time" from the timestamp in the event.
     if (l[2] != 0) {
         // Some X server/client combination swallow the first 32 bit and
         // interpret a set bit 31 as negative sign.
         qt_xdnd_target_current_time = X11->userTime =
             ((sizeof(Time) == 8 && xe->xclient.data.l[2] < 0)
              ? uint(l[2])
              :  l[2]);
     }
 
     if (!passive) {
         // this could be a same-application drop, just proxied due to
         // some XEMBEDding, so try to find the real QMimeData used
         // based on the timestamp for this drop.
         QMimeData *dropData = 0;
         const int at = findXdndDropTransactionByTime(qt_xdnd_target_current_time);
         if (at != -1) {
             dropData = QDragManager::dragPrivate(X11->dndDropTransactions.at(at).object)->data;
             // Can't use the source QMimeData if we need the image conversion code from xdndObtainData
             if (dropData && dropData->hasImage())
                 dropData = 0;
         }
         // if we can't find it, then use the data in the drag manager
         if (!dropData) {
             if (manager->object && !manager->dragPrivate()->data->hasImage())
                 dropData = manager->dragPrivate()->data;
             else
                 dropData = manager->dropData;
         }
 
         // Drop coming from another app? Update keyboard modifiers.
         if (!qt_xdnd_dragging) {
             QApplicationPrivate::modifier_buttons = QApplication::queryKeyboardModifiers();
         }
 
         QDropEvent de(qt_xdnd_current_position, possible_actions, dropData,
                       QApplication::mouseButtons(), QApplication::keyboardModifiers());
         QApplication::sendEvent(qt_xdnd_current_widget, &de);
         if (!de.isAccepted()) {
             // Ignore a failed drag
             global_accepted_action = Qt::IgnoreAction;
         } else {
             global_accepted_action = de.dropAction();
         }
         XClientMessageEvent finished;
         finished.type = ClientMessage;
         finished.window = qt_xdnd_dragsource_xid;
         finished.format = 32;
         finished.message_type = ATOM(XdndFinished);
         DNDDEBUG << "xdndHandleDrop"
              << "qt_xdnd_current_widget" << qt_xdnd_current_widget
              << (qt_xdnd_current_widget ? qt_xdnd_current_widget->effectiveWinId() : 0)
              << "t_xdnd_current_widget->window()"
              << (qt_xdnd_current_widget ? qt_xdnd_current_widget->window() : 0)
              << (qt_xdnd_current_widget ? qt_xdnd_current_widget->window()->internalWinId() : 0);
         finished.data.l[0] = qt_xdnd_current_widget?qt_xdnd_current_widget->window()->internalWinId():0;
         finished.data.l[1] = de.isAccepted() ? 1 : 0; // flags
         finished.data.l[2] = qtaction_to_xdndaction(global_accepted_action);
         XSendEvent(X11->display, qt_xdnd_dragsource_xid, False,
                     NoEventMask, (XEvent*)&finished);
     } else {
         QDragLeaveEvent e;
         QApplication::sendEvent(qt_xdnd_current_widget, &e);
     }
     qt_xdnd_dragsource_xid = 0;
     qt_xdnd_current_widget = 0;
     waiting_for_status = false;
 
     // reset
     qt_xdnd_target_current_time = CurrentTime;
 }

◆ xdndHandleEnter()

void QX11Data::xdndHandleEnter	(	QWidget *	,
		const XEvent *	xe,
		bool
	)

Definition at line 802 of file qdnd_x11.cpp.

 {
     motifdnd_active = false;
 
     last_enter_event.xclient = xe->xclient;
 
     const long *l = xe->xclient.data.l;
     int version = (int)(((unsigned long)(l[1])) >> 24);
 
     if (version > xdnd_version)
         return;
 
     qt_xdnd_dragsource_xid = l[0];
 
     int j = 0;
     if (l[1] & 1) {
         // get the types from XdndTypeList
         Atom   type = XNone;
         int f;
         unsigned long n, a;
         unsigned char *retval = 0;
         XGetWindowProperty(X11->display, qt_xdnd_dragsource_xid, ATOM(XdndTypelist), 0,
                            qt_xdnd_max_type, False, XA_ATOM, &type, &f,&n,&a,&retval);
         if (retval) {
             Atom *data = (Atom *)retval;
             for (; j<qt_xdnd_max_type && j < (int)n; j++) {
                 qt_xdnd_types[j] = data[j];
             }
             XFree((uchar*)data);
         }
     } else {
         // get the types from the message
         int i;
         for(i=2; i < 5; i++) {
             qt_xdnd_types[j++] = l[i];
         }
     }
     qt_xdnd_types[j] = 0;
 }

◆ xdndHandleFinished()

void QX11Data::xdndHandleFinished	(	QWidget *	,
		const XEvent *	xe,
		bool	passive
	)

Definition at line 1217 of file qdnd_x11.cpp.

 {
     DEBUG("xdndHandleFinished");
     const unsigned long *l = (const unsigned long *)xe->xclient.data.l;
 
     DNDDEBUG << "xdndHandleFinished, l[0]" << l[0]
              << "qt_xdnd_current_target" << qt_xdnd_current_target
              << "qt_xdnd_current_proxy_targe" << qt_xdnd_current_proxy_target;
 
     if (l[0]) {
         int at = findXdndDropTransactionByWindow(l[0]);
         if (at != -1) {
             restartXdndDropExpiryTimer();
 
             QXdndDropTransaction t = X11->dndDropTransactions.takeAt(at);
             QDragManager *manager = QDragManager::self();
 
             Window target = qt_xdnd_current_target;
             Window proxy_target = qt_xdnd_current_proxy_target;
             QWidget *embedding_widget = current_embedding_widget;
             QDrag *currentObject = manager->object;
 
             qt_xdnd_current_target = t.target;
             qt_xdnd_current_proxy_target = t.proxy_target;
             current_embedding_widget = t.embedding_widget;
             manager->object = t.object;
 
             if (!passive)
                 (void) checkEmbedded(qt_xdnd_current_widget, xe);
 
             current_embedding_widget = 0;
             qt_xdnd_current_target = 0;
             qt_xdnd_current_proxy_target = 0;
 
             if (t.object)
                 t.object->deleteLater();
 
             qt_xdnd_current_target = target;
             qt_xdnd_current_proxy_target = proxy_target;
             current_embedding_widget = embedding_widget;
             manager->object = currentObject;
         }
     }
     waiting_for_status = false;
 }

◆ xdndHandleLeave()

void QX11Data::xdndHandleLeave	(	QWidget *	w,
		const XEvent *	xe,
		bool
	)

Definition at line 1047 of file qdnd_x11.cpp.

 {
     DEBUG("xdnd leave");
     if (!qt_xdnd_current_widget ||
          w->window() != qt_xdnd_current_widget->window()) {
         return; // sanity
     }
 
     if (checkEmbedded(current_embedding_widget, xe)) {
         current_embedding_widget = 0;
         qt_xdnd_current_widget = 0;
         return;
     }
 
     const unsigned long *l = (const unsigned long *)xe->xclient.data.l;
 
     QDragLeaveEvent e;
     QApplication::sendEvent(qt_xdnd_current_widget, &e);
 
     if (l[0] != qt_xdnd_dragsource_xid) {
         // This often happens - leave other-process window quickly
         DEBUG("xdnd drag leave from unexpected source (%08lx not %08lx", l[0], qt_xdnd_dragsource_xid);
         qt_xdnd_current_widget = 0;
         return;
     }
 
     qt_xdnd_dragsource_xid = 0;
     qt_xdnd_types[0] = 0;
     qt_xdnd_current_widget = 0;
 }

◆ xdndHandlePosition()

void QX11Data::xdndHandlePosition	(	QWidget *	w,
		const XEvent *	xe,
		bool	passive
	)

Definition at line 991 of file qdnd_x11.cpp.

 {
     DEBUG("xdndHandlePosition");
     while (XCheckIfEvent(X11->display, (XEvent *)xe, xdnd_position_scanner, 0))
         ;
 
     handle_xdnd_position(w, xe, passive);
 }

◆ xdndHandleSelectionRequest()

void QX11Data::xdndHandleSelectionRequest ( const XSelectionRequestEvent * req )

Definition at line 1807 of file qdnd_x11.cpp.

 {
     if (!req)
         return;
     XEvent evt;
     evt.xselection.type = SelectionNotify;
     evt.xselection.display = req->display;
     evt.xselection.requestor = req->requestor;
     evt.xselection.selection = req->selection;
     evt.xselection.target = XNone;
     evt.xselection.property = XNone;
     evt.xselection.time = req->time;
 
     QDragManager *manager = QDragManager::self();
     QDrag *currentObject = manager->object;
 
     // which transaction do we use? (note: -2 means use current manager->object)
     int at = -1;
 
     // figure out which data the requestor is really interested in
     if (manager->object && req->time == qt_xdnd_source_current_time) {
         // requestor wants the current drag data
         at = -2;
     } else {
         // if someone has requested data in response to XdndDrop, find the corresponding transaction. the
         // spec says to call XConvertSelection() using the timestamp from the XdndDrop
         at = findXdndDropTransactionByTime(req->time);
         if (at == -1) {
             // no dice, perhaps the client was nice enough to use the same window id in XConvertSelection()
             // that we sent the XdndDrop event to.
             at = findXdndDropTransactionByWindow(req->requestor);
         }
         if (at == -1 && req->time == CurrentTime) {
             // previous Qt versions always requested the data on a child of the target window
             // using CurrentTime... but it could be asking for either drop data or the current drag's data
             Window target = findXdndAwareParent(req->requestor);
             if (target) {
                 if (qt_xdnd_current_target && qt_xdnd_current_target == target)
                     at = -2;
                 else
                     at = findXdndDropTransactionByWindow(target);
             }
         }
     }
     if (at >= 0) {
         restartXdndDropExpiryTimer();
 
         // use the drag object from an XdndDrop tansaction
         manager->object = X11->dndDropTransactions.at(at).object;
     } else if (at != -2) {
         // no transaction found, we'll have to reject the request
         manager->object = 0;
     }
     if (manager->object) {
         Atom atomFormat = req->target;
         int dataFormat = 0;
         QByteArray data;
         if (X11->xdndMimeDataForAtom(req->target, manager->dragPrivate()->data,
                                      &data, &atomFormat, &dataFormat)) {
             int dataSize = data.size() / (dataFormat / 8);
             XChangeProperty (X11->display, req->requestor, req->property,
                              atomFormat, dataFormat, PropModeReplace,
                              (unsigned char *)data.data(), dataSize);
             evt.xselection.property = req->property;
             evt.xselection.target = atomFormat;
         }
     }
 
     // reset manager->object in case we modified it above
     manager->object = currentObject;
 
     // ### this can die if req->requestor crashes at the wrong
     // ### moment
     XSendEvent(X11->display, req->requestor, False, 0, &evt);
 }

◆ xdndHandleStatus()

void QX11Data::xdndHandleStatus	(	QWidget *	w,
		const XEvent *	xe,
		bool	passive
	)

Definition at line 1037 of file qdnd_x11.cpp.

 {
     DEBUG("xdndHandleStatus");
     while (XCheckIfEvent(X11->display, (XEvent *)xe, xdnd_status_scanner, 0))
         ;
 
     handle_xdnd_status(w, xe, passive);
     DEBUG("xdndHandleStatus end");
 }

◆ xdndMimeAtomForFormat()

Atom QX11Data::xdndMimeAtomForFormat	(	const QString &	format,
		QVariant::Type	requestedType,
		const QList< Atom > &	atoms,
		QByteArray *	requestedEncoding
	)

Definition at line 652 of file qdnd_x11.cpp.

 {
     encoding->clear();
 
     // find matches for string types
     if (format == QLatin1String("text/plain")) {
         if (atoms.contains(ATOM(UTF8_STRING)))
             return ATOM(UTF8_STRING);
         if (atoms.contains(ATOM(COMPOUND_TEXT)))
             return ATOM(COMPOUND_TEXT);
         if (atoms.contains(ATOM(TEXT)))
             return ATOM(TEXT);
         if (atoms.contains(XA_STRING))
             return XA_STRING;
     }
 
     // find matches for uri types
     if (format == QLatin1String("text/uri-list")) {
         Atom a = xdndMimeStringToAtom(format);
         if (a && atoms.contains(a))
             return a;
         a = xdndMimeStringToAtom(QLatin1String("text/x-moz-url"));
         if (a && atoms.contains(a))
             return a;
     }
 
     // find match for image
     if (format == QLatin1String("image/ppm")) {
         if (atoms.contains(XA_PIXMAP))
             return XA_PIXMAP;
     }
 
     // for string/text requests try to use a format with a well-defined charset
     // first to avoid encoding problems
     if (requestedType == QVariant::String
         && format.startsWith(QLatin1String("text/"))
         && !format.contains(QLatin1String("charset="))) {
 
         QString formatWithCharset = format;
         formatWithCharset.append(QLatin1String(";charset=utf-8"));
 
         Atom a = xdndMimeStringToAtom(formatWithCharset);
         if (a && atoms.contains(a)) {
             *encoding = "utf-8";
             return a;
         }
     }
 
     Atom a = xdndMimeStringToAtom(format);
     if (a && atoms.contains(a))
         return a;
 
     return 0;
 }

◆ xdndMimeAtomsForFormat()

QList< Atom > QX11Data::xdndMimeAtomsForFormat ( const QString & format )

Definition at line 561 of file qdnd_x11.cpp.

 {
     QList<Atom> atoms;
     atoms.append(xdndMimeStringToAtom(format));
 
     // special cases for strings
     if (format == QLatin1String("text/plain")) {
         atoms.append(ATOM(UTF8_STRING));
         atoms.append(XA_STRING);
         atoms.append(ATOM(TEXT));
         atoms.append(ATOM(COMPOUND_TEXT));
     }
 
     // special cases for uris
     if (format == QLatin1String("text/uri-list")) {
         atoms.append(xdndMimeStringToAtom(QLatin1String("text/x-moz-url")));
     }
 
     //special cases for images
     if (format == QLatin1String("image/ppm"))
         atoms.append(XA_PIXMAP);
     if (format == QLatin1String("image/pbm"))
         atoms.append(XA_BITMAP);
 
     return atoms;
 }

◆ xdndMimeAtomToString()

QString QX11Data::xdndMimeAtomToString ( Atom a )

Definition at line 433 of file qdnd_x11.cpp.

 {
     QString atomName;
     if (a) {
         char *atom = XGetAtomName(display, a);
         atomName = QString::fromLatin1(atom);
         XFree(atom);
     }
     return atomName;
 }

◆ xdndMimeConvertToFormat()

QVariant QX11Data::xdndMimeConvertToFormat	(	Atom	a,
		const QByteArray &	data,
		const QString &	format,
		QVariant::Type	requestedType,
		const QByteArray &	encoding
	)

Definition at line 589 of file qdnd_x11.cpp.

 {
     QString atomName = xdndMimeAtomToString(a);
     if (atomName == format)
         return data;
 
     if (!encoding.isEmpty()
         && atomName == format + QLatin1String(";charset=") + QString::fromLatin1(encoding)) {
 
         if (requestedType == QVariant::String) {
             QTextCodec *codec = QTextCodec::codecForName(encoding);
             if (codec)
                 return codec->toUnicode(data);
         }
 
         return data;
     }
 
     // special cases for string types
     if (format == QLatin1String("text/plain")) {
         if (a == ATOM(UTF8_STRING))
             return QString::fromUtf8(data);
         if (a == XA_STRING)
             return QString::fromLatin1(data);
         if (a == ATOM(TEXT) || a == ATOM(COMPOUND_TEXT))
             // #### might be wrong for COMPUND_TEXT
             return QString::fromLocal8Bit(data, data.size());
     }
 
     // special case for uri types
     if (format == QLatin1String("text/uri-list")) {
         if (atomName == QLatin1String("text/x-moz-url")) {
             // we expect this as utf16 <url><space><title>
             // the first part is a url that should only contain ascci char
             // so it should be safe to check that the second char is 0
             // to verify that it is utf16
             if (data.size() > 1 && data.at(1) == 0)
                 return QString::fromRawData((const QChar *)data.constData(),
                                 data.size() / 2).split(QLatin1Char('\n')).first().toLatin1();
         }
     }
 
     // special cas for images
     if (format == QLatin1String("image/ppm")) {
         if (a == XA_PIXMAP && data.size() == sizeof(Pixmap)) {
             Pixmap xpm = *((Pixmap*)data.data());
             if (!xpm)
                 return QByteArray();
             QPixmap qpm = QPixmap::fromX11Pixmap(xpm);
             QImageWriter imageWriter;
             imageWriter.setFormat("PPMRAW");
             QImage imageToWrite = qpm.toImage();
             QBuffer buf;
             buf.open(QIODevice::WriteOnly);
             imageWriter.setDevice(&buf);
             imageWriter.write(imageToWrite);
             return buf.buffer();
         }
     }
     return QVariant();
 }

◆ xdndMimeDataForAtom()

bool QX11Data::xdndMimeDataForAtom	(	Atom	a,
		QMimeData *	mimeData,
		QByteArray *	data,
		Atom *	atomFormat,
		int *	dataFormat
	)

Definition at line 477 of file qdnd_x11.cpp.

 {
     bool ret = false;
     *atomFormat = a;
     *dataFormat = 8;
     QString atomName = xdndMimeAtomToString(a);
     if (QInternalMimeData::hasFormatHelper(atomName, mimeData)) {
         *data = QInternalMimeData::renderDataHelper(atomName, mimeData);
         if (atomName == QLatin1String("application/x-color"))
             *dataFormat = 16;
         ret = true;
     } else {
         if ((a == ATOM(UTF8_STRING) || a == XA_STRING
              || a == ATOM(TEXT) || a == ATOM(COMPOUND_TEXT))
             && QInternalMimeData::hasFormatHelper(QLatin1String("text/plain"), mimeData)) {
             if (a == ATOM(UTF8_STRING)){
                 *data = QInternalMimeData::renderDataHelper(QLatin1String("text/plain"), mimeData);
                 ret = true;
             } else if (a == XA_STRING) {
                 *data = QString::fromUtf8(QInternalMimeData::renderDataHelper(
                         QLatin1String("text/plain"), mimeData)).toLocal8Bit();
                 ret = true;
             } else if (a == ATOM(TEXT) || a == ATOM(COMPOUND_TEXT)) {
                 // the ICCCM states that TEXT and COMPOUND_TEXT are in the
                 // encoding of choice, so we choose the encoding of the locale
                 QByteArray strData = QString::fromUtf8(QInternalMimeData::renderDataHelper(
                                      QLatin1String("text/plain"), mimeData)).toLocal8Bit();
                 char *list[] = { strData.data(), NULL };
 
                 XICCEncodingStyle style = (a == ATOM(COMPOUND_TEXT))
                                         ? XCompoundTextStyle : XStdICCTextStyle;
                 XTextProperty textprop;
                 if (list[0] != NULL
                     && XmbTextListToTextProperty(X11->display, list, 1, style,
                                                  &textprop) == Success) {
                     *atomFormat = textprop.encoding;
                     *dataFormat = textprop.format;
                     *data = QByteArray((const char *) textprop.value, textprop.nitems * textprop.format / 8);
                     ret = true;
 
                     DEBUG("    textprop type %lx\n"
                     "    textprop name '%s'\n"
                     "    format %d\n"
                     "    %ld items\n"
                     "    %d bytes\n",
                     textprop.encoding,
                     X11->xdndMimeAtomToString(textprop.encoding).toLatin1().data(),
                     textprop.format, textprop.nitems, data->size());
 
                     XFree(textprop.value);
                 }
             }
         } else if (atomName == QLatin1String("text/x-moz-url") &&
                    QInternalMimeData::hasFormatHelper(QLatin1String("text/uri-list"), mimeData)) {
             QByteArray uri = QInternalMimeData::renderDataHelper(
                              QLatin1String("text/uri-list"), mimeData).split('\n').first();
             QString mozUri = QString::fromLatin1(uri, uri.size());
             mozUri += QLatin1Char('\n');
             *data = QByteArray(reinterpret_cast<const char *>(mozUri.utf16()), mozUri.length() * 2);
             ret = true;
         } else if ((a == XA_PIXMAP || a == XA_BITMAP) && mimeData->hasImage()) {
             QPixmap pm = qvariant_cast<QPixmap>(mimeData->imageData());
             if (a == XA_BITMAP && pm.depth() != 1) {
                 QImage img = pm.toImage();
                 img = img.convertToFormat(QImage::Format_MonoLSB);
                 pm = QPixmap::fromImage(img);
             }
             QDragManager *dm = QDragManager::self();
             if (dm) {
                 Pixmap handle = pm.handle();
                 *data = QByteArray((const char *) &handle, sizeof(Pixmap));
                 dm->xdndMimeTransferedPixmap[dm->xdndMimeTransferedPixmapIndex] = pm;
                 dm->xdndMimeTransferedPixmapIndex =
                             (dm->xdndMimeTransferedPixmapIndex + 1) % 2;
                 ret = true;
             }
         } else {
             DEBUG("QClipboard: xdndMimeDataForAtom(): converting to type '%s' is not supported", qPrintable(atomName));
         }
     }
     return ret && data != 0;
 }

◆ xdndMimeFormatsForAtom()

QStringList QX11Data::xdndMimeFormatsForAtom ( Atom a )

Definition at line 453 of file qdnd_x11.cpp.

 {
     QStringList formats;
     if (a) {
         QString atomName = xdndMimeAtomToString(a);
         formats.append(atomName);
 
         // special cases for string type
         if (a == ATOM(UTF8_STRING) || a == XA_STRING
             || a == ATOM(TEXT) || a == ATOM(COMPOUND_TEXT))
             formats.append(QLatin1String("text/plain"));
 
         // special cases for uris
         if (atomName == QLatin1String("text/x-moz-url"))
             formats.append(QLatin1String("text/uri-list"));
 
         // special case for images
         if (a == XA_PIXMAP)
             formats.append(QLatin1String("image/ppm"));
     }
     return formats;
 }

◆ xdndMimeStringToAtom()

Atom QX11Data::xdndMimeStringToAtom ( const QString & mimeType )

Definition at line 445 of file qdnd_x11.cpp.

 {
     if (mimeType.isEmpty())
         return 0;
     return XInternAtom(display, mimeType.toLatin1().constData(), False);
 }

◆ xdndSetup()

void QX11Data::xdndSetup ( )

static

Definition at line 707 of file qdnd_x11.cpp.

                          {
     QCursorData::initialize();
     qAddPostRoutine(qt_xdnd_cleanup);
 }

◆ xdndStringToAtom()

Atom QX11Data::xdndStringToAtom ( const char * mimeType )

Definition at line 425 of file qdnd_x11.cpp.

 {
     if (!mimeType || !*mimeType)
         return 0;
     return XInternAtom(display, mimeType, False);
 }

Properties

◆ argbColormaps

Colormap* QX11Data::argbColormaps

Definition at line 471 of file qt_x11_p.h.

◆ argbVisuals

Visual** QX11Data::argbVisuals

Definition at line 470 of file qt_x11_p.h.

◆ atoms

Atom QX11Data::atoms[NAtoms]

Definition at line 698 of file qt_x11_p.h.

◆ bppForDepth

QHash<int, int> QX11Data::bppForDepth

Definition at line 474 of file qt_x11_p.h.

◆ color_count

int QX11Data::color_count

Definition at line 499 of file qt_x11_p.h.

◆ colormap

Colormap QX11Data::colormap

Definition at line 504 of file qt_x11_p.h.

◆ compositingManagerRunning

bool QX11Data::compositingManagerRunning

Definition at line 702 of file qt_x11_p.h.

◆ custom_cmap

bool QX11Data::custom_cmap

Definition at line 500 of file qt_x11_p.h.

◆ default_im

QString QX11Data::default_im

Definition at line 479 of file qt_x11_p.h.

◆ defaultScreen

int QX11Data::defaultScreen

Definition at line 473 of file qt_x11_p.h.

◆ deferred_map

QList<QWidget *> QX11Data::deferred_map

Definition at line 453 of file qt_x11_p.h.

◆ desktopEnvironment

DesktopEnvironment QX11Data::desktopEnvironment

Definition at line 533 of file qt_x11_p.h.

◆ desktopVersion

uint QX11Data::desktopVersion

Definition at line 534 of file qt_x11_p.h.

◆ display

Display* QX11Data::display

Definition at line 392 of file qt_x11_p.h.

◆ displayName

char* QX11Data::displayName

Definition at line 393 of file qt_x11_p.h.

◆ dndDropTransactions

QList<QXdndDropTransaction> QX11Data::dndDropTransactions

Definition at line 383 of file qt_x11_p.h.

◆ fc_antialias

bool QX11Data::fc_antialias

Definition at line 528 of file qt_x11_p.h.

◆ fc_hint_style

int QX11Data::fc_hint_style

Definition at line 529 of file qt_x11_p.h.

◆ fc_scale

qreal QX11Data::fc_scale

Definition at line 527 of file qt_x11_p.h.

◆ focus_model

int QX11Data::focus_model

Definition at line 401 of file qt_x11_p.h.

◆ foreignDisplay

bool QX11Data::foreignDisplay

Definition at line 394 of file qt_x11_p.h.

◆ has_fontconfig

bool QX11Data::has_fontconfig

Definition at line 526 of file qt_x11_p.h.

◆ ignore_badwindow

bool QX11Data::ignore_badwindow

Definition at line 493 of file qt_x11_p.h.

Referenced by badwindow(), and ignoreBadwindow().

◆ mitshm_major

int QX11Data::mitshm_major

Definition at line 439 of file qt_x11_p.h.

◆ motifdnd_active

bool QX11Data::motifdnd_active

Definition at line 390 of file qt_x11_p.h.

◆ net_supported_list

Atom* QX11Data::net_supported_list

Definition at line 463 of file qt_x11_p.h.

◆ net_virtual_root_list

Window* QX11Data::net_virtual_root_list

Definition at line 465 of file qt_x11_p.h.

◆ pattern_fills

struct QX11Data::PatternFills QX11Data::pattern_fills[pattern_fill_count]

◆ ptrXCloseDevice

PtrXCloseDevice QX11Data::ptrXCloseDevice

Definition at line 428 of file qt_x11_p.h.

◆ ptrXcursorLibraryLoadCursor

PtrXcursorLibraryLoadCursor QX11Data::ptrXcursorLibraryLoadCursor

Definition at line 705 of file qt_x11_p.h.

◆ ptrXFixesQueryExtension

PtrXFixesQueryExtension QX11Data::ptrXFixesQueryExtension

Definition at line 421 of file qt_x11_p.h.

◆ ptrXFixesQueryVersion

PtrXFixesQueryVersion QX11Data::ptrXFixesQueryVersion

Definition at line 422 of file qt_x11_p.h.

◆ ptrXFixesSelectSelectionInput

PtrXFixesSelectSelectionInput QX11Data::ptrXFixesSelectSelectionInput

Definition at line 424 of file qt_x11_p.h.

◆ ptrXFixesSetCursorName

PtrXFixesSetCursorName QX11Data::ptrXFixesSetCursorName

Definition at line 423 of file qt_x11_p.h.

◆ ptrXFreeDeviceList

PtrXFreeDeviceList QX11Data::ptrXFreeDeviceList

Definition at line 431 of file qt_x11_p.h.

◆ ptrXineramaIsActive

PtrXineramaIsActive QX11Data::ptrXineramaIsActive

Definition at line 710 of file qt_x11_p.h.

◆ ptrXineramaQueryExtension

PtrXineramaQueryExtension QX11Data::ptrXineramaQueryExtension

Definition at line 709 of file qt_x11_p.h.

◆ ptrXineramaQueryScreens

PtrXineramaQueryScreens QX11Data::ptrXineramaQueryScreens

Definition at line 711 of file qt_x11_p.h.

◆ ptrXListInputDevices

PtrXListInputDevices QX11Data::ptrXListInputDevices

Definition at line 429 of file qt_x11_p.h.

◆ ptrXOpenDevice

PtrXOpenDevice QX11Data::ptrXOpenDevice

Definition at line 430 of file qt_x11_p.h.

◆ ptrXRRQueryExtension

PtrXRRQueryExtension QX11Data::ptrXRRQueryExtension

Definition at line 718 of file qt_x11_p.h.

◆ ptrXRRRootToScreen

PtrXRRRootToScreen QX11Data::ptrXRRRootToScreen

Definition at line 717 of file qt_x11_p.h.

◆ ptrXRRSelectInput

PtrXRRSelectInput QX11Data::ptrXRRSelectInput

Definition at line 715 of file qt_x11_p.h.

◆ ptrXRRUpdateConfiguration

PtrXRRUpdateConfiguration QX11Data::ptrXRRUpdateConfiguration

Definition at line 716 of file qt_x11_p.h.

◆ ptrXSelectExtensionEvent

PtrXSelectExtensionEvent QX11Data::ptrXSelectExtensionEvent

Definition at line 432 of file qt_x11_p.h.

◆ screenCount

int QX11Data::screenCount

Definition at line 472 of file qt_x11_p.h.

◆ screens

QX11InfoData* QX11Data::screens

Definition at line 469 of file qt_x11_p.h.

◆ seen_badwindow

bool QX11Data::seen_badwindow

Definition at line 494 of file qt_x11_p.h.

Referenced by badwindow(), and ignoreBadwindow().

◆ sip_list

QList<ScrollInProgress> QX11Data::sip_list

Definition at line 460 of file qt_x11_p.h.

◆ sip_serial

long QX11Data::sip_serial

Definition at line 459 of file qt_x11_p.h.

◆ solid_fills

struct QX11Data::SolidFills QX11Data::solid_fills[solid_fill_count]

◆ startupId

char* QX11Data::startupId

Definition at line 531 of file qt_x11_p.h.

◆ time

Time QX11Data::time

Definition at line 476 of file qt_x11_p.h.

Referenced by x11Time().

◆ use_mitshm

bool QX11Data::use_mitshm

Definition at line 437 of file qt_x11_p.h.

◆ use_mitshm_pixmaps

bool QX11Data::use_mitshm_pixmaps

Definition at line 438 of file qt_x11_p.h.

◆ use_xfixes

bool QX11Data::use_xfixes

Definition at line 415 of file qt_x11_p.h.

◆ use_xinput

bool QX11Data::use_xinput

Definition at line 442 of file qt_x11_p.h.

◆ use_xkb

bool QX11Data::use_xkb

Definition at line 448 of file qt_x11_p.h.

◆ use_xrandr

bool QX11Data::use_xrandr

Definition at line 404 of file qt_x11_p.h.

◆ use_xrender

bool QX11Data::use_xrender

Definition at line 410 of file qt_x11_p.h.

◆ userTime

Time QX11Data::userTime

Definition at line 477 of file qt_x11_p.h.

◆ visual

Visual* QX11Data::visual

Definition at line 503 of file qt_x11_p.h.

◆ visual_class

int QX11Data::visual_class

Definition at line 497 of file qt_x11_p.h.

◆ visual_id

int QX11Data::visual_id

Definition at line 498 of file qt_x11_p.h.

◆ wm_client_leader

Window QX11Data::wm_client_leader

Definition at line 467 of file qt_x11_p.h.

◆ xfixes_errorbase

int QX11Data::xfixes_errorbase

Definition at line 418 of file qt_x11_p.h.

◆ xfixes_eventbase

int QX11Data::xfixes_eventbase

Definition at line 417 of file qt_x11_p.h.

◆ xfixes_major

int QX11Data::xfixes_major

Definition at line 416 of file qt_x11_p.h.

◆ xinput_errorbase

int QX11Data::xinput_errorbase

Definition at line 445 of file qt_x11_p.h.

◆ xinput_eventbase

int QX11Data::xinput_eventbase

Definition at line 444 of file qt_x11_p.h.

◆ xinput_major

int QX11Data::xinput_major

Definition at line 443 of file qt_x11_p.h.

◆ xkb_errorbase

int QX11Data::xkb_errorbase

Definition at line 451 of file qt_x11_p.h.

◆ xkb_eventbase

int QX11Data::xkb_eventbase

Definition at line 450 of file qt_x11_p.h.

◆ xkb_major

int QX11Data::xkb_major

Definition at line 449 of file qt_x11_p.h.

◆ xrandr_errorbase

int QX11Data::xrandr_errorbase

Definition at line 407 of file qt_x11_p.h.

◆ xrandr_eventbase

int QX11Data::xrandr_eventbase

Definition at line 406 of file qt_x11_p.h.

◆ xrandr_major

int QX11Data::xrandr_major

Definition at line 405 of file qt_x11_p.h.

◆ xrender_major

int QX11Data::xrender_major

Definition at line 411 of file qt_x11_p.h.

◆ xrender_version

int QX11Data::xrender_version

Definition at line 412 of file qt_x11_p.h.

The documentation for this struct was generated from the following files:

/src/gui/kernel/qt_x11_p.h
/src/gui/kernel/qapplication_x11.cpp
/src/gui/kernel/qclipboard_x11.cpp
/src/gui/kernel/qdnd_x11.cpp
/src/gui/kernel/qmotifdnd_x11.cpp
/src/gui/kernel/qwidget_x11.cpp

Classes

Public Types

Public Functions

Static Public Functions

Public Variables

Detailed Description

Enumerations

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

◆ X11Atom

Functions

◆ badwindow()

◆ clipboardReadIncrementalProperty()

◆ clipboardReadProperty()

◆ clipboardWaitForEvent()

◆ dndEnable()

◆ findClientWindow()

◆ getSolidFill()

◆ ignoreBadwindow()

◆ isSupportedByWM()

◆ motifdndEnable()

◆ motifdndFormat()

◆ motifdndHandle()

◆ motifdndObtainData()

◆ preMultiply()

◆ translateModifiers()

◆ xdndAtomToString()

◆ xdndHandleBadwindow()

◆ xdndHandleDrop()

◆ xdndHandleEnter()

◆ xdndHandleFinished()

◆ xdndHandleLeave()

◆ xdndHandlePosition()

◆ xdndHandleSelectionRequest()

◆ xdndHandleStatus()

◆ xdndMimeAtomForFormat()

◆ xdndMimeAtomsForFormat()

◆ xdndMimeAtomToString()

◆ xdndMimeConvertToFormat()

◆ xdndMimeDataForAtom()

◆ xdndMimeFormatsForAtom()

◆ xdndMimeStringToAtom()

◆ xdndSetup()

◆ xdndStringToAtom()

Properties

◆ argbColormaps

◆ argbVisuals

◆ atoms

◆ bppForDepth

◆ color_count

◆ colormap

◆ compositingManagerRunning

◆ custom_cmap

◆ default_im

◆ defaultScreen

◆ deferred_map

◆ desktopEnvironment

◆ desktopVersion

◆ display

◆ displayName

◆ dndDropTransactions

◆ fc_antialias

◆ fc_hint_style

◆ fc_scale

◆ focus_model

◆ foreignDisplay

◆ has_fontconfig

◆ ignore_badwindow

◆ mitshm_major

◆ motifdnd_active

◆ net_supported_list

◆ net_virtual_root_list

◆ pattern_fills

◆ ptrXCloseDevice

◆ ptrXcursorLibraryLoadCursor

◆ ptrXFixesQueryExtension

◆ ptrXFixesQueryVersion

◆ ptrXFixesSelectSelectionInput

◆ ptrXFixesSetCursorName