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