workbench/libs/muimaster/classes/string.c

   1 /*
   2     Copyright © 2003-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /* This is based on muimaster/class/text.c (first string version)
   7  * and on rom/intuition/str*.c
   8  */
   9
  10 #define MUIMASTER_YES_INLINE_STDARG
  11
  12 #include <string.h>
  13 #include <stdlib.h>
  14 #include <stdio.h>
  15 #include <ctype.h>
  16
  17 #include <exec/types.h>
  18 #include <clib/alib_protos.h>
  19
  20 #include <proto/exec.h>
  21 #include <proto/dos.h>
  22 #include <proto/graphics.h>
  23 #include <proto/intuition.h>
  24 #include <proto/utility.h>
  25 #include <proto/muimaster.h>
  26 #include <proto/locale.h>
  27
  28 #ifdef __AROS__
  29 #include <devices/rawkeycodes.h>
  30 #endif
  31
  32 #include "mui.h"
  33 #include "muimaster_intern.h"
  34 #include "support.h"
  35 #include "prefs.h"
  36 #include "penspec.h"
  37 #include "imspec.h"
  38 #include "clipboard.h"
  39 #include "string.h"
  40
  41 //#define MYDEBUG 1
  42 #include "debug.h"
  43
  44 extern struct Library *MUIMasterBase;
  45
  46 struct MUI_StringData
  47 {
  48     ULONG msd_Flags;
  49     CONST_STRPTR msd_Accept;    /* MUIA_String_Accept */
  50     CONST_STRPTR msd_Reject;    /* MUIA_String_Reject */
  51     LONG msd_Align;
  52     struct Hook *msd_EditHook;
  53     Object *msd_AttachedList;
  54     LONG msd_RedrawReason;
  55
  56     ULONG msd_useSecret;
  57     /* Fields mostly ripped from rom/intuition/strgadgets.c */
  58     STRPTR Buffer;              /* char container                   */
  59     STRPTR SecBuffer;           /* Buffer for secret string         */
  60     STRPTR VisualBuffer;        /* Pointer to either Buffer or SecBuffer */
  61     ULONG BufferSize;           /* memory allocated                 */
  62     ULONG NumChars;             /* string length                    */
  63     ULONG BufferPos;            /* cursor (insert/delete) position  */
  64     ULONG MarkPos;              /* cursor text marking start pos    */
  65     LONG DispPos;               /* leftmost visible char            */
  66     ULONG DispCount;            /* number of visible chars          */
  67
  68     ULONG OldClick_Sec;
  69     ULONG OldClick_Micro;
  70     ULONG NewClick_Sec;
  71     ULONG NewClick_Micro;
  72     WORD MultiClick;
  73
  74     WORD Columns;
  75
  76     struct MUI_EventHandlerNode ehn;
  77     struct MUI_PenSpec_intern inactive_text;
  78     struct MUI_PenSpec_intern active_text;
  79     struct MUI_PenSpec_intern marked_text;
  80     struct MUI_PenSpec_intern marked_bg;
  81     struct MUI_PenSpec_intern cursor;
  82
  83     BOOL is_active;
  84 };
  85
  86 #define MSDF_ADVANCEONCR    (1<<0)
  87 #define MSDF_LONELYEDITHOOK (1<<1)
  88 #define MSDF_MARKING            (1<<2)
  89 #define MSDF_KEYMARKING            (1<<3)
  90 #define MSDF_NOINPUT            (1<<4)
  91 #define MSDF_STAYACTIVE     (1<<5)
  92
  93 enum
  94 {
  95     NO_REASON = 0,
  96     WENT_ACTIVE = 1,
  97     WENT_INACTIVE,
  98     DO_CURSOR_LEFT = 3,
  99     DO_CURSOR_RIGHT,
 100     DO_DELETE = 5,
 101     DO_BACKSPACE,
 102     DO_ADDCHAR = 7,
 103     NEW_CONTENTS,
 104     MOVE_CURSOR,
 105     DO_UNKNOWN,
 106 };
 107
 108 #define SECRET_CHAR '*'
 109
 110
 111 /****** String.mui/MUIA_String_Accept ****************************************
 112 *
 113 *   NAME
 114 *       MUIA_String_Accept -- (V4) [ISG], STRPTR
 115 *
 116 *   FUNCTION
 117 *       A string containing the characters to be accepted by the string
 118 *       gadget. If NULL is specified, all characters are accepted. The
 119 *       character list is case sensitive.
 120 *
 121 *   NOTES
 122 *       MUIA_String_Reject takes precedence over MUIA_String_Accept.
 123 *
 124 *       The specified string is not cached within the object.
 125 *
 126 *   SEE ALSO
 127 *       MUIA_String_Reject
 128 *
 129 ******************************************************************************
 130 *
 131 */
 132
 133 /****** String.mui/MUIA_String_Reject ****************************************
 134 *
 135 *   NAME
 136 *       MUIA_String_Reject -- (V4) [ISG], STRPTR
 137 *
 138 *   FUNCTION
 139 *       A string containing the characters to be rejected by the string
 140 *       gadget. If NULL is specified, no characters are rejected. The
 141 *       character list is case sensitive.
 142 *
 143 *   NOTES
 144 *       MUIA_String_Reject takes precedence over MUIA_String_Accept.
 145 *
 146 *       The specified string is not cached within the object.
 147 *
 148 *   SEE ALSO
 149 *       MUIA_String_Accept
 150 *
 151 ******************************************************************************
 152 *
 153 */
 154
 155 /****** String.mui/MUIA_String_BufferPos *************************************
 156 *
 157 *   NAME
 158 *       MUIA_String_BufferPos -- (V4) [ISG], STRPTR
 159 *
 160 *   FUNCTION
 161 *       The cursor's position relative to the start of the string.
 162 *
 163 *   NOTES
 164 *       The MUI AutoDocs claim this attribute is not initialisable.
 165 *
 166 ******************************************************************************
 167 *
 168 */
 169
 170 /**************************************************************************
 171  Buffer_Alloc
 172  Allocate memory for buffer
 173 **************************************************************************/
 174 static BOOL Buffer_Alloc(struct MUI_StringData *data)
 175 {
 176     UWORD i;
 177
 178     data->Buffer =
 179         (STRPTR) AllocVec(data->BufferSize * sizeof(char), MEMF_ANY);
 180     if (NULL == data->Buffer)
 181     {
 182         bug("MUIC_String: Can't allocate %ld bytes for buffer1\n",
 183             data->BufferSize * sizeof(char));
 184         return FALSE;
 185     }
 186     if (data->msd_useSecret)
 187     {
 188         data->SecBuffer =
 189             (STRPTR) AllocVec(data->BufferSize * sizeof(char), MEMF_ANY);
 190         if (NULL == data->SecBuffer)
 191         {
 192             bug("MUIC_String: Can't allocate %ld bytes for buffer2\n",
 193                 data->BufferSize * sizeof(char));
 194             FreeVec(data->Buffer);
 195             data->Buffer = NULL;
 196             return FALSE;
 197         }
 198
 199         /* Initialise maximum number of asterisks we'll need */
 200         for (i = 0; i < data->BufferSize - 1; i++)
 201             data->SecBuffer[i] = SECRET_CHAR;
 202
 203         data->VisualBuffer = data->SecBuffer;
 204     }
 205     else
 206         data->VisualBuffer = data->Buffer;
 207
 208     return TRUE;
 209 }
 210
 211 static inline VOID PrepareVisualBuffer(struct MUI_StringData *data)
 212 {
 213     if (data->msd_useSecret)
 214         data->VisualBuffer[data->NumChars] = '\0';
 215 }
 216
 217 static inline VOID CleanVisualBuffer(struct MUI_StringData *data)
 218 {
 219     if (data->msd_useSecret)
 220         data->VisualBuffer[data->NumChars] = SECRET_CHAR;
 221 }
 222
 223 /**************************************************************************
 224  Buffer_SetNewContents
 225  Initialize buffer with a string, replace former content if any
 226 **************************************************************************/
 227 static BOOL Buffer_SetNewContents(struct MUI_StringData *data,
 228     CONST_STRPTR str)
 229 {
 230     if (NULL == data->Buffer)
 231         return FALSE;
 232
 233     if (NULL == str)
 234     {
 235         data->Buffer[0] = 0;
 236         data->NumChars = 0;
 237     }
 238     else
 239     {
 240         data->NumChars = strlen(str);
 241         if (data->NumChars >= data->BufferSize)
 242             data->NumChars = data->BufferSize - 1;
 243
 244         strncpy(data->Buffer, str, data->BufferSize);
 245         data->Buffer[data->BufferSize - 1] = 0;
 246     }
 247
 248     // avoid to BufferPos jumps to end of string if characters are inserted
 249     // in string
 250     if (data->BufferPos > data->NumChars)
 251         data->BufferPos = data->NumChars;
 252     data->DispPos = 0;
 253     return TRUE;
 254 }
 255
 256 /**************************************************************************
 257  Buffer_AddChar
 258  Add a char on cursor position
 259 **************************************************************************/
 260 static BOOL Buffer_AddChar(struct MUI_StringData *data, unsigned char code)
 261 {
 262     STRPTR dst;
 263
 264     if (data->Buffer == NULL)
 265         return FALSE;
 266
 267     if (data->NumChars + 1 >= data->BufferSize)
 268         return FALSE;
 269
 270     dst = &data->Buffer[data->BufferPos + 1];
 271
 272     memmove(dst, &data->Buffer[data->BufferPos],
 273         data->NumChars - data->BufferPos);
 274
 275     dst[data->NumChars - data->BufferPos] = 0;
 276     dst[-1] = code;
 277
 278     data->BufferPos++;
 279     data->NumChars++;
 280     return TRUE;
 281 }
 282
 283 static WORD Buffer_GetWordStartIndex(struct MUI_StringData *data,
 284     WORD startindex)
 285 {
 286     WORD index = startindex;
 287
 288     while (index > 0)
 289     {
 290         if (data->Buffer[index - 1] == ' ')
 291         {
 292             break;
 293         }
 294         index--;
 295     }
 296
 297     return index;
 298 }
 299
 300 static WORD Buffer_GetWordEndIndex(struct MUI_StringData *data,
 301     WORD startindex)
 302 {
 303     WORD index = startindex;
 304
 305     while (index < data->NumChars)
 306     {
 307         if (data->Buffer[index] == ' ')
 308         {
 309             break;
 310         }
 311         index++;
 312     }
 313
 314     return index;
 315 }
 316
 317 static WORD Buffer_GetPrevWordIndex(struct MUI_StringData *data,
 318     WORD startindex)
 319 {
 320     WORD index = startindex;
 321
 322     while (index > 0)
 323     {
 324         index--;
 325
 326         if ((index == 0) ||
 327             ((data->Buffer[index - 1] == ' ') &&
 328                 (data->Buffer[index] != ' ')))
 329         {
 330             break;
 331         }
 332
 333     }
 334
 335     return index;
 336 }
 337
 338 static WORD Buffer_GetSuccWordIndex(struct MUI_StringData *data,
 339     WORD startindex)
 340 {
 341     WORD index = startindex;
 342
 343     while (index < data->NumChars)
 344     {
 345         index++;
 346
 347         if ((index == data->NumChars) ||
 348             ((data->Buffer[index - 1] == ' ') &&
 349                 (data->Buffer[index] != ' ')))
 350         {
 351             break;
 352         }
 353     }
 354
 355     return index;
 356 }
 357
 358 static BOOL Buffer_GetMarkedRange(struct MUI_StringData *data, WORD *start,
 359     WORD *stop)
 360 {
 361     WORD markstart = data->MarkPos;
 362     WORD markstop = data->BufferPos;
 363
 364     markstart = MIN(markstart, data->NumChars);
 365     markstart = MAX(markstart, 0);
 366
 367     markstop = MIN(markstop, data->NumChars);
 368     markstop = MAX(markstop, 0);
 369
 370     if (markstart > markstop)
 371     {
 372         markstart ^= markstop;
 373         markstop ^= markstart;
 374         markstart ^= markstop;
 375     }
 376
 377     switch (data->MultiClick)
 378     {
 379     case 0:
 380         /* char select */
 381         break;
 382
 383     case 1:
 384         /* word select */
 385         markstart = Buffer_GetWordStartIndex(data, markstart);
 386         markstop = Buffer_GetWordEndIndex(data, markstop);
 387         break;
 388
 389     default:
 390         /* select all */
 391         markstart = 0;
 392         markstop = data->NumChars;
 393         break;
 394
 395     }
 396
 397     if (markstart == markstop)
 398         return FALSE;
 399
 400     if (start)
 401         *start = markstart;
 402     if (stop)
 403         *stop = markstop;
 404
 405     //kprintf("Buffer_GetMarkedRange: returning %d .. %d\n",
 406     //    markstart, markstop);
 407
 408     return TRUE;
 409 }
 410
 411 static BOOL Buffer_AnythingMarked(struct MUI_StringData *data)
 412 {
 413     if (!(data->msd_Flags & MSDF_MARKING))
 414         return FALSE;
 415
 416     return Buffer_GetMarkedRange(data, NULL, NULL);
 417 }
 418
 419 static BOOL Buffer_KillMarked(struct MUI_StringData *data)
 420 {
 421     WORD markstart = data->MarkPos;
 422     WORD markstop = data->BufferPos;
 423     WORD marklen;
 424
 425     //kprintf("\nBuffer_KillMarked 1  markpos %d  bufferpos %d  numchars %d\n",
 426     //    markstart, markstop, data->NumChars);
 427
 428     if (!(data->msd_Flags & MSDF_MARKING))
 429         return FALSE;
 430
 431     data->msd_Flags &= ~MSDF_MARKING;
 432
 433     if (!Buffer_GetMarkedRange(data, &markstart, &markstop))
 434         return FALSE;
 435
 436     //kprintf("Buffer_KillMarked 2  markstart %d  markstop %d\n",
 437     //    markstart, markstop);
 438
 439     if (markstart > markstop)
 440     {
 441         markstart ^= markstop;
 442         markstop ^= markstart;
 443         markstart ^= markstop;
 444     }
 445
 446     marklen = markstop - markstart;
 447
 448     //kprintf("Buffer_KillMarked: markstart %d  markstop %d\n",
 449     //    markstart, markstop);
 450
 451     memmove(&data->Buffer[markstart],
 452         &data->Buffer[markstart + marklen],
 453         data->NumChars - markstart - marklen + 1);
 454
 455     data->NumChars -= marklen;
 456     data->BufferPos = markstart;
 457
 458     return TRUE;
 459 }
 460
 461 /**************************************************************************
 462  OM_NEW
 463 **************************************************************************/
 464 IPTR String__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 465 {
 466     struct MUI_StringData *data;
 467     struct TagItem *tags, *tag;
 468     CONST_STRPTR str = NULL;
 469     char integerbuf[20];
 470
 471     obj = (Object *) DoSuperNewTags(cl, obj, NULL,
 472         /*  MUIA_FillArea, TRUE, */
 473         TAG_MORE, (IPTR) msg->ops_AttrList);
 474     if (!obj)
 475         return FALSE;
 476
 477     data = INST_DATA(cl, obj);
 478     data->msd_useSecret = FALSE;
 479     data->msd_Align = MUIV_String_Format_Left;
 480     data->BufferSize = 80;
 481     data->Columns = -1;
 482
 483     Buffer_SetNewContents(data, "");    /* <-- isn't this pointless? */
 484
 485     /* parse initial taglist */
 486     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 487     {
 488         switch (tag->ti_Tag)
 489         {
 490         case MUIA_String_Accept:
 491             data->msd_Accept = (CONST_STRPTR) tag->ti_Data;
 492             break;
 493
 494         case MUIA_String_Reject:
 495             data->msd_Reject = (CONST_STRPTR) tag->ti_Data;
 496             break;
 497
 498         case MUIA_String_AdvanceOnCR:
 499             _handle_bool_tag(data->msd_Flags, tag->ti_Data,
 500                 MSDF_ADVANCEONCR);
 501             break;
 502
 503         case MUIA_String_BufferPos:
 504             data->BufferPos = (ULONG) tag->ti_Data;
 505             break;
 506
 507         case MUIA_String_AttachedList:
 508             data->msd_AttachedList = (Object *) tag->ti_Data;
 509             break;
 510
 511         case MUIA_String_Secret:
 512             data->msd_useSecret = (BOOL) tag->ti_Data;
 513             break;
 514
 515         case MUIA_String_Contents:
 516             str = (CONST_STRPTR) tag->ti_Data;
 517             break;
 518
 519         case MUIA_String_EditHook:
 520             data->msd_EditHook = (struct Hook *)tag->ti_Data;
 521             break;
 522
 523         case MUIA_String_Format:
 524             data->msd_Align = (LONG) tag->ti_Data;
 525             break;
 526
 527         case MUIA_String_Integer:
 528             snprintf(integerbuf, 19, "%ld", tag->ti_Data);
 529             str = integerbuf;
 530             break;
 531
 532         case MUIA_String_LonelyEditHook:
 533             _handle_bool_tag(data->msd_Flags, tag->ti_Data,
 534                 MSDF_LONELYEDITHOOK);
 535             break;
 536
 537         case MUIA_String_MaxLen:
 538             data->BufferSize = tag->ti_Data;
 539             if (data->BufferSize < 1)
 540                 data->BufferSize = 1;
 541             break;
 542
 543         case MUIA_String_Columns:      /* BetterString */
 544             data->Columns = (WORD) tag->ti_Data;
 545             break;
 546
 547         case MUIA_String_NoInput:      /* BetterString */
 548             _handle_bool_tag(data->msd_Flags, tag->ti_Data, MSDF_NOINPUT);
 549             break;
 550
 551         case MUIA_String_StayActive:   /* BetterString */
 552             _handle_bool_tag(data->msd_Flags, tag->ti_Data,
 553                 MSDF_STAYACTIVE);
 554             break;
 555
 556         }
 557     }
 558
 559     if (Buffer_Alloc(data))
 560     {
 561         Buffer_SetNewContents(data, str);
 562     }
 563
 564     if (NULL == data->Buffer)
 565     {
 566         CoerceMethod(cl, obj, OM_DISPOSE);
 567         return 0;
 568     }
 569
 570     D(bug("String_New(%p)\n", obj));
 571
 572     data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS;
 573     data->ehn.ehn_Priority = 0;
 574     data->ehn.ehn_Flags = 0;
 575     data->ehn.ehn_Object = obj;
 576     data->ehn.ehn_Class = cl;
 577
 578     CurrentTime(&data->OldClick_Sec, &data->OldClick_Micro);
 579
 580     return (IPTR) obj;
 581 }
 582
 583 /**************************************************************************
 584  OM_DISPOSE
 585 **************************************************************************/
 586 IPTR String__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 587 {
 588     struct MUI_StringData *data = INST_DATA(cl, obj);
 589
 590     FreeVec(data->Buffer);
 591     FreeVec(data->SecBuffer);
 592
 593     D(bug("String_Dispose %p\n", obj));
 594
 595     return DoSuperMethodA(cl, obj, msg);
 596 }
 597
 598 /**************************************************************************
 599  OM_SET
 600 **************************************************************************/
 601 IPTR String__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 602 {
 603     struct MUI_StringData *data = INST_DATA(cl, obj);
 604     struct TagItem *tags = msg->ops_AttrList;
 605     struct TagItem *tag;
 606
 607     while ((tag = NextTagItem(&tags)) != NULL)
 608     {
 609         switch (tag->ti_Tag)
 610         {
 611         case MUIA_String_Contents:
 612             Buffer_SetNewContents(data, (STRPTR) tag->ti_Data);
 613             data->msd_RedrawReason = NEW_CONTENTS;
 614             data->msd_Flags &= ~(MSDF_MARKING | MSDF_KEYMARKING);
 615             MUI_Redraw(obj, MADF_DRAWOBJECT);
 616             break;
 617
 618         case MUIA_String_Accept:
 619             data->msd_Accept = (CONST_STRPTR) tag->ti_Data;
 620             break;
 621
 622         case MUIA_String_Reject:
 623             data->msd_Reject = (CONST_STRPTR) tag->ti_Data;
 624             break;
 625
 626         case MUIA_String_AttachedList:
 627             data->msd_AttachedList = (Object *) tag->ti_Data;
 628             break;
 629
 630         case MUIA_String_Integer:
 631             {
 632                 char buf[20];
 633
 634                 snprintf(buf, 19, "%ld", tag->ti_Data);
 635                 set(obj, MUIA_String_Contents, buf);
 636             }
 637             break;
 638
 639         case MUIA_String_AdvanceOnCR:
 640             _handle_bool_tag(data->msd_Flags, tag->ti_Data,
 641                 MSDF_ADVANCEONCR);
 642             break;
 643
 644         case MUIA_String_BufferPos:
 645             data->BufferPos = (ULONG) tag->ti_Data;
 646             data->msd_Flags &= ~MSDF_MARKING;
 647             data->msd_RedrawReason = MOVE_CURSOR;
 648             MUI_Redraw(obj, MADF_DRAWUPDATE);
 649             break;
 650
 651         case MUIA_String_DisplayPos:
 652             data->BufferPos = (ULONG) tag->ti_Data;
 653             data->DispPos = data->BufferPos;    // move both pos
 654             data->msd_Flags &= ~MSDF_MARKING;
 655             data->msd_RedrawReason = MOVE_CURSOR;
 656             MUI_Redraw(obj, MADF_DRAWUPDATE);
 657             break;
 658
 659         case MUIA_String_NoInput:      /* BetterString */
 660             _handle_bool_tag(data->msd_Flags, tag->ti_Data, MSDF_NOINPUT);
 661             break;
 662
 663         case MUIA_String_StayActive:   /* BetterString */
 664             _handle_bool_tag(data->msd_Flags, tag->ti_Data,
 665                 MSDF_STAYACTIVE);
 666             break;
 667
 668         case MUIA_String_SelectSize:   /* BetterString */
 669             // TODO: Implement OM_SET(MUIA_String_SelectSize)!
 670             break;
 671
 672         }
 673     }
 674
 675     return DoSuperMethodA(cl, obj, (Msg) msg);
 676 }
 677
 678
 679 /**************************************************************************
 680  OM_GET
 681 **************************************************************************/
 682 IPTR String__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 683 {
 684     struct MUI_StringData *data = INST_DATA(cl, obj);
 685
 686 #define STORE *(msg->opg_Storage)
 687     switch (msg->opg_AttrID)
 688     {
 689     case MUIA_String_Contents:
 690         STORE = (IPTR) data->Buffer;
 691         return TRUE;
 692
 693     case MUIA_String_Secret:
 694         STORE = (IPTR) data->msd_useSecret;
 695         return TRUE;
 696
 697     case MUIA_String_Accept:
 698         STORE = (IPTR) data->msd_Accept;
 699         return TRUE;
 700
 701     case MUIA_String_Reject:
 702         STORE = (IPTR) data->msd_Reject;
 703         return TRUE;
 704
 705     case MUIA_String_AttachedList:
 706         STORE = (IPTR) data->msd_AttachedList;
 707         return TRUE;
 708
 709     case MUIA_String_Format:
 710         STORE = (IPTR) data->msd_Align;
 711         return TRUE;
 712
 713     case MUIA_String_Integer:
 714         {
 715             STRPTR buf = NULL;
 716             STORE = 0;
 717             get(obj, MUIA_String_Contents, &buf);
 718             if (NULL != buf)
 719             {
 720                 LONG val = 0;
 721                 StrToLong(buf, &val);
 722                 STORE = val;
 723             }
 724             return TRUE;
 725         }
 726
 727     case MUIA_String_MaxLen:
 728         STORE = (IPTR) data->BufferSize;
 729         return TRUE;
 730
 731     case MUIA_String_AdvanceOnCR:
 732         STORE = (data->msd_Flags & MSDF_ADVANCEONCR) ? TRUE : FALSE;
 733         return TRUE;
 734
 735     case MUIA_String_BufferPos:
 736         STORE = data->BufferPos;
 737         return TRUE;
 738
 739     case MUIA_String_DisplayPos:
 740         STORE = data->DispPos;
 741         return TRUE;
 742
 743     case MUIA_String_NoInput:  /* BetterString */
 744         STORE = (data->msd_Flags & MSDF_NOINPUT) ? TRUE : FALSE;
 745         return TRUE;
 746
 747     case MUIA_String_StayActive:       /* BetterString */
 748         STORE = (data->msd_Flags & MSDF_STAYACTIVE) ? TRUE : FALSE;
 749         return TRUE;
 750
 751     case MUIA_String_SelectSize:       /* BetterString */
 752         if (data->msd_Flags & MSDF_MARKING)
 753         {
 754             WORD markstart, markstop;
 755
 756             if (Buffer_GetMarkedRange(data, &markstart, &markstop))
 757             {
 758                 LONG size = markstop - markstart;
 759
 760                 if (data->MarkPos < data->BufferPos)
 761                     size = -size;
 762
 763                 STORE = (IPTR) size;
 764
 765                 return 1;
 766             }
 767
 768         }
 769
 770         STORE = 0;
 771         return TRUE;
 772
 773     }
 774
 775     return DoSuperMethodA(cl, obj, (Msg) msg);
 776 #undef STORE
 777 }
 778
 779 /**************************************************************************
 780  MUIM_Setup
 781 **************************************************************************/
 782 IPTR String__MUIM_Setup(struct IClass *cl, Object *obj,
 783     struct MUIP_Setup *msg)
 784 {
 785     struct MUI_StringData *data = INST_DATA(cl, obj);
 786
 787     if (0 == DoSuperMethodA(cl, obj, (Msg) msg))
 788         return FALSE;
 789
 790     data->is_active = FALSE;
 791     set(obj, MUIA_Background,
 792         (IPTR) muiGlobalInfo(obj)->mgi_Prefs->string_bg_inactive);
 793
 794     zune_pen_spec_to_intern(
 795         (const struct MUI_PenSpec *)muiGlobalInfo(obj)->mgi_Prefs->
 796         string_text_inactive, &data->inactive_text);
 797     zune_penspec_setup(&data->inactive_text, muiRenderInfo(obj));
 798
 799     zune_pen_spec_to_intern(
 800         (const struct MUI_PenSpec *)muiGlobalInfo(obj)->mgi_Prefs->
 801         string_text_active, &data->active_text);
 802     zune_penspec_setup(&data->active_text, muiRenderInfo(obj));
 803
 804     zune_pen_spec_to_intern(
 805         (const struct MUI_PenSpec *)muiGlobalInfo(obj)->mgi_Prefs->
 806         string_text_marked, &data->marked_text);
 807     zune_penspec_setup(&data->marked_text, muiRenderInfo(obj));
 808
 809     zune_pen_spec_to_intern(
 810         (const struct MUI_PenSpec *)muiGlobalInfo(obj)->mgi_Prefs->
 811         string_bg_marked, &data->marked_bg);
 812     zune_penspec_setup(&data->marked_bg, muiRenderInfo(obj));
 813
 814     zune_pen_spec_to_intern(
 815         (const struct MUI_PenSpec *)muiGlobalInfo(obj)->mgi_Prefs->
 816         string_cursor, &data->cursor);
 817     zune_penspec_setup(&data->cursor, muiRenderInfo(obj));
 818
 819     DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR) & data->ehn);
 820     return TRUE;
 821 }
 822
 823 /**************************************************************************
 824  MUIM_Cleanup
 825 **************************************************************************/
 826 IPTR String__MUIM_Cleanup(struct IClass *cl, Object *obj,
 827     struct MUIP_Cleanup *msg)
 828 {
 829     struct MUI_StringData *data = INST_DATA(cl, obj);
 830
 831     D(bug("String_Cleanup %p\n", obj));
 832     DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR) & data->ehn);
 833
 834     zune_penspec_cleanup(&data->inactive_text);
 835     zune_penspec_cleanup(&data->active_text);
 836     zune_penspec_cleanup(&data->marked_text);
 837     zune_penspec_cleanup(&data->marked_bg);
 838     zune_penspec_cleanup(&data->cursor);
 839
 840     return (DoSuperMethodA(cl, obj, (Msg) msg));
 841 }
 842
 843 /**************************************************************************
 844  MUIM_AskMinMax
 845 **************************************************************************/
 846 IPTR String__MUIM_AskMinMax(struct IClass *cl, Object *obj,
 847     struct MUIP_AskMinMax *msg)
 848 {
 849     struct MUI_StringData *data = INST_DATA(cl, obj);
 850
 851     DoSuperMethodA(cl, obj, (Msg) msg);
 852
 853     if (data->Columns >= 0)
 854     {
 855         msg->MinMaxInfo->MinWidth += _font(obj)->tf_XSize * data->Columns;
 856         msg->MinMaxInfo->DefWidth += _font(obj)->tf_XSize * data->Columns;
 857         msg->MinMaxInfo->MaxWidth += _font(obj)->tf_XSize * data->Columns;
 858     }
 859     else
 860     {
 861         msg->MinMaxInfo->MinWidth += _font(obj)->tf_XSize * 4;
 862         msg->MinMaxInfo->DefWidth += _font(obj)->tf_XSize * 12;
 863         msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
 864     }
 865
 866     msg->MinMaxInfo->MinHeight += _font(obj)->tf_YSize;
 867     msg->MinMaxInfo->DefHeight += _font(obj)->tf_YSize;
 868     msg->MinMaxInfo->MaxHeight += _font(obj)->tf_YSize;
 869
 870 /*    D(bug("String_AskMinMax(%p): Min=%ldx%ld Max=%ldx%ld Def=%ldx%ld\n", */
 871 /*            obj, msg->MinMaxInfo->MinWidth, msg->MinMaxInfo->MinHeight, */
 872 /*            msg->MinMaxInfo->MaxWidth, msg->MinMaxInfo->MaxHeight, */
 873 /*            msg->MinMaxInfo->DefWidth, msg->MinMaxInfo->DefHeight)); */
 874
 875     return TRUE;
 876 }
 877
 878
 879 static WORD MaxDispPos(struct IClass *cl, Object *obj)
 880 {
 881     struct MUI_StringData *data = INST_DATA(cl, obj);
 882     WORD numfit, max_disppos, numchars;
 883     struct TextExtent te;
 884     BOOL cursor_at_end;
 885
 886     cursor_at_end = (data->BufferPos == data->NumChars);
 887
 888 /*      D(bug("MaxDispPos(current length: %d, bufferpos=%d)\n", */
 889 /*            data->NumChars, data->BufferPos)); */
 890
 891 /*      D(bug("cursor_at_end: %d\n", cursor_at_end)); */
 892
 893     if (cursor_at_end)          /* Cursor at end of string ? */
 894     {
 895 /*              D(bug("Making cursor last char\n")); */
 896         numchars = data->NumChars + 1;  /* Take cursor into account */
 897
 898 /*            This has already been done by UpdateDisp() which called us
 899         strinfo->Buffer[strinfo->NumChars] = 0x20;
 900
 901 */
 902     }
 903     else
 904     {
 905         numchars = data->NumChars;
 906     }
 907
 908     /* Find the amount of characters that fit into the bbox, counting
 909      ** from the last character in the buffer and forward,
 910      */
 911     numfit = TextFit(_rp(obj),
 912         &(data->Buffer[numchars - 1]),
 913         numchars, &te, NULL, -1, _mwidth(obj), _mheight(obj));
 914
 915     max_disppos = numchars - numfit;
 916
 917 /*    if ((max_disppos > 0) && (!cursor_at_end))
 918             max_disppos --;
 919   */
 920
 921 /*      D(bug("Numchars w/cursor: %d, Numfit: %d, maxdisppos=%d  " */
 922 /*            "bbox->Width = %d  te->te_Width = %d\n", */
 923 /*            numchars, numfit, max_disppos, _mwidth(obj), te.te_Width)); */
 924
 925     return max_disppos;
 926 }
 927
 928
 929 static void UpdateDisp(struct IClass *cl, Object *obj)
 930 {
 931     struct MUI_StringData *data = INST_DATA(cl, obj);
 932     struct TextExtent te;
 933     STRPTR dispstr;
 934
 935     /* If the cursor is at the trailing \0, insert a SPACE instead */
 936     if (data->BufferPos == data->NumChars)
 937         data->VisualBuffer[data->NumChars] = ' ';
 938
 939     /* In this function we check if the cursor has gone outside
 940      ** of the visible area (because of application setting
 941      ** strinfo->BufferPos or strinfo->DispPos to a different value, or
 942      ** because of user input).
 943      ** This is made a bit difficult by the rule (R), that there
 944      ** should NOT be available space on the right, and characters
 945      ** scrolled out at the left, at the same time.
 946      ** We have 3 possible scenarios:
 947      ** 1) Cursor to the left of DispPos:
 948      **    Set DispPos to the lowest of BufferPos and the
 949      **          maximum allowed disppos (according to (R) ).
 950      ** 2) Cursor to the right of visible area:
 951      **    Set dispose sou that the cursor is the last visible character.
 952      **    This afheres to (R).
 953      ** 3) Cursor inside visible area. Do a check on rule (R),
 954      **    and if DispPos > max allowed, then adjust it down,
 955      **    so that the last character in the buffer becomes last character
 956      **          displayed. (The cursor will still be visible after adjustion)
 957      */
 958
 959     /* 1) Cursor to the left of visible area */
 960     if (data->BufferPos < data->DispPos)
 961     {
 962         WORD max_disppos;
 963
 964         max_disppos = MaxDispPos(cl, obj);
 965         data->DispPos = MIN(data->BufferPos, max_disppos);
 966     }
 967     else        /* Cursor equal to the right of disppos [ 2) or 3) ] */
 968     {
 969         UWORD strsize;
 970
 971         /* How many pixels are there from current 1st displayed to cursor? */
 972         strsize = TextLength(_rp(obj),
 973             data->VisualBuffer + data->DispPos,
 974             data->BufferPos - data->DispPos + 1);
 975
 976         /* 2) More than fits into the gadget ? */
 977         if (strsize > _mwidth(obj))
 978         {
 979             /* Compute new DispPos such that the cursor is at the right */
 980             data->DispPos = data->BufferPos
 981                 - TextFit(_rp(obj),
 982                 &(data->VisualBuffer[data->BufferPos]),
 983                 data->NumChars, &te, NULL, -1,
 984                 _mwidth(obj), _mheight(obj)) + 1;
 985
 986 /*              D(bug("cursor right of visible area, new disppos: %d\n", */
 987 /*                  data->DispPos)); */
 988         }
 989         else                    /* 3). Cursor inside gadget */
 990         {
 991             WORD max_disppos;
 992
 993             max_disppos = MaxDispPos(cl, obj);
 994             if (data->DispPos > max_disppos)
 995                 data->DispPos = max_disppos;
 996
 997         }        /* if (cursor inside or to the right of visible area ) */
 998
 999     }
1000
1001     /* Update the DispCount */
1002     /* It might be necessary with special handling for centre aligned gads */
1003     dispstr = &(data->VisualBuffer[data->DispPos]);
1004 /*      D(bug("DispCount before = %d\n", data->DispCount)); */
1005     data->DispCount = TextFit(_rp(obj), dispstr,
1006         data->NumChars - data->DispPos,
1007         &te, NULL, 1, _mwidth(obj), _mheight(obj));
1008 /*      D(bug("DispCount after = %d\n", data->DispCount)); */
1009
1010     /* 0-terminate string (in case we put a SPACE at the end) */
1011     data->VisualBuffer[data->NumChars] = '\0';
1012 }
1013
1014
1015 /* Gets left position of text in the string gadget */
1016 static UWORD GetTextLeft(struct IClass *cl, Object *obj)
1017 {
1018     struct MUI_StringData *data = INST_DATA(cl, obj);
1019     UWORD text_left = 0;
1020     STRPTR dispstr = &(data->VisualBuffer[data->DispPos]);
1021     UWORD dispstrlen;
1022     BOOL cursor_at_end;
1023
1024     cursor_at_end = (data->BufferPos == data->NumChars);
1025     dispstrlen = MIN(data->DispCount, data->NumChars - data->DispPos);
1026
1027     switch (data->msd_Align)
1028     {
1029     case MUIV_String_Format_Left:
1030         text_left = _mleft(obj);
1031         break;
1032
1033     case MUIV_String_Format_Center:
1034         {
1035             WORD textwidth = TextLength(_rp(obj), dispstr, dispstrlen);
1036             if (cursor_at_end)
1037                 textwidth += TextLength(_rp(obj), " ", 1);
1038             text_left = _mleft(obj) + ((_mwidth(obj) - textwidth) / 2);
1039 /*              D(bug("GetTextLeft: dispstr=%s, dispstrlen=%d, textw=%d, " */
1040 /*                  "textl=%d\n", */
1041 /*                  dispstr, dispstrlen, textwidth, text_left)); */
1042         }
1043         break;
1044
1045     case MUIV_String_Format_Right:
1046         {
1047             WORD textwidth = TextLength(_rp(obj), dispstr, dispstrlen);
1048
1049             if (cursor_at_end)
1050                 textwidth += TextLength(_rp(obj), " ", 1);
1051             text_left = _mleft(obj) + (_mwidth(obj) - 1 - textwidth);
1052         }
1053         break;
1054     }
1055     return (text_left);
1056 }
1057
1058 /* Gets right offset of text in the string gadget */
1059 static UWORD GetTextRight(struct IClass *cl, Object *obj)
1060 {
1061     struct MUI_StringData *data = INST_DATA(cl, obj);
1062     UWORD text_right = 0;
1063     STRPTR dispstr = &(data->VisualBuffer[data->DispPos]);
1064     UWORD dispstrlen;
1065     BOOL cursor_at_end;
1066
1067     cursor_at_end = (data->BufferPos == data->NumChars);
1068     dispstrlen = MIN(data->DispCount, data->NumChars - data->DispPos);
1069
1070     switch (data->msd_Align)
1071     {
1072     case MUIV_String_Format_Left:
1073         text_right =
1074             _mleft(obj) + TextLength(_rp(obj), dispstr, dispstrlen);
1075         break;
1076
1077     case MUIV_String_Format_Center:
1078         {
1079             WORD textwidth = TextLength(_rp(obj), dispstr, dispstrlen);
1080
1081             if (cursor_at_end)
1082                 textwidth += TextLength(_rp(obj), " ", 1);
1083             text_right = _mright(obj) - ((_mwidth(obj) - textwidth) / 2);
1084         }
1085         break;
1086
1087     case MUIV_String_Format_Right:
1088         text_right = _mright(obj);
1089         break;
1090     }
1091     return (text_right);
1092 }
1093
1094
1095 /* Updates the stringdata in case user has set some fields */
1096 static VOID UpdateStringData(struct IClass *cl, Object *obj)
1097 {
1098     struct MUI_StringData *data = INST_DATA(cl, obj);
1099
1100     data->NumChars = strlen(data->Buffer);
1101
1102     if (data->BufferPos > data->NumChars)
1103     {
1104         data->BufferPos = data->NumChars;
1105     }
1106 }
1107
1108 static VOID TextM(Object *obj, struct MUI_StringData *data,
1109     STRPTR text, WORD textlen, WORD markstart, WORD markend)
1110 {
1111     struct RastPort *rp = _rp(obj);
1112     ULONG textpen;
1113     WORD len;
1114
1115     if (data->is_active)
1116         textpen = data->active_text.p_pen;
1117     else
1118         textpen = data->inactive_text.p_pen;
1119
1120     //kprintf("TextM: textlen %d  markstart %d  markend %d ... \n",
1121     //    textlen, markstart, markend);
1122
1123     /* <unmarked><marked><unmarked> */
1124
1125     /* <unmarked> */
1126
1127     len = MIN(markstart, textlen);
1128     len = MAX(len, 0);
1129
1130     if (len)
1131     {
1132         //kprintf("A: %d   ", len);
1133
1134         SetABPenDrMd(rp, textpen, _pens(obj)[MPEN_BACKGROUND], JAM1);
1135         Text(rp, text, len);
1136
1137         text += len;
1138         textlen -= len;
1139
1140     }
1141
1142     len = MIN(markend - len, textlen);
1143     len = MAX(len, 0);
1144
1145     if (len)
1146     {
1147         //kprintf("B: %d   ", len);
1148         SetABPenDrMd(_rp(obj), data->marked_text.p_pen,
1149             data->marked_bg.p_pen, JAM2);
1150         Text(rp, text, len);
1151
1152         text += len;
1153         textlen -= len;
1154     }
1155
1156     if (textlen)
1157     {
1158         //kprintf("C: %d   ", textlen);
1159
1160         SetABPenDrMd(rp, textpen, _pens(obj)[MPEN_BACKGROUND], JAM1);
1161         Text(rp, text, textlen);
1162     }
1163     //kprintf("\n");
1164 }
1165
1166 /**************************************************************************
1167  MUIM_Draw
1168 **************************************************************************/
1169 IPTR String__MUIM_Draw(struct IClass *cl, Object *obj,
1170     struct MUIP_Draw *msg)
1171 {
1172     struct MUI_StringData *data = INST_DATA(cl, obj);
1173     UWORD text_left;
1174     UWORD text_top;
1175     STRPTR dispstr;
1176     UWORD dispstrlen;
1177     ULONG textpen;
1178     UWORD textleft_save;
1179     WORD markstart = 0, markstop = 0;
1180
1181     /*  D(bug("\nString_Draw(%p) %ldx%ldx%ldx%ld reason=%ld msgflgs=%ld " */
1182 /*          "curs=%d " */
1183 /*          "displ=%ld len=%ld buf='%s'\n",obj,_mleft(obj),_mtop(obj), */
1184 /*          _mwidth(obj),_mheight(obj), data->msd_RedrawReason, msg->flags, */
1185 /*          data->BufferPos, data->DispPos, data->NumChars, data->Buffer)); */
1186
1187     DoSuperMethodA(cl, obj, (Msg) msg);
1188
1189     if (!(msg->flags & MADF_DRAWUPDATE) && !(msg->flags & MADF_DRAWOBJECT))
1190         return 0;
1191
1192     PrepareVisualBuffer(data);
1193     SetFont(_rp(obj), _font(obj));
1194     if (data->is_active)
1195         textpen = data->active_text.p_pen;
1196     else
1197         textpen = data->inactive_text.p_pen;
1198
1199     /* Update the stringdata in case of user change */
1200     UpdateStringData(cl, obj);
1201
1202     /* Update the DispPos and DispCount fields so that the gadget renders
1203      * properly */
1204     UpdateDisp(cl, obj);
1205
1206     text_top = _mtop(obj)
1207         + ((_mheight(obj) - _rp(obj)->Font->tf_YSize) >> 1)
1208         + _rp(obj)->Font->tf_Baseline;
1209
1210     dispstr = data->VisualBuffer + data->DispPos;
1211     dispstrlen = MIN(data->DispCount, data->NumChars - data->DispPos);
1212     textleft_save = text_left = GetTextLeft(cl, obj);
1213
1214     // little flicker improvement, don't redraw first part of string
1215     // when adding a char
1216     if (msg->flags & MADF_DRAWUPDATE &&
1217         data->msd_RedrawReason == DO_ADDCHAR &&
1218         data->msd_Align == MUIV_String_Format_Left && data->DispPos == 0)
1219     {
1220         text_left += TextLength(_rp(obj), dispstr, data->BufferPos - 1);
1221         dispstr += data->BufferPos - 1;
1222         dispstrlen -= data->BufferPos - 1;
1223         DoMethod(obj, MUIM_DrawBackground, text_left, _mtop(obj),
1224             _mwidth(obj) - text_left + _mleft(obj), _mheight(obj),
1225             text_left, _mtop(obj), 0);
1226     }
1227     else if (msg->flags & MADF_DRAWUPDATE)
1228     {
1229         DoMethod(obj, MUIM_DrawBackground, _mleft(obj), _mtop(obj),
1230             _mwidth(obj), _mheight(obj), _mleft(obj), _mtop(obj), 0);
1231     }
1232
1233     SetABPenDrMd(_rp(obj), textpen, _pens(obj)[MPEN_BACKGROUND], JAM1);
1234     Move(_rp(obj), text_left, text_top);
1235
1236     if ((data->msd_Flags & MSDF_MARKING)
1237         && Buffer_GetMarkedRange(data, &markstart, &markstop))
1238     {
1239         TextM(obj, data, dispstr, dispstrlen, markstart - data->DispPos,
1240             markstop - data->DispPos);
1241
1242     }
1243     else
1244     {
1245         Text(_rp(obj), dispstr, dispstrlen);
1246
1247         if (data->is_active)    // active, draw cursor
1248         {
1249             UWORD cursoroffset = data->BufferPos - data->DispPos;
1250
1251             dispstr = data->VisualBuffer + data->DispPos;
1252             text_left = textleft_save;
1253
1254             SetABPenDrMd(_rp(obj), data->active_text.p_pen,
1255                 data->cursor.p_pen, JAM2);
1256             text_left += TextLength(_rp(obj), dispstr, cursoroffset);
1257
1258
1259             Move(_rp(obj), text_left, text_top);
1260             Text(_rp(obj),
1261                 ((data->BufferPos < data->NumChars)
1262                     ? dispstr + cursoroffset : (STRPTR) " "), 1);
1263         }
1264     }
1265
1266     data->msd_RedrawReason = NO_REASON;
1267     CleanVisualBuffer(data);
1268
1269     return TRUE;
1270 }
1271
1272 /**************************************************************************
1273  Returns whether object needs redrawing
1274 **************************************************************************/
1275 static int String_HandleVanillakey(struct IClass *cl, Object *obj,
1276     unsigned char code, UWORD qual, IPTR *retval)
1277 {
1278     struct MUI_StringData *data =
1279         (struct MUI_StringData *)INST_DATA(cl, obj);
1280     BOOL doinput;
1281
1282     D(bug("String_HandleVanillakey: code=%d qual=%d\n", code, qual));
1283
1284     if (0 == code)
1285         return 0;
1286
1287     doinput = (data->msd_Flags & MSDF_NOINPUT) ? FALSE : TRUE;
1288
1289     if (doinput && (code == '\b'))      /* backspace */
1290     {
1291         if (Buffer_KillMarked(data))
1292         {
1293             return 1;
1294         }
1295
1296         if (data->BufferPos > 0)
1297         {
1298             LONG shift;
1299
1300             if ((qual & IEQUALIFIER_LSHIFT) || (qual & IEQUALIFIER_RSHIFT))
1301             {
1302                 shift = data->BufferPos;
1303                 data->msd_RedrawReason = NEW_CONTENTS;
1304             }
1305             else
1306             {
1307                 shift = 1;
1308                 data->msd_RedrawReason = DO_BACKSPACE;
1309             }
1310
1311             strcpy(&data->Buffer[data->BufferPos - shift],
1312                 &data->Buffer[data->BufferPos]);
1313             data->BufferPos -= shift;
1314             data->NumChars -= shift;
1315             return 1;
1316         }
1317         return 0;
1318     }
1319
1320     if (doinput && (code == 21))        // ctrl-u == NAK (like shift-bs)
1321     {
1322         if (Buffer_KillMarked(data))
1323         {
1324             return 1;
1325         }
1326
1327         if (data->BufferPos > 0)
1328         {
1329             strcpy(&data->Buffer[0], &data->Buffer[data->BufferPos]);
1330             data->NumChars -= data->BufferPos;
1331             data->BufferPos = 0;
1332             data->msd_RedrawReason = NEW_CONTENTS;
1333             return 1;
1334         }
1335         return 0;
1336     }
1337
1338     if (doinput && (code == 127))       /* del */
1339     {
1340         if (!Buffer_KillMarked(data))
1341         {
1342             if ((qual & IEQUALIFIER_LSHIFT) || (qual & IEQUALIFIER_RSHIFT))
1343             {
1344                 data->Buffer[data->BufferPos] = 0;
1345                 data->NumChars = data->BufferPos;
1346                 data->msd_RedrawReason = NEW_CONTENTS;
1347             }
1348             else
1349             {
1350                 if (data->BufferPos < data->NumChars)
1351                 {
1352                     strcpy(&data->Buffer[data->BufferPos],
1353                         &data->Buffer[data->BufferPos + 1]);
1354                     data->NumChars--;
1355                 }
1356
1357                 data->msd_RedrawReason = DO_DELETE;
1358             }
1359         }
1360         return 1;
1361     }
1362
1363     if (doinput && (code == 11))        // ctrl-k == VT == \v (like shift-del)
1364     {
1365         if (!Buffer_KillMarked(data))
1366         {
1367             data->Buffer[data->BufferPos] = 0;
1368             data->NumChars = data->BufferPos;
1369             data->msd_RedrawReason = NEW_CONTENTS;
1370         }
1371         return 1;
1372     }
1373
1374     if (doinput && (code == 24))        /* ctrl x == ascii cancel */
1375     {
1376         if (!Buffer_KillMarked(data))
1377         {
1378             data->Buffer[0] = 0;
1379             data->BufferPos = 0;
1380             data->NumChars = 0;
1381             data->msd_RedrawReason = NEW_CONTENTS;
1382         }
1383         return 1;
1384     }
1385
1386     if (code == 1)              // ctrl-a, linestart
1387     {
1388         data->BufferPos = 0;
1389         data->msd_Flags &= ~(MSDF_MARKING | MSDF_KEYMARKING);
1390         return 1;
1391     }
1392
1393     if (code == 26)             // ctrl-z, lineend
1394     {
1395         data->BufferPos = data->NumChars;
1396         data->msd_Flags &= ~(MSDF_MARKING | MSDF_KEYMARKING);
1397         return 1;
1398     }
1399
1400     if (code == '\t')             // tab
1401     {
1402         return 0;
1403     }
1404
1405     if (((ToLower(code) == 'c') || (ToLower(code) == 'x')) &&
1406         (qual & IEQUALIFIER_RCOMMAND))
1407     {
1408         WORD markstart, markstop;
1409
1410         if ((data->msd_Flags & MSDF_MARKING)
1411             && Buffer_GetMarkedRange(data, &markstart, &markstop))
1412         {
1413             clipboard_write_text(&data->Buffer[markstart],
1414                 markstop - markstart);
1415
1416             if (doinput && (ToLower(code) == 'x'))
1417             {
1418                 Buffer_KillMarked(data);
1419             }
1420             else
1421             {
1422                 data->BufferPos = markstop;
1423                 data->msd_Flags &= ~MSDF_MARKING;
1424             }
1425             return 1;
1426         }
1427         return 0;
1428     }
1429
1430     if (doinput && (ToLower(code) == 'v') && (qual & IEQUALIFIER_RCOMMAND))
1431     {
1432         STRPTR text;
1433         int retval;
1434         struct Locale *locale = OpenLocale(NULL);
1435
1436         retval = Buffer_KillMarked(data);
1437         if ((text = clipboard_read_text()))
1438         {
1439             STRPTR text2 = text;
1440             UBYTE c;
1441
1442             while ((c = *text2++))
1443             {
1444                 if (!IsPrint(locale, c))
1445                     break;
1446                 if (!(Buffer_AddChar(data, c)))
1447                     break;
1448                 if (!retval)
1449                     retval = 1;
1450             }
1451
1452             clipboard_free_text(text);
1453         }
1454
1455         CloseLocale(locale);
1456
1457         return retval;
1458     }
1459
1460     if (data->msd_Accept != NULL)
1461     {
1462         /* Check if character is accepted */
1463         if (NULL == strchr(data->msd_Accept, code))
1464         {
1465             DisplayBeep(NULL);
1466             *retval = MUI_EventHandlerRC_Eat;
1467             return 0;
1468         }
1469     }
1470
1471     if (data->msd_Reject != NULL)
1472     {
1473         /* Check if character is rejected */
1474         if (NULL != strchr(data->msd_Reject, code))
1475         {
1476             DisplayBeep(NULL);
1477             *retval = MUI_EventHandlerRC_Eat;
1478             return 0;
1479         }
1480     }
1481
1482     if (doinput)
1483     {
1484         struct Locale *locale = OpenLocale(NULL);
1485
1486         if (!(code >= 0x09 && code <= 0x0D) && IsPrint(locale, code))
1487         {
1488             Buffer_KillMarked(data);
1489             if (Buffer_AddChar(data, code))
1490             {
1491                 data->msd_RedrawReason = DO_ADDCHAR;
1492                 return 2;
1493             }
1494         }
1495
1496         CloseLocale(locale);
1497     }
1498
1499     data->msd_RedrawReason = DO_UNKNOWN;
1500     return 0;
1501 }
1502
1503
1504 /**************************************************************************
1505  MUIM_HandleEvent
1506 **************************************************************************/
1507 IPTR String__MUIM_HandleEvent(struct IClass *cl, Object *obj,
1508     struct MUIP_HandleEvent *msg)
1509 {
1510     struct MUI_StringData *data =
1511         (struct MUI_StringData *)INST_DATA(cl, obj);
1512     IPTR retval = 0;
1513     int update = 0;
1514     BOOL edited = FALSE;
1515     LONG muikey = msg->muikey;
1516     BOOL cursor_kills_marking = FALSE;
1517
1518     if ((data->msd_Flags & MSDF_MARKING)
1519         && !(data->msd_Flags & MSDF_KEYMARKING))
1520     {
1521         cursor_kills_marking = TRUE;
1522     }
1523
1524     /* Convert raw keys to MUI keys for marking */
1525     if (muikey == MUIKEY_NONE && msg->imsg != NULL)
1526     {
1527         if (msg->imsg->Class == IDCMP_RAWKEY)
1528         {
1529             static LONG muikeytable[3][2] = {
1530                 {MUIKEY_LEFT, MUIKEY_RIGHT},
1531                 {MUIKEY_WORDLEFT, MUIKEY_WORDRIGHT},
1532                 {MUIKEY_LINESTART, MUIKEY_LINEEND}
1533             };
1534             WORD dirindex = -1, amountindex = 0;
1535
1536             switch (msg->imsg->Code)
1537             {
1538             case 0x4F:
1539                 dirindex = 0;
1540                 break;
1541
1542             case 0x4E:
1543                 dirindex = 1;
1544                 break;
1545
1546 #ifdef __AROS__
1547             case RAWKEY_HOME:
1548                 muikey = MUIKEY_LINESTART;
1549                 break;
1550
1551             case RAWKEY_END:
1552                 muikey = MUIKEY_LINEEND;
1553                 break;
1554 #endif
1555
1556             }
1557
1558             if (dirindex != -1)
1559             {
1560                 if (msg->imsg->
1561                     Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
1562                 {
1563                     amountindex = 2;
1564                 }
1565                 else if (msg->imsg->Qualifier & IEQUALIFIER_CONTROL)
1566                 {
1567                     amountindex = 1;
1568                 }
1569
1570                 muikey = muikeytable[amountindex][dirindex];
1571             }
1572
1573         }
1574     }
1575
1576     D(bug("String_HandleEvent: muikey %d, imsg %p is_active=%d\n", muikey,
1577             msg->imsg, data->is_active));
1578     if (muikey != MUIKEY_NONE && data->is_active)
1579     {
1580         retval = MUI_EventHandlerRC_Eat;
1581
1582         switch (muikey)
1583         {
1584         case MUIKEY_LEFT:
1585             if (cursor_kills_marking)
1586             {
1587                 update = 1;
1588                 data->BufferPos = MIN(data->BufferPos, data->MarkPos);
1589                 if (data->BufferPos > 0)
1590                     data->BufferPos--;
1591
1592                 data->msd_Flags &= ~MSDF_MARKING;
1593             }
1594             else if (data->BufferPos > 0)
1595             {
1596                 update = 1;
1597
1598                 data->BufferPos--;
1599                 data->msd_RedrawReason = DO_CURSOR_LEFT;
1600             }
1601             break;
1602         case MUIKEY_RIGHT:
1603             if (cursor_kills_marking)
1604             {
1605                 update = 1;
1606                 data->BufferPos = MAX(data->BufferPos, data->MarkPos);
1607                 data->msd_Flags &= ~MSDF_MARKING;
1608             }
1609             else if (data->BufferPos < data->NumChars)
1610             {
1611                 update = 1;
1612                 data->BufferPos++;
1613                 data->msd_RedrawReason = DO_CURSOR_RIGHT;
1614             }
1615             break;
1616         case MUIKEY_WORDLEFT:
1617             if (data->BufferPos > 0)
1618             {
1619                 data->BufferPos =
1620                     Buffer_GetPrevWordIndex(data, data->BufferPos);
1621                 update = 1;
1622                 data->msd_RedrawReason = DO_CURSOR_LEFT;
1623             }
1624             if (cursor_kills_marking)
1625             {
1626                 data->msd_Flags &= ~MSDF_MARKING;
1627                 update = 1;
1628             }
1629             break;
1630         case MUIKEY_WORDRIGHT:
1631             if (data->BufferPos < data->NumChars)
1632             {
1633                 data->BufferPos =
1634                     Buffer_GetSuccWordIndex(data, data->BufferPos);
1635                 update = 1;
1636                 data->msd_RedrawReason = DO_CURSOR_RIGHT;
1637             }
1638             if (cursor_kills_marking)
1639             {
1640                 data->msd_Flags &= ~MSDF_MARKING;
1641                 update = 1;
1642             }
1643             break;
1644         case MUIKEY_LINESTART:
1645             data->BufferPos = 0;
1646             update = 1;
1647             if (cursor_kills_marking)
1648             {
1649                 data->msd_Flags &= ~MSDF_MARKING;
1650             }
1651             break;
1652
1653         case MUIKEY_LINEEND:
1654             data->BufferPos = data->NumChars;
1655             update = 1;
1656             if (cursor_kills_marking)
1657             {
1658                 data->msd_Flags &= ~MSDF_MARKING;
1659             }
1660             break;
1661
1662         case MUIKEY_UP:
1663             if (data->msd_AttachedList)
1664                 set(data->msd_AttachedList,
1665                     MUIA_List_Active, MUIV_List_Active_Up);
1666             break;
1667         case MUIKEY_DOWN:
1668             if (data->msd_AttachedList)
1669                 set(data->msd_AttachedList,
1670                     MUIA_List_Active, MUIV_List_Active_Down);
1671             break;
1672         case MUIKEY_PAGEUP:
1673             if (data->msd_AttachedList)
1674                 set(data->msd_AttachedList,
1675                     MUIA_List_Active, MUIV_List_Active_PageUp);
1676             break;
1677         case MUIKEY_PAGEDOWN:
1678             if (data->msd_AttachedList)
1679                 set(data->msd_AttachedList,
1680                     MUIA_List_Active, MUIV_List_Active_PageDown);
1681             break;
1682         case MUIKEY_TOP:
1683             if (data->msd_AttachedList)
1684                 set(data->msd_AttachedList,
1685                     MUIA_List_Active, MUIV_List_Active_Top);
1686             break;
1687         case MUIKEY_BOTTOM:
1688             if (data->msd_AttachedList)
1689                 set(data->msd_AttachedList,
1690                     MUIA_List_Active, MUIV_List_Active_Bottom);
1691             break;
1692         case MUIKEY_PRESS:
1693             {
1694                 UBYTE *buf = NULL;
1695                 LONG val = 0;
1696
1697                 get(obj, MUIA_String_Contents, &buf);
1698
1699                 if (data->msd_Flags & MSDF_STAYACTIVE)
1700                 {
1701                     /* Do not change active object */
1702                 }
1703                 else if (data->msd_Flags & MSDF_ADVANCEONCR)
1704                 {
1705                     set(_win(obj), MUIA_Window_ActiveObject,
1706                         MUIV_Window_ActiveObject_Next);
1707                 }
1708                 else if (!(data->msd_Flags & MSDF_STAYACTIVE))
1709                 {
1710                     set(_win(obj), MUIA_Window_ActiveObject,
1711                         MUIV_Window_ActiveObject_None);
1712                 }
1713
1714                 /* Notify listeners of new string value */
1715                 set(obj, MUIA_String_Acknowledge, buf);
1716
1717                 /* Notify listeners of new integer value (if any) */
1718                 if (StrToLong(buf, &val) >= 0)
1719                     superset(cl, obj, MUIA_String_Integer, val);
1720             }
1721             break;
1722
1723         case MUIKEY_WINDOW_CLOSE:
1724             data->is_active = FALSE;
1725             set(obj, MUIA_Background,
1726                 (IPTR) muiGlobalInfo(obj)->mgi_Prefs->string_bg_inactive);
1727             DoMethod(obj, MUIM_GoInactive);
1728             retval = 0;
1729             break;
1730
1731         default:
1732             retval = 0;
1733         }                       // switch(muikey)
1734     }                           // if (muikey != MUIKEY_NONE)
1735
1736     if (msg->imsg)
1737     {
1738         UWORD code = msg->imsg->Code;
1739         //UWORD qual = msg->imsg->Qualifier;
1740         WORD x = msg->imsg->MouseX;
1741         WORD y = msg->imsg->MouseY;
1742
1743         //bug("String_HandleEvent: parsing imsg %p, class=%ld\n",
1744         //    msg->imsg, msg->imsg->Class);
1745
1746         switch (msg->imsg->Class)
1747         {
1748         case IDCMP_MOUSEBUTTONS:       /* set cursor and activate it */
1749             if (code == SELECTDOWN)
1750             {
1751                 //bug("String_HandleEvent: code == SELECTDOWN, x=%d y=%d\n",
1752                 //    x, y);
1753
1754                 if (_isinobject(obj, x, y))
1755                 {
1756                     UWORD text_left, text_right;
1757
1758                     retval = MUI_EventHandlerRC_Eat;
1759
1760                     CurrentTime(&data->NewClick_Sec, &data->NewClick_Micro);
1761                     if (DoubleClick(data->OldClick_Sec,
1762                             data->OldClick_Micro, data->NewClick_Sec,
1763                             data->NewClick_Micro))
1764                     {
1765                         data->MultiClick++;
1766                     }
1767                     else
1768                     {
1769                         data->MultiClick = 0;
1770                     }
1771                     data->OldClick_Sec = data->NewClick_Sec;
1772                     data->OldClick_Micro = data->NewClick_Micro;
1773
1774                     //kprintf("multiclick %d\n", data->MultiClick);
1775
1776                     if (!data->is_active)
1777                     {
1778                         //bug("String got button, lets activate\n");
1779                         data->is_active = TRUE;
1780                         data->msd_RedrawReason = WENT_ACTIVE;
1781                         // redraw
1782                         set(obj, MUIA_Background,
1783                             (IPTR) muiGlobalInfo(obj)->mgi_Prefs->
1784                             string_bg_active);
1785
1786                         //DoMethod(obj, MUIM_GoActive);
1787                         set(_win(obj), MUIA_Window_ActiveObject, obj);
1788                         // let other objects a chance to get desactivated
1789                         //retval = 0;
1790                     }
1791
1792                     if (!(data->ehn.ehn_Events & IDCMP_MOUSEMOVE))
1793                     {
1794                         DoMethod(_win(obj), MUIM_Window_RemEventHandler,
1795                             (IPTR) & data->ehn);
1796                         data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
1797                         DoMethod(_win(obj), MUIM_Window_AddEventHandler,
1798                             (IPTR) & data->ehn);
1799                     }
1800
1801                     PrepareVisualBuffer(data);
1802                     text_left = GetTextLeft(cl, obj);
1803                     text_right = GetTextRight(cl, obj);
1804                     CleanVisualBuffer(data);
1805
1806                     /* Check if mouseclick is inside displayed text */
1807                     if ((x >= text_left) && (x <= text_right))
1808                     {
1809                         /* Find new cursor pos. */
1810                         struct TextExtent te;
1811                         ULONG newpos;
1812                         STRPTR dispstr = data->Buffer + data->DispPos;
1813
1814                         newpos = data->DispPos
1815                             + TextFit(_rp(obj), dispstr,
1816                             data->NumChars - data->DispPos, &te, NULL, 1,
1817                             x - text_left, _rp(obj)->Font->tf_YSize);
1818
1819                         if (data->BufferPos != newpos)
1820                         {
1821                             data->BufferPos = newpos;
1822                             update = 1;
1823                         }
1824                     }
1825                     else if (x < text_left)
1826                     {
1827                         /* Click on empty space at left. Set cursor to first
1828                          * visible */
1829                         if (data->BufferPos != data->DispPos)
1830                         {
1831                             data->BufferPos = data->DispPos;
1832                             update = 1;
1833                         }
1834                     }
1835                     else
1836                     {
1837                         /* Click on empty space at right. Set cursor to last
1838                          * visible */
1839                         if (data->BufferPos !=
1840                             data->DispPos + data->DispCount)
1841                         {
1842                             data->BufferPos =
1843                                 data->DispPos + data->DispCount;
1844                             update = 1;
1845                         }
1846                     }           /* if (click is on text or not) */
1847
1848                     data->MarkPos = data->BufferPos;
1849
1850                     if (data->MultiClick == 0)
1851                     {
1852                         if (data->msd_Flags & MSDF_MARKING)
1853                         {
1854                             data->msd_Flags &= ~MSDF_MARKING;
1855                             update = 1;
1856                         }
1857                     }
1858                     else if (data->MultiClick
1859                         && Buffer_GetMarkedRange(data, NULL, NULL))
1860                     {
1861                         data->msd_Flags |= MSDF_MARKING;
1862                         update = 1;
1863                     }
1864
1865
1866                 }               /* is in object */
1867                 else if (data->is_active
1868                     && !(data->msd_Flags & MSDF_STAYACTIVE))
1869                         /* and click not on object */
1870                 {
1871                     data->is_active = FALSE;
1872                     set(obj, MUIA_Background,
1873                         (IPTR) muiGlobalInfo(obj)->mgi_Prefs->
1874                         string_bg_inactive);
1875                     //DoMethod(obj, MUIM_GoInactive);
1876                     // let other objects a chance to get activated
1877                     //retval = 0;
1878                 }
1879             }                   /* if (code == SELECTDOWN) */
1880             else if (code == SELECTUP)
1881             {
1882                 if (data->ehn.ehn_Events & IDCMP_MOUSEMOVE)
1883                 {
1884                     DoMethod(_win(obj), MUIM_Window_RemEventHandler,
1885                         (IPTR) & data->ehn);
1886                     data->ehn.ehn_Events &= ~IDCMP_MOUSEMOVE;
1887                     DoMethod(_win(obj), MUIM_Window_AddEventHandler,
1888                         (IPTR) & data->ehn);
1889                 }
1890             }
1891             break;
1892
1893         case IDCMP_MOUSEMOVE:
1894             if (data->is_active)
1895             {
1896                 UWORD text_left, text_right;
1897
1898                 if (!(data->msd_Flags & MSDF_MARKING))
1899                 {
1900                     data->msd_Flags |= MSDF_MARKING;
1901                 }
1902
1903                 PrepareVisualBuffer(data);
1904                 text_left = GetTextLeft(cl, obj);
1905                 text_right = GetTextRight(cl, obj);
1906                 CleanVisualBuffer(data);
1907
1908                 /* Check if mouseclick is inside displayed text */
1909                 if ((x >= text_left) && (x <= text_right))
1910                 {
1911                     /* Find new cursor pos. */
1912                     struct TextExtent te;
1913                     ULONG newpos;
1914                     STRPTR dispstr = data->Buffer + data->DispPos;
1915
1916                     newpos = data->DispPos
1917                         + TextFit(_rp(obj), dispstr,
1918                         data->NumChars - data->DispPos, &te, NULL, 1,
1919                         x - text_left, _rp(obj)->Font->tf_YSize);
1920
1921                     if (data->BufferPos != newpos)
1922                     {
1923                         WORD old_markstart = 0, old_markstop = 0;
1924                         WORD markstart = 0, markstop = 0;
1925                         BOOL was_marked, is_marked;
1926
1927                         was_marked = Buffer_AnythingMarked(data) &&
1928                             Buffer_GetMarkedRange(data, &old_markstart,
1929                             &old_markstop);
1930
1931                         data->BufferPos = newpos;
1932
1933                         is_marked = Buffer_AnythingMarked(data) &&
1934                             Buffer_GetMarkedRange(data, &markstart,
1935                             &markstop);
1936
1937                         if ((was_marked != is_marked) ||
1938                             (old_markstart != markstart) ||
1939                             (old_markstop != markstop))
1940                         {
1941                             update = 1;
1942                         }
1943                     }
1944                 }
1945                 else if ((x < text_left) && (data->BufferPos > 0))
1946                 {
1947                     data->BufferPos--;
1948                     update = 1;
1949                     data->msd_RedrawReason = DO_CURSOR_LEFT;
1950                 }
1951                 else if ((x > text_right)
1952                     && (data->BufferPos < data->NumChars))
1953                 {
1954                     data->BufferPos++;
1955                     update = 1;
1956                     data->msd_RedrawReason = DO_CURSOR_RIGHT;
1957                 }
1958                 //kprintf("  ---- bp: %d\n", data->BufferPos);
1959             }
1960             break;
1961
1962         case IDCMP_RAWKEY:
1963             {
1964                 unsigned char code;
1965
1966                 //bug("String_HandleEvent: idcmp_rawkey\n");
1967
1968                 if (!data->is_active)
1969                     break;
1970
1971                 code = ConvertKey(msg->imsg);
1972                 if (!code)
1973                 {
1974                     switch (msg->imsg->Code)
1975                     {
1976                     case 0x64: /* LALT */
1977                     case 0x65: /* RALT */
1978                     case 0x64 | IECODE_UP_PREFIX:
1979                     case 0x65 | IECODE_UP_PREFIX:
1980                         if (msg->imsg->
1981                             Qualifier & (IEQUALIFIER_LALT |
1982                                 IEQUALIFIER_RALT))
1983                         {
1984                             data->MarkPos = data->BufferPos;
1985                             data->msd_Flags |=
1986                                 (MSDF_MARKING | MSDF_KEYMARKING);
1987                         }
1988                         else
1989                         {
1990                             data->msd_Flags &= ~MSDF_KEYMARKING;
1991                         }
1992                         break;
1993
1994                     }
1995                 }
1996
1997                 if (code)
1998                 {
1999                     update =
2000                         String_HandleVanillakey(cl, obj, code,
2001                         msg->imsg->Qualifier, &retval);
2002                     if (update)
2003                     {
2004                         retval = MUI_EventHandlerRC_Eat;
2005                         edited = TRUE;
2006                     }
2007                 }
2008             }
2009             break;
2010         }
2011     }
2012
2013     /* Trigger notification */
2014     if (edited)
2015         superset(cl, obj, MUIA_String_Contents, data->Buffer);
2016
2017     if (update)
2018     {
2019         MUI_Redraw(obj, MADF_DRAWUPDATE);
2020     }
2021     //D(bug("String eh return %ld\n", retval));
2022
2023     return retval;
2024 }
2025
2026
2027 /**************************************************************************
2028  MUIM_Export : to export an object's "contents" to a dataspace object.
2029 **************************************************************************/
2030 IPTR String__MUIM_Export(struct IClass *cl, Object *obj,
2031     struct MUIP_Export *msg)
2032 {
2033     struct MUI_StringData *data = INST_DATA(cl, obj);
2034     ULONG id;
2035
2036     if ((id = muiNotifyData(obj)->mnd_ObjectID))
2037     {
2038         if (data->Buffer != NULL)
2039             DoMethod(msg->dataspace, MUIM_Dataspace_Add,
2040                 (IPTR) data->Buffer, data->NumChars + 1, (IPTR) id);
2041         else
2042             DoMethod(msg->dataspace, MUIM_Dataspace_Remove, (IPTR) id);
2043     }
2044
2045     return 0;
2046 }
2047
2048
2049 /**************************************************************************
2050  MUIM_Import : to import an object's "contents" from a dataspace object.
2051 **************************************************************************/
2052 IPTR String__MUIM_Import(struct IClass *cl, Object *obj,
2053     struct MUIP_Import *msg)
2054 {
2055     ULONG id;
2056     STRPTR s;
2057
2058     if ((id = muiNotifyData(obj)->mnd_ObjectID))
2059     {
2060         if ((s = (STRPTR) DoMethod(msg->dataspace, MUIM_Dataspace_Find,
2061                     (IPTR) id)))
2062         {
2063             set(obj, MUIA_String_Contents, s);
2064         }
2065     }
2066
2067     return 0;
2068 }
2069
2070 /**************************************************************************
2071  MUIM_GoActive
2072 **************************************************************************/
2073 IPTR String__MUIM_GoActive(struct IClass *cl, Object *obj, Msg msg)
2074 {
2075     struct MUI_StringData *data =
2076         (struct MUI_StringData *)INST_DATA(cl, obj);
2077
2078     //D(bug("String_GoActive %p\n", obj));
2079     DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR) & data->ehn);
2080     data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY;
2081     DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR) & data->ehn);
2082     data->is_active = TRUE;
2083     data->msd_Flags &= ~MSDF_KEYMARKING;
2084     data->msd_RedrawReason = WENT_ACTIVE;
2085     // redraw
2086     set(obj, MUIA_Background,
2087         (IPTR) muiGlobalInfo(obj)->mgi_Prefs->string_bg_active);
2088
2089     return 0;
2090 }
2091
2092 /**************************************************************************
2093  MUIM_GoInactive
2094 **************************************************************************/
2095 IPTR String__MUIM_GoInactive(struct IClass *cl, Object *obj, Msg msg)
2096 {
2097     struct MUI_StringData *data =
2098         (struct MUI_StringData *)INST_DATA(cl, obj);
2099
2100     //D(bug("String_GoInactive %p\n", obj));
2101
2102     DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR) & data->ehn);
2103     data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS;
2104     DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR) & data->ehn);
2105     data->is_active = FALSE;
2106     data->msd_RedrawReason = WENT_INACTIVE;
2107     data->MultiClick = 0;
2108
2109     // redraw
2110     set(obj, MUIA_Background,
2111         (IPTR) muiGlobalInfo(obj)->mgi_Prefs->string_bg_inactive);
2112
2113     return 0;
2114 }
2115
2116 /**************************************************************************
2117  MUIM_String_ClearSelected (BetterString)
2118 **************************************************************************/
2119 IPTR String__MUIM_ClearSelected(struct IClass *cl, Object *obj,
2120     struct MUIP_String_ClearSelected *msg)
2121 {
2122     struct MUI_StringData *data =
2123         (struct MUI_StringData *)INST_DATA(cl, obj);
2124
2125     //D(bug("String_ClearSelected %p\n", obj));
2126
2127     if (Buffer_KillMarked(data))
2128     {
2129         MUI_Redraw(obj, MADF_DRAWUPDATE);
2130     }
2131
2132     return 0;
2133 }
2134
2135 /**************************************************************************
2136  MUIM_String_Insert (BetterString)
2137 **************************************************************************/
2138 IPTR String__MUIM_Insert(struct IClass *cl, Object *obj,
2139     struct MUIP_String_Insert *msg)
2140 {
2141     struct MUI_StringData *data =
2142         (struct MUI_StringData *)INST_DATA(cl, obj);
2143     LONG pos;
2144     ULONG old_bufferpos;
2145     ULONG num_inserted = 0;
2146
2147     //D(bug("String_Insert %p\n", obj));
2148
2149     switch ((ULONG) msg->pos)
2150     {
2151     case MUIV_String_Insert_StartOfString:
2152         pos = 0;
2153         break;
2154
2155     case MUIV_String_Insert_EndOfString:
2156         pos = data->NumChars;
2157         break;
2158
2159     case MUIV_String_Insert_BufferPos:
2160         pos = data->BufferPos;
2161         break;
2162
2163     default:
2164         pos = msg->pos;
2165         break;
2166     }
2167
2168     if ((pos < 0) || (pos > data->NumChars))
2169         return 0;
2170
2171     old_bufferpos = data->BufferPos;
2172     data->BufferPos = pos;
2173
2174     while (msg->text[num_inserted]
2175         && Buffer_AddChar(data, msg->text[num_inserted]))
2176     {
2177         num_inserted++;
2178     }
2179
2180     if (num_inserted)
2181     {
2182         if (old_bufferpos >= pos)
2183         {
2184             data->BufferPos = old_bufferpos + num_inserted;
2185         }
2186         else
2187         {
2188             data->BufferPos = old_bufferpos;
2189         }
2190
2191         MUI_Redraw(obj, MADF_DRAWUPDATE);
2192     }
2193
2194     return 0;
2195 }
2196
2197 /**************************************************************************
2198  MUIM_String_FileNameStart (BetterString)
2199 **************************************************************************/
2200 IPTR String__MUIM_FileNameStart(struct IClass *cl, Object *obj,
2201     struct MUIP_String_FileNameStart *msg)
2202 {
2203     struct MUI_StringData *data =
2204         (struct MUI_StringData *)INST_DATA(cl, obj);
2205     STRPTR buf;
2206
2207     //D(bug("String_FileNameStart %p\n", obj));
2208
2209     buf = data->Buffer;
2210
2211     // TODO: Implement String_FileNameStart correctly!
2212
2213     return (IPTR) buf;
2214 }
2215
2216 BOOPSI_DISPATCHER(IPTR, String_Dispatcher, cl, obj, msg)
2217 {
2218     switch (msg->MethodID)
2219     {
2220     case OM_NEW:
2221         return String__OM_NEW(cl, obj, (struct opSet *)msg);
2222     case OM_DISPOSE:
2223         return String__OM_DISPOSE(cl, obj, msg);
2224     case OM_SET:
2225         return String__OM_SET(cl, obj, (struct opSet *)msg);
2226     case OM_GET:
2227         return String__OM_GET(cl, obj, (struct opGet *)msg);
2228
2229     case MUIM_Setup:
2230         return String__MUIM_Setup(cl, obj, (APTR) msg);
2231     case MUIM_Cleanup:
2232         return String__MUIM_Cleanup(cl, obj, (APTR) msg);
2233     case MUIM_AskMinMax:
2234         return String__MUIM_AskMinMax(cl, obj, (APTR) msg);
2235     case MUIM_Draw:
2236         return String__MUIM_Draw(cl, obj, (APTR) msg);
2237     case MUIM_Export:
2238         return String__MUIM_Export(cl, obj, (APTR) msg);
2239     case MUIM_Import:
2240         return String__MUIM_Import(cl, obj, (APTR) msg);
2241     case MUIM_GoActive:
2242         return String__MUIM_GoActive(cl, obj, (APTR) msg);
2243     case MUIM_GoInactive:
2244         return String__MUIM_GoInactive(cl, obj, (APTR) msg);
2245     case MUIM_HandleEvent:
2246         return String__MUIM_HandleEvent(cl, obj, (APTR) msg);
2247
2248     /* BetterString */
2249     case MUIM_String_ClearSelected:
2250         return String__MUIM_ClearSelected(cl, obj, (APTR) msg);
2251     case MUIM_String_Insert:
2252         return String__MUIM_Insert(cl, obj, (APTR) msg);
2253     case MUIM_String_FileNameStart:
2254         return String__MUIM_FileNameStart(cl, obj, (APTR) msg);
2255     }
2256
2257     return DoSuperMethodA(cl, obj, msg);
2258 }
2259 BOOPSI_DISPATCHER_END
2260
2261 /*
2262  * Class descriptor.
2263  */
2264 const struct __MUIBuiltinClass _MUI_String_desc =
2265 {
2266     MUIC_String,
2267     MUIC_Area,
2268     sizeof(struct MUI_StringData),
2269     (void *)String_Dispatcher
2270 };