![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pick.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xmh|
Return to pick.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xmh |
1.1 root 1: #ifndef lint
2: static char rcs_id[] = "$Header: pick.c,v 1.11 87/09/11 08:18:17 toddb Exp $";
3: #endif lint
4: /*
5: * COPYRIGHT 1987
6: * DIGITAL EQUIPMENT CORPORATION
7: * MAYNARD, MASSACHUSETTS
8: * ALL RIGHTS RESERVED.
9: *
10: * THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE AND
11: * SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT CORPORATION.
12: * DIGITAL MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR
13: * ANY PURPOSE. IT IS SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
14: *
15: * IF THE SOFTWARE IS MODIFIED IN A MANNER CREATING DERIVATIVE COPYRIGHT RIGHTS,
16: * APPROPRIATE LEGENDS MAY BE PLACED ON THE DERIVATIVE WORK IN ADDITION TO THAT
17: * SET FORTH ABOVE.
18: *
19: *
20: * Permission to use, copy, modify, and distribute this software and its
21: * documentation for any purpose and without fee is hereby granted, provided
22: * that the above copyright notice appear in all copies and that both that
23: * copyright notice and this permission notice appear in supporting documentation,
24: * and that the name of Digital Equipment Corporation not be used in advertising
25: * or publicity pertaining to distribution of the software without specific,
26: * written prior permission.
27: */
28:
29: /* pick.c -- handle a pick subwindow. */
30:
31: #include "xmh.h"
32: #include "Form.h"
33:
34: #define WTlabel 0
35: #define WTbutton 1
36: #define WTtextentry 2
37:
38: #define RTfrom 0
39: #define RTto 1
40: #define RTcc 2
41: #define RTdate 3
42: #define RTsubject 4
43: #define RTsearch 5
44: #define RTother 6
45: #define RTignore 7
46:
47: #define FIRSTROWTYPE RTfrom
48: #define LASTUSEFULROWTYPE RTother
49: #define NUMROWTYPE (RTignore+1)
50:
51: static int stdwidth = -1; /* Width to make text fields, and other
52: things that want to be the same width as
53: text fields. */
54:
55: static char *TypeName[NUMROWTYPE];
56:
57: typedef struct {
58: short type; /* Encode what type of window this is. */
59: Window window; /* The window id itself. */
60: struct _RowListRec *row; /* Which row this window is in. */
61: short hilite; /* Whether to hilight (if button subwindow) */
62: char *ptr; /* Data (if text subwindow) */
63: } FormEntryRec, *FormEntryPtr;
64:
65: typedef struct _RowListRec {
66: short type; /* Encode what type of list this is. */
67: Window window; /* Window containing this row */
68: short numwindows; /* How many windows in this list. */
69: FormEntryPtr *wlist; /* List of windows. */
70: struct _GroupRec *group; /* Which group this is in. */
71: } RowListRec, *RowListPtr;
72:
73: typedef struct _GroupRec {
74: short numrows; /* How many rows of window. */
75: Window window; /* Window containing this group */
76: RowListPtr *rlist; /* List of window rows. */
77: struct _FormBoxRec *form; /* Which form this is in. */
78: } GroupRec, *GroupPtr;
79:
80: typedef struct _FormBoxRec {
81: Window outer; /* Outer window (contains scrollbars if any) */
82: Window inner; /* Inner window (contains master form) */
83: short numgroups; /* How many groups of form entries we have. */
84: GroupPtr *glist; /* List of form groups. */
85: struct _PickRec *pick; /* Which pick this is in. */
86: } FormBoxRec, *FormBoxPtr;
87:
88: typedef struct _PickRec {
89: Scrn scrn; /* Scrn containing this pick. */
90: Window label; /* Window with label for this pick. */
91: Toc toc; /* Toc for folder being scanned. */
92: FormBoxPtr general; /* Form for general info about this pick. */
93: FormBoxPtr details; /* Form for details about this pick. */
94: Window errorwindow; /* Pop-up error window. */
95: } PickRec;
96:
97:
98: InitPick()
99: {
100: TypeName[RTfrom] = "From:";
101: TypeName[RTto] = "To:";
102: TypeName[RTcc] = "Cc:";
103: TypeName[RTdate] = "Date:";
104: TypeName[RTsubject] = "Subject:";
105: TypeName[RTsearch] = "Search:";
106: TypeName[RTother] = NULL;
107: }
108:
109: static PickFlipColors(window)
110: Window window;
111: {
112: static Arg arglist[] = {
113: {XtNforeground, NULL},
114: {XtNbackground, NULL},
115: };
116: XtArgVal temp;
117: XtCommandGetValues(DISPLAY window, arglist, XtNumber(arglist));
118: temp = arglist[0].value;
119: arglist[0].value = arglist[1].value;
120: arglist[1].value = temp;
121: XtCommandSetValues(DISPLAY window, arglist, XtNumber(arglist));
122: }
123:
124:
125: static PrepareToUpdate(form)
126: FormBoxPtr form;
127: {
128: XtFormDoLayout(DISPLAY form->inner, FALSE);
129: }
130:
131: static ExecuteUpdate(form)
132: FormBoxPtr form;
133: {
134: XtFormDoLayout(DISPLAY form->inner, TRUE);
135: }
136:
137: static FormEntryPtr CreateEntry(window, type)
138: Window window;
139: int type;
140: {
141: FormEntryPtr entry;
142: entry = (FormEntryPtr) XtMalloc(sizeof(FormEntryRec));
143: entry->row = NULL;
144: entry->window = window;
145: entry->type = type;
146: return entry;
147: }
148:
149:
150: static void AddLabel(row, text, usestd)
151: RowListPtr row;
152: char *text;
153: int usestd;
154: {
155: Window window;
156: static Arg arglist[] = {
157: {XtNlabel, NULL},
158: {XtNborderWidth, (XtArgVal) 0},
159: {XtNjustify, (XtArgVal) XtjustifyRight},
160: {XtNwidth, (XtArgVal) NULL}
161: };
162: arglist[0].value = (XtArgVal) text;
163: arglist[XtNumber(arglist) - 1].value = (XtArgVal) stdwidth;
164: window = XtLabelCreate(DISPLAY row->window, arglist,
165: usestd ? XtNumber(arglist) : XtNumber(arglist) - 1);
166: AddWindow(row, CreateEntry(window, WTlabel));
167: }
168:
169:
170: static void AddButton(row, text, func, hilite)
171: RowListPtr row;
172: char *text;
173: int (*func)();
174: int hilite;
175: {
176: FormEntryPtr entry;
177: static Arg arglist[] = {
178: {XtNlabel, NULL},
179: {XtNfunction, NULL},
180: {XtNparameter, NULL}
181: };
182: entry = CreateEntry((Window) 0, WTbutton);
183: arglist[0].value = (XtArgVal)text;
184: arglist[1].value = (XtArgVal)func;
185: arglist[2].value = (XtArgVal)entry;
186: entry->window = XtCommandCreate(DISPLAY row->window,
187: arglist, XtNumber(arglist));
188: entry->hilite = hilite;
189: if (hilite) PickFlipColors(entry->window);
190: AddWindow(row, entry);
191: }
192:
193:
194: static void AddTextEntry(row, str)
195: RowListPtr row;
196: char *str;
197: {
198: static Arg arglist[] = {
199: {XtNstring, (XtArgVal) NULL},
200: {XtNwidth, (XtArgVal) NULL},
201: {XtNlength, (XtArgVal) 300},
202: {XtNtextOptions, (XtArgVal)(resizeWidth | resizeHeight)},
203: {XtNeditType, (XtArgVal)XttextEdit},
204: };
205: char *ptr;
206: FormEntryPtr entry;
207: ptr = XtMalloc(310);
208: arglist[0].value = (XtArgVal) ptr;
209: arglist[1].value = (XtArgVal) stdwidth;
210: (void) strcpy(ptr, str);
211: entry = CreateEntry(XtTextStringCreate(DISPLAY row->window, arglist,
212: XtNumber(arglist)),
213: WTtextentry);
214: entry->ptr = ptr;
215: AddWindow(row, entry);
216: }
217:
218:
219: static void ChangeTextEntry(entry, str)
220: FormEntryPtr entry;
221: char *str;
222: {
223: static Arg arglist[] = {
224: {XtNtextSource, (XtArgVal) NULL}
225: };
226: XtTextSource *source;
227: if (strcmp(str, entry->ptr) == 0) return;
228: XtTextGetValues(DISPLAY entry->window, arglist, XtNumber(arglist));
229: source = (XtTextSource *) arglist[0].value;
230: XtStringSourceDestroy(source);
231: (void) strcpy(entry->ptr, str);
232: source = (XtTextSource *)
233: XtStringSourceCreate(entry->ptr, 300, XttextEdit);
234: XtTextNewSource(DISPLAY entry->window, source, (XtTextPosition) 0);
235: }
236:
237:
238: static ExecYesNo(entry)
239: FormEntryPtr entry;
240: {
241: RowListPtr row = entry->row;
242: int i;
243: if (!entry->hilite) {
244: entry->hilite = TRUE;
245: PickFlipColors(entry->window);
246: for (i = 0; i < row->numwindows; i++)
247: if (entry == row->wlist[i])
248: break;
249: if (i > 0 && row->wlist[i-1]->type == WTbutton)
250: i--;
251: else
252: i++;
253: entry = row->wlist[i];
254: entry->hilite = FALSE;
255: PickFlipColors(entry->window);
256: }
257: }
258:
259:
260:
261:
262: static ExecRowOr(entry)
263: FormEntryPtr entry;
264: {
265: RowListPtr row = entry->row;
266: FormBoxPtr form = row->group->form;
267: PrepareToUpdate(form);
268: DeleteWindow(entry);
269: AddLabel(row, "or", FALSE);
270: AddTextEntry(row, "");
271: AddButton(row, "Or", ExecRowOr, FALSE);
272: ExecuteUpdate(form);
273: }
274:
275:
276: static ExecGroupOr(entry)
277: FormEntryPtr entry;
278: {
279: FormBoxPtr form = entry->row->group->form;
280: QXUnmapWindow(theDisplay, form->inner);
281: PrepareToUpdate(form);
282: AddDetailGroup(form);
283: ExecuteUpdate(form);
284: QXMapWindow(theDisplay, form->inner);
285: }
286:
287: static char **argv;
288: static int argvsize;
289:
290:
291: static AppendArgv(ptr)
292: char *ptr;
293: {
294: argvsize++;
295: argv = ResizeArgv(argv, argvsize);
296: argv[argvsize - 1] = MallocACopy(ptr);
297: }
298:
299: static EraseLast()
300: {
301: argvsize--;
302: XtFree((char *) argv[argvsize]);
303: argv[argvsize] = 0;
304: }
305:
306:
307:
308: static ParseRow(row)
309: RowListPtr row;
310: {
311: int result = FALSE;
312: int i;
313: FormEntryPtr entry;
314: char str[1000];
315: if (row->type > LASTUSEFULROWTYPE)
316: return FALSE;
317: for (i = 3; i < row->numwindows; i += 2) {
318: entry = row->wlist[i];
319: if (*(entry->ptr)) {
320: if (!result) {
321: result = TRUE;
322: if (row->wlist[1]->hilite)
323: AppendArgv("-not");
324: AppendArgv("-lbrace");
325: }
326: switch (row->type) {
327: case RTfrom:
328: AppendArgv("-from");
329: break;
330: case RTto:
331: AppendArgv("-to");
332: break;
333: case RTcc:
334: AppendArgv("-cc");
335: break;
336: case RTdate:
337: AppendArgv("-date");
338: break;
339: case RTsubject:
340: AppendArgv("-subject");
341: break;
342: case RTsearch:
343: AppendArgv("-search");
344: break;
345: case RTother:
346: AppendArgv(sprintf(str, "--%s", row->wlist[2]->ptr));
347: break;
348: }
349: AppendArgv(entry->ptr);
350: AppendArgv("-or");
351: }
352: }
353: if (result) {
354: EraseLast();
355: AppendArgv("-rbrace");
356: AppendArgv("-and");
357: }
358: return result;
359: }
360:
361:
362: static ParseGroup(group)
363: GroupPtr group;
364: {
365: int found = FALSE;
366: int i;
367: for (i=0 ; i<group->numrows ; i++)
368: found |= ParseRow(group->rlist[i]);
369: if (found) {
370: EraseLast();
371: AppendArgv("-rbrace");
372: AppendArgv("-or");
373: AppendArgv("-lbrace");
374: }
375: return found;
376: }
377:
378:
379:
380: static void DestroyErrorWindow(pick)
381: Pick pick;
382: {
383: if (pick->errorwindow) {
384: (void) XtSendDestroyNotify(DISPLAY pick->errorwindow);
385: QXDestroyWindow(theDisplay, pick->errorwindow);
386: pick->errorwindow = NULL;
387: }
388: }
389:
390: static void MakeErrorWindow(pick, str)
391: Pick pick;
392: char *str;
393: {
394: DestroyErrorWindow(pick);
395: pick->errorwindow = XtDialogCreate(DISPLAY pick->scrn->window, str,
396: (char *)NULL, (ArgList)NULL, 0);
397: XtDialogAddButton(DISPLAY pick->errorwindow, "OK", DestroyErrorWindow,
398: (caddr_t)pick);
399: CenterWindow(pick->scrn->window, pick->errorwindow);
400: QXMapWindow(theDisplay, pick->errorwindow);
401: }
402:
403:
404:
405: static ExecOK(entry)
406: FormEntryPtr entry;
407: {
408: Pick pick = entry->row->group->form->pick;
409: Toc toc = pick->toc;
410: FormBoxPtr details = pick->details;
411: FormBoxPtr general = pick->general;
412: GroupPtr group = general->glist[0];
413: RowListPtr row0 = group->rlist[0];
414: RowListPtr row1 = group->rlist[1];
415: RowListPtr row2 = group->rlist[2];
416: char *fromseq = row0->wlist[3]->ptr;
417: char *toseq = row0->wlist[1]->ptr;
418: char *fromdate = row1->wlist[1]->ptr;
419: char *todate = row1->wlist[3]->ptr;
420: char *datefield = row1->wlist[5]->ptr;
421: short removeoldmsgs = row2->wlist[1]->hilite;
422: char str[1000];
423: int i, found;
424:
425: DestroyErrorWindow(pick);
426: if (strcmp(toseq, "all") == 0) {
427: MakeErrorWindow(pick, "Can't create a sequence called \"all\".");
428: return;
429: }
430: if (TocGetSeqNamed(toc, fromseq) == NULL) {
431: (void) sprintf(str, "Sequence \"%s\" doesn't exist!", fromseq);
432: MakeErrorWindow(pick, str);
433: return;
434: }
435: argv = MakeArgv(1);
436: argvsize = 0;
437: AppendArgv("pick");
438: AppendArgv(sprintf(str, "+%s", TocGetFolderName(toc)));
439: AppendArgv(fromseq);
440: AppendArgv("-sequence");
441: AppendArgv(toseq);
442: if (removeoldmsgs)
443: AppendArgv("-zero");
444: else
445: AppendArgv("-nozero");
446: if (*datefield) {
447: AppendArgv("-datefield");
448: AppendArgv(datefield);
449: }
450: if (*fromdate) {
451: AppendArgv("-after");
452: AppendArgv(fromdate);
453: AppendArgv("-and");
454: }
455: if (*todate) {
456: AppendArgv("-before");
457: AppendArgv(todate);
458: AppendArgv("-and");
459: }
460: found = FALSE;
461: AppendArgv("-lbrace");
462: AppendArgv("-lbrace");
463: for (i=0 ; i<details->numgroups ; i++)
464: found |= ParseGroup(details->glist[i]);
465: EraseLast();
466: EraseLast();
467: if (found) AppendArgv("-rbrace");
468: else if (*fromdate || *todate) EraseLast();
469: if (debug) {
470: for (i=0 ; i<argvsize ; i++)
471: (void) fprintf(stderr, "%s ", argv[i]);
472: (void) fprintf(stderr, "\n");
473: }
474: (void) DoCommand(argv, (char *) NULL, "/dev/null");
475: TocReloadSeqLists(toc);
476: TocChangeViewedSeq(toc, TocGetSeqNamed(toc, toseq));
477: DestroyScrn(pick->scrn);
478: for (i=0 ; i<argvsize ; i++) XtFree((char *) argv[i]);
479: XtFree((char *) argv);
480: }
481:
482:
483:
484: static ExecCancel(entry)
485: FormEntryPtr entry;
486: {
487: Pick pick = entry->row->group->form->pick;
488: Scrn scrn = pick->scrn;
489: (void) DestroyScrn(scrn);
490: #ifdef X10
491: {
492: XEvent event;
493: event.type = LeaveWindow;
494: event.window = entry->window;
495: XtDispatchEvent(DISPLAY &event);
496: }
497: #endif
498: }
499:
500:
501:
502: static AddWindow(row, entry)
503: RowListPtr row;
504: FormEntryPtr entry;
505: {
506: static Arg arglist[] = {
507: {XtNfromHoriz, (XtArgVal)NULL},
508: {XtNresizable, (XtArgVal)TRUE},
509: {XtNtop, (XtArgVal) XtChainTop},
510: {XtNleft, (XtArgVal) XtChainLeft},
511: {XtNbottom, (XtArgVal) XtChainTop},
512: {XtNright, (XtArgVal) XtChainLeft},
513: };
514:
515: row->numwindows++;
516: row->wlist = (FormEntryPtr *)
517: XtRealloc((char *) row->wlist,
518: (unsigned) row->numwindows * sizeof(FormEntryPtr));
519: row->wlist[row->numwindows - 1] = entry;
520: entry->row = row;
521: if (row->numwindows > 1)
522: arglist[0].value = (XtArgVal) row->wlist[row->numwindows - 2]->window;
523: else
524: arglist[0].value = (XtArgVal) NULL;
525: XtFormAddWidget(DISPLAY row->window,
526: entry->window, arglist, XtNumber(arglist));
527: }
528:
529:
530: static DeleteWindow(entry)
531: FormEntryPtr entry;
532: {
533: RowListPtr row = entry->row;
534: int i;
535: QXDestroyWindow(theDisplay, entry->window);
536: (void) XtSendDestroyNotify(DISPLAY entry->window);
537: if (entry->type == WTtextentry)
538: XtFree((char *) entry->ptr);
539: for (i = 0; i < row->numwindows; i++)
540: if (row->wlist[i] == entry)
541: break;
542: row->numwindows--;
543: for (; i < row->numwindows; i++)
544: row->wlist[i] = row->wlist[i + 1];
545: }
546:
547:
548: /* Figure out how wide text fields and labels should be so that they'll all
549: line up correctly, and be big enough to hold everything, but not too big. */
550:
551: static void FindStdWidth()
552: {
553: stdwidth = 100; /* %%% HACK! */
554: }
555:
556:
557: static RowListPtr AddRow(group, type)
558: GroupPtr group;
559: int type;
560: {
561: static Arg arglist1[] = {
562: {XtNborderWidth, (XtArgVal) 0},
563: };
564: static Arg arglist2[] = {
565: {XtNfromVert, (XtArgVal) NULL},
566: {XtNresizable, (XtArgVal) TRUE},
567: {XtNtop, (XtArgVal) XtChainTop},
568: {XtNleft, (XtArgVal) XtChainLeft},
569: {XtNbottom, (XtArgVal) XtChainTop},
570: {XtNright, (XtArgVal) XtChainLeft}
571: };
572: RowListPtr row;
573: group->numrows++;
574: group->rlist = (RowListPtr *)
575: XtRealloc((char *) group->rlist,
576: (unsigned) group->numrows * sizeof(RowListPtr));
577: group->rlist[group->numrows - 1] = row =
578: (RowListPtr) XtMalloc(sizeof(RowListRec));
579: row->type = type;
580: row->numwindows = 0;
581: row->wlist = (FormEntryPtr *) XtMalloc(1);
582: row->group = group;
583: row->window = XtFormCreate(DISPLAY group->window,
584: arglist1, XtNumber(arglist1));
585: if (group->numrows > 1)
586: arglist2[0].value = (XtArgVal)group->rlist[group->numrows - 2]->window;
587: else
588: arglist2[0].value = (XtArgVal) NULL;
589: XtFormAddWidget(DISPLAY group->window,
590: row->window, arglist2, XtNumber(arglist2));
591: if (type == RTignore) return row;
592: AddButton(row, "Pick", ExecYesNo, TRUE);
593: AddButton(row, "Skip", ExecYesNo, FALSE);
594: if (TypeName[type])
595: AddLabel(row, TypeName[type], TRUE);
596: else
597: AddTextEntry(row, "");
598: AddTextEntry(row, "");
599: AddButton(row, "Or", ExecRowOr, FALSE);
600: return row;
601: }
602:
603:
604: static GroupPtr AddGroup(form)
605: FormBoxPtr form;
606: {
607: static Arg arglist1[] = {
608: {XtNborderWidth, (XtArgVal) 0},
609: };
610: static Arg arglist2[] = {
611: {XtNfromVert, (XtArgVal) NULL},
612: {XtNresizable, (XtArgVal) TRUE},
613: {XtNtop, (XtArgVal) XtChainTop},
614: {XtNleft, (XtArgVal) XtChainLeft},
615: {XtNbottom, (XtArgVal) XtChainTop},
616: {XtNright, (XtArgVal) XtChainLeft}
617: };
618: GroupPtr group;
619: form->numgroups++;
620: form->glist = (GroupPtr *)
621: XtRealloc((char *) form->glist,
622: (unsigned) form->numgroups * sizeof(GroupPtr));
623: form->glist[form->numgroups - 1] = group =
624: (GroupPtr) XtMalloc(sizeof(GroupRec));
625: group->numrows = 0;
626: group->form = form;
627: group->rlist = (RowListPtr *) XtMalloc(1);
628: group->window = XtFormCreate(DISPLAY form->inner,
629: arglist1, XtNumber(arglist1));
630: if (form->numgroups > 1)
631: arglist2[0].value = (XtArgVal)form->glist[form->numgroups - 2]->window;
632: else
633: arglist2[0].value = (XtArgVal)NULL;
634: XtFormAddWidget(DISPLAY form->inner,
635: group->window, arglist2, XtNumber(arglist2));
636: return group;
637: }
638:
639:
640:
641: static AddDetailGroup(form)
642: FormBoxPtr form;
643: {
644: GroupPtr group;
645: RowListPtr row;
646: int type;
647: if (form->numgroups > 0) {
648: group = form->glist[form->numgroups - 1];
649: row = group->rlist[group->numrows - 1];
650: DeleteWindow(row->wlist[0]);
651: AddLabel(row, "- or -", FALSE);
652: }
653: group = AddGroup(form);
654: for (type = FIRSTROWTYPE; type <= LASTUSEFULROWTYPE; type++)
655: (void) AddRow(group, type);
656: row = AddRow(group, RTignore);
657: AddButton(row, "- Or -", ExecGroupOr, FALSE);
658: }
659:
660:
661: static AddGeneralGroup(form)
662: FormBoxPtr form;
663: {
664: GroupPtr group;
665: RowListPtr row;
666: group = AddGroup(form);
667: row = AddRow(group, RTignore);
668: AddLabel(row, "Creating sequence:", FALSE);
669: AddTextEntry(row, "");
670: AddLabel(row, "with msgs from sequence:", FALSE);
671: AddTextEntry(row, "");
672: row = AddRow(group, RTignore);
673: AddLabel(row, "Date range:", FALSE);
674: AddTextEntry(row, "");
675: AddLabel(row, " - ", FALSE);
676: AddTextEntry(row, "");
677: AddLabel(row, "Date field:", FALSE);
678: AddTextEntry(row, "");
679: row = AddRow(group, RTignore);
680: AddLabel(row, "Clear old entries from sequence?", FALSE);
681: AddButton(row, "Yes", ExecYesNo, TRUE);
682: AddButton(row, "No", ExecYesNo, FALSE);
683: row = AddRow(group, RTignore);
684: AddButton(row, "OK", ExecOK, FALSE);
685: AddButton(row, "Cancel", ExecCancel, FALSE);
686: }
687:
688:
689: static void InitGeneral(pick, fromseq, toseq)
690: Pick pick;
691: char *fromseq, *toseq;
692: {
693: RowListPtr row;
694: row = pick->general->glist[0]->rlist[0];
695: ChangeTextEntry(row->wlist[1], toseq);
696: ChangeTextEntry(row->wlist[3], fromseq);
697: }
698:
699:
700: static void CleanForm(form)
701: FormBoxPtr form;
702: {
703: int i, j, k;
704: GroupPtr group;
705: RowListPtr row;
706: FormEntryPtr entry;
707: for (i=0 ; i<form->numgroups ; i++) {
708: group = form->glist[i];
709: for (j=0 ; j<group->numrows ; j++) {
710: row = group->rlist[j];
711: for (k=0 ; k<row->numwindows ; k++) {
712: entry = row->wlist[k];
713: if (entry->type == WTtextentry)
714: ChangeTextEntry(entry, "");
715: }
716: }
717: }
718: }
719:
720:
721: static FormBoxPtr MakeAForm(pick, position)
722: Pick pick;
723: int position;
724: {
725: static Arg arglist1[] = {
726: {XtNname, (XtArgVal) "pick"},
727: {XtNallowHoriz, (XtArgVal)TRUE},
728: {XtNallowVert, (XtArgVal)TRUE},
729: };
730: static Arg arglist2[] = {
731: {XtNborderWidth, (XtArgVal) 0}
732: };
733: FormBoxPtr result;
734: result = (FormBoxPtr) XtMalloc(sizeof(FormBoxRec));
735: result->outer = XtScrolledWindowCreate(DISPLAY pick->scrn->window,
736: arglist1, XtNumber(arglist1));
737: result->inner = XtFormCreate(DISPLAY
738: XtScrolledWindowGetFrame(DISPLAY
739: result->outer),
740: arglist2, XtNumber(arglist2));
741: XtScrolledWindowSetChild(DISPLAY result->outer, result->inner);
742: XtVPanedWindowAddPane(DISPLAY pick->scrn->window, result->outer, position,
743: 50, 1500, TRUE);
744: result->pick = pick;
745: result->numgroups = 0;
746: result->glist = (GroupPtr *) XtMalloc(1);
747: return result;
748: }
749:
750:
751:
752: AddPick(scrn, toc, fromseq, toseq)
753: Scrn scrn;
754: Toc toc;
755: char *fromseq, *toseq;
756: {
757: Pick pick;
758: FormBoxPtr general, details;
759: char str[100];
760: int width, height, scrnwidth, scrnheight;
761:
762: if (scrn->pick) {
763: pick = scrn->pick;
764: CleanForm(pick->details);
765: CleanForm(pick->general);
766: } else {
767: pick = scrn->pick = (Pick) XtMalloc(sizeof(PickRec));
768: pick->scrn = scrn;
769: pick->errorwindow = NULL;
770:
771: pick->label = CreateTitleBar(scrn, 0);
772:
773: pick->details = details = MakeAForm(pick, 1);
774: pick->general = general = MakeAForm(pick, 2);
775: FindStdWidth();
776:
777: PrepareToUpdate(details);
778: AddDetailGroup(details);
779: ExecuteUpdate(details);
780: PrepareToUpdate(general);
781: AddGeneralGroup(general);
782: ExecuteUpdate(general);
783: GetWindowSize(general->inner, &width, &height);
784: GetWindowSize(scrn->window, &scrnwidth, &scrnheight);
785: if (width > scrnwidth)
786: height += XtScrollMgrGetThickness(DISPLAY general->outer);
787: XtVPanedSetMinMax(DISPLAY scrn->window,
788: general->outer, height, height);
789: XtVPanedSetMinMax(DISPLAY scrn->window,
790: general->outer, 10, 10000);
791: }
792: pick->toc = toc;
793: InitGeneral(pick, fromseq, toseq);
794: (void) sprintf(str, "Pick: %s", TocGetFolderName(toc));
795: ChangeLabel(pick->label, str);
796: QXStoreName(theDisplay, scrn->window, str);
797: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.