* Tint2 panel
*
* Copyright (C) 2007 Pål Staurland (staura@gmail.com)
-* Modified (C) 2008 thierry lorthiois (lorthiois@bbsoft.fr)
+* Modified (C) 2008 thierry lorthiois (lorthiois@bbsoft.fr) from Omega distribution
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License version 2
#include <Imlib2.h>
#include <signal.h>
-#include "version.h"
+#include <version.h>
#include "server.h"
#include "window.h"
#include "config.h"
#include "task.h"
#include "taskbar.h"
#include "systraybar.h"
+#include "launcher.h"
#include "panel.h"
#include "tooltip.h"
#include "timer.h"
+#include "xsettings-client.h"
+
+// Drag and Drop state variables
+Window dnd_source_window;
+Window dnd_target_window;
+int dnd_version;
+Atom dnd_selection;
+Atom dnd_atom;
+int dnd_sent_request;
+char *dnd_launcher_exec;
void signal_handler(int sig)
{
{
int i;
+ // set global data
+ default_config();
+ default_timeout();
+ default_systray();
+ memset(&server, 0, sizeof(Server_global));
+#ifdef ENABLE_BATTERY
+ default_battery();
+#endif
+ default_clock();
+ default_launcher();
+ default_taskbar();
+ default_tooltip();
+ default_panel();
+
// read options
for (i = 1; i < argc; ++i) {
if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
}
}
// Set signal handler
+ signal_pending = 0;
struct sigaction sa = { .sa_handler = signal_handler };
+ struct sigaction sa_chld = { .sa_handler = SIG_DFL, .sa_flags = SA_NOCLDWAIT };
sigaction(SIGUSR1, &sa, 0);
sigaction(SIGINT, &sa, 0);
sigaction(SIGTERM, &sa, 0);
sigaction(SIGHUP, &sa, 0);
- signal(SIGCHLD, SIG_IGN); // don't have to wait() after fork()
+ sigaction(SIGCHLD, &sa_chld, 0);
- // BSD is too stupid to support pselect(), therefore we have to use select and hope that we do not
- // end up in a race condition there
+ // BSD does not support pselect(), therefore we have to use select and hope that we do not
+ // end up in a race condition there (see 'man select()' on a linux machine for more information)
// block all signals, such that no race conditions occur before pselect in our main loop
// sigset_t block_mask;
// sigaddset(&block_mask, SIGINT);
// sigaddset(&block_mask, SIGHUP);
// sigaddset(&block_mask, SIGUSR1);
// sigprocmask(SIG_BLOCK, &block_mask, 0);
-
- // set global data
- memset(&server, 0, sizeof(Server_global));
- memset(&systray, 0, sizeof(Systraybar));
}
void init_X11()
XSelectInput (server.dsp, server.root_win, PropertyChangeMask|StructureNotifyMask);
setlocale (LC_ALL, "");
-
+ // config file use '.' as decimal separator
+ setlocale(LC_NUMERIC, "POSIX");
+
// load default icon
gchar *path;
const gchar * const *data_dirs;
void cleanup()
{
- stop_all_timeouts();
cleanup_systray();
- stop_net();
- cleanup_panel();
cleanup_tooltip();
cleanup_clock();
+ cleanup_launcher();
#ifdef ENABLE_BATTERY
cleanup_battery();
#endif
+ cleanup_panel();
+ cleanup_config();
if (default_icon) {
imlib_context_set_image(default_icon);
imlib_free_image();
}
- if (config_path) g_free(config_path);
- if (snapshot_path) g_free(snapshot_path);
+ imlib_context_disconnect_display();
cleanup_server();
+ cleanup_timeout();
if (server.dsp) XCloseDisplay(server.dsp);
}
panel->area.width = server.monitor[0].width;
panel->temp_pmap = XCreatePixmap(server.dsp, server.root_win, panel->area.width, panel->area.height, server.depth);
- refresh(&panel->area);
+ rendering(panel);
Imlib_Image img = NULL;
imlib_context_set_drawable(panel->temp_pmap);
img = imlib_create_image_from_drawable(0, 0, 0, panel->area.width, panel->area.height, 0);
imlib_context_set_image(img);
+ if (!panel_horizontal) {
+ // rotate 90° vertical panel
+ imlib_image_flip_horizontal();
+ imlib_image_flip_diagonal();
+ }
imlib_save_image(path);
imlib_free_image();
- XFreePixmap(server.dsp, panel->temp_pmap);
}
else
return 0;
}
- // no task clicked --> check if taskbar clicked
+ LauncherIcon *icon = click_launcher_icon(panel, e->x, e->y);
+ if (icon) {
+ if (e->button == 1) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+ // no launcher/task clicked --> check if taskbar clicked
Taskbar *tskbar = click_taskbar(panel, e->x, e->y);
if (tskbar && e->button == 1 && panel_mode == MULTI_DESKTOP)
return 1;
}
task_drag = click_task(panel, e->xbutton.x, e->xbutton.y);
- XLowerWindow (server.dsp, panel->main_win);
+ if (panel_layer == BOTTOM_LAYER)
+ XLowerWindow (server.dsp, panel->main_win);
}
void event_button_motion_notify (XEvent *e)
Taskbar * drag_taskbar = (Taskbar*)task_drag->area.parent;
drag_taskbar->area.list = g_slist_remove(drag_taskbar->area.list, task_drag);
- if(event_taskbar->area.posx > drag_taskbar->area.posx || event_taskbar->area.posy > drag_taskbar->area.posy)
- event_taskbar->area.list = g_slist_prepend(event_taskbar->area.list, task_drag);
+ if(event_taskbar->area.posx > drag_taskbar->area.posx || event_taskbar->area.posy > drag_taskbar->area.posy) {
+ int i = (taskbarname_enabled) ? 1 : 0;
+ event_taskbar->area.list = g_slist_insert(event_taskbar->area.list, task_drag, i);
+ }
else
event_taskbar->area.list = g_slist_append(event_taskbar->area.list, task_drag);
if (wm_menu && !tint2_handles_click(panel, &e->xbutton)) {
forward_click(e);
- XLowerWindow (server.dsp, panel->main_win);
+ if (panel_layer == BOTTOM_LAYER)
+ XLowerWindow (server.dsp, panel->main_win);
task_drag = 0;
return;
}
if ( click_clock(panel, e->xbutton.x, e->xbutton.y)) {
clock_action(e->xbutton.button);
- XLowerWindow (server.dsp, panel->main_win);
+ if (panel_layer == BOTTOM_LAYER)
+ XLowerWindow (server.dsp, panel->main_win);
+ task_drag = 0;
+ return;
+ }
+
+ if ( click_launcher(panel, e->xbutton.x, e->xbutton.y)) {
+ LauncherIcon *icon = click_launcher_icon(panel, e->xbutton.x, e->xbutton.y);
+ if (icon) {
+ launcher_action(icon);
+ }
task_drag = 0;
return;
}
Taskbar *tskbar;
if ( !(tskbar = click_taskbar(panel, e->xbutton.x, e->xbutton.y)) ) {
// TODO: check better solution to keep window below
- XLowerWindow (server.dsp, panel->main_win);
+ if (panel_layer == BOTTOM_LAYER)
+ XLowerWindow (server.dsp, panel->main_win);
task_drag = 0;
return;
}
window_action( click_task(panel, e->xbutton.x, e->xbutton.y), action);
// to keep window below
- XLowerWindow (server.dsp, panel->main_win);
+ if (panel_layer == BOTTOM_LAYER)
+ XLowerWindow (server.dsp, panel->main_win);
}
Window win = e->xproperty.window;
Atom at = e->xproperty.atom;
+ if (xsettings_client)
+ xsettings_client_process_event(xsettings_client, e);
if (win == server.root_win) {
if (!server.got_root_win) {
XSelectInput (server.dsp, server.root_win, PropertyChangeMask|StructureNotifyMask);
server.got_root_win = 1;
}
+ // Change name of desktops
+ else if (at == server.atom._NET_DESKTOP_NAMES) {
+ if (!taskbarname_enabled) return;
+ GSList *l, *list = server_get_name_of_desktop();
+ int j;
+ gchar *name;
+ Taskbar *tskbar;
+ for (i=0 ; i < nb_panel ; i++) {
+ for (j=0, l=list ; j < panel1[i].nb_desktop ; j++) {
+ if (l) {
+ name = g_strdup(l->data);
+ l = l->next;
+ }
+ else
+ name = g_strdup_printf("%d", j+1);
+ tskbar = &panel1[i].taskbar[j];
+ if (strcmp(name, tskbar->bar_name.name) != 0) {
+ g_free(tskbar->bar_name.name);
+ tskbar->bar_name.name = name;
+ tskbar->bar_name.area.resize = 1;
+ }
+ else
+ g_free(name);
+ }
+ }
+ for (l=list ; l ; l = l->next)
+ g_free(l->data);
+ g_slist_free(list);
+ panel_refresh = 1;
+ }
// Change number of desktops
else if (at == server.atom._NET_NUMBER_OF_DESKTOPS) {
+ if (!taskbar_enabled) return;
server.nb_desktop = server_get_number_of_desktop ();
+ if (server.nb_desktop <= server.desktop) {
+ server.desktop = server.nb_desktop-1;
+ }
cleanup_taskbar();
init_taskbar();
- visible_object();
for (i=0 ; i < nb_panel ; i++) {
+ init_taskbar_panel(&panel1[i]);
+ set_panel_items_order(&panel1[i]);
+ visible_taskbar(&panel1[i]);
panel1[i].area.resize = 1;
}
task_refresh_tasklist();
}
// Change desktop
else if (at == server.atom._NET_CURRENT_DESKTOP) {
+ if (!taskbar_enabled) return;
int old_desktop = server.desktop;
server.desktop = server_get_current_desktop ();
for (i=0 ; i < nb_panel ; i++) {
Panel *panel = &panel1[i];
- if (panel_mode == MULTI_DESKTOP && panel->g_taskbar.use_active) {
- // redraw both taskbar
- if (server.nb_desktop > old_desktop) {
- // can happen if last desktop is deleted and we've been on the last desktop
- panel->taskbar[old_desktop].area.bg = panel->g_taskbar.bg;
- panel->taskbar[old_desktop].area.resize = 1;
- }
- panel->taskbar[server.desktop].area.bg = panel->g_taskbar.bg_active;
- panel->taskbar[server.desktop].area.resize = 1;
- panel_refresh = 1;
- }
+ set_taskbar_state(&panel->taskbar[old_desktop], TASKBAR_NORMAL);
+ set_taskbar_state(&panel->taskbar[server.desktop], TASKBAR_ACTIVE);
// check ALLDESKTOP task => resize taskbar
Taskbar *tskbar;
Task *tsk;
GSList *l;
if (server.nb_desktop > old_desktop) {
tskbar = &panel->taskbar[old_desktop];
- for (l = tskbar->area.list; l ; l = l->next) {
+ l = tskbar->area.list;
+ if (taskbarname_enabled) l = l->next;
+ for (; l ; l = l->next) {
tsk = l->data;
if (tsk->desktop == ALLDESKTOP) {
tsk->area.on_screen = 0;
}
}
tskbar = &panel->taskbar[server.desktop];
- for (l = tskbar->area.list; l ; l = l->next) {
+ l = tskbar->area.list;
+ if (taskbarname_enabled) l = l->next;
+ for (; l ; l = l->next) {
tsk = l->data;
if (tsk->desktop == ALLDESKTOP) {
tsk->area.on_screen = 1;
}
}
}
- if (panel_mode != MULTI_DESKTOP) {
- visible_object();
- }
}
// Window list
else if (at == server.atom._NET_CLIENT_LIST) {
active_task();
panel_refresh = 1;
}
- else if (at == server.atom._XROOTPMAP_ID) {
+ else if (at == server.atom._XROOTPMAP_ID || at == server.atom._XROOTMAP_ID) {
// change Wallpaper
for (i=0 ; i < nb_panel ; i++) {
set_panel_background(&panel1[i]);
// Window title changed
if (at == server.atom._NET_WM_VISIBLE_NAME || at == server.atom._NET_WM_NAME || at == server.atom.WM_NAME) {
- get_title(tsk);
- if (g_tooltip.mapped && (g_tooltip.area == (Area*)tsk)) {
- tooltip_copy_text((Area*)tsk);
- tooltip_update();
+ if (get_title(tsk)) {
+ if (g_tooltip.mapped && (g_tooltip.area == (Area*)tsk)) {
+ tooltip_copy_text((Area*)tsk);
+ tooltip_update();
+ }
+ panel_refresh = 1;
}
- panel_refresh = 1;
}
// Demand attention
else if (at == server.atom._NET_WM_STATE) {
{
// change in root window (xrandr)
if (win == server.root_win) {
- get_monitors();
- init_config();
- config_read_file (config_path);
- init_panel();
- cleanup_config();
+ signal_pending = SIGUSR1;
return;
}
}
}
+char *GetAtomName(Display* disp, Atom a)
+{
+ if (a == None)
+ return "None";
+ else
+ return XGetAtomName(disp, a);
+}
+
+typedef struct Property
+{
+ unsigned char *data;
+ int format, nitems;
+ Atom type;
+} Property;
+
+//This fetches all the data from a property
+struct Property 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);
+
+ fprintf(stderr, "DnD %s:%d: Property:\n", __FILE__, __LINE__);
+ fprintf(stderr, "DnD %s:%d: Actual type: %s\n", __FILE__, __LINE__, GetAtomName(disp, actual_type));
+ fprintf(stderr, "DnD %s:%d: Actual format: %d\n", __FILE__, __LINE__, actual_format);
+ fprintf(stderr, "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;
+}
-void dnd_message(XClientMessageEvent *e)
+// 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 pick_target_from_list(Display* disp, Atom* atom_list, int nitems)
{
+ Atom to_be_requested = None;
+ int i;
+ for (i = 0; i < nitems; i++) {
+ char *atom_name = GetAtomName(disp, atom_list[i]);
+ fprintf(stderr, "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 (strcmp(atom_name, "STRING") == 0) {
+ to_be_requested = atom_list[i];
+ }
+ }
+
+ 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 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 pick_target_from_list(disp, atoms, n);
+}
+
+// Finds the best target given a local copy of a property.
+Atom 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 pick_target_from_list(disp, atom_list, p.nitems);
+ }
+}
+
+void 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);
+
+ fprintf(stderr, "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, "DnD %s:%d: Protocol version = %d\n", __FILE__, __LINE__, dnd_version);
+ fprintf(stderr, "DnD %s:%d: Type 1 = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, e->data.l[2]));
+ fprintf(stderr, "DnD %s:%d: Type 2 = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, e->data.l[3]));
+ fprintf(stderr, "DnD %s:%d: Type 3 = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, 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 = read_property(server.dsp, dnd_source_window, server.atom.XdndTypeList);
+ dnd_atom = pick_target_from_targets(server.dsp, p);
+ XFree(p.data);
+ } else {
+ //Use the available list
+ dnd_atom = pick_target_from_atoms(server.dsp, e->data.l[2], e->data.l[3], e->data.l[4]);
+ }
+
+ fprintf(stderr, "DnD %s:%d: Requested type = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, dnd_atom));
+}
+
+void 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;
if (task->desktop != server.desktop )
set_desktop (task->desktop);
window_action(task, TOGGLE);
+ } else {
+ LauncherIcon *icon = click_launcher_icon(panel, mapX, mapY);
+ if (icon) {
+ accept = 1;
+ dnd_launcher_exec = icon->cmd;
+ } else {
+ dnd_launcher_exec = 0;
+ }
}
// send XdndStatus event to get more XdndPosition events
se.message_type = server.atom.XdndStatus;
se.format = 32;
se.data.l[0] = e->window; // XID of the target window
- se.data.l[1] = 0; // bit 0: accept drop bit 1: send XdndPosition events if inside rectangle
+ 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
- se.data.l[4] = None; // None = drop will not be accepted
+ if (accept) {
+ se.data.l[4] = dnd_version >= 2 ? e->data.l[4] : server.atom.XdndActionCopy;
+ } else {
+ se.data.l[4] = None; // None = drop will not be accepted
+ }
+
XSendEvent(server.dsp, e->data.l[0], False, NoEventMask, (XEvent*)&se);
}
+void dnd_drop(XClientMessageEvent *e)
+{
+ if (dnd_target_window && dnd_launcher_exec) {
+ if (dnd_version >= 1) {
+ XConvertSelection(server.dsp, server.atom.XdndSelection, XA_STRING, dnd_selection, dnd_target_window, e->data.l[2]);
+ } else {
+ XConvertSelection(server.dsp, server.atom.XdndSelection, XA_STRING, 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, sizeof(m), 0);
+ 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.dsp, e->data.l[0], False, NoEventMask, (XEvent*)&m);
+ }
+}
int main (int argc, char *argv[])
{
Panel *panel;
GSList *it;
struct timeval* timeout;
+ int hidden_dnd = 0;
+start:
init (argc, argv);
- init_config();
init_X11();
i = 0;
}
init_panel();
- cleanup_config();
if (snapshot_path) {
get_snapshot(snapshot_path);
cleanup();
x11_fd = ConnectionNumber(server.dsp);
XSync(server.dsp, False);
+ // XDND initialization
+ dnd_source_window = 0;
+ dnd_target_window = 0;
+ dnd_version = 0;
+ dnd_selection = XInternAtom(server.dsp, "PRIMARY", 0);
+ dnd_atom = None;
+ dnd_sent_request = 0;
+ dnd_launcher_exec = 0;
+
// sigset_t empty_mask;
// sigemptyset(&empty_mask);
else {
if (panel->temp_pmap) XFreePixmap(server.dsp, panel->temp_pmap);
panel->temp_pmap = XCreatePixmap(server.dsp, server.root_win, panel->area.width, panel->area.height, server.depth);
- refresh(&panel->area);
+ rendering(panel);
XCopyArea(server.dsp, panel->temp_pmap, panel->main_win, server.gc, 0, 0, panel->area.width, panel->area.height, 0, 0);
}
}
autohide_trigger_show(panel);
else if (e.type == LeaveNotify)
autohide_trigger_hide(panel);
- if (panel->is_hidden)
- continue; // discard further processing of this event because the panel is not visible yet
+ if (panel->is_hidden) {
+ if (e.type == ClientMessage && e.xclient.message_type == server.atom.XdndPosition) {
+ hidden_dnd = 1;
+ autohide_show(panel);
+ }
+ else
+ continue; // discard further processing of this event because the panel is not visible yet
+ }
+ else if (hidden_dnd && e.type == ClientMessage && e.xclient.message_type == server.atom.XdndLeave) {
+ hidden_dnd = 0;
+ autohide_hide(panel);
+ }
}
switch (e.type) {
if (e.xmotion.state & button_mask)
event_button_motion_notify (&e);
- if (!g_tooltip.enabled) break;
Panel* panel = get_panel(e.xmotion.window);
Area* area = click_area(panel, e.xmotion.x, e.xmotion.y);
if (area->_get_tooltip_text)
- tooltip_trigger_show(area, panel, e.xmotion.x_root, e.xmotion.y_root);
+ tooltip_trigger_show(area, panel, &e);
else
tooltip_trigger_hide();
break;
}
case LeaveNotify:
- if (g_tooltip.enabled)
- tooltip_trigger_hide();
+ tooltip_trigger_hide();
break;
case Expose:
case UnmapNotify:
case DestroyNotify:
if (e.xany.window == server.composite_manager) {
- // TODO: Stop real_transparency
- //signal_pending = SIGUSR2;
+ // Stop real_transparency
+ signal_pending = SIGUSR1;
break;
}
- if (e.xany.window == g_tooltip.window || !systray.area.on_screen)
+ if (e.xany.window == g_tooltip.window || !systray_enabled)
break;
for (it = systray.list_icons; it; it = g_slist_next(it)) {
if (((TrayWindow*)it->data)->tray_id == e.xany.window) {
break;
}
}
- break;
+ break;
case ClientMessage:
ev = &e.xclient;
if (ev->data.l[1] == server.atom._NET_WM_CM_S0) {
if (ev->data.l[2] == None)
- // TODO: Stop real_transparency
- //signal_pending = SIGUSR2;
- ;
+ // Stop real_transparency
+ signal_pending = SIGUSR1;
else
- // TODO: Start real_transparency
- //signal_pending = SIGUSR2;
- ;
+ // Start real_transparency
+ signal_pending = SIGUSR1;
}
- if (!systray.area.on_screen) break;
- if (e.xclient.message_type == server.atom._NET_SYSTEM_TRAY_OPCODE && e.xclient.format == 32 && e.xclient.window == net_sel_win) {
+ if (systray_enabled && e.xclient.message_type == server.atom._NET_SYSTEM_TRAY_OPCODE && e.xclient.format == 32 && e.xclient.window == net_sel_win) {
net_message(&e.xclient);
}
+ else if (e.xclient.message_type == server.atom.XdndEnter) {
+ dnd_enter(&e.xclient);
+ }
else if (e.xclient.message_type == server.atom.XdndPosition) {
- dnd_message(&e.xclient);
+ dnd_position(&e.xclient);
+ }
+ else if (e.xclient.message_type == server.atom.XdndDrop) {
+ dnd_drop(&e.xclient);
}
break;
+ case SelectionNotify:
+ {
+ Atom target = e.xselection.target;
+
+ fprintf(stderr, "DnD %s:%d: A selection notify has arrived!\n", __FILE__, __LINE__);
+ fprintf(stderr, "DnD %s:%d: Requestor = %lu\n", __FILE__, __LINE__, e.xselectionrequest.requestor);
+ fprintf(stderr, "DnD %s:%d: Selection atom = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, e.xselection.selection));
+ fprintf(stderr, "DnD %s:%d: Target atom = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, target));
+ fprintf(stderr, "DnD %s:%d: Property atom = %s\n", __FILE__, __LINE__, GetAtomName(server.dsp, e.xselection.property));
+
+ if (e.xselection.property != None && dnd_launcher_exec) {
+ Property prop = read_property(server.dsp, dnd_target_window, dnd_selection);
+
+ //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 = pick_target_from_targets(server.dsp, prop);
+
+ if (dnd_atom == None) {
+ fprintf(stderr, "No matching datatypes.\n");
+ } else {
+ //Request the data type we are able to select
+ fprintf(stderr, "Now requsting type %s", GetAtomName(server.dsp, dnd_atom));
+ XConvertSelection(server.dsp, dnd_selection, dnd_atom, dnd_selection, dnd_target_window, CurrentTime);
+ }
+ } else if (target == dnd_atom) {
+ //Dump the binary data
+ fprintf(stderr, "DnD %s:%d: Data begins:\n", __FILE__, __LINE__);
+ fprintf(stderr, "--------\n");
+ int i;
+ for (i = 0; i < prop.nitems * prop.format/8; i++)
+ fprintf(stderr, "%c", ((char*)prop.data)[i]);
+ fprintf(stderr, "--------\n");
+
+ int cmd_length = 0;
+ cmd_length += 1; // (
+ cmd_length += strlen(dnd_launcher_exec) + 1; // exec + space
+ cmd_length += 1; // open double quotes
+ for (i = 0; i < prop.nitems * prop.format/8; i++) {
+ char c = ((char*)prop.data)[i];
+ if (c == '\n') {
+ if (i < prop.nitems * prop.format/8 - 1) {
+ cmd_length += 3; // close double quotes, space, open double quotes
+ }
+ } else if (c == '\r') {
+ } else {
+ cmd_length += 1; // 1 character
+ if (c == '`' || c == '$' || c == '\\') {
+ cmd_length += 1; // escape with one backslash
+ }
+ }
+ }
+ cmd_length += 1; // close double quotes
+ cmd_length += 2; // &)
+ cmd_length += 1; // terminator
+
+ char *cmd = malloc(cmd_length);
+ cmd[0] = '\0';
+ strcat(cmd, "(");
+ strcat(cmd, dnd_launcher_exec);
+ strcat(cmd, " \"");
+ for (i = 0; i < prop.nitems * prop.format/8; i++) {
+ char c = ((char*)prop.data)[i];
+ if (c == '\n') {
+ if (i < prop.nitems * prop.format/8 - 1) {
+ strcat(cmd, "\" \"");
+ }
+ } else if (c == '\r') {
+ } else {
+ if (c == '`' || c == '$' || c == '\\') {
+ strcat(cmd, "\\");
+ }
+ char sc[2];
+ sc[0] = c;
+ sc[1] = '\0';
+ strcat(cmd, sc);
+ }
+ }
+ strcat(cmd, "\"");
+ strcat(cmd, "&)");
+ fprintf(stderr, "DnD %s:%d: Running command: %s\n", __FILE__, __LINE__, cmd);
+ tint_exec(cmd);
+ free(cmd);
+
+ // Reply OK.
+ XClientMessageEvent m;
+ memset(&m, sizeof(m), 0);
+ m.type = ClientMessage;
+ m.display = server.dsp;
+ 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.dsp, dnd_source_window, False, NoEventMask, (XEvent*)&m);
+ XSync(server.dsp, False);
+ }
+
+ XFree(prop.data);
+ }
+
+ break;
+ }
+
default:
if (e.type == XDamageNotify+damage_event) {
// union needed to avoid strict-aliasing warnings by gcc
callback_timeout_expired();
- switch (signal_pending) {
- case SIGUSR1: // reload config file
- signal_pending = 0;
- init_config();
- config_read_file (config_path);
- init_panel();
- cleanup_config();
- break;
- case SIGINT:
- case SIGTERM:
- case SIGHUP:
- cleanup ();
- return 0;
+ if (signal_pending) {
+ cleanup();
+ if (signal_pending == SIGUSR1) {
+ // restart tint2
+ // SIGUSR1 used when : user's signal, composite manager stop/start or xrandr
+ FD_CLR (x11_fd, &fdset); // not sure if needed
+ goto start;
+ }
+ else {
+ // SIGINT, SIGTERM, SIGHUP
+ return 0;
+ }
}
}
}