plan9-archive/devwsys-prev

devwsys/dat.h+13−0

 	CursorSize=	32
 };
+/* snarf buffer size */
+enum{
+	SnarfSize=	100*1024
+};
 /* Datatypes: */
 typedef struct Client Client;
 typedef struct DImage DImage;
 typedef struct Refresh Refresh;
 typedef struct Refx Refx;
 typedef struct Cursor Cursor;
+typedef struct Clip Clip;
 typedef struct Window Window;
 /* Drawing device */
 	uchar	mask[(CursorSize/8)*CursorSize];
 };
+/* snarf buffer */
+struct Clip
+{
+	char buf[SnarfSize];
+};
 /* Window system */
 struct Window
 {
 Window	**window;
 int		nclient;
 Client	**client;
+Clip clip;

devwsys/fns.h+2−0

@@ -49,3 +49,5 @@ int xupdatelabel(Window*); · 48 unmodified lines
49	void xtopwindow(Window*);	49	void xtopwindow(Window*);
50	void xresizewindow(Window*, Rectangle);	50	void xresizewindow(Window*, Rectangle);
51	void xsetcursor(Window*);	51	void xsetcursor(Window*);
		52	char* xgetsnarf(Window*);
		53	void xputsnarf(Window, char);

devwsys/ixp_fsys.c+58−5

 typedef char* (*MsgFunc)(void*, IxpMsg*);
 typedef char* (*BufFunc)(void*);
+static char *snarfbuf;
 static void
 dostat(IxpStat *s, IxpFileId *f) {
 	s->type = 0;
 		w->mouseopen = 1;
 		ixp_pending_pushfid(w->mousep, r->fid);
 		break;
+	case FsFSnarf:
+		if((r->ifcall.topen.mode&3) == ORDWR){
+			/* one at a time please */
+			ixp_respond(r, Enoperm);
+			return;
+		}
+		break;
 	}
 	if((r->ifcall.topen.mode&3) == OEXEC
 void
 fs_read(Ixp9Req *r) {
-	char buf[512];
+	char buf[512], *s;
 	int n;
 	IxpFileId *f;
 	Client *cl;
 		}
 		n = readrefresh(buf, r->ifcall.io.count, cl);
 		if(n > 0) {
 			ixp_srv_readbuf(r, buf, n);
 			ixp_respond(r, nil);
 		}
 			ixp_srv_readbuf(r, w->label, strlen(w->label));
 		ixp_respond(r, nil);
 		return;
+	case FsFSnarf:
+		s= xgetsnarf(w);
+		ixp_srv_readbuf(r, s, strlen(s));
+		ixp_respond(r, nil);
+		return;
 	case FsFWctl:
 		// XXX TODO: visible, current
 		sprint(buf, "%11d %11d %11d %11d %s %s ", w->orig.x +  w->screenr.min.x, w->orig.y + w->screenr.min.y, w->screenr.max.x, w->screenr.max.y, "visible", "current");
 void
 fs_write(Ixp9Req *r) {
-	char *label;
+	char *label, *p;
 	char err[256];
 	IxpFileId *f;
 	Window *w;
 		label[r->ifcall.twrite.count] = 0;
 		setlabel(w, label);
 		break;
+	case FsFSnarf:
+		if(r->ifcall.twrite.offset+r->ifcall.twrite.count >= SnarfSize){
+			ixp_respond(r, "too much snarf");
+			return;
+		}
+		if(r->ifcall.twrite.count == 0){
+			r->ofcall.io.count = r->ifcall.io.count;
+			break;
+		}
+		if(snarfbuf == nil)
+			r->ofcall.io.count = 0;
+		else
+			r->ofcall.io.count = strlen(snarfbuf);
+		if(r->ifcall.twrite.offset+r->ifcall.twrite.count > r->ofcall.io.count){
+			r->ofcall.io.count = r->ifcall.twrite.offset+r->ifcall.twrite.count;
+			p = malloc(r->ofcall.io.count+1);
+			if(p == nil){
+				ixp_respond(r, Enomem);
+				return;
+			}
+			if(snarfbuf){
+				strcpy(p, snarfbuf);
+				free(snarfbuf);
+			}
+			snarfbuf = p;
+		}
+		memmove(snarfbuf+r->ifcall.twrite.offset, r->ifcall.twrite.data, r->ifcall.twrite.count);
+		break;
 	case FsFWctl:
  		r->ofcall.io.count = r->ifcall.io.count;
 		wctlmesg(w, r->ifcall.twrite.data, r->ofcall.rwrite.count, err);
-		ixp_respond(r, nil);
+		break;
-		return;
 	}
 	ixp_respond(r, nil);
 }
 	}
 	// TODO: ../../inferno-os/emu/port/devdraw.c:971
-	if(f->tab.type == FsFCtl)
+	switch(f->tab.type){
+	case FsFCtl:
 		cl->busy = 0;
+	case FsFSnarf:
+		if(r->fid->omode == OWRITE){
+			if(snarfbuf)
+				xputsnarf(w, snarfbuf);
+			else
+				xputsnarf(w, "");
+		}
+		free(snarfbuf);
+	}
 	if(!iswindow(f->tab.type) && (decref(&cl->r)==0))
 		drawfree(cl);
 	ixp_respond(r, nil);

devwsys/x11/display.c+4−0

 #include <memlayer.h>
 #include <cursor.h>
 #include "dat.h"
+#include "fns.h"
 #include "inc.h"
 #include "x.h"
 		setupcmap(xconn.root);
 	}
 	xconn.screenrect = Rect(0, 0, WidthOfScreen(xconn.screen), HeightOfScreen(xconn.screen));
+	xinitclipboard();
 	return 0;
 }

devwsys/x11/event.c+5−0

 		writekbd(w, -1);;
 		break;
+	case SelectionRequest:
+		xselect(&xev);
+		break;
 	default:
 		break;
 	}
 {
 	Mouse m;
+	xsetsnarfowner(w);
 	if(xtoplan9mouse(&xev, &m) < 0)
 		return;
 	// debugev("Mouse event at window %d: x=%d y=%d b=%d\n", w->id, m.xy.x, m.xy.y, m.buttons);

devwsys/x11/itrans.c+212−10

@@ -8,6 +8,14 @@ · 7 unmodified lines
8	#include "inc.h"	8	#include "inc.h"
9	#include "x.h"	9	#include "x.h"
10		10
		11	/* for copy/paste, lifted from plan9ports via drawterm */
		12	static int putsnarf, assertsnarf;
		13	static Atom clipboard;
		14	static Atom utf8string;
		15	static Atom targets;
		16	static Atom text;
		17	static Atom compoundtext;
		18
11	long keysym2ucs(KeySym);	19	long keysym2ucs(KeySym);
12	int	20	int
13	xtoplan9kbd(XEvent *e)	21	xtoplan9kbd(XEvent *e)
@@ -126,16 +134,6 @@ xtoplan9mouse(XEvent e, Mouse m) · 112 unmodified lines
126	XButtonEvent *be;	134	XButtonEvent *be;
127	XMotionEvent *me;	135	XMotionEvent *me;
128		136
129	/* TODO
130	if(_x.putsnarf != _x.assertsnarf){
131	_x.assertsnarf = _x.putsnarf;
132	XSetSelectionOwner(_x.display, XA_PRIMARY, _x.drawable, CurrentTime);
133	if(_x.clipboard != None)
134	XSetSelectionOwner(_x.display, _x.clipboard, _x.drawable, CurrentTime);
135	XFlush(_x.display);
136	}
137	*/
138
139	switch(e->type){	137	switch(e->type){
140	case ButtonPress:	138	case ButtonPress:
141	be = (XButtonEvent*)e;	139	be = (XButtonEvent*)e;
@@ -222,3 +220,207 @@ xtoplan9mouse(XEvent e, Mouse m) · 80 unmodified lines
222	m->buttons \|= 16;	220	m->buttons \|= 16;
223	return 0;	221	return 0;
224	}	222	}
		223
		224	/*
		225	* Cut and paste. Just couldn't stand to make this simple...
		226	*/
		227
		228	void
		229	xinitclipboard(void){
		230	clipboard = XInternAtom(xconn.display, "CLIPBOARD", False);
		231	utf8string = XInternAtom(xconn.display, "UTF8_STRING", False);
		232	targets = XInternAtom(xconn.display, "TARGETS", False);
		233	text = XInternAtom(xconn.display, "TEXT", False);
		234	compoundtext = XInternAtom(xconn.display, "COMPOUND_TEXT", False);
		235	}
		236
		237	void
		238	xsetsnarfowner(Window *w)
		239	{
		240	Xwin *xw;
		241
		242	xw = w->x;
		243	if(putsnarf != assertsnarf){
		244	assertsnarf = putsnarf;
		245	XSetSelectionOwner(xconn.display, XA_PRIMARY, xw->drawable, CurrentTime);
		246	if(clipboard != None)
		247	XSetSelectionOwner(xconn.display, clipboard, xw->drawable, CurrentTime);
		248	XFlush(xconn.display);
		249	}
		250	}
		251
		252	char*
		253	xgetsnarf(Window *window)
		254	{
		255	uchar data, xdata;
		256	Atom clipboard, type, prop;
		257	unsigned long len, lastlen, dummy;
		258	int fmt, i;
		259	XWindow w, xdrawable;
		260	XDisplay *xd;
		261	Xwin *xw;
		262
		263	/*
		264	* Have we snarfed recently and the X server hasn't caught up?
		265	*/
		266	if(putsnarf != assertsnarf)
		267	goto mine;
		268
		269	xd = xconn.display;
		270	xw = window->x;
		271	xdrawable = xw->drawable;
		272
		273	/*
		274	* Is there a primary selection (highlighted text in an xterm)?
		275	*/
		276	clipboard = XA_PRIMARY;
		277	w = XGetSelectionOwner(xd, XA_PRIMARY);
		278	if(w == xdrawable){
		279	mine:
		280	data = (uchar*)strdup(clip.buf);
		281	goto out;
		282	}
		283
		284	/*
		285	* If not, is there a clipboard selection?
		286	*/
		287	if(w == None && clipboard != None){
		288	clipboard = clipboard;
		289	w = XGetSelectionOwner(xd, clipboard);
		290	if(w == xdrawable)
		291	goto mine;
		292	}
		293
		294	/*
		295	* If not, give up.
		296	*/
		297	if(w == None){
		298	data = nil;
		299	goto out;
		300	}
		301
		302	/*
		303	* We should be waiting for SelectionNotify here, but it might never
		304	* come, and we have no way to time out. Instead, we will clear
		305	* local property #1, request our buddy to fill it in for us, and poll
		306	* until he's done or we get tired of waiting.
		307	*
		308	* We should try to go for utf8string instead of XA_STRING,
		309	* but that would add to the polling.
		310	*/
		311	prop = 1;
		312	XChangeProperty(xd, xdrawable, prop, XA_STRING, 8, PropModeReplace, (uchar*)"", 0);
		313	XConvertSelection(xd, clipboard, XA_STRING, prop, xdrawable, CurrentTime);
		314	XFlush(xd);
		315	lastlen = 0;
		316	for(i=0; i<10 \|\| (lastlen!=0 && i<30); i++){
		317	usleep(10*1000);
		318	XGetWindowProperty(xd, xdrawable, prop, 0, 0, 0, AnyPropertyType,
		319	&type, &fmt, &dummy, &len, &data);
		320	if(lastlen == len && len > 0)
		321	break;
		322	lastlen = len;
		323	}
		324	if(i == 10){
		325	data = nil;
		326	goto out;
		327	}
		328	/* get the property */
		329	data = nil;
		330	XGetWindowProperty(xd, xdrawable, prop, 0, SnarfSize/sizeof(unsigned long), 0,
		331	AnyPropertyType, &type, &fmt, &len, &dummy, &xdata);
		332	if((type != XA_STRING && type != utf8string) \|\| len == 0){
		333	if(xdata)
		334	XFree(xdata);
		335	data = nil;
		336	}else{
		337	if(xdata){
		338	data = (uchar)strdup((char)xdata);
		339	XFree(xdata);
		340	}else
		341	data = nil;
		342	}
		343	out:
		344	return (char*)data;
		345	}
		346
		347	void
		348	xputsnarf(Window window, char data)
		349	{
		350	XButtonEvent e;
		351	XWindow xdrawable;
		352	Xwin *xw;
		353
		354	if(strlen(data) >= SnarfSize)
		355	return;
		356	strcpy(clip.buf, data);
		357
		358	xw = window->x;
		359	xdrawable = xw->drawable;
		360
		361	/* leave note for mouse proc to assert selection ownership */
		362	putsnarf++;
		363
		364	/* send mouse a fake event so snarf is announced */
		365	memset(&e, 0, sizeof e);
		366	e.type = ButtonPress;
		367	e.window = xdrawable;
		368	e.state = ~0;
		369	e.button = ~0;
		370	XSendEvent(xconn.display, xdrawable, True, ButtonPressMask, (XEvent*)&e);
		371	XFlush(xconn.display);
		372	}
		373
		374	void
		375	xselect(XEvent *e)
		376	{
		377	char *name;
		378	XEvent r;
		379	XSelectionRequestEvent *xe;
		380	Atom a[4];
		381	XDisplay *xd;
		382
		383	if(e->xany.type != SelectionRequest)
		384	return;
		385
		386	xd = xconn.display;
		387
		388	memset(&r, 0, sizeof r);
		389	xe = (XSelectionRequestEvent*)e;
		390	if(0) iprint("xselect target=%d requestor=%d property=%d selection=%d\n",
		391	xe->target, xe->requestor, xe->property, xe->selection);
		392	r.xselection.property = xe->property;
		393	if(xe->target == targets){
		394	a[0] = XA_STRING;
		395	a[1] = utf8string;
		396	a[2] = text;
		397	a[3] = compoundtext;
		398
		399	XChangeProperty(xd, xe->requestor, xe->property, xe->target,
		400	8, PropModeReplace, (uchar*)a, sizeof a);
		401	}else if(xe->target == XA_STRING \|\| xe->target == utf8string \|\| xe->target == text \|\| xe->target == compoundtext){
		402	/* if the target is STRING we're supposed to reply with Latin1 XXX */
		403	XChangeProperty(xd, xe->requestor, xe->property, xe->target,
		404	8, PropModeReplace, (uchar*)clip.buf, strlen(clip.buf));
		405	}else{
		406	iprint("get %d\n", xe->target);
		407	name = XGetAtomName(xd, xe->target);
		408	if(name == nil)
		409	iprint("XGetAtomName failed\n");
		410	else if(strcmp(name, "TIMESTAMP") != 0)
		411	iprint("%s: cannot handle selection request for '%s' (%d)\n", argv0, name, (int)xe->target);
		412	r.xselection.property = None;
		413	}
		414
		415	r.xselection.display = xe->display;
		416	/* r.xselection.property filled above */
		417	r.xselection.target = xe->target;
		418	r.xselection.type = SelectionNotify;
		419	r.xselection.requestor = xe->requestor;
		420	r.xselection.time = xe->time;
		421	r.xselection.send_event = True;
		422	r.xselection.selection = xe->selection;
		423	XSendEvent(xd, xe->requestor, False, 0, &r);
		424	XFlush(xd);
		425	}
		426

devwsys/x11/x.h+3−0

@@ -70,3 +70,6 @@ void xmovewindow(Window*, Rectangle); · 69 unmodified lines
70	void xputxdata(Memimage*, Rectangle);	70	void xputxdata(Memimage*, Rectangle);
71	void xmemimagedraw(Memimage, Rectangle, Memimage, Point,	71	void xmemimagedraw(Memimage, Rectangle, Memimage, Point,
72	Memimage*, Point, int);	72	Memimage*, Point, int);
		73	void xinitclipboard(void);
		74	void xsetsnarfowner(Window*);
		75	void xselect(XEvent*);