You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdebase/klipper/clipboardpoll.cpp

335 lines
12 KiB

// -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8; -*-
/* This file is part of the KDE project
Copyright (C) 2003 by Lubos Lunak <l.lunak@kde.org>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "clipboardpoll.h"
#include <kapplication.h>
#include <tqclipboard.h>
#include <kdebug.h>
#include <X11/Xatom.h>
#include <time.h>
#ifdef HAVE_XFIXES
#include <X11/extensions/Xfixes.h>
#endif
#include "toplevel.h"
//#define NOISY_KLIPPER_
/*
The polling magic:
There's no way with X11 how to find out if the selection has changed (unless its ownership
is taken away from the current client). In the future, there will be hopefully such notification,
which will make this whole file more or less obsolete. But for now, Klipper has to poll.
In order to avoid transferring all the data on every time pulse, this file implements two
optimizations: The first one is checking whether the selection owner is Qt application (using
the _QT_SELECTION/CLIPBOARD_SENTINEL atoms on the root window of screen 0), and if yes,
Klipper can rely on TQClipboard's signals. If the owner is not Qt app, and the ownership has changed,
it means the selection has changed as well. Otherwise, first only the timestamp
of the last selection change is requested using the TIMESTAMP selection target, and if it's
the same, it's assumed the contents haven't changed. Note that some applications (like XEmacs) does
not provide this information, so Klipper has to assume that the clipboard might have changed in this
case --- this is what is meant by REFUSED below.
Update: Now there's also support for XFixes, so in case XFixes support is detected, only XFixes is
used for detecting changes, everything else is ignored, even Qt's clipboard signals.
*/
ClipboardPoll::ClipboardPoll( TQWidget* parent )
: TQWidget( parent )
, xfixes_event_base( -1 )
{
hide();
const char* names[ 6 ]
= { "_QT_SELECTION_SENTINEL",
"_QT_CLIPBOARD_SENTINEL",
"CLIPBOARD",
"TIMESTAMP",
"KLIPPER_SELECTION_TIMESTAMP",
"KLIPPER_CLIPBOARD_TIMESTAMP" };
Atom atoms[ 6 ];
XInternAtoms( qt_xdisplay(), const_cast< char** >( names ), 6, False, atoms );
selection.sentinel_atom = atoms[ 0 ];
clipboard.sentinel_atom = atoms[ 1 ];
xa_clipboard = atoms[ 2 ];
xa_timestamp = atoms[ 3 ];
selection.timestamp_atom = atoms[ 4 ];
clipboard.timestamp_atom = atoms[ 5 ];
bool use_polling = true;
kapp->installX11EventFilter( this );
#ifdef HAVE_XFIXES
int dummy;
if( XFixesQueryExtension( qt_xdisplay(), &xfixes_event_base, &dummy ))
{
XFixesSelectSelectionInput( qt_xdisplay(), qt_xrootwin( 0 ), XA_PRIMARY,
XFixesSetSelectionOwnerNotifyMask |
XFixesSelectionWindowDestroyNotifyMask |
XFixesSelectionClientCloseNotifyMask );
XFixesSelectSelectionInput( qt_xdisplay(), qt_xrootwin( 0 ), xa_clipboard,
XFixesSetSelectionOwnerNotifyMask |
XFixesSelectionWindowDestroyNotifyMask |
XFixesSelectionClientCloseNotifyMask );
use_polling = false;
#ifdef NOISY_KLIPPER_
kdDebug() << "Using XFIXES" << endl;
#endif
}
#endif
if( use_polling )
{
#ifdef NOISY_KLIPPER_
kdDebug() << "Using polling" << endl;
#endif
initPolling();
}
}
void ClipboardPoll::initPolling()
{
connect( kapp->clipboard(), TQT_SIGNAL( selectionChanged() ), TQT_SLOT(qtSelectionChanged()));
connect( kapp->clipboard(), TQT_SIGNAL( dataChanged() ), TQT_SLOT( qtClipboardChanged() ));
connect( &timer, TQT_SIGNAL( timeout()), TQT_SLOT( timeout()));
timer.start( 1000, false );
selection.atom = XA_PRIMARY;
clipboard.atom = xa_clipboard;
selection.last_change = clipboard.last_change = GET_QT_X_TIME(); // don't trigger right after startup
selection.last_owner = XGetSelectionOwner( qt_xdisplay(), XA_PRIMARY );
#ifdef NOISY_KLIPPER_
kdDebug() << "(1) Setting last_owner for =" << "selection" << ":" << selection.last_owner << endl;
#endif
clipboard.last_owner = XGetSelectionOwner( qt_xdisplay(), xa_clipboard );
#ifdef NOISY_KLIPPER_
kdDebug() << "(2) Setting last_owner for =" << "clipboard" << ":" << clipboard.last_owner << endl;
#endif
selection.waiting_for_timestamp = false;
clipboard.waiting_for_timestamp = false;
updateQtOwnership( selection );
updateQtOwnership( clipboard );
}
void ClipboardPoll::qtSelectionChanged()
{
emit clipboardChanged( true );
}
void ClipboardPoll::qtClipboardChanged()
{
emit clipboardChanged( false );
}
bool ClipboardPoll::x11Event( XEvent* e )
{
// note that this is also installed as app-wide filter
#ifdef HAVE_XFIXES
if( xfixes_event_base != -1 && e->type == xfixes_event_base + XFixesSelectionNotify )
{
XFixesSelectionNotifyEvent* ev = reinterpret_cast< XFixesSelectionNotifyEvent* >( e );
if( ev->selection == XA_PRIMARY && !kapp->clipboard()->ownsSelection())
{
#ifdef NOISY_KLIPPER_
kdDebug() << "SELECTION CHANGED (XFIXES)" << endl;
#endif
SET_QT_X_TIME(ev->timestamp);
emit clipboardChanged( true );
}
else if( ev->selection == xa_clipboard && !kapp->clipboard()->ownsClipboard())
{
#ifdef NOISY_KLIPPER_
kdDebug() << "CLIPBOARD CHANGED (XFIXES)" << endl;
#endif
SET_QT_X_TIME(ev->timestamp);
emit clipboardChanged( false );
}
}
#endif
if( e->type == SelectionNotify && e->xselection.requestor == winId())
{
if( changedTimestamp( selection, *e ) ) {
#ifdef NOISY_KLIPPER_
kdDebug() << "SELECTION CHANGED (GOT TIMESTAMP)" << endl;
#endif
emit clipboardChanged( true );
}
if ( changedTimestamp( clipboard, *e ) )
{
#ifdef NOISY_KLIPPER_
kdDebug() << "CLIPBOARD CHANGED (GOT TIMESTAMP)" << endl;
#endif
emit clipboardChanged( false );
}
return true; // filter out
}
return false;
}
void ClipboardPoll::updateQtOwnership( SelectionData& data )
{
Atom type;
int format;
unsigned long nitems;
unsigned long after;
unsigned char* prop = NULL;
if( XGetWindowProperty( qt_xdisplay(), qt_xrootwin( 0 ), data.sentinel_atom, 0, 2, False,
XA_WINDOW, &type, &format, &nitems, &after, &prop ) != Success
|| type != XA_WINDOW || format != 32 || nitems != 2 || prop == NULL )
{
#ifdef REALLY_NOISY_KLIPPER_
kdDebug() << "UPDATEQT BAD PROPERTY" << endl;
#endif
data.owner_is_qt = false;
if( prop != NULL )
XFree( prop );
return;
}
Window owner = reinterpret_cast< long* >( prop )[ 0 ]; // [0] is new owner, [1] is previous
XFree( prop );
Window current_owner = XGetSelectionOwner( qt_xdisplay(), data.atom );
data.owner_is_qt = ( owner == current_owner );
#ifdef REALLY_NOISY_KLIPPER_
kdDebug() << "owner=" << owner << "; current_owner=" << current_owner << endl;
kdDebug() << "UPDATEQT:" << ( &data == &selection ? "selection" : "clipboard" ) << ":" << data.owner_is_qt << endl;
#endif
}
void ClipboardPoll::timeout()
{
KlipperWidget::updateTimestamp();
if( !kapp->clipboard()->ownsSelection() && checkTimestamp( selection ) ) {
#ifdef NOISY_KLIPPER_
kdDebug() << "SELECTION CHANGED" << endl;
#endif
emit clipboardChanged( true );
}
if( !kapp->clipboard()->ownsClipboard() && checkTimestamp( clipboard ) ) {
#ifdef NOISY_KLIPPER_
kdDebug() << "CLIPBOARD CHANGED" << endl;
#endif
emit clipboardChanged( false );
}
}
bool ClipboardPoll::checkTimestamp( SelectionData& data )
{
Window current_owner = XGetSelectionOwner( qt_xdisplay(), data.atom );
bool signal = false;
updateQtOwnership( data );
if( data.owner_is_qt )
{
data.last_change = CurrentTime;
#ifdef REALLY_NOISY_KLIPPER_
kdDebug() << "(3) Setting last_owner for =" << ( &data==&selection ?"selection":"clipboard" ) << ":" << current_owner << endl;
#endif
data.last_owner = current_owner;
data.waiting_for_timestamp = false;
return false;
}
if( current_owner != data.last_owner )
{
signal = true; // owner has changed
data.last_owner = current_owner;
#ifdef REALLY_NOISY_KLIPPER_
kdDebug() << "(4) Setting last_owner for =" << ( &data==&selection ?"selection":"clipboard" ) << ":" << current_owner << endl;
#endif
data.waiting_for_timestamp = false;
data.last_change = CurrentTime;
#ifdef REALLY_NOISY_KLIPPER_
kdDebug() << "OWNER CHANGE:" << ( data.atom == XA_PRIMARY ) << ":" << current_owner << endl;
#endif
return true;
}
if( current_owner == None ) {
return false; // None also last_owner...
}
if( data.waiting_for_timestamp ) {
// We're already waiting for the timestamp of the last check
return false;
}
XDeleteProperty( qt_xdisplay(), winId(), data.timestamp_atom );
XConvertSelection( qt_xdisplay(), data.atom, xa_timestamp, data.timestamp_atom, winId(), GET_QT_X_TIME() );
data.waiting_for_timestamp = true;
data.waiting_x_time = GET_QT_X_TIME();
#ifdef REALLY_NOISY_KLIPPER_
kdDebug() << "WAITING TIMESTAMP:" << ( data.atom == XA_PRIMARY ) << endl;
#endif
return false;
}
bool ClipboardPoll::changedTimestamp( SelectionData& data, const XEvent& ev )
{
if( ev.xselection.requestor != winId()
|| ev.xselection.selection != data.atom
|| ev.xselection.time != data.waiting_x_time )
{
return false;
}
data.waiting_for_timestamp = false;
if( ev.xselection.property == None )
{
#ifdef NOISY_KLIPPER_
kdDebug() << "REFUSED:" << ( data.atom == XA_PRIMARY ) << endl;
#endif
return true;
}
Atom type;
int format;
unsigned long nitems;
unsigned long after;
unsigned char* prop = NULL;
if( XGetWindowProperty( qt_xdisplay(), winId(), ev.xselection.property, 0, 1, False,
AnyPropertyType, &type, &format, &nitems, &after, &prop ) != Success
|| format != 32 || nitems != 1 || prop == NULL )
{
#ifdef NOISY_KLIPPER_
kdDebug() << "BAD PROPERTY:" << ( data.atom == XA_PRIMARY ) << endl;
#endif
if( prop != NULL )
XFree( prop );
return true;
}
Time timestamp = reinterpret_cast< long* >( prop )[ 0 ];
XFree( prop );
#ifdef NOISY_KLIPPER_
kdDebug() << "GOT TIMESTAMP:" << ( data.atom == XA_PRIMARY ) << endl;
kdDebug() << "timestamp=" << timestamp
<< "; CurrentTime=" << CurrentTime
<< "; last_change=" << data.last_change
<< endl;
#endif
if( timestamp != data.last_change || timestamp == CurrentTime )
{
#ifdef NOISY_KLIPPER_
kdDebug() << "TIMESTAMP CHANGE:" << ( data.atom == XA_PRIMARY ) << endl;
#endif
data.last_change = timestamp;
return true;
}
return false; // ok, same timestamp
}
#include "clipboardpoll.moc"