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
  17 char *WMTextDidChangeNotification = "WMTextDidChangeNotification";
  18 char *WMTextDidBeginEditingNotification = "WMTextDidBeginEditingNotification";
  19 char *WMTextDidEndEditingNotification = "WMTextDidEndEditingNotification";
  20
  21
  22 typedef struct W_TextField {
  23     W_Class widgetClass;
  24     W_View *view;
  25
  26 #if 0
  27     struct W_TextField *nextField;     /* next textfield in the chain */
  28     struct W_TextField *prevField;
  29 #endif
  30
  31     char *text;
  32     int textLen;                       /* size of text */
  33     int bufferSize;                    /* memory allocated for text */
  34
  35     int viewPosition;                  /* position of text being shown */
  36
  37     int cursorPosition;                /* position of the insertion cursor */
  38
  39     short usableWidth;
  40     short offsetWidth;                 /* offset of text from border */
  41
  42     WMRange selection;
  43     WMRange prevselection;
  44
  45     WMFont *font;
  46
  47     WMTextFieldDelegate *delegate;
  48
  49 #if 0
  50     WMHandlerID timerID;               /* for cursor blinking */
  51 #endif
  52     struct {
  53         WMAlignment alignment:2;
  54
  55         unsigned int bordered:1;
  56
  57         unsigned int beveled:1;
  58
  59         unsigned int enabled:1;
  60
  61         unsigned int focused:1;
  62
  63         unsigned int cursorOn:1;
  64
  65         unsigned int secure:1;         /* password entry style */
  66
  67         unsigned int pointerGrabbed:1;
  68
  69         /**/
  70         unsigned int notIllegalMovement:1;
  71     } flags;
  72 } TextField;
  73
  74
  75 #define NOTIFY(T,C,N,A) { WMNotification *notif = WMCreateNotification(N,T,A);\
  76                         if ((T)->delegate && (T)->delegate->C)\
  77                                 (*(T)->delegate->C)((T)->delegate,notif);\
  78                         WMPostNotification(notif);\
  79                         WMReleaseNotification(notif);}
  80
  81
  82 #define MIN_TEXT_BUFFER         2
  83 #define TEXT_BUFFER_INCR        8
  84
  85
  86 #define WM_EMACSKEYMASK   ControlMask
  87
  88 #define WM_EMACSKEY_LEFT  XK_b
  89 #define WM_EMACSKEY_RIGHT XK_f
  90 #define WM_EMACSKEY_HOME  XK_a
  91 #define WM_EMACSKEY_END   XK_e
  92 #define WM_EMACSKEY_BS    XK_h
  93 #define WM_EMACSKEY_DEL   XK_d
  94
  95
  96
  97 #define DEFAULT_WIDTH           60
  98 #define DEFAULT_HEIGHT          20
  99 #define DEFAULT_BORDERED        True
 100 #define DEFAULT_ALIGNMENT       WALeft
 101
 102
 103
 104 static void destroyTextField(TextField *tPtr);
 105 static void paintTextField(TextField *tPtr);
 106
 107 static void handleEvents(XEvent *event, void *data);
 108 static void handleTextFieldActionEvents(XEvent *event, void *data);
 109 static void resizeTextField();
 110
 111 struct W_ViewProcedureTable _TextFieldViewProcedures = {
 112     NULL,
 113         resizeTextField,
 114         NULL
 115 };
 116
 117
 118 #define TEXT_WIDTH(tPtr, start) (WMWidthOfString((tPtr)->font, \
 119                    &((tPtr)->text[(start)]), (tPtr)->textLen - (start) + 1))
 120
 121 #define TEXT_WIDTH2(tPtr, start, end) (WMWidthOfString((tPtr)->font, \
 122                    &((tPtr)->text[(start)]), (end) - (start) + 1))
 123
 124
 125 static void
 126 memmv(char *dest, char *src, int size)
 127 {
 128     int i;
 129
 130     if (dest > src) {
 131         for (i=size-1; i>=0; i--) {
 132             dest[i] = src[i];
 133         }
 134     } else if (dest < src) {
 135         for (i=0; i<size; i++) {
 136             dest[i] = src[i];
 137         }
 138     }
 139 }
 140
 141
 142 static int
 143 incrToFit(TextField *tPtr)
 144 {
 145     int vp = tPtr->viewPosition;
 146
 147     while (TEXT_WIDTH(tPtr, tPtr->viewPosition) > tPtr->usableWidth) {
 148         tPtr->viewPosition++;
 149     }
 150     return vp!=tPtr->viewPosition;
 151 }
 152
 153
 154 static int
 155 incrToFit2(TextField *tPtr)
 156 {
 157     int vp = tPtr->viewPosition;
 158     while (TEXT_WIDTH2(tPtr, tPtr->viewPosition, tPtr->cursorPosition)
 159            >= tPtr->usableWidth)
 160         tPtr->viewPosition++;
 161
 162
 163     return vp!=tPtr->viewPosition;
 164 }
 165
 166
 167 static void
 168 decrToFit(TextField *tPtr)
 169 {
 170     while (TEXT_WIDTH(tPtr, tPtr->viewPosition-1) < tPtr->usableWidth
 171            && tPtr->viewPosition>0)
 172         tPtr->viewPosition--;
 173 }
 174
 175 #undef TEXT_WIDTH
 176 #undef TEXT_WIDTH2
 177
 178 static Bool
 179 requestHandler(WMWidget *w, Atom selection, Atom target, Atom *type,
 180                void **value, unsigned *length, int *format)
 181 {
 182     TextField *tPtr = w;
 183     int count,count2;
 184     Display *dpy = tPtr->view->screen->display;
 185     Atom _TARGETS;
 186     char *text;
 187     text = XGetAtomName(tPtr->view->screen->display,target);
 188     XFree(text);
 189     text = XGetAtomName(tPtr->view->screen->display,selection);
 190     XFree(text);
 191
 192     *format = 32;
 193     *length = 0;
 194     *value = NULL;
 195     count = tPtr->selection.count < 0
 196         ? tPtr->selection.position + tPtr->selection.count
 197         : tPtr->selection.position;
 198
 199     if (target == XA_STRING ||
 200             target == XInternAtom(dpy, "TEXT", False) ||
 201             target == XInternAtom(dpy, "COMPOUND_TEXT", False)) {
 202         *value = wstrdup(&(tPtr->text[count]));
 203         *length = abs(tPtr->selection.count);
 204         *format = 8;
 205         *type = target;
 206         return True;
 207     }
 208
 209     _TARGETS = XInternAtom(dpy, "TARGETS", False);
 210     if (target == _TARGETS) {
 211         int *ptr;
 212
 213         *length = 4;
 214         ptr = *value = (char *) wmalloc(4 * sizeof(Atom));
 215         ptr[0] = _TARGETS;
 216         ptr[1] = XA_STRING;
 217         ptr[2] = XInternAtom(dpy, "TEXT", False);
 218         ptr[3] = XInternAtom(dpy, "COMPOUND_TEXT", False);
 219         *type = target;
 220         return True;
 221     }
 222     /*
 223     *target = XA_PRIMARY;
 224     */
 225     return False;
 226
 227 }
 228
 229
 230 static void
 231 lostHandler(WMWidget *w, Atom selection)
 232 {
 233     TextField *tPtr = (WMTextField*)w;
 234
 235     tPtr->selection.count = 0;
 236     paintTextField(tPtr);
 237 }
 238
 239
 240 WMTextField*
 241 WMCreateTextField(WMWidget *parent)
 242 {
 243     TextField *tPtr;
 244
 245     tPtr = wmalloc(sizeof(TextField));
 246     memset(tPtr, 0, sizeof(TextField));
 247
 248     tPtr->widgetClass = WC_TextField;
 249
 250     tPtr->view = W_CreateView(W_VIEW(parent));
 251     if (!tPtr->view) {
 252         free(tPtr);
 253         return NULL;
 254     }
 255     tPtr->view->self = tPtr;
 256
 257     tPtr->view->attribFlags |= CWCursor;
 258     tPtr->view->attribs.cursor = tPtr->view->screen->textCursor;
 259
 260     W_SetViewBackgroundColor(tPtr->view, tPtr->view->screen->white);
 261
 262     tPtr->text = wmalloc(MIN_TEXT_BUFFER);
 263     tPtr->text[0] = 0;
 264     tPtr->textLen = 0;
 265     tPtr->bufferSize = MIN_TEXT_BUFFER;
 266
 267     tPtr->flags.enabled = 1;
 268
 269     WMCreateEventHandler(tPtr->view, ExposureMask|StructureNotifyMask
 270                          |FocusChangeMask, handleEvents, tPtr);
 271
 272     W_ResizeView(tPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
 273
 274     tPtr->font = WMRetainFont(tPtr->view->screen->normalFont);
 275
 276     tPtr->flags.bordered = DEFAULT_BORDERED;
 277     tPtr->flags.beveled = True;
 278     tPtr->flags.alignment = DEFAULT_ALIGNMENT;
 279     tPtr->offsetWidth =
 280         WMAX((tPtr->view->size.height - WMFontHeight(tPtr->font))/2, 1);
 281
 282     WMCreateEventHandler(tPtr->view, EnterWindowMask|LeaveWindowMask
 283                          |ButtonReleaseMask|ButtonPressMask|KeyPressMask|Button1MotionMask,
 284                          handleTextFieldActionEvents, tPtr);
 285
 286     WMCreateSelectionHandler(tPtr, XA_PRIMARY, CurrentTime, requestHandler,
 287              lostHandler, NULL);
 288
 289
 290     tPtr->flags.cursorOn = 1;
 291
 292     return tPtr;
 293 }
 294
 295
 296 void
 297 WMSetTextFieldDelegate(WMTextField *tPtr, WMTextFieldDelegate *delegate)
 298 {
 299     tPtr->delegate = delegate;
 300 }
 301
 302
 303 void
 304 WMInsertTextFieldText(WMTextField *tPtr, char *text, int position)
 305 {
 306     int len;
 307
 308     CHECK_CLASS(tPtr, WC_TextField);
 309
 310     if (!text)
 311         return;
 312
 313     len = strlen(text);
 314
 315     /* check if buffer will hold the text */
 316     if (len + tPtr->textLen >= tPtr->bufferSize) {
 317         tPtr->bufferSize = tPtr->textLen + len + TEXT_BUFFER_INCR;
 318         tPtr->text = realloc(tPtr->text, tPtr->bufferSize);
 319     }
 320
 321     if (position < 0 || position >= tPtr->textLen) {
 322         /* append the text at the end */
 323         strcat(tPtr->text, text);
 324
 325         incrToFit(tPtr);
 326
 327         tPtr->textLen += len;
 328         tPtr->cursorPosition += len;
 329     } else {
 330         /* insert text at position */
 331         memmv(&(tPtr->text[position+len]), &(tPtr->text[position]),
 332                 tPtr->textLen-position+1);
 333
 334         memcpy(&(tPtr->text[position]), text, len);
 335
 336         tPtr->textLen += len;
 337         if (position >= tPtr->cursorPosition) {
 338             tPtr->cursorPosition += len;
 339             incrToFit2(tPtr);
 340         } else {
 341             incrToFit(tPtr);
 342         }
 343     }
 344
 345     paintTextField(tPtr);
 346 }
 347
 348
 349 void
 350 WMDeleteTextFieldRange(WMTextField *tPtr, WMRange range)
 351 {
 352     CHECK_CLASS(tPtr, WC_TextField);
 353
 354     if (range.position >= tPtr->textLen)
 355         return;
 356
 357     if (range.count < 1) {
 358         if (range.position < 0)
 359             range.position = 0;
 360         tPtr->text[range.position] = 0;
 361         tPtr->textLen = range.position;
 362
 363         tPtr->cursorPosition = 0;
 364         tPtr->viewPosition = 0;
 365     } else {
 366         if (range.position + range.count > tPtr->textLen)
 367             range.count = tPtr->textLen - range.position;
 368         memmv(&(tPtr->text[range.position]), &(tPtr->text[range.position+range.count]),
 369                 tPtr->textLen - (range.position+range.count) + 1);
 370         tPtr->textLen -= range.count;
 371
 372         if (tPtr->cursorPosition > range.position)
 373             tPtr->cursorPosition -= range.count;
 374
 375         decrToFit(tPtr);
 376     }
 377
 378     paintTextField(tPtr);
 379 }
 380
 381
 382
 383 char*
 384 WMGetTextFieldText(WMTextField *tPtr)
 385 {
 386     CHECK_CLASS(tPtr, WC_TextField);
 387
 388     return wstrdup(tPtr->text);
 389 }
 390
 391
 392 void
 393 WMSetTextFieldText(WMTextField *tPtr, char *text)
 394 {
 395     if ((text && strcmp(tPtr->text, text) == 0) ||
 396         (!text && tPtr->textLen == 0))
 397         return;
 398
 399     if (text==NULL) {
 400         tPtr->text[0] = 0;
 401         tPtr->textLen = 0;
 402     } else {
 403         tPtr->textLen = strlen(text);
 404
 405         if (tPtr->textLen >= tPtr->bufferSize) {
 406             tPtr->bufferSize = tPtr->textLen + TEXT_BUFFER_INCR;
 407             tPtr->text = realloc(tPtr->text, tPtr->bufferSize);
 408         }
 409         strcpy(tPtr->text, text);
 410     }
 411     /*
 412     if (tPtr->textLen < tPtr->cursorPosition)
 413         tPtr->cursorPosition = tPtr->textLen;
 414      */
 415     tPtr->cursorPosition = tPtr->textLen;
 416     tPtr->viewPosition = 0;
 417     tPtr->selection.count = 0;
 418
 419     if (tPtr->view->flags.realized)
 420         paintTextField(tPtr);
 421 }
 422
 423
 424 void
 425 WMSetTextFieldFont(WMTextField *tPtr, WMFont *font)
 426 {
 427     /* TODO: update font change after field is mapped */
 428     WMReleaseFont(tPtr->font);
 429     tPtr->font = WMRetainFont(font);
 430 }
 431
 432
 433 void
 434 WMSetTextFieldAlignment(WMTextField *tPtr, WMAlignment alignment)
 435 {
 436     tPtr->flags.alignment = alignment;
 437     if (alignment!=WALeft) {
 438         wwarning("only left alignment is supported in textfields");
 439         return;
 440     }
 441
 442     if (tPtr->view->flags.realized) {
 443         paintTextField(tPtr);
 444     }
 445 }
 446
 447
 448 void
 449 WMSetTextFieldBordered(WMTextField *tPtr, Bool bordered)
 450 {
 451     tPtr->flags.bordered = bordered;
 452
 453     if (tPtr->view->flags.realized) {
 454         paintTextField(tPtr);
 455     }
 456 }
 457
 458
 459 void
 460 WMSetTextFieldBeveled(WMTextField *tPtr, Bool flag)
 461 {
 462     tPtr->flags.beveled = flag;
 463
 464     if (tPtr->view->flags.realized) {
 465         paintTextField(tPtr);
 466     }
 467 }
 468
 469
 470
 471 void
 472 WMSetTextFieldSecure(WMTextField *tPtr, Bool flag)
 473 {
 474     tPtr->flags.secure = flag;
 475
 476     if (tPtr->view->flags.realized) {
 477         paintTextField(tPtr);
 478     }
 479 }
 480
 481
 482 Bool
 483 WMGetTextFieldEditable(WMTextField *tPtr)
 484 {
 485     return tPtr->flags.enabled;
 486 }
 487
 488
 489 void
 490 WMSetTextFieldEditable(WMTextField *tPtr, Bool flag)
 491 {
 492     tPtr->flags.enabled = flag;
 493
 494     if (tPtr->view->flags.realized) {
 495         paintTextField(tPtr);
 496     }
 497 }
 498
 499
 500 void
 501 WMSelectTextFieldRange(WMTextField *tPtr, WMRange range)
 502 {
 503     if (tPtr->flags.enabled) {
 504         if (range.position < 0) {
 505             range.count += range.position;
 506             range.count = (range.count < 0) ? 0 : range.count;
 507             range.position = 0;
 508         } else if (range.position > tPtr->textLen) {
 509             range.position = tPtr->textLen;
 510             range.count = 0;
 511         }
 512
 513         if (range.position + range.count > tPtr->textLen)
 514             range.count = tPtr->textLen - range.position;
 515
 516         tPtr->prevselection = tPtr->selection; /* check if this is needed */
 517
 518         tPtr->selection = range;
 519
 520         if (tPtr->view->flags.realized) {
 521             paintTextField(tPtr);
 522         }
 523     }
 524 }
 525
 526
 527 void
 528 WMSetTextFieldCursorPosition(WMTextField *tPtr, unsigned int position)
 529 {
 530     if (tPtr->flags.enabled) {
 531         if (position > tPtr->textLen)
 532             position = tPtr->textLen;
 533
 534         tPtr->cursorPosition = position;
 535         if (tPtr->view->flags.realized) {
 536             paintTextField(tPtr);
 537         }
 538     }
 539 }
 540
 541
 542 void
 543 WMSetTextFieldNextTextField(WMTextField *tPtr, WMTextField *next)
 544 {
 545     CHECK_CLASS(tPtr, WC_TextField);
 546     if (next == NULL) {
 547         if (tPtr->view->nextFocusChain)
 548             tPtr->view->nextFocusChain->prevFocusChain = NULL;
 549         tPtr->view->nextFocusChain = NULL;
 550         return;
 551     }
 552
 553     CHECK_CLASS(next, WC_TextField);
 554
 555     if (tPtr->view->nextFocusChain)
 556         tPtr->view->nextFocusChain->prevFocusChain = NULL;
 557     if (next->view->prevFocusChain)
 558         next->view->prevFocusChain->nextFocusChain = NULL;
 559
 560     tPtr->view->nextFocusChain = next->view;
 561     next->view->prevFocusChain = tPtr->view;
 562 }
 563
 564
 565 void
 566 WMSetTextFieldPrevTextField(WMTextField *tPtr, WMTextField *prev)
 567 {
 568     CHECK_CLASS(tPtr, WC_TextField);
 569     if (prev == NULL) {
 570         if (tPtr->view->prevFocusChain)
 571             tPtr->view->prevFocusChain->nextFocusChain = NULL;
 572         tPtr->view->prevFocusChain = NULL;
 573         return;
 574     }
 575
 576     CHECK_CLASS(prev, WC_TextField);
 577
 578     if (tPtr->view->prevFocusChain)
 579         tPtr->view->prevFocusChain->nextFocusChain = NULL;
 580     if (prev->view->nextFocusChain)
 581         prev->view->nextFocusChain->prevFocusChain = NULL;
 582
 583     tPtr->view->prevFocusChain = prev->view;
 584     prev->view->nextFocusChain = tPtr->view;
 585 }
 586
 587
 588 static void
 589 resizeTextField(WMTextField *tPtr, unsigned int width, unsigned int height)
 590 {
 591     W_ResizeView(tPtr->view, width, height);
 592
 593     tPtr->offsetWidth =
 594         WMAX((tPtr->view->size.height - WMFontHeight(tPtr->font))/2, 1);
 595
 596     tPtr->usableWidth = tPtr->view->size.width - 2*tPtr->offsetWidth + 2;
 597 }
 598
 599
 600 static char*
 601 makeHiddenString(int length)
 602 {
 603     char *data = wmalloc(length+1);
 604
 605     memset(data, '*', length);
 606     data[length] = '\0';
 607     return data;
 608 }
 609
 610
 611 static void
 612 paintCursor(TextField *tPtr)
 613 {
 614     int cx;
 615     WMScreen *screen = tPtr->view->screen;
 616     int textWidth;
 617     char *text;
 618
 619     if (tPtr->flags.secure)
 620         text = makeHiddenString(strlen(tPtr->text));
 621     else
 622         text = tPtr->text;
 623
 624     cx = WMWidthOfString(tPtr->font, &(text[tPtr->viewPosition]),
 625                          tPtr->cursorPosition-tPtr->viewPosition);
 626
 627     switch (tPtr->flags.alignment) {
 628      case WARight:
 629         textWidth = WMWidthOfString(tPtr->font, text, tPtr->textLen);
 630         if (textWidth < tPtr->usableWidth)
 631             cx += tPtr->offsetWidth + tPtr->usableWidth - textWidth + 1;
 632         else
 633             cx += tPtr->offsetWidth + 1;
 634         break;
 635      case WALeft:
 636         cx += tPtr->offsetWidth + 1;
 637         break;
 638      case WAJustified:
 639         /* not supported */
 640      case WACenter:
 641         textWidth = WMWidthOfString(tPtr->font, text, tPtr->textLen);
 642         if (textWidth < tPtr->usableWidth)
 643             cx += tPtr->offsetWidth + (tPtr->usableWidth-textWidth)/2;
 644         else
 645             cx += tPtr->offsetWidth;
 646         break;
 647     }
 648     /*
 649     XDrawRectangle(screen->display, tPtr->view->window, screen->xorGC,
 650                    cx, tPtr->offsetWidth, 1,
 651                    tPtr->view->size.height - 2*tPtr->offsetWidth - 1);
 652         printf("%d %d\n",cx,tPtr->cursorPosition);
 653      */
 654     XDrawLine(screen->display, tPtr->view->window, screen->xorGC,
 655               cx, tPtr->offsetWidth, cx,
 656               tPtr->view->size.height - tPtr->offsetWidth - 1);
 657
 658     if (tPtr->flags.secure)
 659         free(text);
 660 }
 661
 662
 663
 664 static void
 665 drawRelief(WMView *view, Bool beveled)
 666 {
 667     WMScreen *scr = view->screen;
 668     Display *dpy = scr->display;
 669     GC wgc;
 670     GC lgc;
 671     GC dgc;
 672     int width = view->size.width;
 673     int height = view->size.height;
 674
 675     dgc = WMColorGC(scr->darkGray);
 676
 677     if (!beveled) {
 678         XDrawRectangle(dpy, view->window, dgc, 0, 0, width-1, height-1);
 679
 680         return;
 681     }
 682     wgc = WMColorGC(scr->white);
 683     lgc = WMColorGC(scr->gray);
 684
 685     /* top left */
 686     XDrawLine(dpy, view->window, dgc, 0, 0, width-1, 0);
 687     XDrawLine(dpy, view->window, dgc, 0, 1, width-2, 1);
 688
 689     XDrawLine(dpy, view->window, dgc, 0, 0, 0, height-2);
 690     XDrawLine(dpy, view->window, dgc, 1, 0, 1, height-3);
 691
 692     /* bottom right */
 693     XDrawLine(dpy, view->window, wgc, 0, height-1, width-1, height-1);
 694     XDrawLine(dpy, view->window, lgc, 1, height-2, width-2, height-2);
 695
 696     XDrawLine(dpy, view->window, wgc, width-1, 0, width-1, height-1);
 697     XDrawLine(dpy, view->window, lgc, width-2, 1, width-2, height-3);
 698 }
 699
 700
 701 static void
 702 paintTextField(TextField *tPtr)
 703 {
 704     W_Screen *screen = tPtr->view->screen;
 705     W_View *view = tPtr->view;
 706     W_View viewbuffer;
 707     int tx, ty, tw, th;
 708     int rx;
 709     int bd;
 710     int totalWidth;
 711     char *text;
 712     Pixmap drawbuffer;
 713
 714
 715     if (!view->flags.realized || !view->flags.mapped)
 716         return;
 717
 718     if (!tPtr->flags.bordered) {
 719         bd = 0;
 720     } else {
 721         bd = 2;
 722     }
 723
 724     if (tPtr->flags.secure) {
 725         text = makeHiddenString(strlen(tPtr->text));
 726     } else {
 727         text = tPtr->text;
 728     }
 729
 730     totalWidth = tPtr->view->size.width - 2*bd;
 731
 732     drawbuffer = XCreatePixmap(screen->display, view->window,
 733             view->size.width, view->size.height, screen->depth);
 734     XFillRectangle(screen->display, drawbuffer, WMColorGC(screen->white),
 735             0,0, view->size.width,view->size.height);
 736     /* this is quite dirty */
 737     viewbuffer.screen = view->screen;
 738     viewbuffer.size = view->size;
 739     viewbuffer.window = drawbuffer;
 740
 741
 742     if (tPtr->textLen > 0) {
 743         tw = WMWidthOfString(tPtr->font, &(text[tPtr->viewPosition]),
 744                              tPtr->textLen - tPtr->viewPosition);
 745
 746         th = WMFontHeight(tPtr->font);
 747
 748         ty = tPtr->offsetWidth;
 749         switch (tPtr->flags.alignment) {
 750          case WALeft:
 751             tx = tPtr->offsetWidth + 1;
 752             if (tw < tPtr->usableWidth)
 753                 XFillRectangle(screen->display, drawbuffer,
 754                                WMColorGC(screen->white),
 755                                bd+tw,bd, totalWidth-tw,view->size.height-2*bd);
 756             break;
 757
 758          case WACenter:
 759             tx = tPtr->offsetWidth + (tPtr->usableWidth - tw) / 2;
 760             if (tw < tPtr->usableWidth)
 761                 XClearArea(screen->display, view->window, bd, bd,
 762                            totalWidth, view->size.height-2*bd, False);
 763             break;
 764
 765          default:
 766          case WARight:
 767             tx = tPtr->offsetWidth + tPtr->usableWidth - tw - 1;
 768             if (tw < tPtr->usableWidth)
 769                 XClearArea(screen->display, view->window, bd, bd,
 770                            totalWidth-tw, view->size.height-2*bd, False);
 771             break;
 772         }
 773
 774         if (!tPtr->flags.enabled)
 775             WMSetColorInGC(screen->darkGray, screen->textFieldGC);
 776
 777         WMDrawImageString(screen, drawbuffer, screen->textFieldGC,
 778                           tPtr->font, tx, ty,
 779                           &(text[tPtr->viewPosition]),
 780                           tPtr->textLen - tPtr->viewPosition);
 781
 782         if (tPtr->selection.count) {
 783             int count,count2;
 784
 785             count = tPtr->selection.count < 0
 786                 ? tPtr->selection.position + tPtr->selection.count
 787                 : tPtr->selection.position;
 788             count2 = abs(tPtr->selection.count);
 789             if (count < tPtr->viewPosition) {
 790                 count2 = abs(count2 - abs(tPtr->viewPosition - count));
 791                 count = tPtr->viewPosition;
 792             }
 793
 794
 795             rx = tPtr->offsetWidth + 1 + WMWidthOfString(tPtr->font,text,count)
 796                 - WMWidthOfString(tPtr->font,text,tPtr->viewPosition);
 797
 798             XSetBackground(screen->display, screen->textFieldGC,
 799                     screen->gray->color.pixel);
 800
 801             WMDrawImageString(screen, drawbuffer, screen->textFieldGC,
 802                     tPtr->font, rx, ty, &(text[count]),
 803                     count2);
 804
 805             XSetBackground(screen->display, screen->textFieldGC,
 806                     screen->white->color.pixel);
 807         }
 808
 809         if (!tPtr->flags.enabled)
 810             WMSetColorInGC(screen->black, screen->textFieldGC);
 811     } else {
 812             XFillRectangle(screen->display, drawbuffer,
 813                            WMColorGC(screen->white),
 814                            bd,bd, totalWidth,view->size.height-2*bd);
 815     }
 816
 817     /* draw relief */
 818     if (tPtr->flags.bordered) {
 819         drawRelief(&viewbuffer, tPtr->flags.beveled);
 820     }
 821
 822     if (tPtr->flags.secure)
 823         free(text);
 824     XCopyArea(screen->display, drawbuffer, view->window,
 825               screen->copyGC, 0,0, view->size.width,
 826               view->size.height,0,0);
 827     XFreePixmap(screen->display, drawbuffer);
 828
 829     /* draw cursor */
 830     if (tPtr->flags.focused && tPtr->flags.enabled && tPtr->flags.cursorOn) {
 831         paintCursor(tPtr);
 832     }
 833 }
 834
 835
 836 #if 0
 837 static void
 838 blinkCursor(void *data)
 839 {
 840     TextField *tPtr = (TextField*)data;
 841
 842     if (tPtr->flags.cursorOn) {
 843         tPtr->timerID = WMAddTimerHandler(CURSOR_BLINK_OFF_DELAY, blinkCursor,
 844                                           data);
 845     } else {
 846         tPtr->timerID = WMAddTimerHandler(CURSOR_BLINK_ON_DELAY, blinkCursor,
 847                                           data);
 848     }
 849     paintCursor(tPtr);
 850     tPtr->flags.cursorOn = !tPtr->flags.cursorOn;
 851 }
 852 #endif
 853
 854
 855 static void
 856 handleEvents(XEvent *event, void *data)
 857 {
 858     TextField *tPtr = (TextField*)data;
 859
 860     CHECK_CLASS(data, WC_TextField);
 861
 862
 863     switch (event->type) {
 864      case FocusIn:
 865         if (W_FocusedViewOfToplevel(W_TopLevelOfView(tPtr->view))!=tPtr->view)
 866             return;
 867         tPtr->flags.focused = 1;
 868 #if 0
 869         if (!tPtr->timerID) {
 870             tPtr->timerID = WMAddTimerHandler(CURSOR_BLINK_ON_DELAY,
 871                                               blinkCursor, tPtr);
 872         }
 873 #endif
 874         paintTextField(tPtr);
 875
 876         NOTIFY(tPtr, didBeginEditing, WMTextDidBeginEditingNotification, NULL);
 877
 878         tPtr->flags.notIllegalMovement = 0;
 879         break;
 880
 881      case FocusOut:
 882         tPtr->flags.focused = 0;
 883 #if 0
 884         if (tPtr->timerID)
 885             WMDeleteTimerHandler(tPtr->timerID);
 886         tPtr->timerID = NULL;
 887 #endif
 888
 889         paintTextField(tPtr);
 890         if (!tPtr->flags.notIllegalMovement) {
 891             NOTIFY(tPtr, didEndEditing, WMTextDidEndEditingNotification,
 892                    (void*)WMIllegalTextMovement);
 893         }
 894         break;
 895
 896      case Expose:
 897         if (event->xexpose.count!=0)
 898             break;
 899         paintTextField(tPtr);
 900         break;
 901
 902      case DestroyNotify:
 903         destroyTextField(tPtr);
 904         break;
 905     }
 906 }
 907
 908
 909 static void
 910 handleTextFieldKeyPress(TextField *tPtr, XEvent *event)
 911 {
 912     char buffer[64];
 913     KeySym ksym;
 914     int count, refresh = 0;
 915     int control_pressed = 0;
 916
 917     if (((XKeyEvent *) event)->state & WM_EMACSKEYMASK) {
 918         control_pressed = 1;
 919     }
 920
 921     count = XLookupString(&event->xkey, buffer, 63, &ksym, NULL);
 922     buffer[count] = '\0';
 923
 924     if (!(event->xkey.state & ShiftMask)) {
 925         if (tPtr->selection.count)
 926             refresh = 1;
 927         tPtr->prevselection = tPtr->selection;
 928         tPtr->selection.position = tPtr->cursorPosition;
 929         tPtr->selection.count = 0;
 930     }
 931
 932     /* Be careful in any case in this switch statement, never to call
 933      * to more than a function that can generate text change notifications.
 934      * Only one text change notification should be sent in any case.
 935      * Else hazardous things can happen.
 936      * Maybe we need a better solution than the function wrapper to inform
 937      * functions that change text in text fields, if they need to send a
 938      * change notification or not. -Dan
 939      */
 940     switch (ksym) {
 941      case XK_Tab:
 942      case XK_ISO_Left_Tab:
 943         if (event->xkey.state & ShiftMask) {
 944             if (tPtr->view->prevFocusChain) {
 945                 W_SetFocusOfTopLevel(W_TopLevelOfView(tPtr->view),
 946                                      tPtr->view->prevFocusChain);
 947                 tPtr->flags.notIllegalMovement = 1;
 948             }
 949             NOTIFY(tPtr, didEndEditing, WMTextDidEndEditingNotification,
 950                    (void*)WMBacktabTextMovement);
 951         } else {
 952             if (tPtr->view->nextFocusChain) {
 953                 W_SetFocusOfTopLevel(W_TopLevelOfView(tPtr->view),
 954                                      tPtr->view->nextFocusChain);
 955                 tPtr->flags.notIllegalMovement = 1;
 956             }
 957             NOTIFY(tPtr, didEndEditing, WMTextDidEndEditingNotification,
 958                    (void*)WMTabTextMovement);
 959         }
 960         break;
 961
 962      case XK_Return:
 963         NOTIFY(tPtr, didEndEditing, WMTextDidEndEditingNotification,
 964                (void*)WMReturnTextMovement);
 965         break;
 966
 967      case WM_EMACSKEY_LEFT:
 968         if (!control_pressed) {
 969             goto normal_key;
 970         }
 971      case XK_KP_Left:
 972      case XK_Left:
 973         if (tPtr->cursorPosition > 0) {
 974             paintCursor(tPtr);
 975             if (event->xkey.state & ControlMask) {
 976                 int i;
 977                 for (i = tPtr->cursorPosition - 1; i >= 0; i--)
 978                     if (tPtr->text[i] == ' ' || i == 0) {
 979                         tPtr->cursorPosition = i;
 980                         break;
 981                     }
 982             } else {
 983                 tPtr->cursorPosition--;
 984             }
 985             if (tPtr->cursorPosition < tPtr->viewPosition) {
 986                 tPtr->viewPosition = tPtr->cursorPosition;
 987                 refresh = 1;
 988             } else {
 989                 paintCursor(tPtr);
 990             }
 991         }
 992         break;
 993
 994     case WM_EMACSKEY_RIGHT:
 995       if (!control_pressed) {
 996         goto normal_key;
 997       }
 998     case XK_KP_Right:
 999      case XK_Right:
1000         if (tPtr->cursorPosition < tPtr->textLen) {
1001             paintCursor(tPtr);
1002             if (event->xkey.state & ControlMask) {
1003                 int i;
1004                 for (i = tPtr->cursorPosition + 1; i <= tPtr->textLen; i++)
1005                     if (tPtr->text[i] == ' ' || i == tPtr->textLen) {
1006                         tPtr->cursorPosition = i;
1007                         break;
1008                     }
1009             } else {
1010                tPtr->cursorPosition++;
1011             }
1012             while (WMWidthOfString(tPtr->font,
1013                                 &(tPtr->text[tPtr->viewPosition]),
1014                                 tPtr->cursorPosition-tPtr->viewPosition)
1015                    > tPtr->usableWidth) {
1016                 tPtr->viewPosition++;
1017                 refresh = 1;
1018             }
1019             if (!refresh)
1020                 paintCursor(tPtr);
1021         }
1022         break;
1023
1024     case WM_EMACSKEY_HOME:
1025       if (!control_pressed) {
1026         goto normal_key;
1027       }
1028     case XK_KP_Home:
1029      case XK_Home:
1030         if (tPtr->cursorPosition > 0) {
1031             paintCursor(tPtr);
1032             tPtr->cursorPosition = 0;
1033             if (tPtr->viewPosition > 0) {
1034                 tPtr->viewPosition = 0;
1035                 refresh = 1;
1036             } else {
1037                 paintCursor(tPtr);
1038             }
1039         }
1040         break;
1041
1042     case WM_EMACSKEY_END:
1043       if (!control_pressed) {
1044         goto normal_key;
1045       }
1046      case XK_KP_End:
1047      case XK_End:
1048         if (tPtr->cursorPosition < tPtr->textLen) {
1049             paintCursor(tPtr);
1050             tPtr->cursorPosition = tPtr->textLen;
1051             tPtr->viewPosition = 0;
1052             while (WMWidthOfString(tPtr->font,
1053                                    &(tPtr->text[tPtr->viewPosition]),
1054                                    tPtr->textLen-tPtr->viewPosition)
1055                    > tPtr->usableWidth) {
1056                 tPtr->viewPosition++;
1057                 refresh = 1;
1058             }
1059             if (!refresh)
1060                 paintCursor(tPtr);
1061         }
1062         break;
1063
1064      case WM_EMACSKEY_BS:
1065       if (!control_pressed) {
1066         goto normal_key;
1067       }
1068      case XK_BackSpace:
1069         if (tPtr->cursorPosition > 0) {
1070             WMRange range;
1071
1072             if (tPtr->prevselection.count) {
1073                 range.position = tPtr->prevselection.count < 0
1074                     ? tPtr->prevselection.position + tPtr->prevselection.count
1075                     : tPtr->prevselection.position;
1076
1077                 range.count = abs(tPtr->prevselection.count);
1078             } else {
1079                 range.position = tPtr->cursorPosition - 1;
1080                 range.count = 1;
1081             }
1082             WMDeleteTextFieldRange(tPtr, range);
1083             NOTIFY(tPtr, didChange, WMTextDidChangeNotification,
1084                    (void*)WMDeleteTextEvent);
1085         }
1086         break;
1087
1088     case WM_EMACSKEY_DEL:
1089       if (!control_pressed) {
1090         goto normal_key;
1091       }
1092     case XK_KP_Delete:
1093      case XK_Delete:
1094         if (tPtr->cursorPosition < tPtr->textLen || tPtr->prevselection.count) {
1095             WMRange range;
1096
1097             if (tPtr->prevselection.count) {
1098                 range.position = tPtr->prevselection.count < 0
1099                     ? tPtr->prevselection.position + tPtr->prevselection.count
1100                     : tPtr->prevselection.position;
1101
1102                 range.count = abs(tPtr->prevselection.count);
1103             } else {
1104                 range.position = tPtr->cursorPosition;
1105                 range.count = 1;
1106             }
1107             WMDeleteTextFieldRange(tPtr, range);
1108             NOTIFY(tPtr, didChange, WMTextDidChangeNotification,
1109                    (void*)WMDeleteTextEvent);
1110         }
1111         break;
1112
1113     normal_key:
1114      default:
1115         if (count > 0 && !iscntrl(buffer[0])) {
1116             WMRange range;
1117
1118             if (tPtr->prevselection.count) {
1119                 range.position = tPtr->prevselection.count < 0
1120                     ? tPtr->prevselection.position + tPtr->prevselection.count
1121                     : tPtr->prevselection.position;
1122
1123                 range.count = abs(tPtr->prevselection.count);
1124             } else {
1125                 range.position = tPtr->cursorPosition;
1126                 range.count = 1;
1127             }
1128             if (tPtr->prevselection.count)
1129                 WMDeleteTextFieldRange(tPtr, range);
1130             WMInsertTextFieldText(tPtr, buffer, tPtr->cursorPosition);
1131             NOTIFY(tPtr, didChange, WMTextDidChangeNotification,
1132                    (void*)WMInsertTextEvent);
1133         } else {
1134             return;
1135         }
1136         break;
1137     }
1138     if (event->xkey.state & ShiftMask) {
1139         if (tPtr->selection.count == 0)
1140             tPtr->selection.position = tPtr->cursorPosition;
1141         tPtr->selection.count = tPtr->cursorPosition - tPtr->selection.position;
1142         refresh = 1;
1143     }
1144     tPtr->prevselection.count = 0;
1145     if (refresh) {
1146         paintTextField(tPtr);
1147     }
1148 }
1149
1150
1151 static int
1152 pointToCursorPosition(TextField *tPtr, int x)
1153 {
1154     int a, b, mid;
1155     int tw;
1156
1157     if (tPtr->flags.bordered)
1158         x -= 2;
1159
1160     a = tPtr->viewPosition;
1161     b = tPtr->viewPosition + tPtr->textLen;
1162     if (WMWidthOfString(tPtr->font, &(tPtr->text[tPtr->viewPosition]),
1163                         tPtr->textLen - tPtr->viewPosition) < x)
1164         return tPtr->textLen;
1165
1166     while (a < b && b-a>1) {
1167         mid = (a+b)/2;
1168         tw = WMWidthOfString(tPtr->font, &(tPtr->text[tPtr->viewPosition]),
1169                              mid - tPtr->viewPosition);
1170         if (tw > x)
1171             b = mid;
1172         else if (tw < x)
1173             a = mid;
1174         else
1175             return mid;
1176     }
1177     return (a+b)/2;
1178 }
1179
1180
1181 static void
1182 handleTextFieldActionEvents(XEvent *event, void *data)
1183 {
1184     TextField *tPtr = (TextField*)data;
1185     static int move;
1186
1187     CHECK_CLASS(data, WC_TextField);
1188
1189     switch (event->type) {
1190      case KeyPress:
1191         if (tPtr->flags.enabled && tPtr->flags.focused) {
1192             handleTextFieldKeyPress(tPtr, event);
1193             XGrabPointer(WMScreenDisplay(W_VIEW(tPtr)->screen),
1194                          W_VIEW(tPtr)->window, False,
1195                          PointerMotionMask|ButtonPressMask|ButtonReleaseMask,
1196                          GrabModeAsync, GrabModeAsync, None,
1197                          W_VIEW(tPtr)->screen->invisibleCursor,
1198                          CurrentTime);
1199             tPtr->flags.pointerGrabbed = 1;
1200         }
1201         break;
1202
1203      case MotionNotify:
1204
1205         if (tPtr->flags.pointerGrabbed) {
1206             tPtr->flags.pointerGrabbed = 0;
1207             XUngrabPointer(WMScreenDisplay(W_VIEW(tPtr)->screen), CurrentTime);
1208         }
1209
1210         if (tPtr->flags.enabled && (event->xmotion.state & Button1Mask)) {
1211
1212             if (tPtr->viewPosition < tPtr->textLen && event->xmotion.x >
1213                 tPtr->usableWidth) {
1214                 if (WMWidthOfString(tPtr->font,
1215                                     &(tPtr->text[tPtr->viewPosition]),
1216                                     tPtr->cursorPosition-tPtr->viewPosition)
1217                     > tPtr->usableWidth) {
1218                     tPtr->viewPosition++;
1219                 }
1220             } else if (tPtr->viewPosition > 0 && event->xmotion.x < 0) {
1221                 paintCursor(tPtr);
1222                 tPtr->viewPosition--;
1223             }
1224
1225             if (!tPtr->selection.count) {
1226                 tPtr->selection.position = tPtr->cursorPosition;
1227             }
1228
1229             tPtr->cursorPosition =
1230                 pointToCursorPosition(tPtr, event->xmotion.x);
1231
1232             tPtr->selection.count = tPtr->cursorPosition - tPtr->selection.position;
1233
1234             /*
1235              printf("notify %d %d\n",event->xmotion.x,tPtr->usableWidth);
1236              */
1237
1238             paintCursor(tPtr);
1239             paintTextField(tPtr);
1240
1241         }
1242         if (move) {
1243             XSetSelectionOwner(tPtr->view->screen->display,
1244                        XA_PRIMARY, tPtr->view->window, CurrentTime);
1245         }
1246         break;
1247
1248      case ButtonPress:
1249         if (tPtr->flags.pointerGrabbed) {
1250             tPtr->flags.pointerGrabbed = 0;
1251             XUngrabPointer(WMScreenDisplay(W_VIEW(tPtr)->screen), CurrentTime);
1252             break;
1253         }
1254
1255         move = 1;
1256         switch (tPtr->flags.alignment) {
1257             int textWidth;
1258          case WARight:
1259             textWidth = WMWidthOfString(tPtr->font, tPtr->text, tPtr->textLen);
1260             if (tPtr->flags.enabled && !tPtr->flags.focused) {
1261                 WMSetFocusToWidget(tPtr);
1262             } else if (tPtr->flags.focused) {
1263                 tPtr->selection.count = 0;
1264             }
1265             if(textWidth < tPtr->usableWidth){
1266                 tPtr->cursorPosition = pointToCursorPosition(tPtr,
1267                                      event->xbutton.x - tPtr->usableWidth
1268                                      + textWidth);
1269             }
1270             else tPtr->cursorPosition = pointToCursorPosition(tPtr,
1271                                      event->xbutton.x);
1272             /*
1273             tPtr->cursorPosition = pointToCursorPosition(tPtr,
1274                                      event->xbutton.x);
1275                 tPtr->cursorPosition += tPtr->usableWidth - textWidth;
1276             }
1277
1278             tPtr->cursorPosition = pointToCursorPosition(tPtr,
1279                                      event->xbutton.x);
1280                                      */
1281             paintTextField(tPtr);
1282             break;
1283
1284          case WALeft:
1285             if (tPtr->flags.enabled && !tPtr->flags.focused) {
1286                 WMSetFocusToWidget(tPtr);
1287                 tPtr->cursorPosition = pointToCursorPosition(tPtr,
1288                                      event->xbutton.x);
1289                 paintTextField(tPtr);
1290             } else if (tPtr->flags.focused) {
1291                 tPtr->cursorPosition = pointToCursorPosition(tPtr,
1292                                      event->xbutton.x);
1293                 tPtr->selection.count = 0;
1294                 paintTextField(tPtr);
1295             }
1296             if (event->xbutton.button == Button2 && tPtr->flags.enabled) {
1297                 char *text;
1298
1299                 text = W_GetTextSelection(tPtr->view->screen, XA_PRIMARY);
1300
1301                 if (!text) {
1302                 text = W_GetTextSelection(tPtr->view->screen,
1303                               tPtr->view->screen->clipboardAtom);
1304                 }
1305                 if (!text) {
1306                     text = W_GetTextSelection(tPtr->view->screen,
1307                                               XA_CUT_BUFFER0);
1308                 }
1309                 if (text) {
1310                     WMInsertTextFieldText(tPtr, text, tPtr->cursorPosition);
1311                     XFree(text);
1312                     NOTIFY(tPtr, didChange, WMTextDidChangeNotification,
1313                            (void*)WMInsertTextEvent);
1314                 }
1315             }
1316             break;
1317         }
1318         break;
1319
1320      case ButtonRelease:
1321         if (tPtr->flags.pointerGrabbed) {
1322             tPtr->flags.pointerGrabbed = 0;
1323             XUngrabPointer(WMScreenDisplay(W_VIEW(tPtr)->screen), CurrentTime);
1324         }
1325
1326         move = 0;
1327         break;
1328     }
1329 }
1330
1331
1332 static void
1333 destroyTextField(TextField *tPtr)
1334 {
1335 #if 0
1336     if (tPtr->timerID)
1337         WMDeleteTimerHandler(tPtr->timerID);
1338 #endif
1339
1340     WMReleaseFont(tPtr->font);
1341
1342     if (tPtr->text)
1343         free(tPtr->text);
1344
1345     free(tPtr);
1346 }