45 #ifdef QCLIPBOARD_DEBUG 48 # define DEBUG if (false) qDebug 51 #ifdef QCLIPBOARD_DEBUG_VERBOSE 52 # define VDEBUG qDebug 54 # define VDEBUG if (false) qDebug 57 #include "qplatformdefs.h" 62 #ifndef QT_NO_CLIPBOARD 81 #include <private/qwidget_p.h> 84 #include <X11/extensions/Xfixes.h> 85 #endif // QT_NO_XFIXES 182 delete mimeDataRef();
190 return mimeDataRef();
195 timestamp = CurrentTime;
216 timestamp = CurrentTime;
217 mode = clipboardMode;
235 if (internalCbData == 0) {
250 if (internalSelData == 0) {
282 if (it != transactions->
end()) {
283 if ((*it)->x11Event(
event) != 0)
298 qWarning(
"QClipboard: Timed out while sending data");
301 delete *transactions->
begin();
308 DEBUG(
"QClipboard: sending %d bytes (INCR transaction %p)", d.
size(),
this);
310 XSelectInput(
X11->display,
window, PropertyChangeMask);
312 if (! transactions) {
313 VDEBUG(
"QClipboard: created INCR transaction map");
323 VDEBUG(
"QClipboard: destroyed INCR transacton %p",
this);
325 XSelectInput(
X11->display,
window, NoEventMask);
329 VDEBUG(
"QClipboard: no more INCR transactions");
344 if (event->type != PropertyNotify
345 || (event->xproperty.state != PropertyDelete
346 || event->xproperty.atom !=
property))
354 if (bytes_left > 0) {
356 VDEBUG(
"QClipboard: sending %d bytes, %d remaining (INCR transaction %p)",
357 xfer, bytes_left - xfer,
this);
382 #if defined(Q_C_CALLBACKS) 411 data->
timestamp =
event->xselectionclear.time;
417 if (
X11->use_xfixes && event->type == (
X11->xfixes_eventbase + XFixesSelectionNotify)) {
418 XFixesSelectionNotifyEvent *req =
419 reinterpret_cast<XFixesSelectionNotifyEvent *
>(
event);
420 data->
timestamp = req->selection_timestamp;
426 #if defined(Q_C_CALLBACKS) 439 if (
X11->use_xfixes &&
X11->ptrXFixesSelectSelectionInput) {
440 const unsigned long eventMask =
441 XFixesSetSelectionOwnerNotifyMask | XFixesSelectionWindowDestroyNotifyMask | XFixesSelectionClientCloseNotifyMask;
442 for (
int i = 0; i <
X11->screenCount; ++i) {
444 XA_PRIMARY, eventMask);
449 #endif // QT_NO_XFIXES 451 if (
X11->time == CurrentTime) {
457 if (data.timestamp == CurrentTime) {
462 XChangeProperty(
X11->display, ownerId,
464 PropModeReplace, (
uchar*)&dummy, 1);
465 XWindowEvent(
X11->display, ownerId, PropertyChangeMask, &ev);
466 data.timestamp = ev.xproperty.time;
469 X11->time = data.timestamp;
502 VDEBUG(
"QClipboard: event_filter(): caught event type %d",
event->type);
512 return ((e->type == SelectionRequest && (e->xselectionrequest.selection == XA_PRIMARY
514 || (e->type == SelectionClear && (e->xselectionclear.selection == XA_PRIMARY
527 Q_ASSERT(!
"QClipboard: internal error, qt_xclb_wait_for_event recursed");
541 if (XCheckTypedWindowEvent(
display, win, type, event)) {
543 qApp->setEventFilter(old_event_filter);
550 XSync(
X11->display,
false);
565 qApp->setEventFilter(old_event_filter);
568 }
while (started.
msecsTo(now) < timeout);
571 qApp->setEventFilter(old_event_filter);
574 if (XCheckTypedWindowEvent(
X11->display,win,type,event))
586 qApp->x11ProcessEvent(&e);
590 XFlush(
X11->display);
593 struct timeval usleep_tv;
594 usleep_tv.tv_sec = 0;
595 usleep_tv.tv_usec = 50000;
596 select(0, 0, 0, 0, &usleep_tv);
597 }
while (started.
msecsTo(now) < timeout);
604 {
return XMaxRequestSize(dpy) > 65536 ? 65536*4 : XMaxRequestSize(dpy)*4 - 100; }
620 format = &dummy_format;
623 r = XGetWindowProperty(
display, win, property, 0, 0, False,
624 AnyPropertyType, type, format,
625 &length, &bytes_left, &data);
632 int offset = 0, buffer_offset = 0, format_inc = 1, proplen = bytes_left;
634 VDEBUG(
"QClipboard: read_property(): initial property length: %d", proplen);
639 format_inc =
sizeof(char) / 1;
643 format_inc =
sizeof(short) / 2;
644 proplen *=
sizeof(short) / 2;
648 format_inc =
sizeof(long) / 4;
649 proplen *=
sizeof(long) / 4;
653 int newSize = proplen;
656 bool ok = (buffer->
size() == newSize);
657 VDEBUG(
"QClipboard: read_property(): buffer resized to %d", buffer->
size());
665 r = XGetWindowProperty(
display, win, property, offset, maxsize/4,
666 False, AnyPropertyType, type, format,
667 &length, &bytes_left, &data);
671 offset += length / (32 / *
format);
672 length *= format_inc * (*format) / 8;
677 if ((
int)(buffer_offset + length) > buffer->
size()) {
678 length = buffer->
size() - buffer_offset;
684 memcpy(buffer->
data() + buffer_offset,
data, length);
685 buffer_offset += length;
692 XTextProperty textprop;
693 textprop.encoding = *
type;
694 textprop.format = *
format;
695 textprop.nitems = buffer_offset;
696 textprop.value = (
unsigned char *) buffer->
data();
700 if (XmbTextPropertyToTextList(
display, &textprop, &list_ret,
701 &count) ==
Success && count && list_ret) {
702 offset = buffer_offset = strlen(list_ret[0]);
704 memcpy(buffer->
data(), list_ret[0], offset);
706 if (list_ret) XFreeStringList(list_ret);
712 *size = buffer_offset;
714 VDEBUG(
"QClipboard: read_property(): buffer size %d, buffer offset %d, offset %d",
715 buffer->
size(), buffer_offset, offset);
718 XDeleteProperty(
display, win, property);
731 bool alloc_error =
false;
740 alloc_error = buf.
size() != nbytes+1;
747 if (event.xproperty.atom != property ||
748 event.xproperty.state != PropertyNewValue)
750 if (
X11->clipboardReadProperty(win, property,
true, &tmp_buf, &length, 0, 0)) {
759 }
else if (!alloc_error) {
760 if (offset+length > (
int)buf.
size()) {
761 buf.
resize(offset+length+65535);
762 if (buf.
size() != offset+length+65535) {
764 length = buf.
size() - offset;
792 for (
int i = 0; i < formats.
size(); ++i) {
794 for (
int j = 0; j < atoms.
size(); ++j) {
804 XChangeProperty(
X11->display, window, property, XA_ATOM, 32,
811 Atom atomFormat = target;
817 DEBUG(
"QClipboard: send_selection(): converting to type '%s' is not supported", fmt.
data());
820 DEBUG(
"QClipboard: send_selection(): converting to type '%s'", fmt.
data());
822 if (
X11->xdndMimeDataForAtom(target, d->
source(), &
data, &atomFormat, &dataFormat)) {
824 VDEBUG(
"QClipboard: send_selection():\n" 825 " property type %lx\n" 826 " property name '%s'\n" 829 target,
X11->xdndMimeAtomToString(atomFormat).toLatin1().data(), dataFormat, data.
size());
834 bool allow_incr =
property != motif_clip_temporary;
837 const int increment = (XMaxRequestSize(
X11->display) * 4) - 24;
838 if (data.
size() > increment && allow_incr) {
839 long bytes = data.
size();
840 XChangeProperty(
X11->display, window, property,
848 if (data.
size() > increment)
850 int dataSize = data.
size() / (dataFormat / 8);
852 XChangeProperty(
X11->display, window, property, atomFormat,
853 dataFormat, PropModeReplace, (
uchar *) data.
data(),
892 if (selection_watcher)
894 if (clipboard_watcher)
951 if (!
X11->clipboardWaitForEvent(ownerId, SelectionNotify, &event, 10000,
true)) {
952 qWarning(
"QClipboard: Unable to receive an event from the " 953 "clipboard manager in a reasonable time");
959 switch (xevent->type) {
963 if (xevent->xselectionclear.selection == XA_PRIMARY) {
970 DEBUG(
"QClipboard: new selection owner 0x%lx at time %lx (ours %lx)",
971 XGetSelectionOwner(dpy, XA_PRIMARY),
972 xevent->xselectionclear.time, d->
timestamp);
982 }
else if (xevent->xselectionclear.selection ==
ATOM(
CLIPBOARD)) {
989 DEBUG(
"QClipboard: new clipboard owner 0x%lx at time %lx (%lx)",
991 xevent->xselectionclear.time, d->
timestamp);
1002 qWarning(
"QClipboard: Unknown SelectionClear event received");
1007 case SelectionNotify:
1017 case SelectionRequest:
1020 XSelectionRequestEvent *req = &xevent->xselectionrequest;
1022 if (requestor && req->requestor == requestor->
internalWinId())
1026 event.xselection.type = SelectionNotify;
1027 event.xselection.display = req->display;
1028 event.xselection.requestor = req->requestor;
1029 event.xselection.selection = req->selection;
1030 event.xselection.target = req->target;
1031 event.xselection.property =
XNone;
1032 event.xselection.time = req->time;
1034 DEBUG(
"QClipboard: SelectionRequest from %lx\n" 1035 " selection 0x%lx (%s) target 0x%lx (%s)",
1038 X11->xdndAtomToString(req->selection).data(),
1040 X11->xdndAtomToString(req->target).data());
1043 if (req->selection == XA_PRIMARY) {
1048 qWarning(
"QClipboard: Unknown selection '%lx'", req->selection);
1049 XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
1053 if (! d->source()) {
1054 qWarning(
"QClipboard: Cannot transfer data, no data available");
1055 XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
1059 DEBUG(
"QClipboard: SelectionRequest at time %lx (ours %lx)",
1060 req->time, d->timestamp);
1062 if (d->timestamp == CurrentTime
1063 || (req->time != CurrentTime && req->time < d->timestamp)) {
1064 DEBUG(
"QClipboard: SelectionRequest too old");
1065 XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
1075 int multi_format = 0;
1078 bool multi_writeback =
false;
1080 if (req->target == xa_multiple) {
1082 if (req->property ==
XNone 1083 || !
X11->clipboardReadProperty(req->requestor, req->property,
false, &multi_data,
1084 0, &multi_type, &multi_format)
1085 || multi_format != 32) {
1087 XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
1090 nmulti = multi_data.
size()/
sizeof(*multi);
1091 multi =
new AtomPair[nmulti];
1092 memcpy(multi,multi_data.
data(),multi_data.
size());
1096 for (; imulti < nmulti; ++imulti) {
1101 target = multi[imulti].target;
1102 property = multi[imulti].property;
1104 target = req->target;
1105 property = req->property;
1106 if (property ==
XNone)
1113 }
else if (target == xa_timestamp) {
1114 if (d->timestamp != CurrentTime) {
1115 XChangeProperty(dpy, req->requestor, property, XA_INTEGER, 32,
1116 PropModeReplace, (
uchar *) &d->timestamp, 1);
1119 qWarning(
"QClipboard: Invalid data timestamp");
1121 }
else if (target == xa_targets) {
1129 multi[imulti].property =
XNone;
1130 multi_writeback =
true;
1133 event.xselection.property = ret;
1139 if (multi_writeback) {
1142 XChangeProperty(dpy, req->requestor, req->property, multi_type, 32,
1143 PropModeReplace, (
uchar *) multi, nmulti * 2);
1147 event.xselection.property = req->property;
1151 XSendEvent(dpy, req->requestor, False, NoEventMask, &event);
1153 DEBUG(
"QClipboard: SelectionNotify to 0x%lx\n" 1154 " property 0x%lx (%s)",
1155 req->requestor, event.xselection.property,
1156 X11->xdndAtomToString(event.xselection.property).data());
1182 qWarning(
"QClipboardWatcher: Internal error: Unsupported clipboard mode");
1191 if(selection_watcher ==
this)
1192 selection_watcher = 0;
1193 if(clipboard_watcher ==
this)
1194 clipboard_watcher = 0;
1203 qWarning(
"QClipboardWatcher::empty: Internal error: Application owns the selection");
1207 return win ==
XNone;
1226 for (
int i = 0; i < size; ++i) {
1227 if (targets[i] == 0)
1230 QStringList formatsForAtom =
X11->xdndMimeFormatsForAtom(targets[i]);
1231 for (
int j = 0; j < formatsForAtom.
size(); ++j) {
1235 VDEBUG(
" format: %s",
X11->xdndAtomToString(targets[i]).data());
1262 for (
int i = 0; i < size; ++i)
1263 atoms.append(targets[i]);
1266 Atom fmtatom =
X11->xdndMimeAtomForFormat(fmt, requestedType, atoms, &encoding);
1271 return X11->xdndMimeConvertToFormat(fmtatom,
getDataInFormat(fmtatom), fmt, requestedType, encoding);
1283 DEBUG(
"QClipboardWatcher::getDataInFormat: selection '%s' format '%s'",
1284 X11->xdndAtomToString(
atom).data(),
X11->xdndAtomToString(fmtatom).data());
1286 XSelectInput(dpy, win, NoEventMask);
1292 VDEBUG(
"QClipboardWatcher::getDataInFormat: waiting for SelectionNotify event");
1296 xevent.xselection.property ==
XNone) {
1297 DEBUG(
"QClipboardWatcher::getDataInFormat: format not available");
1301 VDEBUG(
"QClipboardWatcher::getDataInFormat: fetching data...");
1304 XSelectInput(dpy, win, PropertyChangeMask);
1308 int nbytes = buf.
size() >= 4 ? *((
int*)buf.
data()) : 0;
1313 XSelectInput(dpy, win, NoEventMask);
1315 DEBUG(
"QClipboardWatcher::getDataInFormat: %d bytes received", buf.
size());
1332 qWarning(
"QClipboard::mimeData: unsupported mode '%d'", mode);
1337 if (mode == Selection) {
1338 if (! selection_watcher)
1342 if (! clipboard_watcher)
1380 qWarning(
"QClipboard::setMimeData: unsupported mode '%d'", mode);
1399 Window prevOwner = XGetSelectionOwner(dpy, atom);
1401 XSetSelectionOwner(dpy, atom, newOwner,
X11->time);
1403 if (mode == Selection)
1408 if (XGetSelectionOwner(dpy, atom) != newOwner) {
1409 qWarning(
"QClipboard::setData: Cannot set X11 selection owner for %s",
1410 X11->xdndAtomToString(atom).data());
1417 owners[0] = newOwner;
1418 owners[1] = prevOwner;
1420 sentinel_atom, XA_WINDOW, 32, PropModeReplace,
1421 (
unsigned char*)&owners, 2);
1436 if (owner && !
X11->use_xfixes) {
1448 unsigned char *retval;
1454 if (XGetWindowProperty(
X11->display,
1457 &actualType, &actualFormat, &nitems,
1458 &bytesLeft, &retval) ==
Success) {
1460 if (actualType == XA_WINDOW && actualFormat == 32 && nitems == 2) {
1462 if (owners[0] == win || owners[1] == win)
1488 if (owner && !
X11->use_xfixes) {
1489 unsigned char *retval;
1492 unsigned long nitems, bytesLeft;
1494 if (XGetWindowProperty(
X11->display,
1497 &actualType, &actualFormat, &nitems, &bytesLeft,
1500 if (actualType == XA_WINDOW && actualFormat == 32 && nitems == 2) {
1502 if (owners[0] == win || owners[1] == win)
1527 #ifdef QCLIPBOARD_DEBUG 1528 DEBUG(
"qt_xfixes_selection_changed: owner = %u; selectionOwner = %u; internal timestamp = %u; external timestamp = %u",
1529 (
unsigned int)(owner ? (
int)owner->
internalWinId() : 0), (
unsigned int)selectionOwner,
1530 (
unsigned int)(d ? d->
timestamp : 0), (
unsigned int)timestamp);
1532 if (!owner || (selectionOwner && selectionOwner != owner->
internalWinId()) ||
1541 #ifdef QCLIPBOARD_DEBUG 1542 DEBUG(
"qt_xfixes_clipboard_changed: owner = %u; clipboardOwner = %u; internal timestamp = %u; external timestamp = %u",
1543 (
unsigned int)(owner ? (
int)owner->
internalWinId() : 0), (
unsigned int)clipboardOwner,
1544 (
unsigned int)(d ? d->
timestamp : 0), (
unsigned int)timestamp);
1546 if (!owner || (clipboardOwner && clipboardOwner != owner->
internalWinId()) ||
1554 #endif // QT_NO_CLIPBOARD The QVariant class acts like a union for the most common Qt data types.
Mode
This enum type is used to control which part of the system clipboard is used by QClipboard::mimeData(...
int startTimer(int interval)
Starts a timer and returns a timer identifier, or returns zero if it could not start a timer...
static bool qt_x11_incr_event_filter(void *message, long *result)
bool qt_check_clipboard_sentinel()
static Atom send_targets_selection(QClipboardData *d, Window window, Atom property)
void clear(Mode mode=Clipboard)
Clear the clipboard contents.
QStringList formats_sys() const
void emitChanged(Mode mode)
Emits the appropriate changed signal for mode.
static void cleanupSelectionData()
bool clipboardReadProperty(Window win, Atom property, bool deleteProperty, QByteArray *buffer, int *size, Atom *type, int *format)
bool filterEvent(void *message)
Sends message through the event filter that was set by setEventFilter().
static int clipboard_timeout
Q_DECL_CONSTEXPR const T & qMin(const T &a, const T &b)
void clear()
Removes all the MIME type and data entries in the object.
#define QT_END_NAMESPACE
This macro expands to.
QByteArray clipboardReadIncrementalProperty(Window win, Atom property, int nbytes, bool nullterm)
static bool timer_event_clear
char * data()
Returns a pointer to the data stored in the byte array.
bool event(QEvent *)
Reimplemented Function
void ownerDestroyed()
Internal cleanup for Windows.
#define it(className, varName)
void qAddPostRoutine(QtCleanUpFunction p)
QMap< Window, QClipboardINCRTransaction * > TransactionMap
static bool pending_clipboard_changed
QClipboard(QObject *parent)
static QAbstractEventDispatcher * instance(QThread *thread=0)
Returns a pointer to the event dispatcher object for the specified thread.
qint64 msecsTo(const QElapsedTimer &other) const
Returns the number of milliseconds between this QElapsedTimer and other.
static Bool checkForClipboardEvents(Display *, XEvent *e, XPointer)
static int pending_timer_id
static void cleanupClipboardData()
bool remove(const T &value)
The QByteArray class provides an array of bytes.
static Qt::HANDLE appRootWindow(int screen=-1)
Returns a handle for the applications root window on the given screen.
static QStringList formatsHelper(const QMimeData *data)
static QClipboardData * internalCbData
static QApplication::EventFilter prev_event_filter
static QMimeData * selectionData
int select(int, fd_set *, fd_set *, fd_set *, struct timeval *)
static QClipboardWatcher * selection_watcher
static QClipboardData * internalSelData
QLatin1String(DBUS_INTERFACE_DBUS))) Q_GLOBAL_STATIC_WITH_ARGS(QString
bool supportsMode(Mode mode) const
Returns true if the clipboard supports the clipboard mode speacified by mode; otherwise returns false...
int count(const T &t) const
Returns the number of occurrences of value in the list.
iterator find(const Key &key)
Returns an iterator pointing to the item with key key in the map.
QByteArray data(const QString &mimetype) const
Returns the data stored in the object in the format described by the MIME type specified by mimeType...
bool qt_xfixes_selection_changed(Window selectionOwner, Time timestamp)
void setMimeData(QMimeData *data, Mode mode=Clipboard)
Sets the clipboard data to src.
The QString class provides a Unicode character string.
static XEvent captured_event
bool ownsMode(Mode mode) const
Returns true if the clipboard supports the clipboard data speacified by mode; otherwise returns false...
The QVector class is a template class that provides a dynamic array.
The QObject class is the base class of all Qt objects.
virtual bool event(QEvent *)
This virtual function receives events to an object and should return true if the event e was recogniz...
The QElapsedTimer class provides a fast way to calculate elapsed times.
void setObjectName(const QString &name)
~QClipboardINCRTransaction(void)
static TransactionMap * transactions
static bool toBool(Register *reg, int type, bool *ok=0)
void append(const T &t)
Inserts value at the end of the list.
const QMimeData * mimeData(Mode mode=Clipboard) const
Returns a reference to a QMimeData representation of the current clipboard data.
#define QT_BEGIN_NAMESPACE
This macro expands to.
Q_GUI_EXPORT EGLDisplay display()
static QClipboardData * clipboardData()
int x11Event(XEvent *event)
static QClipboard * clipboard()
Returns a pointer to the application global clipboard.
static int capture_event_type
bool isEmpty() const
Returns true if the string has no characters; otherwise returns false.
bool hasFormat_sys(const QString &mimetype) const
const T & at(int i) const
Returns the item at index position i in the list.
The QStringList class provides a list of strings.
QStringList formats() const
Returns a list of formats supported by the object.
void append(const T &t)
Inserts value at the end of the vector.
Q_CORE_EXPORT void qWarning(const char *,...)
int timerId() const
Returns the unique timer identifier, which is the same identifier as returned from QObject::startTime...
static const char * data(const QByteArray &arr)
Type
This enum type defines the types of variable that a QVariant can contain.
QBool contains(const QString &str, Qt::CaseSensitivity cs=Qt::CaseSensitive) const
Returns true if the list contains the string str; otherwise returns false.
The QClipboard class provides access to the window system clipboard.
QByteArray toLatin1() const Q_REQUIRED_RESULT
Returns a Latin-1 representation of the string as a QByteArray.
void setSource(QMimeData *s)
static void qt_xclb_incr_timeout(void)
The QMimeData class provides a container for data that records information about its MIME type...
QVariant retrieveData_sys(const QString &mimetype, QVariant::Type preferredType) const
bool inherits(const char *classname) const
Returns true if this object is an instance of a class that inherits className or a QObject subclass t...
static bool pending_selection_changed
iterator begin()
Returns an STL-style iterator pointing to the first item in the map.
static QDesktopWidget * desktop()
Returns the desktop widget (also called the root window).
const char * constData() const
Returns a pointer to the data stored in the byte array.
int remove(const Key &key)
Removes all the items that have the key key from the map.
static QWidget * requestor
static QClipboardData * selectionData()
The QMap::iterator class provides an STL-style non-const iterator for QMap and QMultiMap.
The QTimerEvent class contains parameters that describe a timer event.
virtual bool processEvents(QEventLoop::ProcessEventsFlags flags)=0
Processes pending events that match flags until there are no more events to process.
iterator end()
Returns an STL-style iterator pointing to the imaginary item after the last item in the map...
static Atom send_selection(QClipboardData *d, Atom target, Window window, Atom property)
iterator insert(const Key &key, const T &value)
Inserts a new item with the key key and a value of value.
void resize(int size)
Sets the size of the byte array to size bytes.
bool(* EventFilter)(void *message, long *result)
A function with the following signature that can be used as an event filter:
int size() const
Returns the number of items in the list.
bool isEmpty() const
Returns true if the map contains no items; otherwise returns false.
static bool waiting_for_data
static Window capture_event_win
int size() const
Returns the number of bytes in this byte array.
bool contains(const T &t) const
Returns true if the vector contains an occurrence of value; otherwise returns false.
bool clipboardWaitForEvent(Window win, int type, XEvent *event, int timeout, bool checkManager=false)
QVariant property(const char *name) const
Returns the value of the object's name property.
The QClipboardEvent class provides the parameters used in a clipboard event.
bool isEmpty() const
Returns true if the byte array has size 0; otherwise returns false.
T * data()
Returns a pointer to the data stored in the vector.
QClipboardINCRTransaction(Window w, Atom p, Atom t, int f, QByteArray d, unsigned int i)
QByteArray getDataInFormat(Atom fmtatom) const
QMimeData * source() const
static int maxSelectionIncr(Display *dpy)
bool qt_check_selection_sentinel()
static QClipboardWatcher * clipboard_watcher
The QEvent class is the base class of all event classes.
Type type() const
Returns the event type.
void qAddPostRoutine(QtCleanUpFunction ptr)
Adds a global routine that will be called from the QApplication destructor.
static bool has_captured_event
int size() const
Returns the number of items in the vector.
QMimeData *& mimeDataRef() const
static bool qt_x11_clipboard_event_filter(void *message, long *)
void start()
Starts this timer.
The QAbstractEventDispatcher class provides an interface to manage Qt's event queue.
static QMimeData * clipboardData
The QMap class is a template class that provides a skip-list-based dictionary.
static Bool qt_init_timestamp_scanner(Display *, XEvent *event, XPointer arg)
bool qt_xfixes_clipboard_changed(Window clipboardOwner, Time timestamp)
void connectNotify(const char *)
Internal optimization for Windows.
The QList class is a template class that provides lists.
void killTimer(int id)
Kills the timer with timer identifier, id.