/* Copyright (C) 1996-2001 Ulric Eriksson 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, 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* --- plugin.c The protocol runs over two pipes, connected to the plugin's stdin and stdout: Upon startup, the plugin prints an identification message of the following form: 200 text This line, like every line, is terminated by a single newline character, *not* a CRLF sequence. A result code starting with the digit '2' indicates successful startup. Any other result code is taken as a failure; in particular, a non-digit suggests that this is not a plugin at all! Communication takes place in a command-reply fashion. The command consists of a single line of no more that 1024 characters, starting with a command verb and optionally followed by parameters. Commands are case sensitive. These commands are implemented here: SAVE filename Save data in file LOAD filename Load data from file EXEC string Execute the string, which should be interpretable by the plugin HELP List available commands NOOP Do nothing WIN Print the window id of window to be captured EWIN Tell the plugin where to send events PH Tell the plugin its handle QUIT Quit PRNT Produce Postscript representation of the plugin The reply consists of a numeric result code, the character ' ' followed by text: 200 text Command completed successfully 400 text Command failed 500 text Command unknown The plugin *must reply* even if the command cannot be executed. Otherwise there will be an annoying timeout when the main program waits for the reply. This implementation does *not* handle multi-line replies and will likely choke on them. I'm just testing. The typical use of the plugin library will be like this: 1. plugin_start: The plugin is loaded into the buffer but not displayed. The application runs and displays its toplevel window outside Siag. The toplevel window is found. The geometry is saved. The window is unmapped. The window ID is saved. 2. In activate_window, every plugin in the buffer is checked to see if it needs to be displayed. 3. plugin_show: A new widget is created in the grid, using the geometry information retrieved before. The plugin toplevel is reparented into the widget and then mapped. 4. plugin_hide: The toplevel window is unmapped and the widget destroyed. 5. plugin_stop: plugin is hidden, QUIT is sent and pipes are closed. --- */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../common/common.h" #include #include "plugin.h" #define REPARENT_LOOPS 50 #define PLUGIN_MAX 30 /*#define DEBUG */ char **plugin_patterns; static struct { int pfd[2], qfd[2]; int taken; int visible; pid_t pid; Window victim; Position x, y; Dimension width, height, border, depth; Widget parent, core; /* keeper of new parent window */ } plugin[PLUGIN_MAX]; static int nplugin = 0; static struct { char *desc, *ext, *cmd; } *handler; static int nhandler = 0; static Widget topLevel = None; static Cursor sane_cursor, lr_cursor; static Atom plugin_protocol; static void (*plugin_execute)(char *) = NULL; /* --- write a line to the plugin */ int plugin_write(int ph, char *b) { int retval = write(plugin[ph].pfd[1], b, strlen(b)); return retval; } /* --- read a line from the plugin, return number of chars read */ int plugin_read(int ph, char *b) { fd_set rfds; struct timeval tv; int retval, n; FD_ZERO(&rfds); FD_SET(plugin[ph].qfd[0], &rfds); tv.tv_sec = 30; tv.tv_usec = 0; retval = select(plugin[ph].qfd[0]+1, &rfds, NULL, NULL, &tv); if (!retval) return 0; #if 1 for (n = 0; n < 1024; n++) { if (!read(plugin[ph].qfd[0], b+n, 1)) break; if (b[n] == '\n') { n++; break; } } #else n = read(plugin[ph].qfd[0], b, 1024); #endif b[n] = '\0'; return n; } static char **parse_cmd(char *cmd, char *fn, char *name) { int i = 0; char **argv = (char **)MwMalloc(10*sizeof(char *)); char *cmd_copy = MwStrdup(cmd); char *p; for (p = strtok(cmd_copy, " \n"); p && i < 9; p = strtok(NULL, " \n")) { if (p[0] == '%') { switch (p[1]) { case 's': argv[i++] = MwStrdup(fn); break; case 'W': argv[i++] = MwStrdup(name); break; case '%': argv[i++] = p+1; break; default: ; } } else { argv[i++] = p; } } argv[i] = NULL; return argv; } static int plugin_handler_find(char *ext) { int i; for (i = 0; i < nhandler; i++) if (!strcmp(ext, handler[i].ext)) return i; return -1; } /* --- Run a plugin without displaying it. fn: File name of file to be loaded. The extension is used to choose from available plugins. All the plumbing for communicating with the plugin is set up. Returns a plugin handle for success of -1 for failure. */ int plugin_start(char *fn) { int x, y; unsigned int width, height, border, depth; Window victim, root; int ph, i; char *cmd; char *ext = strrchr(fn, '.'); if (!ext) ext = fn; else ext++; i = plugin_handler_find(ext); if (i == -1) return -1; /* no handler found */ for (ph = 0; ph < nplugin; ph++) if (!plugin[ph].taken) break; if (ph == nplugin) nplugin++; if (nplugin >= PLUGIN_MAX) return -1; /* too many */ cmd = handler[i].cmd; plugin[ph].taken = 1; if (pipe(plugin[ph].pfd) == -1) return -1; if (pipe(plugin[ph].qfd) == -1) return -1; plugin[ph].pid = fork(); if (plugin[ph].pid == -1) { /* error */ nplugin--; return -1; } else if (plugin[ph].pid == 0) { /* child */ char **argv; close(plugin[ph].pfd[1]); dup2(plugin[ph].pfd[0], 0); close(plugin[ph].pfd[0]); close(plugin[ph].qfd[0]); dup2(plugin[ph].qfd[1], 1); close(plugin[ph].qfd[1]); /* run the plugin */ argv = parse_cmd(cmd, fn, "SiAg_PlUgIn"); execvp(argv[0], argv); exit(EXIT_FAILURE); } else { /* parent */ char r[1024]; int n; close(plugin[ph].pfd[0]); close(plugin[ph].qfd[1]); n = 1; while (n) { n = sleep(n); } if (plugin_read(ph, r) < 6 || r[0] != '2') { return -1; } sprintf(r, "EWIN %lx\n", (unsigned long)XtWindow(topLevel)); plugin_write(ph, r); if (plugin_read(ph, r) < 2) { /* it doesn't matter if the plugin returns error */ return -1; } sprintf(r, "PH %d\n", ph); plugin_write(ph, r); if (plugin_read(ph, r) < 2) { return -1; } plugin_write(ph, "WIN\n"); if (plugin_read(ph, r) < 6 || r[0] != '2') { return -1; } victim = strtol(r+4, NULL, 16); if (victim == None) { plugin[ph].taken = 0; return -1; } XGetGeometry(XtDisplay(topLevel), victim, &root, &x, &y, &width, &height, &border, &depth); plugin[ph].width = width+2*border; plugin[ph].height = height+2*border; plugin[ph].border = border; plugin[ph].depth = depth; plugin[ph].victim = victim; plugin[ph].visible = 1; plugin[ph].parent = None; plugin[ph].core = None; plugin[ph].x = 0; /* unused */ plugin[ph].y = 0; plugin_hide(ph); } return ph; } /* --- Resize a plugin. ph: Plugin handle wi: New width he: New height Returns 0 for success or non-0 for failure. */ int plugin_size_set(int ph, int width, int height) { if (width < 10 || width > 1000 || height < 10 || height > 1000) return -1; plugin[ph].width = width; plugin[ph].height = height; if (plugin[ph].visible && plugin[ph].core != None) { XtResizeWidget(plugin[ph].core, width+6, height+6, 1); XResizeWindow(XtDisplay(plugin[ph].core), plugin[ph].victim, width, height); } return 0; } /* --- Kill a plugin. Close the pipes, close the window, kill the process. ph: Plugin handle. Returns 0 for success or non-0 for failure. */ int plugin_stop(int ph) { char b[1024]; plugin_hide(ph); plugin_write(ph, "QUIT\n"); plugin_read(ph, b); close(plugin[ph].pfd[1]); close(plugin[ph].qfd[0]); kill(plugin[ph].pid, SIGINT); plugin[ph].taken = 0; return 0; } /* --- Tell the plugin to load a file. ph: Plugin handle fn: File name Returns 0 for success or non-0 for failure. */ int plugin_load(int ph, char *fn) { char cmd[1024]; sprintf(cmd, "LOAD %s\n", fn); plugin_write(ph, cmd); plugin_read(ph, cmd); /* ignore the response for now */ return 0; } /* --- Tell the plugin to save to a file. ph: plugin handle fn: File name Returns 0 for success or non-0 for failure. */ int plugin_save(int ph, char *fn) { char cmd[1024]; sprintf(cmd, "SAVE %s\n", fn); plugin_write(ph, cmd); plugin_read(ph, cmd); /* ignore the response for now */ return 0; } /* --- Ask the plugin what commands it understands. ph: plugin handle Returns a one-line string with the available commands. Caller must free. */ char *plugin_help(int ph) { char cmd[1024]; plugin_write(ph, "HELP\n"); cmd[0] = '\0'; plugin_read(ph, cmd); return MwStrdup(cmd); } /* --- Find the handle of a plugin running under a widget. */ int plugin_find_by_widget(Widget w) { int ph; for (ph = 0; ph < nplugin; ph++) if (plugin[ph].core == w) return ph; return -1; } /* --- Find the handle of a plugin running in a window. */ int plugin_find_by_window(Window w) { int ph; for (ph = 0; ph < nplugin; ph++) if (plugin[ph].victim == w) return ph; return -1; } /* a callback to tell the app about the change */ static void (*handle_plugin_exit)(int) = NULL; static void handle_destroy(Widget w, XtPointer p, XEvent *event, Boolean *b) { if (event->type == DestroyNotify) { XDestroyWindowEvent dwevent = event->xdestroywindow; int ph = plugin_find_by_window(dwevent.window); if (ph >= 0) { plugin[ph].taken = 0; if (plugin[ph].core != None) XtDestroyWidget(plugin[ph].core); if (handle_plugin_exit) (*handle_plugin_exit)(ph); } } } /* --- Display the plugin, i.e. map the window and reparent if necessary. win: window pointer ph: plugin handle Return 0 for success or non-0 for failure. */ int plugin_show(int ph, Widget grid) { Display *display = XtDisplay(grid); Window w = plugin[ph].victim; Window to; int i; Cardinal n; Window root, parent, *child; plugin[ph].parent = grid; if (plugin[ph].visible) plugin_hide(ph); plugin[ph].visible = 1; /* we don't need to tell Table where to put the widget, because it will be picked up from plugin_coordinates */ plugin[ph].core = XtVaCreateManagedWidget("plugin-parent", compositeWidgetClass, grid, XtNwidth, plugin[ph].width+6, XtNheight, plugin[ph].height+6, XtNborderWidth, 1, (char *)0); to = XtWindow(plugin[ph].core); XSync(display, False); for (i = 0; i < REPARENT_LOOPS; i++) { XReparentWindow(display, w, to, 0, 0); XQueryTree(display, w, &root, &parent, &child, &n); XSync(display, False); } XMoveWindow(display, w, 2, 2); XMapWindow(display, w); XSync(display, False); XtAddEventHandler(plugin[ph].core, SubstructureNotifyMask, False, handle_destroy, (XtPointer)XtWindow(plugin[ph].core)); /* XSelectInput(display, w, SubstructureNotifyMask | FocusChangeMask | LeaveWindowMask | EnterWindowMask | KeyPressMask | KeyReleaseMask | PropertyChangeMask | ColormapChangeMask); */ XDefineCursor(display, w, sane_cursor); return plugin_size_set(ph, plugin[ph].width, plugin[ph].height); } /* --- Hide the plugin, i.e. unmap the window. ph: Plugin handle Returns 0 for success or non-0 for failure. */ int plugin_hide(int ph) { int i; XWMHints *hints; Display *display = XtDisplay(topLevel); Screen *screen = XtScreen(topLevel); Window w = plugin[ph].victim; XSync(display, False); XWithdrawWindow(display, w, XScreenNumberOfScreen(screen)); XSync(display, False); hints = XGetWMHints(display, w); hints->flags |= WindowGroupHint; hints->window_group = RootWindowOfScreen(screen); XSetWMHints(display, w, hints); #if 1 /* testing */ for (i = 0; i < REPARENT_LOOPS; i++) { Window root, parent, *child; Cardinal n; XQueryTree(display, w, &root, &parent, &child, &n); XReparentWindow(display, w, root, 0, 0); XSync(display, False); } #endif if (plugin[ph].core != None) { XtDestroyWidget(plugin[ph].core); plugin[ph].core = None; } return 0; } typedef struct { char *chars; XColor xcolor; } colors; /* --- Clever little hack to print anything, including plugins that don't know how to print themselves. Works the following way: 1. Create override widget of the right size. 2. Reparent plugin to override widget. 3. Send expose event to plugin. 4. Copy override widget to pixmap. 5. Reparent plugin back to main application. 6. Destroy override widget. 7. Print the widget as in image plugin. */ static void prnt(Pixmap pixmap, FILE *fp) { unsigned int width, height, depth = 8; unsigned int ncolors, cpp; int x, y, col; char *title = "Plugged in image"; time_t t; char **data, *key, *color; XpmAttributes xa; int i, n; colors *cm; xa.valuemask = 0; /* figure out a thing or two */ n = XpmCreateDataFromPixmap(XtDisplay(topLevel), &data, pixmap, None, &xa); if (n != XpmSuccess) { printf("503 XpmCreateDataFromPixmap returns %d\n", n); return; } sscanf(data[0], "%d %d %d %d", &width, &height, &ncolors, &cpp); cm = (colors *)MwMalloc(ncolors*sizeof(colors)); for (i = 0; i < ncolors; i++) { cm[i].chars = (char *)MwMalloc(cpp); memcpy(cm[i].chars, data[i+1], cpp); key = strtok(data[i+1]+cpp, " \t"); /* skip past chars */ color = strtok(NULL, " \t"); while (key && color && strcmp(key, "c")) { key = strtok(NULL, " \t"); color = strtok(NULL, " \t"); }; if (!color) { printf("504 No such color\n"); return; } XParseColor(XtDisplay(topLevel), XDefaultColormapOfScreen(XtScreen(topLevel)), color, &cm[i].xcolor); } /* print postscript preblurb */ fprintf(fp, "%%!PS-Adobe-2.0 EPSF-2.0\n"); fprintf(fp, "%%%%Creator: Image plugin for Siag Office\n"); fprintf(fp, "%%%%Title: %s\n", title); fprintf(fp, "%%%%Pages: 1\n"); fprintf(fp, "%%%%BoundingBox: %d %d %d %d\n", 0, 0, width, height); t = time(NULL); fprintf(fp, "%%%%CreationDate: %s", ctime(&t)); fprintf(fp, "%%%%EndComments\n"); fprintf(fp, "%%%%EndProlog\n"); fprintf(fp, "%%%%Page: 1 1\n\n\n"); fprintf(fp, "gsave\n\n"); fprintf(fp, "/inch {72 mul} def\n"); fprintf(fp, "%d %d scale\n", width, height); fprintf(fp, "/line %d string def\n", 3*width); fprintf(fp, "%d %d %d\n", width, height, depth); fprintf(fp, "[ %d %d %d %d %d %d ]\n", width, 0, 0, -height, 0, height); fprintf(fp, "{currentfile line readhexstring pop}\n"); fprintf(fp, "false 3 colorimage\n"); /* print all the pixels */ col = 0; for (y = 0; y < height; y++) { char *line = data[y+ncolors+1]; for (x = 0; x < width; x++) { char *pix = line+cpp*x; for (i = 0; i < ncolors; i++) if (!memcmp(cm[i].chars, pix, cpp)) break; if (i == ncolors) i = 0; fprintf(fp, "%02hx%02hx%02hx", (cm[i].xcolor.red / 256) & 255, (cm[i].xcolor.green / 256) & 255, (cm[i].xcolor.blue / 256) & 255); col += 6; if (col >= 72) { fprintf(fp, "\n"); col = 0; } } } if (col) fprintf(fp, "\n"); /* print postscript postblurb */ fprintf(fp, "%%\n\n"); fprintf(fp, "grestore\n"); for (i = 0; i < ncolors; i++) MwFree(cm[i].chars); MwFree(cm); MwFree(data); } /* --- Print even though the plugin doesn't know how. */ static int print_anyway(int ph, FILE *fp) { Widget ow; unsigned int width = plugin[ph].width; unsigned int height = plugin[ph].height; int i; ow = XtVaCreatePopupShell("plugin_print", overrideShellWidgetClass, topLevel, XtNx, 0, XtNy, 0, XtNwidth, width, XtNheight, height, (char *)0); XtPopup(ow, XtGrabNone); XSync(XtDisplay(ow), False); for (i = 0; i < 1 /*REPARENT_LOOPS*/; i++) { XReparentWindow(XtDisplay(topLevel), plugin[ph].victim, XtWindow(ow), 0, 0); XSync(XtDisplay(topLevel), False); XClearWindow(XtDisplay(topLevel), plugin[ph].victim); XSync(XtDisplay(topLevel), False); } /* print */ prnt(plugin[ph].victim /*pixmap*/, fp); /* finished printing */ for (i = 0; i < 1 /*REPARENT_LOOPS*/; i++) { XReparentWindow(XtDisplay(topLevel), plugin[ph].victim, XtWindow(plugin[ph].core), 2, 2); XSync(XtDisplay(topLevel), False); } XtDestroyWidget(ow); return 0; } #define TRAILER "%%Trailer" /* --- Tell the plugin to print its window into the file. ph: Plugin handle Returns 0 for success or non-0 for failure, such as an i/o error. */ /* This code just doesn't work. There are too many opportunities for the plugin to mess up the protocol state by sending data without a trailer or by sending extra junk at the end or by sending bogus data. I need to make this much more bulletproof. The first step is to better show the difference between print data and plugin messages. Precede each line with a single space and strip it off here. Finish with a line consisting of the single word END. */ int plugin_print(int ph, FILE *fp, int x, int y, int trust_plugin) { char b[1024]; int w, h; int result = 1; fprintf(fp, "save\n"); fprintf(fp, "%d %d translate\n", x, y); /* figure out how big the clipping rectangle should be */ w = plugin[ph].width; h = plugin[ph].height; fprintf(fp, "newpath %d %d moveto %d %d lineto" " %d %d lineto %d %d lineto closepath clip\n", 0, 0, 0, h, w, h, w, 0); fprintf(fp, "/showpage {} def\n"); /* disarm this */ if (trust_plugin) { plugin_write(ph, "PRNT\n"); if (!plugin_read(ph, b)) { fprintf(stderr, "Nothing from plugin\n"); result = 1; } else if (strlen(b) < 5 || b[0] != '2') { result = print_anyway(ph, fp); } else { while (plugin_read(ph, b)) { if (b[0] != ' ') break; /* found END */ if (strcmp(b, " %%Trailer\n") && strcmp(b, " %%EOF\n")) fputs(b+1, fp); } result = (b[0] == ' '); /* didn't find END */ } } else { result = print_anyway(ph, fp); } fprintf(fp, "restore\n"); return result; } /* --- Register a plugin handler. desc: a plaintext description of the plugin ext: magic extension to be handled by this plugin cmd: command to run the plugin Returns 0 for success, non-0 for failure. */ int plugin_register(char *desc, char *ext, char *cmd) { char b[1024]; int n = plugin_handler_find(ext); if (n == -1) { /* allocate room for new plugin */ n = nhandler++; handler = MwRealloc(handler, nhandler*sizeof *handler); plugin_patterns = MwRealloc(plugin_patterns, (nhandler+1)*sizeof *plugin_patterns); plugin_patterns[nhandler] = NULL; } else { /* reuse old position */ MwFree(handler[n].desc); MwFree(handler[n].ext); MwFree(handler[n].cmd); MwFree(plugin_patterns[n]); } handler[n].desc = MwStrdup(desc); handler[n].ext = MwStrdup(ext); handler[n].cmd = MwStrdup(cmd); sprintf(b, "%s (*.%s)", desc, ext); plugin_patterns[n] = MwStrdup(b); return 0; } /* --- There are eight cases: - upper left corner - upper border - upper right corner - left border - right border - lower left corner - lower border - lower right corner Corners resize, borders move. We don't implement moving yet, only resizing. Also, we only allow resizing using the lower right corner. */ static void PluginResizeAction(Widget w, XEvent *event, String *params, Cardinal *n) { XtAppContext app_context = XtWidgetToApplicationContext(w); int owner_events = True; unsigned int event_mask = ButtonReleaseMask | PointerMotionMask; int pointer_mode = GrabModeAsync; int keyboard_mode = GrabModeAsync; Window confine_to = XtWindow(XtParent(w)); static Cursor cursor = None; Time time = CurrentTime; int waiting = True; Dimension wi, he, wi2, he2; int ph = plugin_find_by_widget(w); if (ph == -1) return; wi = event->xbutton.x; he = event->xbutton.y; XtVaGetValues(w, XtNwidth, &wi2, XtNheight, &he2, (char *)0); if (wi2-wi > 10 || he2-he > 10) return; /* snipped from colnum_grab */ if (cursor == None) cursor = XCreateFontCursor(XtDisplay(w), XC_bottom_right_corner); XtGrabPointer(w, owner_events, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, time); while (waiting) { XEvent event_return; XtAppNextEvent(app_context, &event_return); if (event_return.type == ButtonRelease) { waiting = False; } else if (event_return.type == MotionNotify) { wi = event_return.xmotion.x; he = event_return.xmotion.y; plugin_size_set(ph, wi, he); } else { XtDispatchEvent(&event_return); } } XtUngrabPointer(w, CurrentTime); pr_scr_flag = TRUE; } static void PluginCursorAction(Widget w, XEvent *event, String *params, Cardinal *n) { int x, y; Dimension wi, he; x = event->xmotion.x; y = event->xmotion.y; XtVaGetValues(w, XtNwidth, &wi, XtNheight, &he, (char *)0); if (wi-x < 10 && he-y < 10) { XDefineCursor(XtDisplay(w), XtWindow(w), lr_cursor); } else { XDefineCursor(XtDisplay(w), XtWindow(w), None); } } static XtActionsRec actions[] = { {"plugin-resize", PluginResizeAction}, {"plugin-cursor", PluginCursorAction} }; /* Handle callbacks from plugins The protocol today is: 1. The application registers a window where events can be sent, and a function that can execute commands in the form of strings. 2. An event handler is added to the window which handles ClientMessage events. 3. Each started plugin is passed two pieces of information: the window above using the EWIN command, and its plugin handle using the PH command. 4. When a plugin wants its parent's attention, it stuffs the following information into a ClientMessage event: - the protocol version, currently always 0 - the plugin handle - a ticket: a number used to identify the message. 5. The event is sent to the window registered above. 6. The event handler receives the event, does a little sanity checking and extracts the information. 7. The main application sends the command "WHAT ticket" to the plugin, where ticket is the number from step 4. 8. The plugin responds with a string. 9. The string is passed to the executor function registered in step 1. Now that the communication is established, it is up to the application and plugin to agree on how to continue. For Siag, the commands from the plugin will be handled by the execute function, so the command will simply be a Scheme function call. The function can then do what it is told and the exchange be finished. It may also be that the function comes back to the plugin and asks for more information, or it may feed data to the plugin. Examples: - A database plugin will take a SQL query (using the EXEC command). Since the query may take some time to finish, the main application goes about its business. When the query comes back, the plugin calls out to the main application. It uses a command (collect-sql), which goes back to the plugin and collects the data. There is no collect-sql function and no database plugin yet, I'm just making this up. - A plotting plugin uses a timer to periodically call back for updated data. That way real-time updates can be done without any special support in the main application. There is no plotting plugin yet either, although SciPlot looks promising. - A plugin can use the main application's user interface to display error messages. The plugin protocol only depends on Unix pipes for the communication. This extension depends on X for its implementation. For user interfaces based on X, such as Xt or Gtk, this is fine. For a plugin that has a text-based interface, or no user interface at all (what would a database plugin need a user interface for), there must be another mechanism. */ static int plugin_message(XEvent *event) { return event->type == ClientMessage && event->xclient.message_type == plugin_protocol && event->xclient.format == 32; } static void PluginDispatchEvent(Widget w, XtPointer pt, XEvent *e, Boolean *b) { int n, ph, ticket; char cmd[1024]; if (!plugin_message(e)) { return; } if (e->xclient.data.l[0] != 0) { fprintf(stderr, "Unknown protocol version\n"); return; } ph = e->xclient.data.l[1]; ticket = e->xclient.data.l[2]; sprintf(cmd, "WHAT %d\n", ticket); n = plugin_write(ph, cmd); if (plugin_read(ph, cmd) >= 2) plugin_execute(cmd); } /* end of plugin callback code */ /* --- Initialise the plugin code. */ void plugin_init(Widget w, void (*handle_exit)(int), void (*exec_cmd)(char *)) { Display *dpy; XtAppContext app_context = XtWidgetToApplicationContext(w); topLevel = w; handle_plugin_exit = handle_exit; sane_cursor = XCreateFontCursor(XtDisplay(w), XC_top_left_arrow); lr_cursor = XCreateFontCursor(XtDisplay(w), XC_bottom_right_corner); XtAppAddActions(app_context, actions, XtNumber(actions)); /* experimental code to get attention from plugins */ dpy = XtDisplay(w); plugin_protocol = XInternAtom(dpy, "_PLUGIN_PROTOCOL", False); plugin_execute = exec_cmd; XtAddEventHandler(w, NoEventMask, True, PluginDispatchEvent, NULL); } /* --- Returns the size of a plugin */ int plugin_size_get(int ph, int *width, int *height) { if (ph < 0 || ph >= nplugin) return -1; *width = plugin[ph].width; *height = plugin[ph].height; return 0; }