Context Navigation

source: trunk/athena/bin/xdsc/reply.c @ 12350

Visit:

Revision 12350, 28.6 KB checked in by ghudson, 26 years ago (diff)
Some RCS ID cleanup: delete $Log$ and replace other RCS keywords with $Id$.

Rev	Line
[4988]	1	/*
	2	Copyright 1991 by the Massachusetts Institute of Technology
	3
	4	Permission to use, copy, modify, and distribute this
	5	software and its documentation for any purpose and without
	6	fee is hereby granted, provided that the above copyright
	7	notice appear in all copies and that both that copyright
	8	notice and this permission notice appear in supporting
	9	documentation, and that the name of M.I.T. not be used in
	10	advertising or publicity pertaining to distribution of the
	11	software without specific, written prior permission.
	12	M.I.T. makes no representations about the suitability of
	13	this software for any purpose. It is provided "as is"
	14	without express or implied warranty.
	15	*/
	16
[3914]	17	#include <stdio.h>
[8902]	18	#include <string.h>
[4642]	19	#include <ctype.h>
[3914]	20	#include <X11/Intrinsic.h>
	21	#include <X11/StringDefs.h>
[4642]	22	#include <X11/Xaw/List.h>
	23	#include <X11/Xaw/Command.h>
	24	#include <X11/Xaw/Box.h>
	25	#include <X11/Xaw/Paned.h>
	26	#include <X11/Xaw/AsciiText.h>
	27	#include <X11/Xaw/Dialog.h>
[3914]	28	#include <X11/Shell.h>
	29	#include "xdsc.h"
	30
[12350]	31	static char rcsid[] = "$Id: reply.c,v 1.17 1999-01-22 23:15:39 ghudson Exp $";
[3914]	32
	33	extern char *getenv();
	34	extern char *RunCommand();
[4642]	35	extern char *CurrentMtg();
[3914]	36	extern char filebase[];
[4356]	37	extern int topscreen;
[3951]	38	extern Widget topW, paneW;
[3914]	39	extern TextWidget bottextW;
[3972]	40	extern int char_width;
[5061]	41	extern char *GetTransactionFile();
	42	extern Boolean nocache;
[3914]	43
	44	static char sourcefile[80];
	45
	46	static void SendCB();
[4356]	47	void TriggerSend();
[3914]	48
[4356]	49	static Widget writePopupW = 0, writeTextW;
[3914]	50	static void WriteCB();
[4356]	51	void TriggerWrite();
[3914]	52
[4356]	53	static Widget numPopupW = 0, numTextW;
	54	static void NumCB();
	55	void GetTransactionNum();
	56	void TriggerNum();
	57
[3914]	58	static Widget addPopupW = 0, addHostTextW, addPathTextW;
	59	static void AddCB();
[4356]	60	void TriggerAdd();
[3914]	61
	62	static Widget deletePopupW = 0, deleteMtgTextW;
	63	static void DeleteCB();
[4356]	64	void TriggerDelete();
[3914]	65
	66	static Widget warningPopupW = 0;
[4890]	67	void DieCB();
[4356]	68	void TriggerPopdown();
	69	void TriggerFocusMove();
[4890]	70	int PopdownCB();
[3914]	71
	72	static Widget helpPopupW = 0;
	73
	74	static char *GetDefaultValue();
	75
[4642]	76	static Boolean CompareWithoutWhitespace();
	77
[4052]	78	typedef struct {
	79	Widget sendPopupW;
	80	Widget sendButtonW;
	81	Widget subjectTextW;
	82	Widget bodyTextW;
	83	char mtg[80];
	84	int replynum;
[4356]	85	} SendData, *SendDataPtr;
[4052]	86
[4356]	87	typedef struct trnrec {
	88	SendDataPtr data;
	89	struct trnrec *nextrec;
	90	} TransactionRec, *TransactionRecPtr;
	91
	92	static TransactionRecPtr listhead = 0;
	93
	94	/*
	95	** The structures TransactionRec and SendData are to keep track of the
	96	** contexts for multiple enter-transaction windows. listhead is the
	97	** first of a chain of TransactionRec's, one per window. This is
	98	** so we can search through the list when a keyhit comes in trying to
	99	** trigger a button, and figure out which button matches a particular
	100	** text widget.
	101	*/
	102
[3914]	103	void
	104	SubmitTransaction(myreplynum)
	105	int myreplynum;
	106	{
	107	Arg args[5];
	108	unsigned int n;
[4052]	109	char *subjectline;
[3914]	110	char buffer[80];
[3972]	111	char ptr1, ptr2;
[3914]	112	char *returndata;
[4052]	113	Widget localPaneW, box1W, box2W, buttonW;
[4356]	114	SendDataPtr data;
	115	TransactionRecPtr i;
[3914]	116
[4356]	117	if (listhead == 0) {
	118	listhead = (TransactionRecPtr) malloc (sizeof (TransactionRec));
	119	listhead->data = 0;
	120	listhead->nextrec = 0;
	121	}
	122
	123	for (i = listhead; i->data != 0 && i->nextrec != 0; i = i->nextrec)
	124	;
	125
	126	if (i->data != 0) {
	127	i->nextrec =
	128	(TransactionRecPtr) malloc (sizeof (TransactionRec));
	129	i = i->nextrec;
	130	i->data = 0;
	131	i->nextrec = 0;
	132	}
	133
	134	data = (SendDataPtr) malloc (sizeof (SendData));
	135
	136	i->data = data;
	137
[3914]	138	/*
[4052]	139	** Save current meeting name and reply number
[3914]	140	*/
[4052]	141	strcpy (data->mtg, CurrentMtg(0));
	142	data->replynum = myreplynum;
[3914]	143
	144	/*
	145	** Find and use the subject of the previous transaction if we are replying.
	146	*/
[4052]	147	if (myreplynum != 0) {
	148	sprintf (buffer, "(gti %d %s)\n", myreplynum, CurrentMtg(0));
[3914]	149	returndata = RunCommand (buffer, NULL, NULL, True);
	150
	151	if ((int) returndata <= 0) {
	152	return;
	153	}
[3972]	154
	155	/*
	156	** Find the third quote
	157	*/
	158	for (n = 0, ptr1 = returndata; n < 3; n++)
	159	while (*ptr1++ != '\"')
	160	;
	161	/*
	162	** Copy from just after the third quote to the next non-escaped quote
	163	*/
	164	ptr2 = buffer;
	165	while (*ptr1 != '\"') {
	166	if (*ptr1 == '\\')
	167	ptr1++;
	168	ptr2++ = ptr1++;
	169	}
	170	*ptr2 = '\0';
	171
[3914]	172	if (!strncmp (buffer, "Re: ", 4)) {
[4052]	173	subjectline = (char *) malloc (strlen(buffer) + 1);
[3914]	174	sprintf (subjectline, "%s", buffer);
	175	}
	176	else {
[4052]	177	subjectline = (char *) malloc (strlen(buffer) + 5);
[3914]	178	sprintf (subjectline, "Re: %s", buffer);
	179	}
	180	myfree(returndata);
	181	}
	182	else {
[4052]	183	subjectline = (char *) malloc (80);
[3914]	184	sprintf (subjectline, "");
	185	}
	186
	187	n = 0;
[3972]	188	XtSetArg(args[n], XtNwidth, 80 * char_width); n++;
[4052]	189	data->sendPopupW = XtCreatePopupShell(
[3914]	190	"enterpopup",
	191	topLevelShellWidgetClass,
	192	topW,
	193	args,
	194	n);
	195
	196	n = 0;
[3951]	197	localPaneW = XtCreateManagedWidget(
[3914]	198	"pane",
	199	panedWidgetClass,
[4052]	200	data->sendPopupW,
[3914]	201	args,
	202	n);
	203
[4052]	204	if (myreplynum == 0) {
[3914]	205	sprintf ( buffer,
	206	" (Entering new transaction in %s)",
[3942]	207	CurrentMtg(0));
[3914]	208	}
	209
	210	else {
	211	sprintf ( buffer,
	212	" (Replying to transaction %d in %s)",
[4052]	213	myreplynum, CurrentMtg(0));
[3914]	214	}
	215
	216	n = 0;
	217	XtSetArg(args[n], XtNstring, buffer); n++;
	218	XtSetArg(args[n], XtNeditType, XawtextRead); n++;
	219	(void) XtCreateManagedWidget(
	220	"desctext",
	221	asciiTextWidgetClass,
[3951]	222	localPaneW,
[3914]	223	args,
	224	n);
	225
	226	n = 0;
	227	XtSetArg(args[n], XtNborderWidth, 0); n++;
	228	box1W = XtCreateManagedWidget(
	229	"topbox",
	230	boxWidgetClass,
[3951]	231	localPaneW,
[3914]	232	args,
	233	n);
	234
	235	n = 0;
	236	(void) XtCreateManagedWidget(
	237	"label",
	238	labelWidgetClass,
	239	box1W,
	240	args,
	241	n);
	242
	243	n = 0;
	244	XtSetArg(args[n], XtNstring, subjectline); n++;
	245	XtSetArg(args[n], XtNborderWidth, 0); n++;
	246	XtSetArg(args[n], XtNeditType, XawtextEdit); n++;
[3972]	247	XtSetArg(args[n], XtNwidth, 60 * char_width); n++;
[4052]	248	data->subjectTextW = XtCreateManagedWidget(
[3914]	249	"subjecttext",
	250	asciiTextWidgetClass,
	251	box1W,
	252	args,
	253	n);
[4052]	254	myfree(subjectline);
[3914]	255
	256	n = 0;
	257	XtSetArg(args[n], XtNeditType, XawtextEdit); n++;
[3972]	258	XtSetArg(args[n], XtNwidth, 80 * char_width); n++;
[4052]	259	data->bodyTextW = XtCreateManagedWidget(
[3914]	260	"bodytext",
	261	asciiTextWidgetClass,
[3951]	262	localPaneW,
[3914]	263	args,
	264	n);
	265
	266	n = 0;
	267	XtSetArg(args[n], XtNborderWidth, 0); n++;
	268	box2W = XtCreateManagedWidget(
	269	"botbox",
	270	boxWidgetClass,
[3951]	271	localPaneW,
[3914]	272	args,
	273	n);
	274
	275	n = 0;
[4052]	276	data->sendButtonW = XtCreateManagedWidget(
[3914]	277	"send",
	278	commandWidgetClass,
	279	box2W,
	280	args,
	281	n);
	282
[4052]	283	XtAddCallback (data->sendButtonW, XtNcallback, SendCB, data);
	284
[3914]	285	n = 0;
[4052]	286	buttonW = XtCreateManagedWidget(
[3914]	287	"abort",
	288	commandWidgetClass,
	289	box2W,
	290	args,
	291	n);
[4052]	292	XtAddCallback (buttonW, XtNcallback, SendCB, data);
	293	XtPopup(data->sendPopupW, XtGrabNone);
[3914]	294	}
	295
	296	static void
	297	SendCB(w, client_data, call_data)
	298	Widget w;
	299	XtPointer client_data;
	300	XtPointer call_data;
	301	{
	302	Arg args[5];
	303	unsigned int n;
	304	char *tempstring;
[3942]	305	char command [LONGNAMELEN + 25];
[3914]	306	char filename[50];
	307	FILE *fp;
	308	char *returndata;
[4356]	309	SendDataPtr data = (SendDataPtr) client_data;
	310	TransactionRecPtr i, parent;
[3914]	311
[4052]	312	if (data->sendButtonW == w) {
[3914]	313	n = 0;
	314	XtSetArg(args[n], XtNstring, &tempstring); n++;
[4052]	315	XtGetValues (data->bodyTextW, args, n);
[3914]	316
	317	sprintf ( filename, "%s-%dr",
[4052]	318	filebase, data->replynum);
[3914]	319	if ((fp = fopen(filename, "w")) == (FILE *) NULL) {
	320	sprintf (command, "could not open file'%s'\n", filename);
	321	PutUpWarning("WARNING", command, False);
	322	}
	323	else {
	324	fprintf (fp, "%s\n", tempstring);
	325	fclose (fp);
	326	/*
	327	** Breakdown in the edsc protocol: We have to first send it the (at...)
	328	** to enter the transaction, then the newline-terminated subject line
	329	** on the next line. (No parens around subject line)
	330	*/
	331	sprintf(command, "(at %d %s %s)\n",
[4052]	332	data->replynum, filename, data->mtg);
[3914]	333	(void) RunCommand (command, NULL, NULL, False);
	334
	335	n = 0;
	336	XtSetArg(args[n], XtNstring, &tempstring); n++;
[4052]	337	XtGetValues (data->subjectTextW, args, n);
	338
[4397]	339	for (n = 0; tempstring[n]; n++)
	340	if (tempstring[n] == '\n')
	341	tempstring[n] = ' ';
	342
[3914]	343	sprintf(command, "%s\n",tempstring);
	344
	345	returndata = RunCommand (command, NULL, NULL, True);
[3997]	346	if ((int) returndata > 0)
	347	myfree(returndata);
[3914]	348	unlink (filename);
	349	}
	350	}
	351
[4052]	352	XtDestroyWidget(data->sendPopupW);
	353	myfree (data);
[3914]	354
[4356]	355	for (i = listhead, parent = 0; i; parent = i, i = i->nextrec) {
	356	if (data->subjectTextW == i->data->subjectTextW) {
	357	if (parent)
	358	parent->nextrec = i->nextrec;
	359	else
	360	listhead = i->nextrec;
	361	myfree (i->data);
	362	myfree (i);
	363	break;
	364	}
	365	}
	366
[4052]	367	GoToTransaction (TransactionNum(CURRENT), False);
[3914]	368
	369	XFlush(XtDisplay(topW));
	370	}
	371
	372	void
	373	WriteTransaction(current)
	374	int current;
	375	{
	376	Arg args[5];
	377	unsigned int n;
	378	char destfile[80];
[4356]	379	Widget button, writePaneW, writeBox1W;
[4383]	380	Position parentx, parenty;
	381	Dimension parentwidth, mywidth;
[3914]	382
	383	if (writePopupW)
	384	return;
	385
[4383]	386	n = 0;
	387	XtSetArg(args[n], XtNwidth, &parentwidth); n++;
	388	XtSetArg(args[n], XtNx, &parentx); n++;
	389	XtSetArg(args[n], XtNy, &parenty); n++;
	390	XtGetValues (topW, args, n);
	391
[3914]	392	sprintf ( destfile,
	393	"%s/xdsc/%s-%d", getenv("HOME"),
[3942]	394	CurrentMtg(1), current);
[3914]	395
[5061]	396	if (nocache)
	397	strcpy (sourcefile, GetTransactionFile(current));
	398	else
	399	sprintf ( sourcefile,
	400	"%s-%d", filebase, current);
[3914]	401
[4383]	402	mywidth = 80 * char_width;
	403
[3914]	404	n = 0;
[4383]	405	XtSetArg(args[n], XtNwidth, mywidth); n++;
	406	XtSetArg(args[n], XtNtransient, True); n++;
	407	XtSetArg(args[n], XtNtransientFor, topW); n++;
	408	XtSetArg(args[n], XtNx,
	409	parentx + ((parentwidth - mywidth) / 2)); n++;
	410	XtSetArg(args[n], XtNy, parenty + 100); n++;
[3914]	411	writePopupW = XtCreatePopupShell(
	412	"writepopup",
[4383]	413	transientShellWidgetClass,
[3914]	414	topW,
	415	args,
	416	n);
[4356]	417
	418	writePaneW = XtCreateManagedWidget(
	419	"pane",
	420	panedWidgetClass,
	421	writePopupW,
	422	NULL,
	423	0);
	424
[3914]	425	n = 0;
[4356]	426	(void) XtCreateManagedWidget(
	427	"label",
	428	labelWidgetClass,
	429	writePaneW,
[3914]	430	args,
	431	n);
	432
	433	n = 0;
[4356]	434	XtSetArg(args[n], XtNborderWidth, 0); n++;
	435	XtSetArg(args[n], XtNeditType, XawtextEdit); n++;
	436	XtSetArg(args[n], XtNwidth, 15 * char_width); n++;
	437	XtSetArg(args[n], XtNstring, destfile); n++;
	438
	439	writeTextW = XtCreateManagedWidget(
	440	"text",
	441	asciiTextWidgetClass,
	442	writePaneW,
	443	args,
	444	n);
	445
	446	n = 0;
	447	XtSetArg(args[n], XtNborderWidth, 0); n++;
	448	writeBox1W = XtCreateManagedWidget(
	449	"box1",
	450	boxWidgetClass,
	451	writePaneW,
	452	args,
	453	n);
	454
	455	n = 0;
	456	button = XtCreateManagedWidget(
[3914]	457	"write",
	458	commandWidgetClass,
[4356]	459	writeBox1W,
[3914]	460	args,
	461	n);
	462
[12263]	463	XtAddCallback (button, XtNcallback, WriteCB, (XtPointer) True);
[3914]	464
	465	n = 0;
[4356]	466	button = XtCreateManagedWidget(
[3914]	467	"abort",
	468	commandWidgetClass,
[4356]	469	writeBox1W,
[3914]	470	args,
	471	n);
	472
[12263]	473	XtAddCallback (button, XtNcallback, WriteCB, (XtPointer) False);
[3914]	474	XtPopup(writePopupW, XtGrabNone);
	475	}
	476
	477	static void
	478	WriteCB(w, client_data, call_data)
	479	Widget w;
	480	XtPointer client_data;
	481	XtPointer call_data;
	482	{
	483	char command[165];
	484	char tempptr1, destfile;
[4356]	485	Arg args[5];
	486	unsigned int n;
[3914]	487
[4356]	488	if (!writePopupW)
	489	return;
	490
[3914]	491	if ((Boolean) client_data) {
[4356]	492	n = 0;
	493	XtSetArg(args[n], XtNstring, &destfile); n++;
	494	XtGetValues (writeTextW, args, n);
	495
[3914]	496	/*
	497	** Make directory path. We ignore errors until we actually try to copy.
	498	*/
[3942]	499	tempptr1 = strchr(destfile + 1,'/');
[3914]	500
	501	while (tempptr1) {
	502	*tempptr1 = '\0';
[3942]	503	sprintf (command, "test -d %s", destfile);
	504	if (system (command) != 0) {
	505	sprintf (command, "mkdir %s", destfile);
	506	system (command);
	507	}
[3914]	508	*tempptr1 = '/';
	509	tempptr1 = strchr(tempptr1+1,'/');
	510	}
	511
	512	sprintf (command, "cp %s %s", sourcefile, destfile);
	513	if (system (command) != 0) {
	514	sprintf (command, "Cannot write to '%s'\n",destfile);
	515	PutUpWarning("WARNING", command, False);
	516	}
	517	}
	518
	519	XtDestroyWidget(writePopupW);
	520	writePopupW = 0;
	521	}
	522
	523	void
	524	AddMeeting()
	525	{
	526	Arg args[5];
	527	unsigned int n;
	528	char defaultvalue1, defaultvalue2;
[4383]	529	Position parentx, parenty;
	530	Dimension parentwidth, mywidth;
[3914]	531
	532	Widget addPaneW, addBox1W, addLabel1W;
	533	Widget addBox2W, addLabel2W, addBox3W, addButton1W;
	534	Widget addButton2W;
	535
	536	if (addPopupW)
	537	return;
	538
[3972]	539	n = 0;
[4383]	540	XtSetArg(args[n], XtNwidth, &parentwidth); n++;
	541	XtSetArg(args[n], XtNx, &parentx); n++;
	542	XtSetArg(args[n], XtNy, &parenty); n++;
	543	XtGetValues (topW, args, n);
	544
	545	mywidth = 80 * char_width;
	546
	547	n = 0;
	548	XtSetArg(args[n], XtNwidth, mywidth); n++;
	549	XtSetArg(args[n], XtNtransient, True); n++;
	550	XtSetArg(args[n], XtNtransientFor, topW); n++;
	551	XtSetArg(args[n], XtNx,
	552	parentx + ((parentwidth - mywidth) / 2)); n++;
	553	XtSetArg(args[n], XtNy, parenty + 100); n++;
	554
[3914]	555	addPopupW = XtCreatePopupShell(
	556	"addpopup",
[4383]	557	transientShellWidgetClass,
[3914]	558	topW,
[3972]	559	args,
	560	n);
[3914]	561
	562	addPaneW = XtCreateManagedWidget(
	563	"pane",
	564	panedWidgetClass,
	565	addPopupW,
	566	NULL,
	567	0);
	568
	569	n = 0;
	570	(void) XtCreateManagedWidget(
	571	"label",
	572	labelWidgetClass,
	573	addPaneW,
	574	args,
	575	n);
	576	n = 0;
	577	XtSetArg(args[n], XtNborderWidth, 0); n++;
	578	addBox1W = XtCreateManagedWidget(
	579	"box1",
	580	boxWidgetClass,
	581	addPaneW,
	582	args,
	583	n);
	584
	585	n = 0;
	586	addLabel1W = XtCreateManagedWidget(
	587	"label",
	588	labelWidgetClass,
	589	addBox1W,
	590	args,
	591	n);
	592
	593	n = 0;
	594	XtSetArg(args[n], XtNborderWidth, 0); n++;
	595	XtSetArg(args[n], XtNeditType, XawtextEdit); n++;
[3972]	596	XtSetArg(args[n], XtNwidth, 60 * char_width); n++;
[3914]	597	/*
	598	** Is there a default hostname we can use?
	599	*/
	600	if (defaultvalue1 = GetDefaultValue("Host:")) {
	601	XtSetArg(args[n], XtNstring, defaultvalue1); n++;
	602	}
	603
	604	addHostTextW = XtCreateManagedWidget(
	605	"hosttext",
	606	asciiTextWidgetClass,
	607	addBox1W,
	608	args,
	609	n);
	610
	611	if (defaultvalue1)
	612	myfree (defaultvalue1);
	613
	614	n = 0;
	615	XtSetArg(args[n], XtNborderWidth, 0); n++;
	616	addBox2W = XtCreateManagedWidget(
	617	"box2",
	618	boxWidgetClass,
	619	addPaneW,
	620	args,
	621	n);
	622
	623	n = 0;
	624	addLabel2W = XtCreateManagedWidget(
	625	"label",
	626	labelWidgetClass,
	627	addBox2W,
	628	args,
	629	n);
	630
	631	n = 0;
	632	XtSetArg(args[n], XtNborderWidth, 0); n++;
	633	XtSetArg(args[n], XtNeditType, XawtextEdit); n++;
[3972]	634	XtSetArg(args[n], XtNwidth, 60 * char_width); n++;
[3914]	635	/*
	636	** Is there a default pathname we can use?
	637	*/
	638	if (defaultvalue2 = GetDefaultValue("Pathname:")) {
	639	XtSetArg(args[n], XtNstring, defaultvalue2); n++;
	640	}
	641
	642	addPathTextW = XtCreateManagedWidget(
	643	"pathtext",
	644	asciiTextWidgetClass,
	645	addBox2W,
	646	args,
	647	n);
	648
	649	if (defaultvalue2)
	650	myfree (defaultvalue2);
	651
	652	n = 0;
	653	XtSetArg(args[n], XtNborderWidth, 0); n++;
	654	addBox3W = XtCreateManagedWidget(
	655	"box3",
	656	boxWidgetClass,
	657	addPaneW,
	658	args,
	659	n);
	660
	661	n = 0;
	662	addButton1W = XtCreateManagedWidget(
	663	"add",
	664	commandWidgetClass,
	665	addBox3W,
	666	args,
	667	n);
[12263]	668	XtAddCallback (addButton1W, XtNcallback, AddCB, (XtPointer) True);
[3914]	669
	670	n = 0;
	671	addButton2W = XtCreateManagedWidget(
	672	"abort",
	673	commandWidgetClass,
	674	addBox3W,
	675	args,
	676	n);
	677
[12263]	678	XtAddCallback (addButton2W, XtNcallback, AddCB, (XtPointer) False);
[3914]	679	XtPopup(addPopupW, XtGrabNone);
[4397]	680
[3914]	681	}
	682
	683	static void
	684	AddCB(w, client_data, call_data)
	685	Widget w;
	686	XtPointer client_data;
	687	XtPointer call_data;
	688	{
	689	char buffer[165];
	690	char tempstring1, tempstring2, *returndata;
	691	Arg args[5];
	692	unsigned int n;
	693
[4356]	694	if ((Boolean) client_data && addPopupW) {
[3914]	695	n = 0;
	696	XtSetArg(args[n], XtNstring, &tempstring1); n++;
	697	XtGetValues (addHostTextW, args, n);
	698
	699	n = 0;
	700	XtSetArg(args[n], XtNstring, &tempstring2); n++;
	701	XtGetValues (addPathTextW, args, n);
	702
	703	sprintf (buffer, "(am %s %s)\n", tempstring1, tempstring2);
	704	returndata = RunCommand (buffer, NULL, NULL, True);
	705
	706	if ( (int) returndata <= 0)
	707	return;
	708
[4642]	709	/* This forced an automatic update. Unfortunately, it erased any list
	710	of transaction headers.
	711
	712	TopSelect(NULL, 2, NULL);
	713	*/
[3914]	714	myfree (returndata);
	715	myfree (tempstring1);
	716	myfree (tempstring2);
	717	}
	718
[4356]	719	if (addPopupW) {
	720	XtDestroyWidget(addPopupW);
[4397]	721	XtSetKeyboardFocus(topW, topW);
[4356]	722	}
	723
[3914]	724	addPopupW = 0;
	725	}
	726
	727	void
	728	DeleteMeeting()
	729	{
	730	Arg args[5];
	731	unsigned int n;
	732
	733	Widget deletePaneW, deleteBox1W;
	734	Widget deleteBox2W, deleteButton1W, deleteButton2W;
	735	char *defaultvalue;
[4383]	736	Position parentx, parenty;
	737	Dimension parentwidth, mywidth;
[3914]	738
	739	if (deletePopupW)
	740	return;
	741
[3972]	742	n = 0;
[4383]	743	XtSetArg(args[n], XtNwidth, &parentwidth); n++;
	744	XtSetArg(args[n], XtNx, &parentx); n++;
	745	XtSetArg(args[n], XtNy, &parenty); n++;
	746	XtGetValues (topW, args, n);
	747
	748	mywidth = 80 * char_width;
	749
	750	n = 0;
	751	XtSetArg(args[n], XtNwidth, mywidth); n++;
	752	XtSetArg(args[n], XtNtransient, True); n++;
	753	XtSetArg(args[n], XtNtransientFor, topW); n++;
	754	XtSetArg(args[n], XtNx,
	755	parentx + ((parentwidth - mywidth) / 2)); n++;
	756	XtSetArg(args[n], XtNy, parenty + 100); n++;
	757
[3914]	758	deletePopupW = XtCreatePopupShell(
	759	"deletepopup",
[4383]	760	transientShellWidgetClass,
[3914]	761	topW,
[3972]	762	args,
	763	n);
[3914]	764
	765	deletePaneW = XtCreateManagedWidget(
	766	"pane",
	767	panedWidgetClass,
	768	deletePopupW,
	769	NULL,
	770	0);
	771
	772	n = 0;
	773	(void) XtCreateManagedWidget(
	774	"label",
	775	labelWidgetClass,
	776	deletePaneW,
	777	args,
	778	n);
	779
	780	n = 0;
	781	XtSetArg(args[n], XtNborderWidth, 0); n++;
	782	deleteBox1W = XtCreateManagedWidget(
	783	"box1",
	784	boxWidgetClass,
	785	deletePaneW,
	786	args,
	787	n);
	788
	789	n = 0;
	790	(void) XtCreateManagedWidget(
	791	"label",
	792	labelWidgetClass,
	793	deleteBox1W,
	794	args,
	795	n);
	796
	797	n = 0;
	798	XtSetArg(args[n], XtNborderWidth, 0); n++;
	799	XtSetArg(args[n], XtNeditType, XawtextEdit); n++;
[3972]	800	XtSetArg(args[n], XtNwidth, 60 * char_width); n++;
[3914]	801	if (defaultvalue = GetDefaultValue("Name:")) {
	802	XtSetArg(args[n], XtNstring, defaultvalue); n++;
	803	}
	804	deleteMtgTextW = XtCreateManagedWidget(
[4356]	805	"text",
[3914]	806	asciiTextWidgetClass,
	807	deleteBox1W,
	808	args,
	809	n);
	810
	811	if (defaultvalue)
	812	myfree (defaultvalue);
	813
	814	n = 0;
	815	XtSetArg(args[n], XtNborderWidth, 0); n++;
	816	deleteBox2W = XtCreateManagedWidget(
	817	"box2",
	818	boxWidgetClass,
	819	deletePaneW,
	820	args,
	821	n);
	822
	823	n = 0;
	824	deleteButton1W = XtCreateManagedWidget(
	825	"delete",
	826	commandWidgetClass,
	827	deleteBox2W,
	828	args,
	829	n);
[12263]	830	XtAddCallback (deleteButton1W, XtNcallback, DeleteCB,
	831	(XtPointer) True);
[3914]	832
	833	n = 0;
	834	deleteButton2W = XtCreateManagedWidget(
	835	"abort",
	836	commandWidgetClass,
	837	deleteBox2W,
	838	args,
	839	n);
[12263]	840	XtAddCallback (deleteButton2W, XtNcallback, DeleteCB,
	841	(XtPointer) False);
[4397]	842
[3914]	843	XtPopup(deletePopupW, XtGrabNone);
[4397]	844
[3914]	845	}
	846
	847	static void
	848	DeleteCB(w, client_data, call_data)
	849	Widget w;
	850	XtPointer client_data;
	851	XtPointer call_data;
	852	{
	853	char buffer[165];
	854	char tempstring1, returndata;
	855	Arg args[5];
	856	unsigned int n;
	857
[4356]	858	if (!deletePopupW)
	859	return;
	860
[3914]	861	if ((Boolean) client_data) {
	862	n = 0;
	863	XtSetArg(args[n], XtNstring, &tempstring1); n++;
	864	XtGetValues (deleteMtgTextW, args, n);
	865	/*
[4642]	866	** Protect us when we remove the current meeting. Watch out for leading
	867	** and trailing spaces in the text widget's value.
[3914]	868	*/
[4642]	869	if ( CompareWithoutWhitespace(tempstring1, CurrentMtg(0)) \|\|
	870	CompareWithoutWhitespace(tempstring1, CurrentMtg(1)))
[4383]	871	SaveMeetingNames("", "");
[3914]	872
	873	sprintf (buffer, "(dm %s)\n", tempstring1);
	874	returndata = RunCommand (buffer, NULL, NULL, True);
	875
	876	if ( (int) returndata <= 0)
	877	return;
	878
[4642]	879	/*
	880	TopSelect(NULL, 2, NULL);
	881	*/
[3914]	882	myfree (returndata);
	883	myfree (tempstring1);
	884	}
	885
	886	XtDestroyWidget(deletePopupW);
	887	deletePopupW = 0;
	888	}
	889
[4642]	890	static Boolean
	891	CompareWithoutWhitespace(s, t)
	892	char s, t;
	893	{
	894	while (isspace(*s))
	895	*s++;
	896
	897	while (isspace(*t))
	898	*t++;
	899
	900	while (s && t && (s++ == t++))
	901	;
	902
	903	if (!t && !s)
	904	return (True);
	905
	906	if (!*t) {
	907	while (isspace(*s))
	908	s++;
	909	if (!*s)
	910	return (True);
	911	else
	912	return (False);
	913	}
	914
	915	if (!*s) {
	916	while (isspace(*t))
	917	t++;
	918	if (!*t)
	919	return (True);
	920	else
	921	return (False);
	922	}
	923
	924	return (False);
	925	}
	926
[3914]	927	PutUpWarning(prefix, message, deathoption)
	928	char *prefix;
	929	char *message;
	930	Boolean deathoption;
	931	{
	932	Arg args[5];
	933	unsigned int n;
	934	Widget warningPaneW, warningButtonW, warningBoxW, deathButtonW;
[4356]	935	Position parentx, parenty;
	936	Dimension parentwidth, mywidth;
	937	int flag = 0;
[3914]	938
	939	if (warningPopupW)
	940	return;
	941
	942	n = 0;
[4356]	943	XtSetArg(args[n], XtNwidth, &parentwidth); n++;
	944	XtSetArg(args[n], XtNx, &parentx); n++;
	945	XtSetArg(args[n], XtNy, &parenty); n++;
	946	XtGetValues (topW, args, n);
	947
	948	mywidth = (strlen(message)+2) * char_width;
	949
	950	n = 0;
	951	XtSetArg(args[n], XtNwidth, mywidth); n++;
	952	XtSetArg(args[n], XtNtransient, True); n++;
	953	XtSetArg(args[n], XtNtransientFor, topW); n++;
	954	XtSetArg(args[n], XtNx,
	955	parentx + ((parentwidth - mywidth) / 2)); n++;
	956	XtSetArg(args[n], XtNy, parenty + 100); n++;
[3914]	957	warningPopupW = XtCreatePopupShell(
	958	"warningpopup",
[4356]	959	transientShellWidgetClass,
[3914]	960	topW,
	961	args,
	962	n);
	963
	964	warningPaneW = XtCreateManagedWidget(
	965	"pane",
	966	panedWidgetClass,
	967	warningPopupW,
	968	NULL,
	969	0);
[3951]	970	XtInstallAccelerators(warningPaneW, paneW);
[3914]	971
[4383]	972	if (*prefix) {
	973	n = 0;
	974	XtSetArg(args[n], XtNlabel, prefix); n++;
	975	XtSetArg(args[n], XtNwidth, 300); n++;
	976	(void) XtCreateManagedWidget(
	977	"label1",
	978	labelWidgetClass,
	979	warningPaneW,
	980	args,
	981	n);
	982	}
[3914]	983
	984	n = 0;
	985	XtSetArg(args[n], XtNlabel, message); n++;
	986	(void) XtCreateManagedWidget(
	987	"label2",
	988	labelWidgetClass,
	989	warningPaneW,
	990	args,
	991	n);
	992	n = 0;
	993	warningBoxW = XtCreateManagedWidget(
	994	"box",
	995	boxWidgetClass,
	996	warningPaneW,
	997	args,
	998	n);
	999
	1000	n = 0;
	1001	warningButtonW = XtCreateManagedWidget(
	1002	"acknowledge",
	1003	commandWidgetClass,
	1004	warningBoxW,
	1005	args,
	1006	n);
	1007
[12263]	1008	XtAddCallback (warningButtonW, XtNcallback, PopdownCB,
	1009	(XtPointer) False);
[3914]	1010
	1011	if (deathoption) {
	1012	deathButtonW = XtCreateManagedWidget(
	1013	"quit immediately",
	1014	commandWidgetClass,
	1015	warningBoxW,
	1016	NULL, 0);
	1017
[12263]	1018	XtAddCallback (deathButtonW, XtNcallback, DieCB,
	1019	(XtPointer) False);
[3914]	1020	}
	1021
[3951]	1022	XtInstallAllAccelerators(warningPopupW, paneW);
[4397]	1023	XtSetKeyboardFocus(paneW, warningButtonW);
[3951]	1024
[3914]	1025	XtPopup(warningPopupW, XtGrabNone);
	1026	}
	1027
	1028	void
	1029	DieCB(w, client_data, call_data)
	1030	Widget w;
	1031	XtPointer client_data;
	1032	XtPointer call_data;
	1033	{
	1034	exit (-1);
	1035	}
	1036
[4356]	1037	PopdownCB(w, client_data, call_data)
[3914]	1038	Widget w;
	1039	XtPointer client_data;
	1040	XtPointer call_data;
	1041	{
[4890]	1042	int didsomething = 0;
	1043
[3914]	1044	if (warningPopupW) {
	1045	XtDestroyWidget(warningPopupW);
	1046	warningPopupW = 0;
[4890]	1047	didsomething = 1;
[3914]	1048	}
	1049
	1050	if (helpPopupW) {
	1051	XtDestroyWidget(helpPopupW);
	1052	helpPopupW = 0;
[4890]	1053	didsomething = 1;
[3914]	1054	}
[4397]	1055	XtSetKeyboardFocus(topW, topW);
[4890]	1056	return (didsomething);
[3914]	1057	}
	1058
	1059
	1060	void
	1061	PutUpHelp()
	1062	{
	1063	Arg args[5];
	1064	unsigned int n;
[3951]	1065	Widget localPaneW, textW, boxW, buttonW;
[3914]	1066
	1067	if (helpPopupW)
	1068	return;
	1069
	1070	n = 0;
	1071	helpPopupW = XtCreatePopupShell(
	1072	"helppopup",
	1073	topLevelShellWidgetClass,
	1074	topW,
	1075	args,
	1076	n);
	1077
[3951]	1078	XtInstallAccelerators(helpPopupW, paneW);
[3914]	1079	n = 0;
[3951]	1080	localPaneW = XtCreateManagedWidget(
[3914]	1081	"pane",
	1082	panedWidgetClass,
	1083	helpPopupW,
	1084	args,
	1085	n);
	1086
	1087	n = 0;
[3951]	1088	XtSetArg(args[n], XtNeditType, XawtextEdit); n++;
[3972]	1089	XtSetArg(args[n], XtNwidth, 80 * char_width); n++;
[3914]	1090
	1091	textW = XtCreateManagedWidget(
	1092	"helptext",
	1093	asciiTextWidgetClass,
[3951]	1094	localPaneW,
[3914]	1095	args,
	1096	n);
[3951]	1097	XtInstallAccelerators(textW, paneW);
[3914]	1098
	1099	n = 0;
	1100	XtSetArg(args[n], XtNborderWidth, 0); n++;
	1101	boxW = XtCreateManagedWidget(
	1102	"box",
	1103	boxWidgetClass,
[3951]	1104	localPaneW,
[3914]	1105	args,
	1106	n);
	1107
	1108	n = 0;
	1109	buttonW = XtCreateManagedWidget(
	1110	"okay",
	1111	commandWidgetClass,
	1112	boxW,
	1113	args,
	1114	n);
	1115
[3951]	1116	XtInstallAllAccelerators(helpPopupW, paneW);
[12263]	1117	XtAddCallback (buttonW, XtNcallback, PopdownCB, (XtPointer) True);
[3914]	1118	XtPopup(helpPopupW, XtGrabNone);
	1119	}
	1120
	1121
	1122	/*
	1123	** Okay, here's some really crude stuff. We assume the text in bottextW
	1124	** contains lines like " Host: YABBA.DABBA.DOO" where "Host:" is
	1125	** the sort of thing that we call a "prompt." We find the line, if any,
	1126	** including the string pointed to by prompt, and return a pointer to
	1127	** the string from whitespace to \n following the prompt.
	1128	*/
	1129
	1130	static char *
	1131	GetDefaultValue(prompt)
	1132	char *prompt;
	1133	{
	1134	Arg args[5];
	1135	unsigned int n;
	1136	char prompt1, string, string1, string2;
	1137	char *retval;
	1138
	1139	n = 0;
	1140	XtSetArg(args[n], XtNstring, &string); n++;
	1141	XtGetValues (bottextW, args, n);
	1142
	1143	/*
	1144	** Now we look for the prompt.
	1145	*/
	1146
	1147	for (string1 = string; *string1; string1++) {
	1148	for ( prompt1 = prompt, string2 = string1;
	1149	prompt1 == string2;
	1150	prompt1++, string2++)
	1151	;
	1152
	1153	if (!*prompt1) break;
	1154	}
	1155
	1156	if (!*string1) {
	1157	return (NULL);
	1158	}
	1159
	1160	for (string2 = string1; *string2 != ' '; string2++);
	1161
	1162	for ( ; *string2 == ' '; string2++);
	1163
	1164	*strchr (string2, '\n') = '\0';
	1165
	1166	retval = (char *) malloc (strlen(string2) + 1);
	1167	strcpy (retval, string2);
	1168	*(strchr(string2, '\0')) = '\n';
	1169	return (retval);
	1170	}
[4356]	1171
	1172	void
	1173	GetTransactionNum()
	1174	{
	1175	Arg args[5];
	1176	unsigned int n;
	1177	Widget button, numPaneW, numBox1W;
[4383]	1178	Position parentx, parenty;
	1179	Dimension parentwidth, mywidth;
[4356]	1180
	1181	if (numPopupW)
	1182	return;
	1183
[4383]	1184	n = 0;
	1185	XtSetArg(args[n], XtNwidth, &parentwidth); n++;
	1186	XtSetArg(args[n], XtNx, &parentx); n++;
	1187	XtSetArg(args[n], XtNy, &parenty); n++;
	1188	XtGetValues (topW, args, n);
[4356]	1189
[4383]	1190	mywidth = 35 * char_width;
	1191
[4356]	1192	n = 0;
[4383]	1193	XtSetArg(args[n], XtNwidth, mywidth); n++;
	1194	XtSetArg(args[n], XtNtransient, True); n++;
	1195	XtSetArg(args[n], XtNtransientFor, topW); n++;
	1196	XtSetArg(args[n], XtNx,
	1197	parentx + ((parentwidth - mywidth) / 2)); n++;
	1198	XtSetArg(args[n], XtNy, parenty + 100); n++;
	1199
[4356]	1200	numPopupW = XtCreatePopupShell(
	1201	"numpopup",
[4383]	1202	transientShellWidgetClass,
[4356]	1203	topW,
	1204	args,
	1205	n);
	1206
	1207	numPaneW = XtCreateManagedWidget(
	1208	"pane",
	1209	panedWidgetClass,
	1210	numPopupW,
	1211	NULL,
	1212	0);
	1213
	1214	n = 0;
	1215
	1216	(void) XtCreateManagedWidget(
	1217	"label",
	1218	labelWidgetClass,
	1219	numPaneW,
	1220	args,
	1221	n);
	1222
	1223	n = 0;
	1224	XtSetArg(args[n], XtNborderWidth, 0); n++;
	1225	XtSetArg(args[n], XtNeditType, XawtextEdit); n++;
	1226	XtSetArg(args[n], XtNwidth, 15 * char_width); n++;
	1227
	1228	numTextW = XtCreateManagedWidget(
	1229	"text",
	1230	asciiTextWidgetClass,
	1231	numPaneW,
	1232	args,
	1233	n);
	1234
	1235	n = 0;
	1236	XtSetArg(args[n], XtNborderWidth, 0); n++;
	1237	numBox1W = XtCreateManagedWidget(
	1238	"box1",
	1239	boxWidgetClass,
	1240	numPaneW,
	1241	args,
	1242	n);
	1243
	1244	n = 0;
	1245	button = XtCreateManagedWidget(
	1246	"goto",
	1247	commandWidgetClass,
	1248	numBox1W,
	1249	args,
	1250	n);
	1251
[12263]	1252	XtAddCallback (button, XtNcallback, NumCB, (XtPointer) True);
[4356]	1253
	1254	n = 0;
	1255	button = XtCreateManagedWidget(
	1256	"abort",
	1257	commandWidgetClass,
	1258	numBox1W,
	1259	args,
	1260	n);
	1261
[12263]	1262	XtAddCallback (button, XtNcallback, NumCB, (XtPointer) False);
[4356]	1263	XtPopup(numPopupW, XtGrabNone);
	1264	}
	1265
	1266	static void
	1267	NumCB(w, client_data, call_data)
	1268	Widget w;
	1269	XtPointer client_data;
	1270	XtPointer call_data;
	1271	{
	1272	char *tempstring;
	1273	Arg args[5];
	1274	unsigned int n;
	1275
	1276	if (!numPopupW)
	1277	return;
	1278
	1279	if ((Boolean) client_data) {
	1280	n = 0;
	1281	XtSetArg(args[n], XtNstring, &tempstring); n++;
	1282	XtGetValues (numTextW, args, n);
	1283	GoToTransaction(atoi(tempstring), True);
	1284	myfree (tempstring);
	1285	}
	1286
	1287	XtDestroyWidget(numPopupW);
[4397]	1288	XtSetKeyboardFocus(topW, topW);
[4356]	1289	numPopupW = 0;
	1290	}
	1291
	1292	void
	1293	TriggerAdd(w, event, params, num_params)
	1294	Widget w;
	1295	XEvent *event;
	1296	String *params;
	1297	int *num_params;
	1298	{
	1299	if (*num_params < 1)
	1300	return;
	1301
[4383]	1302	AddCB(w, (XtPointer) !strcmp(params[0], "Go"), NULL);
[4356]	1303	}
	1304
	1305	void
	1306	TriggerNum(w, event, params, num_params)
	1307	Widget w;
	1308	XEvent *event;
	1309	String *params;
	1310	int *num_params;
	1311	{
	1312	if (*num_params < 1)
	1313	return;
	1314
[4383]	1315	NumCB(w, (XtPointer) !strcmp(params[0], "Go"), NULL);
[4356]	1316	}
	1317
	1318	void
	1319	TriggerWrite(w, event, params, num_params)
	1320	Widget w;
	1321	XEvent *event;
	1322	String *params;
	1323	int *num_params;
	1324	{
	1325	if (*num_params < 1)
	1326	return;
	1327
[4383]	1328	WriteCB(w, (XtPointer) !strcmp(params[0], "Go"), NULL);
[4356]	1329	}
	1330
	1331	void
	1332	TriggerDelete(w, event, params, num_params)
	1333	Widget w;
	1334	XEvent *event;
	1335	String *params;
	1336	int *num_params;
	1337	{
	1338	if (*num_params < 1)
	1339	return;
	1340
[4383]	1341	DeleteCB(w, (XtPointer) !strcmp(params[0], "Go"), NULL);
[4356]	1342	}
	1343
	1344	void
	1345	TriggerPopdown(w, event, params, num_params)
	1346	Widget w;
	1347	XEvent *event;
	1348	String *params;
	1349	int *num_params;
	1350	{
	1351	if (*num_params < 1)
	1352	return;
	1353
[4383]	1354	PopdownCB(w, (XtPointer) !strcmp(params[0], "Go"), NULL);
[4356]	1355	}
	1356
	1357	void
	1358	TriggerSend(w, event, params, num_params)
	1359	Widget w;
	1360	XEvent *event;
	1361	String *params;
	1362	int *num_params;
	1363	{
	1364	TransactionRecPtr i;
	1365
	1366	if (*num_params < 1)
	1367	return;
	1368
	1369	if (listhead == 0) {
	1370	return;
	1371	}
	1372
	1373	for (i = listhead; i; i = i->nextrec) {
	1374	if (w == i->data->subjectTextW)
	1375	break;
	1376	if (w == i->data->bodyTextW)
	1377	break;
	1378	if (w == i->data->sendButtonW)
	1379	break;
	1380	if (w == i->data->sendPopupW)
	1381	break;
	1382	}
	1383
	1384	if (i == 0)
	1385	return;
	1386
	1387	/*
	1388	** Okay, here's a kludge. SendCB() checks the incoming widget ID,
	1389	** and if it's equal to the sendButtonW stored in the data structure,
	1390	** it actually does the send. So we fool it here.
	1391	*/
[4383]	1392	if (strcmp(params[0], "Go") == 0)
[4356]	1393	SendCB(i->data->sendButtonW, i->data, NULL);
	1394	else
	1395	SendCB(NULL, i->data, NULL);
	1396	}
	1397
	1398	/*
[4383]	1399	** Pass TriggerFocusMove "Prev" to move focus up, "Next" to move it down.
[4356]	1400	** It figures out which widget got the event and moves focus to
	1401	** the appropriate neighbor.
	1402	*/
	1403
	1404	void
	1405	TriggerFocusMove(w, event, params, num_params)
	1406	Widget w;
	1407	XEvent *event;
	1408	String *params;
	1409	int *num_params;
	1410	{
	1411	TransactionRecPtr i;
[4383]	1412	int direction = -1;
[4356]	1413	Widget targetW = 0;
[4397]	1414	Widget shellparent;
[4356]	1415
	1416	if (*num_params < 1)
	1417	return;
	1418
[4397]	1419	for ( shellparent = XtParent(w);
	1420	shellparent && !XtIsShell(shellparent);
	1421	shellparent = XtParent(shellparent))
	1422	;
	1423
[4383]	1424	if (!strcmp (params[0], "Next"))
	1425	direction = 2;
	1426	if (!strcmp (params[0], "Prev"))
	1427	direction = 1;
	1428	if (!strcmp (params[0], "Toggle"))
	1429	direction = 0;
[4356]	1430
[4397]	1431	if (!strcmp (params[0], "Here")) {
	1432	XtSetKeyboardFocus(topW, shellparent);
	1433	XtSetKeyboardFocus(shellparent, w);
	1434	return;
	1435	}
	1436
[4356]	1437	/*
[4383]	1438	** Was the hit widget in the add-mtg popup? All keys become toggle.
[4356]	1439	*/
	1440	if (addPopupW) {
[4383]	1441	if (w == addHostTextW)
[4356]	1442	targetW = addPathTextW;
[4383]	1443	if (w == addPathTextW)
[4356]	1444	targetW = addHostTextW;
	1445	}
	1446
	1447	/*
	1448	** Check the subject and body widgets in the list of entryrecs.
	1449	*/
	1450	if (listhead != 0) {
	1451	for (i = listhead; i; i = i->nextrec) {
	1452	if (w == i->data->subjectTextW &&
	1453	(direction == 2 \|\| direction == 0))
	1454	targetW = i->data->bodyTextW;
	1455	if (w == i->data->bodyTextW &&
	1456	(direction == 1 \|\| direction == 0))
	1457	targetW = i->data->subjectTextW;
	1458	}
	1459	}
	1460
[4397]	1461	if (targetW) {
	1462	XtSetKeyboardFocus(topW, shellparent);
	1463	XtSetKeyboardFocus(shellparent, targetW);
	1464	}
[4356]	1465	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: