components/x11/libXaw4/src/Xaw3_1AsciiSink.c

   1 #if (!defined(lint) && !defined(SABER))
   2 static char Xrcsid[] = "$XConsortium: AsciiSink.c,v 1.49 89/12/14 19:15:55 converse Exp $";
   3 #endif /* lint && SABER */
   4
   5 /***********************************************************
   6 Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
   7 and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
   8
   9                         All Rights Reserved
  10
  11 Permission to use, copy, modify, and distribute this software and its
  12 documentation for any purpose and without fee is hereby granted,
  13 provided that the above copyright notice appear in all copies and that
  14 both that copyright notice and this permission notice appear in
  15 supporting documentation, and that the names of Digital or MIT not be
  16 used in advertising or publicity pertaining to distribution of the
  17 software without specific, written prior permission.
  18
  19 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  20 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  21 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  22 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  23 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  24 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  25 SOFTWARE.
  26
  27 ******************************************************************/
  28
  29 #include <stdio.h>
  30
  31 #include <X11/Xlib.h>
  32 #include <X11/Xutil.h>
  33 #include <X11/Xatom.h>
  34 #include <X11/IntrinsicP.h>
  35 #include <X11/StringDefs.h>
  36 #include <./Xaw3_1XawInit.h>
  37 #include <./Xaw3_1AsciiSinkP.h>
  38 #include <./Xaw3_1AsciiSrcP.h>  /* For source function defs. */
  39 #include <./Xaw3_1TextP.h>      /* I also reach into the text widget. */
  40
  41 #ifdef GETLASTPOS
  42 #undef GETLASTPOS               /* We will use our own GETLASTPOS. */
  43 #endif
  44
  45 #define GETLASTPOS XawTextSourceScan(source, 0, XawstAll, XawsdRight, 1, TRUE)
  46
  47 static void Initialize(), Destroy();
  48 static Boolean SetValues();
  49
  50 static void DisplayText(), InsertCursor(), FindPosition();
  51 static void FindDistance(), Resolve(), GetCursorBounds();
  52
  53 #define offset(field) XtOffset(AsciiSinkObject, ascii_sink.field)
  54
  55 static XtResource resources[] = {
  56     {XtNecho, XtCOutput, XtRBoolean, sizeof(Boolean),
  57         offset(echo), XtRImmediate, (caddr_t) True},
  58     {XtNdisplayNonprinting, XtCOutput, XtRBoolean, sizeof(Boolean),
  59         offset(display_nonprinting), XtRImmediate, (caddr_t) True},
  60 };
  61 #undef offset
  62
  63 #define SuperClass              (&textSinkClassRec)
  64 AsciiSinkClassRec asciiSinkClassRec = {
  65   {
  66 /* core_class fields */
  67     /* superclass               */      (WidgetClass) SuperClass,
  68     /* class_name               */      "AsciiSink",
  69     /* widget_size              */      sizeof(AsciiSinkRec),
  70     /* class_initialize         */      XawInitializeWidgetSet,
  71     /* class_part_initialize    */      NULL,
  72     /* class_inited             */      FALSE,
  73     /* initialize               */      Initialize,
  74     /* initialize_hook          */      NULL,
  75     /* obj1                     */      NULL,
  76     /* obj2                     */      NULL,
  77     /* obj3                     */      0,
  78     /* resources                */      resources,
  79     /* num_resources            */      XtNumber(resources),
  80     /* xrm_class                */      NULLQUARK,
  81     /* obj4                     */      FALSE,
  82     /* obj5                     */      FALSE,
  83     /* obj6                     */      FALSE,
  84     /* obj7                     */      FALSE,
  85     /* destroy                  */      Destroy,
  86     /* obj8                     */      NULL,
  87     /* obj9                     */      NULL,
  88     /* set_values               */      SetValues,
  89     /* set_values_hook          */      NULL,
  90     /* obj10                    */      NULL,
  91     /* get_values_hook          */      NULL,
  92     /* obj11                    */      NULL,
  93     /* version                  */      XtVersion,
  94     /* callback_private         */      NULL,
  95     /* obj12                    */      NULL,
  96     /* obj13                    */      NULL,
  97     /* obj14                    */      NULL,
  98     /* extension                */      NULL
  99   },
 100 /* text_sink_class fields */
 101   {
 102     /* DisplayText              */      DisplayText,
 103     /* InsertCursor             */      InsertCursor,
 104     /* ClearToBackground        */      XtInheritClearToBackground,
 105     /* FindPosition             */      FindPosition,
 106     /* FindDistance             */      FindDistance,
 107     /* Resolve                  */      Resolve,
 108     /* MaxLines                 */      XtInheritMaxLines,
 109     /* MaxHeight                */      XtInheritMaxHeight,
 110     /* SetTabs                  */      XtInheritSetTabs,
 111     /* GetCursorBounds          */      GetCursorBounds
 112   },
 113 /* ascii_sink_class fields. */
 114   {
 115     /* Keep Compiler happy.     */      NULL
 116   }
 117 };
 118
 119 WidgetClass asciiSinkObjectClass = (WidgetClass)&asciiSinkClassRec;
 120
 121 /* Utilities */
 122
 123 static int
 124 CharWidth (w, x, c)
 125 Widget w;
 126 int x;
 127 unsigned char c;
 128 {
 129     register int    i, width, nonPrinting;
 130     AsciiSinkObject sink = (AsciiSinkObject) w;
 131     XFontStruct *font = sink->text_sink.font;
 132     Position *tab;
 133
 134     if ( c == LF ) return(0);
 135
 136     if (c == TAB) {
 137         /* Adjust for Left Margin. */
 138         x -= ((TextWidget) XtParent(w))->text.margin.left;
 139
 140         if (x >= XtParent(w)->core.width) return 0;
 141         for (i = 0, tab = sink->text_sink.tabs ;
 142              i < sink->text_sink.tab_count ; i++, tab++) {
 143             if (x < *tab) {
 144                 if (*tab < XtParent(w)->core.width)
 145                     return *tab - x;
 146                 else
 147                     return 0;
 148             }
 149         }
 150         return 0;
 151     }
 152
 153     if ( (nonPrinting = (c < (unsigned char) SP)) )
 154         if (sink->ascii_sink.display_nonprinting)
 155             c += '@';
 156         else {
 157             c = SP;
 158             nonPrinting = False;
 159         }
 160
 161     if (font->per_char &&
 162             (c >= font->min_char_or_byte2 && c <= font->max_char_or_byte2))
 163         width = font->per_char[c - font->min_char_or_byte2].width;
 164     else
 165         width = font->min_bounds.width;
 166
 167     if (nonPrinting)
 168         width += CharWidth(w, x, (unsigned char) '^');
 169
 170     return width;
 171 }
 172
 173 /*      Function Name: PaintText
 174  *      Description: Actually paints the text into the windoe.
 175  *      Arguments: w - the text widget.
 176  *                 gc - gc to paint text with.
 177  *                 x, y - location to paint the text.
 178  *                 buf, len - buffer and length of text to paint.
 179  *      Returns: the width of the text painted, or 0.
 180  *
 181  * NOTE:  If this string attempts to paint past the end of the window
 182  *        then this function will return zero.
 183  */
 184
 185 static Dimension
 186 PaintText(w, gc, x, y, buf, len)
 187 Widget w;
 188 GC gc;
 189 Position x, y;
 190 unsigned char * buf;
 191 int len;
 192 {
 193     AsciiSinkObject sink = (AsciiSinkObject) w;
 194     TextWidget ctx = (TextWidget) XtParent(w);
 195
 196     Position max_x;
 197     Dimension width = XTextWidth(sink->text_sink.font, (char *) buf, len);
 198     max_x = (Position) ctx->core.width;
 199
 200     if ( ((int) width) <= -x)              /* Don't draw if we can't see it. */
 201       return(width);
 202
 203     XDrawImageString(XtDisplay(ctx), XtWindow(ctx), gc,
 204                      (int) x, (int) y, (char *) buf, len);
 205     if ( (((Position) width + x) > max_x) && (ctx->text.margin.right != 0) ) {
 206         x = ctx->core.width - ctx->text.margin.right;
 207         width = ctx->text.margin.right;
 208         XFillRectangle(XtDisplay((Widget) ctx), XtWindow( (Widget) ctx),
 209                        sink->ascii_sink.normgc, (int) x,
 210                        (int) y - sink->text_sink.font->ascent,
 211                        (unsigned int) width,
 212                        (unsigned int) (sink->text_sink.font->ascent +
 213                                        sink->text_sink.font->descent));
 214         return(0);
 215     }
 216     return(width);
 217 }
 218
 219 /* Sink Object Functions */
 220
 221 /*
 222  * This function does not know about drawing more than one line of text.
 223  */
 224
 225 static void
 226 DisplayText(w, x, y, pos1, pos2, highlight)
 227 Widget w;
 228 Position x, y;
 229 Boolean highlight;
 230 XawTextPosition pos1, pos2;
 231 {
 232     AsciiSinkObject sink = (AsciiSinkObject) w;
 233     Widget source = XawTextGetSource(XtParent(w));
 234     unsigned char buf[BUFSIZ];
 235
 236     int j, k;
 237     XawTextBlock blk;
 238     GC gc = highlight ? sink->ascii_sink.invgc : sink->ascii_sink.normgc;
 239     GC invgc = highlight ? sink->ascii_sink.normgc : sink->ascii_sink.invgc;
 240
 241     if (!sink->ascii_sink.echo) return;
 242
 243     y += sink->text_sink.font->ascent;
 244     for ( j = 0 ; pos1 < pos2 ; ) {
 245         pos1 = XawTextSourceRead(source, pos1, &blk, pos2 - pos1);
 246         for (k = 0; k < blk.length; k++) {
 247             if (j >= BUFSIZ) {  /* buffer full, dump the text. */
 248                 x += PaintText(w, gc, x, y, buf, j);
 249                 j = 0;
 250             }
 251             buf[j] = blk.ptr[k];
 252             if (buf[j] == LF)   /* line feeds ('\n') are not printed. */
 253                 continue;
 254
 255             else if (buf[j] == '\t') {
 256                 Position temp = 0;
 257                 Dimension width;
 258
 259                 if ((j != 0) && ((temp = PaintText(w, gc, x, y, buf, j)) == 0))
 260                   return;
 261
 262                 x += temp;
 263                 width = CharWidth(w, x, (unsigned char) '\t');
 264                 XFillRectangle(XtDisplayOfObject(w), XtWindowOfObject(w),
 265                                invgc, (int) x,
 266                                (int) y - sink->text_sink.font->ascent,
 267                                (unsigned int) width,
 268                                (unsigned int) (sink->text_sink.font->ascent +
 269                                                sink->text_sink.font->descent));
 270                 x += width;
 271                 j = -1;
 272             }
 273             else if ( buf[j] < (unsigned char) ' ' ) {
 274                 if (sink->ascii_sink.display_nonprinting) {
 275                     buf[j + 1] = buf[j] + '@';
 276                     buf[j] = '^';
 277                     j++;
 278                 }
 279                 else
 280                     buf[j] = ' ';
 281             }
 282             j++;
 283         }
 284     }
 285     if (j > 0)
 286         (void) PaintText(w, gc, x, y, buf, j);
 287 }
 288
 289 #define insertCursor_width 6
 290 #define insertCursor_height 3
 291 static char insertCursor_bits[] = {0x0c, 0x1e, 0x33};
 292
 293 static Pixmap
 294 CreateInsertCursor(s)
 295 Screen *s;
 296 {
 297     return (XCreateBitmapFromData (DisplayOfScreen(s), RootWindowOfScreen(s),
 298                   insertCursor_bits, insertCursor_width, insertCursor_height));
 299 }
 300
 301 /*      Function Name: GetCursorBounds
 302  *      Description: Returns the size and location of the cursor.
 303  *      Arguments: w - the text object.
 304  * RETURNED        rect - an X rectangle to return the cursor bounds in.
 305  *      Returns: none.
 306  */
 307
 308 static void
 309 GetCursorBounds(w, rect)
 310 Widget w;
 311 XRectangle * rect;
 312 {
 313     AsciiSinkObject sink = (AsciiSinkObject) w;
 314
 315     rect->width = (unsigned short) insertCursor_width;
 316     rect->height = (unsigned short) insertCursor_height;
 317     rect->x = sink->ascii_sink.cursor_x - (short) (rect->width / 2);
 318     rect->y = sink->ascii_sink.cursor_y - (short) rect->height;
 319 }
 320
 321 /*
 322  * The following procedure manages the "insert" cursor.
 323  */
 324
 325 static void
 326 InsertCursor (w, x, y, state)
 327 Widget w;
 328 Position x, y;
 329 XawTextInsertState state;
 330 {
 331     AsciiSinkObject sink = (AsciiSinkObject) w;
 332     Widget text_widget = XtParent(w);
 333     XRectangle rect;
 334
 335     sink->ascii_sink.cursor_x = x;
 336     sink->ascii_sink.cursor_y = y;
 337
 338     GetCursorBounds(w, &rect);
 339     if (state != sink->ascii_sink.laststate && XtIsRealized(text_widget))
 340         XCopyPlane(XtDisplay(text_widget),
 341                    sink->ascii_sink.insertCursorOn,
 342                    XtWindow(text_widget), sink->ascii_sink.xorgc,
 343                    0, 0, (unsigned int) rect.width, (unsigned int) rect.height,
 344                    (int) rect.x, (int) rect.y, 1);
 345     sink->ascii_sink.laststate = state;
 346 }
 347
 348 /*
 349  * Given two positions, find the distance between them.
 350  */
 351
 352 static void
 353 FindDistance (w, fromPos, fromx, toPos, resWidth, resPos, resHeight)
 354 Widget w;
 355 XawTextPosition fromPos;        /* First position. */
 356 int fromx;                      /* Horizontal location of first position. */
 357 XawTextPosition toPos;          /* Second position. */
 358 int *resWidth;                  /* Distance between fromPos and resPos. */
 359 XawTextPosition *resPos;        /* Actual second position used. */
 360 int *resHeight;                 /* Height required. */
 361 {
 362     AsciiSinkObject sink = (AsciiSinkObject) w;
 363     Widget source = XawTextGetSource(XtParent(w));
 364
 365     register XawTextPosition index, lastPos;
 366     register unsigned char c;
 367     XawTextBlock blk;
 368
 369     /* we may not need this */
 370     lastPos = GETLASTPOS;
 371     XawTextSourceRead(source, fromPos, &blk, toPos - fromPos);
 372     *resWidth = 0;
 373     for (index = fromPos; index != toPos && index < lastPos; index++) {
 374         if (index - blk.firstPos >= blk.length)
 375             XawTextSourceRead(source, index, &blk, toPos - fromPos);
 376         c = blk.ptr[index - blk.firstPos];
 377         *resWidth += CharWidth(w, fromx + *resWidth, c);
 378         if (c == LF) {
 379             index++;
 380             break;
 381         }
 382     }
 383     *resPos = index;
 384     *resHeight = sink->text_sink.font->ascent +sink->text_sink.font->descent;
 385 }
 386
 387
 388 static void
 389 FindPosition(w, fromPos, fromx, width, stopAtWordBreak,
 390                   resPos, resWidth, resHeight)
 391 Widget w;
 392 XawTextPosition fromPos;        /* Starting position. */
 393 int fromx;                      /* Horizontal location of starting position.*/
 394 int width;                      /* Desired width. */
 395 int stopAtWordBreak;            /* Whether the resulting position should be at
 396                                    a word break. */
 397 XawTextPosition *resPos;        /* Resulting position. */
 398 int *resWidth;                  /* Actual width used. */
 399 int *resHeight;                 /* Height required. */
 400 {
 401     AsciiSinkObject sink = (AsciiSinkObject) w;
 402     Widget source = XawTextGetSource(XtParent(w));
 403
 404     XawTextPosition lastPos, index, whiteSpacePosition;
 405     int     lastWidth, whiteSpaceWidth;
 406     Boolean whiteSpaceSeen;
 407     unsigned char c;
 408     XawTextBlock blk;
 409
 410     lastPos = GETLASTPOS;
 411
 412     XawTextSourceRead(source, fromPos, &blk, BUFSIZ);
 413     *resWidth = 0;
 414     whiteSpaceSeen = FALSE;
 415     c = 0;
 416     for (index = fromPos; *resWidth <= width && index < lastPos; index++) {
 417         lastWidth = *resWidth;
 418         if (index - blk.firstPos >= blk.length)
 419             XawTextSourceRead(source, index, &blk, BUFSIZ);
 420         c = blk.ptr[index - blk.firstPos];
 421         *resWidth += CharWidth(w, fromx + *resWidth, c);
 422
 423         if ((c == SP || c == TAB) && *resWidth <= width) {
 424             whiteSpaceSeen = TRUE;
 425             whiteSpacePosition = index;
 426             whiteSpaceWidth = *resWidth;
 427         }
 428         if (c == LF) {
 429             index++;
 430             break;
 431         }
 432     }
 433     if (*resWidth > width && index > fromPos) {
 434         *resWidth = lastWidth;
 435         index--;
 436         if (stopAtWordBreak && whiteSpaceSeen) {
 437             index = whiteSpacePosition + 1;
 438             *resWidth = whiteSpaceWidth;
 439         }
 440     }
 441     if (index == lastPos && c != LF) index = lastPos + 1;
 442     *resPos = index;
 443     *resHeight = sink->text_sink.font->ascent +sink->text_sink.font->descent;
 444 }
 445
 446 static void
 447 Resolve (w, pos, fromx, width, leftPos, rightPos)
 448 Widget w;
 449 XawTextPosition pos;
 450 int fromx, width;
 451 XawTextPosition *leftPos, *rightPos;
 452 {
 453     int resWidth, resHeight;
 454     Widget source = XawTextGetSource(XtParent(w));
 455
 456     FindPosition(w, pos, fromx, width, FALSE, leftPos, &resWidth, &resHeight);
 457     if (*leftPos > GETLASTPOS)
 458       *leftPos = GETLASTPOS;
 459     *rightPos = *leftPos;
 460 }
 461
 462 static void
 463 GetGC(sink)
 464 AsciiSinkObject sink;
 465 {
 466     XtGCMask valuemask = (GCFont |
 467                           GCGraphicsExposures | GCForeground | GCBackground );
 468     XGCValues values;
 469
 470     values.font = sink->text_sink.font->fid;
 471     values.graphics_exposures = (Bool) FALSE;
 472
 473     values.foreground = sink->text_sink.foreground;
 474     values.background = sink->text_sink.background;
 475     sink->ascii_sink.normgc = XtGetGC((Widget)sink, valuemask, &values);
 476
 477     values.foreground = sink->text_sink.background;
 478     values.background = sink->text_sink.foreground;
 479     sink->ascii_sink.invgc = XtGetGC((Widget)sink, valuemask, &values);
 480
 481     values.function = GXxor;
 482     values.background = (unsigned long) 0L;     /* (pix ^ 0) = pix */
 483     values.foreground = (sink->text_sink.background ^
 484                          sink->text_sink.foreground);
 485     valuemask = GCFunction | GCForeground | GCBackground;
 486
 487     sink->ascii_sink.xorgc = XtGetGC((Widget)sink, valuemask, &values);
 488 }
 489
 490
 491 /***** Public routines *****/
 492
 493 /*      Function Name: Initialize
 494  *      Description: Initializes the TextSink Object.
 495  *      Arguments: request, new - the requested and new values for the object
 496  *                                instance.
 497  *      Returns: none.
 498  *
 499  */
 500
 501 /* ARGSUSED */
 502 static void
 503 Initialize(request, new)
 504 Widget request, new;
 505 {
 506     AsciiSinkObject sink = (AsciiSinkObject) new;
 507
 508     GetGC(sink);
 509
 510     sink->ascii_sink.insertCursorOn= CreateInsertCursor(XtScreenOfObject(new));
 511     sink->ascii_sink.laststate = XawisOff;
 512     sink->ascii_sink.cursor_x = sink->ascii_sink.cursor_y = 0;
 513 }
 514
 515 /*      Function Name: Destroy
 516  *      Description: This function cleans up when the object is
 517  *                   destroyed.
 518  *      Arguments: w - the AsciiSink Object.
 519  *      Returns: none.
 520  */
 521
 522 static void
 523 Destroy(w)
 524 Widget w;
 525 {
 526    AsciiSinkObject sink = (AsciiSinkObject) w;
 527
 528    XtReleaseGC(w, sink->ascii_sink.normgc);
 529    XtReleaseGC(w, sink->ascii_sink.invgc);
 530    XtReleaseGC(w, sink->ascii_sink.xorgc);
 531    XFreePixmap(XtDisplayOfObject(w), sink->ascii_sink.insertCursorOn);
 532 }
 533
 534 /*      Function Name: SetValues
 535  *      Description: Sets the values for the AsciiSink
 536  *      Arguments: current - current state of the object.
 537  *                 request - what was requested.
 538  *                 new - what the object will become.
 539  *      Returns: True if redisplay is needed.
 540  */
 541
 542 /* ARGSUSED */
 543 static Boolean
 544 SetValues(current, request, new)
 545 Widget current, request, new;
 546 {
 547     AsciiSinkObject w = (AsciiSinkObject) new;
 548     AsciiSinkObject old_w = (AsciiSinkObject) current;
 549
 550     if (w->text_sink.font != old_w->text_sink.font) {
 551         XtReleaseGC((Widget)w, w->ascii_sink.normgc);
 552         XtReleaseGC((Widget)w, w->ascii_sink.invgc);
 553         GetGC(w);
 554         ((TextWidget)XtParent(new))->text.redisplay_needed = True;
 555     } else {
 556         if ( (w->ascii_sink.echo != old_w->ascii_sink.echo) ||
 557              (w->ascii_sink.display_nonprinting !=
 558                                      old_w->ascii_sink.display_nonprinting) )
 559             ((TextWidget)XtParent(new))->text.redisplay_needed = True;
 560     }
 561
 562     return False;
 563 }