src/text.c

   1 /********************************************************************\
   2  * text.c -- a basic text field                                     *
   3  * Copyright (C) 1997 Robin D. Clark                                *
   4  *                                                                  *
   5  * This program is free software; you can redistribute it and/or    *
   6  * modify it under the terms of the GNU General Public License as   *
   7  * published by the Free Software Foundation; either version 2 of   *
   8  * the License, or (at your option) any later version.              *
   9  *                                                                  *
  10  * This program is distributed in the hope that it will be useful,  *
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
  13  * GNU General Public License for more details.                     *
  14  *                                                                  *
  15  * You should have received a copy of the GNU General Public License*
  16  * along with this program; if not, write to the Free Software      *
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.        *
  18  *                                                                  *
  19  *   Author: Rob Clark                                              *
  20  * Internet: rclark@cs.hmc.edu                                      *
  21  *  Address: 609 8th Street                                         *
  22  *           Huntington Beach, CA 92648-4632                        *
  23 \********************************************************************/
  24
  25 #include "wconfig.h"
  26
  27 #include <X11/Xlib.h>
  28 #include <X11/Xutil.h>
  29 #include <X11/keysym.h>
  30 #include <stdlib.h>
  31 #include <ctype.h>
  32
  33 #include "WindowMaker.h"
  34 #include "funcs.h"
  35 #include "text.h"
  36 #include "actions.h"
  37
  38 /* X11R5 don't have this */
  39 #ifndef IsPrivateKeypadKey
  40 #define IsPrivateKeypadKey(keysym) \
  41   (((KeySym)(keysym) >= 0x11000000) && ((KeySym)(keysym) <= 0x1100FFFF))
  42 #endif
  43
  44
  45 #if 0
  46 #  define  ENTER(X)  fprintf(stderr,"Entering:  %s()\n", X);
  47 #  define  LEAVE(X)  fprintf(stderr,"Leaving:   %s()\n", X);
  48 #  define  DEBUG(X)  fprintf(stderr,"debug:     %s()\n", X);
  49 #else
  50 #  define  ENTER(X)
  51 #  define  LEAVE(X)
  52 #  define  DEBUG(X)
  53 #endif
  54
  55 extern Cursor wCursor[WCUR_LAST];
  56
  57 /********************************************************************\
  58  * The event handler for the text-field:                            *
  59 \********************************************************************/
  60 static void textEventHandler( WObjDescriptor *desc, XEvent *event );
  61
  62 static void handleExpose( WObjDescriptor *desc, XEvent *event );
  63
  64 static void textInsert( WTextInput *wtext, char *txt );
  65 #if 0
  66 static void blink(void *data);
  67 #endif
  68
  69 /********************************************************************\
  70  * handleKeyPress                                                   *
  71  *   handle cursor keys, regular keys, etc.  Inserts characters in  *
  72  *   text field, at cursor position, if it is a "Normal" key.  If   *
  73  *   ksym is the delete key, backspace key, etc., the appropriate   *
  74  *   action is performed on the text in the text field.  Does not   *
  75  *   refresh the text field                                         *
  76  *                                                                  *
  77  * Args:   wText - the text field                                   *
  78  *         ksym  - the key that was pressed                         *
  79  * Return: True, unless the ksym is ignored                         *
  80  * Global: modifier - the bitfield that keeps track of the modifier *
  81  *                    keys that are down                            *
  82 \********************************************************************/
  83 static int
  84 handleKeyPress( WTextInput *wtext, XKeyEvent *event )
  85   {
  86   KeySym ksym;
  87   char buffer[32];
  88   int count;
  89
  90   count = XLookupString(event, buffer, 32, &ksym, NULL);
  91
  92   /* Ignore these keys: */
  93   if( IsFunctionKey(ksym)      || IsKeypadKey(ksym) ||
  94       IsMiscFunctionKey(ksym)  || IsPFKey(ksym)     ||
  95       IsPrivateKeypadKey(ksym) )
  96     /* If we don't handle it, make sure it isn't a key that
  97      * the window manager needs to see */
  98     return False;
  99
 100   /* Take care of the cursor keys.. ignore up and down
 101    * cursor keys */
 102   else if( IsCursorKey(ksym) )
 103     {
 104     int length = wtext->text.length;
 105     switch(ksym)
 106       {
 107       case XK_Home:
 108       case XK_Begin:
 109       wtext->text.endPos = 0;
 110       break;
 111       case XK_Left:
 112       wtext->text.endPos--;
 113       break;
 114       case XK_Right:
 115       wtext->text.endPos++;
 116       break;
 117       case XK_End:
 118       wtext->text.endPos = length;
 119       break;
 120       default:
 121       return False;
 122       }
 123     /* make sure that the startPos and endPos have values
 124      * that make sense  (ie the are in [0..length] ) */
 125     if( wtext->text.endPos < 0 )
 126       wtext->text.endPos = 0;
 127     if( wtext->text.endPos > length )
 128       wtext->text.endPos = length;
 129     wtext->text.startPos = wtext->text.endPos;
 130     }
 131   else
 132     {
 133     switch(ksym)
 134       {
 135       /* Ignore these keys: */
 136       case XK_Escape:
 137           wtext->canceled = True;
 138       case XK_Return:
 139           wtext->done = True;
 140           break;
 141       case XK_Tab:
 142       case XK_Num_Lock:
 143       break;
 144
 145       case XK_Delete:
 146       /* delete after cursor */
 147       if( (wtext->text.endPos == wtext->text.startPos) &&
 148           (wtext->text.endPos < wtext->text.length) )
 149         wtext->text.endPos++;
 150       textInsert( wtext, "" );
 151       break;
 152       case XK_BackSpace:
 153       /* delete before cursor */
 154       if(  (wtext->text.endPos == wtext->text.startPos) &&
 155            (wtext->text.startPos > 0) )
 156         wtext->text.startPos--;
 157       textInsert( wtext, "" );
 158       break;
 159       default:
 160           if (count==1 && !iscntrl(buffer[0])) {
 161               buffer[count] = 0;
 162               textInsert( wtext, buffer);
 163           }
 164       }
 165     }
 166   return True;
 167   }
 168
 169
 170
 171 /********************************************************************\
 172  * textXYtoPos                                                     *
 173  *   given X coord, return position in array                        *
 174 \********************************************************************/
 175 static int
 176 textXtoPos( WTextInput *wtext, int x )
 177   {
 178   int pos;
 179   x -= wtext->xOffset;
 180
 181   for( pos=0; wtext->text.txt[pos] != '\0'; pos++ )
 182     {
 183     if( x < 0 )
 184       break;
 185     else
 186       x -= WMWidthOfString( wtext->font, &(wtext->text.txt[pos]), 1 );
 187     }
 188
 189   return pos;
 190   }
 191
 192 /********************************************************************\
 193  * wTextCreate                                                      *
 194  *   create an instance of a text class                             *
 195  *                                                                  *
 196  * Args:                                                            *
 197  * Return:                                                          *
 198  * Global: dpy - the display                                        *
 199 \********************************************************************/
 200 WTextInput *
 201 wTextCreate( WCoreWindow *core, int x, int y, int width, int height )
 202   {
 203   WTextInput *wtext;
 204
 205   ENTER("wTextCreate");
 206
 207   wtext = wmalloc(sizeof(WTextInput));
 208   wtext->core = wCoreCreate( core, x, y, width, height );
 209   wtext->core->descriptor.handle_anything = &textEventHandler;
 210   wtext->core->descriptor.handle_expose = &handleExpose;
 211   wtext->core->descriptor.parent_type = WCLASS_TEXT_INPUT;
 212   wtext->core->descriptor.parent = wtext;
 213
 214   wtext->font = core->screen_ptr->menu_entry_font;
 215
 216   XDefineCursor( dpy, wtext->core->window, wCursor[WCUR_TEXT] );
 217
 218   /* setup the text: */
 219   wtext->text.txt      = (char *)wmalloc(sizeof(char));
 220   wtext->text.txt[0]   = '\0';
 221   wtext->text.length   = 0;
 222   wtext->text.startPos = 0;
 223   wtext->text.endPos   = 0;
 224
 225     {
 226     XGCValues gcv;
 227
 228     gcv.foreground = core->screen_ptr->black_pixel;
 229     gcv.background = core->screen_ptr->white_pixel;
 230     gcv.line_width = 1;
 231     gcv.function   = GXcopy;
 232
 233     wtext->gc = XCreateGC( dpy, wtext->core->window,
 234                            (GCForeground|GCBackground|
 235                             GCFunction|GCLineWidth),
 236                            &gcv );
 237
 238     /* set up the regular context */
 239     gcv.foreground = core->screen_ptr->black_pixel;
 240     gcv.background = core->screen_ptr->white_pixel;
 241     gcv.line_width = 1;
 242     gcv.function   = GXcopy;
 243
 244     wtext->regGC = XCreateGC( dpy, wtext->core->window,
 245                               (GCForeground|GCBackground|
 246                                GCFunction|GCLineWidth),
 247                               &gcv );
 248
 249     /* set up the inverted context */
 250     gcv.function   = GXcopyInverted;
 251
 252     wtext->invGC = XCreateGC( dpy, wtext->core->window,
 253                               (GCForeground|GCBackground|
 254                                GCFunction|GCLineWidth),
 255                               &gcv );
 256
 257     /* and set the background! */
 258     XSetWindowBackground( dpy, wtext->core->window, gcv.background );
 259     }
 260
 261   /* Figure out the y-offset... */
 262   wtext->yOffset = (height - WMFontHeight(wtext->font))/2;
 263   wtext->xOffset = wtext->yOffset;
 264
 265   wtext->canceled     = False;
 266   wtext->done         = False;     /* becomes True when the user    *
 267                                   * hits "Return" key             */
 268
 269   XMapRaised(dpy, wtext->core->window);
 270
 271   LEAVE("wTextCreate");
 272
 273   return wtext;
 274   }
 275
 276 /********************************************************************\
 277  * wTextDestroy                                                     *
 278  *                                                                  *
 279  * Args:   wtext  - the text field                                  *
 280  * Return:                                                          *
 281  * Global: dpy    - the display                                     *
 282 \********************************************************************/
 283 void
 284 wTextDestroy( WTextInput *wtext )
 285   {
 286   ENTER("wTextDestroy")
 287
 288 #if 0
 289   if (wtext->magic)
 290       wDeleteTimerHandler(wtext->magic);
 291   wtext->magic = NULL;
 292 #endif
 293   XFreeGC( dpy, wtext->gc );
 294   XFreeGC( dpy, wtext->regGC );
 295   XFreeGC( dpy, wtext->invGC );
 296   wfree( wtext->text.txt );
 297   wCoreDestroy( wtext->core );
 298   wfree( wtext );
 299
 300   LEAVE("wTextDestroy");
 301   }
 302
 303
 304 /* The text-field consists of a frame drawn around the outside,
 305  * and a textbox inside.  The space between the frame and the
 306  * text-box is the xOffset,yOffset.  When the text needs refreshing,
 307  * we only have to redraw the part inside the text-box, and we can
 308  * leave the frame.  If we get an expose event, or for some reason
 309  * need to redraw the frame, wTextPaint will redraw the frame, and
 310  * then call wTextRefresh to redraw the text-box */
 311
 312
 313 /********************************************************************\
 314  * textRefresh                                                     *
 315  *   Redraw the text field.  Call this after messing with the text  *
 316  *   field.  wTextRefresh re-draws the inside of the text field. If *
 317  *   the frame-area of the text-field needs redrawing, call         *
 318  *   wTextPaint()                                                   *
 319  *                                                                  *
 320  * Args:   wtext  - the text field                                  *
 321  * Return: none                                                     *
 322  * Global: dpy    - the display                                     *
 323 \********************************************************************/
 324 static void
 325 textRefresh(WTextInput *wtext)
 326 {
 327     WScreen *scr = wtext->core->screen_ptr;
 328     char *ptr = wtext->text.txt;
 329     int  x1,x2,y1,y2;
 330
 331     /* x1,y1 is the upper left corner of the text box */
 332     x1 = wtext->xOffset;
 333     y1 = wtext->yOffset;
 334     /* x2,y2 is the lower right corner of the text box */
 335     x2 = wtext->core->width - wtext->xOffset;
 336     y2 = wtext->core->height - wtext->yOffset;
 337
 338     /* Fill in the text field.  Use the invGC to draw the rectangle,
 339      * becuase then it will be the background color */
 340     XFillRectangle(dpy, wtext->core->window, wtext->invGC,
 341                    x1, y1, x2-x1, y2-y1);
 342
 343     /* Draw the text normally */
 344     WMDrawImageString(scr->wmscreen, wtext->core->window,
 345                       scr->black, scr->white, wtext->font, x1, y1, ptr,
 346                       wtext->text.length);
 347
 348     /* Draw the selected text */
 349     if (wtext->text.startPos != wtext->text.endPos) {
 350         int sp,ep;
 351         /* we need sp < ep */
 352         if (wtext->text.startPos > wtext->text.endPos) {
 353             sp = wtext->text.endPos;
 354             ep = wtext->text.startPos;
 355         } else {
 356             sp = wtext->text.startPos;
 357             ep = wtext->text.endPos;
 358         }
 359
 360         /* x1,y1 is now the upper-left of the selected area */
 361         x1 += WMWidthOfString(wtext->font, ptr, sp);
 362         /* and x2,y2 is the lower-right of the selected area */
 363         ptr += sp * sizeof(char);
 364         x2 = x1 + WMWidthOfString(wtext->font, ptr, (ep - sp));
 365         /* Fill in the area  where the selected text will go:     *
 366          * use the regGC to draw the rectangle, becuase then it   *
 367          * will be the color of the non-selected text             */
 368         XFillRectangle(dpy, wtext->core->window, wtext->regGC,
 369                        x1, y1, x2-x1, y2-y1);
 370
 371         /* Draw the selected text. Inverse bg and fg colors for selection */
 372         WMDrawImageString(scr->wmscreen, wtext->core->window,
 373                           scr->white, scr->black, wtext->font, x1, y1, ptr,
 374                           (ep - sp));
 375     }
 376
 377     /* And draw a quick little line for the cursor position */
 378     x1 = WMWidthOfString(wtext->font, wtext->text.txt, wtext->text.endPos)
 379         + wtext->xOffset;
 380     XDrawLine(dpy, wtext->core->window, wtext->regGC, x1, 2, x1,
 381               wtext->core->height - 3);
 382 }
 383
 384
 385 /********************************************************************\
 386  * wTextPaint                                                       *
 387  *                                                                  *
 388  * Args:   wtext  - the text field                                  *
 389  * Return:                                                          *
 390  * Global: dpy    - the display                                     *
 391 \********************************************************************/
 392 void
 393 wTextPaint( WTextInput *wtext )
 394   {
 395   ENTER("wTextPaint");
 396
 397   /* refresh */
 398   textRefresh( wtext );
 399
 400   /* Draw box */
 401   XDrawRectangle(dpy, wtext->core->window, wtext->gc, 0, 0,
 402                  wtext->core->width-1, wtext->core->height-1);
 403
 404   LEAVE("wTextPaint");
 405   }
 406
 407
 408 /********************************************************************\
 409  * wTextGetText                                                     *
 410  *   return the string in the text field wText.  DO NOT FREE THE    *
 411  *   RETURNED STRING!                                               *
 412  *                                                                  *
 413  * Args:   wtext  - the text field                                  *
 414  * Return: the text in the text field (NULL terminated)             *
 415  * Global:                                                          *
 416 \********************************************************************/
 417 char *
 418 wTextGetText( WTextInput *wtext )
 419   {
 420      if (!wtext->canceled)
 421           return wtext->text.txt;
 422       else
 423           return NULL;
 424   }
 425
 426 /********************************************************************\
 427  * wTextPutText                                                     *
 428  *   Put the string txt in the text field wText.  The text field    *
 429  *   needs to be explicitly refreshed after wTextPutText by calling *
 430  *   wTextRefresh().                                                *
 431  *   The string txt is copied                                       *
 432  *                                                                  *
 433  * Args:   wtext  - the text field                                  *
 434  *         txt    - the new text string... freed by the text field! *
 435  * Return: none                                                     *
 436  * Global:                                                          *
 437 \********************************************************************/
 438 void
 439 wTextPutText( WTextInput *wtext, char *txt )
 440   {
 441   int length = strlen(txt);
 442
 443   /* no memory leaks!  free the old txt */
 444   if( wtext->text.txt != NULL )
 445     wfree( wtext->text.txt );
 446
 447   wtext->text.txt = (char *)wmalloc((length+1)*sizeof(char));
 448   strcpy(wtext->text.txt, txt );
 449   wtext->text.length   = length;
 450   /* By default No text is selected, and the cursor is at the end */
 451   wtext->text.startPos = length;
 452   wtext->text.endPos   = length;
 453   }
 454
 455 /********************************************************************\
 456  * textInsert                                                      *
 457  *   Insert some text at the cursor.  (if startPos != endPos,       *
 458  *   replace the selected text, otherwise insert)                   *
 459  *   The string txt is copied.                                      *
 460  *                                                                  *
 461  * Args:   wText  - the text field                                  *
 462  *         txt    - the new text string... freed by the text field! *
 463  * Return: none                                                     *
 464  * Global:                                                          *
 465 \********************************************************************/
 466 static void
 467 textInsert( WTextInput *wtext, char *txt )
 468   {
 469   char *newTxt;
 470   int  newLen, txtLen, i,j;
 471   int  sp,ep;
 472
 473   /* we need sp < ep */
 474   if( wtext->text.startPos > wtext->text.endPos )
 475     {
 476     sp = wtext->text.endPos;
 477     ep = wtext->text.startPos;
 478     }
 479   else
 480     {
 481     sp = wtext->text.startPos;
 482     ep = wtext->text.endPos;
 483     }
 484
 485   txtLen = strlen(txt);
 486   newLen = wtext->text.length + txtLen - (ep - sp) + 1;
 487
 488   newTxt = (char *)malloc(newLen*sizeof(char));
 489
 490   /* copy the old text up to sp */
 491   for( i=0; i<sp; i++ )
 492     newTxt[i] = wtext->text.txt[i];
 493
 494   /* insert new text */
 495   for( j=0; j<txtLen; j++,i++ )
 496     newTxt[i] = txt[j];
 497
 498   /* copy old text after ep */
 499   for( j=ep; j<wtext->text.length; j++,i++ )
 500     newTxt[i] = wtext->text.txt[j];
 501
 502   newTxt[i] = '\0';
 503
 504   /* By default No text is selected, and the cursor is at the end
 505    * of inserted text */
 506   wtext->text.startPos = sp+txtLen;
 507   wtext->text.endPos   = sp+txtLen;
 508
 509   wfree(wtext->text.txt);
 510   wtext->text.txt    = newTxt;
 511   wtext->text.length = newLen-1;
 512   }
 513
 514 /********************************************************************\
 515  * wTextSelect                                                      *
 516  *   Select some text.  If start == end, then the cursor is moved   *
 517  *   to that position.  If end == -1, then the text from start to   *
 518  *   the end of the text entered in the text field is selected.     *
 519  *   The text field is not automatically re-drawn!  You must call   *
 520  *   wTextRefresh to re-draw the text field.                        *
 521  *                                                                  *
 522  * Args:   wtext  - the text field                                  *
 523  *         start  - the beginning of the selected text              *
 524  *         end    - the end of the selected text                    *
 525  * Return: none                                                     *
 526  * Global:                                                          *
 527 \********************************************************************/
 528 void
 529 wTextSelect( WTextInput *wtext, int start, int end )
 530   {
 531   if( end == -1 )
 532     wtext->text.endPos = wtext->text.length;
 533   else
 534     wtext->text.endPos = end;
 535   wtext->text.startPos = start;
 536   }
 537
 538 #if 0
 539 static void
 540 blink(void *data)
 541 {
 542     int x;
 543     WTextInput *wtext = (WTextInput*)data;
 544     GC gc;
 545
 546   /* And draw a quick little line for the cursor position */
 547     if (wtext->blink_on) {
 548         gc = wtext->regGC;
 549         wtext->blink_on = 0;
 550     } else {
 551         gc = wtext->invGC;
 552         wtext->blink_on = 1;
 553     }
 554     x = WMWidthOfString( wtext->font, wtext->text.txt, wtext->text.endPos )
 555         + wtext->xOffset;
 556     XDrawLine( dpy, wtext->core->window, gc, x, 2, x, wtext->core->height-3);
 557
 558     if (wtext->blinking)
 559         wtext->magic = wAddTimerHandler(CURSOR_BLINK_RATE, blink, data);
 560 }
 561 #endif
 562
 563 /********************************************************************\
 564  * textEventHandler -- handles and dispatches all the events that   *
 565  *   the text field class supports                                  *
 566  *                                                                  *
 567  * Args:   desc - all we need to know about this object             *
 568  * Return: none                                                     *
 569  * Global:                                                          *
 570 \********************************************************************/
 571 static void
 572 textEventHandler( WObjDescriptor *desc, XEvent *event )
 573   {
 574   WTextInput *wtext  = desc->parent;
 575   int   handled = False;      /* has the event been handled */
 576
 577   switch( event->type )
 578     {
 579     case MotionNotify:
 580       /* If the button isn't down, we don't care about the
 581        * event, but otherwise we want to adjust the selected
 582        * text so we can wTextRefresh() */
 583       if( event->xmotion.state & (Button1Mask|Button3Mask|Button2Mask) )
 584       {
 585       DEBUG("MotionNotify");
 586       handled = True;
 587       wtext->text.endPos = textXtoPos( wtext, event->xmotion.x );
 588       }
 589       break;
 590
 591     case ButtonPress:
 592       DEBUG("ButtonPress");
 593       handled = True;
 594       wtext->text.startPos = textXtoPos( wtext, event->xbutton.x );
 595       wtext->text.endPos   = wtext->text.startPos;
 596       break;
 597
 598     case ButtonRelease:
 599       DEBUG("ButtonRelease");
 600       handled = True;
 601       wtext->text.endPos = textXtoPos( wtext, event->xbutton.x );
 602       break;
 603
 604     case KeyPress:
 605       DEBUG("KeyPress");
 606       handled = handleKeyPress( wtext, &event->xkey );
 607       break;
 608
 609     case EnterNotify:
 610       DEBUG("EnterNotify");
 611       handled = True;
 612 #if 0
 613       if (!wtext->magic)
 614         {
 615         wtext->magic = wAddTimerHandler(CURSOR_BLINK_RATE, blink, wtext);
 616         wtext->blink_on = !wtext->blink_on;
 617         blink(wtext);
 618         wtext->blinking = 1;
 619         }
 620 #endif
 621       break;
 622
 623     case LeaveNotify:
 624       DEBUG("LeaveNotify");
 625       handled = True;
 626 #if 0
 627       wtext->blinking = 0;
 628       if (wtext->blink_on)
 629             blink(wtext);
 630       if (wtext->magic)
 631             wDeleteTimerHandler(wtext->magic);
 632       wtext->magic = NULL;
 633 #endif
 634       break;
 635
 636     default:
 637       break;
 638     }
 639
 640   if( handled )
 641     textRefresh(wtext);
 642   else
 643     WMHandleEvent(event);
 644
 645   return;
 646   }
 647
 648
 649 static void
 650 handleExpose(WObjDescriptor *desc, XEvent *event)
 651 {
 652     wTextPaint(desc->parent);
 653 }
 654