WINGs/wtextfield.c

   1
   2
   3
   4
   5 #include "WINGsP.h"
   6
   7 #include <X11/keysym.h>
   8 #include <X11/Xatom.h>
   9
  10 #include <ctype.h>
  11
  12 #define CURSOR_BLINK_ON_DELAY   600
  13 #define CURSOR_BLINK_OFF_DELAY  300
  14
  15
  16 char *WMTextDidChangeNotification = "WMTextDidChangeNotification";
  17 char *WMTextDidBeginEditingNotification = "WMTextDidBeginEditingNotification";
  18 char *WMTextDidEndEditingNotification = "WMTextDidEndEditingNotification";
  19
  20
  21 typedef struct W_TextField {
  22     W_Class widgetClass;
  23     W_View *view;
  24
  25     struct W_TextField *nextField;     /* next textfield in the chain */
  26     struct W_TextField *prevField;
  27
  28     char *text;
  29     int textLen;                       /* size of text */
  30     int bufferSize;                    /* memory allocated for text */
  31
  32     int viewPosition;                  /* position of text being shown */
  33
  34     int cursorPosition;                /* position of the insertion cursor */
  35
  36     short usableWidth;
  37     short offsetWidth;                 /* offset of text from border */
  38
  39     WMRange selection;
  40     WMRange prevselection;
  41
  42 #if 0
  43     WMHandlerID timerID;               /* for cursor blinking */
  44 #endif
  45     struct {
  46         WMAlignment alignment:2;
  47
  48         unsigned int bordered:1;
  49
  50         unsigned int enabled:1;
  51
  52         unsigned int focused:1;
  53
  54         unsigned int cursorOn:1;
  55
  56         unsigned int secure:1;         /* password entry style */
  57
  58         /**/
  59         unsigned int notIllegalMovement:1;
  60     } flags;
  61 } TextField;
  62
  63
  64 #define MIN_TEXT_BUFFER         2
  65 #define TEXT_BUFFER_INCR        8
  66
  67
  68 #define WM_EMACSKEYMASK   ControlMask
  69
  70 #define WM_EMACSKEY_LEFT  XK_b
  71 #define WM_EMACSKEY_RIGHT XK_f
  72 #define WM_EMACSKEY_HOME  XK_a
  73 #define WM_EMACSKEY_END   XK_e
  74 #define WM_EMACSKEY_BS    XK_h
  75 #define WM_EMACSKEY_DEL   XK_d
  76
  77
  78
  79 #define DEFAULT_WIDTH           60
  80 #define DEFAULT_HEIGHT          20
  81 #define DEFAULT_BORDERED        True
  82 #define DEFAULT_ALIGNMENT       WALeft
  83
  84
  85
  86 static void destroyTextField(TextField *tPtr);
  87 static void paintTextField(TextField *tPtr);
  88
  89 static void handleEvents(XEvent *event, void *data);
  90 static void handleTextFieldActionEvents(XEvent *event, void *data);
  91 static void resizeTextField();
  92
  93 struct W_ViewProcedureTable _TextFieldViewProcedures = {
  94     NULL,
  95         resizeTextField,
  96         NULL
  97 };
  98
  99
 100 #define TEXT_WIDTH(tPtr, start) (WMWidthOfString((tPtr)->view->screen->normalFont, \
 101                                    &((tPtr)->text[(start)]), (tPtr)->textLen - (start) + 1))
 102
 103 #define TEXT_WIDTH2(tPtr, start, end) (WMWidthOfString((tPtr)->view->screen->normalFont, \
 104                                    &((tPtr)->text[(start)]), (end) - (start) + 1))
 105
 106
 107 static void
 108 memmv(char *dest, char *src, int size)
 109 {
 110     int i;
 111
 112     if (dest > src) {
 113         for (i=size-1; i>=0; i--) {
 114             dest[i] = src[i];
 115         }
 116     } else if (dest < src) {
 117         for (i=0; i<size; i++) {
 118             dest[i] = src[i];
 119         }
 120     }
 121 }
 122
 123
 124 static int
 125 incrToFit(TextField *tPtr)
 126 {
 127     int vp = tPtr->viewPosition;
 128
 129     while (TEXT_WIDTH(tPtr, tPtr->viewPosition) > tPtr->usableWidth) {
 130         tPtr->viewPosition++;
 131     }
 132     return vp!=tPtr->viewPosition;
 133 }
 134
 135
 136 static int
 137 incrToFit2(TextField *tPtr)
 138 {
 139     int vp = tPtr->viewPosition;
 140     while (TEXT_WIDTH2(tPtr, tPtr->viewPosition, tPtr->cursorPosition)
 141            >= tPtr->usableWidth)
 142         tPtr->viewPosition++;
 143
 144
 145     return vp!=tPtr->viewPosition;
 146 }
 147
 148
 149 static void
 150 decrToFit(TextField *tPtr)
 151 {
 152     while (TEXT_WIDTH(tPtr, tPtr->viewPosition-1) < tPtr->usableWidth
 153            && tPtr->viewPosition>0)
 154         tPtr->viewPosition--;
 155 }
 156
 157 #undef TEXT_WIDTH
 158 #undef TEXT_WIDTH2
 159
 160
 161 WMTextField*
 162 WMCreateTextField(WMWidget *parent)
 163 {
 164     TextField *tPtr;
 165
 166
 167     tPtr = wmalloc(sizeof(TextField));
 168     memset(tPtr, 0, sizeof(TextField));
 169
 170     tPtr->widgetClass = WC_TextField;
 171
 172     tPtr->view = W_CreateView(W_VIEW(parent));
 173     if (!tPtr->view) {
 174         free(tPtr);
 175         return NULL;
 176     }
 177     tPtr->view->self = tPtr;
 178
 179     tPtr->view->attribFlags |= CWCursor;
 180     tPtr->view->attribs.cursor = tPtr->view->screen->textCursor;
 181
 182     W_SetViewBackgroundColor(tPtr->view, tPtr->view->screen->white);
 183
 184     tPtr->text = wmalloc(MIN_TEXT_BUFFER);
 185     tPtr->text[0] = 0;
 186     tPtr->textLen = 0;
 187     tPtr->bufferSize = MIN_TEXT_BUFFER;
 188
 189     tPtr->flags.enabled = 1;
 190
 191     WMCreateEventHandler(tPtr->view, ExposureMask|StructureNotifyMask
 192                          |FocusChangeMask, handleEvents, tPtr);
 193
 194     W_ResizeView(tPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 195     WMSetTextFieldBordered(tPtr, DEFAULT_BORDERED);
 196     tPtr->flags.alignment = DEFAULT_ALIGNMENT;
 197     tPtr->offsetWidth = (tPtr->view->size.height
 198                          - WMFontHeight(tPtr->view->screen->normalFont))/2;
 199
 200     WMCreateEventHandler(tPtr->view, EnterWindowMask|LeaveWindowMask
 201                          |ButtonPressMask|KeyPressMask|Button1MotionMask,
 202                          handleTextFieldActionEvents, tPtr);
 203
 204     tPtr->flags.cursorOn = 1;
 205
 206     return tPtr;
 207 }
 208
 209
 210 void
 211 WMInsertTextFieldText(WMTextField *tPtr, char *text, int position)
 212 {
 213     int len;
 214
 215     CHECK_CLASS(tPtr, WC_TextField);
 216
 217     if (!text)
 218         return;
 219
 220     len = strlen(text);
 221
 222     /* check if buffer will hold the text */
 223     if (len + tPtr->textLen >= tPtr->bufferSize) {
 224         tPtr->bufferSize = tPtr->textLen + len + TEXT_BUFFER_INCR;
 225         tPtr->text = realloc(tPtr->text, tPtr->bufferSize);
 226     }
 227
 228     if (position < 0 || position >= tPtr->textLen) {
 229         /* append the text at the end */
 230         strcat(tPtr->text, text);
 231
 232         incrToFit(tPtr);
 233
 234         tPtr->textLen += len;
 235         tPtr->cursorPosition += len;
 236     } else {
 237         /* insert text at position */
 238         memmv(&(tPtr->text[position+len]), &(tPtr->text[position]),
 239                 tPtr->textLen-position+1);
 240
 241         memcpy(&(tPtr->text[position]), text, len);
 242
 243         tPtr->textLen += len;
 244         if (position >= tPtr->cursorPosition) {
 245             tPtr->cursorPosition += len;
 246             incrToFit2(tPtr);
 247         } else {
 248             incrToFit(tPtr);
 249         }
 250     }
 251
 252     paintTextField(tPtr);
 253
 254     WMPostNotificationName(WMTextDidChangeNotification, tPtr, NULL);
 255 }
 256
 257
 258 void
 259 WMDeleteTextFieldRange(WMTextField *tPtr, WMRange range)
 260 {
 261     CHECK_CLASS(tPtr, WC_TextField);
 262
 263     if (range.position >= tPtr->textLen)
 264         return;
 265
 266     if (range.count < 1) {
 267         if (range.position < 0)
 268             range.position = 0;
 269         tPtr->text[range.position] = 0;
 270         tPtr->textLen = range.position;
 271
 272         tPtr->cursorPosition = 0;
 273         tPtr->viewPosition = 0;
 274     } else {
 275         if (range.position + range.count > tPtr->textLen)
 276             range.count = tPtr->textLen - range.position;
 277         memmv(&(tPtr->text[range.position]), &(tPtr->text[range.position+range.count]),
 278                 tPtr->textLen - (range.position+range.count) + 1);
 279         tPtr->textLen -= range.count;
 280
 281         if (tPtr->cursorPosition > range.position)
 282             tPtr->cursorPosition -= range.count;
 283
 284         decrToFit(tPtr);
 285     }
 286
 287     paintTextField(tPtr);
 288
 289     WMPostNotificationName(WMTextDidChangeNotification, tPtr, NULL);
 290 }
 291
 292
 293
 294 char*
 295 WMGetTextFieldText(WMTextField *tPtr)
 296 {
 297     CHECK_CLASS(tPtr, WC_TextField);
 298
 299     return wstrdup(tPtr->text);
 300 }
 301
 302
 303 void
 304 WMSetTextFieldText(WMTextField *tPtr, char *text)
 305 {
 306     if (text==NULL) {
 307         tPtr->text[0] = 0;
 308         tPtr->textLen = 0;
 309     } else {
 310         tPtr->textLen = strlen(text);
 311
 312         if (tPtr->textLen >= tPtr->bufferSize) {
 313             tPtr->bufferSize = tPtr->textLen + TEXT_BUFFER_INCR;
 314             tPtr->text = realloc(tPtr->text, tPtr->bufferSize);
 315         }
 316         strcpy(tPtr->text, text);
 317     }
 318     /*
 319     if (tPtr->textLen < tPtr->cursorPosition)
 320         tPtr->cursorPosition = tPtr->textLen;
 321      */
 322     tPtr->cursorPosition = 0;
 323     tPtr->viewPosition = 0;
 324
 325     if (tPtr->view->flags.realized)
 326         paintTextField(tPtr);
 327
 328     WMPostNotificationName(WMTextDidChangeNotification, tPtr, NULL);
 329 }
 330
 331
 332 void
 333 WMSetTextFieldAlignment(WMTextField *tPtr, WMAlignment alignment)
 334 {
 335     tPtr->flags.alignment = alignment;
 336     if (alignment!=WALeft) {
 337         wwarning("only left alignment is supported in textfields");
 338         return;
 339     }
 340
 341     if (tPtr->view->flags.realized) {
 342         paintTextField(tPtr);
 343     }
 344 }
 345
 346
 347 void
 348 WMSetTextFieldBordered(WMTextField *tPtr, Bool bordered)
 349 {
 350     tPtr->flags.bordered = bordered;
 351
 352     if (tPtr->view->flags.realized) {
 353         paintTextField(tPtr);
 354     }
 355 }
 356
 357
 358
 359 void
 360 WMSetTextFieldSecure(WMTextField *tPtr, Bool flag)
 361 {
 362     tPtr->flags.secure = flag;
 363
 364     if (tPtr->view->flags.realized) {
 365         paintTextField(tPtr);
 366     }
 367 }
 368
 369
 370 void
 371 WMSetTextFieldEnabled(WMTextField *tPtr, Bool flag)
 372 {
 373     tPtr->flags.enabled = flag;
 374
 375     if (tPtr->view->flags.realized) {
 376         paintTextField(tPtr);
 377     }
 378 }
 379
 380
 381 static void
 382 resizeTextField(WMTextField *tPtr, unsigned int width, unsigned int height)
 383 {
 384     W_ResizeView(tPtr->view, width, height);
 385
 386     tPtr->offsetWidth = (tPtr->view->size.height
 387                          - WMFontHeight(tPtr->view->screen->normalFont))/2;
 388
 389     tPtr->usableWidth = tPtr->view->size.width - 2*tPtr->offsetWidth;
 390 }
 391
 392
 393 static void
 394 paintCursor(TextField *tPtr)
 395 {
 396     int cx;
 397     WMScreen *screen = tPtr->view->screen;
 398     int textWidth;
 399
 400     cx = WMWidthOfString(screen->normalFont,
 401                          &(tPtr->text[tPtr->viewPosition]),
 402                          tPtr->cursorPosition-tPtr->viewPosition);
 403
 404     switch (tPtr->flags.alignment) {
 405      case WARight:
 406         textWidth = WMWidthOfString(screen->normalFont, tPtr->text,
 407                                     tPtr->textLen);
 408         if (textWidth < tPtr->usableWidth)
 409             cx += tPtr->offsetWidth + tPtr->usableWidth - textWidth;
 410         else
 411             cx += tPtr->offsetWidth;
 412         break;
 413      case WALeft:
 414         cx += tPtr->offsetWidth;
 415         break;
 416      case WAJustified:
 417         /* not supported */
 418      case WACenter:
 419         textWidth = WMWidthOfString(screen->normalFont, tPtr->text,
 420                                     tPtr->textLen);
 421         if (textWidth < tPtr->usableWidth)
 422             cx += tPtr->offsetWidth + (tPtr->usableWidth-textWidth)/2;
 423         else
 424             cx += tPtr->offsetWidth;
 425         break;
 426     }
 427     /*
 428     XDrawRectangle(screen->display, tPtr->view->window, screen->xorGC,
 429                    cx, tPtr->offsetWidth, 1,
 430                    tPtr->view->size.height - 2*tPtr->offsetWidth - 1);
 431      */
 432     XDrawLine(screen->display, tPtr->view->window, screen->xorGC,
 433               cx, tPtr->offsetWidth, cx,
 434               tPtr->view->size.height - tPtr->offsetWidth - 1);
 435 }
 436
 437
 438
 439 static void
 440 drawRelief(WMView *view)
 441 {
 442     WMScreen *scr = view->screen;
 443     Display *dpy = scr->display;
 444     GC wgc;
 445     GC lgc;
 446     GC dgc;
 447     int width = view->size.width;
 448     int height = view->size.height;
 449
 450     wgc = W_GC(scr->white);
 451     dgc = W_GC(scr->darkGray);
 452     lgc = W_GC(scr->gray);
 453
 454     /* top left */
 455     XDrawLine(dpy, view->window, dgc, 0, 0, width-1, 0);
 456     XDrawLine(dpy, view->window, dgc, 0, 1, width-2, 1);
 457
 458     XDrawLine(dpy, view->window, dgc, 0, 0, 0, height-2);
 459     XDrawLine(dpy, view->window, dgc, 1, 0, 1, height-3);
 460
 461     /* bottom right */
 462     XDrawLine(dpy, view->window, wgc, 0, height-1, width-1, height-1);
 463     XDrawLine(dpy, view->window, lgc, 1, height-2, width-2, height-2);
 464
 465     XDrawLine(dpy, view->window, wgc, width-1, 0, width-1, height-1);
 466     XDrawLine(dpy, view->window, lgc, width-2, 1, width-2, height-3);
 467 }
 468
 469
 470 static void
 471 paintTextField(TextField *tPtr)
 472 {
 473     W_Screen *screen = tPtr->view->screen;
 474     W_View *view = tPtr->view;
 475     int tx, ty, tw, th;
 476     int rx;
 477     int bd;
 478     int totalWidth;
 479
 480
 481     if (!view->flags.realized || !view->flags.mapped)
 482         return;
 483
 484     if (!tPtr->flags.bordered) {
 485         bd = 0;
 486     } else {
 487         bd = 2;
 488     }
 489
 490     totalWidth = tPtr->view->size.width - 2*bd;
 491
 492     if (tPtr->textLen > 0) {
 493         tw = WMWidthOfString(screen->normalFont,
 494                              &(tPtr->text[tPtr->viewPosition]),
 495                              tPtr->textLen - tPtr->viewPosition);
 496
 497         th = WMFontHeight(screen->normalFont);
 498
 499         ty = tPtr->offsetWidth;
 500         switch (tPtr->flags.alignment) {
 501          case WALeft:
 502             tx = tPtr->offsetWidth;
 503             if (tw < tPtr->usableWidth)
 504                 XClearArea(screen->display, view->window, bd+tw, bd,
 505                            totalWidth-tw, view->size.height-2*bd,
 506                            False);
 507             break;
 508
 509          case WACenter:
 510             tx = tPtr->offsetWidth + (tPtr->usableWidth - tw) / 2;
 511             if (tw < tPtr->usableWidth)
 512                 XClearArea(screen->display, view->window, bd, bd,
 513                            totalWidth, view->size.height-2*bd, False);
 514             break;
 515
 516          default:
 517          case WARight:
 518             tx = tPtr->offsetWidth + tPtr->usableWidth - tw;
 519             if (tw < tPtr->usableWidth)
 520                 XClearArea(screen->display, view->window, bd, bd,
 521                            totalWidth-tw, view->size.height-2*bd, False);
 522             break;
 523         }
 524
 525         if (!tPtr->flags.secure) {
 526             if (!tPtr->flags.enabled)
 527                 WMSetColorInGC(screen->darkGray, screen->textFieldGC);
 528
 529             WMDrawImageString(screen, view->window, screen->textFieldGC,
 530                               screen->normalFont, tx, ty,
 531                               &(tPtr->text[tPtr->viewPosition]),
 532                               tPtr->textLen - tPtr->viewPosition);
 533
 534             if (tPtr->selection.count) {
 535                 int count;
 536
 537                 count = tPtr->selection.count < 0
 538                     ? tPtr->selection.position + tPtr->selection.count
 539                     : tPtr->selection.position;
 540
 541                 rx = tx + WMWidthOfString(screen->normalFont,
 542                                           &(tPtr->text[tPtr->viewPosition]),
 543                                           count);
 544
 545                 XSetBackground(screen->display, screen->textFieldGC,
 546                                screen->gray->color.pixel);
 547
 548                 WMDrawImageString(screen, view->window, screen->textFieldGC,
 549                                   screen->normalFont, rx, ty,
 550                                   &(tPtr->text[count]),
 551                                   abs(tPtr->selection.count));
 552
 553                 XSetBackground(screen->display, screen->textFieldGC,
 554                                screen->white->color.pixel);
 555             }
 556
 557             if (!tPtr->flags.enabled)
 558                 WMSetColorInGC(screen->black, screen->textFieldGC);
 559         }
 560     } else {
 561         XClearArea(screen->display, view->window, bd, bd, totalWidth,
 562                    view->size.height - 2*bd, False);
 563     }
 564
 565     /* draw cursor */
 566     if (tPtr->flags.focused && tPtr->flags.enabled && tPtr->flags.cursorOn
 567         && !tPtr->flags.secure) {
 568         paintCursor(tPtr);
 569     }
 570
 571     /* draw relief */
 572     if (tPtr->flags.bordered) {
 573         drawRelief(view);
 574     }
 575 }
 576
 577
 578 #if 0
 579 static void
 580 blinkCursor(void *data)
 581 {
 582     TextField *tPtr = (TextField*)data;
 583
 584     if (tPtr->flags.cursorOn) {
 585         tPtr->timerID = WMAddTimerHandler(CURSOR_BLINK_OFF_DELAY, blinkCursor,
 586                                           data);
 587     } else {
 588         tPtr->timerID = WMAddTimerHandler(CURSOR_BLINK_ON_DELAY, blinkCursor,
 589                                           data);
 590     }
 591     paintCursor(tPtr);
 592     tPtr->flags.cursorOn = !tPtr->flags.cursorOn;
 593 }
 594 #endif
 595
 596
 597 static void
 598 handleEvents(XEvent *event, void *data)
 599 {
 600     TextField *tPtr = (TextField*)data;
 601
 602     CHECK_CLASS(data, WC_TextField);
 603
 604
 605     switch (event->type) {
 606      case FocusIn:
 607         if (W_FocusedViewOfToplevel(W_TopLevelOfView(tPtr->view))!=tPtr->view)
 608             return;
 609         tPtr->flags.focused = 1;
 610 #if 0
 611         if (!tPtr->timerID) {
 612             tPtr->timerID = WMAddTimerHandler(CURSOR_BLINK_ON_DELAY,
 613                                               blinkCursor, tPtr);
 614         }
 615 #endif
 616         paintTextField(tPtr);
 617
 618         WMPostNotificationName(WMTextDidBeginEditingNotification, tPtr, NULL);
 619
 620         tPtr->flags.notIllegalMovement = 0;
 621         break;
 622
 623      case FocusOut:
 624         tPtr->flags.focused = 0;
 625 #if 0
 626         if (tPtr->timerID)
 627             WMDeleteTimerHandler(tPtr->timerID);
 628         tPtr->timerID = NULL;
 629 #endif
 630
 631         paintTextField(tPtr);
 632         if (!tPtr->flags.notIllegalMovement) {
 633             WMPostNotificationName(WMTextDidEndEditingNotification, tPtr,
 634                                    (void*)WMIllegalTextMovement);
 635         }
 636         break;
 637
 638      case Expose:
 639         if (event->xexpose.count!=0)
 640             break;
 641         paintTextField(tPtr);
 642         break;
 643
 644      case DestroyNotify:
 645         destroyTextField(tPtr);
 646         break;
 647     }
 648 }
 649
 650
 651 static void
 652 handleTextFieldKeyPress(TextField *tPtr, XEvent *event)
 653 {
 654     char buffer[64];
 655     KeySym ksym;
 656     int count, refresh = 0;
 657     int control_pressed = 0;
 658     int changed;
 659     WMScreen *scr = tPtr->view->screen;
 660
 661     changed = 0;
 662
 663     if (((XKeyEvent *) event)->state & WM_EMACSKEYMASK) {
 664         control_pressed = 1;
 665     }
 666
 667     count = XLookupString(&event->xkey, buffer, 63, &ksym, NULL);
 668     buffer[count] = '\0';
 669
 670     if (!event->xkey.state & ShiftMask) {
 671         if (tPtr->selection.count)
 672             refresh = 1;
 673         tPtr->prevselection = tPtr->selection;
 674         tPtr->selection.position = tPtr->cursorPosition;
 675         tPtr->selection.count = 0;
 676     }
 677
 678     switch (ksym) {
 679      case XK_Tab:
 680         if (event->xkey.state & ShiftMask) {
 681             if (tPtr->view->prevFocusChain) {
 682                 W_SetFocusOfTopLevel(W_TopLevelOfView(tPtr->view),
 683                                      tPtr->view->prevFocusChain);
 684                 tPtr->flags.notIllegalMovement = 1;
 685             }
 686             WMPostNotificationName(WMTextDidEndEditingNotification, tPtr,
 687                                    (void*)WMBacktabTextMovement);
 688         } else {
 689             if (tPtr->view->nextFocusChain) {
 690                 W_SetFocusOfTopLevel(W_TopLevelOfView(tPtr->view),
 691                                  tPtr->view->nextFocusChain);
 692                 tPtr->flags.notIllegalMovement = 1;
 693             }
 694             WMPostNotificationName(WMTextDidEndEditingNotification,
 695                                    tPtr, (void*)WMTabTextMovement);
 696         }
 697         break;
 698
 699      case XK_Return:
 700         WMPostNotificationName(WMTextDidEndEditingNotification, tPtr,
 701                                (void*)WMReturnTextMovement);
 702         break;
 703
 704      case WM_EMACSKEY_LEFT:
 705         if (!control_pressed) {
 706             goto normal_key;
 707         }
 708      case XK_KP_Left:
 709      case XK_Left:
 710         if (tPtr->cursorPosition > 0) {
 711             paintCursor(tPtr);
 712             if (event->xkey.state & ControlMask) {
 713                 int i;
 714                 for (i = tPtr->cursorPosition - 1; i >= 0; i--)
 715                     if (tPtr->text[i] == ' ' || i == 0) {
 716                         tPtr->cursorPosition = i;
 717                         break;
 718                     }
 719             } else {
 720                 tPtr->cursorPosition--;
 721             }
 722             if (tPtr->cursorPosition < tPtr->viewPosition) {
 723                 tPtr->viewPosition = tPtr->cursorPosition;
 724                 refresh = 1;
 725             } else {
 726                 paintCursor(tPtr);
 727             }
 728         }
 729         break;
 730
 731     case WM_EMACSKEY_RIGHT:
 732       if (!control_pressed) {
 733         goto normal_key;
 734       }
 735     case XK_KP_Right:
 736      case XK_Right:
 737         if (tPtr->cursorPosition < tPtr->textLen) {
 738             paintCursor(tPtr);
 739             if (event->xkey.state & ControlMask) {
 740                 int i;
 741                 for (i = tPtr->cursorPosition + 1; i <= tPtr->textLen; i++)
 742                     if (tPtr->text[i] == ' ' || i == tPtr->textLen) {
 743                         tPtr->cursorPosition = i;
 744                         break;
 745                     }
 746             } else {
 747                tPtr->cursorPosition++;
 748             }
 749             while (WMWidthOfString(scr->normalFont,
 750                                 &(tPtr->text[tPtr->viewPosition]),
 751                                 tPtr->cursorPosition-tPtr->viewPosition)
 752                    > tPtr->usableWidth) {
 753                 tPtr->viewPosition++;
 754                 refresh = 1;
 755             }
 756             if (!refresh)
 757                 paintCursor(tPtr);
 758         }
 759         break;
 760
 761     case WM_EMACSKEY_HOME:
 762       if (!control_pressed) {
 763         goto normal_key;
 764       }
 765     case XK_KP_Home:
 766      case XK_Home:
 767         if (tPtr->cursorPosition > 0) {
 768             paintCursor(tPtr);
 769             tPtr->cursorPosition = 0;
 770             if (tPtr->viewPosition > 0) {
 771                 tPtr->viewPosition = 0;
 772                 refresh = 1;
 773             } else {
 774                 paintCursor(tPtr);
 775             }
 776         }
 777         break;
 778
 779     case WM_EMACSKEY_END:
 780       if (!control_pressed) {
 781         goto normal_key;
 782       }
 783      case XK_KP_End:
 784      case XK_End:
 785         if (tPtr->cursorPosition < tPtr->textLen) {
 786             paintCursor(tPtr);
 787             tPtr->cursorPosition = tPtr->textLen;
 788             tPtr->viewPosition = 0;
 789             while (WMWidthOfString(scr->normalFont,
 790                                    &(tPtr->text[tPtr->viewPosition]),
 791                                    tPtr->textLen-tPtr->viewPosition)
 792                    > tPtr->usableWidth) {
 793                 tPtr->viewPosition++;
 794                 refresh = 1;
 795             }
 796             if (!refresh)
 797                 paintCursor(tPtr);
 798         }
 799         break;
 800
 801      case WM_EMACSKEY_BS:
 802       if (!control_pressed) {
 803         goto normal_key;
 804       }
 805      case XK_BackSpace:
 806         if (tPtr->cursorPosition > 0) {
 807             WMRange range;
 808             changed = 1;
 809             if (tPtr->prevselection.count) {
 810                 range.position = tPtr->prevselection.count < 0
 811                     ? tPtr->prevselection.position + tPtr->prevselection.count
 812                     : tPtr->prevselection.position;
 813
 814                 range.count = abs(tPtr->prevselection.count);
 815             } else {
 816                 range.position = tPtr->cursorPosition - 1;
 817                 range.count = 1;
 818             }
 819             WMDeleteTextFieldRange(tPtr, range);
 820         }
 821         break;
 822
 823     case WM_EMACSKEY_DEL:
 824       if (!control_pressed) {
 825         goto normal_key;
 826       }
 827     case XK_KP_Delete:
 828      case XK_Delete:
 829         if (tPtr->cursorPosition < tPtr->textLen || tPtr->prevselection.count) {
 830             WMRange range;
 831             changed = 1;
 832             if (tPtr->prevselection.count) {
 833                 range.position = tPtr->prevselection.count < 0
 834                     ? tPtr->prevselection.position + tPtr->prevselection.count
 835                     : tPtr->prevselection.position;
 836
 837                 range.count = abs(tPtr->prevselection.count);
 838             } else {
 839                 range.position = tPtr->cursorPosition;
 840                 range.count = 1;
 841             }
 842             WMDeleteTextFieldRange(tPtr, range);
 843         }
 844         break;
 845
 846     normal_key:
 847      default:
 848         if (count > 0 && !iscntrl(buffer[0])) {
 849             WMRange range;
 850             changed = 1;
 851             if (tPtr->prevselection.count) {
 852                 range.position = tPtr->prevselection.count < 0
 853                     ? tPtr->prevselection.position + tPtr->prevselection.count
 854                     : tPtr->prevselection.position;
 855
 856                 range.count = abs(tPtr->prevselection.count);
 857             } else {
 858                 range.position = tPtr->cursorPosition;
 859                 range.count = 1;
 860             }
 861             if (tPtr->prevselection.count)
 862                 WMDeleteTextFieldRange(tPtr, range);
 863             WMInsertTextFieldText(tPtr, buffer, tPtr->cursorPosition);
 864         } else {
 865             return;
 866         }
 867         break;
 868     }
 869     if (event->xkey.state & ShiftMask) {
 870         if (tPtr->selection.count == 0)
 871             tPtr->selection.position = tPtr->cursorPosition;
 872         tPtr->selection.count = tPtr->cursorPosition - tPtr->selection.position;
 873         refresh = 1;
 874     }
 875     tPtr->prevselection.count = 0;
 876     if (refresh) {
 877         paintTextField(tPtr);
 878     }
 879
 880     if (changed) {
 881         WMPostNotificationName(WMTextDidChangeNotification, tPtr, NULL);
 882     }
 883 }
 884
 885
 886 static int
 887 pointToCursorPosition(TextField *tPtr, int x)
 888 {
 889     WMFont *font = tPtr->view->screen->normalFont;
 890     int a, b, mid;
 891     int tw;
 892
 893     if (tPtr->flags.bordered)
 894         x -= 2;
 895
 896     a = tPtr->viewPosition;
 897     b = tPtr->viewPosition + tPtr->textLen;
 898     if (WMWidthOfString(font, &(tPtr->text[tPtr->viewPosition]),
 899                         tPtr->textLen-tPtr->viewPosition) < x)
 900         return tPtr->textLen;
 901
 902     while (a < b && b-a>1) {
 903         mid = (a+b)/2;
 904         tw = WMWidthOfString(font, &(tPtr->text[tPtr->viewPosition]),
 905                              mid - tPtr->viewPosition);
 906         if (tw > x)
 907             b = mid;
 908         else if (tw < x)
 909             a = mid;
 910         else
 911             return mid;
 912     }
 913     return (a+b)/2;
 914 }
 915
 916
 917 static void
 918 handleTextFieldActionEvents(XEvent *event, void *data)
 919 {
 920     TextField *tPtr = (TextField*)data;
 921
 922     CHECK_CLASS(data, WC_TextField);
 923
 924     switch (event->type) {
 925      case KeyPress:
 926         if (tPtr->flags.enabled)
 927             handleTextFieldKeyPress(tPtr, event);
 928         break;
 929
 930      case MotionNotify:
 931         if (tPtr->flags.enabled && (event->xmotion.state & Button1Mask)) {
 932
 933             if (!tPtr->selection.count) {
 934                 tPtr->selection.position = tPtr->cursorPosition;
 935             }
 936
 937             tPtr->cursorPosition = pointToCursorPosition(tPtr,
 938                                                          event->xmotion.x);
 939
 940             tPtr->selection.count = tPtr->cursorPosition
 941                 - tPtr->selection.position;
 942
 943             paintTextField(tPtr);
 944         }
 945         break;
 946
 947      case ButtonPress:
 948         if (tPtr->flags.enabled && !tPtr->flags.focused) {
 949             WMSetFocusToWidget(tPtr);
 950             tPtr->cursorPosition = pointToCursorPosition(tPtr,
 951                                                          event->xbutton.x);
 952             paintTextField(tPtr);
 953         } else if (tPtr->flags.focused) {
 954             tPtr->cursorPosition = pointToCursorPosition(tPtr,
 955                                                          event->xbutton.x);
 956             tPtr->selection.count = 0;
 957             paintTextField(tPtr);
 958         }
 959         if (event->xbutton.button == Button2 && tPtr->flags.enabled) {
 960             char *text;
 961
 962             text = W_GetTextSelection(tPtr->view->screen,
 963                                       tPtr->view->screen->clipboardAtom);
 964             if (!text) {
 965                 text = W_GetTextSelection(tPtr->view->screen, XA_CUT_BUFFER0);
 966             }
 967             if (text) {
 968                 WMInsertTextFieldText(tPtr, text, tPtr->cursorPosition);
 969                 XFree(text);
 970                 WMPostNotificationName(WMTextDidChangeNotification, tPtr,
 971                                        NULL);
 972             }
 973         }
 974         break;
 975
 976      case ButtonRelease:
 977
 978         break;
 979     }
 980 }
 981
 982
 983 static void
 984 destroyTextField(TextField *tPtr)
 985 {
 986 #if 0
 987     if (tPtr->timerID)
 988         WMDeleteTimerHandler(tPtr->timerID);
 989 #endif
 990
 991     if (tPtr->text)
 992         free(tPtr->text);
 993
 994     free(tPtr);
 995 }