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