WINGs/wtextfield.c

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