WINGs/wtextfield.c

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