![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Text.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 / Xtk|
Return to Text.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / Xtk |
1.1 root 1: #ifndef lint
2: static char rcsid[] = "$Header: Text.c,v 1.4 87/09/13 23:32:44 newman Exp $";
3: #endif lint
4:
5: /*
6: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
7: *
8: * All Rights Reserved
9: *
10: * Permission to use, copy, modify, and distribute this software and its
11: * documentation for any purpose and without fee is hereby granted,
12: * provided that the above copyright notice appear in all copies and that
13: * both that copyright notice and this permission notice appear in
14: * supporting documentation, and that the name of Digital Equipment
15: * Corporation not be used in advertising or publicity pertaining to
16: * distribution of the software without specific, written prior permission.
17: *
18: *
19: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
20: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
21: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
22: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
23: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
24: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
25: * SOFTWARE.
26: */
27: /* File: Text.c */
28:
29: #include "Intrinsic.h"
30: #include "Text.h"
31: #include "TextP.h"
32: #include "Scroll.h"
33: #include "Atoms.h"
34: #include <sys/file.h>
35: #include <X11/Xutil.h>
36: #include <strings.h>
37:
38: extern void bcopy();
39:
40: #define BufMax 1000
41: #define abs(x) (((x) < 0) ? (-(x)) : (x))
42: #define min(x,y) ((x) < (y) ? (x) : (y))
43: #define max(x,y) ((x) > (y) ? (x) : (y))
44: #define GETLASTPOS (*(ctx->text.source->scan)) (ctx->text.source, 0, XtstFile, XtsdRight, 1, TRUE)
45: #define BUTTONMASK 0x143d
46:
47: #define yMargin 2
48: #define zeroPosition ((XtTextPosition) 0)
49:
50: extern void BuildLineTable ();
51:
52: /****************************************************************
53: *
54: * Full class record constant
55: *
56: ****************************************************************/
57:
58: extern caddr_t defaultTextTranslations;
59:
60: static XtResource resources[] = {
61: {XtNtextOptions, XtCTextOptions, XrmRInt, sizeof (int),
62: XtOffset(TextWidget, text.options), XrmRString, "0"},
63: {XtNdisplayPosition, XtCTextPosition, XrmRInt,
64: sizeof (XtTextPosition), XtOffset(TextWidget, text.lt.top),
65: XrmRString, "0"},
66: {XtNinsertPosition, XtCTextPosition, XtRInt,
67: sizeof(XtTextPosition), XtOffset(TextWidget, text.insertPos),
68: XrmRString, "0"},
69: {XtNleftMargin, XtCMargin, XrmRInt, sizeof (int),
70: XtOffset(TextWidget, text.leftmargin), XrmRString, "2"},
71: {XtNselectionArray, XtCSelectionArray, XrmRPointer,
72: sizeof(SelectionArray), XtOffset(TextWidget, text.sarray),
73: XrmRPointer, NULL},
74: {XtNtextSource, XtCTextSource, XrmRPointer, sizeof (caddr_t),
75: XtOffset(TextWidget, text.source), XrmRPointer, NULL},
76: {XtNtextSink, XtCTextSink, XrmRPointer, sizeof (caddr_t),
77: XtOffset(TextWidget, text.sink), XrmRPointer, NULL},
78: {XtNselection, XtCSelection, XrmRPointer, sizeof(caddr_t),
79: XtOffset(TextWidget, text.s), XrmRPointer, NULL},
80: {XtNeventBindings, XtCEventBindings, XtRStringTable,
81: sizeof(_XtTranslations), XtOffset(TextWidget, core.translations),
82: XtRStringTable, (caddr_t)&defaultTextTranslations},
83: };
84:
85:
86: static void Initialize(request, new)
87: Widget request, new;
88: {
89: TextWidget ctx = (TextWidget) new;
90:
91: if (ctx->core.width == 0)
92: ctx->core.width = 200;
93: if (ctx->core.height == 0)
94: ctx->core.height = 200;
95:
96: ctx->text.lt.lines = 0;
97: ctx->text.lt.info = NULL;
98: ctx->text.s.left = ctx->text.s.right = 0;
99: ctx->text.s.type = XtselectPosition;
100: ctx->text.sbar = ctx->text.outer = NULL;
101: ctx->text.sarray[0] = XtselectPosition;
102: ctx->text.sarray[1] = XtselectWord;
103: ctx->text.sarray[2] = XtselectLine;
104: ctx->text.sarray[3] = XtselectParagraph;
105: ctx->text.sarray[4] = XtselectAll;
106: ctx->text.sarray[5] = XtselectNull;
107: ctx->text.showposition = TRUE;
108: ctx->text.lastPos = GETLASTPOS;
109: ctx->text.dialog = NULL;
110: ctx->text.updateFrom = (XtTextPosition *) XtMalloc(1);
111: ctx->text.updateTo = (XtTextPosition *) XtMalloc(1);
112: ctx->text.numranges = ctx->text.maxranges = 0;
113: ctx->text.gc = DefaultGCOfScreen(XtScreen(ctx));
114: BuildLineTable(ctx, ctx->text.lt.top);
115: /* what about this ugly scrollbar stuff?
116: if (ctx->text.options & scrollVertical) {
117: scrollMgrArgs[0].value =
118: scrollBarArgs[0].value = (caddr_t)(XtWindow(ctx));
119: ctx->text.outer =
120: XtScrollMgrCreate(ctx->core.display, parent, scrollMgrArgs, XtNumber(scrollMgrArgs));
121: XtWindow(ctx) = XtScrollMgrGetChild(ctx->core.display, ctx->text.outer);
122: ctx->text.sbar =
123: XtCreateWidget("scrollbar", scrollbarWidgetClass, ctx->text.outer,
124: scrollBarArgs, XtNumber(scrollBarArgs));
125: XMapSubwindows(ctx->core.display, ctx->text.outer);
126: (void) XtSetEventHandler(ctx->core.display, ctx->text.outer, ProcessTextEvent,
127: StructureNotifyMask, (caddr_t) ctx);
128: }
129: */
130: }
131:
132: static void Realize( w, valueMask, attributes )
133: Widget w;
134: Mask valueMask;
135: XSetWindowAttributes *attributes;
136: {
137: TextWidget ctx = (TextWidget)w;
138: if (ctx->text.sbar) XtRealizeWidget(ctx->text.sbar);
139: ctx->core.window =
140: XCreateWindow(
141: XtDisplay(w), w->core.parent->core.window,
142: w->core.x, w->core.y,
143: w->core.width, w->core.height, w->core.border_width,
144: w->core.depth, InputOutput, (Visual *)CopyFromParent,
145: valueMask, attributes);
146: }
147:
148: /* Utility routines for support of Text */
149:
150:
151: /*
152: * Procedure to manage insert cursor visibility for editable text. It uses
153: * the value of ctx->insertPos and an implicit argument. In the event that
154: * position is immediately preceded by an eol graphic, then the insert cursor
155: * is displayed at the beginning of the next line.
156: */
157: static void InsertCursor (ctx, state)
158: TextWidget ctx;
159: InsertState state;
160: {
161: Position x, y;
162: int dy, line, visible;
163: XtTextBlock text;
164:
165: if (ctx->text.lt.lines < 1) return;
166: visible = LineAndXYForPosition(ctx, ctx->text.insertPos, &line, &x, &y);
167: if (line < ctx->text.lt.lines)
168: dy = (ctx->text.lt.info[line + 1].y - ctx->text.lt.info[line].y) + 1;
169: else
170: dy = (ctx->text.lt.info[line].y - ctx->text.lt.info[line - 1].y) + 1;
171:
172: /** If the insert position is just after eol then put it on next line **/
173: if (x > ctx->text.leftmargin &&
174: ctx->text.insertPos > 0 &&
175: ctx->text.insertPos >= ctx->text.lastPos) {
176: /* reading the source is bogus and this code should use scan */
177: (*(ctx->text.source->read)) (ctx->text.source, ctx->text.insertPos - 1, &text, 1);
178: if (text.ptr[0] == '\n') {
179: x = ctx->text.leftmargin;
180: y += dy;
181: }
182: }
183: y += dy;
184: if (visible)
185: (*(ctx->text.sink->insertCursor))(ctx, x, y, state);
186: }
187:
188:
189: /*
190: * Procedure to register a span of text that is no longer valid on the display
191: * It is used to avoid a number of small, and potentially overlapping, screen
192: * updates. [note: this is really a private procedure but is used in
193: * multiple modules].
194: */
195: _XtTextNeedsUpdating(ctx, left, right)
196: TextWidget ctx;
197: XtTextPosition left, right;
198: {
199: int i;
200: if (left < right) {
201: for (i = 0; i < ctx->text.numranges; i++) {
202: if (left <= ctx->text.updateTo[i] && right >= ctx->text.updateFrom[i]) {
203: ctx->text.updateFrom[i] = min(left, ctx->text.updateFrom[i]);
204: ctx->text.updateTo[i] = max(right, ctx->text.updateTo[i]);
205: return;
206: }
207: }
208: ctx->text.numranges++;
209: if (ctx->text.numranges > ctx->text.maxranges) {
210: ctx->text.maxranges = ctx->text.numranges;
211: i = ctx->text.maxranges * sizeof(XtTextPosition);
212: ctx->text.updateFrom = (XtTextPosition *)
213: XtRealloc((char *)ctx->text.updateFrom, (unsigned) i);
214: ctx->text.updateTo = (XtTextPosition *)
215: XtRealloc((char *)ctx->text.updateTo, (unsigned) i);
216: }
217: ctx->text.updateFrom[ctx->text.numranges - 1] = left;
218: ctx->text.updateTo[ctx->text.numranges - 1] = right;
219: }
220: }
221:
222:
223: /*
224: * Procedure to read a span of text in Ascii form. This is purely a hack and
225: * we probably need to add a function to sources to provide this functionality.
226: * [note: this is really a private procedure but is used in multiple modules].
227: */
228: char *_XtTextGetText(ctx, left, right)
229: TextWidget ctx;
230: XtTextPosition left, right;
231: {
232: char *result, *tempResult;
233: int length, resultLength;
234: XtTextBlock text;
235: XtTextPosition end, nend;
236:
237: resultLength = right - left + 10; /* Bogus? %%% */
238: result = (char *)XtMalloc((unsigned) resultLength);
239: end = (*(ctx->text.source->read))(ctx->text.source, left, &text, right - left);
240: (void) strncpy(result, text.ptr, text.length);
241: length = text.length;
242: while (end < right) {
243: nend = (*(ctx->text.source->read))(ctx->text.source, end, &text, right - end);
244: tempResult = result + length;
245: (void) strncpy(tempResult, text.ptr, text.length);
246: length += text.length;
247: end = nend;
248: }
249: result[length] = 0;
250: return result;
251: }
252:
253:
254:
255: /*
256: * This routine maps an x and y position in a window that is displaying text
257: * into the corresponding position in the source.
258: */
259: static XtTextPosition PositionForXY (ctx, x, y)
260: TextWidget ctx;
261: Position x,y;
262: {
263: /* it is illegal to call this routine unless there is a valid line table! */
264: int width, fromx, line;
265: XtTextPosition position, resultstart, resultend;
266:
267: /*** figure out what line it is on ***/
268: for (line = 0; line < ctx->text.lt.lines - 1; line++) {
269: if (y <= ctx->text.lt.info[line + 1].y)
270: break;
271: }
272: position = ctx->text.lt.info[line].position;
273: if (position >= ctx->text.lastPos)
274: return ctx->text.lastPos;
275: fromx = ctx->text.lt.info[line].x; /* starting x in line */
276: width = x - fromx; /* num of pix from starting of line */
277: (*(ctx->text.sink->resolve)) (ctx, position, fromx, width,
278: &resultstart, &resultend);
279: if (resultstart >= ctx->text.lt.info[line + 1].position)
280: resultstart = (*(ctx->text.source->scan))(ctx->text.source,
281: ctx->text.lt.info[line + 1].position, XtstPositions, XtsdLeft, 1, TRUE);
282: return resultstart;
283: }
284:
285: /*
286: * This routine maps a source position in to the corresponding line number
287: * of the text that is displayed in the window.
288: */
289: int LineForPosition (ctx, position)
290: TextWidget ctx;
291: XtTextPosition position;
292: /* it is illegal to call this routine unless there is a valid line table!*/
293: {
294: int line;
295:
296: if (position <= ctx->text.lt.info[0].position)
297: return 0;
298: for (line = 0; line < ctx->text.lt.lines; line++)
299: if (position < ctx->text.lt.info[line + 1].position)
300: break;
301: return line;
302: }
303:
304: /*
305: * This routine maps a source position into the corresponding line number
306: * and the x, y coordinates of the text that is displayed in the window.
307: */
308: static int LineAndXYForPosition (ctx, pos, line, x, y)
309: TextWidget ctx;
310: XtTextPosition pos;
311: int *line;
312: Position *x, *y;
313: /* it is illegal to call this routine unless there is a valid line table!*/
314: {
315: XtTextPosition linePos, endPos;
316: int visible, realW, realH;
317:
318: *line = 0;
319: *x = ctx->text.leftmargin;
320: *y = yMargin;
321: visible = IsPositionVisible(ctx, pos);
322: if (visible) {
323: *line = LineForPosition(ctx, pos);
324: *y = ctx->text.lt.info[*line].y;
325: *x = ctx->text.lt.info[*line].x;
326: linePos = ctx->text.lt.info[*line].position;
327: (*(ctx->text.sink->findDistance))(ctx, linePos,
328: *x, pos, &realW, &endPos, &realH);
329: *x = *x + realW;
330: }
331: return visible;
332: }
333:
334: /*
335: * This routine builds a line table. It does this by starting at the
336: * specified position and measuring text to determine the staring position
337: * of each line to be displayed. It also determines and saves in the
338: * linetable all the required metrics for displaying a given line (e.g.
339: * x offset, y offset, line length, etc.).
340: */
341: static void BuildLineTable (ctx, position)
342: TextWidget ctx;
343: XtTextPosition position;
344: {
345: Position x, y;
346: Dimension width, realW, realH;
347: int line, lines;
348: XtTextPosition startPos, endPos;
349: Boolean rebuild;
350:
351: rebuild = (Boolean) (position != ctx->text.lt.top);
352: lines = (*(ctx->text.sink->maxLines))(ctx, ctx->core.height);
353: if (ctx->text.lt.info != NULL && lines != ctx->text.lt.lines) {
354: XtFree((char *) ctx->text.lt.info);
355: ctx->text.lt.info = NULL;
356: }
357: if (ctx->text.lt.info == NULL) {
358: ctx->text.lt.info = (LineTableEntry *)
359: XtMalloc((unsigned)sizeof(LineTableEntry) * (lines + 1));
360: for (line = 0; line < lines; line++) {
361: ctx->text.lt.info[line].position = 0;
362: ctx->text.lt.info[line].y = 0;
363: }
364: rebuild = TRUE;
365: }
366: else
367: lines = ctx->text.lt.lines;
368: if (rebuild) {
369: ctx->text.lt.top = position;
370: ctx->text.lt.lines = lines;
371: startPos = position;
372: y = yMargin;
373: for (line = 0; line <= ctx->text.lt.lines; line++) {
374: x = ctx->text.leftmargin;
375: ctx->text.lt.info[line].x = x;
376: ctx->text.lt.info[line].y = y;
377: ctx->text.lt.info[line].position = startPos;
378: if (startPos <= ctx->text.lastPos) {
379: width = (ctx->text.options & resizeWidth) ? 9999 : ctx->core.width - x;
380: (*(ctx->text.sink->findPosition))(ctx,
381: startPos, x,
382: width, (ctx->text.options & wordBreak),
383: &endPos, &realW, &realH);
384: if (!(ctx->text.options & wordBreak) && endPos < ctx->text.lastPos) {
385: endPos = (*(ctx->text.source->scan))(ctx->text.source, startPos,
386: XtstEOL, XtsdRight, 1, TRUE);
387: if (endPos == startPos)
388: endPos = ctx->text.lastPos + 1;
389: }
390: ctx->text.lt.info[line].endX = realW + x;
391: startPos = endPos;
392: }
393: else ctx->text.lt.info[line].endX = x;
394: y = y + realH;
395: }
396: }
397: }
398:
399: /*
400: * This routine is used to re-display the entire window, independent of
401: * its current state.
402: */
403: void ForceBuildLineTable(ctx)
404: TextWidget ctx;
405: {
406: XtTextPosition position;
407:
408: position = ctx->text.lt.top;
409: ctx->text.lt.top++; /* ugly, but it works */
410: BuildLineTable(ctx, position);
411: }
412:
413: /*
414: * This routine is used by Text to notify an associated scrollbar of the
415: * correct metrics (position and shown fraction) for the text being currently
416: * displayed in the window.
417: */
418: static void SetScrollBar(ctx)
419: TextWidget ctx;
420: {
421: float first, last;
422: if (ctx->text.sbar) {
423: if ((ctx->text.lastPos > 0) && (ctx->text.lt.lines > 0)) {
424: first = ctx->text.lt.top;
425: first /= ctx->text.lastPos;
426: /* Just an approximation */
427: last = ctx->text.lt.info[ctx->text.lt.lines].position;
428: last /= ctx->text.lastPos;
429: }
430: else {
431: first = 0.0;
432: last = 1.0;
433: }
434: XtScrollBarSetThumb(ctx->text.sbar, first, last - first);
435: }
436: }
437:
438:
439: /*
440: * The routine will scroll the displayed text by lines. If the arg is
441: * positive, move up; otherwise, move down. [note: this is really a private
442: * procedure but is used in multiple modules].
443: */
444: _XtTextScroll(ctx, n)
445: TextWidget ctx;
446: int n;
447: {
448: XtTextPosition top, target;
449: if (n >= 0) {
450: top = min(ctx->text.lt.info[n].position, ctx->text.lastPos);
451: BuildLineTable(ctx, top);
452: if (top >= ctx->text.lastPos)
453: DisplayTextWindow(ctx);
454: else {
455: XCopyArea(XtDisplay(ctx), XtWindow(ctx), XtWindow(ctx), ctx->text.gc,
456: 0, ctx->text.lt.info[n].y,
457: 9999, (Dimension)ctx->core.height - ctx->text.lt.info[n].y,
458: 0, ctx->text.lt.info[0].y);
459: (*(ctx->text.sink->clearToBackground))(ctx, 0,
460: ctx->text.lt.info[0].y + ctx->core.height - ctx->text.lt.info[n].y,
461: 9999, 9999);
462: if (n < ctx->text.lt.lines) n++;
463: _XtTextNeedsUpdating(ctx,
464: ctx->text.lt.info[ctx->text.lt.lines - n].position, ctx->text.lastPos);
465: SetScrollBar(ctx);
466: }
467: } else {
468: Dimension tempHeight;
469: n = -n;
470: target = ctx->text.lt.top;
471: top = (*(ctx->text.source->scan))(ctx->text.source, target, XtstEOL,
472: XtsdLeft, n+1, FALSE);
473: tempHeight = ctx->text.lt.info[ctx->text.lt.lines-n].y;
474: BuildLineTable(ctx, top);
475: if (ctx->text.lt.info[n].position == target) {
476: XCopyArea(XtDisplay(ctx), XtWindow(ctx), XtWindow(ctx), ctx->text.gc,
477: 0, ctx->text.lt.info[0].y, 9999, tempHeight,
478: 0, ctx->text.lt.info[n].y);
479: _XtTextNeedsUpdating(ctx,
480: ctx->text.lt.info[0].position, ctx->text.lt.info[n].position);
481: SetScrollBar(ctx);
482: } else if (ctx->text.lt.top != target) DisplayTextWindow(ctx);
483: }
484: }
485:
486: /*
487: * The routine will scroll the displayed text by pixels. If the arg is
488: * positive, move up; otherwise, move down.
489: */
490: /*ARGSUSED*/ /* keep lint happy */
491: static int ScrollUpDownProc (w, data, pix)
492: Widget w;
493: int data;
494: int pix;
495: {
496: TextWidget ctx = (TextWidget)w;
497: int apix, line;
498: _XtTextPrepareToUpdate(ctx);
499: apix = abs(pix);
500: for (line = 1;
501: line < ctx->text.lt.lines && apix > ctx->text.lt.info[line + 1].y;
502: line++);
503: if (pix >= 0)
504: _XtTextScroll(ctx, line);
505: else
506: _XtTextScroll(ctx, -line);
507: _XtTextExecuteUpdate(ctx);
508: }
509:
510: /*
511: * The routine "thumbs" the displayed text. Thumbing means reposition the
512: * displayed view of the source to a new position determined by a fraction
513: * of the way from beginning to end. Ideally, this should be determined by
514: * the number of displayable lines in the source. This routine does it as a
515: * fraction of the first position and last position and then normalizes to
516: * the start of the line containing the position.
517: */
518: /*ARGSUSED*/ /* keep lint happy */
519: static int ThumbProc (w, data, where)
520: Widget w;
521: int data;
522: float where;
523: /* BUG/deficiency: The normalize to line portion of this routine will
524: * cause thumbing to always position to the start of the source.
525: */
526: {
527:
528: TextWidget ctx= (TextWidget)w;
529: XtTextPosition position;
530: _XtTextPrepareToUpdate(ctx);
531: position = where * ctx->text.lastPos;
532: position = (*(ctx->text.source->scan))(ctx->text.source, position, XtstEOL, XtsdLeft,
533: 1, FALSE);
534: BuildLineTable(ctx, position);
535: DisplayTextWindow(ctx);
536: _XtTextExecuteUpdate(ctx);
537: }
538:
539:
540: int _XtTextSetNewSelection(ctx, left, right)
541: TextWidget ctx;
542: XtTextPosition left, right;
543: {
544: XtTextPosition pos;
545:
546: if (left < ctx->text.s.left) {
547: pos = min(right, ctx->text.s.left);
548: _XtTextNeedsUpdating(ctx, left, pos);
549: }
550: if (left > ctx->text.s.left) {
551: pos = min(left, ctx->text.s.right);
552: _XtTextNeedsUpdating(ctx, ctx->text.s.left, pos);
553: }
554: if (right < ctx->text.s.right) {
555: pos = max(right, ctx->text.s.left);
556: _XtTextNeedsUpdating(ctx, pos, ctx->text.s.right);
557: }
558: if (right > ctx->text.s.right) {
559: pos = max(left, ctx->text.s.right);
560: _XtTextNeedsUpdating(ctx, pos, right);
561: }
562:
563: ctx->text.s.left = left;
564: ctx->text.s.right = right;
565: }
566:
567:
568:
569: /*
570: * This internal routine deletes the text from pos1 to pos2 in a source and
571: * then inserts, at pos1, the text that was passed. As a side effect it
572: * "invalidates" that portion of the displayed text (if any).
573: */
574: int ReplaceText (ctx, pos1, pos2, text)
575: TextWidget ctx;
576: XtTextPosition pos1, pos2;
577: XtTextBlock *text;
578:
579: /* it is illegal to call this routine unless there is a valid line table!*/
580: {
581: int i, line1, line2, visible, delta, error;
582: Position x, y;
583: Dimension realW, realH, width;
584: XtTextPosition startPos, endPos, updateFrom;
585:
586: /* the insertPos may not always be set to the right spot in XttextAppend */
587: if ((pos1 == ctx->text.insertPos) &&
588: ((*(ctx->text.source->editType))(ctx->text.source) == XttextAppend)) {
589: ctx->text.insertPos = GETLASTPOS;
590: pos2 = pos2 - pos1 + ctx->text.insertPos;
591: pos1 = ctx->text.insertPos;
592: }
593: updateFrom = (*(ctx->text.source->scan))(ctx->text.source, pos1, XtstWhiteSpace, XtsdLeft,
594: 1, TRUE);
595: updateFrom = (*(ctx->text.source->scan))(ctx->text.source, updateFrom, XtstPositions, XtsdLeft,
596: 1, TRUE);
597: startPos = max(updateFrom, ctx->text.lt.top);
598: visible = LineAndXYForPosition(ctx, startPos, &line1, &x, &y);
599: error = (*(ctx->text.source->replace))(ctx->text.source, pos1, pos2, text, &delta);
600: if (error) return error;
601: ctx->text.lastPos = GETLASTPOS;
602: if (ctx->text.lt.top >= ctx->text.lastPos) {
603: BuildLineTable(ctx, ctx->text.lastPos);
604: ClearWindow(ctx);
605: SetScrollBar(ctx);
606: return error;
607: }
608: if (delta < ctx->text.lastPos) {
609: for (i = 0; i < ctx->text.numranges; i++) {
610: if (ctx->text.updateFrom[i] > pos1)
611: ctx->text.updateFrom[i] += delta;
612: if (ctx->text.updateTo[i] >= pos1)
613: ctx->text.updateTo[i] += delta;
614: }
615: }
616:
617: line2 = LineForPosition(ctx, pos1);
618: /*
619: * fixup all current line table entries to reflect edit.
620: * BUG: it is illegal to do arithmetic on positions. This code should
621: * either use scan or the source needs to provide a function for doing
622: * position arithmetic.
623: */
624: for (i = line2 + 1; i <= ctx->text.lt.lines; i++)
625: ctx->text.lt.info[i].position += delta;
626:
627: endPos = pos1;
628: /*
629: * Now process the line table and fixup in case edits caused
630: * changes in line breaks. If we are breaking on word boundaries,
631: * this code checks for moving words to and from lines.
632: */
633: if (visible) {
634: for (i = line1; i < ctx->text.lt.lines; i++) {/* fixup line table */
635: width = (ctx->text.options & resizeWidth) ? 9999 : ctx->core.width - x;
636: if (startPos <= ctx->text.lastPos) {
637: (*(ctx->text.sink->findPosition))(ctx, startPos, x,
638: width, (ctx->text.options & wordBreak),
639: &endPos, &realW, &realH);
640: if (!(ctx->text.options & wordBreak) && endPos < ctx->text.lastPos) {
641: endPos = (*(ctx->text.source->scan))(ctx->text.source, startPos,
642: XtstEOL, XtsdRight, 1, TRUE);
643: if (endPos == startPos)
644: endPos = ctx->text.lastPos + 1;
645: }
646: ctx->text.lt.info[i].endX = realW + x;
647: ctx->text.lt.info[i + 1].y = realH + ctx->text.lt.info[i].y;
648: if ((endPos > pos1) &&
649: (endPos == ctx->text.lt.info[i + 1].position))
650: break;
651: startPos = endPos;
652: }
653: if (startPos > ctx->text.lastPos)
654: ctx->text.lt.info[i + 1].endX = ctx->text.leftmargin;
655: ctx->text.lt.info[i + 1].position = startPos;
656: x = ctx->text.lt.info[i + 1].x;
657: }
658: }
659: if (delta >= ctx->text.lastPos)
660: endPos = ctx->text.lastPos;
661: if (delta >= ctx->text.lastPos || pos2 >= ctx->text.lt.top)
662: _XtTextNeedsUpdating(ctx, updateFrom, endPos);
663: SetScrollBar(ctx);
664: return error;
665: }
666:
667:
668: /*
669: * This routine will display text between two arbitrary source positions.
670: * In the event that this span contains highlighted text for the selection,
671: * only that portion will be displayed highlighted.
672: */
673: static void DisplayText(ctx, pos1, pos2)
674: TextWidget ctx;
675: XtTextPosition pos1, pos2;
676: /* it is illegal to call this routine unless there is a valid line table!*/
677: {
678: Position x, y;
679: Dimension height;
680: int line, i, visible;
681: XtTextPosition startPos, endPos;
682:
683: if (pos1 < ctx->text.lt.top)
684: pos1 = ctx->text.lt.top;
685: if (pos2 > ctx->text.lastPos)
686: pos2 = ctx->text.lastPos;
687: if (pos1 >= pos2) return;
688: visible = LineAndXYForPosition(ctx, pos1, &line, &x, &y);
689: if (!visible)
690: return;
691: startPos = pos1;
692: height = ctx->text.lt.info[1].y - ctx->text.lt.info[0].y;
693: for (i = line; i < ctx->text.lt.lines; i++) {
694: endPos = ctx->text.lt.info[i + 1].position;
695: if (endPos > pos2)
696: endPos = pos2;
697: if (endPos > startPos) {
698: if (x == ctx->text.leftmargin)
699: (*(ctx->text.sink->clearToBackground))(ctx,
700: 0, y, ctx->text.leftmargin, height);
701: if (startPos >= ctx->text.s.right || endPos <= ctx->text.s.left) {
702: (*(ctx->text.sink->display))(ctx, x, y,
703: startPos, endPos, FALSE);
704: } else if (startPos >= ctx->text.s.left && endPos <= ctx->text.s.right) {
705: (*(ctx->text.sink->display))(ctx, x, y,
706: startPos, endPos, TRUE);
707: } else {
708: DisplayText(ctx, startPos, ctx->text.s.left);
709: DisplayText(ctx, max(startPos, ctx->text.s.left),
710: min(endPos, ctx->text.s.right));
711: DisplayText(ctx, ctx->text.s.right, endPos);
712: }
713: }
714: startPos = endPos;
715: height = ctx->text.lt.info[i + 1].y - ctx->text.lt.info[i].y;
716: (*(ctx->text.sink->clearToBackground))(ctx,
717: ctx->text.lt.info[i].endX, y, 999, height);
718: x = ctx->text.leftmargin;
719: y = ctx->text.lt.info[i + 1].y;
720: if ((endPos == pos2) && (endPos != ctx->text.lastPos))
721: break;
722: }
723: }
724:
725: /*
726: * This routine implements multi-click selection in a hardwired manner.
727: * It supports multi-click entity cycling (char, word, line, file) and mouse
728: * motion adjustment of the selected entitie (i.e. select a word then, with
729: * button still down, adjust wich word you really meant by moving the mouse).
730: * [NOTE: This routine is to be replaced by a set of procedures that
731: * will allows clients to implements a wide class of draw through and
732: * multi-click selection user interfaces.]
733: */
734: static void DoSelection (ctx, position, time, motion)
735: TextWidget ctx;
736: XtTextPosition position;
737: unsigned short time;
738: Boolean motion;
739: {
740: int delta;
741: XtTextPosition newLeft, newRight;
742: XtSelectType newType;
743: XtSelectType *sarray;
744:
745: delta = (time < ctx->text.lasttime) ?
746: ctx->text.lasttime - time : time - ctx->text.lasttime;
747: if (motion)
748: newType = ctx->text.s.type;
749: else {
750: if ((delta < 500) && ((position >= ctx->text.s.left)
751: && (position <= ctx->text.s.right))) { /* multi-click event */
752: sarray = ctx->text.sarray;
753: for (sarray = ctx->text.sarray;
754: *sarray != XtselectNull && *sarray != ctx->text.s.type;
755: sarray++) ;
756: if (*sarray != XtselectNull) sarray++;
757: if (*sarray == XtselectNull) sarray = ctx->text.sarray;
758: newType = *sarray;
759: } else { /* single-click event */
760: newType = *(ctx->text.sarray);
761: }
762: ctx->text.lasttime = time;
763: }
764: switch (newType) {
765: case XtselectPosition:
766: newLeft = newRight = position;
767: break;
768: case XtselectChar:
769: newLeft = position;
770: newRight = (*(ctx->text.source->scan))(
771: ctx->text.source, position, position, XtsdRight, 1, FALSE);
772: break;
773: case XtselectWord:
774: newLeft = (*(ctx->text.source->scan))(
775: ctx->text.source, position, XtstWhiteSpace, XtsdLeft, 1, FALSE);
776: newRight = (*(ctx->text.source->scan))(
777: ctx->text.source, position, XtstWhiteSpace, XtsdRight, 1, FALSE);
778: break;
779: case XtselectLine:
780: case XtselectParagraph: /* need "para" scan mode to implement pargraph */
781: newLeft = (*(ctx->text.source->scan))(
782: ctx->text.source, position, XtstEOL, XtsdLeft, 1, FALSE);
783: newRight = (*(ctx->text.source->scan))(
784: ctx->text.source, position, XtstEOL, XtsdRight, 1, FALSE);
785: break;
786: case XtselectAll:
787: newLeft = (*(ctx->text.source->scan))(
788: ctx->text.source, position, XtstFile, XtsdLeft, 1, FALSE);
789: newRight = (*(ctx->text.source->scan))(
790: ctx->text.source, position, XtstFile, XtsdRight, 1, FALSE);
791: break;
792: }
793: if ((newLeft != ctx->text.s.left) || (newRight != ctx->text.s.right)
794: || (newType != ctx->text.s.type)) {
795: _XtTextSetNewSelection(ctx, newLeft, newRight);
796: ctx->text.s.type = newType;
797: if (position - ctx->text.s.left < ctx->text.s.right - position)
798: ctx->text.insertPos = newLeft;
799: else
800: ctx->text.insertPos = newRight;
801: }
802: if (!motion) { /* setup so we can freely mix select extend calls*/
803: ctx->text.origSel.type = ctx->text.s.type;
804: ctx->text.origSel.left = ctx->text.s.left;
805: ctx->text.origSel.right = ctx->text.s.right;
806: if (position >= ctx->text.s.left + ((ctx->text.s.right - ctx->text.s.left) / 2))
807: ctx->text.extendDir = XtsdRight;
808: else
809: ctx->text.extendDir = XtsdLeft;
810: }
811: }
812:
813: /*
814: * This routine implements extension of the currently selected text in
815: * the "current" mode (i.e. char word, line, etc.). It worries about
816: * extending from either end of the selection and handles the case when you
817: * cross through the "center" of the current selection (e.g. switch which
818: * end you are extending!).
819: * [NOTE: This routine will be replaced by a set of procedures that
820: * will allows clients to implements a wide class of draw through and
821: * multi-click selection user interfaces.]
822: */
823: static void ExtendSelection (ctx, position, motion)
824: TextWidget ctx;
825: XtTextPosition position;
826: Boolean motion;
827: {
828: XtTextPosition newLeft, newRight;
829:
830:
831: if (!motion) { /* setup for extending selection */
832: ctx->text.origSel.type = ctx->text.s.type;
833: ctx->text.origSel.left = ctx->text.s.left;
834: ctx->text.origSel.right = ctx->text.s.right;
835: if (position >= ctx->text.s.left + ((ctx->text.s.right - ctx->text.s.left) / 2))
836: ctx->text.extendDir = XtsdRight;
837: else
838: ctx->text.extendDir = XtsdLeft;
839: }
840: else /* check for change in extend direction */
841: if ((ctx->text.extendDir == XtsdRight && position < ctx->text.origSel.left) ||
842: (ctx->text.extendDir == XtsdLeft && position > ctx->text.origSel.right)) {
843: ctx->text.extendDir = (ctx->text.extendDir == XtsdRight)? XtsdLeft : XtsdRight;
844: _XtTextSetNewSelection(ctx, ctx->text.origSel.left, ctx->text.origSel.right);
845: }
846: newLeft = ctx->text.s.left;
847: newRight = ctx->text.s.right;
848: switch (ctx->text.s.type) {
849: case XtselectPosition:
850: if (ctx->text.extendDir == XtsdRight)
851: newRight = position;
852: else
853: newLeft = position;
854: break;
855: case XtselectWord:
856: if (ctx->text.extendDir == XtsdRight)
857: newRight = position = (*(ctx->text.source->scan))(
858: ctx->text.source, position, XtstWhiteSpace, XtsdRight, 1, FALSE);
859: else
860: newLeft = position = (*(ctx->text.source->scan))(
861: ctx->text.source, position, XtstWhiteSpace, XtsdLeft, 1, FALSE);
862: break;
863: case XtselectLine:
864: case XtselectParagraph: /* need "para" scan mode to implement pargraph */
865: if (ctx->text.extendDir == XtsdRight)
866: newRight = position = (*(ctx->text.source->scan))(
867: ctx->text.source, position, XtstEOL, XtsdRight, 1, TRUE);
868: else
869: newLeft = position = (*(ctx->text.source->scan))(
870: ctx->text.source, position, XtstEOL, XtsdLeft, 1, FALSE);
871: break;
872: case XtselectAll:
873: position = ctx->text.insertPos;
874: break;
875: }
876: _XtTextSetNewSelection(ctx, newLeft, newRight);
877: ctx->text.insertPos = position;
878: }
879:
880:
881: /*
882: * Clear the window to background color.
883: */
884: static ClearWindow (ctx)
885: TextWidget ctx;
886: {
887: (*(ctx->text.sink->clearToBackground))(ctx, 0, 0, ctx->core.width, ctx->core.height);
888: }
889:
890:
891: /*
892: * Internal redisplay entire window.
893: */
894: DisplayTextWindow (w)
895: Widget w;
896: {
897: TextWidget ctx = (TextWidget) w;
898: ClearWindow(ctx);
899: BuildLineTable(ctx, ctx->text.lt.top);
900: _XtTextNeedsUpdating(ctx, zeroPosition, ctx->text.lastPos);
901: SetScrollBar(ctx);
902: }
903:
904: /*
905: * This routine checks to see if the window should be resized (grown or
906: * shrunk) or scrolled then text to be painted overflows to the right or
907: * the bottom of the window. It is used by the keyboard input routine.
908: */
909: CheckResizeOrOverflow(ctx)
910: TextWidget ctx;
911: {
912: XtTextPosition posToCheck;
913: int visible, line, width;
914: XtWidgetGeometry rbox;
915: if (ctx->text.options & resizeWidth) {
916: width = 0;
917: for (line=0 ; line<ctx->text.lt.lines ; line++)
918: if (width < ctx->text.lt.info[line].endX)
919: width = ctx->text.lt.info[line].endX;
920: width += ctx->text.leftmargin;
921: if (width > ctx->core.width) {
922: rbox.request_mode = CWWidth;
923: rbox.width = width;
924: if ( XtMakeGeometryRequest(ctx, &rbox, NULL) != XtGeometryNo) {
925: ctx->core.width = rbox.width;
926: }
927: }
928: }
929: if ((ctx->text.options & resizeHeight) || (ctx->text.options & scrollOnOverflow)) {
930: if (ctx->text.options & scrollOnOverflow)
931: posToCheck = ctx->text.insertPos;
932: else
933: posToCheck = ctx->text.lastPos;
934: visible = IsPositionVisible(ctx, posToCheck);
935: if (visible)
936: line = LineForPosition(ctx, posToCheck);
937: else
938: line = ctx->text.lt.lines;
939: if ((ctx->text.options & scrollOnOverflow) && (line + 1 > ctx->text.lt.lines)) {
940: BuildLineTable(ctx, ctx->text.lt.info[1].position);
941: XCopyArea(XtDisplay(ctx), XtWindow(ctx), XtWindow(ctx),
942: ctx->text.gc, (Position)ctx->text.leftmargin,
943: ctx->text.lt.info[1].y, 9999, 9999,
944: (Position)ctx->text.leftmargin, ctx->text.lt.info[0].y);
945: }
946: else
947: if ((ctx->text.options & resizeHeight) && (line + 1 != ctx->text.lt.lines)) {
948: rbox.request_mode = CWHeight;
949: rbox.height = (*(ctx->text.sink->maxHeight))
950: (ctx, line + 1) + (2*yMargin)+2;
951: if (XtMakeGeometryRequest(ctx, &rbox, NULL) != XtGeometryNo) {
952: ctx->core.width = rbox.height ;
953: };
954: }
955: }
956: }
957:
958: /*
959: * This routine is used to perform various selection functions. The goal is
960: * to be able to specify all the more popular forms of draw-through and
961: * multi-click selection user interfaces from the outside.
962: */
963: void AlterSelection (ctx, mode, action)
964: TextWidget ctx;
965: SelectionMode mode; /* {XtsmTextSelect, XtsmTextExtend} */
966: SelectionAction action; /* {XtactionStart, XtactionAdjust, XtactionEnd} */
967: {
968: XtTextPosition position;
969: char *ptr;
970:
971: position = PositionForXY (ctx, (int) ctx->text.ev_x, (int) ctx->text.ev_y);
972: if (action == XtactionStart) {
973: switch (mode) {
974: case XtsmTextSelect:
975: DoSelection (ctx, position, ctx->text.time, FALSE);
976: break;
977: case XtsmTextExtend:
978: ExtendSelection (ctx, position, FALSE);
979: break;
980: }
981: }
982: else {
983: switch (mode) {
984: case XtsmTextSelect:
985: DoSelection (ctx, position, ctx->text.time, TRUE);
986: break;
987: case XtsmTextExtend:
988: ExtendSelection (ctx, position, TRUE);
989: break;
990: }
991: }
992: if (action == XtactionEnd && ctx->text.s.left < ctx->text.s.right) {
993: ptr = _XtTextGetText (ctx, ctx->text.s.left, ctx->text.s.right);
994: XStoreBuffer (XtDisplay(ctx), ptr, min (strlen (ptr), MAXCUT), 0);
995: XtFree (ptr);
996: }
997: }
998:
999: /*
1000: * This routine processes all "expose region" XEvents. In general, its job
1001: * is to the best job at minimal re-paint of the text, displayed in the
1002: * window, that it can.
1003: */
1004: static void ProcessExposeRegion(w, event)
1005: Widget w;
1006: XEvent *event;
1007: {
1008: TextWidget ctx = (TextWidget) w;
1009: XtTextPosition pos1, pos2, resultend;
1010: int line;
1011: int x = event->xexpose.x;
1012: int y = event->xexpose.y;
1013: int width = event->xexpose.width;
1014: int height = event->xexpose.height;
1015: LineTableEntryPtr info;
1016:
1017: _XtTextPrepareToUpdate(ctx);
1018: if (x < ctx->text.leftmargin) /* stomp on caret tracks */
1019: (*(ctx->text.sink->clearToBackground))(ctx, x, y, width, height);
1020: /* figure out starting line that was exposed */
1021: line = LineForPosition(ctx, PositionForXY(ctx, x, y));
1022: while (line < ctx->text.lt.lines && ctx->text.lt.info[line + 1].y < y)
1023: line++;
1024: while (line < ctx->text.lt.lines) {
1025: info = &(ctx->text.lt.info[line]);
1026: if (info->y >= y + height)
1027: break;
1028: (*(ctx->text.sink->resolve))(ctx,
1029: info->position, info->x,
1030: x - info->x, &pos1, &resultend);
1031: (*(ctx->text.sink->resolve))(ctx,
1032: info->position, info->x,
1033: x + width - info->x, &pos2,
1034: &resultend);
1035: pos2 = (*(ctx->text.source->scan))(ctx->text.source, pos2, XtstPositions,
1036: XtsdRight, 1, TRUE);
1037: _XtTextNeedsUpdating(ctx, pos1, pos2);
1038: line++;
1039: }
1040: _XtTextExecuteUpdate(ctx);
1041: }
1042:
1043:
1044: static int oldinsert = -1;
1045:
1046: /*
1047: * This routine does all setup required to syncronize batched screen updates
1048: */
1049: int _XtTextPrepareToUpdate(ctx)
1050: TextWidget ctx;
1051: {
1052: if (oldinsert < 0) {
1053: InsertCursor(ctx, XtisOff);
1054: ctx->text.numranges = 0;
1055: ctx->text.showposition = FALSE;
1056: oldinsert = ctx->text.insertPos;
1057: }
1058: }
1059:
1060:
1061: /*
1062: * This is a private utility routine used by _XtTextExecuteUpdate. It
1063: * processes all the outstanding update requests and merges update
1064: * ranges where possible.
1065: */
1066: static FlushUpdate(ctx)
1067: TextWidget ctx;
1068: {
1069: int i, w;
1070: XtTextPosition updateFrom, updateTo;
1071: while (ctx->text.numranges > 0) {
1072: updateFrom = ctx->text.updateFrom[0];
1073: w = 0;
1074: for (i=1 ; i<ctx->text.numranges ; i++) {
1075: if (ctx->text.updateFrom[i] < updateFrom) {
1076: updateFrom = ctx->text.updateFrom[i];
1077: w = i;
1078: }
1079: }
1080: updateTo = ctx->text.updateTo[w];
1081: ctx->text.numranges--;
1082: ctx->text.updateFrom[w] = ctx->text.updateFrom[ctx->text.numranges];
1083: ctx->text.updateTo[w] = ctx->text.updateTo[ctx->text.numranges];
1084: for (i=ctx->text.numranges-1 ; i>=0 ; i--) {
1085: while (ctx->text.updateFrom[i] <= updateTo && i < ctx->text.numranges) {
1086: updateTo = ctx->text.updateTo[i];
1087: ctx->text.numranges--;
1088: ctx->text.updateFrom[i] = ctx->text.updateFrom[ctx->text.numranges];
1089: ctx->text.updateTo[i] = ctx->text.updateTo[ctx->text.numranges];
1090: }
1091: }
1092: DisplayText(ctx, updateFrom, updateTo);
1093: }
1094: }
1095:
1096:
1097: /*
1098: * This is a private utility routine used by _XtTextExecuteUpdate. This routine
1099: * worries about edits causing new data or the insertion point becoming
1100: * invisible (off the screen). Currently it always makes it visible by
1101: * scrolling. It probably needs generalization to allow more options.
1102: */
1103: _XtTextShowPosition(ctx)
1104: TextWidget ctx;
1105: {
1106: XtTextPosition top, first, second;
1107: if (ctx->text.insertPos < ctx->text.lt.top ||
1108: ctx->text.insertPos >= ctx->text.lt.info[ctx->text.lt.lines].position) {
1109: if (ctx->text.lt.lines > 0 && (ctx->text.insertPos < ctx->text.lt.top
1110: || ctx->text.lt.info[ctx->text.lt.lines].position <= ctx->text.lastPos)) {
1111: first = ctx->text.lt.top;
1112: second = ctx->text.lt.info[1].position;
1113: if (ctx->text.insertPos < first)
1114: top = (*(ctx->text.source->scan))(
1115: ctx->text.source, ctx->text.insertPos, XtstEOL,
1116: XtsdLeft, 1, FALSE);
1117: else
1118: top = (*(ctx->text.source->scan))(
1119: ctx->text.source, ctx->text.insertPos, XtstEOL,
1120: XtsdLeft, ctx->text.lt.lines, FALSE);
1121: BuildLineTable(ctx, top);
1122: while (ctx->text.insertPos >= ctx->text.lt.info[ctx->text.lt.lines].position) {
1123: if (ctx->text.lt.info[ctx->text.lt.lines].position > ctx->text.lastPos)
1124: break;
1125: BuildLineTable(ctx, ctx->text.lt.info[1].position);
1126: }
1127: if (ctx->text.lt.top == second) {
1128: BuildLineTable(ctx, first);
1129: _XtTextScroll(ctx, 1);
1130: } else if (ctx->text.lt.info[1].position == first) {
1131: BuildLineTable(ctx, first);
1132: _XtTextScroll(ctx, -1);
1133: } else {
1134: ctx->text.numranges = 0;
1135: if (ctx->text.lt.top != first)
1136: DisplayTextWindow(ctx);
1137: }
1138: }
1139: }
1140: }
1141:
1142:
1143:
1144: /*
1145: * This routine causes all batched screen updates to be performed
1146: */
1147: _XtTextExecuteUpdate(ctx)
1148: TextWidget ctx;
1149: {
1150: if (oldinsert >= 0) {
1151: if (oldinsert != ctx->text.insertPos || ctx->text.showposition)
1152: _XtTextShowPosition(ctx);
1153: FlushUpdate(ctx);
1154: InsertCursor(ctx, XtisOn);
1155: oldinsert = -1;
1156: }
1157: }
1158:
1159:
1160: static void TextDestroy(ctx)
1161: TextWidget ctx;
1162: {
1163: if (ctx->text.dialog)
1164: (void) XtDestroyWidget(ctx->text.dialog);
1165: if (ctx->text.outer)
1166: (void) XtDestroyWidget(ctx->text.outer);
1167: if (ctx->text.sbar)
1168: (void) XtDestroyWidget(ctx->text.sbar);
1169: XtFree((char *)ctx->text.updateFrom);
1170: XtFree((char *)ctx->text.updateTo);
1171: }
1172:
1173:
1174: static void Resize(w)
1175: Widget w;
1176: {
1177: TextWidget ctx = (TextWidget) w;
1178: _XtTextPrepareToUpdate(ctx);
1179: ForceBuildLineTable(ctx);
1180: _XtTextExecuteUpdate(ctx);
1181: }
1182:
1183:
1184: /*
1185: * This routine allow the application program to Set attributes.
1186: */
1187:
1188: Boolean XtTextSetValues(current, request, new, last)
1189: Widget current, request, new;
1190: Boolean last;
1191: {
1192: TextWidget oldtw = (TextWidget) current;
1193: TextWidget newtw = (TextWidget) new;
1194: Boolean redisplay = FALSE;
1195:
1196: _XtTextPrepareToUpdate(oldtw);
1197:
1198: if (oldtw->text.sink != newtw->text.sink)
1199: redisplay = TRUE;
1200:
1201: if (oldtw->text.source != newtw->text.source) {
1202: ForceBuildLineTable(oldtw);
1203: redisplay = TRUE;
1204: }
1205: if (oldtw->text.insertPos != newtw->text.insertPos)
1206: oldtw->text.showposition = TRUE;
1207:
1208: if (oldtw->text.lt.top != newtw->text.lt.top)
1209: redisplay = TRUE;
1210:
1211: if (oldtw->text.leftmargin != newtw->text.leftmargin)
1212: redisplay = TRUE;
1213:
1214: if (redisplay)
1215: DisplayTextWindow(oldtw);
1216: _XtTextExecuteUpdate(oldtw);
1217: return (FALSE); /* this needs looking at! */
1218: }
1219:
1220:
1221:
1222: void XtTextDisplay (w)
1223: Widget w;
1224: {
1225: TextWidget ctx = (TextWidget) w;;
1226:
1227: _XtTextPrepareToUpdate(ctx);
1228: DisplayTextWindow(ctx);
1229: _XtTextExecuteUpdate(ctx);
1230: }
1231:
1232: /*******************************************************************
1233: The following routines provide procedural interfaces to Text window state
1234: setting and getting. They need to be redone so than the args code can use
1235: them. I suggest we create a complete set that takes the context as an
1236: argument and then have the public version lookup the context and call the
1237: internal one. The major value of this set is that they have actual application
1238: clients and therefore the functionality provided is required for any future
1239: version of Text.
1240: ********************************************************************/
1241:
1242: void XtTextSetSelectionArray(w, sarray)
1243: Widget w;
1244: XtSelectType *sarray;
1245: {
1246: TextWidget ctx = (TextWidget) w;
1247: XtSelectType *s2;
1248:
1249: s2 = ctx->text.sarray;
1250: while (XtselectNull != (*s2++ = *sarray++)) ;
1251: }
1252:
1253: void XtTextSetLastPos (w, lastPos)
1254: Widget w;
1255: XtTextPosition lastPos;
1256: {
1257: TextWidget ctx = (TextWidget) w;
1258:
1259: _XtTextPrepareToUpdate(ctx);
1260: (*(ctx->text.source->setLastPos))(ctx->text.source, lastPos);
1261: ctx->text.lastPos = GETLASTPOS;
1262: ForceBuildLineTable(ctx);
1263: DisplayTextWindow(ctx);
1264: _XtTextExecuteUpdate(ctx);
1265: }
1266:
1267:
1268: void XtTextGetSelectionPos(w, left, right)
1269: Widget w;
1270: XtTextPosition *left, *right;
1271: {
1272: TextWidget ctx = (TextWidget) w;
1273: *left = ctx->text.s.left;
1274: *right = ctx->text.s.right;
1275: }
1276:
1277:
1278: void XtTextNewSource(w, source, startPos)
1279: Widget w;
1280: XtTextSource *source;
1281: XtTextPosition startPos;
1282: {
1283: TextWidget ctx = (TextWidget) w;
1284:
1285: ctx->text.source = source;
1286: ctx->text.lt.top = startPos;
1287: ctx->text.s.left = ctx->text.s.right = 0;
1288: ctx->text.insertPos = startPos;
1289: ctx->text.lastPos = GETLASTPOS;
1290: ForceBuildLineTable(ctx);
1291: _XtTextPrepareToUpdate(ctx);
1292: DisplayTextWindow(ctx);
1293: _XtTextExecuteUpdate(ctx);
1294: }
1295:
1296: /*
1297: * This public routine deletes the text from startPos to endPos in a source and
1298: * then inserts, at startPos, the text that was passed. As a side effect it
1299: * "invalidates" that portion of the displayed text (if any), so that things
1300: * will be repainted properly.
1301: */
1302: int XtTextReplace(w, startPos, endPos, text)
1303: Widget w;
1304: XtTextPosition startPos, endPos;
1305: XtTextBlock *text;
1306: {
1307: TextWidget ctx = (TextWidget) w;
1308: int result;
1309: result = EDITERROR;
1310: _XtTextPrepareToUpdate(ctx);
1311: result = ReplaceText(ctx, startPos, endPos, text);
1312: _XtTextExecuteUpdate(ctx);
1313: return result;
1314: }
1315:
1316:
1317: XtTextPosition XtTextTopPosition(w)
1318: Widget w;
1319: {
1320: TextWidget ctx = (TextWidget) w;
1321:
1322: return ctx->text.lt.top;
1323: }
1324:
1325:
1326: void XtTextSetInsertionPoint(w, position)
1327: Widget w;
1328: XtTextPosition position;
1329: {
1330: TextWidget ctx = (TextWidget) w;
1331:
1332: _XtTextPrepareToUpdate(ctx);
1333: ctx->text.insertPos = position;
1334: ctx->text.showposition = TRUE;
1335: _XtTextExecuteUpdate(ctx);
1336: }
1337:
1338:
1339: XtTextPosition XtTextGetInsertionPoint(w)
1340: Widget w;
1341: {
1342: TextWidget ctx = (TextWidget) w;
1343:
1344: return(ctx->text.insertPos);
1345: }
1346:
1347:
1348: void XtTextUnsetSelection(w)
1349: Widget w;
1350: {
1351: TextWidget ctx = (TextWidget) w;
1352:
1353: _XtTextPrepareToUpdate(ctx);
1354: _XtTextSetNewSelection(ctx, zeroPosition, zeroPosition);
1355: _XtTextExecuteUpdate(ctx);
1356: }
1357:
1358:
1359: void XtTextChangeOptions(w, options)
1360: Widget w;
1361: int options;
1362: {
1363: TextWidget ctx = (TextWidget) w;
1364:
1365: ctx->text.options = options;
1366: }
1367:
1368:
1369: int XtTextGetOptions(w)
1370: Widget w;
1371: {
1372: TextWidget ctx = (TextWidget) w;
1373:
1374: return ctx->text.options;
1375: }
1376:
1377: void XtTextSetNewSelection (w, left, right)
1378: Widget w;
1379: XtTextPosition left, right;
1380: {
1381: TextWidget ctx = (TextWidget) w;
1382:
1383: _XtTextPrepareToUpdate(ctx);
1384: _XtTextSetNewSelection(ctx, left, right);
1385: _XtTextExecuteUpdate(ctx);
1386: }
1387:
1388: void XtTextInvalidate(w, from, to)
1389: Widget w;
1390: XtTextPosition from,to;
1391: {
1392: TextWidget ctx = (TextWidget) w;
1393:
1394: ctx->text.lastPos = (*(ctx->text.source->getLastPos))(ctx->text.source);
1395: _XtTextPrepareToUpdate(ctx);
1396: _XtTextNeedsUpdating(ctx, from, to);
1397: ForceBuildLineTable(ctx);
1398: _XtTextExecuteUpdate(ctx);
1399: }
1400:
1401:
1402: /* Returns the window actually containing the text (which is not the same
1403: as the given window if the text window has scrollbars.) */
1404:
1405: Window XtTextGetInnerWindow(w)
1406: Widget w;
1407: {
1408: TextWidget ctx = (TextWidget) w;
1409: return XtWindow(ctx);
1410: }
1411:
1412: /* The following used to be a separate file, TextActs.c, but
1413: is included here because textActionsTable can't be external
1414: to the file declaring textClassRec */
1415:
1416: /* Misc. routines */
1417: void TextAcceptFocus(w)
1418: Widget w;
1419: {
1420: TextWidget ctx = (TextWidget) w;
1421: if (!ctx->text.hasfocus)
1422: XSetInputFocus(XtDisplay(ctx), XtWindow(ctx),
1423: RevertToPointerRoot, CurrentTime);
1424: }
1425:
1426: static StartAction(ctx, event)
1427: TextWidget ctx;
1428: XEvent *event;
1429: {
1430: _XtTextPrepareToUpdate(ctx);
1431: if (event->type == ButtonPress) TextAcceptFocus(ctx);
1432: /* this code is wrong if actions bound to non-button events! */
1433: ctx->text.time = event->xbutton.time;
1434: ctx->text.ev_x = event->xbutton.x;
1435: ctx->text.ev_y = event->xbutton.y;
1436: }
1437:
1438: static EndAction(ctx)
1439: TextWidget ctx;
1440: {
1441: CheckResizeOrOverflow(ctx);
1442: _XtTextExecuteUpdate(ctx);
1443: }
1444:
1445: /*ARGSUSED*/
1446: static DoFeep(ctx)
1447: TextWidget ctx;
1448: {
1449: XBell(XtDisplay(ctx), 50);
1450: }
1451:
1452: static DeleteOrKill(ctx, from, to, kill)
1453: TextWidget ctx;
1454: XtTextPosition from, to;
1455: Boolean kill;
1456: {
1457: XtTextBlock text;
1458: char *ptr;
1459:
1460: if (kill && from < to) {
1461: ptr = _XtTextGetText(ctx, from, to);
1462: XStoreBuffer(XtDisplay(ctx), ptr, strlen(ptr), 1);
1463: XtFree(ptr);
1464: }
1465: text.length = 0;
1466: if (ReplaceText(ctx, from, to, &text)) {
1467: XBell(XtDisplay(ctx), 50);
1468: return;
1469: }
1470: _XtTextSetNewSelection(ctx, from, from);
1471: ctx->text.insertPos = from;
1472: ctx->text.showposition = TRUE;
1473: }
1474:
1475:
1476: StuffFromBuffer(ctx, buffer)
1477: TextWidget ctx;
1478: int buffer;
1479: {
1480: extern char *XFetchBuffer();
1481: XtTextBlock text;
1482: text.ptr = XFetchBuffer(XtDisplay(ctx), &(text.length), buffer);
1483: if (ReplaceText(ctx, ctx->text.insertPos, ctx->text.insertPos, &text)) {
1484: XBell(XtDisplay(ctx), 50);
1485: return;
1486: }
1487: ctx->text.insertPos = ctx->text.source->scan(ctx->text.source,
1488: ctx->text.insertPos, XtstPositions, XtsdRight, text.length, TRUE);
1489: _XtTextSetNewSelection(ctx, ctx->text.insertPos, ctx->text.insertPos);
1490: XtFree(text.ptr);
1491: }
1492:
1493:
1494: static UnKill(ctx, event)
1495: TextWidget ctx;
1496: XEvent *event;
1497: {
1498: StartAction(ctx, event);
1499: StuffFromBuffer(ctx, 1);
1500: EndAction(ctx);
1501: }
1502:
1503: static Stuff(ctx, event)
1504: TextWidget ctx;
1505: XEvent *event;
1506: {
1507: StartAction(ctx, event);
1508: StuffFromBuffer(ctx, 0);
1509: EndAction(ctx);
1510: }
1511:
1512:
1513: static XtTextPosition NextPosition(ctx, position, kind, direction)
1514: TextWidget ctx;
1515: XtTextPosition position;
1516: ScanType kind;
1517: ScanDirection direction;
1518: {
1519: XtTextPosition pos;
1520:
1521: pos = ctx->text.source->scan(
1522: ctx->text.source, position, kind, direction, 1, FALSE);
1523: if (pos == ctx->text.insertPos)
1524: pos = ctx->text.source->scan(
1525: ctx->text.source, position, kind, direction, 2, FALSE);
1526: return pos;
1527: }
1528:
1529: /* routines for moving around */
1530:
1531: static MoveForwardChar(ctx, event)
1532: TextWidget ctx;
1533: XEvent *event;
1534: {
1535: StartAction(ctx, event);
1536: ctx->text.insertPos = ctx->text.source->scan(
1537: ctx->text.source, ctx->text.insertPos, XtstPositions, XtsdRight, 1,
1538: TRUE);
1539: EndAction(ctx);
1540: }
1541:
1542: static MoveBackwardChar(ctx, event)
1543: TextWidget ctx;
1544: XEvent *event;
1545: {
1546: StartAction(ctx, event);
1547: ctx->text.insertPos = ctx->text.source->scan(
1548: ctx->text.source, ctx->text.insertPos, XtstPositions, XtsdLeft,
1549: 1, TRUE);
1550: EndAction(ctx);
1551: }
1552:
1553: static MoveForwardWord(ctx, event)
1554: TextWidget ctx;
1555: XEvent *event;
1556: {
1557: StartAction(ctx, event);
1558: ctx->text.insertPos = NextPosition(ctx, ctx->text.insertPos,
1559: XtstWhiteSpace, XtsdRight);
1560: EndAction(ctx);
1561: }
1562:
1563: static MoveBackwardWord(ctx, event)
1564: TextWidget ctx;
1565: XEvent *event;
1566: {
1567: StartAction(ctx, event);
1568: ctx->text.insertPos = NextPosition(ctx, ctx->text.insertPos,
1569: XtstWhiteSpace, XtsdLeft);
1570: EndAction(ctx);
1571: }
1572:
1573: static MoveBackwardParagraph(ctx, event)
1574: TextWidget ctx;
1575: XEvent *event;
1576: {
1577: StartAction(ctx, event);
1578: ctx->text.insertPos = NextPosition(ctx, ctx->text.insertPos,
1579: XtstEOL, XtsdLeft);
1580: EndAction(ctx);
1581: }
1582:
1583: static MoveForwardParagraph(ctx, event)
1584: TextWidget ctx;
1585: XEvent *event;
1586: {
1587: StartAction(ctx, event);
1588: ctx->text.insertPos = NextPosition(ctx, ctx->text.insertPos,
1589: XtstEOL, XtsdRight);
1590: EndAction(ctx);
1591: }
1592:
1593:
1594: static MoveToLineStart(ctx, event)
1595: TextWidget ctx;
1596: XEvent *event;
1597: {
1598: int line;
1599: StartAction(ctx, event);
1600: _XtTextShowPosition(ctx);
1601: line = LineForPosition(ctx, ctx->text.insertPos);
1602: ctx->text.insertPos = ctx->text.lt.info[line].position;
1603: EndAction(ctx);
1604: }
1605:
1606: static MoveToLineEnd(ctx, event)
1607: TextWidget ctx;
1608: XEvent *event;
1609: {
1610: int line;
1611: XtTextPosition next;
1612: StartAction(ctx, event);
1613: _XtTextShowPosition(ctx);
1614: line = LineForPosition(ctx, ctx->text.insertPos);
1615: next = ctx->text.lt.info[line+1].position;
1616: if (next > ctx->text.lastPos)
1617: next = ctx->text.lastPos;
1618: else
1619: next = ctx->text.source->scan(ctx->text.source, next, XtstPositions,
1620: XtsdLeft, 1, TRUE);
1621: ctx->text.insertPos = next;
1622: EndAction(ctx);
1623: }
1624:
1625:
1626: static int LineLastWidth = 0;
1627: static XtTextPosition LineLastPosition = 0;
1628:
1629: static MoveNextLine(ctx, event)
1630: TextWidget ctx;
1631: XEvent *event;
1632: {
1633: int width, width2, height, line;
1634: XtTextPosition position, maxp;
1635: StartAction(ctx, event);
1636: _XtTextShowPosition(ctx);
1637: line = LineForPosition(ctx, ctx->text.insertPos);
1638: if (line == ctx->text.lt.lines - 1) {
1639: _XtTextScroll(ctx, 1);
1640: line = LineForPosition(ctx, ctx->text.insertPos);
1641: }
1642: if (LineLastPosition == ctx->text.insertPos)
1643: width = LineLastWidth;
1644: else
1645: ctx->text.sink->findDistance(ctx,
1646: ctx->text.lt.info[line].position, ctx->text.lt.info[line].x,
1647: ctx->text.insertPos, &width, &position, &height);
1648: line++;
1649: if (ctx->text.lt.info[line].position > ctx->text.lastPos) {
1650: ctx->text.insertPos = ctx->text.lastPos;
1651: EndAction(ctx);
1652: return;
1653: }
1654: ctx->text.sink->findPosition(ctx,
1655: ctx->text.lt.info[line].position, ctx->text.lt.info[line].x,
1656: width, FALSE, &position, &width2, &height);
1657: maxp = ctx->text.source->scan(ctx->text.source,
1658: ctx->text.lt.info[line+1].position,
1659: XtstPositions, XtsdLeft, 1, TRUE);
1660: if (position > maxp)
1661: position = maxp;
1662: ctx->text.insertPos = position;
1663: LineLastWidth = width;
1664: LineLastPosition = position;
1665: EndAction(ctx);
1666: }
1667:
1668: static MovePreviousLine(ctx, event)
1669: TextWidget ctx;
1670: XEvent *event;
1671: {
1672: int width, width2, height, line;
1673: XtTextPosition position, maxp;
1674: StartAction(ctx, event);
1675: _XtTextShowPosition(ctx);
1676: line = LineForPosition(ctx, ctx->text.insertPos);
1677: if (line == 0) {
1678: _XtTextScroll(ctx, -1);
1679: line = LineForPosition(ctx, ctx->text.insertPos);
1680: }
1681: if (line > 0) {
1682: if (LineLastPosition == ctx->text.insertPos)
1683: width = LineLastWidth;
1684: else
1685: ctx->text.sink->findDistance(ctx,
1686: ctx->text.lt.info[line].position,
1687: ctx->text.lt.info[line].x,
1688: ctx->text.insertPos, &width, &position, &height);
1689: line--;
1690: ctx->text.sink->findPosition(ctx,
1691: ctx->text.lt.info[line].position, ctx->text.lt.info[line].x,
1692: width, FALSE, &position, &width2, &height);
1693: maxp = ctx->text.source->scan(ctx->text.source,
1694: ctx->text.lt.info[line+1].position,
1695: XtstPositions, XtsdLeft, 1, TRUE);
1696: if (position > maxp)
1697: position = maxp;
1698: ctx->text.insertPos = position;
1699: LineLastWidth = width;
1700: LineLastPosition = position;
1701: }
1702: EndAction(ctx);
1703: }
1704:
1705:
1706:
1707: static MoveBeginningOfFile(ctx, event)
1708: TextWidget ctx;
1709: XEvent *event;
1710: {
1711: StartAction(ctx, event);
1712: ctx->text.insertPos = ctx->text.source->scan(ctx->text.source,
1713: ctx->text.insertPos, XtstFile, XtsdLeft, 1, TRUE);
1714: EndAction(ctx);
1715: }
1716:
1717:
1718: static MoveEndOfFile(ctx, event)
1719: TextWidget ctx;
1720: XEvent *event;
1721: {
1722: StartAction(ctx, event);
1723: ctx->text.insertPos = ctx->text.source->scan(ctx->text.source,
1724: ctx->text.insertPos, XtstFile, XtsdRight, 1, TRUE);
1725: EndAction(ctx);
1726: }
1727:
1728: static ScrollOneLineUp(ctx, event)
1729: TextWidget ctx;
1730: XEvent *event;
1731: {
1732: StartAction(ctx, event);
1733: _XtTextScroll(ctx, 1);
1734: EndAction(ctx);
1735: }
1736:
1737: static ScrollOneLineDown(ctx, event)
1738: TextWidget ctx;
1739: XEvent *event;
1740: {
1741: StartAction(ctx, event);
1742: _XtTextScroll(ctx, -1);
1743: EndAction(ctx);
1744: }
1745:
1746: static MoveNextPage(ctx, event)
1747: TextWidget ctx;
1748: XEvent *event;
1749: {
1750: StartAction(ctx, event);
1751: _XtTextScroll(ctx, max(1, ctx->text.lt.lines - 2));
1752: ctx->text.insertPos = ctx->text.lt.top;
1753: EndAction(ctx);
1754: }
1755:
1756: static MovePreviousPage(ctx, event)
1757: TextWidget ctx;
1758: XEvent *event;
1759: {
1760: StartAction(ctx, event);
1761: _XtTextScroll(ctx, -max(1, ctx->text.lt.lines - 2));
1762: ctx->text.insertPos = ctx->text.lt.top;
1763: EndAction(ctx);
1764: }
1765:
1766:
1767:
1768:
1769: /* delete routines */
1770:
1771: static DeleteForwardChar(ctx, event)
1772: TextWidget ctx;
1773: XEvent *event;
1774: {
1775: XtTextPosition next;
1776:
1777: StartAction(ctx, event);
1778: next = ctx->text.source->scan(
1779: ctx->text.source, ctx->text.insertPos, XtstPositions,
1780: XtsdRight, 1, TRUE);
1781: DeleteOrKill(ctx, ctx->text.insertPos, next, FALSE);
1782: EndAction(ctx);
1783: }
1784:
1785: static DeleteBackwardChar(ctx, event)
1786: TextWidget ctx;
1787: XEvent *event;
1788: {
1789: XtTextPosition next;
1790:
1791: StartAction(ctx, event);
1792: next = ctx->text.source->scan(
1793: ctx->text.source, ctx->text.insertPos, XtstPositions,
1794: XtsdLeft, 1, TRUE);
1795: DeleteOrKill(ctx, next, ctx->text.insertPos, FALSE);
1796: EndAction(ctx);
1797: }
1798:
1799: static DeleteForwardWord(ctx, event)
1800: TextWidget ctx;
1801: XEvent *event;
1802: {
1803: XtTextPosition next;
1804:
1805: StartAction(ctx, event);
1806: next = NextPosition(ctx, ctx->text.insertPos, XtstWhiteSpace, XtsdRight);
1807: DeleteOrKill(ctx, ctx->text.insertPos, next, FALSE);
1808: EndAction(ctx);
1809: }
1810:
1811: static DeleteBackwardWord(ctx, event)
1812: TextWidget ctx;
1813: XEvent *event;
1814: {
1815: XtTextPosition next;
1816:
1817: StartAction(ctx, event);
1818: next = NextPosition(ctx, ctx->text.insertPos, XtstWhiteSpace, XtsdLeft);
1819: DeleteOrKill(ctx, next, ctx->text.insertPos, FALSE);
1820: EndAction(ctx);
1821: }
1822:
1823: static KillForwardWord(ctx, event)
1824: TextWidget ctx;
1825: XEvent *event;
1826: {
1827: XtTextPosition next;
1828:
1829: StartAction(ctx, event);
1830: next = NextPosition(ctx, ctx->text.insertPos, XtstWhiteSpace, XtsdRight);
1831: DeleteOrKill(ctx, ctx->text.insertPos, next, TRUE);
1832: EndAction(ctx);
1833: }
1834:
1835: static KillBackwardWord(ctx, event)
1836: TextWidget ctx;
1837: XEvent *event;
1838: {
1839: XtTextPosition next;
1840:
1841: StartAction(ctx, event);
1842: next = NextPosition(ctx, ctx->text.insertPos, XtstWhiteSpace, XtsdLeft);
1843: DeleteOrKill(ctx, next, ctx->text.insertPos, TRUE);
1844: EndAction(ctx);
1845: }
1846:
1847: static KillCurrentSelection(ctx, event)
1848: TextWidget ctx;
1849: XEvent *event;
1850: {
1851: StartAction(ctx, event);
1852: DeleteOrKill(ctx, ctx->text.s.left, ctx->text.s.right, TRUE);
1853: EndAction(ctx);
1854: }
1855:
1856: static DeleteCurrentSelection(ctx, event)
1857: TextWidget ctx;
1858: XEvent *event;
1859: {
1860: StartAction(ctx, event);
1861: DeleteOrKill(ctx, ctx->text.s.left, ctx->text.s.right, FALSE);
1862: EndAction(ctx);
1863: }
1864:
1865: static KillToEndOfLine(ctx, event)
1866: TextWidget ctx;
1867: XEvent *event;
1868: {
1869: int line;
1870: XtTextPosition last, next;
1871: StartAction(ctx, event);
1872: _XtTextShowPosition(ctx);
1873: line = LineForPosition(ctx, ctx->text.insertPos);
1874: last = ctx->text.lt.info[line + 1].position;
1875: next = ctx->text.source->scan(ctx->text.source, ctx->text.insertPos,
1876: XtstEOL, XtsdRight, 1, FALSE);
1877: if (last > ctx->text.lastPos)
1878: last = ctx->text.lastPos;
1879: if (last > next && ctx->text.insertPos < next)
1880: last = next;
1881: DeleteOrKill(ctx, ctx->text.insertPos, last, TRUE);
1882: EndAction(ctx);
1883: }
1884:
1885: static KillToEndOfParagraph(ctx, event)
1886: TextWidget ctx;
1887: XEvent *event;
1888: {
1889: XtTextPosition next;
1890:
1891: StartAction(ctx, event);
1892: next = ctx->text.source->scan(ctx->text.source, ctx->text.insertPos, XtstEOL, XtsdRight,
1893: 1, FALSE);
1894: if (next == ctx->text.insertPos)
1895: next = ctx->text.source->scan(ctx->text.source, next, XtstEOL, XtsdRight, 1, TRUE);
1896: DeleteOrKill(ctx, ctx->text.insertPos, next, TRUE);
1897: EndAction(ctx);
1898: }
1899:
1900: static int InsertNewLineAndBackup(ctx, event)
1901: TextWidget ctx;
1902: XEvent *event;
1903: {
1904: StartAction(ctx, event);
1905: InsertNewLineAndBackupInternal(ctx);
1906: EndAction(ctx);
1907: }
1908:
1909: static int InsertNewLineAndBackupInternal(ctx)
1910: TextWidget ctx;
1911: {
1912: XtTextBlock text;
1913: text.length = 1;
1914: text.ptr = "\n";
1915: text.firstPos = 0;
1916: if (ReplaceText(ctx, ctx->text.insertPos, ctx->text.insertPos, &text)) {
1917: XBell( XtDisplay(ctx), 50);
1918: return(EDITERROR);
1919: }
1920: _XtTextSetNewSelection(ctx, (XtTextPosition) 0, (XtTextPosition) 0);
1921: ctx->text.showposition = TRUE;
1922: return(EDITDONE);
1923: }
1924:
1925:
1926:
1927: static int InsertNewLine(ctx, event)
1928: TextWidget ctx;
1929: XEvent *event;
1930: {
1931: XtTextPosition next;
1932:
1933: StartAction(ctx, event);
1934: if (InsertNewLineAndBackupInternal(ctx))
1935: return(EDITERROR);
1936: next = ctx->text.source->scan(ctx->text.source, ctx->text.insertPos,
1937: XtstPositions, XtsdRight, 1, TRUE);
1938: ctx->text.insertPos = next;
1939: EndAction(ctx);
1940: return(EDITDONE);
1941: }
1942:
1943:
1944: static InsertNewLineAndIndent(ctx, event)
1945: TextWidget ctx;
1946: XEvent *event;
1947: {
1948: XtTextBlock text;
1949: XtTextPosition pos1, pos2;
1950:
1951: StartAction(ctx, event);
1952: pos1 = ctx->text.source->scan(ctx->text.source, ctx->text.insertPos,
1953: XtstEOL, XtsdLeft, 1, FALSE);
1954: pos2 = ctx->text.source->scan(ctx->text.source, pos1, XtstEOL,
1955: XtsdLeft, 1, TRUE);
1956: pos2 = ctx->text.source->scan(ctx->text.source, pos2, XtstWhiteSpace,
1957: XtsdRight, 1, TRUE);
1958: text.ptr = _XtTextGetText(ctx, pos1, pos2);
1959: text.length = strlen(text.ptr);
1960: if (InsertNewLine(ctx, event)) return;
1961: if (ReplaceText(ctx, ctx->text.insertPos, ctx->text.insertPos, &text)) {
1962: XBell(XtDisplay(ctx), 50);
1963: EndAction(ctx);
1964: return;
1965: }
1966: ctx->text.insertPos = ctx->text.source->scan(ctx->text.source,
1967: ctx->text.insertPos, XtstPositions, XtsdRight, text.length, TRUE);
1968: XtFree(text.ptr);
1969: EndAction(ctx);
1970: }
1971:
1972: static NewSelection(ctx, l, r)
1973: TextWidget ctx;
1974: XtTextPosition l, r;
1975: {
1976: char *ptr;
1977: _XtTextSetNewSelection(ctx, l, r);
1978: if (l < r) {
1979: ptr = _XtTextGetText(ctx, l, r);
1980: XStoreBuffer(XtDisplay(ctx), ptr, min(strlen(ptr), MAXCUT), 0);
1981: XtFree(ptr);
1982: }
1983: }
1984:
1985: static SelectWord(ctx, event)
1986: TextWidget ctx;
1987: XEvent *event;
1988: {
1989: XtTextPosition l, r;
1990: StartAction(ctx, event);
1991: l = ctx->text.source->scan(ctx->text.source, ctx->text.insertPos,
1992: XtstWhiteSpace, XtsdLeft, 1, FALSE);
1993: r = ctx->text.source->scan(ctx->text.source, l, XtstWhiteSpace,
1994: XtsdRight, 1, FALSE);
1995: NewSelection(ctx, l, r);
1996: EndAction(ctx);
1997: }
1998:
1999:
2000: static SelectAll(ctx, event)
2001: TextWidget ctx;
2002: XEvent *event;
2003: {
2004: StartAction(ctx, event);
2005: NewSelection(ctx, (XtTextPosition) 0, ctx->text.lastPos);
2006: EndAction(ctx);
2007: }
2008:
2009: static SelectStart(ctx, event)
2010: TextWidget ctx;
2011: XEvent *event;
2012: {
2013: StartAction(ctx, event);
2014: AlterSelection(ctx, XtsmTextSelect, XtactionStart);
2015: EndAction(ctx);
2016: }
2017:
2018: static SelectAdjust(ctx, event)
2019: TextWidget ctx;
2020: XEvent *event;
2021: {
2022: StartAction(ctx, event);
2023: AlterSelection(ctx, XtsmTextSelect, XtactionAdjust);
2024: EndAction(ctx);
2025: }
2026:
2027: static SelectEnd(ctx, event)
2028: TextWidget ctx;
2029: XEvent *event;
2030: {
2031: StartAction(ctx, event);
2032: AlterSelection(ctx, XtsmTextSelect, XtactionEnd);
2033: EndAction(ctx);
2034: }
2035:
2036: static ExtendStart(ctx, event)
2037: TextWidget ctx;
2038: XEvent *event;
2039: {
2040: StartAction(ctx, event);
2041: AlterSelection(ctx, XtsmTextExtend, XtactionStart);
2042: EndAction(ctx);
2043: }
2044:
2045: static ExtendAdjust(ctx, event)
2046: TextWidget ctx;
2047: XEvent *event;
2048: {
2049: StartAction(ctx, event);
2050: AlterSelection(ctx, XtsmTextExtend, XtactionAdjust);
2051: EndAction(ctx);
2052: }
2053:
2054: static ExtendEnd(ctx, event)
2055: TextWidget ctx;
2056: XEvent *event;
2057: {
2058: StartAction(ctx, event);
2059: AlterSelection(ctx, XtsmTextExtend, XtactionEnd);
2060: EndAction(ctx);
2061: }
2062:
2063:
2064: static RedrawDisplay(ctx, event)
2065: TextWidget ctx;
2066: XEvent *event;
2067: {
2068: StartAction(ctx, event);
2069: ForceBuildLineTable(ctx);
2070: DisplayTextWindow(ctx);
2071: EndAction(ctx);
2072: }
2073:
2074:
2075: _XtTextAbortDialog(ctx, event)
2076: TextWidget ctx;
2077: XEvent *event;
2078: {
2079: StartAction(ctx, event);
2080: if (ctx->text.dialog) {
2081: XtDestroyWidget(ctx->text.dialog);
2082: ctx->text.dialog = NULL;
2083: }
2084: EndAction(ctx);
2085: }
2086:
2087:
2088: /* Insert a file of the given name into the text. Returns 0 if file found,
2089: -1 if not. */
2090:
2091: static InsertFileNamed(ctx, str)
2092: TextWidget ctx;
2093: char *str;
2094: {
2095: int fid;
2096: XtTextBlock text;
2097: char buf[1000];
2098: XtTextPosition position;
2099:
2100: if (str == NULL || strlen(str) == 0) return -1;
2101: fid = open(str, O_RDONLY);
2102: if (fid <= 0) return -1;
2103: _XtTextPrepareToUpdate(ctx);
2104: position = ctx->text.insertPos;
2105: while ((text.length = read(fid, buf, 512)) > 0) {
2106: text.ptr = buf;
2107: (void) ReplaceText(ctx, position, position, &text);
2108: position = ctx->text.source->scan(ctx->text.source, position,
2109: XtstPositions, XtsdRight, text.length, TRUE);
2110: }
2111: (void) close(fid);
2112: ctx->text.insertPos = position;
2113: _XtTextExecuteUpdate(ctx);
2114: return 0;
2115: }
2116:
2117: static DoInsert(ctx)
2118: TextWidget ctx;
2119: {
2120: /* can't do dialog boxes yet
2121: if (InsertFileNamed(ctx, XtDialogGetValueString(XtDisplay(ctx), ctx->text.dialog)))
2122: XBell(XtDisplay(ctx), 50);
2123: else
2124: _XtTextAbortDialog(ctx);
2125: */
2126: }
2127:
2128: static TextFocusIn (ctx, event)
2129: TextWidget ctx;
2130: XEvent *event;
2131: { ctx->text.hasfocus = TRUE; }
2132:
2133: static void TextFocusOut(ctx, event)
2134: TextWidget ctx;
2135: XEvent *event;
2136: { ctx->text.hasfocus = FALSE; }
2137:
2138: #define STRBUFSIZE 100
2139:
2140: static XComposeStatus compose_status = {NULL, 0};
2141: static InsertChar(ctx, event)
2142: TextWidget ctx;
2143: XEvent *event;
2144: {
2145: char strbuf[STRBUFSIZE];
2146: int keycode;
2147: XtTextBlock text;
2148: text.length = XLookupString (event, strbuf, STRBUFSIZE,
2149: &keycode, &compose_status);
2150: if (text.length==0) return;
2151: StartAction(ctx, event);
2152: text.ptr = &strbuf[0];;
2153: text.firstPos = 0;
2154: if (ReplaceText(ctx, ctx->text.insertPos, ctx->text.insertPos, &text)) {
2155: XBell(XtDisplay(ctx), 50);
2156: EndAction(ctx);
2157: return;
2158: }
2159: ctx->text.insertPos =
2160: (*(ctx->text.source->scan))(ctx->text.source, ctx->text.insertPos,
2161: XtstPositions, XtsdRight, text.length, TRUE);
2162: _XtTextSetNewSelection(ctx, ctx->text.insertPos, ctx->text.insertPos);
2163:
2164: EndAction(ctx);
2165: }
2166:
2167: static InsertFile(ctx, event)
2168: TextWidget ctx;
2169: XEvent *event;
2170: {
2171: char *ptr;
2172: XtTextBlock text;
2173:
2174: /* this depends on dialog boxes...
2175:
2176: StartAction(ctx, event);
2177: if (ctx->text.source->editType(ctx->text.source) != XttextEdit) {
2178: XBell(XtDisplay(ctx), 50);
2179: EndAction(ctx);
2180: return;
2181: }
2182: if (ctx->text.s.left < ctx->text.s.right) {
2183: ptr = _XtTextGetText(ctx, ctx->text.s.left, ctx->text.s.right);
2184: DeleteCurrentSelection(ctx);
2185: if (InsertFileNamed(ctx, ptr)) {
2186: XBell( XtDisplay(ctx), 50);
2187: text.ptr = ptr;
2188: text.length = strlen(ptr);
2189: (void) ReplaceText(ctx, ctx->text.insertPos, ctx->text.insertPos, &text);
2190: ctx->text.s.left = ctx->text.insertPos;
2191: ctx->text.s.right = ctx->text.insertPos =
2192: ctx->text.source->scan(ctx->text.source, ctx->text.insertPos,
2193: XtstPositions, XtsdRight, text.length, TRUE);
2194: }
2195: XtFree(ptr);
2196: EndAction(ctx);
2197: return;
2198: }
2199: if (ctx->text.dialog)
2200: _XtTextAbortDialog(ctx);
2201: ctx->text.dialog = XtDialogCreate( XtDisplay(ctx), ctx->text.w, "Insert File:", "", (ArgList)NULL, 0);
2202: XtDialogAddButton( XtDisplay(ctx), ctx->text.dialog, "Abort", _XtTextAbortDialog, (caddr_t)ctx);
2203: XtDialogAddButton( XtDisplay(ctx), ctx->text.dialog, "DoIt", DoInsert, (caddr_t)ctx);
2204: XMapWindow( XtDisplay(ctx), ctx->text.dialog);
2205: EndAction(ctx);
2206: */
2207: }
2208:
2209: /* Actions Table */
2210:
2211: XtActionsRec textActionsTable [] = {
2212: /* motion bindings */
2213: {"forward-character", (caddr_t)MoveForwardChar},
2214: {"backward-character", (caddr_t)MoveBackwardChar},
2215: {"forward-word", (caddr_t)MoveForwardWord},
2216: {"backward-word", (caddr_t)MoveBackwardWord},
2217: {"forward-paragraph", (caddr_t)MoveForwardParagraph},
2218: {"backward-paragraph", (caddr_t)MoveBackwardParagraph},
2219: {"beginning-of-line", (caddr_t)MoveToLineStart},
2220: {"end-of-line", (caddr_t)MoveToLineEnd},
2221: {"next-line", (caddr_t)MoveNextLine},
2222: {"previous-line", (caddr_t)MovePreviousLine},
2223: {"next-page", (caddr_t)MoveNextPage},
2224: {"previous-page", (caddr_t)MovePreviousPage},
2225: {"beginning-of-file", (caddr_t)MoveBeginningOfFile},
2226: {"end-of-file", (caddr_t)MoveEndOfFile},
2227: {"scroll-one-line-up", (caddr_t)ScrollOneLineUp},
2228: {"scroll-one-line-down", (caddr_t)ScrollOneLineDown},
2229: /* delete bindings */
2230: {"delete-next-character", (caddr_t)DeleteForwardChar},
2231: {"delete-previous-character", (caddr_t)DeleteBackwardChar},
2232: {"delete-next-word", (caddr_t)DeleteForwardWord},
2233: {"delete-previous-word", (caddr_t)DeleteBackwardWord},
2234: {"delete-selection", (caddr_t)DeleteCurrentSelection},
2235: /* kill bindings */
2236: {"kill-word", (caddr_t)KillForwardWord},
2237: {"backward-kill-word", (caddr_t)KillBackwardWord},
2238: {"kill-selection", (caddr_t)KillCurrentSelection},
2239: {"kill-to-end-of-line", (caddr_t)KillToEndOfLine},
2240: {"kill-to-end-of-paragraph", (caddr_t)KillToEndOfParagraph},
2241: /* unkill bindings */
2242: {"unkill", (caddr_t)UnKill},
2243: {"stuff", (caddr_t)Stuff},
2244: /* new line stuff */
2245: {"newline-and-indent", (caddr_t)InsertNewLineAndIndent},
2246: {"newline-and-backup", (caddr_t)InsertNewLineAndBackup},
2247: {"newline", (caddr_t)InsertNewLine},
2248: /* Selection stuff */
2249: {"select-word", (caddr_t)SelectWord},
2250: {"select-all", (caddr_t)SelectAll},
2251: {"select-start", (caddr_t)SelectStart},
2252: {"select-adjust", (caddr_t)SelectAdjust},
2253: {"select-end", (caddr_t)SelectEnd},
2254: {"extend-start", (caddr_t)ExtendStart},
2255: {"extend-adjust", (caddr_t)ExtendAdjust},
2256: {"extend-end", (caddr_t)ExtendEnd},
2257: /* Miscellaneous */
2258: {"redraw-display", (caddr_t)RedrawDisplay},
2259: {"insert-file", (caddr_t)InsertFile},
2260: {"insert-char", (caddr_t)InsertChar},
2261: {"focus-in", (caddr_t)TextFocusIn},
2262: {"focus-out", (caddr_t)TextFocusOut},
2263: {NULL,NULL}
2264: };
2265:
2266: static char *defaultTextEventBindings[] = {
2267: /* motion bindings */
2268: "Ctrl<Key>F: forward-character()",
2269: "<Key>0xff53: forward-character()",
2270: "Ctrl<Key>B: backward-character()",
2271: "<Key>0xff51: backward-character()",
2272: "Meta<Key>F: forward-word()",
2273: "Meta<Key>B: backward-word()",
2274: "Meta<Key>]: forward-paragraph()",
2275: "Ctrl<Key>[: backward-paragraph()",
2276: "Ctrl<Key>A: beginning-of-line()",
2277: "Ctrl<Key>E: end-of-line()",
2278: "Ctrl<Key>N: next-line()",
2279: "<Key>0xff54: next-line()",
2280: "Ctrl<Key>P: previous-line()",
2281: "<Key>0xff52: previous-line()",
2282: "Ctrl<Key>V: next-page()",
2283: "Meta<Key>V: previous-page()",
2284: "Meta<Key>\\<: beginning-of-file()",
2285: "Meta<Key>\\>: end-of-file()",
2286: "Ctrl<Key>Z: scroll-one-line-up()",
2287: "Meta<Key>Z: scroll-one-line-down()",
2288: /* delete binding*/
2289: "Ctrl<Key>D: delete-next-character()",
2290: "Ctrl<Key>H: delete-previous-character()",
2291: "<Key>0xff7f: delete-previous-character()",
2292: "<Key>0xffff: delete-previous-character()",
2293: "<Key>0xff08: delete-previous-character()",
2294: "Meta<Key>D: delete-next-word()",
2295: "Meta<Key>H: delete-previous-word()",
2296: /* kill bindings */
2297: "Shift Meta<Key>D: kill-word()",
2298: "Shift Meta<Key>H: backward-kill-word()",
2299: "Ctrl<Key>W: kill-selection()",
2300: "Ctrl<Key>K: kill-to-end-of-line()",
2301: "Meta<Key>K: kill-to-end-of-paragraph()",
2302: /* unkill bindings */
2303: "Ctrl<Key>Y: unkill()",
2304: "Meta<Key>Y: stuff()",
2305: /* new line stuff */
2306: "Ctrl<Key>J: newline-and-indent()",
2307: "<Key>0xff0a: newline-and-indent()",
2308: "Ctrl<Key>O: newline-and-backup()",
2309: "Ctrl<Key>M: newline()",
2310: "<Key>0xff0d: newline()",
2311: /* Miscellaneous */
2312: "Ctrl<Key>L: redraw-display()",
2313: "Meta<Key>I: insert-file()",
2314: "<FocusIn>: focus-in()",
2315: "<FocusOut>: focus-out()",
2316: /* selection stuff */
2317: "<Btn1Down>: select-start()",
2318: "Button1<PtrMoved>: extend-adjust()",
2319: "<Btn1Up>: extend-end()",
2320: "<Btn2Down>: stuff()",
2321: "<Btn3Down>: extend-start()",
2322: "Button3<PtrMoved>: extend-adjust()",
2323: "<Btn3Up>: extend-end()",
2324: /* default character handling */
2325: "<Key>: insert-char()",
2326:
2327: NULL
2328: };
2329:
2330: /* grodyness needed because Xrm wants pointer to thing, not thing... */
2331: caddr_t defaultTextTranslations = (caddr_t)defaultTextEventBindings;
2332:
2333: TextClassRec textClassRec = {
2334: /* core fields */
2335: /* superclass */ (WidgetClass) &widgetClassRec,
2336: /* class_name */ "Text",
2337: /* widget_size */ sizeof(TextRec),
2338: /* class_initialize */ NULL,
2339: /* class_inited */ FALSE,
2340: /* initialize */ Initialize,
2341: /* realize */ Realize,
2342: /* actions */ textActionsTable,
2343: /* num_actions */ XtNumber(textActionsTable),
2344: /* resources */ resources,
2345: /* num_ resource */ XtNumber(resources),
2346: /* xrm_class */ NULLQUARK,
2347: /* compress_motion */ TRUE,
2348: /* compress_exposure */ FALSE,
2349: /* visible_interest */ FALSE,
2350: /* destroy */ TextDestroy,
2351: /* resize */ Resize,
2352: /* expose */ ProcessExposeRegion,
2353: /* set_values */ XtTextSetValues,
2354: /* accept_focus */ TextAcceptFocus,
2355: };
2356:
2357: WidgetClass textWidgetClass = (WidgetClass)&textClassRec;
2358:
2359:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.