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.
335 lines
12 KiB
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"
|