X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=src%2Ftint.c;h=5767f2b53bd4704606b9968634ed6ec542959106;hb=827f5d6fc955e7071351716d7d0d41b66ed65a76;hp=0e8cad8adadf6614da927ea4f337df658d4ff8fa;hpb=90eae1e7be4621a84a0253c3048790523f0c8375;p=chaz%2Ftint2 diff --git a/src/tint.c b/src/tint.c index 0e8cad8..5767f2b 100644 --- a/src/tint.c +++ b/src/tint.c @@ -31,6 +31,11 @@ #include #include +#ifdef HAVE_SN +#include +#include +#endif + #include #include "server.h" #include "window.h" @@ -44,6 +49,14 @@ #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) { @@ -112,6 +125,58 @@ void init (int argc, char *argv[]) // sigprocmask(SIG_BLOCK, &block_mask, 0); } +#ifdef HAVE_SN +static int error_trap_depth = 0; + +static void +error_trap_push (SnDisplay *display, + Display *xdisplay) +{ + ++error_trap_depth; +} + +static void +error_trap_pop (SnDisplay *display, + Display *xdisplay) +{ + if (error_trap_depth == 0) + { + fprintf(stderr, "Error trap underflow!\n"); + return; + } + + XSync(xdisplay, False); /* get all errors out of the queue */ + --error_trap_depth; +} + +static void sigchld_handler(int sig) { + // Wait for all dead processes + pid_t pid; + while ((pid = waitpid(-1, NULL, WNOHANG)) > 0) { + SnLauncherContext *ctx; + ctx = (SnLauncherContext *) g_tree_lookup (server.pids, GINT_TO_POINTER (pid)); + if (ctx == NULL) { + fprintf(stderr, "Unknown child %d terminated!\n", pid); + } + else { + g_tree_remove (server.pids, GINT_TO_POINTER (pid)); + sn_launcher_context_complete (ctx); + sn_launcher_context_unref (ctx); + } + } +} + +static gint cmp_ptr(gconstpointer a, gconstpointer b) { + if (a < b) + return -1; + else if (a == b) + return 0; + else + return 1; +} + +#endif // HAVE_SN + void init_X11() { server.dsp = XOpenDisplay (NULL); @@ -126,6 +191,19 @@ void init_X11() server_init_visual(); XSetErrorHandler ((XErrorHandler) server_catch_error); +#ifdef HAVE_SN + // Initialize startup-notification + server.sn_dsp = sn_display_new (server.dsp, error_trap_push, error_trap_pop); + server.pids = g_tree_new (cmp_ptr); + // Setup a handler for child termination + struct sigaction act; + memset (&act, 0, sizeof (struct sigaction)); + act.sa_handler = sigchld_handler; + if (sigaction(SIGCHLD, &act, 0)) { + perror("sigaction"); + } +#endif // HAVE_SN + imlib_context_set_display (server.dsp); imlib_context_set_visual (server.visual); imlib_context_set_colormap (server.colormap); @@ -253,14 +331,14 @@ void window_action (Task *tsk, int action) case NEXT_TASK: if (task_active) { Task *tsk1; - tsk1 = next_task(task_active); + tsk1 = next_task(find_active_task(tsk, task_active)); set_active(tsk1->win); } break; case PREV_TASK: if (task_active) { Task *tsk1; - tsk1 = prev_task(task_active); + tsk1 = prev_task(find_active_task(tsk, task_active)); set_active(tsk1->win); } } @@ -372,8 +450,10 @@ 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); @@ -436,7 +516,7 @@ void event_button_release (XEvent *e) 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); + launcher_action(icon, e); } task_drag = 0; return; @@ -490,13 +570,41 @@ void event_property_notify (XEvent *e) // Change name of desktops else if (at == server.atom._NET_DESKTOP_NAMES) { - printf("_NET_DESKTOP_NAMES\n"); + 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(); for (i=0 ; i < nb_panel ; i++) { @@ -524,7 +632,9 @@ void event_property_notify (XEvent *e) 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; @@ -534,7 +644,9 @@ void event_property_notify (XEvent *e) } } 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; @@ -553,7 +665,7 @@ void event_property_notify (XEvent *e) 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]); @@ -690,9 +802,150 @@ void event_configure_notify (Window win) } } +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; @@ -704,6 +957,14 @@ void dnd_message(XClientMessageEvent *e) 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 @@ -713,13 +974,42 @@ void dnd_message(XClientMessageEvent *e) 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[]) { @@ -759,6 +1049,15 @@ start: 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); @@ -806,6 +1105,9 @@ start: if (select(x11_fd+1, &fdset, 0, 0, timeout) > 0) { while (XPending (server.dsp)) { XNextEvent(server.dsp, &e); +#if HAVE_SN + sn_display_process_event (server.sn_dsp, &e); +#endif // HAVE_SN panel = get_panel(e.xany.window); if (panel && panel_autohide) { @@ -842,7 +1144,6 @@ start: 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) @@ -853,8 +1154,7 @@ start: } case LeaveNotify: - if (g_tooltip.enabled) - tooltip_trigger_hide(); + tooltip_trigger_hide(); break; case Expose: @@ -892,7 +1192,7 @@ start: break; } } - break; + break; case ClientMessage: ev = &e.xclient; @@ -907,11 +1207,122 @@ start: 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