// X11 implementation of clipboard access for Nasal
//
// Copyright (C) 2012 Thomas Geymayer <tomgey@gmail.com>
//
// 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; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
/*
* See the following links for more information on X11 clipboard:
*
* http://www.jwz.org/doc/x-cut-and-paste.html
* http://michael.toren.net/mirrors/doc/X-copy+paste.txt
* https://github.com/kfish/xsel/blob/master/xsel.c
*/
#include "NasalClipboard.hxx"
#include <simgear/debug/logstream.hxx>
#include <X11/Xlib.h>
#include <X11/Xatom.h>
class ClipboardX11:
public NasalClipboard
{
public:
ClipboardX11():
_display( XOpenDisplay(NULL) ),
_window( XCreateSimpleWindow(
_display,
DefaultRootWindow(_display),
0, 0, 1, 1, // dummy dimensions -> window will never be mapped
0,
0, 0
) ),
_atom_targets( XInternAtom(_display, "TARGETS", False) ),
_atom_text( XInternAtom(_display, "TEXT", False) ),
_atom_utf8( XInternAtom(_display, "UTF8_STRING", False) ),
_atom_primary( XInternAtom(_display, "PRIMARY", False) ),
_atom_clipboard( XInternAtom(_display, "CLIPBOARD", False) )
{
assert(_display);
}
virtual ~ClipboardX11()
{
// Ensure we get rid of any selection ownership
if( XGetSelectionOwner(_display, _atom_primary) )
XSetSelectionOwner(_display, _atom_primary, None, CurrentTime);
if( XGetSelectionOwner(_display, _atom_clipboard) )
XSetSelectionOwner(_display, _atom_clipboard, None, CurrentTime);
}
/**
* We need to run an event queue to check for selection request
*/
virtual void update()
{
while( XPending(_display) )
{
XEvent event;
XNextEvent(_display, &event);
handleEvent(event);
}
}
/**
* Get clipboard contents as text
*/
virtual std::string getText(Type type)
{
Atom atom_type = typeToAtom(type);
//Request a list of possible conversions
XConvertSelection( _display, atom_type, _atom_targets, atom_type,
_window, CurrentTime );
Atom requested_type = None;
bool sent_request = false;
for(int cnt = 0; cnt < 5;)
{
XEvent event;
XNextEvent(_display, &event);
if( event.type != SelectionNotify )
{
handleEvent(event);
continue;
}
Atom target = event.xselection.target;
if(event.xselection.property == None)
{
if( target == _atom_targets )
// If TARGETS can not be converted no selection is available
break;
SG_LOG
(
SG_NASAL,
SG_WARN,
"ClipboardX11::getText: Conversion failed: "
"target=" << getAtomName(target)
);
break;
}
//If we're being given a list of targets (possible conversions)
if(target == _atom_targets && !sent_request)
{
sent_request = true;
requested_type = XA_STRING; // TODO select other type
XConvertSelection( _display, atom_type, requested_type, atom_type,
_window, CurrentTime );
}
else if(target == requested_type)
{
Property prop = readProperty(_window, atom_type);
if( prop.format != 8 )
{
SG_LOG
(
SG_NASAL,
SG_WARN,
"ClipboardX11::getText: can only handle 8-bit data (is "
<< prop.format << "-bit) -> retry "
<< cnt++
);
XFree(prop.data);
continue;
}
std::string result((const char*)prop.data, prop.num_items);
XFree(prop.data);
return result;
}
else
{
SG_LOG
(
SG_NASAL,
SG_WARN,
"ClipboardX11::getText: wrong target: " << getAtomName(target)
);
break;
}
}
return std::string();
}
/**
* Set clipboard contents as text
*/
virtual bool setText(const std::string& text, Type type)
{
Atom atom_type = typeToAtom(type);
XSetSelectionOwner(_display, atom_type, _window, CurrentTime);
if( XGetSelectionOwner(_display, atom_type) != _window )
{
SG_LOG
(
SG_NASAL,
SG_ALERT,
"ClipboardX11::setText: failed to get selection owner!"
);
return false;
}
// We need to store the text for sending it to another application upon
// request
if( type == CLIPBOARD )
_clipboard = text;
else
_selection = text;
return true;
}
protected:
Display *_display;
Window _window;
Atom _atom_targets,
_atom_text,
_atom_utf8,
_atom_primary,
_atom_clipboard;
std::string _clipboard,
_selection;
void handleEvent(const XEvent& event)
{
switch( event.type )
{
case SelectionRequest:
handleSelectionRequest(event.xselectionrequest);
break;
case SelectionClear:
if( event.xselectionclear.selection == _atom_clipboard )
_clipboard.clear();
else
_selection.clear();
break;
default:
SG_LOG
(
SG_NASAL,
SG_WARN,
"ClipboardX11: unexpected XEvent: " << event.type
);
break;
}
}
void handleSelectionRequest(const XSelectionRequestEvent& sel_req)
{
SG_LOG
(
SG_NASAL,
SG_DEBUG,
"ClipboardX11: handle selection request: "
"selection=" << getAtomName(sel_req.selection) << ", "
"target=" << getAtomName(sel_req.target)
);
const std::string& buf = sel_req.selection == _atom_clipboard
? _clipboard
: _selection;
// Prepare response to notify whether we have written to the property or
// are unable to do the conversion
XSelectionEvent response;
response.type = SelectionNotify;
response.display = sel_req.display;
response.requestor = sel_req.requestor;
response.selection = sel_req.selection;
response.target = sel_req.target;
response.property = sel_req.property;
response.time = sel_req.time;
if( sel_req.target == _atom_targets )
{
static Atom supported[] = {
XA_STRING,
_atom_text,
_atom_utf8
};
changeProperty
(
sel_req.requestor,
sel_req.property,
sel_req.target,
&supported,
sizeof(supported)
);
}
else if( sel_req.target == XA_STRING
|| sel_req.target == _atom_text
|| sel_req.target == _atom_utf8 )
{
changeProperty
(
sel_req.requestor,
sel_req.property,
sel_req.target,
buf.data(),
buf.size()
);
}
else
{
// Notify requestor that we are unable to perform requested conversion
response.property = None;
}
XSendEvent(_display, sel_req.requestor, False, 0, (XEvent*)&response);
}
void changeProperty( Window w,
Atom prop,
Atom type,
const void *data,
size_t size )
{
XChangeProperty
(
_display, w, prop, type, 8, PropModeReplace,
static_cast<const unsigned char*>(data), size
);
}
struct Property
{
unsigned char *data;
int format;
unsigned long num_items;
Atom type;
};
// Get all data from a property
Property readProperty(Window w, Atom property)
{
Atom actual_type;
int actual_format;
unsigned long nitems;
unsigned long bytes_after;
unsigned char *ret = 0;
int read_bytes = 1024;
//Keep trying to read the property until there are no
//bytes unread.
do
{
if( ret )
XFree(ret);
XGetWindowProperty
(
_display, w, property, 0, read_bytes, False, AnyPropertyType,
&actual_type, &actual_format, &nitems, &bytes_after,
&ret
);
read_bytes *= 2;
} while( bytes_after );
Property p = {ret, actual_format, nitems, actual_type};
return p;
}
std::string getAtomName(Atom atom) const
{
return atom == None ? "None" : XGetAtomName(_display, atom);
}
Atom typeToAtom(Type type) const
{
return type == CLIPBOARD ? _atom_clipboard : _atom_primary;
}
};
//------------------------------------------------------------------------------
NasalClipboard::Ptr NasalClipboard::create()
{
return NasalClipboard::Ptr(new ClipboardX11);
}