Debian Codegraph @

src/Text.c

raw
1 /***********************************************************
2
3 Copyright 1987, 1988, 1994, 1998 The Open Group
4
5 Permission to use, copy, modify, distribute, and sell this software and its
6 documentation for any purpose is hereby granted without fee, provided that
7 the above copyright notice appear in all copies and that both that
8 copyright notice and this permission notice appear in supporting
9 documentation.
10
11 The above copyright notice and this permission notice shall be included in
12 all copies or substantial portions of the Software.
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20
21 Except as contained in this notice, the name of The Open Group shall not be
22 used in advertising or otherwise to promote the sale, use or other dealings
23 in this Software without prior written authorization from The Open Group.
24
25
26 Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
27
28 All Rights Reserved
29
30 Permission to use, copy, modify, and distribute this software and its
31 documentation for any purpose and without fee is hereby granted,
32 provided that the above copyright notice appear in all copies and that
33 both that copyright notice and this permission notice appear in
34 supporting documentation, and that the name of Digital not be
35 used in advertising or publicity pertaining to distribution of the
36 software without specific, written prior permission.
37
38 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
39 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
40 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
41 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
42 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
43 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
44 SOFTWARE.
45
46 ******************************************************************/
47
48 /*
49 * Copyright (c) 1998 by The XFree86 Project, Inc.
50 *
51 * Permission is hereby granted, free of charge, to any person obtaining a
52 * copy of this software and associated documentation files (the "Software"),
53 * to deal in the Software without restriction, including without limitation
54 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
55 * and/or sell copies of the Software, and to permit persons to whom the
56 * Software is furnished to do so, subject to the following conditions:
57 *
58 * The above copyright notice and this permission notice shall be included in
59 * all copies or substantial portions of the Software.
60 *
61 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
62 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
63 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
64 * THE XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
65 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
66 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
67 * SOFTWARE.
68 *
69 * Except as contained in this notice, the name of the XFree86 Project shall
70 * not be used in advertising or otherwise to promote the sale, use or other
71 * dealings in this Software without prior written authorization from the
72 * XFree86 Project.
73 */
74
75 #ifdef HAVE_CONFIG_H
76 #include <config.h>
77 #endif
78 #include <stdio.h>
79 #include <X11/IntrinsicP.h>
80 #include <X11/StringDefs.h>
81 #include <X11/Shell.h>
82 #include <X11/Xatom.h>
83 #include <X11/Xfuncs.h>
84 #include <X11/Xutil.h>
85 #include <X11/Xmu/Misc.h>
86 #include <X11/Xmu/Xmu.h>
87 #include <X11/Xaw/Cardinals.h>
88 #include <X11/Xaw/MultiSinkP.h>
89 #include <X11/Xaw/TextP.h>
90 #include <X11/Xaw/TextSrcP.h>
91 #include <X11/Xaw/TextSinkP.h>
92 #include <X11/Xaw/Scrollbar.h>
93 #include <X11/Xaw/XawImP.h>
94 #include <X11/Xaw/XawInit.h>
95 #include "Private.h"
96 #include "XawI18n.h"
97
98 #ifndef MAX_LEN_CT
99 #define MAX_LEN_CT 6 /* for sequence: ESC $ ( A \xx \xx */
100 #endif
101
102 unsigned long FMT8BIT = 0L;
103 unsigned long XawFmt8Bit = 0L;
104 unsigned long XawFmtWide = 0L;
105
106 #define SinkClearToBG _XawTextSinkClearToBackground
107
108 #define SrcScan XawTextSourceScan
109 #define SrcRead XawTextSourceRead
110 #define SrcReplace XawTextSourceReplace
111 #define SrcSearch XawTextSourceSearch
112 #define SrcCvtSel XawTextSourceConvertSelection
113 #define SrcSetSelection XawTextSourceSetSelection
114
115 #define MULTI_CLICK_TIME 500L
116
117 #define SRC_CHANGE_NONE 0
118 #define SRC_CHANGE_AFTER 1
119 #define SRC_CHANGE_BEFORE 2
120 #define SRC_CHANGE_OVERLAP 3
121
122 #define Superclass (&simpleClassRec)
123
124 /*
125 * Compute a the maximum length of a cut buffer that we can pass at any
126 * time. The 64 allows for the overhead of the Change Property request.
127 */
128 #define MAX_CUT_LEN(dpy) (XMaxRequestSize(dpy) - 64)
129
130 #define ClearWindow(ctx) \
131 _XawTextNeedsUpdating((ctx), \
132 (ctx)->text.lt.top, \
133 (ctx)->text.lt.info[ctx->text.lt.lines].position)
134
135 /*
136 * Class Methods
137 */
138 static void XawTextClassInitialize(void);
139 static void XawTextInitialize(Widget, Widget, ArgList, Cardinal*);
140 static void XawTextRealize(Widget, XtValueMask*, XSetWindowAttributes*);
141 static void XawTextDestroy(Widget);
142 static void XawTextResize(Widget);
143 static void XawTextExpose(Widget, XEvent*, Region);
144 static Boolean XawTextSetValues(Widget, Widget, Widget, ArgList, Cardinal*);
145 static void XawTextGetValuesHook(Widget, ArgList, Cardinal*);
146 static Bool XawTextChangeSensitive(Widget);
147
148 /*
149 * Prototypes
150 */
151 static XawTextPosition _BuildLineTable(TextWidget, XawTextPosition, int);
152 static void _CreateCutBuffers(Display*);
153 static Boolean TextConvertSelection(Widget, Atom*, Atom*, Atom*, XtPointer*,
154 unsigned long*, int*);
155 static int CountLines(TextWidget, XawTextPosition, XawTextPosition);
156 static void CreateHScrollBar(TextWidget);
157 static void CreateVScrollBar(TextWidget);
158 static void CvtStringToScrollMode(XrmValuePtr, Cardinal*,
159 XrmValuePtr, XrmValuePtr);
160 static Boolean CvtScrollModeToString(Display*, XrmValue*, Cardinal*,
161 XrmValue*, XrmValue*, XtPointer*);
162 static void CvtStringToWrapMode(XrmValuePtr, Cardinal*,
163 XrmValuePtr, XrmValuePtr);
164 static Boolean CvtWrapModeToString(Display*, XrmValue*, Cardinal*,
165 XrmValue*, XrmValue*, XtPointer*);
166 static Boolean CvtStringToJustifyMode(Display*, XrmValue*, Cardinal*,
167 XrmValue*, XrmValue*, XtPointer*);
168 static Boolean CvtJustifyModeToString(Display*, XrmValue*, Cardinal*,
169 XrmValue*, XrmValue*, XtPointer*);
170 static void DestroyHScrollBar(TextWidget);
171 static void DestroyVScrollBar(TextWidget);
172 #ifndef OLDXAW
173 static void DisplayText(Widget, XawTextPosition, XawTextPosition);
174 #endif
175 static void OldDisplayText(Widget, XawTextPosition, XawTextPosition);
176 static void DisplayTextWindow(Widget);
177 static void DoCopyArea(TextWidget, int, int, unsigned int, unsigned int,
178 int, int);
179 static void DoSelection(TextWidget, XawTextPosition, Time, Bool);
180 static void ExtendSelection(TextWidget, XawTextPosition, Bool);
181 static XawTextPosition FindGoodPosition(TextWidget, XawTextPosition);
182 static void FlushUpdate(TextWidget);
183 static int GetCutBufferNumber(Atom);
184 static int GetMaxTextWidth(TextWidget);
185 static unsigned int GetWidestLine(TextWidget);
186 static void HScroll(Widget, XtPointer, XtPointer);
187 static void HJump(Widget, XtPointer, XtPointer);
188 static void InsertCursor(Widget, XawTextInsertState);
189 static Bool LineAndXYForPosition(TextWidget, XawTextPosition, int*,
190 int*, int*);
191 static int LineForPosition(TextWidget, XawTextPosition);
192 static void TextLoseSelection(Widget, Atom*);
193 static Bool MatchSelection(Atom, XawTextSelection*);
194 static void ModifySelection(TextWidget, XawTextPosition, XawTextPosition);
195 static XawTextPosition PositionForXY(TextWidget, int, int);
196 static void PositionHScrollBar(TextWidget);
197 static void PositionVScrollBar(TextWidget);
198 #ifndef OLDXAW
199 static int ResolveColumnNumber(TextWidget);
200 static int ResolveLineNumber(TextWidget);
201 #endif
202 static void _SetSelection(TextWidget, XawTextPosition, XawTextPosition,
203 Atom*, Cardinal);
204 static void TextSinkResize(Widget);
205 static void UpdateTextInRectangle(TextWidget, XRectangle*);
206 static void UpdateTextInLine(TextWidget, int, int, int);
207 static void VScroll(Widget, XtPointer, XtPointer);
208 static void VJump(Widget, XtPointer, XtPointer);
209
210 /*
211 * External
212 */
213 void _XawTextAlterSelection(TextWidget,
214 XawTextSelectionMode, XawTextSelectionAction,
215 String*, Cardinal*);
216 void _XawTextCheckResize(TextWidget);
217 void _XawTextClearAndCenterDisplay(TextWidget);
218 void _XawTextExecuteUpdate(TextWidget);
219 char *_XawTextGetText(TextWidget, XawTextPosition, XawTextPosition);
220 void _XawTextPrepareToUpdate(TextWidget);
221 int _XawTextReplace(TextWidget, XawTextPosition, XawTextPosition,
222 XawTextBlock*);
223 Atom *_XawTextSelectionList(TextWidget, String*, Cardinal);
224 void _XawTextSetScrollBars(TextWidget);
225 void _XawTextSetSelection(TextWidget, XawTextPosition, XawTextPosition,
226 String*, Cardinal);
227 void _XawTextVScroll(TextWidget, int);
228 void XawTextScroll(TextWidget, int, int);
229 void _XawTextSetSource(Widget, Widget, XawTextPosition, XawTextPosition);
230 #ifndef OLDXAW
231 void _XawTextSetLineAndColumnNumber(TextWidget, Bool);
232 #endif
233 void _XawTextSourceChanged(Widget, XawTextPosition, XawTextPosition,
234 XawTextBlock*, int);
235
236 /* Not used by other modules, but were extern on previous versions
237 * of the library
238 */
239 void _XawTextShowPosition(TextWidget);
240
241 /*
242 * From TextAction.c
243 */
244 extern void _XawTextZapSelection(TextWidget, XEvent*, Bool);
245
246 /*
247 * From TextSrc.c
248 */
249 void _XawSourceAddText(Widget, Widget);
250 void _XawSourceRemoveText(Widget, Widget, Bool);
251 Bool _XawTextSourceNewLineAtEOF(Widget);
252
253 /*
254 * From TextSink.c
255 */
256 void _XawTextSinkClearToBackground(Widget, int, int, unsigned, unsigned);
257 void _XawTextSinkDisplayText(Widget, int, int, XawTextPosition, XawTextPosition,
258 Bool);
259
260 /****************************************************************
261 *
262 * Full class record constant
263 *
264 ****************************************************************/
265 /*
266 * From TextTr.c
267 */
268 static XawTextSelectType defaultSelectTypes[] = {
269 XawselectPosition, XawselectAlphaNumeric, XawselectWord, XawselectLine,
270 XawselectParagraph, XawselectAll, XawselectNull,
271 };
272
273 static XPointer defaultSelectTypesPtr = (XPointer)defaultSelectTypes;
274 static Dimension defWidth = 100;
275 static Dimension defHeight = DEFAULT_TEXT_HEIGHT;
276
277 #define offset(field) XtOffsetOf(TextRec, field)
278 static XtResource resources[] = {
279 {
280 XtNwidth,
281 XtCWidth,
282 XtRDimension,
283 sizeof(Dimension),
284 offset(core.width),
285 XtRDimension,
286 (XtPointer)&defWidth
287 },
288 {
289 XtNcursor,
290 XtCCursor,
291 XtRCursor,
292 sizeof(Cursor),
293 offset(simple.cursor),
294 XtRString,
295 (XtPointer)"xterm"
296 },
297 {
298 XtNheight,
299 XtCHeight,
300 XtRDimension,
301 sizeof(Dimension),
302 offset(core.height),
303 XtRDimension,
304 (XtPointer)&defHeight
305 },
306 {
307 XtNdisplayPosition,
308 XtCTextPosition,
309 XtRInt,
310 sizeof(XawTextPosition),
311 offset(text.lt.top),
312 XtRImmediate,
313 (XtPointer)0
314 },
315 {
316 XtNinsertPosition,
317 XtCTextPosition,
318 XtRInt,
319 sizeof(XawTextPosition),
320 offset(text.insertPos),
321 XtRImmediate,
322 (XtPointer)0
323 },
324 {
325 XtNleftMargin,
326 XtCMargin,
327 XtRPosition,
328 sizeof(Position),
329 offset(text.r_margin.left),
330 XtRImmediate,
331 (XtPointer)2
332 },
333 {
334 XtNrightMargin,
335 XtCMargin,
336 XtRPosition,
337 sizeof(Position),
338 offset(text.r_margin.right),
339 XtRImmediate,
340 (XtPointer)4
341 },
342 {
343 XtNtopMargin,
344 XtCMargin,
345 XtRPosition,
346 sizeof(Position),
347 offset(text.r_margin.top),
348 XtRImmediate,
349 (XtPointer)2
350 },
351 {
352 XtNbottomMargin,
353 XtCMargin,
354 XtRPosition,
355 sizeof(Position),
356 offset(text.r_margin.bottom),
357 XtRImmediate,
358 (XtPointer)2
359 },
360 {
361 XtNselectTypes,
362 XtCSelectTypes,
363 XtRPointer,
364 sizeof(XawTextSelectType*),
365 offset(text.sarray),
366 XtRPointer,
367 (XtPointer)&defaultSelectTypesPtr
368 },
369 {
370 XtNtextSource,
371 XtCTextSource,
372 XtRWidget,
373 sizeof(Widget),
374 offset(text.source),
375 XtRImmediate,
376 NULL
377 },
378 {
379 XtNtextSink,
380 XtCTextSink,
381 XtRWidget,
382 sizeof(Widget),
383 offset(text.sink),
384 XtRImmediate,
385 NULL
386 },
387 {
388 XtNdisplayCaret,
389 XtCOutput,
390 XtRBoolean,
391 sizeof(Boolean),
392 offset(text.display_caret),
393 XtRImmediate,
394 (XtPointer)True
395 },
396 {
397 XtNscrollVertical,
398 XtCScroll,
399 XtRScrollMode,
400 sizeof(XawTextScrollMode),
401 offset(text.scroll_vert),
402 XtRImmediate,
403 (XtPointer)False
404 },
405 {
406 XtNscrollHorizontal,
407 XtCScroll,
408 XtRScrollMode,
409 sizeof(XawTextScrollMode),
410 offset(text.scroll_horiz),
411 XtRImmediate,
412 (XtPointer)False
413 },
414 {
415 XtNwrap,
416 XtCWrap,
417 XtRWrapMode,
418 sizeof(XawTextWrapMode),
419 offset(text.wrap),
420 XtRImmediate,
421 (XtPointer)XawtextWrapNever
422 },
423 {
424 XtNautoFill,
425 XtCAutoFill,
426 XtRBoolean,
427 sizeof(Boolean),
428 offset(text.auto_fill),
429 XtRImmediate,
430 (XtPointer)False
431 },
432 #ifndef OLDXAW
433 {
434 XtNpositionCallback,
435 XtCCallback,
436 XtRCallback,
437 sizeof(XtPointer),
438 offset(text.position_callbacks),
439 XtRCallback,
440 NULL
441 },
442 {
443 XtNleftColumn,
444 XtCColumn,
445 XtRShort,
446 sizeof(short),
447 offset(text.left_column),
448 XtRImmediate,
449 (XtPointer)0
450 },
451 {
452 XtNrightColumn,
453 XtCColumn,
454 XtRShort,
455 sizeof(short),
456 offset(text.right_column),
457 XtRImmediate,
458 (XtPointer)0
459 },
460 {
461 XtNjustifyMode,
462 XtCJustifyMode,
463 XtRJustifyMode,
464 sizeof(XawTextJustifyMode),
465 offset(text.justify),
466 XtRImmediate,
467 (XtPointer)XawjustifyLeft
468 },
469 #endif /* OLDXAW */
470 };
471 #undef offset
472
473 #define done(address, type) \
474 { toVal->size = sizeof(type); toVal->addr = (XPointer)address; }
475
476 static XrmQuark QWrapNever, QWrapLine, QWrapWord;
477 static XrmQuark QScrollNever, QScrollWhenNeeded, QScrollAlways;
478 static XrmQuark QJustifyLeft, QJustifyRight, QJustifyCenter, QJustifyFull;
479
480 /*ARGSUSED*/
481 static void
482 CvtStringToScrollMode(XrmValuePtr args _X_UNUSED, Cardinal *num_args _X_UNUSED,
483 XrmValuePtr fromVal, XrmValuePtr toVal)
484 {
485 static XawTextScrollMode scrollMode = XawtextScrollNever;
486 XrmQuark q;
487 char name[32];
488
489 XmuNCopyISOLatin1Lowered(name, (char *)fromVal->addr, sizeof(name));
490 q = XrmStringToQuark(name);
491
492 if (q == QScrollNever || q == QScrollWhenNeeded)
493 scrollMode = XawtextScrollNever;
494 else if (q == QScrollAlways)
495 scrollMode = XawtextScrollAlways;
496 else if (strcmp(name, "true") == 0 || strcmp(name, "1") == 0)
497 scrollMode = XawtextScrollAlways;
498 else if (strcmp(name, "false") == 0 || strcmp(name, "0") == 0)
499 scrollMode = XawtextScrollNever;
500 else
501 XtStringConversionWarning((char *)fromVal->addr, XtRScrollMode);
502
503 done(&scrollMode, XawTextScrollMode);
504 }
505
506 /*ARGSUSED*/
507 static Boolean
508 CvtScrollModeToString(Display *dpy, XrmValue *args _X_UNUSED, Cardinal *num_args _X_UNUSED,
509 XrmValue *fromVal, XrmValue *toVal _X_UNUSED, XtPointer *data _X_UNUSED)
510 {
511 static String buffer;
512 Cardinal size;
513
514 switch (*(XawTextScrollMode *)fromVal->addr) {
515 case XawtextScrollNever:
516 case XawtextScrollWhenNeeded:
517 buffer = XtEtextScrollNever;
518 break;
519 case XawtextScrollAlways:
520 buffer = XtEtextScrollAlways;
521 break;
522 default:
523 XawTypeToStringWarning(dpy, XtRScrollMode);
524 toVal->addr = NULL;
525 toVal->size = 0;
526 return (False);
527 }
528 size = (Cardinal)strlen(buffer) + 1;
529 if (toVal->addr != NULL) {
530 if (toVal->size < size) {
531 toVal->size = size;
532 return (False);
533 }
534 strcpy((char *)toVal->addr, buffer);
535 }
536 else
537 toVal->addr = (XPointer)buffer;
538 toVal->size = sizeof(String);
539
540 return (True);
541 }
542
543 /*ARGSUSED*/
544 static void
545 CvtStringToWrapMode(XrmValuePtr args _X_UNUSED, Cardinal *num_args _X_UNUSED,
546 XrmValuePtr fromVal, XrmValuePtr toVal)
547 {
548 static XawTextWrapMode wrapMode = XawtextWrapNever;
549 XrmQuark q;
550 char lowerName[6];
551
552 XmuNCopyISOLatin1Lowered(lowerName, (char *)fromVal->addr,
553 sizeof(lowerName));
554 q = XrmStringToQuark(lowerName);
555
556 if (q == QWrapNever)
557 wrapMode = XawtextWrapNever;
558 else if (q == QWrapLine)
559 wrapMode = XawtextWrapLine;
560 else if (q == QWrapWord)
561 wrapMode = XawtextWrapWord;
562 else
563 XtStringConversionWarning((char *)fromVal->addr, XtRWrapMode);
564
565 done(&wrapMode, XawTextWrapMode);
566 }
567
568 /*ARGSUSED*/
569 static Boolean
570 CvtWrapModeToString(Display *dpy, XrmValue *args _X_UNUSED, Cardinal *num_args _X_UNUSED,
571 XrmValue *fromVal, XrmValue *toVal _X_UNUSED, XtPointer *data _X_UNUSED)
572 {
573 static String buffer;
574 Cardinal size;
575
576 switch (*(XawTextWrapMode *)fromVal->addr) {
577 case XawtextWrapNever:
578 buffer = XtEtextWrapNever;
579 break;
580 case XawtextWrapLine:
581 buffer = XtEtextWrapLine;
582 break;
583 case XawtextWrapWord:
584 buffer = XtEtextWrapWord;
585 break;
586 default:
587 XawTypeToStringWarning(dpy, XtRWrapMode);
588 toVal->addr = NULL;
589 toVal->size = 0;
590 return (False);
591 }
592 size = (Cardinal)strlen(buffer) + 1;
593 if (toVal->addr != NULL) {
594 if (toVal->size < size) {
595 toVal->size = size;
596 return (False);
597 }
598 strcpy((char *)toVal->addr, buffer);
599 }
600 else
601 toVal->addr = (XPointer)buffer;
602 toVal->size = sizeof(String);
603
604 return (True);
605 }
606
607 /*ARGSUSED*/
608 static Boolean
609 CvtStringToJustifyMode(Display *dpy _X_UNUSED, XrmValue *args _X_UNUSED, Cardinal *num_args _X_UNUSED,
610 XrmValue *fromVal, XrmValue *toVal, XtPointer *data _X_UNUSED)
611 {
612 XawTextJustifyMode justify;
613 XrmQuark q;
614 char lowerName[8];
615
616 XmuNCopyISOLatin1Lowered(lowerName, (char *)fromVal->addr,
617 sizeof(lowerName));
618 q = XrmStringToQuark(lowerName);
619
620 if (q == QJustifyLeft)
621 justify = XawjustifyLeft;
622 else if (q == QJustifyRight)
623 justify = XawjustifyRight;
624 else if (q == QJustifyCenter)
625 justify = XawjustifyCenter;
626 else if(q == QJustifyFull)
627 justify = XawjustifyFull;
628 else {
629 XtStringConversionWarning((char *)fromVal->addr, XtRJustifyMode);
630 return (False);
631 }
632
633 toVal->size = sizeof(XawTextJustifyMode);
634 *(XawTextJustifyMode *)(toVal->addr) = justify;
635
636 return (True);
637 }
638
639
640 /*ARGSUSED*/
641 static Boolean
642 CvtJustifyModeToString(Display *dpy, XrmValue *args _X_UNUSED, Cardinal *num_args _X_UNUSED,
643 XrmValue *fromVal, XrmValue *toVal, XtPointer *data _X_UNUSED)
644 {
645 static String buffer;
646 Cardinal size;
647
648 switch (*(XawTextJustifyMode *)fromVal->addr) {
649 case XawjustifyLeft:
650 buffer = XtEtextJustifyLeft;
651 break;
652 case XawjustifyRight:
653 buffer = XtEtextJustifyRight;
654 break;
655 case XawjustifyCenter:
656 buffer = XtEtextJustifyCenter;
657 break;
658 case XawjustifyFull:
659 buffer = XtEtextJustifyFull;
660 break;
661 default:
662 XawTypeToStringWarning(dpy, XtRJustifyMode);
663 toVal->addr = NULL;
664 toVal->size = 0;
665 return (False);
666 }
667 size = (Cardinal)strlen(buffer) + 1;
668 if (toVal->addr != NULL) {
669 if (toVal->size < size) {
670 toVal->size = size;
671 return (False);
672 }
673 strcpy((char *)toVal->addr, buffer);
674 }
675 else
676 toVal->addr = (XPointer)buffer;
677 toVal->size = sizeof(String);
678
679 return (True);
680 }
681
682 #undef done
683
684 static void
685 XawTextClassInitialize(void)
686 {
687 if (!XawFmt8Bit)
688 FMT8BIT = XawFmt8Bit = (unsigned long)XrmPermStringToQuark("FMT8BIT");
689 if (!XawFmtWide)
690 XawFmtWide = (unsigned long)XrmPermStringToQuark("FMTWIDE");
691
692 XawInitializeWidgetSet();
693
694 textClassRec.core_class.num_actions = _XawTextActionsTableCount;
695
696 QWrapNever = XrmPermStringToQuark(XtEtextWrapNever);
697 QWrapLine = XrmPermStringToQuark(XtEtextWrapLine);
698 QWrapWord = XrmPermStringToQuark(XtEtextWrapWord);
699 XtAddConverter(XtRString, XtRWrapMode, CvtStringToWrapMode, NULL, 0);
700 XtSetTypeConverter(XtRWrapMode, XtRString, CvtWrapModeToString,
701 NULL, 0, XtCacheNone, NULL);
702 QScrollNever = XrmPermStringToQuark(XtEtextScrollNever);
703 QScrollWhenNeeded = XrmPermStringToQuark(XtEtextScrollWhenNeeded);
704 QScrollAlways = XrmPermStringToQuark(XtEtextScrollAlways);
705 XtAddConverter(XtRString, XtRScrollMode, CvtStringToScrollMode,
706 NULL, 0);
707 XtSetTypeConverter(XtRScrollMode, XtRString, CvtScrollModeToString,
708 NULL, 0, XtCacheNone, NULL);
709 QJustifyLeft = XrmPermStringToQuark(XtEtextJustifyLeft);
710 QJustifyRight = XrmPermStringToQuark(XtEtextJustifyRight);
711 QJustifyCenter = XrmPermStringToQuark(XtEtextJustifyCenter);
712 QJustifyFull = XrmPermStringToQuark(XtEtextJustifyFull);
713 XtSetTypeConverter(XtRString, XtRJustifyMode, CvtStringToJustifyMode,
714 NULL, 0, XtCacheNone, NULL);
715 XtSetTypeConverter(XtRJustifyMode, XtRString, CvtJustifyModeToString,
716 NULL, 0, XtCacheNone, NULL);
717 }
718
719 /*
720 * Function:
721 * PositionHScrollBar
722 *
723 * Parameters:
724 * ctx - text widget
725 *
726 * Description:
727 * Positions the Horizontal scrollbar.
728 */
729 static void
730 PositionHScrollBar(TextWidget ctx)
731 {
732 Widget hbar = ctx->text.hbar, vbar = ctx->text.vbar;
733 Position x, y;
734 Dimension width, height;
735
736 if (ctx->text.hbar == NULL)
737 return;
738
739 if (vbar != NULL)
740 x = (Position)XtWidth(vbar);
741 else
742 x = (Position)(-XtBorderWidth(hbar));
743 y = (Position)(XtHeight(ctx) - XtHeight(hbar) - XtBorderWidth(hbar));
744 if (vbar != NULL) {
745 width = (Dimension)(XtWidth(ctx) - XtWidth(vbar) - XtBorderWidth(vbar));
746 if (width > XtWidth(ctx))
747 width = XtWidth(ctx);
748 }
749 else
750 width = XtWidth(ctx);
751 height = XtHeight(hbar);
752
753 XtConfigureWidget(hbar, x, y, width, height, XtBorderWidth(hbar));
754 }
755
756 /*
757 * Function:
758 * PositionVScrollBar
759 *
760 * Parameters:
761 * ctx - text widget
762 *
763 * Description:
764 * Positions the Vertical scrollbar.
765 */
766 static void
767 PositionVScrollBar(TextWidget ctx)
768 {
769 Widget vbar = ctx->text.vbar;
770 Position x, y;
771 Dimension width, height;
772
773 if (vbar == NULL)
774 return;
775
776 x = y = (Position)(-XtBorderWidth(vbar));
777 height = XtHeight(ctx);
778 width = XtWidth(vbar);
779
780 XtConfigureWidget(vbar, x, y, width, height, XtBorderWidth(vbar));
781 }
782
783 static void
784 CreateVScrollBar(TextWidget ctx)
785 {
786 Widget vbar;
787
788 if (ctx->text.vbar != NULL)
789 return;
790
791 ctx->text.vbar = vbar =
792 XtCreateWidget("vScrollbar", scrollbarWidgetClass, (Widget)ctx, NULL, 0);
793 XtAddCallback(vbar, XtNscrollProc, VScroll, (XtPointer)ctx);
794 XtAddCallback(vbar, XtNjumpProc, VJump, (XtPointer)ctx);
795
796 ctx->text.r_margin.left += (Position) (XtWidth(vbar) + XtBorderWidth(vbar));
797 ctx->text.left_margin = ctx->text.margin.left = ctx->text.r_margin.left;
798
799 PositionVScrollBar(ctx);
800 PositionHScrollBar(ctx);
801 TextSinkResize(ctx->text.sink);
802
803 if (XtIsRealized((Widget)ctx)) {
804 XtRealizeWidget(vbar);
805 XtMapWidget(vbar);
806 }
807 XtSetKeyboardFocus(vbar, (Widget)ctx);
808 }
809
810 /*
811 * Function:
812 * DestroyVScrollBar
813 *
814 * Parameters:
815 * ctx - parent text widget
816 *
817 * Description:
818 * Removes vertical ScrollBar.
819 */
820 static void
821 DestroyVScrollBar(TextWidget ctx)
822 {
823 Widget vbar = ctx->text.vbar;
824
825 if (vbar == NULL)
826 return;
827
828 ctx->text.r_margin.left = (Position)(ctx->text.r_margin.left - (XtWidth(vbar) + XtBorderWidth(vbar)));
829 ctx->text.left_margin = ctx->text.margin.left = ctx->text.r_margin.left;
830
831 XtDestroyWidget(vbar);
832 ctx->text.vbar = NULL;
833 if (!ctx->core.being_destroyed) {
834 PositionHScrollBar(ctx);
835 TextSinkResize(ctx->text.sink);
836 }
837 }
838
839 static void
840 CreateHScrollBar(TextWidget ctx)
841 {
842 Arg args[1];
843 Widget hbar;
844 int bottom;
845
846 if (ctx->text.hbar != NULL)
847 return;
848
849 XtSetArg(args[0], XtNorientation, XtorientHorizontal);
850 ctx->text.hbar = hbar =
851 XtCreateWidget("hScrollbar", scrollbarWidgetClass, (Widget)ctx, args, 1);
852 XtAddCallback(hbar, XtNscrollProc, HScroll, (XtPointer)ctx);
853 XtAddCallback(hbar, XtNjumpProc, HJump, (XtPointer)ctx);
854
855 bottom = ctx->text.r_margin.bottom + XtHeight(hbar) + XtBorderWidth(hbar);
856
857 ctx->text.margin.bottom = ctx->text.r_margin.bottom = (Position)bottom;
858
859 PositionHScrollBar(ctx);
860 TextSinkResize(ctx->text.sink);
861
862 if (XtIsRealized((Widget)ctx)) {
863 XtRealizeWidget(hbar);
864 XtMapWidget(hbar);
865 }
866 XtSetKeyboardFocus(hbar, (Widget)ctx);
867 }
868
869 /*
870 * Function:
871 * DestroyHScrollBar
872 *
873 * Parameters:
874 * ctx - parent text widget
875 *
876 * Description:
877 * Removes horizontal ScrollBar.
878 */
879 static void
880 DestroyHScrollBar(TextWidget ctx)
881 {
882 Widget hbar = ctx->text.hbar;
883
884 if (hbar == NULL)
885 return;
886
887 ctx->text.r_margin.bottom = (Position)(ctx->text.r_margin.bottom
888 - (XtHeight(hbar)
889 + XtBorderWidth(hbar)));
890 ctx->text.margin.bottom = ctx->text.r_margin.bottom;
891
892 XtDestroyWidget(hbar);
893 ctx->text.hbar = NULL;
894 if (!ctx->core.being_destroyed)
895 TextSinkResize(ctx->text.sink);
896 }
897
898 /*ARGSUSED*/
899 static void
900 XawTextInitialize(Widget request _X_UNUSED, Widget cnew,
901 ArgList args _X_UNUSED, Cardinal *num_args _X_UNUSED)
902 {
903 TextWidget ctx = (TextWidget)cnew;
904
905 ctx->text.lt.lines = 0;
906 ctx->text.lt.info = (XawTextLineTableEntry *)
907 XtCalloc(1, sizeof(XawTextLineTableEntry));
908 #ifndef OLDXAW
909 ctx->text.lt.base_line = 1;
910 #endif
911 (void)bzero(&ctx->text.origSel, sizeof(XawTextSelection));
912 (void)bzero(&ctx->text.s, sizeof(XawTextSelection));
913 ctx->text.s.type = XawselectPosition;
914 ctx->text.salt = NULL;
915 ctx->text.hbar = ctx->text.vbar = NULL;
916 ctx->text.lasttime = 0;
917 ctx->text.time = 0;
918 ctx->text.showposition = True;
919 ctx->text.lastPos = ctx->text.source != NULL ?
920 XawTextGetLastPosition(ctx) : 0;
921 ctx->text.file_insert = NULL;
922 ctx->text.search = NULL;
923 ctx->text.update = XmuNewScanline(0, 0, 0);
924 ctx->text.gc = XtGetGC(cnew, 0, 0);
925 ctx->text.hasfocus = False;
926 ctx->text.margin = ctx->text.r_margin; /* Structure copy */
927 ctx->text.left_margin = ctx->text.r_margin.left;
928 ctx->text.update_disabled = False;
929 ctx->text.clear_to_eol = True;
930 ctx->text.old_insert = -1;
931 ctx->text.mult = 1;
932 ctx->text.salt2 = NULL;
933 ctx->text.from_left = -1;
934
935 #ifndef OLDXAW
936 ctx->text.numeric = False;
937 ctx->text.selection_state = False;
938 ctx->text.kill_ring = 0;
939
940 ctx->text.line_number = -1;
941 ctx->text.column_number = -1;
942 ctx->text.source_changed = SRC_CHANGE_NONE;
943
944 ctx->text.kill_ring_ptr = NULL;
945 ctx->text.overwrite = False;
946 #endif
947
948 if (XtHeight(ctx) == DEFAULT_TEXT_HEIGHT) {
949 XtHeight(ctx) = (Dimension)VMargins(ctx);
950 if (ctx->text.sink != NULL)
951 XtHeight(ctx) += (Dimension) XawTextSinkMaxHeight(ctx->text.sink, 1);
952 }
953
954 if (ctx->text.scroll_vert == XawtextScrollAlways)
955 CreateVScrollBar(ctx);
956 if (ctx->text.scroll_horiz == XawtextScrollAlways)
957 CreateHScrollBar(ctx);
958
959 #ifndef OLDXAW
960 if (ctx->text.left_column < 0)
961 ctx->text.left_column = 0;
962 if (ctx->text.right_column < 0)
963 ctx->text.right_column = 0;
964 #endif
965 }
966
967 static void
968 XawTextRealize(Widget w, XtValueMask *mask, XSetWindowAttributes *attr)
969 {
970 TextWidget ctx = (TextWidget)w;
971
972 (*textClassRec.core_class.superclass->core_class.realize)(w, mask, attr);
973
974 if (ctx->text.hbar != NULL) {
975 XtRealizeWidget(ctx->text.hbar);
976 XtMapWidget(ctx->text.hbar);
977 }
978
979 if (ctx->text.vbar != NULL) {
980 XtRealizeWidget(ctx->text.vbar);
981 XtMapWidget(ctx->text.vbar);
982 }
983
984 _XawTextBuildLineTable(ctx, ctx->text.lt.top, True);
985
986 #ifndef OLDXAW
987 _XawTextSetLineAndColumnNumber(ctx, True);
988 #endif
989 }
990
991 /* Utility routines for support of Text */
992 static void
993 _CreateCutBuffers(Display *d)
994 {
995 static struct _DisplayRec {
996 struct _DisplayRec *next;
997 Display *dpy;
998 } *dpy_list = NULL;
999 struct _DisplayRec *dpy_ptr;
1000
1001 for (dpy_ptr = dpy_list; dpy_ptr != NULL; dpy_ptr = dpy_ptr->next)
1002 if (dpy_ptr->dpy == d)
1003 return;
1004
1005 dpy_ptr = XtNew(struct _DisplayRec);
1006 dpy_ptr->next = dpy_list;
1007 dpy_ptr->dpy = d;
1008 dpy_list = dpy_ptr;
1009
1010 #define Create(buffer) \
1011 XChangeProperty(d, RootWindow(d, 0), buffer, XA_STRING, 8, \
1012 PropModeAppend, NULL, 0);
1013
1014 Create(XA_CUT_BUFFER0);
1015 Create(XA_CUT_BUFFER1);
1016 Create(XA_CUT_BUFFER2);
1017 Create(XA_CUT_BUFFER3);
1018 Create(XA_CUT_BUFFER4);
1019 Create(XA_CUT_BUFFER5);
1020 Create(XA_CUT_BUFFER6);
1021 Create(XA_CUT_BUFFER7);
1022
1023 #undef Create
1024 }
1025
1026 /*
1027 * Procedure to manage insert cursor visibility for editable text. It uses
1028 * the value of ctx->insertPos and an implicit argument. In the event that
1029 * position is immediately preceded by an eol graphic, then the insert cursor
1030 * is displayed at the beginning of the next line.
1031 */
1032 static void
1033 InsertCursor(Widget w, XawTextInsertState state)
1034 {
1035 TextWidget ctx = (TextWidget)w;
1036 int x, y;
1037 int line;
1038
1039 if (ctx->text.lt.lines < 1)
1040 return;
1041
1042 if (ctx->text.display_caret &&
1043 LineAndXYForPosition(ctx, ctx->text.insertPos, &line, &x, &y)) {
1044 if (line < ctx->text.lt.lines)
1045 y += (ctx->text.lt.info[line + 1].y - ctx->text.lt.info[line].y) + 1;
1046 else
1047 y += (ctx->text.lt.info[line].y - ctx->text.lt.info[line - 1].y) + 1;
1048
1049 XawTextSinkInsertCursor(ctx->text.sink, (Position)x, (Position)y, state);
1050 }
1051
1052 /* Keep Input Method up to speed */
1053 if (ctx->simple.international) {
1054 Arg list[1];
1055
1056 XtSetArg(list[0], XtNinsertPosition, ctx->text.insertPos);
1057 _XawImSetValues(w, list, 1);
1058 }
1059 }
1060
1061 /*
1062 * Procedure to register a span of text that is no longer valid on the display
1063 * It is used to avoid a number of small, and potentially overlapping, screen
1064 * updates.
1065 */
1066 void
1067 _XawTextNeedsUpdating(TextWidget ctx,
1068 XawTextPosition left, XawTextPosition right)
1069 {
1070 if (left >= right)
1071 return;
1072 else {
1073 XmuSegment segment = {
1074 .x1 = (int)left,
1075 .x2 = (int)right
1076 };
1077
1078 (void)XmuScanlineOrSegment(ctx->text.update, &segment);
1079 }
1080 }
1081
1082 /*
1083 * Procedure to read a span of text in Ascii form. This is purely a hack and
1084 * we probably need to add a function to sources to provide this functionality.
1085 * [note: this is really a private procedure but is used in multiple modules].
1086 */
1087 char *
1088 _XawTextGetText(TextWidget ctx, XawTextPosition left, XawTextPosition right)
1089 {
1090 char *result, *tempResult;
1091 XawTextBlock text;
1092 int bytes;
1093
1094 if (XawTextFormat(ctx, XawFmt8Bit))
1095 bytes = sizeof(unsigned char);
1096 else if (XawTextFormat(ctx, XawFmtWide))
1097 bytes = sizeof(wchar_t);
1098 else /* if there is another format, add here */
1099 bytes = 1;
1100
1101 /* leave space for ZERO */
1102 tempResult = result = XtMalloc((unsigned)(right - left + ONE) * (unsigned)bytes);
1103
1104 while (left < right) {
1105 left = SrcRead(ctx->text.source, left, &text, (int)(right - left));
1106 if (!text.length)
1107 break;
1108 memmove(tempResult, text.ptr, (unsigned)(text.length * bytes));
1109 tempResult += text.length * bytes;
1110 }
1111
1112 if (bytes == sizeof(wchar_t))
1113 *((wchar_t*)tempResult) = (wchar_t)0;
1114 else
1115 *tempResult = '\0';
1116
1117 return (result);
1118 }
1119
1120 /* Like _XawTextGetText, but enforces ICCCM STRING type encoding. This
1121 * routine is currently used to put just the ASCII chars in the selection
1122 * into a cut buffer.
1123 */
1124 char *
1125 _XawTextGetSTRING(TextWidget ctx, XawTextPosition left, XawTextPosition right)
1126 {
1127 /* allow ESC in accordance with ICCCM */
1128 if (XawTextFormat(ctx, XawFmtWide)) {
1129 MultiSinkObject sink = (MultiSinkObject)ctx->text.sink;
1130 wchar_t *ws = (wchar_t *)_XawTextGetText(ctx, left, right);
1131 long n = (long)wcslen(ws);
1132 long i, j;
1133
1134 for (j = 0, i = 0; j < n; j++) {
1135 wchar_t wc = ws[j];
1136 if (XwcTextEscapement (sink->multi_sink.fontset, &wc, 1)
1137 || (wc == _Xaw_atowc(XawTAB)) || (wc == _Xaw_atowc(XawLF))
1138 || (wc == _Xaw_atowc(XawESC)))
1139 ws[i++] = wc;
1140 }
1141 ws[i] = (wchar_t)0;
1142 return ((char *)ws);
1143 }
1144 else {
1145 unsigned char *s = (unsigned char *)_XawTextGetText(ctx, left, right);
1146 /* only HT and NL control chars are allowed, strip out others */
1147 long n = (long)strlen((char *)s);
1148 long i = 0, j;
1149
1150 for (j = 0; j < n; j++) {
1151 unsigned char c = s[j];
1152 if (((c >= 0x20) && c <= 0x7f)
1153 ||(c >= 0xa0) || (c == XawTAB) || (c == XawLF)
1154 || (c == XawESC)) {
1155 s[i] = c;
1156 i++;
1157 }
1158 }
1159 s[i] = 0;
1160
1161 return ((char *)s);
1162 }
1163 }
1164
1165 /*
1166 * This routine maps an x and y position in a window that is displaying text
1167 * into the corresponding position in the source.
1168 */
1169 static XawTextPosition
1170 PositionForXY(TextWidget ctx, int x, int y)
1171 {
1172 int fromx, line, width, height;
1173 XawTextPosition position;
1174
1175 if (ctx->text.lt.lines == 0)
1176 return (0);
1177
1178 for (line = 0; line < ctx->text.lt.lines - 1; line++) {
1179 if (y <= ctx->text.lt.info[line + 1].y)
1180 break;
1181 }
1182 position = ctx->text.lt.info[line].position;
1183 if (position >= ctx->text.lastPos)
1184 return (ctx->text.lastPos);
1185 fromx = ctx->text.left_margin;
1186 XawTextSinkFindPosition(ctx->text.sink, position, fromx, x - fromx,
1187 False, &position, &width, &height);
1188
1189 if (position > ctx->text.lastPos)
1190 return (ctx->text.lastPos);
1191
1192 if (position >= ctx->text.lt.info[line + 1].position)
1193 position = SrcScan(ctx->text.source, ctx->text.lt.info[line + 1].position,
1194 XawstPositions, XawsdLeft, 1, True);
1195
1196 return (position);
1197 }
1198
1199 /*
1200 * This routine maps a source position in to the corresponding line number
1201 * of the text that is displayed in the window.
1202 */
1203 static int
1204 LineForPosition(TextWidget ctx, XawTextPosition position)
1205 {
1206 int line;
1207
1208 for (line = 0; line < ctx->text.lt.lines; line++)
1209 if (position < ctx->text.lt.info[line + 1].position)
1210 break;
1211
1212 return (line);
1213 }
1214
1215 /*
1216 * This routine maps a source position into the corresponding line number
1217 * and the x, y coordinates of the text that is displayed in the window.
1218 */
1219 static Bool
1220 LineAndXYForPosition(TextWidget ctx, XawTextPosition pos,
1221 int *line, int *x, int *y)
1222 {
1223 Boolean visible;
1224
1225 *line = 0;
1226 *x = ctx->text.left_margin;
1227 *y = ctx->text.margin.top + 1;
1228 if ((visible = IsPositionVisible(ctx, pos)) != False) {
1229 XawTextPosition linePos, endPos;
1230 int realW, realH;
1231
1232 *line = LineForPosition(ctx, pos);
1233 *y = ctx->text.lt.info[*line].y;
1234 linePos = ctx->text.lt.info[*line].position;
1235 XawTextSinkFindDistance(ctx->text.sink, linePos,
1236 *x, pos, &realW, &endPos, &realH);
1237 *x += realW;
1238 }
1239
1240 return (visible);
1241 }
1242
1243 /*
1244 * This routine builds a line table. It does this by starting at the
1245 * specified position and measuring text to determine the staring position
1246 * of each line to be displayed. It also determines and saves in the
1247 * linetable all the required metrics for displaying a given line (e.g.
1248 * x offset, y offset, line length, etc.).
1249 */
1250 void
1251 _XawTextBuildLineTable(TextWidget ctx, XawTextPosition position,
1252 _XtBoolean force_rebuild)
1253 {
1254 int lines = 0;
1255 Cardinal size;
1256
1257 if ((int)XtHeight(ctx) > VMargins(ctx)) {
1258 Dimension height = (Dimension)(XtHeight(ctx) - VMargins(ctx));
1259 lines = XawTextSinkMaxLines(ctx->text.sink, height);
1260 }
1261 size = (Cardinal)(sizeof(XawTextLineTableEntry) * (size_t)(lines + 1));
1262
1263 if (lines != ctx->text.lt.lines || ctx->text.lt.info == NULL) {
1264 ctx->text.lt.info = (XawTextLineTableEntry *)
1265 XtRealloc((char *)ctx->text.lt.info, size);
1266 ctx->text.lt.lines = lines;
1267 force_rebuild = True;
1268 }
1269
1270 if (force_rebuild) {
1271 (void)bzero((char *)ctx->text.lt.info, size);
1272 /* force a text update in the first text line if it is visible */
1273 ctx->text.lt.info[0].position = (XawTextPosition)-1;
1274 }
1275 if (position != ctx->text.lt.info[0].position) {
1276 (void)_BuildLineTable(ctx, position, 0);
1277 ctx->text.clear_to_eol = True;
1278 }
1279 }
1280
1281 /*
1282 * We may need to resize the line table here, since there maybe lines with
1283 * different fonts (that can be shorter or taller than the default one)
1284 */
1285 static XawTextPosition
1286 _BuildLineTable(TextWidget ctx, XawTextPosition position, int line)
1287 {
1288 XawTextLineTableEntry *lt = ctx->text.lt.info + line;
1289 XawTextPosition end, update_from = -1;
1290 Position y;
1291 int wwidth, width, height;
1292 #ifndef OLDXAW
1293 Widget src = ctx->text.source;
1294 #endif
1295 int max_y = (int)XtHeight(ctx) - (int)ctx->text.margin.bottom;
1296
1297 if (ctx->text.wrap == XawtextWrapNever)
1298 wwidth = 0x7fffffff;
1299 else
1300 wwidth = GetMaxTextWidth(ctx);
1301
1302 /* XXX y may change, due to font size changes. See later */
1303 y = line == 0 ? ctx->text.margin.top : lt->y;
1304
1305 #ifndef OLDXAW
1306 if (ctx->text.lt.base_line < 0) {
1307 if (line == 0)
1308 ctx->text.lt.top = position;
1309 }
1310 else if (line == 0) {
1311 XawTextPosition pos = ctx->text.lt.top;
1312 int base_line = ctx->text.lt.base_line;
1313
1314 if (position == 0)
1315 base_line = 1;
1316 else if (ctx->text.lt.base_line == 0 ||
1317 ctx->text.source_changed == SRC_CHANGE_OVERLAP) {
1318 pos = 0;
1319 base_line = 1;
1320
1321 while (pos < position) {
1322 pos = SrcScan(src, pos, XawstEOL, XawsdRight, 1, True);
1323 if (pos <= position) {
1324 ++base_line;
1325 if (pos == ctx->text.lastPos) {
1326 base_line -= !_XawTextSourceNewLineAtEOF(src);
1327 break;
1328 }
1329 }
1330 }
1331 }
1332 else if (ctx->text.wrap == XawtextWrapNever
1333 && IsPositionVisible(ctx, position))
1334 base_line += LineForPosition(ctx, position);
1335 else if (pos < position) {
1336 while (pos < position) {
1337 pos = SrcScan(src, pos, XawstEOL, XawsdRight, 1, True);
1338 if (pos <= position) {
1339 ++base_line;
1340 if (pos == ctx->text.lastPos) {
1341 base_line -= !_XawTextSourceNewLineAtEOF(src);
1342 break;
1343 }
1344 }
1345 }
1346 }
1347 else if (pos > position) {
1348 while (pos > position) {
1349 pos = SrcScan(src, pos, XawstEOL, XawsdLeft, 1, False);
1350 if (--pos >= position)
1351 --base_line;
1352 }
1353 }
1354
1355 ctx->text.lt.top = position;
1356 ctx->text.lt.base_line = base_line;
1357 }
1358 #else
1359 if (line == 0)
1360 ctx->text.lt.top = position;
1361 #endif
1362
1363 /* CONSTCOND */
1364 while (True) {
1365 XawTextSinkFindPosition(ctx->text.sink, position, ctx->text.left_margin,
1366 wwidth, ctx->text.wrap == XawtextWrapWord,
1367 &end, &width, &height);
1368
1369 if (lt->position != position) {
1370 _XawTextNeedsUpdating(ctx, position,
1371 end <= position ? position + 1 : end);
1372 ctx->text.clear_to_eol = True;
1373 lt->position = position;
1374 }
1375 if (lt->y != y) {
1376 if (update_from < 0)
1377 update_from = line == 0 ?
1378 ctx->text.lt.info[0].position :
1379 ctx->text.lt.info[line - 1].position;
1380 lt->y = y;
1381 ctx->text.clear_to_eol = True;
1382 }
1383 if (lt->textWidth != (Cardinal)width) {
1384 if (lt->textWidth > (Cardinal)width)
1385 ctx->text.clear_to_eol = True;
1386 lt->textWidth = (Dimension)width;
1387 }
1388 y = (Position)(y + height);
1389
1390 if (end > ctx->text.lastPos) {
1391 position = end;
1392 ctx->text.clear_to_eol = True;
1393 _XawTextNeedsUpdating(ctx, end, end + ctx->text.lt.lines - line);
1394 while (line++ < ctx->text.lt.lines) {
1395 if (line > 1 && y > max_y) {
1396 ctx->text.lt.lines = line - 1;
1397 break;
1398 }
1399 ++lt;
1400 if (lt->y != y) {
1401 if (update_from < 0)
1402 update_from = line < 2 ?
1403 ctx->text.lt.info[0].position :
1404 ctx->text.lt.info[line - 2].position;
1405 lt->y = y;
1406 }
1407 lt->position = ++position;
1408 lt->textWidth = 0;
1409 y = (Position)(y + height);
1410 }
1411 if (update_from >= 0)
1412 _XawTextNeedsUpdating(ctx, update_from,
1413 ctx->text.lt.info[ctx->text.lt.lines].position);
1414 _XawTextSetScrollBars(ctx);
1415
1416 return (ctx->text.lastPos);
1417 }
1418
1419 if (line && y > max_y)
1420 /* will return in the next loop */
1421 ctx->text.lt.lines = line;
1422
1423 if (++line > ctx->text.lt.lines && y < max_y) {
1424 /* grow the line table */
1425 ctx->text.lt.info = (XawTextLineTableEntry *)
1426 XtRealloc((char *)ctx->text.lt.info,
1427 (Cardinal)(sizeof(XawTextLineTableEntry) * (size_t)(line + 1)));
1428 lt = ctx->text.lt.info + line;
1429 bzero(lt, sizeof(XawTextLineTableEntry));
1430 ++ctx->text.lt.lines;
1431 }
1432 else
1433 ++lt;
1434 if (position == end)
1435 ++position;
1436 else
1437 position = end;
1438
1439 if (line > ctx->text.lt.lines) {
1440 if (update_from >= 0)
1441 _XawTextNeedsUpdating(ctx, update_from,
1442 ctx->text.lt.info[ctx->text.lt.lines].position);
1443 _XawTextSetScrollBars(ctx);
1444
1445 return (position);
1446 }
1447 }
1448 /*NOTREACHED*/
1449 }
1450
1451 /*
1452 * Function:
1453 * GetWidestLine
1454 *
1455 * Parameters:
1456 * ctx - text widget
1457 *
1458 * Description:
1459 * Returns the width (in pixels) of the widest line that
1460 * is currently visible.
1461 *
1462 * Returns:
1463 * The width of the widest line
1464 */
1465 static unsigned int
1466 GetWidestLine(TextWidget ctx)
1467 {
1468 int i;
1469 unsigned int widest;
1470 XawTextLineTablePtr lt = &(ctx->text.lt);
1471
1472 for (i = 0, widest = 0; i < lt->lines; i++)
1473 if (widest < lt->info[i].textWidth)
1474 widest = lt->info[i].textWidth;
1475
1476 return (widest);
1477 }
1478
1479 /*
1480 * This routine is used by Text to notify an associated scrollbar of the
1481 * correct metrics (position and shown fraction) for the text being currently
1482 * displayed in the window.
1483 */
1484 void
1485 _XawTextSetScrollBars(TextWidget ctx)
1486 {
1487 float first;
1488
1489 if (ctx->text.scroll_vert == XawtextScrollAlways) {
1490 float last;
1491
1492 if (ctx->text.lastPos == 0)
1493 first = 0.0;
1494 else
1495 first = (float)ctx->text.lt.top / (float)ctx->text.lastPos;
1496
1497 if (ctx->text.lt.info[ctx->text.lt.lines].position < ctx->text.lastPos)
1498 last = (float)ctx->text.lt.info[ctx->text.lt.lines].position /
1499 (float)ctx->text.lastPos;
1500 else
1501 last = 1.0;
1502
1503 XawScrollbarSetThumb(ctx->text.vbar, first, last - first);
1504 }
1505
1506 if (ctx->text.scroll_horiz == XawtextScrollAlways) {
1507 unsigned value = GetWidestLine(ctx);
1508 float denom = (float)value;
1509 float widest;
1510
1511 if (denom <= 0)
1512 denom = (float)((int)XtWidth(ctx) - RHMargins(ctx));
1513 if (denom <= 0)
1514 denom = 1;
1515 widest = (float)((int)XtWidth(ctx) - RHMargins(ctx)) / denom;
1516 first = (float)(ctx->text.r_margin.left - ctx->text.left_margin);
1517 first /= denom;
1518
1519 XawScrollbarSetThumb(ctx->text.hbar, first, widest);
1520 }
1521 }
1522
1523 static void
1524 DoCopyArea(TextWidget ctx, int src_x, int src_y,
1525 unsigned int width, unsigned int height, int dst_x, int dst_y)
1526 {
1527 int x1, y1, x2, y2;
1528
1529 x1 = ctx->text.r_margin.left;
1530 y1 = ctx->text.r_margin.top;
1531 x2 = XtWidth(ctx) - ctx->text.r_margin.right;
1532 y2 = XtHeight(ctx) - ctx->text.r_margin.bottom;
1533
1534 if (x1 >= x2 || y1 >= y2)
1535 return;
1536
1537 src_x = XawMax(x1, XawMin(src_x, x2));
1538 src_y = XawMax(y1, XawMin(src_y, y2));
1539 dst_x = XawMax(x1, XawMin(dst_x, x2));
1540 dst_y = XawMax(y1, XawMin(dst_y, y2));
1541 width = (unsigned)XawMax(0, XawMin(x2 - dst_x, (int)width));
1542 height = (unsigned)XawMax(0, XawMin(y2 - dst_y, (int)height));
1543
1544 XCopyArea(XtDisplay(ctx), XtWindow(ctx), XtWindow(ctx), ctx->text.gc,
1545 src_x, src_y, width, height, dst_x, dst_y);
1546 }
1547
1548 /*
1549 * Function:
1550 * XawTextScroll
1551 *
1552 * Parameters:
1553 * ctx - text widget
1554 * vlines - number of lines to scroll vertically
1555 * hpixels - number of pixels to scroll horizontally
1556 *
1557 * Description:
1558 * Generic function for scrolling the text window.
1559 * Allows vertical and horizontal scroll at the same time.
1560 */
1561 void
1562 XawTextScroll(TextWidget ctx, int vlines, int hpixels)
1563 {
1564 XawTextPosition top, tmp, update_from, update_to;
1565 XawTextLineTable *lt;
1566 Arg arglist[1];
1567 int y0, y1, y2, count, dim, wwidth, lines = ctx->text.lt.lines;
1568 int vwidth, vheight; /* visible width and height */
1569 Bool scroll;
1570
1571 vwidth = (int)XtWidth(ctx) - RHMargins(ctx);
1572 vheight = (int)XtHeight(ctx) - RVMargins(ctx);
1573 lt = &ctx->text.lt;
1574
1575 if (!lt || vwidth <= 0 || vheight <= 0)
1576 return;
1577
1578 if ((scroll = ctx->core.background_pixmap == XtUnspecifiedPixmap) == True) {
1579 dim = lt->info[1].y - lt->info[0].y;
1580 for (count = 1; count < lt->lines - 1; count++)
1581 if (lt->info[count + 1].y - lt->info[count].y != dim) {
1582 scroll = False;
1583 break;
1584 }
1585 }
1586
1587 wwidth = GetMaxTextWidth(ctx);
1588
1589 /*
1590 * Do the horizontall scrolling
1591 */
1592 if (hpixels < 0 && ctx->text.left_margin - hpixels > ctx->text.r_margin.left)
1593 hpixels = ctx->text.left_margin - ctx->text.r_margin.left;
1594 ctx->text.left_margin -= hpixels;
1595
1596 update_from = lt->top; /* remember the old value */
1597 /*
1598 * Checks the requested number of lines and calculates the top
1599 * of the line table
1600 */
1601 if (vlines < 0) { /* VScroll Up */
1602 if (IsPositionVisible(ctx, 0))
1603 vlines = 0;
1604 else if (ctx->text.wrap != XawtextWrapNever) {
1605 XawTextPosition end;
1606 int n_lines = 0;
1607
1608 count = -vlines;
1609 end = lt->top;
1610 while (n_lines < count) {
1611 top = SrcScan(ctx->text.source, end, XawstEOL,
1612 XawsdLeft, 2, False);
1613 n_lines += CountLines(ctx, top, end);
1614 end = top;
1615 }
1616
1617 while (count++ < n_lines) {
1618 tmp = top;
1619 XawTextSinkFindPosition(ctx->text.sink, top,
1620 ctx->text.left_margin,
1621 wwidth,ctx->text.wrap == XawtextWrapWord,
1622 &top, &dim, &dim);
1623 if (tmp == top)
1624 ++top;
1625 }
1626 }
1627 else
1628 top = SrcScan(ctx->text.source, lt->top, XawstEOL,
1629 XawsdLeft, -vlines + 1, False);
1630 if (-vlines >= ctx->text.lt.lines)
1631 scroll = False;
1632 }
1633 else if (vlines > 0) { /* VScroll Down */
1634 if (LineForPosition(ctx, ctx->text.lastPos) == 0)
1635 vlines = 0;
1636 if (vlines < lt->lines)
1637 top = XawMin(lt->info[vlines].position, ctx->text.lastPos);
1638 else if (ctx->text.wrap == XawtextWrapNever)
1639 top = SrcScan(ctx->text.source,
1640 SrcScan(ctx->text.source, lt->top,
1641 XawstEOL, XawsdRight, vlines,
1642 True),
1643 XawstEOL, XawsdLeft, 1, False);
1644 else {
1645 top = lt->top;
1646 count = 0;
1647 while (count++ < vlines) {
1648 tmp = top;
1649 XawTextSinkFindPosition(ctx->text.sink, top,
1650 ctx->text.left_margin,
1651 wwidth, ctx->text.wrap == XawtextWrapWord,
1652 &top, &dim, &dim);
1653 if (tmp == top)
1654 ++top;
1655 }
1656 }
1657 if (vlines >= ctx->text.lt.lines
1658 || lt->info[vlines].position >= ctx->text.lastPos)
1659 scroll = False;
1660 }
1661
1662 if (!vlines) {
1663 if (hpixels) {
1664 ClearWindow(ctx);
1665 ctx->text.clear_to_eol = True;
1666 }
1667 _XawTextSetScrollBars(ctx);
1668 return;
1669 }
1670
1671 /* Flushes any pending updates. Normally, there may be a call to
1672 * XawTextUnsetSelection not yet updated.
1673 */
1674 if (!hpixels && scroll) {
1675 ctx->text.clear_to_eol = True;
1676 FlushUpdate(ctx);
1677 }
1678
1679 /*
1680 * Rebuild the line table, doing the vertical scroll
1681 */
1682 (void)_BuildLineTable(ctx, top, 0);
1683 lt = &ctx->text.lt;
1684 if (scroll) {
1685 for (count = 0; count < lt->lines - 1; count++)
1686 if (lt->info[count + 1].y - lt->info[count].y != dim) {
1687 scroll = False;
1688 break;
1689 }
1690 }
1691
1692 XtSetArg(arglist[0], XtNinsertPosition, lt->top + lt->lines);
1693 _XawImSetValues((Widget)ctx, arglist, 1);
1694
1695 if (hpixels || !scroll || lines != lt->lines)
1696 return;
1697
1698 /* _BuildLineTable updates everything if the top position changes.
1699 * It is not required here.
1700 */
1701 (void)XmuScanlineXor(ctx->text.update, ctx->text.update);
1702 if (vlines < 0 && IsPositionVisible(ctx, 0))
1703 vlines = -LineForPosition(ctx, update_from);
1704
1705 y0 = ctx->text.r_margin.top;
1706 if (vlines < 0) {
1707 update_from = lt->top;
1708 update_to = lt->info[-vlines + 1].position - 1;
1709 y1 = lt->info[lt->lines + vlines].y;
1710 y2 = lt->info[-vlines].y;
1711 DoCopyArea(ctx, ctx->text.r_margin.left, y0, (unsigned)vwidth,
1712 (unsigned)(y1 - y0),
1713 ctx->text.r_margin.left, y2);
1714 }
1715 else {
1716 update_from = lt->info[lt->lines - vlines].position;
1717 update_to = lt->info[lt->lines].position;
1718 y2 = lt->info[vlines].y;
1719 DoCopyArea(ctx, ctx->text.r_margin.left, y2,
1720 (unsigned)vwidth, (unsigned)(lt->info[lt->lines].y - y2),
1721 ctx->text.r_margin.left, y0);
1722 }
1723 _XawTextNeedsUpdating(ctx, update_from, update_to);
1724 ctx->text.clear_to_eol = True;
1725 }
1726
1727 /*
1728 * The routine will scroll the displayed text by lines. If the arg is
1729 * positive, move up; otherwise, move down. [note: this is really a private
1730 * procedure but is used in multiple modules].
1731 */
1732 void
1733 _XawTextVScroll(TextWidget ctx, int n)
1734 {
1735 XawTextScroll(ctx, n, 0);
1736 }
1737
1738 /*ARGSUSED*/
1739 static void
1740 HScroll(Widget w _X_UNUSED, XtPointer closure, XtPointer callData)
1741 {
1742 TextWidget ctx = (TextWidget)closure;
1743 long pixels = (long)callData;
1744
1745 if (pixels > 0) {
1746 long max;
1747
1748 max = (int)GetWidestLine(ctx) + ctx->text.left_margin -
1749 ctx->text.r_margin.left;
1750 max = XawMax(0, max);
1751 pixels = XawMin(pixels, max);
1752 }
1753
1754 if (pixels) {
1755 _XawTextPrepareToUpdate(ctx);
1756 XawTextScroll(ctx, 0, (int)pixels);
1757 _XawTextExecuteUpdate(ctx);
1758 }
1759 }
1760
1761 /*ARGSUSED*/
1762 static void
1763 HJump(Widget w, XtPointer closure, XtPointer callData)
1764 {
1765 TextWidget ctx = (TextWidget)closure;
1766 float percent = *(float *)callData;
1767 unsigned value = GetWidestLine(ctx);
1768 long pixels;
1769
1770 pixels = ctx->text.left_margin -
1771 (ctx->text.r_margin.left - (int)(percent * (float)value));
1772
1773 HScroll(w, (XtPointer)ctx, (XtPointer)pixels);
1774 }
1775
1776 /*
1777 * Function:
1778 * UpdateTextInLine
1779 *
1780 * Parameters:
1781 * ctx - text widget
1782 * line - line to update
1783 * x1 - left pixel
1784 * x2 - right pixel
1785 *
1786 * Description:
1787 * Updates the text in the given line and pixel interval
1788 */
1789 static void
1790 UpdateTextInLine(TextWidget ctx, int line, int x1, int x2)
1791 {
1792 XawTextLineTableEntry *lt = ctx->text.lt.info + line;
1793 XawTextPosition left, right;
1794 int from_x, width, height;
1795
1796 if (lt->position >= ctx->text.lastPos
1797 || ctx->text.left_margin > x2
1798 || (int)lt->textWidth + ctx->text.left_margin < x1) {
1799 /* Mark line to be cleared */
1800 if (ctx->text.clear_to_eol)
1801 _XawTextNeedsUpdating(ctx, lt->position, lt->position + 1);
1802 return;
1803 }
1804
1805 from_x = ctx->text.left_margin;
1806 XawTextSinkFindPosition(ctx->text.sink, lt->position,
1807 from_x, x1 - from_x,
1808 False, &left, &width, &height);
1809 if (line == ctx->text.lt.lines)
1810 right = -1;
1811 else if ((Cardinal)x2 >= (lt->textWidth - (unsigned)from_x))
1812 right = lt[1].position - 1;
1813 else {
1814 from_x += width;
1815 XawTextSinkFindPosition(ctx->text.sink, left,
1816 from_x, x2 - from_x,
1817 False, &right, &width, &height);
1818 }
1819
1820 if ((right < 0) || (right + 1 <= lt[1].position))
1821 ++right;
1822
1823 /* Mark text interval to be repainted */
1824 _XawTextNeedsUpdating(ctx, left, right);
1825 }
1826
1827 /*
1828 * The routine will scroll the displayed text by pixels. If the calldata is
1829 * positive, move up; otherwise, move down.
1830 */
1831 /*ARGSUSED*/
1832 static void
1833 VScroll(Widget w _X_UNUSED, XtPointer closure, XtPointer callData)
1834 {
1835 TextWidget ctx = (TextWidget)closure;
1836 long height, lines = (long)callData;
1837
1838 height = XtHeight(ctx) - VMargins(ctx);
1839 if (height < 1)
1840 height = 1;
1841 lines = (lines * ctx->text.lt.lines) / height;
1842 _XawTextPrepareToUpdate(ctx);
1843 XawTextScroll(ctx, (int)lines, 0);
1844 _XawTextExecuteUpdate(ctx);
1845 }
1846
1847 /*ARGSUSED*/
1848 static void
1849 VJump(Widget w _X_UNUSED, XtPointer closure, XtPointer callData)
1850 {
1851 float percent = *(float *)callData;
1852 TextWidget ctx = (TextWidget)closure;
1853 XawTextPosition top, last, position, tmp;
1854 XawTextLineTable *lt = &(ctx->text.lt);
1855 int dim, vlines = 0, wwidth = GetMaxTextWidth(ctx);
1856 Bool scroll = True;
1857
1858 position = (XawTextPosition)(percent * (float)ctx->text.lastPos);
1859 top = lt->top;
1860
1861 if (!lt->lines || (position >= lt->top && position < lt->info[1].position)) {
1862 _XawTextSetScrollBars(ctx);
1863 return;
1864 }
1865
1866 #ifndef OLDXAW
1867 ctx->text.lt.base_line = -1;
1868 #endif
1869
1870 if (position > lt->top) { /* VScroll Up */
1871 if (position > lt->top && position < lt->info[lt->lines].position)
1872 vlines = LineForPosition(ctx, position);
1873 else {
1874 scroll = False;
1875 top = SrcScan(ctx->text.source, position, XawstEOL,
1876 XawsdLeft, 1, False);
1877 if (ctx->text.wrap != XawtextWrapNever) {
1878 last = top;
1879 while (last < position) {
1880 tmp = last;
1881 XawTextSinkFindPosition(ctx->text.sink, last,
1882 ctx->text.left_margin, wwidth,
1883 ctx->text.wrap == XawtextWrapWord,
1884 &last, &dim, &dim);
1885 if (last == tmp)
1886 ++last;
1887 if (last < position)
1888 top = last;
1889 }
1890 }
1891 }
1892 }
1893 else { /* VScroll Down */
1894 /*
1895 * Calculates the number of lines
1896 */
1897 while (top > position) {
1898 last = top;
1899 top = SrcScan(ctx->text.source, top, XawstEOL,
1900 XawsdLeft, 2, False);
1901 vlines -= CountLines(ctx, top, last);
1902 if (-vlines >= ctx->text.lt.lines) {
1903 scroll = False;
1904 top = SrcScan(ctx->text.source, position, XawstEOL,
1905 XawsdLeft, 1, False);
1906 break;
1907 }
1908 }
1909 /*
1910 * Normalize
1911 */
1912 if (ctx->text.wrap != XawtextWrapNever) {
1913 last = top;
1914 while (last < position) {
1915 tmp = last;
1916 XawTextSinkFindPosition(ctx->text.sink, last,
1917 ctx->text.left_margin,
1918 wwidth,
1919 ctx->text.wrap == XawtextWrapWord,
1920 &last, &dim, &dim);
1921 if (last == tmp)
1922 ++last;
1923 if (last < position)
1924 top = last;
1925 ++vlines;
1926 }
1927 }
1928 }
1929
1930 if (vlines || !scroll) {
1931 _XawTextPrepareToUpdate(ctx);
1932 if (scroll)
1933 XawTextScroll(ctx, vlines, 0);
1934 else
1935 _BuildLineTable(ctx, top, 0);
1936 _XawTextExecuteUpdate(ctx);
1937 }
1938 }
1939
1940 static Bool
1941 MatchSelection(Atom selection, XawTextSelection *s)
1942 {
1943 Atom *match;
1944 int count;
1945
1946 for (count = 0, match = s->selections; count < s->atom_count;
1947 match++, count++)
1948 if (*match == selection)
1949 return (True);
1950
1951 return (False);
1952 }
1953
1954 static Boolean
1955 TextConvertSelection(Widget w, Atom *selection, Atom *target, Atom *type,
1956 XtPointer *value, unsigned long *length, int *format)
1957 {
1958 Display *d = XtDisplay(w);
1959 TextWidget ctx = (TextWidget)w;
1960 Widget src = ctx->text.source;
1961 XawTextEditType edit_mode;
1962 XawTextSelectionSalt *salt = NULL;
1963 XawTextSelection *s;
1964
1965 if (*target == XA_TARGETS(d)) {
1966 Atom *targetP, *std_targets;
1967 unsigned long std_length;
1968
1969 if (SrcCvtSel(src, selection, target, type, value, length, format))
1970 return (True);
1971 else {
1972 Arg args[1];
1973
1974 XtSetArg(args[0], XtNeditType, &edit_mode);
1975 XtGetValues(src, args, ONE);
1976 }
1977
1978 XmuConvertStandardSelection(w, ctx->text.time, selection,
1979 target, type, (XPointer*)&std_targets,
1980 &std_length, format);
1981
1982 *length = 7 + (unsigned long)(edit_mode == XawtextEdit) + std_length;
1983 *value = XtMalloc((Cardinal)(sizeof(Atom)*(*length)));
1984 targetP = *(Atom**)value;
1985 *targetP++ = XA_STRING;
1986 *targetP++ = XA_TEXT(d);
1987 *targetP++ = XA_UTF8_STRING(d);
1988 *targetP++ = XA_COMPOUND_TEXT(d);
1989 *targetP++ = XA_LENGTH(d);
1990 *targetP++ = XA_LIST_LENGTH(d);
1991 *targetP++ = XA_CHARACTER_POSITION(d);
1992 if (edit_mode == XawtextEdit) {
1993 *targetP++ = XA_DELETE(d);
1994 }
1995 (void)memmove((char*)targetP, (char*)std_targets,
1996 sizeof(Atom) * std_length);
1997 XtFree((char*)std_targets);
1998 *type = XA_ATOM;
1999 *format = 32;
2000 return (True);
2001 }
2002
2003 if (SrcCvtSel(src, selection, target, type, value, length, format))
2004 return (True);
2005
2006 if (MatchSelection(*selection, &ctx->text.s))
2007 s = &ctx->text.s;
2008 else {
2009 for (salt = ctx->text.salt; salt; salt = salt->next)
2010 if (MatchSelection(*selection, &salt->s))
2011 break;
2012 if (!salt)
2013 return (False);
2014 s = &salt->s;
2015 }
2016 if (*target == XA_STRING
2017 || *target == XA_TEXT(d)
2018 || *target == XA_UTF8_STRING(d)
2019 || *target == XA_COMPOUND_TEXT(d)) {
2020 if (*target == XA_TEXT(d)) {
2021 if (XawTextFormat(ctx, XawFmtWide))
2022 *type = XA_COMPOUND_TEXT(d);
2023 else
2024 *type = XA_STRING;
2025 }
2026 else
2027 *type = *target;
2028 /*
2029 * If salt is True, the salt->contents stores CT string,
2030 * its length is measured in bytes.
2031 * Refer to _XawTextSaltAwaySelection().
2032 *
2033 * by Li Yuhong, Mar. 20, 1991.
2034 */
2035 if (!salt) {
2036 *value = _XawTextGetSTRING(ctx, s->left, s->right);
2037 if (XawTextFormat(ctx, XawFmtWide)) {
2038 XTextProperty textprop;
2039 if (XwcTextListToTextProperty(d, (wchar_t **)value, 1,
2040 XCompoundTextStyle, &textprop)
2041 < Success) {
2042 XtFree((char *)*value);
2043 return (False);
2044 }
2045 XtFree((char *)*value);
2046 *value = (XtPointer)textprop.value;
2047 *length = textprop.nitems;
2048 }
2049 else
2050 *length = strlen((char *)*value);
2051 }
2052 else {
2053 *value = XtMalloc((Cardinal)((size_t)(salt->length + 1) * sizeof(unsigned char)));
2054 strcpy ((char *)*value, salt->contents);
2055 *length = (unsigned long)salt->length;
2056 }
2057 /* Got *value,*length, now in COMPOUND_TEXT format. */
2058 if (XawTextFormat(ctx, XawFmtWide) && *type == XA_STRING) {
2059 wchar_t **wlist;
2060 int count;
2061 XTextProperty textprop = {
2062 .encoding = XA_COMPOUND_TEXT(d),
2063 .value = (unsigned char *)*value,
2064 .nitems = strlen(*value),
2065 .format = 8
2066 };
2067
2068 if (XwcTextPropertyToTextList(d, &textprop, &wlist, &count)
2069 < Success
2070 || count < 1) {
2071 XtFree((char *)*value);
2072 return (False);
2073 }
2074 XtFree((char *)*value);
2075 if (XwcTextListToTextProperty(d, wlist, 1, XStringStyle, &textprop)
2076 < Success) {
2077 XwcFreeStringList((wchar_t**) wlist);
2078 return (False);
2079 }
2080 *value = (XtPointer)textprop.value;
2081 *length = textprop.nitems;
2082 XwcFreeStringList(wlist);
2083 } else if (*type == XA_UTF8_STRING(d)) {
2084 char **list;
2085 int count;
2086 XTextProperty textprop = {
2087 .encoding = XA_COMPOUND_TEXT(d),
2088 .value = (unsigned char *)*value,
2089 .nitems = strlen(*value),
2090 .format = 8
2091 };
2092
2093 if (Xutf8TextPropertyToTextList(d, &textprop, &list, &count)
2094 < Success
2095 || count < 1) {
2096 XtFree((char *)*value);
2097 return (False);
2098 }
2099 XtFree((char *)*value);
2100 *value = *list;
2101 *length = strlen(*list);
2102 XFree(list);
2103 }
2104 *format = 8;
2105 return (True);
2106 }
2107
2108 if ((*target == XA_LIST_LENGTH(d)) || (*target == XA_LENGTH(d))) {
2109 long * temp;
2110
2111 temp = (long *)XtMalloc((unsigned)sizeof(long));
2112 if (*target == XA_LIST_LENGTH(d))
2113 *temp = 1L;
2114 else /* *target == XA_LENGTH(d) */
2115 *temp = (long) (s->right - s->left);
2116
2117 *value = (XPointer)temp;
2118 *type = XA_INTEGER;
2119 *length = 1L;
2120 *format = 32;
2121 return (True);
2122 }
2123
2124 if (*target == XA_CHARACTER_POSITION(d)) {
2125 long * temp;
2126
2127 temp = (long *)XtMalloc((unsigned)(2 * sizeof(long)));
2128 temp[0] = (long)(s->left + 1);
2129 temp[1] = s->right;
2130 *value = (XPointer)temp;
2131 *type = XA_SPAN(d);
2132 *length = 2L;
2133 *format = 32;
2134 return (True);
2135 }
2136
2137 if (*target == XA_DELETE(d)) {
2138 if (!salt)
2139 _XawTextZapSelection(ctx, NULL, True);
2140 *value = NULL;
2141 *type = XA_NULL(d);
2142 *length = 0;
2143 *format = 32;
2144 return (True);
2145 }
2146
2147 if (XmuConvertStandardSelection(w, ctx->text.time, selection, target, type,
2148 (XPointer *)value, length, format))
2149 return (True);
2150
2151 /* else */
2152 return (False);
2153 }
2154
2155 /*
2156 * Function:
2157 * GetCutBuffferNumber
2158 *
2159 * Parameters:
2160 * atom - atom to check
2161 *
2162 * Description:
2163 * Returns the number of the cut buffer.
2164 *
2165 * Returns:
2166 * The number of the cut buffer representing this atom or NOT_A_CUT_BUFFER
2167 */
2168 #define NOT_A_CUT_BUFFER -1
2169 static int
2170 GetCutBufferNumber(Atom atom)
2171 {
2172 if (atom == XA_CUT_BUFFER0) return (0);
2173 if (atom == XA_CUT_BUFFER1) return (1);
2174 if (atom == XA_CUT_BUFFER2) return (2);
2175 if (atom == XA_CUT_BUFFER3) return (3);
2176 if (atom == XA_CUT_BUFFER4) return (4);
2177 if (atom == XA_CUT_BUFFER5) return (5);
2178 if (atom == XA_CUT_BUFFER6) return (6);
2179 if (atom == XA_CUT_BUFFER7) return (7);
2180 return (NOT_A_CUT_BUFFER);
2181 }
2182
2183 static void
2184 TextLoseSelection(Widget w, Atom *selection)
2185 {
2186 TextWidget ctx = (TextWidget)w;
2187 Atom *atomP;
2188 int i;
2189 XawTextSelectionSalt*salt, *prevSalt, *nextSalt;
2190
2191 atomP = ctx->text.s.selections;
2192 for (i = 0 ; i < ctx->text.s.atom_count; i++, atomP++)
2193 if ((*selection == *atomP)
2194 || (GetCutBufferNumber(*atomP) != NOT_A_CUT_BUFFER))
2195 *atomP = (Atom)0;
2196
2197 while (ctx->text.s.atom_count
2198 && ctx->text.s.selections[ctx->text.s.atom_count - 1] == 0)
2199 ctx->text.s.atom_count--;
2200
2201 /*
2202 * Must walk the selection list in opposite order from UnsetSelection
2203 */
2204 atomP = ctx->text.s.selections;
2205 for (i = 0 ; i < ctx->text.s.atom_count; i++, atomP++)
2206 if (*atomP == (Atom)0) {
2207 *atomP = ctx->text.s.selections[--ctx->text.s.atom_count];
2208 while (ctx->text.s.atom_count
2209 && ctx->text.s.selections[ctx->text.s.atom_count-1] == 0)
2210 ctx->text.s.atom_count--;
2211 }
2212
2213 if (ctx->text.s.atom_count == 0)
2214 ModifySelection(ctx, ctx->text.insertPos, ctx->text.insertPos);
2215
2216 prevSalt = 0;
2217 for (salt = ctx->text.salt; salt; salt = nextSalt) {
2218 atomP = salt->s.selections;
2219 nextSalt = salt->next;
2220 for (i = 0 ; i < salt->s.atom_count; i++, atomP++)
2221 if (*selection == *atomP)
2222 *atomP = (Atom)0;
2223
2224 while (salt->s.atom_count
2225 && salt->s.selections[salt->s.atom_count-1] == 0)
2226 salt->s.atom_count--;
2227
2228 /*
2229 * Must walk the selection list in opposite order from UnsetSelection
2230 */
2231 atomP = salt->s.selections;
2232 for (i = 0 ; i < salt->s.atom_count; i++, atomP++)
2233 if (*atomP == (Atom)0) {
2234 *atomP = salt->s.selections[--salt->s.atom_count];
2235 while (salt->s.atom_count
2236 && salt->s.selections[salt->s.atom_count-1] == 0)
2237 salt->s.atom_count--;
2238 }
2239
2240 if (salt->s.atom_count == 0) {
2241 XtFree ((char *) salt->s.selections);
2242 XtFree (salt->contents);
2243 if (prevSalt)
2244 prevSalt->next = nextSalt;
2245 else
2246 ctx->text.salt = nextSalt;
2247 XtFree((char *)salt);
2248 }
2249 else
2250 prevSalt = salt;
2251 }
2252 }
2253
2254 void
2255 _XawTextSaltAwaySelection(TextWidget ctx, Atom *selections, int num_atoms)
2256 {
2257 XawTextSelectionSalt *salt;
2258 int i, j;
2259
2260 for (i = 0; i < num_atoms; i++)
2261 TextLoseSelection((Widget)ctx, selections + i);
2262 if (num_atoms == 0)
2263 return;
2264 salt = (XawTextSelectionSalt *)
2265 XtMalloc((unsigned)sizeof(XawTextSelectionSalt));
2266 if (!salt)
2267 return;
2268 salt->s.selections = (Atom *)XtMalloc((Cardinal)((size_t)num_atoms * sizeof(Atom)));
2269 if (!salt->s.selections) {
2270 XtFree((char *)salt);
2271 return;
2272 }
2273 salt->s.left = ctx->text.s.left;
2274 salt->s.right = ctx->text.s.right;
2275 salt->s.type = ctx->text.s.type;
2276 salt->contents = _XawTextGetSTRING(ctx, ctx->text.s.left, ctx->text.s.right);
2277 if (XawTextFormat(ctx, XawFmtWide)) {
2278 XTextProperty textprop;
2279 if (XwcTextListToTextProperty(XtDisplay((Widget)ctx),
2280 (wchar_t**)(&(salt->contents)), 1,
2281 XCompoundTextStyle,
2282 &textprop) < Success) {
2283 XtFree(salt->contents);
2284 salt->length = 0;
2285 return;
2286 }
2287 XtFree(salt->contents);
2288 salt->contents = (char *)textprop.value;
2289 salt->length = (int)textprop.nitems;
2290 }
2291 else
2292 salt->length = (int)strlen (salt->contents);
2293 salt->next = ctx->text.salt;
2294 ctx->text.salt = salt;
2295 j = 0;
2296 for (i = 0; i < num_atoms; i++) {
2297 if (GetCutBufferNumber (selections[i]) == NOT_A_CUT_BUFFER) {
2298 salt->s.selections[j++] = selections[i];
2299 XtOwnSelection((Widget)ctx, selections[i], ctx->text.time,
2300 TextConvertSelection, TextLoseSelection, NULL);
2301 }
2302 }
2303 salt->s.atom_count = j;
2304 }
2305
2306 static void
2307 _SetSelection(TextWidget ctx, XawTextPosition left, XawTextPosition right,
2308 Atom *selections, Cardinal count)
2309 {
2310 #ifndef OLDXAW
2311 Cardinal i;
2312 XawTextPosition pos;
2313 TextSrcObject src = (TextSrcObject)ctx->text.source;
2314
2315 for (i = 0; i < src->textSrc.num_text; i++) {
2316 TextWidget tw = (TextWidget)src->textSrc.text[i];
2317 Bool needs_updating = tw->text.old_insert < 0;
2318 Bool showposition = tw->text.showposition;
2319
2320 if (needs_updating) {
2321 tw->text.showposition = False;
2322 _XawTextPrepareToUpdate(tw);
2323 }
2324 #else
2325 TextWidget tw = ctx;
2326 XawTextPosition pos;
2327 #endif /* OLDXAW */
2328
2329 if (left < tw->text.s.left) {
2330 pos = Min(right, tw->text.s.left);
2331 _XawTextNeedsUpdating(tw, left, pos);
2332 }
2333 if (left > tw->text.s.left) {
2334 pos = Min(left, tw->text.s.right);
2335 _XawTextNeedsUpdating(tw, tw->text.s.left, pos);
2336 }
2337 if (right < tw->text.s.right) {
2338 pos = Max(right, tw->text.s.left);
2339 _XawTextNeedsUpdating(tw, pos, tw->text.s.right);
2340 }
2341 if (right > tw->text.s.right) {
2342 pos = Max(left, tw->text.s.right);
2343 _XawTextNeedsUpdating(tw, pos, right);
2344 }
2345
2346 tw->text.s.left = left;
2347 tw->text.s.right = right;
2348
2349 #ifndef OLDXAW
2350 if (needs_updating) {
2351 _XawTextExecuteUpdate(tw);
2352 tw->text.showposition = (Boolean)showposition;
2353 }
2354 }
2355 #endif /* OLDXAW */
2356
2357 SrcSetSelection(ctx->text.source, left, right,
2358 (count == 0) ? None : selections[0]);
2359
2360 if (left < right) {
2361 Widget w = (Widget)ctx;
2362
2363 while (count) {
2364 Atom selection = selections[--count];
2365 int buffer;
2366
2367 /*
2368 * If this is a cut buffer
2369 */
2370 if ((buffer = GetCutBufferNumber(selection)) != NOT_A_CUT_BUFFER) {
2371 unsigned char *ptr, *tptr;
2372 unsigned int amount, max_len = (unsigned)MAX_CUT_LEN(XtDisplay(w));
2373 unsigned long len;
2374
2375 tptr= ptr= (unsigned char *)_XawTextGetSTRING(ctx,
2376 ctx->text.s.left,
2377 ctx->text.s.right);
2378 if (XawTextFormat(ctx, XawFmtWide)) {
2379 /*
2380 * Only XA_STRING(Latin 1) is allowed in CUT_BUFFER,
2381 * so we get it from wchar string, then free the wchar string
2382 */
2383 XTextProperty textprop;
2384
2385 if (XwcTextListToTextProperty(XtDisplay(w), (wchar_t**)&ptr,
2386 1, XStringStyle, &textprop)
2387 < Success){
2388 XtFree((char *)ptr);
2389 return;
2390 }
2391 XtFree((char *)ptr);
2392 tptr = ptr = textprop.value;
2393 }
2394 if (buffer == 0) {
2395 _CreateCutBuffers(XtDisplay(w));
2396 XRotateBuffers(XtDisplay(w), 1);
2397 }
2398 amount = (unsigned)Min ((len = strlen((char *)ptr)), max_len);
2399 XChangeProperty(XtDisplay(w), RootWindow(XtDisplay(w), 0),
2400 selection, XA_STRING, 8, PropModeReplace,
2401 ptr, (int)amount);
2402
2403 while (len > max_len) {
2404 len -= max_len;
2405 tptr += max_len;
2406 amount = (unsigned) Min (len, max_len);
2407 XChangeProperty(XtDisplay(w), RootWindow(XtDisplay(w), 0),
2408 selection, XA_STRING, 8, PropModeAppend,
2409 tptr, (int)amount);
2410 }
2411 XtFree ((char *)ptr);
2412 }
2413 else /* This is a real selection */
2414 XtOwnSelection(w, selection, ctx->text.time, TextConvertSelection,
2415 TextLoseSelection, NULL);
2416 }
2417 }
2418 else
2419 XawTextUnsetSelection((Widget)ctx);
2420 }
2421
2422 #ifndef OLDXAW
2423 void
2424 _XawTextSetLineAndColumnNumber(TextWidget ctx, Bool force)
2425 {
2426 int line_number, column_number;
2427
2428 if (ctx->text.old_insert != ctx->text.insertPos &&
2429 ctx->text.lt.base_line < 0) {
2430 ctx->text.lt.base_line = 0;
2431 (void)_BuildLineTable(ctx, ctx->text.lt.top, 0);
2432 }
2433
2434 line_number = ResolveLineNumber(ctx);
2435 column_number = ResolveColumnNumber(ctx);
2436
2437 if (force || (ctx->text.column_number != column_number
2438 || ctx->text.line_number != line_number)) {
2439 XawTextPositionInfo info;
2440
2441 ctx->text.line_number = info.line_number = line_number;
2442 ctx->text.column_number = (short)(info.column_number = column_number);
2443 info.insert_position = ctx->text.insertPos;
2444 info.last_position = ctx->text.lastPos;
2445 info.overwrite_mode = ctx->text.overwrite;
2446
2447 XtCallCallbacks((Widget)ctx, XtNpositionCallback, (XtPointer)&info);
2448 }
2449 }
2450
2451 static int
2452 ResolveColumnNumber(TextWidget ctx)
2453 {
2454 Widget src = ctx->text.source;
2455 short column_number = 0;
2456 XawTextPosition position;
2457 XawTextBlock block;
2458 unsigned long format = (unsigned long)_XawTextFormat(ctx);
2459 TextSinkObject sink = (TextSinkObject)ctx->text.sink;
2460 short *char_tabs = sink->text_sink.char_tabs;
2461 int tab_count = sink->text_sink.tab_count;
2462 int tab_index = 0, tab_column = 0, tab_base = 0;
2463
2464 if (ctx->text.lt.base_line < 1)
2465 return (ctx->text.column_number);
2466
2467 position = SrcScan(src, ctx->text.insertPos, XawstEOL, XawsdLeft, 1, False);
2468 XawTextSourceRead(src, position, &block, (int)(ctx->text.insertPos - position));
2469
2470 for (; position < ctx->text.insertPos; position++) {
2471 if (position - block.firstPos >= block.length)
2472 XawTextSourceRead(src, position, &block, (int)(ctx->text.insertPos - position));
2473 if ((format == XawFmt8Bit && block.ptr[position - block.firstPos] == '\t') ||
2474 (format == XawFmtWide && ((wchar_t*)block.ptr)[position - block.firstPos] == _Xaw_atowc(XawTAB))) {
2475 while (tab_base + tab_column <= column_number) {
2476 if (tab_count) {
2477 for (; tab_index < tab_count; ++tab_index)
2478 if (tab_base + char_tabs[tab_index] > column_number) {
2479 tab_column = char_tabs[tab_index];
2480 break;
2481 }
2482 if (tab_index >= tab_count) {
2483 tab_base += char_tabs[tab_count - 1];
2484 tab_column = tab_index = 0;
2485 }
2486 }
2487 else
2488 tab_column += DEFAULT_TAB_SIZE;
2489 }
2490 column_number = (short)(tab_base + tab_column);
2491 }
2492 else
2493 ++column_number;
2494 if (column_number >= 16384) {
2495 column_number = 16383;
2496 break;
2497 }
2498 }
2499
2500 return (column_number);
2501 }
2502 #endif /* OLDXAW */
2503
2504 void
2505 _XawTextSourceChanged(Widget w, XawTextPosition left, XawTextPosition right,
2506 XawTextBlock *block, int lines _X_UNUSED)
2507 {
2508 TextWidget ctx = (TextWidget)w;
2509 Widget src = ctx->text.source;
2510 XawTextPosition update_from, update_to, top;
2511 Boolean update_disabled;
2512 int delta, line, line_from;
2513
2514 if (left < ctx->text.old_insert) {
2515 XawTextPosition old_insert = ctx->text.old_insert;
2516
2517 if (right < ctx->text.old_insert)
2518 old_insert -= right - left;
2519 else
2520 old_insert = left;
2521
2522 ctx->text.insertPos = old_insert + block->length;
2523 }
2524 #ifndef OLDXAW
2525 if (left <= ctx->text.lt.top) {
2526 if (left + block->length - (right - left) < ctx->text.lt.top) {
2527 ctx->text.source_changed = SRC_CHANGE_BEFORE;
2528 ctx->text.lt.base_line += lines;
2529 }
2530 else
2531 ctx->text.source_changed = SRC_CHANGE_OVERLAP;
2532 }
2533 else
2534 ctx->text.source_changed = SRC_CHANGE_AFTER;
2535 #endif
2536
2537 update_from = left;
2538 update_to = left + block->length;
2539 update_to = SrcScan(src, update_to, XawstEOL, XawsdRight, 1, False);
2540 delta = (int)(block->length - (right - left));
2541 if (delta < 0)
2542 ctx->text.clear_to_eol = True;
2543 if (update_to == update_from)
2544 ++update_to;
2545 update_disabled = ctx->text.update_disabled;
2546 ctx->text.update_disabled = True;
2547 ctx->text.lastPos = XawTextGetLastPosition(ctx);
2548 top = ctx->text.lt.info[0].position;
2549
2550 XawTextUnsetSelection((Widget)ctx);
2551
2552 if (delta) {
2553 int i;
2554 XmuSegment *seg;
2555
2556 for (seg = ctx->text.update->segment; seg; seg = seg->next) {
2557 if (seg->x1 > (int)left)
2558 break;
2559 else if (seg->x2 > (int)left) {
2560 seg->x2 += delta;
2561 seg = seg->next;
2562 break;
2563 }
2564 }
2565 for (; seg; seg = seg->next) {
2566 seg->x1 += delta;
2567 seg->x2 += delta;
2568 }
2569 XmuOptimizeScanline(ctx->text.update);
2570
2571 for (i = 0; i <= ctx->text.lt.lines; i++)
2572 if (ctx->text.lt.info[i].position > left)
2573 break;
2574 for (; i <= ctx->text.lt.lines; i++)
2575 ctx->text.lt.info[i].position += delta;
2576 }
2577
2578 if (top != ctx->text.lt.info[0].position) {
2579 line_from = line = 0;
2580 ctx->text.lt.top = top = SrcScan(src, ctx->text.lt.info[0].position,
2581 XawstEOL, XawsdLeft, 1, False);
2582 update_from = top;
2583 }
2584 else {
2585 line_from = line = LineForPosition(ctx, update_from + delta);
2586 top = ctx->text.lt.info[line].position;
2587 }
2588
2589 if (line > 0 && ctx->text.wrap == XawtextWrapWord) {
2590 --line;
2591 top = ctx->text.lt.info[line].position;
2592 }
2593
2594 (void)_BuildLineTable(ctx, top, line);
2595
2596 if (ctx->text.wrap == XawtextWrapWord) {
2597 if (line_from != LineForPosition(ctx, update_from)
2598 || line_from != LineForPosition(ctx, update_to)) {
2599 ctx->text.clear_to_eol = True;
2600 update_from = SrcScan(src, update_from,
2601 XawstWhiteSpace, XawsdLeft, 1, True);
2602 if (update_to >= ctx->text.lastPos)
2603 /* this is not an error, it just tells _BuildLineTable to
2604 * clear to the bottom of the window. The value of update_to
2605 * should not be > ctx->text.lastPos.
2606 */
2607 ++update_to;
2608 }
2609 }
2610 else if (!ctx->text.clear_to_eol) {
2611 if (LineForPosition(ctx, update_from)
2612 != LineForPosition(ctx, update_to))
2613 ctx->text.clear_to_eol = True;
2614 }
2615
2616 _XawTextNeedsUpdating(ctx, update_from, update_to);
2617 ctx->text.update_disabled = update_disabled;
2618 }
2619
2620 /*
2621 * Function:
2622 * _XawTextReplace
2623 *
2624 * Parameters:
2625 * ctx - text widget
2626 * left - left offset
2627 * right - right offset
2628 * block - text block
2629 *
2630 * Description:
2631 * Replaces the text between left and right by the text in block.
2632 * Does all the required calculations of offsets, and rebuild the
2633 * the line table, from the insertion point (or previous line, if
2634 * wrap mode is 'word').
2635 *
2636 * Returns:
2637 * XawEditDone - success
2638 * any other value - error code
2639 */
2640 int
2641 _XawTextReplace(TextWidget ctx, XawTextPosition left, XawTextPosition right,
2642 XawTextBlock *block)
2643 {
2644 Arg args[1];
2645 Widget src;
2646 XawTextEditType edit_mode;
2647
2648 if (left == right && block->length == 0)
2649 return (XawEditDone);
2650
2651 src = ctx->text.source;
2652 XtSetArg(args[0], XtNeditType, &edit_mode);
2653 XtGetValues(src, args, 1);
2654
2655 if (edit_mode == XawtextAppend) {
2656 if (block->length == 0)
2657 return (XawEditError);
2658 ctx->text.insertPos = ctx->text.lastPos;
2659 }
2660
2661 #ifndef OLDXAW
2662 return (SrcReplace(src, left, right, block));
2663 #else
2664 if (SrcReplace(src, left, right, block) == XawEditDone) {
2665 _XawTextSourceChanged((Widget)ctx, left, right, block, 0);
2666
2667 return (XawEditDone);
2668 }
2669
2670 return (XawEditError);
2671 #endif
2672 }
2673
2674 /*
2675 * This routine will display text between two arbitrary source positions.
2676 * In the event that this span contains highlighted text for the selection,
2677 * only that portion will be displayed highlighted.
2678 */
2679 static void
2680 OldDisplayText(Widget w, XawTextPosition left, XawTextPosition right)
2681 {
2682 static XmuSegment segment;
2683 static XmuScanline next;
2684 static XmuScanline scanline = {0, &segment, &next};
2685 static XmuArea area = {&scanline};
2686
2687 TextWidget ctx = (TextWidget)w;
2688 int x, y, line;
2689 XawTextPosition last;
2690 XmuScanline *scan;
2691 XmuSegment *seg;
2692 XmuArea *clip = NULL;
2693 Bool cleol = ctx->text.clear_to_eol;
2694 Bool has_selection = ctx->text.s.right > ctx->text.s.left;
2695 XawTextPosition start;
2696
2697 left = left < ctx->text.lt.top ? ctx->text.lt.top : left;
2698
2699 if (left > right || !LineAndXYForPosition(ctx, left, &line, &x, &y))
2700 return;
2701
2702 last = XawTextGetLastPosition(ctx);
2703 segment.x2 = (int)XtWidth(ctx) - ctx->text.r_margin.right;
2704
2705 if (cleol)
2706 clip = XmuCreateArea();
2707
2708 for (start = left;
2709 start < right && line < ctx->text.lt.lines; line++) {
2710 XawTextPosition end, final;
2711
2712 if ((end = ctx->text.lt.info[line + 1].position) > right)
2713 end = right;
2714
2715 final = end;
2716 if (end > last)
2717 end = last;
2718
2719 if (end > start) {
2720 if (!has_selection
2721 || (start >= ctx->text.s.right || end <= ctx->text.s.left))
2722 _XawTextSinkDisplayText(ctx->text.sink, x, y, start, end, False);
2723 else if (start >= ctx->text.s.left && end <= ctx->text.s.right)
2724 _XawTextSinkDisplayText(ctx->text.sink, x, y, start, end, True);
2725 else {
2726 OldDisplayText(w, start, ctx->text.s.left);
2727 OldDisplayText(w, Max(start, ctx->text.s.left),
2728 Min(end, ctx->text.s.right));
2729 OldDisplayText(w, ctx->text.s.right, end);
2730 }
2731 }
2732
2733 x = ctx->text.left_margin;
2734 if (cleol) {
2735 segment.x1 = (int)(ctx->text.lt.info[line].textWidth + (unsigned)x);
2736 if (XmuValidSegment(&segment)) {
2737 scanline.y = y;
2738 next.y = ctx->text.lt.info[line + 1].y;
2739 XmuAreaOr(clip, &area);
2740 }
2741 }
2742
2743 start = final;
2744 y = ctx->text.lt.info[line + 1].y;
2745 }
2746
2747 if (cleol) {
2748 for (scan = clip->scanline; scan && scan->next; scan = scan->next)
2749 for (seg = scan->segment; seg; seg = seg->next)
2750 SinkClearToBG(ctx->text.sink,
2751 seg->x1, scan->y,
2752 (unsigned)(seg->x2 - seg->x1),
2753 (unsigned)(scan->next->y - scan->y));
2754 XmuDestroyArea(clip);
2755 }
2756 }
2757
2758 #ifndef OLDXAW
2759 /*ARGSUSED*/
2760 static void
2761 DisplayText(Widget w, XawTextPosition left, XawTextPosition right)
2762 {
2763 static XmuSegment segment;
2764 static XmuScanline next;
2765 static XmuScanline scanline = {0, &segment, &next};
2766 static XmuArea area = {&scanline};
2767
2768 TextWidget ctx = (TextWidget)w;
2769 int y, line;
2770 XawTextPosition lastPos;
2771 Bool cleol = ctx->text.clear_to_eol;
2772 Bool has_selection = ctx->text.s.right > ctx->text.s.left;
2773 XawTextPaintList *paint_list;
2774 XawTextPosition from;
2775
2776 left = left < ctx->text.lt.top ? ctx->text.lt.top : left;
2777
2778 if (left > right || !IsPositionVisible(ctx, left))
2779 return;
2780
2781 line = LineForPosition(ctx, left);
2782 y = ctx->text.lt.info[line].y;
2783 segment.x2 = (int)XtWidth(ctx) - ctx->text.r_margin.right;
2784 lastPos = XawTextGetLastPosition(ctx);
2785
2786 paint_list = ((TextSinkObject)ctx->text.sink)->text_sink.paint;
2787
2788 for (from = left;
2789 from < right && line < ctx->text.lt.lines; line++) {
2790 XawTextPosition to = ctx->text.lt.info[line + 1].position;
2791
2792 if (to > right)
2793 to = right;
2794
2795 if (to > lastPos)
2796 to = lastPos;
2797
2798 if (from < to) {
2799 if (!has_selection
2800 || (from >= ctx->text.s.right || to <= ctx->text.s.left))
2801 XawTextSinkPreparePaint(ctx->text.sink, y, line, from, to, False);
2802 else if (from >= ctx->text.s.left && to <= ctx->text.s.right)
2803 XawTextSinkPreparePaint(ctx->text.sink, y, line, from, to, True);
2804 else {
2805 XawTextSinkPreparePaint(ctx->text.sink, y, line, from,
2806 ctx->text.s.left, False);
2807 XawTextSinkPreparePaint(ctx->text.sink, y, line,
2808 XawMax(from, ctx->text.s.left),
2809 XawMin(to, ctx->text.s.right), True);
2810 XawTextSinkPreparePaint(ctx->text.sink, y, line,
2811 ctx->text.s.right, to, False);
2812 }
2813 }
2814
2815 if (cleol) {
2816 segment.x1 = (int)(ctx->text.lt.info[line].textWidth + (unsigned)ctx->text.left_margin);
2817 if (XmuValidSegment(&segment)) {
2818 scanline.y = y;
2819 next.y = ctx->text.lt.info[line + 1].y;
2820 XmuAreaOr(paint_list->clip, &area);
2821 }
2822 }
2823 y = ctx->text.lt.info[line + 1].y;
2824 from = to;
2825 }
2826
2827 /* clear to the bottom of the window */
2828 if (cleol && line >= ctx->text.lt.lines) {
2829 segment.x1 = ctx->text.left_margin;
2830 if (XmuValidSegment(&segment)) {
2831 scanline.y = y;
2832 next.y = (int)XtHeight(ctx) - (int)ctx->text.margin.bottom;
2833 XmuAreaOr(paint_list->clip, &area);
2834 }
2835 }
2836 }
2837 #endif
2838
2839 /*
2840 * This routine implements multi-click selection in a hardwired manner.
2841 * It supports multi-click entity cycling (char, word, line, file) and mouse
2842 * motion adjustment of the selected entity (i.e. select a word then, with
2843 * button still down, adjust which word you really meant by moving the mouse).
2844 * [NOTE: This routine is to be replaced by a set of procedures that
2845 * will allows clients to implements a wide class of draw through and
2846 * multi-click selection user interfaces.]
2847 */
2848 static void
2849 DoSelection(TextWidget ctx, XawTextPosition pos, Time time, Bool motion)
2850 {
2851 XawTextPosition newLeft, newRight;
2852 XawTextSelectType newType;
2853 Widget src = ctx->text.source;
2854
2855 if (motion)
2856 newType = ctx->text.s.type;
2857 else {
2858 if ((labs((long) time - (long) ctx->text.lasttime) < MULTI_CLICK_TIME)
2859 && (pos >= ctx->text.s.left && pos <= ctx->text.s.right)) {
2860 XawTextSelectType *sarray = ctx->text.sarray;
2861
2862 for (; *sarray != XawselectNull && *sarray != ctx->text.s.type;
2863 sarray++)
2864 ;
2865 if (*sarray == XawselectNull)
2866 newType = *(ctx->text.sarray);
2867 else {
2868 newType = *(sarray + 1);
2869 if (newType == XawselectNull)
2870 newType = *(ctx->text.sarray);
2871 }
2872 }
2873 else /* single-click event */
2874 newType = *(ctx->text.sarray);
2875
2876 ctx->text.lasttime = time;
2877 }
2878 switch (newType) {
2879 case XawselectPosition:
2880 newLeft = newRight = pos;
2881 break;
2882 case XawselectChar:
2883 newLeft = pos;
2884 newRight = SrcScan(src, pos, XawstPositions, XawsdRight, 1, False);
2885 break;
2886 case XawselectWord:
2887 case XawselectParagraph:
2888 case XawselectAlphaNumeric: {
2889 XawTextScanType stype;
2890
2891 if (newType == XawselectWord)
2892 stype = XawstWhiteSpace;
2893 else if (newType == XawselectParagraph)
2894 stype = XawstParagraph;
2895 else
2896 stype = XawstAlphaNumeric;
2897
2898 /*
2899 * Somewhat complicated, but basically I treat the space between
2900 * two objects as another object. The object that I am currently
2901 * in then becomes the end of the selection.
2902 *
2903 * Chris Peterson - 4/19/90.
2904 */
2905 newRight = SrcScan(ctx->text.source, pos, stype,
2906 XawsdRight, 1, False);
2907 newRight = SrcScan(ctx->text.source, newRight, stype,
2908 XawsdLeft, 1, False);
2909
2910 if (pos != newRight)
2911 newLeft = SrcScan(ctx->text.source, pos, stype,
2912 XawsdLeft, 1, False);
2913 else
2914 newLeft = pos;
2915
2916 newLeft =SrcScan(ctx->text.source, newLeft, stype,
2917 XawsdRight, 1, False);
2918
2919 if (newLeft > newRight) {
2920 XawTextPosition temp = newLeft;
2921 newLeft = newRight;
2922 newRight = temp;
2923 }
2924 } break;
2925 case XawselectLine:
2926 newLeft = SrcScan(src, pos, XawstEOL, XawsdLeft, 1, False);
2927 newRight = SrcScan(src, pos, XawstEOL, XawsdRight, 1, False);
2928 break;
2929 case XawselectAll:
2930 newLeft = SrcScan(src, pos, XawstAll, XawsdLeft, 1, False);
2931 newRight = SrcScan(src, pos, XawstAll, XawsdRight, 1, False);
2932 break;
2933 default:
2934 XtAppWarning(XtWidgetToApplicationContext((Widget) ctx),
2935 "Text Widget: empty selection array.");
2936 return;
2937 }
2938
2939 if (newLeft != ctx->text.s.left || newRight != ctx->text.s.right
2940 || newType != ctx->text.s.type) {
2941 ModifySelection(ctx, newLeft, newRight);
2942 if (pos - ctx->text.s.left < ctx->text.s.right - pos)
2943 ctx->text.insertPos = newLeft;
2944 else
2945 ctx->text.insertPos = newRight;
2946 ctx->text.s.type = newType;
2947 }
2948 if (!motion) { /* setup so we can freely mix select extend calls*/
2949 ctx->text.origSel.type = ctx->text.s.type;
2950 ctx->text.origSel.left = ctx->text.s.left;
2951 ctx->text.origSel.right = ctx->text.s.right;
2952
2953 if (pos >= ctx->text.s.left + (ctx->text.s.right - ctx->text.s.left) / 2)
2954 ctx->text.extendDir = XawsdRight;
2955 else
2956 ctx->text.extendDir = XawsdLeft;
2957 }
2958 }
2959
2960 /*
2961 * This routine implements extension of the currently selected text in
2962 * the "current" mode (i.e. char word, line, etc.). It worries about
2963 * extending from either end of the selection and handles the case when you
2964 * cross through the "center" of the current selection (e.g. switch which
2965 * end you are extending!).
2966 */
2967 static void
2968 ExtendSelection(TextWidget ctx, XawTextPosition pos, Bool motion)
2969 {
2970 XawTextScanDirection dir;
2971
2972 if (!motion) { /* setup for extending selection */
2973 if (ctx->text.s.left == ctx->text.s.right) /* no current selection. */
2974 ctx->text.s.left = ctx->text.s.right = ctx->text.insertPos;
2975 else {
2976 ctx->text.origSel.left = ctx->text.s.left;
2977 ctx->text.origSel.right = ctx->text.s.right;
2978 }
2979
2980 ctx->text.origSel.type = ctx->text.s.type;
2981
2982 if (pos >= ctx->text.s.left + (ctx->text.s.right - ctx->text.s.left) / 2)
2983 ctx->text.extendDir = XawsdRight;
2984 else
2985 ctx->text.extendDir = XawsdLeft;
2986 }
2987 else /* check for change in extend direction */
2988 if ((ctx->text.extendDir == XawsdRight &&
2989 pos <= ctx->text.origSel.left) ||
2990 (ctx->text.extendDir == XawsdLeft &&
2991 pos >= ctx->text.origSel.right)) {
2992 ctx->text.extendDir = (ctx->text.extendDir == XawsdRight) ?
2993 XawsdLeft : XawsdRight;
2994 ModifySelection(ctx, ctx->text.origSel.left, ctx->text.origSel.right);
2995 }
2996
2997 dir = ctx->text.extendDir;
2998 switch (ctx->text.s.type) {
2999 case XawselectWord:
3000 case XawselectParagraph:
3001 case XawselectAlphaNumeric: {
3002 XawTextPosition left_pos, right_pos;
3003 XawTextScanType stype;
3004
3005 if (ctx->text.s.type == XawselectWord)
3006 stype = XawstWhiteSpace;
3007 else if (ctx->text.s.type == XawselectParagraph)
3008 stype = XawstParagraph;
3009 else
3010 stype = XawstAlphaNumeric;
3011
3012 /*
3013 * Somewhat complicated, but basically I treat the space between
3014 * two objects as another object. The object that I am currently
3015 * in then becomes the end of the selection.
3016 *
3017 * Chris Peterson - 4/19/90.
3018 */
3019 right_pos = SrcScan(ctx->text.source, pos, stype,
3020 XawsdRight, 1, False);
3021 right_pos =SrcScan(ctx->text.source, right_pos, stype,
3022 XawsdLeft, 1, False);
3023
3024 if (pos != right_pos)
3025 left_pos = SrcScan(ctx->text.source, pos, stype,
3026 XawsdLeft, 1, False);
3027 else
3028 left_pos = pos;
3029
3030 left_pos =SrcScan(ctx->text.source, left_pos, stype,
3031 XawsdRight, 1, False);
3032
3033 if (dir == XawsdLeft)
3034 pos = Min(left_pos, right_pos);
3035 else /* dir == XawsdRight */
3036 pos = Max(left_pos, right_pos);
3037 } break;
3038 case XawselectLine:
3039 pos = SrcScan(ctx->text.source, pos, XawstEOL,
3040 dir, 1, dir == XawsdRight);
3041 break;
3042 case XawselectAll:
3043 pos = ctx->text.insertPos;
3044 /*FALLTHROUGH*/
3045 case XawselectPosition:
3046 default:
3047 break;
3048 }
3049
3050 if (dir == XawsdRight)
3051 ModifySelection(ctx, ctx->text.s.left, pos);
3052 else
3053 ModifySelection(ctx, pos, ctx->text.s.right);
3054
3055 ctx->text.insertPos = pos;
3056 }
3057
3058 /*
3059 * Function:
3060 * _XawTextClearAndCenterDisplay
3061 *
3062 * Parameters:
3063 * ctx - text widget
3064 *
3065 * Description:
3066 * Redraws the display with the cursor in insert point
3067 * centered vertically.
3068 */
3069 void
3070 _XawTextClearAndCenterDisplay(TextWidget ctx)
3071 {
3072 int left_margin = ctx->text.left_margin;
3073 Bool visible = IsPositionVisible(ctx, ctx->text.insertPos);
3074
3075 _XawTextShowPosition(ctx);
3076
3077 if (XtIsRealized((Widget)ctx) && visible &&
3078 left_margin == ctx->text.left_margin) {
3079 int insert_line = LineForPosition(ctx, ctx->text.insertPos);
3080 int scroll_by = insert_line - (ctx->text.lt.lines >> 1);
3081 Boolean clear_to_eol;
3082
3083 XawTextScroll(ctx, scroll_by, 0);
3084 SinkClearToBG(ctx->text.sink, 0, 0, XtWidth(ctx), XtHeight(ctx));
3085 ClearWindow(ctx);
3086 clear_to_eol = ctx->text.clear_to_eol;
3087 ctx->text.clear_to_eol = False;
3088 FlushUpdate(ctx);
3089 ctx->text.clear_to_eol = clear_to_eol;
3090 }
3091 }
3092
3093 /*
3094 * Internal redisplay entire window
3095 * Legal to call only if widget is realized
3096 */
3097 static void
3098 DisplayTextWindow(Widget w)
3099 {
3100 TextWidget ctx = (TextWidget)w;
3101
3102 _XawTextBuildLineTable(ctx, ctx->text.lt.top, False);
3103 ClearWindow(ctx);
3104 }
3105
3106 static void
3107 TextSinkResize(Widget w)
3108 {
3109 if (w && XtClass(w)->core_class.resize)
3110 XtClass(w)->core_class.resize(w);
3111 }
3112
3113 /* ARGSUSED */
3114 void
3115 _XawTextCheckResize(TextWidget ctx _X_UNUSED)
3116 {
3117 return;
3118 }
3119
3120 /*
3121 * Converts (params, num_params) to a list of atoms & caches the
3122 * list in the TextWidget instance.
3123 */
3124 Atom *
3125 _XawTextSelectionList(TextWidget ctx, String *list, Cardinal nelems)
3126 {
3127 Atom *sel = ctx->text.s.selections;
3128 Display *dpy = XtDisplay((Widget)ctx);
3129 int n;
3130
3131 if (nelems > (Cardinal)ctx->text.s.array_size) {
3132 sel = (Atom *)XtRealloc((char *)sel, (Cardinal)(sizeof(Atom) * (size_t)nelems));
3133 ctx->text.s.array_size = (int)nelems;
3134 ctx->text.s.selections = sel;
3135 }
3136 for (n = (int)nelems; --n >= 0; sel++, list++)
3137 *sel = XInternAtom(dpy, *list, False);
3138 ctx->text.s.atom_count = (int)nelems;
3139
3140 return (ctx->text.s.selections);
3141 }
3142
3143 /*
3144 * Function:
3145 * SetSelection
3146 *
3147 * Parameters:
3148 * ctx - text widget
3149 * defaultSel - default selection
3150 * l - left and right ends of the selection
3151 * r - ""
3152 * list - the selection list (as strings).
3153 * nelems - ""
3154 *
3155 * Description:
3156 * Sets the current selection.
3157 *
3158 * Note:
3159 * if (ctx->text.s.left >= ctx->text.s.right) then the selection is unset
3160 */
3161 void
3162 _XawTextSetSelection(TextWidget ctx, XawTextPosition l, XawTextPosition r,
3163 String *list, Cardinal nelems)
3164 {
3165 if (nelems == 1 && !strcmp (list[0], "none"))
3166 return;
3167 if (nelems == 0) {
3168 static String defaultSel = "PRIMARY";
3169 list = &defaultSel;
3170 nelems = 1;
3171 }
3172 _SetSelection(ctx, l, r, _XawTextSelectionList(ctx, list, nelems), nelems);
3173 }
3174
3175 /*
3176 * Function:
3177 * ModifySelection
3178 *
3179 * Parameters:
3180 * ctx - text widget
3181 * left - left and right ends of the selection
3182 * right - ""
3183 *
3184 * Description:
3185 * Modifies the current selection.
3186 *
3187 * Note:
3188 * if (ctx->text.s.left >= ctx->text.s.right) then the selection is unset
3189 */
3190 static void
3191 ModifySelection(TextWidget ctx, XawTextPosition left, XawTextPosition right)
3192 {
3193 if (left == right)
3194 ctx->text.insertPos = left;
3195 _SetSelection(ctx, left, right, NULL, 0);
3196 }
3197
3198 /*
3199 * This routine is used to perform various selection functions. The goal is
3200 * to be able to specify all the more popular forms of draw-through and
3201 * multi-click selection user interfaces from the outside.
3202 */
3203 void
3204 _XawTextAlterSelection(TextWidget ctx, XawTextSelectionMode mode,
3205 XawTextSelectionAction action, String *params,
3206 Cardinal *num_params)
3207 {
3208 XawTextPosition position;
3209 Boolean flag;
3210
3211 /*
3212 * This flag is used by TextPop.c:DoReplace() to determine if the selection
3213 * is okay to use, or if it has been modified.
3214 */
3215 if (ctx->text.search != NULL)
3216 ctx->text.search->selection_changed = True;
3217
3218 position = PositionForXY(ctx, (int) ctx->text.ev_x, (int) ctx->text.ev_y);
3219
3220 flag = (action != XawactionStart);
3221 if (mode == XawsmTextSelect)
3222 DoSelection(ctx, position, ctx->text.time, flag);
3223 else /* mode == XawsmTextExtend */
3224 ExtendSelection (ctx, position, flag);
3225
3226 if (action == XawactionEnd)
3227 _XawTextSetSelection(ctx, ctx->text.s.left, ctx->text.s.right,
3228 params, *num_params);
3229 }
3230
3231 /*
3232 * Function:
3233 * UpdateTextInRectangle
3234 *
3235 * Parameters:
3236 * ctx - the text widget
3237 * rect - rectangle
3238 *
3239 * Description:
3240 * Updates the text in the given rectangle
3241 */
3242 static void
3243 UpdateTextInRectangle(TextWidget ctx, XRectangle *rect)
3244 {
3245 XawTextLineTable *lt;
3246 int line, y1, y2, x2;
3247
3248 y1 = rect->y;
3249 y2 = y1 + rect->height;
3250 x2 = rect->x + rect->width;
3251
3252 for (line = 0, lt = &ctx->text.lt; line < lt->lines; line++)
3253 if (lt->info[line + 1].y > y1)
3254 break;
3255 for (; line <= lt->lines; line++) {
3256 if (lt->info[line].y > y2)
3257 break;
3258 UpdateTextInLine(ctx, line, rect->x, x2);
3259 }
3260 }
3261
3262 /*
3263 * This routine processes all "expose region" XEvents. In general, its job
3264 * is to the best job at minimal re-paint of the text, displayed in the
3265 * window, that it can.
3266 */
3267 /* ARGSUSED */
3268 static void
3269 XawTextExpose(Widget w, XEvent *event, Region region)
3270 {
3271 TextWidget ctx = (TextWidget)w;
3272 Boolean clear_to_eol;
3273 XRectangle expose;
3274
3275 if (event->type == Expose) {
3276 expose.x = (short)event->xexpose.x;
3277 expose.y = (short)event->xexpose.y;
3278 expose.width = (unsigned short)event->xexpose.width;
3279 expose.height = (unsigned short)event->xexpose.height;
3280 }
3281 else if (event->type == GraphicsExpose) {
3282 expose.x = (short)event->xgraphicsexpose.x;
3283 expose.y = (short)event->xgraphicsexpose.y;
3284 expose.width = (unsigned short)event->xgraphicsexpose.width;
3285 expose.height = (unsigned short)event->xgraphicsexpose.height;
3286 }
3287 else
3288 return;
3289
3290 _XawTextPrepareToUpdate(ctx);
3291
3292 if (Superclass->core_class.expose)
3293 (*Superclass->core_class.expose)(w, event, region);
3294
3295 clear_to_eol = ctx->text.clear_to_eol;
3296 ctx->text.clear_to_eol = False;
3297
3298 UpdateTextInRectangle(ctx, &expose);
3299 XawTextSinkGetCursorBounds(ctx->text.sink, &expose);
3300 UpdateTextInRectangle(ctx, &expose);
3301 SinkClearToBG(ctx->text.sink, expose.x, expose.y,
3302 expose.width, expose.height);
3303 _XawTextExecuteUpdate(ctx);
3304 ctx->text.clear_to_eol = clear_to_eol;
3305 }
3306
3307 /*
3308 * This routine does all setup required to synchronize batched screen updates
3309 */
3310 void
3311 _XawTextPrepareToUpdate(TextWidget ctx)
3312 {
3313 if (ctx->text.old_insert < 0) {
3314 InsertCursor((Widget)ctx, XawisOff);
3315 ctx->text.showposition = False;
3316 ctx->text.old_insert = ctx->text.insertPos;
3317 ctx->text.clear_to_eol = False;
3318 #ifndef OLDXAW
3319 ctx->text.source_changed = SRC_CHANGE_NONE;
3320 #endif
3321 }
3322 }
3323
3324 /*
3325 * This is a private utility routine used by _XawTextExecuteUpdate. It
3326 * processes all the outstanding update requests and merges update
3327 * ranges where possible.
3328 */
3329 static void
3330 FlushUpdate(TextWidget ctx)
3331 {
3332 XmuSegment *seg;
3333 void (*display_text)(Widget, XawTextPosition, XawTextPosition);
3334
3335 if (XtIsRealized((Widget)ctx)) {
3336 ctx->text.s.right = XawMin(ctx->text.s.right, ctx->text.lastPos);
3337 ctx->text.s.left = XawMin(ctx->text.s.left, ctx->text.s.right);
3338
3339 #ifndef OLDXAW
3340 if (XawTextSinkBeginPaint(ctx->text.sink) == False)
3341 #endif
3342 display_text = OldDisplayText;
3343 #ifndef OLDXAW
3344 else
3345 display_text = DisplayText;
3346 #endif
3347 for (seg = ctx->text.update->segment; seg; seg = seg->next)
3348 (*display_text)((Widget)ctx,
3349 (XawTextPosition)seg->x1,
3350 (XawTextPosition)seg->x2);
3351 #ifndef OLDXAW
3352 if (display_text != OldDisplayText) {
3353 XawTextSinkDoPaint(ctx->text.sink);
3354 XawTextSinkEndPaint(ctx->text.sink);
3355 }
3356 #endif
3357 }
3358 (void)XmuScanlineXor(ctx->text.update, ctx->text.update);
3359 }
3360
3361 static int
3362 CountLines(TextWidget ctx, XawTextPosition left, XawTextPosition right)
3363 {
3364 if (ctx->text.wrap == XawtextWrapNever || left >= right)
3365 return (1);
3366 else {
3367 int dim, lines = 0, wwidth = GetMaxTextWidth(ctx);
3368
3369 while (left < right) {
3370 XawTextPosition tmp = left;
3371
3372 XawTextSinkFindPosition(ctx->text.sink, left,
3373 ctx->text.left_margin,
3374 wwidth, ctx->text.wrap == XawtextWrapWord,
3375 &left, &dim, &dim);
3376 ++lines;
3377 if (tmp == left)
3378 ++left;
3379 }
3380
3381 return (lines);
3382 }
3383 /*NOTREACHED*/
3384 }
3385
3386 static int
3387 GetMaxTextWidth(TextWidget ctx)
3388 {
3389 XRectangle cursor;
3390 int width;
3391
3392 XawTextSinkGetCursorBounds(ctx->text.sink, &cursor);
3393 width = (int)XtWidth(ctx) - RHMargins(ctx) - cursor.width;
3394
3395 return (XawMax(0, width));
3396 }
3397
3398 /*
3399 * Function:
3400 * _XawTextShowPosition
3401 *
3402 * Parameters:
3403 * ctx - the text widget to show the position
3404 *
3405 * Description:
3406 * Makes sure the text cursor visible, scrolling the text window
3407 * if required.
3408 */
3409 void
3410 _XawTextShowPosition(TextWidget ctx)
3411 {
3412 /*
3413 * Variable scroll is used to avoid scanning large files to calculate
3414 * line offsets
3415 */
3416 int hpixels, vlines;
3417 XawTextPosition first, last, top, tmp;
3418 Bool visible, scroll;
3419
3420 if (!XtIsRealized((Widget)ctx))
3421 return;
3422
3423 /*
3424 * Checks if a horizontal scroll is required
3425 */
3426 if (ctx->text.wrap == XawtextWrapNever) {
3427 int x, vwidth, distance, dim;
3428 XRectangle rect;
3429
3430 vwidth = (int)XtWidth(ctx) - RHMargins(ctx);
3431 last = SrcScan(ctx->text.source, ctx->text.insertPos,
3432 XawstEOL, XawsdLeft, 1, False);
3433 XawTextSinkFindDistance(ctx->text.sink, last,
3434 ctx->text.left_margin,
3435 ctx->text.insertPos,
3436 &distance, &first, &dim);
3437 XawTextSinkGetCursorBounds(ctx->text.sink, &rect);
3438 x = ctx->text.left_margin - ctx->text.r_margin.left;
3439
3440 if (x + distance + rect.width > vwidth)
3441 hpixels = x + distance + rect.width - vwidth + (vwidth >> 2);
3442 else if (x + distance < 0)
3443 hpixels = x + distance - (vwidth >> 2);
3444 else
3445 hpixels = 0;
3446 }
3447 else
3448 hpixels = 0;
3449
3450 visible = IsPositionVisible(ctx, ctx->text.insertPos);
3451
3452 /*
3453 * If the cursor is already visible
3454 */
3455 if (!hpixels && visible)
3456 return;
3457
3458 scroll = ctx->core.background_pixmap == XtUnspecifiedPixmap && !hpixels;
3459 vlines = 0;
3460 first = ctx->text.lt.top;
3461
3462 /*
3463 * Needs to scroll the text window
3464 */
3465 if (visible)
3466 top = ctx->text.lt.top;
3467 else {
3468 top = SrcScan(ctx->text.source, ctx->text.insertPos,
3469 XawstEOL, XawsdLeft, 1, False);
3470
3471 /*
3472 * Finds the nearest left position from ctx->text.insertPos
3473 */
3474 if (ctx->text.wrap != XawtextWrapNever) {
3475 int dim, vwidth = GetMaxTextWidth(ctx);
3476
3477 last = top;
3478 /*CONSTCOND*/
3479 while (1) {
3480 tmp = last;
3481 XawTextSinkFindPosition(ctx->text.sink, last,
3482 ctx->text.left_margin, vwidth,
3483 ctx->text.wrap == XawtextWrapWord,
3484 &last, &dim, &dim);
3485 if (last == tmp)
3486 ++last;
3487 if (last <= ctx->text.insertPos)
3488 top = last;
3489 else
3490 break;
3491 }
3492 }
3493 }
3494
3495 if (scroll) {
3496 if (ctx->text.insertPos < first) { /* Scroll Down */
3497 while (first > top) {
3498 last = first;
3499 first = SrcScan(ctx->text.source, first,
3500 XawstEOL, XawsdLeft, 2, False);
3501 vlines -= CountLines(ctx, first, last);
3502 if (-vlines >= ctx->text.lt.lines) {
3503 scroll = False;
3504 break;
3505 }
3506 }
3507 }
3508 else if (!visible) { /* Scroll Up */
3509 while (first < top) {
3510 last = first;
3511 first = SrcScan(ctx->text.source, first,
3512 XawstEOL, XawsdRight, 1, True);
3513 vlines += CountLines(ctx, last, first);
3514 if (vlines > ctx->text.lt.lines) {
3515 scroll = False;
3516 break;
3517 }
3518 }
3519 }
3520 else
3521 scroll = False;
3522 }
3523
3524 /*
3525 * If a portion of the text that will be scrolled is visible
3526 */
3527 if (scroll)
3528 XawTextScroll(ctx, vlines ? vlines - (ctx->text.lt.lines >> 1) : 0, 0);
3529 /*
3530 * Else redraw the entire text window
3531 */
3532 else {
3533 ctx->text.left_margin -= hpixels;
3534 if (ctx->text.left_margin > ctx->text.r_margin.left)
3535 ctx->text.left_margin = ctx->text.margin.left =
3536 ctx->text.r_margin.left;
3537
3538 if (!visible) {
3539 vlines = ctx->text.lt.lines >> 1;
3540 if (vlines)
3541 top = SrcScan(ctx->text.source, ctx->text.insertPos,
3542 XawstEOL, XawsdLeft, vlines + 1, False);
3543
3544 if (ctx->text.wrap != XawtextWrapNever) {
3545 int dim;
3546 int n_lines = CountLines(ctx, top, ctx->text.insertPos);
3547 int vwidth = GetMaxTextWidth(ctx);
3548
3549 while (n_lines-- > vlines) {
3550 tmp = top;
3551 XawTextSinkFindPosition(ctx->text.sink, top,
3552 ctx->text.left_margin,
3553 vwidth,
3554 ctx->text.wrap == XawtextWrapWord,
3555 &top, &dim, &dim);
3556 if (tmp == top)
3557 ++top;
3558 }
3559 }
3560 _XawTextBuildLineTable(ctx, top, True);
3561 }
3562 else
3563 ClearWindow(ctx);
3564 }
3565 ctx->text.clear_to_eol = True;
3566 }
3567
3568 #ifndef OLDXAW
3569 static int
3570 ResolveLineNumber(TextWidget ctx)
3571 {
3572 int line_number = ctx->text.lt.base_line;
3573 XawTextPosition position = ctx->text.lt.top;
3574
3575 if (ctx->text.lt.base_line < 1)
3576 return (ctx->text.line_number);
3577
3578 if (ctx->text.wrap == XawtextWrapNever
3579 && IsPositionVisible(ctx, ctx->text.insertPos))
3580 line_number += LineForPosition(ctx, ctx->text.insertPos);
3581 else if (position < ctx->text.insertPos) {
3582 while (position < ctx->text.insertPos) {
3583 position = SrcScan(ctx->text.source, position,
3584 XawstEOL, XawsdRight, 1, True);
3585 if (position <= ctx->text.insertPos) {
3586 ++line_number;
3587 if (position == ctx->text.lastPos) {
3588 line_number -= !_XawTextSourceNewLineAtEOF(ctx->text.source);
3589 break;
3590 }
3591 }
3592 }
3593 }
3594 else if (position > ctx->text.insertPos) {
3595 while (position > ctx->text.insertPos) {
3596 position = SrcScan(ctx->text.source, position,
3597 XawstEOL, XawsdLeft, 1, False);
3598 if (--position >= ctx->text.insertPos)
3599 --line_number;
3600 }
3601 }
3602
3603 return (line_number);
3604 }
3605 #endif
3606
3607 /*
3608 * This routine causes all batched screen updates to be performed
3609 */
3610 void
3611 _XawTextExecuteUpdate(TextWidget ctx)
3612 {
3613 if (ctx->text.update_disabled || ctx->text.old_insert < 0)
3614 return;
3615
3616 if(ctx->text.old_insert != ctx->text.insertPos || ctx->text.showposition)
3617 _XawTextShowPosition(ctx);
3618
3619 FlushUpdate(ctx);
3620 InsertCursor((Widget)ctx, XawisOn);
3621 ctx->text.old_insert = -1;
3622 #ifndef OLDXAW
3623 _XawTextSetLineAndColumnNumber(ctx, False);
3624 #endif
3625 }
3626
3627 static void
3628 XawTextDestroy(Widget w)
3629 {
3630 TextWidget ctx = (TextWidget)w;
3631
3632 DestroyHScrollBar(ctx);
3633 DestroyVScrollBar(ctx);
3634
3635 XtFree((char *)ctx->text.s.selections);
3636 XtFree((char *)ctx->text.lt.info);
3637 XtFree((char *)ctx->text.search);
3638 XmuDestroyScanline(ctx->text.update);
3639 XtReleaseGC((Widget)ctx, ctx->text.gc);
3640 }
3641
3642 /*
3643 * by the time we are managed (and get this far) we had better
3644 * have both a source and a sink
3645 */
3646 static void
3647 XawTextResize(Widget w)
3648 {
3649 TextWidget ctx = (TextWidget)w;
3650
3651 PositionVScrollBar(ctx);
3652 PositionHScrollBar(ctx);
3653 TextSinkResize(ctx->text.sink);
3654
3655 ctx->text.showposition = True;
3656 _XawTextBuildLineTable(ctx, ctx->text.lt.top, True);
3657 }
3658
3659 /*
3660 * This routine allow the application program to Set attributes.
3661 */
3662 /*ARGSUSED*/
3663 static Boolean
3664 XawTextSetValues(Widget current, Widget request _X_UNUSED, Widget cnew,
3665 ArgList args, Cardinal *num_args)
3666 {
3667 TextWidget oldtw = (TextWidget)current;
3668 TextWidget newtw = (TextWidget)cnew;
3669 Boolean redisplay = False;
3670 Boolean display_caret = newtw->text.display_caret;
3671 #ifndef OLDXAW
3672 Boolean show_lc = False;
3673 #endif
3674
3675 newtw->text.display_caret = oldtw->text.display_caret;
3676 _XawTextPrepareToUpdate(newtw);
3677 newtw->text.display_caret = display_caret;
3678
3679 if (oldtw->text.r_margin.left != newtw->text.r_margin.left) {
3680 newtw->text.left_margin = newtw->text.margin.left =
3681 newtw->text.r_margin.left;
3682 if (newtw->text.vbar != NULL) {
3683 newtw->text.left_margin += XtWidth(newtw->text.vbar) +
3684 XtBorderWidth(newtw->text.vbar);
3685 }
3686 redisplay = True;
3687 }
3688
3689 if (oldtw->text.scroll_vert != newtw->text.scroll_vert) {
3690 if (newtw->text.scroll_vert == XawtextScrollAlways)
3691 CreateVScrollBar(newtw);
3692 else
3693 DestroyVScrollBar(newtw);
3694
3695 redisplay = True;
3696 }
3697
3698 if (oldtw->text.r_margin.bottom != newtw->text.r_margin.bottom) {
3699 newtw->text.margin.bottom = newtw->text.r_margin.bottom;
3700 if (newtw->text.hbar != NULL)
3701 newtw->text.margin.bottom = (Position)(newtw->text.margin.bottom
3702 + (newtw->text.hbar->core.height
3703 + newtw->text.hbar->core.border_width));
3704 redisplay = True;
3705 }
3706
3707 if (oldtw->text.scroll_horiz != newtw->text.scroll_horiz) {
3708 if (newtw->text.scroll_horiz == XawtextScrollAlways)
3709 CreateHScrollBar(newtw);
3710 else
3711 DestroyHScrollBar(newtw);
3712
3713 redisplay = True;
3714 }
3715
3716 if (oldtw->text.source != newtw->text.source) {
3717 #ifndef OLDXAW
3718 show_lc = True;
3719 _XawSourceRemoveText(oldtw->text.source, cnew,
3720 oldtw->text.source &&
3721 XtParent(oldtw->text.source) == cnew);
3722 _XawSourceAddText(newtw->text.source, cnew);
3723 #endif
3724 _XawTextSetSource((Widget)newtw, newtw->text.source, newtw->text.lt.top,
3725 newtw->text.insertPos);
3726 }
3727
3728 newtw->text.redisplay_needed = False;
3729 XtSetValues((Widget)newtw->text.source, args, *num_args);
3730 XtSetValues((Widget)newtw->text.sink, args, *num_args);
3731
3732 if (oldtw->text.wrap != newtw->text.wrap
3733 || oldtw->text.lt.top != newtw->text.lt.top
3734 || oldtw->text.insertPos != newtw->text.insertPos
3735 || oldtw->text.r_margin.right != newtw->text.r_margin.right
3736 || oldtw->text.r_margin.top != newtw->text.r_margin.top
3737 || oldtw->text.sink != newtw->text.sink
3738 || newtw->text.redisplay_needed) {
3739 if (oldtw->text.wrap != newtw->text.wrap) {
3740 newtw->text.left_margin = newtw->text.margin.left =
3741 newtw->text.r_margin.left;
3742 if (oldtw->text.lt.top == newtw->text.lt.top)
3743 newtw->text.lt.top = SrcScan(newtw->text.source, 0, XawstEOL,
3744 XawsdLeft, 1, False);
3745 }
3746 newtw->text.showposition = True;
3747 #ifndef OLDXAW
3748 show_lc = True;
3749 newtw->text.source_changed = SRC_CHANGE_OVERLAP;
3750 #endif
3751 _XawTextBuildLineTable(newtw, newtw->text.lt.top, True);
3752 redisplay = True;
3753 }
3754
3755 #ifndef OLDXAW
3756 if (newtw->text.left_column < 0)
3757 newtw->text.left_column = 0;
3758 if (newtw->text.right_column < 0)
3759 newtw->text.right_column = 0;
3760 #endif
3761
3762 _XawTextExecuteUpdate(newtw);
3763
3764 #ifndef OLDXAW
3765 if (show_lc)
3766 _XawTextSetLineAndColumnNumber(newtw, True);
3767 #endif
3768
3769 if (redisplay)
3770 _XawTextSetScrollBars(newtw);
3771
3772 return (redisplay);
3773 }
3774
3775 /* invoked by the Simple widget's SetValues */
3776 static Bool
3777 XawTextChangeSensitive(Widget w)
3778 {
3779 Arg args[1];
3780 TextWidget tw = (TextWidget)w;
3781
3782 (*(&simpleClassRec)->simple_class.change_sensitive)(w);
3783
3784 XtSetArg(args[0], XtNancestorSensitive,
3785 (tw->core.ancestor_sensitive && tw->core.sensitive));
3786 if (tw->text.vbar)
3787 XtSetValues(tw->text.vbar, args, ONE);
3788 if (tw->text.hbar)
3789 XtSetValues(tw->text.hbar, args, ONE);
3790 return (False);
3791 }
3792
3793 /*
3794 * Function:
3795 * XawTextGetValuesHook
3796 *
3797 * Parameters:
3798 * w - Text Widget
3799 * args - argument list
3800 * num_args - number of args
3801 *
3802 * Description:
3803 * This is a get values hook routine that gets the
3804 * values in the text source and sink.
3805 */
3806 static void
3807 XawTextGetValuesHook(Widget w, ArgList args, Cardinal *num_args)
3808 {
3809 XtGetValues(((TextWidget)w)->text.source, args, *num_args);
3810 XtGetValues(((TextWidget)w)->text.sink, args, *num_args);
3811 }
3812
3813 /*
3814 * Function:
3815 * FindGoodPosition
3816 *
3817 * Parameters:
3818 * pos - any position
3819 *
3820 * Description:
3821 * Returns a valid position given any position.
3822 *
3823 * Returns:
3824 * A position between (0 and lastPos)
3825 */
3826 static XawTextPosition
3827 FindGoodPosition(TextWidget ctx, XawTextPosition pos)
3828 {
3829 if (pos < 0)
3830 return (0);
3831 return (((pos > ctx->text.lastPos) ? ctx->text.lastPos : pos));
3832 }
3833
3834 /* Li wrote this so the IM can find a given text position's screen position */
3835 void
3836 _XawTextPosToXY(Widget w, XawTextPosition pos, Position *x, Position *y)
3837 {
3838 int line, ix, iy;
3839
3840 LineAndXYForPosition((TextWidget)w, pos, &line, &ix, &iy);
3841 *x = (Position)ix;
3842 *y = (Position)iy;
3843 }
3844
3845 /*******************************************************************
3846 The following routines provide procedural interfaces to Text window state
3847 setting and getting. They need to be redone so than the args code can use
3848 them. I suggest we create a complete set that takes the context as an
3849 argument and then have the public version lookup the context and call the
3850 internal one. The major value of this set is that they have actual application
3851 clients and therefore the functionality provided is required for any future
3852 version of Text.
3853 ********************************************************************/
3854 void
3855 XawTextDisplay(Widget w)
3856 {
3857 TextWidget ctx = (TextWidget)w;
3858
3859 if (!XtIsRealized(w))
3860 return;
3861
3862 _XawTextPrepareToUpdate(ctx);
3863 ctx->text.clear_to_eol = True;
3864 DisplayTextWindow(w);
3865 _XawTextExecuteUpdate(ctx);
3866 }
3867
3868 void
3869 XawTextSetSelectionArray(Widget w, XawTextSelectType *sarray)
3870 {
3871 ((TextWidget)w)->text.sarray = sarray;
3872 }
3873
3874 void
3875 XawTextGetSelectionPos(Widget w, XawTextPosition *left, XawTextPosition *right)
3876 {
3877 *left = ((TextWidget)w)->text.s.left;
3878 *right = ((TextWidget)w)->text.s.right;
3879 }
3880
3881 void
3882 _XawTextSetSource(Widget w, Widget source,
3883 XawTextPosition top, XawTextPosition startPos)
3884 {
3885 TextWidget ctx = (TextWidget)w;
3886 #ifndef OLDXAW
3887 Bool resolve = False;
3888 #endif
3889
3890 #ifndef OLDXAW
3891 if (source != ctx->text.source)
3892 _XawSourceRemoveText(ctx->text.source, w, ctx->text.source &&
3893 XtParent(ctx->text.source) == w);
3894 _XawSourceAddText(source, w);
3895
3896 if (source != ctx->text.source || ctx->text.insertPos != startPos)
3897 resolve = True;
3898
3899 ctx->text.source_changed = SRC_CHANGE_OVERLAP;
3900 #endif
3901 ctx->text.source = source;
3902 ctx->text.s.left = ctx->text.s.right = 0;
3903 ctx->text.lastPos = GETLASTPOS;
3904 top = FindGoodPosition(ctx, top);
3905 startPos = FindGoodPosition(ctx, startPos);
3906 ctx->text.insertPos = ctx->text.old_insert = startPos;
3907 _XawTextPrepareToUpdate(ctx);
3908
3909 _XawTextBuildLineTable(ctx, top, True);
3910
3911 _XawTextExecuteUpdate(ctx);
3912 #ifndef OLDXAW
3913 if (resolve)
3914 _XawTextSetLineAndColumnNumber(ctx, True);
3915 #endif
3916 }
3917
3918 void
3919 XawTextSetSource(Widget w, Widget source, XawTextPosition top)
3920 {
3921 _XawTextSetSource(w, source, top, top);
3922 }
3923
3924 /*
3925 * This public routine deletes the text from startPos to endPos in a source and
3926 * then inserts, at startPos, the text that was passed. As a side effect it
3927 * "invalidates" that portion of the displayed text (if any), so that things
3928 * will be repainted properly.
3929 */
3930 int
3931 XawTextReplace(Widget w, XawTextPosition startPos, XawTextPosition endPos,
3932 XawTextBlock *text)
3933 {
3934 TextWidget ctx = (TextWidget)w;
3935 int result;
3936 #ifndef OLDXAW
3937 Cardinal i;
3938 TextSrcObject src = (TextSrcObject)ctx->text.source;
3939
3940 for (i = 0; i < src->textSrc.num_text; i++)
3941 _XawTextPrepareToUpdate((TextWidget)src->textSrc.text[i]);
3942 #else
3943 _XawTextPrepareToUpdate(ctx);
3944 #endif
3945
3946 endPos = FindGoodPosition(ctx, endPos);
3947 startPos = FindGoodPosition(ctx, startPos);
3948 result = _XawTextReplace(ctx, startPos, endPos, text);
3949
3950 #ifndef OLDXAW
3951 for (i = 0; i < src->textSrc.num_text; i++)
3952 _XawTextExecuteUpdate((TextWidget)src->textSrc.text[i]);
3953 #else
3954 _XawTextExecuteUpdate(ctx);
3955 #endif
3956
3957 return (result);
3958 }
3959
3960 XawTextPosition
3961 XawTextTopPosition(Widget w)
3962 {
3963 return (((TextWidget)w)->text.lt.top);
3964 }
3965
3966 XawTextPosition
3967 XawTextLastPosition(Widget w)
3968 {
3969 return (((TextWidget)w)->text.lastPos);
3970 }
3971
3972 void
3973 XawTextSetInsertionPoint(Widget w, XawTextPosition position)
3974 {
3975 TextWidget ctx = (TextWidget)w;
3976
3977 _XawTextPrepareToUpdate(ctx);
3978 ctx->text.insertPos = FindGoodPosition(ctx, position);
3979 ctx->text.showposition = True;
3980 ctx->text.from_left = -1;
3981
3982 _XawTextExecuteUpdate(ctx);
3983 #ifndef OLDXAW
3984 _XawTextSetLineAndColumnNumber(ctx, False);
3985 #endif
3986 }
3987
3988 XawTextPosition
3989 XawTextGetInsertionPoint(Widget w)
3990 {
3991 return (((TextWidget)w)->text.insertPos);
3992 }
3993
3994 /*
3995 * Note: Must walk the selection list in opposite order from TextLoseSelection
3996 */
3997 void
3998 XawTextUnsetSelection(Widget w)
3999 {
4000 TextWidget ctx = (TextWidget)w;
4001
4002 while (ctx->text.s.atom_count != 0) {
4003 Atom sel = ctx->text.s.selections[ctx->text.s.atom_count - 1];
4004
4005 if (sel != (Atom) 0) {
4006 /*
4007 * As selections are lost the atom_count will decrement
4008 */
4009 if (GetCutBufferNumber(sel) == NOT_A_CUT_BUFFER)
4010 XtDisownSelection(w, sel, ctx->text.time);
4011 TextLoseSelection(w, &sel); /* In case this is a cut buffer, or
4012 XtDisownSelection failed to call us */
4013 }
4014 }
4015 }
4016
4017 void
4018 XawTextSetSelection(Widget w, XawTextPosition left, XawTextPosition right)
4019 {
4020 TextWidget ctx = (TextWidget)w;
4021
4022 _XawTextPrepareToUpdate(ctx);
4023 _XawTextSetSelection(ctx, FindGoodPosition(ctx, left),
4024 FindGoodPosition(ctx, right), NULL, 0);
4025 _XawTextExecuteUpdate(ctx);
4026 }
4027
4028 void
4029 XawTextInvalidate(Widget w, XawTextPosition from, XawTextPosition to)
4030 {
4031 TextWidget ctx = (TextWidget)w;
4032
4033 from = FindGoodPosition(ctx, from);
4034 to = FindGoodPosition(ctx, to);
4035 ctx->text.lastPos = GETLASTPOS;
4036 _XawTextPrepareToUpdate(ctx);
4037 _XawTextNeedsUpdating(ctx, from, to);
4038 _XawTextExecuteUpdate(ctx);
4039 }
4040
4041 /*ARGSUSED*/
4042 void
4043 XawTextDisableRedisplay(Widget w)
4044 {
4045 ((TextWidget)w)->text.update_disabled = True;
4046 _XawTextPrepareToUpdate((TextWidget)w);
4047 }
4048
4049 void
4050 XawTextEnableRedisplay(Widget w)
4051 {
4052 TextWidget ctx = (TextWidget)w;
4053 XawTextPosition lastPos;
4054
4055 if (!ctx->text.update_disabled)
4056 return;
4057
4058 ctx->text.update_disabled = False;
4059 lastPos = ctx->text.lastPos = GETLASTPOS;
4060 ctx->text.lt.top = FindGoodPosition(ctx, ctx->text.lt.top);
4061 ctx->text.insertPos = FindGoodPosition(ctx, ctx->text.insertPos);
4062
4063 if (ctx->text.s.left > lastPos || ctx->text.s.right > lastPos)
4064 ctx->text.s.left = ctx->text.s.right = 0;
4065
4066 _XawTextExecuteUpdate(ctx);
4067 }
4068
4069 Widget
4070 XawTextGetSource(Widget w)
4071 {
4072 return (((TextWidget)w)->text.source);
4073 }
4074
4075 Widget
4076 XawTextGetSink(Widget w)
4077 {
4078 return (((TextWidget)w)->text.sink);
4079 }
4080
4081 void
4082 XawTextDisplayCaret(Widget w,
4083 #if NeedWidePrototypes
4084 int display_caret
4085 #else
4086 Boolean display_caret
4087 #endif
4088 )
4089 {
4090 TextWidget ctx = (TextWidget)w;
4091
4092 if (XtIsRealized(w)) {
4093 _XawTextPrepareToUpdate(ctx);
4094 ctx->text.display_caret = display_caret;
4095 _XawTextExecuteUpdate(ctx);
4096 }
4097 else
4098 ctx->text.display_caret = display_caret;
4099 }
4100
4101 /*
4102 * Function:
4103 * XawTextSearch
4104 *
4105 * Parameters:
4106 * w - text widget
4107 * dir - direction to search
4108 * text - text block containing info about the string to search for
4109 *
4110 * Description:
4111 * Searches for the given text block.
4112 *
4113 * Returns:
4114 * The position of the text found, or XawTextSearchError on an error
4115 */
4116 XawTextPosition
4117 XawTextSearch(Widget w,
4118 #if NeedWidePrototypes
4119 int dir,
4120 #else
4121 XawTextScanDirection dir,
4122 #endif
4123 XawTextBlock *text)
4124 {
4125 TextWidget ctx = (TextWidget)w;
4126
4127 return (SrcSearch(ctx->text.source, ctx->text.insertPos, dir, text));
4128 }
4129
4130 TextClassRec textClassRec = {
4131 /* core */
4132 {
4133 (WidgetClass)&simpleClassRec, /* superclass */
4134 "Text", /* class_name */
4135 sizeof(TextRec), /* widget_size */
4136 XawTextClassInitialize, /* class_initialize */
4137 NULL, /* class_part_init */
4138 False, /* class_inited */
4139 XawTextInitialize, /* initialize */
4140 NULL, /* initialize_hook */
4141 XawTextRealize, /* realize */
4142 _XawTextActionsTable, /* actions */
4143 0, /* num_actions */
4144 resources, /* resources */
4145 XtNumber(resources), /* num_resource */
4146 NULLQUARK, /* xrm_class */
4147 True, /* compress_motion */
4148 XtExposeGraphicsExpose | /* compress_exposure */
4149 XtExposeNoExpose,
4150 True, /* compress_enterleave */
4151 False, /* visible_interest */
4152 XawTextDestroy, /* destroy */
4153 XawTextResize, /* resize */
4154 XawTextExpose, /* expose */
4155 XawTextSetValues, /* set_values */
4156 NULL, /* set_values_hook */
4157 XtInheritSetValuesAlmost, /* set_values_almost */
4158 XawTextGetValuesHook, /* get_values_hook */
4159 NULL, /* accept_focus */
4160 XtVersion, /* version */
4161 NULL, /* callback_private */
4162 _XawDefaultTextTranslations, /* tm_table */
4163 XtInheritQueryGeometry, /* query_geometry */
4164 XtInheritDisplayAccelerator, /* display_accelerator */
4165 NULL, /* extension */
4166 },
4167 /* simple */
4168 {
4169 XawTextChangeSensitive, /* change_sensitive */
4170 #ifndef OLDXAW
4171 NULL,
4172 #endif
4173 },
4174 /* text */
4175 {
4176 NULL, /* extension */
4177 }
4178 };
4179
4180 WidgetClass textWidgetClass = (WidgetClass)&textClassRec;