kmanagerselection.cpp

/****************************************************************************
 
 $Id$
 
 Copyright (C) 2003 Lubos Lunak        <l.lunak@kde.org>
 
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
****************************************************************************/
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif 
 
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
 
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
 
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
 
#include <tqobject.h>
#ifdef TQ_WS_X11 // FIXME(E)
 
#include "kmanagerselection.h"
 
#include <kdebug.h>
#include <tqwidget.h>
#include <tdeapplication.h>
#include <kxerrorhandler.h>
#include <X11/Xatom.h>
 
class TDESelectionOwnerPrivate
    : public TQWidget
    {
    public:
        TDESelectionOwnerPrivate( TDESelectionOwner* owner );
    protected:
        virtual bool x11Event( XEvent* ev );
    private:
        TDESelectionOwner* owner;
    };
    
TDESelectionOwnerPrivate::TDESelectionOwnerPrivate( TDESelectionOwner* owner_P )
    :   owner( owner_P )
    {
    tdeApp->installX11EventFilter( this );
    }
    
bool TDESelectionOwnerPrivate::x11Event( XEvent* ev_P )
    {
    return owner->filterEvent( ev_P );
    }
    
TDESelectionOwner::TDESelectionOwner( Atom selection_P, int screen_P, TQObject* parent_P )
    :   TQObject( parent_P ),
        selection( selection_P ),
        screen( screen_P >= 0 ? screen_P : DefaultScreen( tqt_xdisplay())),
        window( None ),
        timestamp( CurrentTime ),
        extra1( 0 ), extra2( 0 ),
        d( new TDESelectionOwnerPrivate( this ))
    {
    }
    
TDESelectionOwner::TDESelectionOwner( const char* selection_P, int screen_P, TQObject* parent_P )
    :   TQObject( parent_P ),
        selection( XInternAtom( tqt_xdisplay(), selection_P, False )),
        screen( screen_P >= 0 ? screen_P : DefaultScreen( tqt_xdisplay())),
        window( None ),
        timestamp( CurrentTime ),
        extra1( 0 ), extra2( 0 ),
        d( new TDESelectionOwnerPrivate( this ))
    {
    }
 
TDESelectionOwner::~TDESelectionOwner()
    {
    release();
    delete d;
    }
        
bool TDESelectionOwner::claim( bool force_P, bool force_kill_P )
    {
    if( manager_atom == None )
        getAtoms();
    if( timestamp != CurrentTime )
        release();
    Display* const dpy = tqt_xdisplay();
    Window prev_owner = XGetSelectionOwner( dpy, selection );
    if( prev_owner != None )
        {
        if( !force_P )
            {
//            kdDebug() << "Selection already owned, failing" << endl;
            return false;
            }
        XSelectInput( dpy, prev_owner, StructureNotifyMask );
        }
    XSetWindowAttributes attrs;
    attrs.override_redirect = True;
    window = XCreateWindow( dpy, RootWindow( dpy, screen ), 0, 0, 1, 1, 
        0, CopyFromParent, InputOnly, CopyFromParent, CWOverrideRedirect, &attrs );
//    kdDebug() << "Using owner window " << window << endl;
    Atom tmp = XA_ATOM;
    XSelectInput( dpy, window, PropertyChangeMask );
    XChangeProperty( dpy, window, XA_ATOM, XA_ATOM, 32, PropModeReplace,
        reinterpret_cast< unsigned char* >( &tmp ), 1 );
    XEvent ev;
    XSync( dpy, False );
    XCheckTypedWindowEvent( dpy, window, PropertyNotify, &ev ); // get a timestamp
    timestamp = ev.xproperty.time;
    XSelectInput( dpy, window, StructureNotifyMask ); // for DestroyNotify
    XSetSelectionOwner( dpy, selection, window, timestamp );
    Window new_owner = XGetSelectionOwner( dpy, selection );
    if( new_owner != window )
        {
//        kdDebug() << "Failed to claim selection : " << new_owner << endl;
        XDestroyWindow( dpy, window );
        timestamp = CurrentTime;
        return false;
        }
    if( prev_owner != None )
        {
//        kdDebug() << "Waiting for previous owner to disown" << endl;
        for( int cnt = 0;
             ;
             ++cnt )
            {
            if( XCheckTypedWindowEvent( dpy, prev_owner, DestroyNotify, &ev ) == True )
                break;
            struct timeval tm = { 0, 50000 }; // 50 ms
            select( 0, NULL, NULL, NULL, &tm );
            if( cnt == 19 )
                {
                if( force_kill_P )
                    {
//                    kdDebug() << "Killing previous owner" << endl;
                    XKillClient( dpy, prev_owner );
                    }
                break;
                }
            }
        }
    ev.type = ClientMessage;
    ev.xclient.window = RootWindow( dpy, screen );
    ev.xclient.display = dpy;
    ev.xclient.message_type = manager_atom;
    ev.xclient.format = 32;
    ev.xclient.data.l[ 0 ] = timestamp;
    ev.xclient.data.l[ 1 ] = selection;
    ev.xclient.data.l[ 2 ] = window;
    ev.xclient.data.l[ 3 ] = extra1;
    ev.xclient.data.l[ 4 ] = extra2;
    XSendEvent( dpy, RootWindow( dpy, screen ), False, StructureNotifyMask, &ev );
//    kdDebug() << "Claimed selection" << endl;
    return true;
    }
 
// destroy resource first
void TDESelectionOwner::release()
    {
    if( timestamp == CurrentTime )
        return;
    XDestroyWindow( tqt_xdisplay(), window ); // also makes the selection not owned
//    kdDebug() << "Releasing selection" << endl;
    timestamp = CurrentTime;
    }
 
Window TDESelectionOwner::ownerWindow() const
    {
    if( timestamp == CurrentTime )
        return None;
    return window;
    }
 
void TDESelectionOwner::setData( long extra1_P, long extra2_P )
    {
    extra1 = extra1_P;
    extra2 = extra2_P;
    }
    
bool TDESelectionOwner::filterEvent( XEvent* ev_P )
    {
    if( timestamp != CurrentTime && ev_P->xany.window == window )
        {
        if( handleMessage( ev_P ))
            return true;
        }
    switch( ev_P->type )
    {
    case SelectionClear:
        {
        if( timestamp == CurrentTime || ev_P->xselectionclear.selection != selection )
            return false;
        timestamp = CurrentTime;
//      kdDebug() << "Lost selection" << endl;
        emit lostOwnership();
        XSelectInput( tqt_xdisplay(), window, 0 );
        XDestroyWindow( tqt_xdisplay(), window );
      return false;
        }
    case DestroyNotify:
        {
        if( timestamp == CurrentTime || ev_P->xdestroywindow.window != window )
            return false;
        timestamp = CurrentTime;
//      kdDebug() << "Lost selection (destroyed)" << endl;
        emit lostOwnership();
      return false;
        }
    case SelectionNotify:
        {
        if( timestamp == CurrentTime || ev_P->xselection.selection != selection )
            return false;
        // ignore?
      return false;
        }
    case SelectionRequest:
        filter_selection_request( ev_P->xselectionrequest );
      return false;
    }
    return false;
    }
 
bool TDESelectionOwner::handleMessage( XEvent* )
    {
    return false;
    }
 
void TDESelectionOwner::filter_selection_request( XSelectionRequestEvent& ev_P )
    {
    if( timestamp == CurrentTime || ev_P.selection != selection )
        return;
    if( ev_P.time != CurrentTime
        && ev_P.time - timestamp > 1U << 31 )
        return; // too old or too new request
//    kdDebug() << "Got selection request" << endl;
    bool handled = false;
    if( ev_P.target == xa_multiple )
        {
        if( ev_P.property != None )
            {
            const int MAX_ATOMS = 100; // no need to handle more?
            int format;
            Atom type;
            unsigned long items;
            unsigned long after;
            unsigned char* data;
            if( XGetWindowProperty( tqt_xdisplay(), ev_P.requestor, ev_P.property, 0,
                MAX_ATOMS, False, AnyPropertyType, &type, &format, &items, &after,
                &data ) == Success && format == 32 && items % 2 == 0 )
                {
                bool handled_array[ MAX_ATOMS ];
                Atom* atoms = reinterpret_cast< Atom* >( data );
                for( unsigned int i = 0;
                     i < items / 2;
                     ++i )
                    handled_array[ i ] = handle_selection(
                        atoms[ i * 2 ], atoms[ i * 2 + 1 ], ev_P.requestor );
                bool all_handled = true;
                for( unsigned int i = 0;
                     i < items / 2;
                     ++i )
                    if( !handled_array[ i ] )
                        {
                        all_handled = false;
                        atoms[ i * 2 + 1 ] = None;
                        }
                if( !all_handled )
                    XChangeProperty( tqt_xdisplay(), ev_P.requestor, ev_P.property, XA_ATOM,
                        32, PropModeReplace, reinterpret_cast< unsigned char* >( atoms ), items );
                handled = true;
                XFree( data );
                }
            }
        }
    else
        {
        if( ev_P.property == None ) // obsolete client
            ev_P.property = ev_P.target;
        handled = handle_selection( ev_P.target, ev_P.property, ev_P.requestor );
        }
    XEvent ev;
    ev.xselection.type = SelectionNotify;
    ev.xselection.display = tqt_xdisplay();
    ev.xselection.requestor = ev_P.requestor;
    ev.xselection.target = ev_P.target;
    ev.xselection.property = handled ? ev_P.property : None;
    XSendEvent( tqt_xdisplay(), ev_P.requestor, False, 0, &ev );
    }
 
bool TDESelectionOwner::handle_selection( Atom target_P, Atom property_P, Window requestor_P )
    {
    if( target_P == xa_timestamp )
        {
//        kdDebug() << "Handling timestamp request" << endl;
        XChangeProperty( tqt_xdisplay(), requestor_P, property_P, XA_INTEGER, 32,
            PropModeReplace, reinterpret_cast< unsigned char* >( &timestamp ), 1 );
        }
    else if( target_P == xa_targets )
        replyTargets( property_P, requestor_P );
    else if( genericReply( target_P, property_P, requestor_P ))
        ; // handled
    else
        return false; // unknown
    return true;
    }
 
void TDESelectionOwner::replyTargets( Atom property_P, Window requestor_P )
    {
    Atom atoms[ 3 ] = { xa_multiple, xa_timestamp, xa_targets };
//    kdDebug() << "Handling targets request" << endl;
    XChangeProperty( tqt_xdisplay(), requestor_P, property_P, XA_ATOM, 32, PropModeReplace,
        reinterpret_cast< unsigned char* >( atoms ), 3 );
    }
 
bool TDESelectionOwner::genericReply( Atom, Atom, Window )
    {
    return false;
    }
 
void TDESelectionOwner::getAtoms()
    {
    if( manager_atom == None )
        {
        Atom atoms[ 4 ];
        const char* const names[] =
            { "MANAGER", "MULTIPLE", "TARGETS", "TIMESTAMP" };
        XInternAtoms( tqt_xdisplay(), const_cast< char** >( names ), 4, False, atoms );
        manager_atom = atoms[ 0 ];
        xa_multiple = atoms[ 1];
        xa_targets = atoms[ 2 ];
        xa_timestamp = atoms[ 3 ];
        }
    }
 
Atom TDESelectionOwner::manager_atom = None;
Atom TDESelectionOwner::xa_multiple = None;
Atom TDESelectionOwner::xa_targets = None;
Atom TDESelectionOwner::xa_timestamp = None;
 
//*******************************************
// TDESelectionWatcher
//*******************************************
 
 
class TDESelectionWatcherPrivate
    : public TQWidget
    {
    public:
        TDESelectionWatcherPrivate( TDESelectionWatcher* watcher );
    protected:
        virtual bool x11Event( XEvent* ev );
    private:
        TDESelectionWatcher* watcher;
    };
    
TDESelectionWatcherPrivate::TDESelectionWatcherPrivate( TDESelectionWatcher* watcher_P )
    :   watcher( watcher_P )
    {
    tdeApp->installX11EventFilter( this );
    }
    
bool TDESelectionWatcherPrivate::x11Event( XEvent* ev_P )
    {
    watcher->filterEvent( ev_P );
    return false;
    }
    
 
TDESelectionWatcher::TDESelectionWatcher( Atom selection_P, int screen_P, TQObject* parent_P )
    :   TQObject( parent_P ),
        selection( selection_P ),
        screen( screen_P >= 0 ? screen_P : DefaultScreen( tqt_xdisplay())),
        selection_owner( None ),
        d( new TDESelectionWatcherPrivate( this ))
    {
    init();
    }
    
TDESelectionWatcher::TDESelectionWatcher( const char* selection_P, int screen_P, TQObject* parent_P )
    :   TQObject( parent_P ),
        selection( XInternAtom( tqt_xdisplay(), selection_P, False )),
        screen( screen_P >= 0 ? screen_P : DefaultScreen( tqt_xdisplay())),
        selection_owner( None ),
        d( new TDESelectionWatcherPrivate( this ))
    {
    init();
    }
 
TDESelectionWatcher::~TDESelectionWatcher()
    {
    delete d;
    }
    
void TDESelectionWatcher::init()
    {
    if( manager_atom == None )
        {
        Display* const dpy = tqt_xdisplay();
        manager_atom = XInternAtom( dpy, "MANAGER", False );
        XWindowAttributes attrs;
        XGetWindowAttributes( dpy, RootWindow( dpy, screen ), &attrs );
        long event_mask = attrs.your_event_mask;
        // StructureNotifyMask on the root window is needed
        XSelectInput( dpy, RootWindow( dpy, screen ), event_mask | StructureNotifyMask );
        }
    }    
 
Window TDESelectionWatcher::owner()
    {
    Display* const dpy = tqt_xdisplay();
    KXErrorHandler handler;
    Window current_owner = XGetSelectionOwner( dpy, selection );
    if( current_owner == None )
        return None;
    if( current_owner == selection_owner )
        return selection_owner;
    XSelectInput( dpy, current_owner, StructureNotifyMask );
    if( !handler.error( true ) && current_owner == XGetSelectionOwner( dpy, selection ))
        {
//        kdDebug() << "isOwner: " << current_owner << endl;
        selection_owner = current_owner;
        emit newOwner( selection_owner );
        }
    else
        selection_owner = None;
    return selection_owner;
    }
 
// void return value in order to allow more watchers in one process
void TDESelectionWatcher::filterEvent( XEvent* ev_P )
    {
    if( ev_P->type == ClientMessage )
        {
//        kdDebug() << "got ClientMessage" << endl;
        if( ev_P->xclient.message_type != manager_atom
            || ev_P->xclient.data.l[ 1 ] != static_cast< long >( selection ))
            return;
//        kdDebug() << "handling message" << endl;
        if( static_cast< long >( owner()) == ev_P->xclient.data.l[ 2 ] )
            {
            // owner() emits newOwner() if needed, no need to do it twice
            }
        return;
        }
    if( ev_P->type == DestroyNotify )
        {
        if( selection_owner == None || ev_P->xdestroywindow.window != selection_owner )
            return;
        selection_owner = None; // in case the exactly same ID gets reused as the owner
        if( owner() == None )
            emit lostOwner(); // it must be safe to delete 'this' in a slot
        return;
        }
    return;
    }
 
Atom TDESelectionWatcher::manager_atom = None;
 
void TDESelectionOwner::virtual_hook( int, void* )
{ /*BASE::virtual_hook( id, data );*/ }
 
void TDESelectionWatcher::virtual_hook( int, void* )
{ /*BASE::virtual_hook( id, data );*/ }
 
#include "kmanagerselection.moc"
#endif