444 lines
17 KiB
C
444 lines
17 KiB
C
/**************************************************************************
|
|
* Copyright (C) 2017 tint2 authors
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License version 2
|
|
* as published by the Free Software Foundation.
|
|
*
|
|
* 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.
|
|
**************************************************************************/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "drag_and_drop.h"
|
|
#include "panel.h"
|
|
#include "server.h"
|
|
#include "task.h"
|
|
|
|
// Drag and Drop state variables
|
|
static Window dnd_source_window;
|
|
static Window dnd_target_window;
|
|
static int dnd_version;
|
|
static Atom dnd_selection;
|
|
static Atom dnd_atom;
|
|
static int dnd_sent_request;
|
|
static LauncherIcon *dnd_launcher_icon;
|
|
gboolean debug_dnd = FALSE;
|
|
|
|
gboolean hidden_panel_shown_for_dnd;
|
|
|
|
// This fetches all the data from a property
|
|
struct Property dnd_read_property(Display *disp, 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 != 0)
|
|
XFree(ret);
|
|
XGetWindowProperty(disp,
|
|
w,
|
|
property,
|
|
0,
|
|
read_bytes,
|
|
False,
|
|
AnyPropertyType,
|
|
&actual_type,
|
|
&actual_format,
|
|
&nitems,
|
|
&bytes_after,
|
|
&ret);
|
|
read_bytes *= 2;
|
|
} while (bytes_after != 0);
|
|
|
|
if (debug_dnd)
|
|
fprintf(stderr, "tint2: DnD %s:%d: Property:\n", __FILE__, __LINE__);
|
|
fprintf(stderr, "tint2: DnD %s:%d: Actual type: %s\n", __FILE__, __LINE__, GetAtomName(disp, actual_type));
|
|
fprintf(stderr, "tint2: DnD %s:%d: Actual format: %d\n", __FILE__, __LINE__, actual_format);
|
|
fprintf(stderr, "tint2: DnD %s:%d: Number of items: %lu\n", __FILE__, __LINE__, nitems);
|
|
|
|
Property p;
|
|
p.data = ret;
|
|
p.format = actual_format;
|
|
p.nitems = nitems;
|
|
p.type = actual_type;
|
|
|
|
return p;
|
|
}
|
|
|
|
// This function takes a list of targets which can be converted to (atom_list, nitems)
|
|
// and a list of acceptable targets with prioritees (datatypes). It returns the highest
|
|
// entry in datatypes which is also in atom_list: ie it finds the best match.
|
|
Atom dnd_pick_target_from_list(Display *disp, Atom *atom_list, int nitems)
|
|
{
|
|
Atom to_be_requested = None;
|
|
int i;
|
|
for (i = 0; i < nitems; i++) {
|
|
const char *atom_name = GetAtomName(disp, atom_list[i]);
|
|
fprintf(stderr, "tint2: DnD %s:%d: Type %d = %s\n", __FILE__, __LINE__, i, atom_name);
|
|
|
|
// See if this data type is allowed and of higher priority (closer to zero)
|
|
// than the present one.
|
|
if (strcasecmp(atom_name, "STRING") == 0) {
|
|
to_be_requested = atom_list[i];
|
|
} else if (strcasecmp(atom_name, "text/uri-list") == 0 && !to_be_requested) {
|
|
to_be_requested = atom_list[i];
|
|
}
|
|
}
|
|
|
|
fprintf(stderr,
|
|
"tint2: DnD %s:%d: Accepting: Type %s\n",
|
|
__FILE__,
|
|
__LINE__,
|
|
GetAtomName(server.display, to_be_requested));
|
|
|
|
return to_be_requested;
|
|
}
|
|
|
|
// Finds the best target given up to three atoms provided (any can be None).
|
|
// Useful for part of the Xdnd protocol.
|
|
Atom dnd_pick_target_from_atoms(Display *disp, Atom t1, Atom t2, Atom t3)
|
|
{
|
|
Atom atoms[3];
|
|
int n = 0;
|
|
|
|
if (t1 != None)
|
|
atoms[n++] = t1;
|
|
|
|
if (t2 != None)
|
|
atoms[n++] = t2;
|
|
|
|
if (t3 != None)
|
|
atoms[n++] = t3;
|
|
|
|
return dnd_pick_target_from_list(disp, atoms, n);
|
|
}
|
|
|
|
// Finds the best target given a local copy of a property.
|
|
Atom dnd_pick_target_from_targets(Display *disp, Property p)
|
|
{
|
|
// The list of targets is a list of atoms, so it should have type XA_ATOM
|
|
// but it may have the type TARGETS instead.
|
|
|
|
if ((p.type != XA_ATOM && p.type != server.atom.TARGETS) || p.format != 32) {
|
|
// This would be really broken. Targets have to be an atom list
|
|
// and applications should support this. Nevertheless, some
|
|
// seem broken (MATLAB 7, for instance), so ask for STRING
|
|
// next instead as the lowest common denominator
|
|
return XA_STRING;
|
|
} else {
|
|
Atom *atom_list = (Atom *)p.data;
|
|
|
|
return dnd_pick_target_from_list(disp, atom_list, p.nitems);
|
|
}
|
|
}
|
|
|
|
void dnd_init()
|
|
{
|
|
dnd_source_window = 0;
|
|
dnd_target_window = 0;
|
|
dnd_version = 0;
|
|
dnd_selection = XInternAtom(server.display, "PRIMARY", 0);
|
|
dnd_atom = None;
|
|
dnd_sent_request = 0;
|
|
dnd_launcher_icon = NULL;
|
|
hidden_panel_shown_for_dnd = FALSE;
|
|
}
|
|
|
|
void handle_dnd_enter(XClientMessageEvent *e)
|
|
{
|
|
dnd_atom = None;
|
|
int more_than_3 = e->data.l[1] & 1;
|
|
dnd_source_window = e->data.l[0];
|
|
dnd_version = (e->data.l[1] >> 24);
|
|
|
|
if (debug_dnd) {
|
|
fprintf(stderr, "tint2: DnD %s:%d: DnDEnter\n", __FILE__, __LINE__);
|
|
fprintf(stderr,
|
|
"DnD %s:%d: DnDEnter. Supports > 3 types = %s\n",
|
|
__FILE__,
|
|
__LINE__,
|
|
more_than_3 ? "yes" : "no");
|
|
fprintf(stderr, "tint2: DnD %s:%d: Protocol version = %d\n", __FILE__, __LINE__, dnd_version);
|
|
fprintf(stderr,
|
|
"tint2: DnD %s:%d: Type 1 = %s\n",
|
|
__FILE__,
|
|
__LINE__,
|
|
GetAtomName(server.display, e->data.l[2]));
|
|
fprintf(stderr,
|
|
"tint2: DnD %s:%d: Type 2 = %s\n",
|
|
__FILE__,
|
|
__LINE__,
|
|
GetAtomName(server.display, e->data.l[3]));
|
|
fprintf(stderr,
|
|
"tint2: DnD %s:%d: Type 3 = %s\n",
|
|
__FILE__,
|
|
__LINE__,
|
|
GetAtomName(server.display, e->data.l[4]));
|
|
}
|
|
|
|
// Query which conversions are available and pick the best
|
|
if (more_than_3) {
|
|
// Fetch the list of possible conversions
|
|
// Notice the similarity to TARGETS with paste.
|
|
Property p = dnd_read_property(server.display, dnd_source_window, server.atom.XdndTypeList);
|
|
dnd_atom = dnd_pick_target_from_targets(server.display, p);
|
|
XFree(p.data);
|
|
} else {
|
|
// Use the available list
|
|
dnd_atom = dnd_pick_target_from_atoms(server.display, e->data.l[2], e->data.l[3], e->data.l[4]);
|
|
}
|
|
|
|
if (debug_dnd)
|
|
fprintf(stderr,
|
|
"tint2: DnD %s:%d: Requested type = %s\n",
|
|
__FILE__,
|
|
__LINE__,
|
|
GetAtomName(server.display, dnd_atom));
|
|
}
|
|
|
|
void handle_dnd_position(XClientMessageEvent *e)
|
|
{
|
|
dnd_target_window = e->window;
|
|
int accept = 0;
|
|
Panel *panel = get_panel(e->window);
|
|
int x, y, mapX, mapY;
|
|
Window child;
|
|
x = (e->data.l[2] >> 16) & 0xFFFF;
|
|
y = e->data.l[2] & 0xFFFF;
|
|
XTranslateCoordinates(server.display, server.root_win, e->window, x, y, &mapX, &mapY, &child);
|
|
Task *task = click_task(panel, mapX, mapY);
|
|
if (task) {
|
|
if (task->desktop != server.desktop)
|
|
change_desktop(task->desktop);
|
|
task_handle_mouse_event(task, TOGGLE);
|
|
} else {
|
|
LauncherIcon *icon = click_launcher_icon(panel, mapX, mapY);
|
|
if (icon) {
|
|
accept = 1;
|
|
dnd_launcher_icon = icon;
|
|
} else {
|
|
dnd_launcher_icon = NULL;
|
|
}
|
|
}
|
|
|
|
// send XdndStatus event to get more XdndPosition events
|
|
XClientMessageEvent se;
|
|
se.type = ClientMessage;
|
|
se.window = e->data.l[0];
|
|
se.message_type = server.atom.XdndStatus;
|
|
se.format = 32;
|
|
se.data.l[0] = e->window; // XID of the target window
|
|
se.data.l[1] = accept ? 1 : 0; // bit 0: accept drop bit 1: send XdndPosition events if inside rectangle
|
|
se.data.l[2] = 0; // Rectangle x,y for which no more XdndPosition events
|
|
se.data.l[3] = (1 << 16) | 1; // Rectangle w,h for which no more XdndPosition events
|
|
if (accept) {
|
|
se.data.l[4] = server.atom.XdndActionCopy;
|
|
} else {
|
|
se.data.l[4] = None; // None = drop will not be accepted
|
|
}
|
|
|
|
if (debug_dnd)
|
|
fprintf(stderr,
|
|
"tint2: DnD %s:%d: Accepted: %s\n",
|
|
__FILE__,
|
|
__LINE__,
|
|
accept ? GetAtomName(server.display, (Atom)se.data.l[4]) : "no");
|
|
|
|
XSendEvent(server.display, e->data.l[0], False, NoEventMask, (XEvent *)&se);
|
|
}
|
|
|
|
void handle_dnd_drop(XClientMessageEvent *e)
|
|
{
|
|
if (dnd_target_window && dnd_launcher_icon) {
|
|
if (dnd_version >= 1) {
|
|
XConvertSelection(server.display,
|
|
server.atom.XdndSelection,
|
|
dnd_atom,
|
|
dnd_selection,
|
|
dnd_target_window,
|
|
e->data.l[2]);
|
|
} else {
|
|
XConvertSelection(server.display,
|
|
server.atom.XdndSelection,
|
|
dnd_atom,
|
|
dnd_selection,
|
|
dnd_target_window,
|
|
CurrentTime);
|
|
}
|
|
} else {
|
|
// The source is sending anyway, despite instructions to the contrary.
|
|
// So reply that we're not interested.
|
|
XClientMessageEvent m;
|
|
memset(&m, 0, sizeof(m));
|
|
m.type = ClientMessage;
|
|
m.display = e->display;
|
|
m.window = e->data.l[0];
|
|
m.message_type = server.atom.XdndFinished;
|
|
m.format = 32;
|
|
m.data.l[0] = dnd_target_window;
|
|
m.data.l[1] = 0;
|
|
m.data.l[2] = None; // Failed.
|
|
XSendEvent(server.display, e->data.l[0], False, NoEventMask, (XEvent *)&m);
|
|
}
|
|
}
|
|
|
|
void handle_dnd_selection_notify(XSelectionEvent *e)
|
|
{
|
|
Atom target = e->target;
|
|
|
|
if (debug_dnd) {
|
|
fprintf(stderr, "tint2: DnD %s:%d: A selection notify has arrived!\n", __FILE__, __LINE__);
|
|
fprintf(stderr,
|
|
"DnD %s:%d: Selection atom = %s\n",
|
|
__FILE__,
|
|
__LINE__,
|
|
GetAtomName(server.display, e->selection));
|
|
fprintf(stderr, "tint2: DnD %s:%d: Target atom = %s\n", __FILE__, __LINE__, GetAtomName(server.display, target));
|
|
fprintf(stderr,
|
|
"DnD %s:%d: Property atom = %s\n",
|
|
__FILE__,
|
|
__LINE__,
|
|
GetAtomName(server.display, e->property));
|
|
}
|
|
|
|
if (dnd_launcher_icon) {
|
|
Property prop = dnd_read_property(server.display, dnd_target_window, dnd_selection);
|
|
|
|
if (prop.data) {
|
|
// If we're being given a list of targets (possible conversions)
|
|
if (target == server.atom.TARGETS && !dnd_sent_request) {
|
|
dnd_sent_request = 1;
|
|
dnd_atom = dnd_pick_target_from_targets(server.display, prop);
|
|
|
|
if (dnd_atom == None) {
|
|
if (debug_dnd)
|
|
fprintf(stderr, "tint2: No matching datatypes.\n");
|
|
} else {
|
|
// Request the data type we are able to select
|
|
if (debug_dnd)
|
|
fprintf(stderr, "tint2: Now requsting type %s", GetAtomName(server.display, dnd_atom));
|
|
XConvertSelection(server.display,
|
|
dnd_selection,
|
|
dnd_atom,
|
|
dnd_selection,
|
|
dnd_target_window,
|
|
CurrentTime);
|
|
}
|
|
} else if (target == dnd_atom) {
|
|
// Dump the binary data
|
|
if (debug_dnd) {
|
|
fprintf(stderr, "tint2: DnD %s:%d: Received data:\n", __FILE__, __LINE__);
|
|
fprintf(stderr, "tint2: --------\n");
|
|
for (int i = 0; i < prop.nitems * prop.format / 8; i++)
|
|
fprintf(stderr, "%c", ((char *)prop.data)[i]);
|
|
fprintf(stderr, "tint2: --------\n");
|
|
}
|
|
|
|
// https://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#exec-variables
|
|
GString *cmd = g_string_new(dnd_launcher_icon->cmd);
|
|
|
|
const char *atom_name = GetAtomName(server.display, prop.type);
|
|
if (strcasecmp(atom_name, "STRING") == 0 || strcasecmp(atom_name, "text/uri-list") == 0) {
|
|
GString *url = g_string_new("");
|
|
GString *prev_url = g_string_new("");
|
|
gboolean must_unescape = strcasecmp(atom_name, "text/uri-list") == 0;
|
|
for (int i = 0; i < prop.nitems * prop.format / 8; i++) {
|
|
char c = ((char *)prop.data)[i];
|
|
if (c == '\n') {
|
|
if (must_unescape) {
|
|
char *raw = g_uri_unescape_string(url->str, NULL);
|
|
if (raw) {
|
|
g_string_assign(url, raw);
|
|
}
|
|
free(raw);
|
|
}
|
|
// Many programs cannot handle this prefix
|
|
tint2_g_string_replace(url, "file://", "");
|
|
// Some programs put duplicates in the list, we remove them
|
|
if (strcmp(url->str, prev_url->str) != 0) {
|
|
if (strstr(cmd->str, "%F")) {
|
|
GString *piece = g_string_new("");
|
|
g_string_append(piece, " \"");
|
|
g_string_append(piece, url->str);
|
|
g_string_append(piece, "\"");
|
|
g_string_append(piece, " %F");
|
|
tint2_g_string_replace(cmd, "%F", piece->str);
|
|
g_string_free(piece, TRUE);
|
|
} else if (strstr(cmd->str, "%f")) {
|
|
GString *piece = g_string_new("");
|
|
g_string_append(piece, " \"");
|
|
g_string_append(piece, url->str);
|
|
g_string_append(piece, "\"");
|
|
tint2_g_string_replace(cmd, "%f", piece->str);
|
|
g_string_free(piece, TRUE);
|
|
break;
|
|
} else {
|
|
g_string_append(cmd, " \"");
|
|
g_string_append(cmd, url->str);
|
|
g_string_append(cmd, "\"");
|
|
}
|
|
}
|
|
g_string_assign(prev_url, url->str);
|
|
g_string_assign(url, "");
|
|
} else if (c == '\r') {
|
|
// Nothing to do
|
|
} else {
|
|
if (c == '`' || c == '$' || c == '\\') {
|
|
g_string_append(url, "\\");
|
|
}
|
|
g_string_append_c(url, c);
|
|
}
|
|
}
|
|
g_string_free(url, TRUE);
|
|
g_string_free(prev_url, TRUE);
|
|
}
|
|
tint2_g_string_replace(cmd, "%F", "");
|
|
tint2_g_string_replace(cmd, "%f", "");
|
|
if (debug_dnd)
|
|
fprintf(stderr, "tint2: DnD %s:%d: Running command: %s\n", __FILE__, __LINE__, cmd->str);
|
|
tint_exec(cmd->str,
|
|
NULL,
|
|
NULL,
|
|
e->time,
|
|
NULL,
|
|
0,
|
|
0,
|
|
dnd_launcher_icon->start_in_terminal,
|
|
dnd_launcher_icon->startup_notification);
|
|
g_string_free(cmd, TRUE);
|
|
|
|
// Reply OK.
|
|
XClientMessageEvent m;
|
|
memset(&m, 0, sizeof(m));
|
|
m.type = ClientMessage;
|
|
m.display = server.display;
|
|
m.window = dnd_source_window;
|
|
m.message_type = server.atom.XdndFinished;
|
|
m.format = 32;
|
|
m.data.l[0] = dnd_target_window;
|
|
m.data.l[1] = 1;
|
|
m.data.l[2] = server.atom.XdndActionCopy; // We only ever copy.
|
|
XSendEvent(server.display, dnd_source_window, False, NoEventMask, (XEvent *)&m);
|
|
XSync(server.display, False);
|
|
}
|
|
|
|
XFree(prop.data);
|
|
}
|
|
}
|
|
}
|