![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to TextActs.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 / lib / oldXtk|
Return to TextActs.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / oldXtk |
1.1 root 1: /* $Header: TextActs.c,v 1.1 87/09/11 07:59:49 toddb Exp $ */
2: #ifndef lint
3: static char *sccsid = "@(#)TextActions.c 1.17 2/25/87";
4: #endif lint
5:
6: /*
7: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
8: *
9: * All Rights Reserved
10: *
11: * Permission to use, copy, modify, and distribute this software and its
12: * documentation for any purpose and without fee is hereby granted,
13: * provided that the above copyright notice appear in all copies and that
14: * both that copyright notice and this permission notice appear in
15: * supporting documentation, and that the name of Digital Equipment
16: * Corporation not be used in advertising or publicity pertaining to
17: * distribution of the software without specific, written prior permission.
18: *
19: *
20: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
21: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
22: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
23: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
24: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
25: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
26: * SOFTWARE.
27: */
28:
29:
30: #include "Xlib.h"
31: #include "Intrinsic.h"
32: #include "Text.h"
33: #include "TextDisp.h"
34: #include "Dialog.h"
35:
36: #define min(x,y) ((x) < (y) ? (x) : (y))
37: #define max(x,y) ((x) > (y) ? (x) : (y))
38:
39: /* ||| Kludge, declar in .h file somewhere */
40:
41: extern char *_XtTextGetText(); /* ctx, left, right */
42: /* TextContext *ctx; */
43: /* XtTextPosition left, right; */
44:
45: extern caddr_t XtSetActionBindings();/* eventTable, actionTable, defaultValue */
46: /* XtEventsPtr eventTable; */
47: /* XtActionsPtr actionTable; */
48: /* caddr_t defaultValue; */
49:
50: extern void AlterSelection(); /* ctx, mode, action */
51: /* TextContext *ctx; */
52: /* SelectionMode mode; /* {XtsmTextSelect, XtsmTextExtend} */
53: /* SelectionAction action; /* {XtactionStart, XtactionAdjust, XtactionEnd} */
54:
55: extern void ForceBuildLineTable(); /* ctx */
56: /* TextContext *ctx; */
57:
58: /* Misc. routines */
59:
60: /*ARGSUSED*/
61: static DoFeep(ctx)
62: TextContext *ctx;
63: {
64: XBell(ctx->dpy, 50);
65: }
66:
67: static DeleteOrKill(ctx, from, to, kill)
68: TextContext *ctx;
69: XtTextPosition from, to;
70: Boolean kill;
71: {
72: XtTextBlock text;
73: char *ptr;
74:
75: if (kill && from < to) {
76: ptr = _XtTextGetText(ctx, from, to);
77: XStoreBuffer(ctx->dpy, ptr, strlen(ptr), 1);
78: XtFree(ptr);
79: }
80: text.length = 0;
81: if (ReplaceText(ctx, from, to, &text)) {
82: XBell(ctx->dpy, 50);
83: return;
84: }
85: _XtTextSetNewSelection(ctx, from, from);
86: ctx->insertPos = from;
87: ctx->showposition = TRUE;
88: }
89:
90:
91: StuffFromBuffer(ctx, buffer)
92: TextContext *ctx;
93: int buffer;
94: {
95: extern char *XFetchBuffer();
96: XtTextBlock text;
97: text.ptr = XFetchBuffer(ctx->dpy, &(text.length), buffer);
98: if (ReplaceText(ctx, ctx->insertPos, ctx->insertPos, &text)) {
99: XBell(ctx->dpy, 50);
100: return;
101: }
102: ctx->insertPos = ctx->source->scan(ctx->source, ctx->insertPos,
103: XtstPositions, XtsdRight, text.length, TRUE);
104: _XtTextSetNewSelection(ctx, ctx->insertPos, ctx->insertPos);
105: XtFree(text.ptr);
106: }
107:
108:
109: static UnKill(ctx)
110: TextContext *ctx;
111: {
112: StuffFromBuffer(ctx, 1);
113: }
114:
115: static Stuff(ctx)
116: TextContext *ctx;
117: {
118: StuffFromBuffer(ctx, 0);
119: }
120:
121:
122: static XtTextPosition NextPosition(ctx, position, kind, direction)
123: TextContext *ctx;
124: XtTextPosition position;
125: ScanType kind;
126: ScanDirection direction;
127: {
128: XtTextPosition pos;
129:
130: pos = ctx->source->scan(
131: ctx->source, position, kind, direction, 1, FALSE);
132: if (pos == ctx->insertPos)
133: pos = ctx->source->scan(
134: ctx->source, position, kind, direction, 2, FALSE);
135: return pos;
136: }
137:
138: /* routines for moving around */
139:
140: static MoveForwardChar(ctx)
141: TextContext *ctx;
142: {
143: ctx->insertPos = ctx->source->scan(
144: ctx->source, ctx->insertPos, XtstPositions, XtsdRight, 1, TRUE);
145: }
146:
147: static MoveBackwardChar(ctx)
148: TextContext *ctx;
149: {
150: ctx->insertPos = ctx->source->scan(
151: ctx->source, ctx->insertPos, XtstPositions, XtsdLeft, 1, TRUE);
152: }
153:
154: static MoveForwardWord(ctx)
155: TextContext *ctx;
156: {
157: ctx->insertPos = NextPosition(ctx, ctx->insertPos, XtstWhiteSpace, XtsdRight);
158: }
159:
160: static MoveBackwardWord(ctx)
161: TextContext *ctx;
162: {
163: ctx->insertPos = NextPosition(ctx, ctx->insertPos, XtstWhiteSpace, XtsdLeft);
164: }
165:
166: static MoveBackwardParagraph(ctx)
167: TextContext *ctx;
168: {
169: ctx->insertPos = NextPosition(ctx, ctx->insertPos, XtstEOL, XtsdLeft);
170: }
171:
172: static MoveForwardParagraph(ctx)
173: TextContext *ctx;
174: {
175: ctx->insertPos = NextPosition(ctx, ctx->insertPos, XtstEOL, XtsdRight);
176: }
177:
178:
179: static MoveToLineStart(ctx)
180: TextContext *ctx;
181: {
182: int line;
183: _XtTextShowPosition(ctx);
184: line = LineForPosition(ctx, ctx->insertPos);
185: ctx->insertPos = ctx->lt.info[line].position;
186: }
187:
188: static MoveToLineEnd(ctx)
189: TextContext *ctx;
190: {
191: int line;
192: XtTextPosition next;
193: _XtTextShowPosition(ctx);
194: line = LineForPosition(ctx, ctx->insertPos);
195: next = ctx->lt.info[line+1].position;
196: if (next > ctx->lastPos)
197: next = ctx->lastPos;
198: else
199: next = ctx->source->scan(ctx->source, next, XtstPositions, XtsdLeft, 1, TRUE);
200: ctx->insertPos = next;
201: }
202:
203:
204: static int LineLastWidth = 0;
205: static XtTextPosition LineLastPosition = 0;
206:
207: static MoveNextLine(ctx)
208: TextContext *ctx;
209: {
210: int width, width2, height, line;
211: XtTextPosition position, maxp;
212: _XtTextShowPosition(ctx);
213: line = LineForPosition(ctx, ctx->insertPos);
214: if (line == ctx->lt.lines - 1) {
215: _XtTextScroll(ctx, 1);
216: line = LineForPosition(ctx, ctx->insertPos);
217: }
218: if (LineLastPosition == ctx->insertPos)
219: width = LineLastWidth;
220: else
221: ctx->sink->findDistance(ctx->sink, ctx->source,
222: ctx->lt.info[line].position, ctx->lt.info[line].x,
223: ctx->insertPos, &width, &position, &height);
224: line++;
225: if (ctx->lt.info[line].position > ctx->lastPos) {
226: ctx->insertPos = ctx->lastPos;
227: return;
228: }
229: ctx->sink->findPosition(ctx->sink, ctx->source,
230: ctx->lt.info[line].position, ctx->lt.info[line].x,
231: width, FALSE, &position, &width2, &height);
232: maxp = ctx->source->scan(ctx->source, ctx->lt.info[line+1].position,
233: XtstPositions, XtsdLeft, 1, TRUE);
234: if (position > maxp)
235: position = maxp;
236: ctx->insertPos = position;
237: LineLastWidth = width;
238: LineLastPosition = position;
239: }
240:
241: static MovePreviousLine(ctx)
242: TextContext *ctx;
243: {
244: int width, width2, height, line;
245: XtTextPosition position, maxp;
246: _XtTextShowPosition(ctx);
247: line = LineForPosition(ctx, ctx->insertPos);
248: if (line == 0) {
249: _XtTextScroll(ctx, -1);
250: line = LineForPosition(ctx, ctx->insertPos);
251: }
252: if (line > 0) {
253: if (LineLastPosition == ctx->insertPos)
254: width = LineLastWidth;
255: else
256: ctx->sink->findDistance(ctx->sink, ctx->source,
257: ctx->lt.info[line].position, ctx->lt.info[line].x,
258: ctx->insertPos, &width, &position, &height);
259: line--;
260: ctx->sink->findPosition(ctx->sink, ctx->source,
261: ctx->lt.info[line].position, ctx->lt.info[line].x,
262: width, FALSE, &position, &width2, &height);
263: maxp = ctx->source->scan(ctx->source, ctx->lt.info[line+1].position,
264: XtstPositions, XtsdLeft, 1, TRUE);
265: if (position > maxp)
266: position = maxp;
267: ctx->insertPos = position;
268: LineLastWidth = width;
269: LineLastPosition = position;
270: }
271: }
272:
273:
274:
275: static MoveBeginningOfFile(ctx)
276: TextContext *ctx;
277: {
278: ctx->insertPos = ctx->source->scan(ctx->source, ctx->insertPos, XtstFile,
279: XtsdLeft, 1, TRUE);
280: }
281:
282:
283: static MoveEndOfFile(ctx)
284: TextContext *ctx;
285: {
286: ctx->insertPos = ctx->source->scan(ctx->source, ctx->insertPos, XtstFile,
287: XtsdRight, 1, TRUE);
288: }
289:
290: static ScrollOneLineUp(ctx)
291: TextContext *ctx;
292: {
293: _XtTextScroll(ctx, 1);
294: }
295:
296: static ScrollOneLineDown(ctx)
297: TextContext *ctx;
298: {
299: _XtTextScroll(ctx, -1);
300: }
301:
302: static MoveNextPage(ctx)
303: TextContext *ctx;
304: {
305: _XtTextScroll(ctx, max(1, ctx->lt.lines - 2));
306: ctx->insertPos = ctx->lt.top;
307: }
308:
309: static MovePreviousPage(ctx)
310: TextContext *ctx;
311: {
312: _XtTextScroll(ctx, -max(1, ctx->lt.lines - 2));
313: ctx->insertPos = ctx->lt.top;
314: }
315:
316:
317:
318:
319: /* delete routines */
320:
321: static DeleteForwardChar(ctx)
322: TextContext *ctx;
323: {
324: XtTextPosition next;
325:
326: next = ctx->source->scan(
327: ctx->source, ctx->insertPos, XtstPositions, XtsdRight, 1, TRUE);
328: DeleteOrKill(ctx, ctx->insertPos, next, FALSE);
329: }
330:
331: static DeleteBackwardChar(ctx)
332: TextContext *ctx;
333: {
334: XtTextPosition next;
335:
336: next = ctx->source->scan(
337: ctx->source, ctx->insertPos, XtstPositions, XtsdLeft, 1, TRUE);
338: DeleteOrKill(ctx, next, ctx->insertPos, FALSE);
339: }
340:
341: static DeleteForwardWord(ctx)
342: TextContext *ctx;
343: {
344: XtTextPosition next;
345:
346: next = NextPosition(ctx, ctx->insertPos, XtstWhiteSpace, XtsdRight);
347: DeleteOrKill(ctx, ctx->insertPos, next, FALSE);
348: }
349:
350: static DeleteBackwardWord(ctx)
351: TextContext *ctx;
352: {
353: XtTextPosition next;
354:
355: next = NextPosition(ctx, ctx->insertPos, XtstWhiteSpace, XtsdLeft);
356: DeleteOrKill(ctx, next, ctx->insertPos, FALSE);
357: }
358:
359: static KillForwardWord(ctx)
360: TextContext *ctx;
361: {
362: XtTextPosition next;
363:
364: next = NextPosition(ctx, ctx->insertPos, XtstWhiteSpace, XtsdRight);
365: DeleteOrKill(ctx, ctx->insertPos, next, TRUE);
366: }
367:
368: static KillBackwardWord(ctx)
369: TextContext *ctx;
370: {
371: XtTextPosition next;
372:
373: next = NextPosition(ctx, ctx->insertPos, XtstWhiteSpace, XtsdLeft);
374: DeleteOrKill(ctx, next, ctx->insertPos, TRUE);
375: }
376:
377: static KillCurrentSelection(ctx)
378: TextContext *ctx;
379: {
380: DeleteOrKill(ctx, ctx->s.left, ctx->s.right, TRUE);
381: }
382:
383: static DeleteCurrentSelection(ctx)
384: TextContext *ctx;
385: {
386: DeleteOrKill(ctx, ctx->s.left, ctx->s.right, FALSE);
387: }
388:
389: static KillToEndOfLine(ctx)
390: TextContext *ctx;
391: {
392: int line;
393: XtTextPosition last, next;
394: _XtTextShowPosition(ctx);
395: line = LineForPosition(ctx, ctx->insertPos);
396: last = ctx->lt.info[line + 1].position;
397: next = ctx->source->scan(ctx->source, ctx->insertPos, XtstEOL, XtsdRight,
398: 1, FALSE);
399: if (last > ctx->lastPos)
400: last = ctx->lastPos;
401: if (last > next && ctx->insertPos < next)
402: last = next;
403: DeleteOrKill(ctx, ctx->insertPos, last, TRUE);
404: }
405:
406: static KillToEndOfParagraph(ctx)
407: TextContext *ctx;
408: {
409: XtTextPosition next;
410:
411: next = ctx->source->scan(ctx->source, ctx->insertPos, XtstEOL, XtsdRight,
412: 1, FALSE);
413: if (next == ctx->insertPos)
414: next = ctx->source->scan(ctx->source, next, XtstEOL, XtsdRight, 1, TRUE);
415: DeleteOrKill(ctx, ctx->insertPos, next, TRUE);
416: }
417:
418: static int InsertNewLineAndBackup(ctx)
419: TextContext *ctx;
420: {
421: XtTextBlock text;
422: text.length = 1;
423: text.ptr = "\n";
424: text.firstPos = 0;
425: if (ReplaceText(ctx, ctx->insertPos, ctx->insertPos, &text)) {
426: XBell(ctx->dpy, 50);
427: return(EDITERROR);
428: }
429: _XtTextSetNewSelection(ctx, (XtTextPosition) 0, (XtTextPosition) 0);
430: ctx->showposition = TRUE;
431: return(EDITDONE);
432: }
433:
434:
435:
436: static int InsertNewLine(ctx)
437: TextContext *ctx;
438: {
439: XtTextPosition next;
440:
441: if (InsertNewLineAndBackup(ctx))
442: return(EDITERROR);
443: next = ctx->source->scan(ctx->source, ctx->insertPos,
444: XtstPositions, XtsdRight, 1, TRUE);
445: ctx->insertPos = next;
446: return(EDITDONE);
447: }
448:
449:
450: static InsertNewLineAndIndent(ctx)
451: TextContext *ctx;
452: {
453: XtTextBlock text;
454: XtTextPosition pos1, pos2;
455:
456: pos1 = ctx->source->scan(ctx->source, ctx->insertPos, XtstEOL, XtsdLeft,
457: 1, FALSE);
458: pos2 = ctx->source->scan(ctx->source, pos1, XtstEOL, XtsdLeft, 1, TRUE);
459: pos2 = ctx->source->scan(ctx->source, pos2, XtstWhiteSpace, XtsdRight, 1, TRUE);
460: text.ptr = _XtTextGetText(ctx, pos1, pos2);
461: text.length = strlen(text.ptr);
462: if (InsertNewLine(ctx)) return;
463: if (ReplaceText(ctx, ctx->insertPos, ctx->insertPos, &text)) {
464: XBell(ctx->dpy, 50);
465: return;
466: }
467: ctx->insertPos = ctx->source->scan(ctx->source, ctx->insertPos,
468: XtstPositions, XtsdRight, text.length, TRUE);
469: XtFree(text.ptr);
470: }
471:
472: static NewSelection(ctx, l, r)
473: TextContext *ctx;
474: XtTextPosition l, r;
475: {
476: char *ptr;
477: _XtTextSetNewSelection(ctx, l, r);
478: if (l < r) {
479: ptr = _XtTextGetText(ctx, l, r);
480: XStoreBuffer(ctx->dpy, ptr, min(strlen(ptr), MAXCUT), 0);
481: XtFree(ptr);
482: }
483: }
484:
485: static SelectWord(ctx)
486: TextContext *ctx;
487: {
488: XtTextPosition l, r;
489: l = ctx->source->scan(ctx->source, ctx->insertPos, XtstWhiteSpace, XtsdLeft,
490: 1, FALSE);
491: r = ctx->source->scan(ctx->source, l, XtstWhiteSpace, XtsdRight, 1, FALSE);
492: NewSelection(ctx, l, r);
493: }
494:
495:
496: static SelectAll(ctx)
497: TextContext *ctx;
498: {
499: NewSelection(ctx, (XtTextPosition) 0, ctx->lastPos);
500: }
501:
502: static SelectStart(ctx)
503: TextContext *ctx;
504: {
505: AlterSelection(ctx, XtsmTextSelect, XtactionStart);
506: }
507:
508: static SelectAdjust(ctx)
509: TextContext *ctx;
510: {
511: AlterSelection(ctx, XtsmTextSelect, XtactionAdjust);
512: }
513:
514: static SelectEnd(ctx)
515: TextContext *ctx;
516: {
517: AlterSelection(ctx, XtsmTextSelect, XtactionEnd);
518: }
519:
520: static ExtendStart(ctx)
521: TextContext *ctx;
522: {
523: AlterSelection(ctx, XtsmTextExtend, XtactionStart);
524: }
525:
526: static ExtendAdjust(ctx)
527: TextContext *ctx;
528: {
529: AlterSelection(ctx, XtsmTextExtend, XtactionAdjust);
530: }
531:
532: static ExtendEnd(ctx)
533: TextContext *ctx;
534: {
535: AlterSelection(ctx, XtsmTextExtend, XtactionEnd);
536: }
537:
538:
539: static RedrawDisplay(ctx)
540: TextContext *ctx;
541: {
542: ForceBuildLineTable(ctx);
543: DisplayTextWindow(ctx);
544: }
545:
546:
547: _XtTextAbortDialog(ctx)
548: TextContext *ctx;
549: {
550: if (ctx->dialog) {
551: XDestroyWindow(ctx->dpy, ctx->dialog);
552: (void) XtSendDestroyNotify(ctx->dpy, ctx->dialog);
553: ctx->dialog = NULL;
554: }
555: }
556:
557:
558: /* Insert a file of the given name into the text. Returns 0 if file found,
559: -1 if not. */
560:
561: static InsertFileNamed(ctx, str)
562: TextContext *ctx;
563: char *str;
564: {
565: int fid;
566: XtTextBlock text;
567: char buf[1000];
568: XtTextPosition position;
569:
570: if (str == NULL || strlen(str) == 0) return -1;
1.1.1.2 ! root 571: fid = open(str, 0);
1.1 root 572: if (fid <= 0) return -1;
573: _XtTextPrepareToUpdate(ctx);
574: position = ctx->insertPos;
575: while ((text.length = read(fid, buf, 512)) > 0) {
576: text.ptr = buf;
577: (void) ReplaceText(ctx, position, position, &text);
578: position = ctx->source->scan(ctx->source, position, XtstPositions,
579: XtsdRight, text.length, TRUE);
580: }
581: (void) close(fid);
582: ctx->insertPos = position;
583: _XtTextExecuteUpdate(ctx);
584: return 0;
585: }
586:
587: static DoInsert(ctx)
588: TextContext *ctx;
589: {
590: if (InsertFileNamed(ctx, XtDialogGetValueString(ctx->dpy, ctx->dialog)))
591: XBell(ctx->dpy, 50);
592: else
593: _XtTextAbortDialog(ctx);
594: }
595:
596: static InsertFile(ctx)
597: TextContext *ctx;
598: {
599: char *ptr;
600: XtTextBlock text;
601:
602: if (ctx->source->editType(ctx->source) != XttextEdit) {
603: XBell(ctx->dpy, 50);
604: return;
605: }
606: if (ctx->s.left < ctx->s.right) {
607: ptr = _XtTextGetText(ctx, ctx->s.left, ctx->s.right);
608: DeleteCurrentSelection(ctx);
609: if (InsertFileNamed(ctx, ptr)) {
610: XBell(ctx->dpy, 50);
611: text.ptr = ptr;
612: text.length = strlen(ptr);
613: (void) ReplaceText(ctx, ctx->insertPos, ctx->insertPos, &text);
614: ctx->s.left = ctx->insertPos;
615: ctx->s.right = ctx->insertPos =
616: ctx->source->scan(ctx->source, ctx->insertPos, XtstPositions,
617: XtsdRight, text.length, TRUE);
618: }
619: XtFree(ptr);
620: return;
621: }
622: if (ctx->dialog)
623: _XtTextAbortDialog(ctx);
624: ctx->dialog = XtDialogCreate(ctx->dpy, ctx->w, "Insert File:", "", (ArgList)NULL, 0);
625: XtDialogAddButton(ctx->dpy, ctx->dialog, "Abort", _XtTextAbortDialog, (caddr_t)ctx);
626: XtDialogAddButton(ctx->dpy, ctx->dialog, "DoIt", DoInsert, (caddr_t)ctx);
627: XMapWindow(ctx->dpy, ctx->dialog);
628: }
629:
630: /* Actions Table */
631:
632: static XtActionsRec actionsTable [] = {
633: /* motion bindings */
634: {"forward-character", (caddr_t)MoveForwardChar},
635: {"backward-character", (caddr_t)MoveBackwardChar},
636: {"forward-word", (caddr_t)MoveForwardWord},
637: {"backward-word", (caddr_t)MoveBackwardWord},
638: {"forward-paragraph", (caddr_t)MoveForwardParagraph},
639: {"backward-paragraph", (caddr_t)MoveBackwardParagraph},
640: {"beginning-of-line", (caddr_t)MoveToLineStart},
641: {"end-of-line", (caddr_t)MoveToLineEnd},
642: {"next-line", (caddr_t)MoveNextLine},
643: {"previous-line", (caddr_t)MovePreviousLine},
644: {"next-page", (caddr_t)MoveNextPage},
645: {"previous-page", (caddr_t)MovePreviousPage},
646: {"beginning-of-file", (caddr_t)MoveBeginningOfFile},
647: {"end-of-file", (caddr_t)MoveEndOfFile},
648: {"scroll-one-line-up", (caddr_t)ScrollOneLineUp},
649: {"scroll-one-line-down", (caddr_t)ScrollOneLineDown},
650: /* delete bindings */
651: {"delete-next-character", (caddr_t)DeleteForwardChar},
652: {"delete-previous-character", (caddr_t)DeleteBackwardChar},
653: {"delete-next-word", (caddr_t)DeleteForwardWord},
654: {"delete-previous-word", (caddr_t)DeleteBackwardWord},
655: {"delete-selection", (caddr_t)DeleteCurrentSelection},
656: /* kill bindings */
657: {"kill-word", (caddr_t)KillForwardWord},
658: {"backward-kill-word", (caddr_t)KillBackwardWord},
659: {"kill-selection", (caddr_t)KillCurrentSelection},
660: {"kill-to-end-of-line", (caddr_t)KillToEndOfLine},
661: {"kill-to-end-of-paragraph", (caddr_t)KillToEndOfParagraph},
662: /* unkill bindings */
663: {"unkill", (caddr_t)UnKill},
664: {"stuff", (caddr_t)Stuff},
665: /* new line stuff */
666: {"newline-and-indent", (caddr_t)InsertNewLineAndIndent},
667: {"newline-and-backup", (caddr_t)InsertNewLineAndBackup},
668: {"newline", (caddr_t)InsertNewLine},
669: /* Selection stuff */
670: {"select-word", (caddr_t)SelectWord},
671: {"select-all", (caddr_t)SelectAll},
672: {"select-start", (caddr_t)SelectStart},
673: {"select-adjust", (caddr_t)SelectAdjust},
674: {"select-end", (caddr_t)SelectEnd},
675: {"extend-start", (caddr_t)ExtendStart},
676: {"extend-adjust", (caddr_t)ExtendAdjust},
677: {"extend-end", (caddr_t)ExtendEnd},
678: /* Miscellaneous */
679: {"redraw-display", (caddr_t)RedrawDisplay},
680: {"insert-file", (caddr_t)InsertFile},
681: {NULL,NULL}
682: };
683:
684: static char *defaultTextEventBindings[] = {
685: /* motion bindings */
686: "<Ctrl>F: forward-character\n",
687: "<Key>0xff53: forward-character\n",
688: "<Ctrl>B: backward-character\n",
689: "<Key>0xff51: backward-character\n",
690: "<Meta>F: forward-word\n",
691: "<Meta>B: backward-word\n",
692: "<Meta>]: forward-paragraph\n",
693: "<Ctrl>[: backward-paragraph\n",
694: "<Ctrl>A: beginning-of-line\n",
695: "<Ctrl>E: end-of-line\n",
696: "<Ctrl>N: next-line\n",
697: "<Key>0xff54: next-line\n",
698: "<Ctrl>P: previous-line\n",
699: "<Key>0xff52: previous-line\n",
700: "<Ctrl>V: next-page\n",
701: "<Meta>V: previous-page\n",
702: "<Meta>\\<: beginning-of-file\n",
703: "<Meta>\\>: end-of-file\n",
704: "<Ctrl>Z: scroll-one-line-up\n",
705: "<Meta>Z: scroll-one-line-down\n",
706: /* delete bindings */
707: "<Ctrl>D: delete-next-character\n",
708: "<Ctrl>H: delete-previous-character\n",
709: "<Key>0xff7f: delete-previous-character\n",
710: "<Key>0xffff: delete-previous-character\n",
711: "<Key>0xff08: delete-previous-character\n",
712: "<Meta>D: delete-next-word\n",
713: "<Meta>H: delete-previous-word\n",
714: /* kill bindings */
715: "s<Meta>D: kill-word\n",
716: "s<Meta>H: backward-kill-word\n",
717: "<Ctrl>W: kill-selection\n",
718: "<Ctrl>K: kill-to-end-of-line\n",
719: "<Meta>K: kill-to-end-of-paragraph\n",
720: /* unkill bindings */
721: "<Ctrl>Y: unkill\n",
722: "<Meta>Y: stuff\n",
723: /* new line stuff */
724: "<Ctrl>J: newline-and-indent\n",
725: "<Key>0xff0a: newline-and-indent\n",
726: "<Ctrl>O: newline-and-backup\n",
727: "<Ctrl>M: newline\n",
728: "<Key>0xff0d: newline\n",
729: /* Miscellaneous */
730: "<Ctrl>L: redraw-display\n",
731: "<Meta>I: insert-file\n",
732: /* selection stuff */
733: "<BtnDown>1: select-start\n",
734: "<PtrMoved>1: extend-adjust\n",
735: "<BtnUp>1: extend-end\n",
736: "<BtnDown>2: stuff\n",
737: "<BtnDown>3: extend-start\n",
738: "<PtrMoved>3: extend-adjust\n",
739: "<BtnUp>3: extend-end\n",
740: NULL
741: };
742:
743: caddr_t XtSetTextEventBindings(dpy, eventTable)
744: Display *dpy;
745: XtEventsPtr eventTable;
746: {
747: caddr_t state;
748:
749: if (eventTable == NULL) /* supply defaults */
750: eventTable = XtParseEventBindings(defaultTextEventBindings);
751: state = XtSetActionBindings(
752: dpy, eventTable, actionsTable, (caddr_t) DoFeep);
753: return state;
754: }
755:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.