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