workbench/classes/zune/betterstring/mcc/HandleInput.c

   1 /***************************************************************************
   2
   3  BetterString.mcc - A better String gadget MUI Custom Class
   4  Copyright (C) 1997-2000 Allan Odgaard
   5  Copyright (C) 2005-2013 by BetterString.mcc Open Source Team
   6
   7  This library is free software; you can redistribute it and/or
   8  modify it under the terms of the GNU Lesser General Public
   9  License as published by the Free Software Foundation; either
  10  version 2.1 of the License, or (at your option) any later version.
  11
  12  This library is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  Lesser General Public License for more details.
  16
  17  BetterString class Support Site:  http://www.sf.net/projects/bstring-mcc/
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #include <string.h>
  24 #include <stdlib.h>
  25
  26 #include <clib/alib_protos.h>
  27 #include <clib/macros.h>
  28 #include <proto/exec.h>
  29 #include <proto/graphics.h>
  30 #include <proto/intuition.h>
  31 #include <proto/muimaster.h>
  32 #include <proto/keymap.h>
  33 #include <proto/layers.h>
  34 #include <proto/locale.h>
  35 #include <proto/dos.h>
  36
  37 #include "private.h"
  38
  39 #include "SDI_stdarg.h"
  40
  41 #define BlockEnabled(data)  (isFlagSet((data)->Flags, FLG_BlockEnabled) && (data)->BlockStart != (data)->BlockStop)
  42
  43 #if defined(__amigaos4__) || defined(__MORPHOS__)
  44 static int VARARGS68K MySPrintf(char *buf, const char *fmt, ...)
  45 {
  46   VA_LIST args;
  47
  48   VA_START(args, fmt);
  49   RawDoFmt(fmt, VA_ARG(args, void *), NULL, (STRPTR)buf);
  50   VA_END(args);
  51
  52   return(strlen(buf));
  53 }
  54 #elif defined(__AROS__)
  55 #define MySPrintf __sprintf /* from amiga lib */
  56 #else
  57 static int STDARGS MySPrintf(char *buf, const char *fmt, ...)
  58 {
  59   static const UWORD PutCharProc[2] = {0x16C0,0x4E75};
  60   /* dirty hack to avoid assembler part :-)
  61      16C0: move.b d0,(a3)+
  62      4E75: rts */
  63   va_list args;
  64
  65   va_start(args, fmt);
  66   RawDoFmt(fmt, args, (void (*)(void))PutCharProc, (STRPTR)buf);
  67   va_end(args);
  68
  69   return(strlen(buf));
  70 }
  71 #endif
  72
  73 static void AddToUndo(struct InstData *data)
  74 {
  75   ENTER();
  76
  77   FreeContentString(data->Undo);
  78
  79   if((data->Undo = AllocContentString(strlen(data->Contents)+1)) != NULL)
  80   {
  81     strlcpy(data->Undo, data->Contents, strlen(data->Contents)+1);
  82     data->UndoPos = data->BufferPos;
  83     clearFlag(data->Flags, FLG_RedoAvailable);
  84   }
  85
  86   LEAVE();
  87 }
  88
  89 static WORD AlignOffset(Object *obj, struct InstData *data)
  90 {
  91   WORD   width = _mwidth(obj);
  92   WORD   offset = 0;
  93
  94   ENTER();
  95
  96   if(data->Alignment != MUIV_String_Format_Left)
  97   {
  98     STRPTR text = data->Contents+data->DisplayPos;
  99     UWORD  StrLength = strlen(text);
 100     UWORD  length, textlength, crsr_width;
 101     struct TextExtent tExtend;
 102
 103     SetFont(&data->rport, _font(obj));
 104     length = TextFit(&data->rport, text, StrLength, &tExtend, NULL, 1, width, _font(obj)->tf_YSize);
 105     textlength = TextLength(&data->rport, text, length);
 106
 107     crsr_width = isFlagSet(data->Flags, FLG_Active) ? TextLength(&data->rport, (*(data->Contents+data->BufferPos) == '\0') ? (char *)"n" : (char *)(data->Contents+data->BufferPos), 1) : 0;
 108     if(crsr_width && BlockEnabled(data) == FALSE && data->BufferPos == data->DisplayPos+StrLength)
 109     {
 110       textlength += crsr_width;
 111     }
 112
 113     switch(data->Alignment)
 114     {
 115       case MUIV_String_Format_Center:
 116         offset = (width - textlength)/2;
 117         break;
 118       case MUIV_String_Format_Right:
 119         offset = (width - textlength);
 120         break;
 121     }
 122   }
 123
 124   RETURN(offset);
 125   return offset;
 126 }
 127
 128 static BOOL Reject(UBYTE code, STRPTR reject)
 129 {
 130   BOOL rc = TRUE;
 131
 132   ENTER();
 133
 134   if(reject != NULL)
 135   {
 136     while(*reject != '\0')
 137     {
 138       if(code == *reject++)
 139       {
 140         rc = FALSE;
 141         break;
 142       }
 143     }
 144   }
 145
 146   RETURN(rc);
 147   return rc;
 148 }
 149
 150 static BOOL Accept(UBYTE code, STRPTR accept)
 151 {
 152   return(accept ? !Reject(code, accept) : TRUE);
 153 }
 154
 155 static UWORD DecimalValue(UBYTE code)
 156 {
 157   if(code >= '0' && code <= '9')
 158     return(code - '0');
 159   if(code >= 'a' && code <= 'f')
 160     return(code - 'a' + 10);
 161   if(code >= 'A' && code <= 'F')
 162     return(code - 'A' + 10);
 163
 164   return(0);
 165 }
 166
 167 static BOOL IsHex(UBYTE code)
 168 {
 169   return(
 170     (code >= '0' && code <= '9') ||
 171     (code >= 'a' && code <= 'f') ||
 172     (code >= 'A' && code <= 'F') ? TRUE : FALSE);
 173 }
 174
 175 static LONG FindDigit(struct InstData *data)
 176 {
 177   WORD  pos = data->BufferPos;
 178
 179   ENTER();
 180
 181   if(IsDigit(data->locale, *(data->Contents+pos)))
 182   {
 183     while(pos > 0 && IsDigit(data->locale, *(data->Contents+pos-1)))
 184       pos--;
 185   }
 186   else
 187   {
 188     while(*(data->Contents+pos) != '\0' && !IsDigit(data->locale, *(data->Contents+pos)))
 189       pos++;
 190   }
 191
 192   if(*(data->Contents+pos) == '\0')
 193   {
 194     pos = data->BufferPos;
 195     while(pos && !IsDigit(data->locale, *(data->Contents+pos)))
 196       pos--;
 197
 198     while(pos > 0 && IsDigit(data->locale, *(data->Contents+pos-1)))
 199       pos--;
 200
 201     if(!pos && !IsDigit(data->locale, *data->Contents))
 202     {
 203       pos = -1;
 204     }
 205   }
 206
 207   RETURN(pos);
 208   return pos;
 209 }
 210
 211 static UWORD NextWord(STRPTR text, UWORD x, struct Locale *locale)
 212 {
 213   ENTER();
 214
 215   while(IsAlNum(locale, (UBYTE)text[x]))
 216     x++;
 217
 218   while(text[x] != '\0' && !IsAlNum(locale, (UBYTE)text[x]))
 219     x++;
 220
 221   RETURN(x);
 222   return x;
 223 }
 224
 225 static UWORD PrevWord(STRPTR text, UWORD x, struct Locale *locale)
 226 {
 227   ENTER();
 228
 229   if(x)
 230     x--;
 231
 232   while(x && !IsAlNum(locale, (UBYTE)text[x]))
 233     x--;
 234
 235   while(x > 0 && IsAlNum(locale, (UBYTE)text[x-1]))
 236     x--;
 237
 238   RETURN(x);
 239   return x;
 240 }
 241
 242 void DeleteBlock(struct InstData *data)
 243 {
 244   ENTER();
 245
 246   AddToUndo(data);
 247
 248   if(BlockEnabled(data) == TRUE)
 249   {
 250     UWORD Blk_Start, Blk_Width;
 251
 252     Blk_Start = (data->BlockStart < data->BlockStop) ? data->BlockStart : data->BlockStop;
 253     Blk_Width = abs(data->BlockStop-data->BlockStart);
 254     memmove(data->Contents+Blk_Start, data->Contents+Blk_Start+Blk_Width, strlen(data->Contents+Blk_Start+Blk_Width)+1);
 255     data->BufferPos = Blk_Start;
 256   }
 257
 258   LEAVE();
 259 }
 260
 261 static void CopyBlock(struct InstData *data)
 262 {
 263   ENTER();
 264
 265   if(isFlagClear(data->Flags, FLG_Secret))
 266   {
 267     UWORD Blk_Start, Blk_Width;
 268     //struct IFFHandle *iff;
 269
 270     if(BlockEnabled(data) == TRUE)
 271     {
 272       Blk_Start = (data->BlockStart < data->BlockStop) ? data->BlockStart : data->BlockStop;
 273       Blk_Width = abs(data->BlockStop-data->BlockStart);
 274     }
 275     else
 276     {
 277       Blk_Start = 0;
 278       Blk_Width = strlen(data->Contents);
 279     }
 280
 281     StringToClipboard(&data->Contents[Blk_Start], Blk_Width);
 282   }
 283
 284   LEAVE();
 285 }
 286
 287 static void CutBlock(struct InstData *data)
 288 {
 289   ENTER();
 290
 291   AddToUndo(data);
 292
 293   if(BlockEnabled(data) == TRUE)
 294   {
 295     CopyBlock(data);
 296     DeleteBlock(data);
 297     clearFlag(data->Flags, FLG_BlockEnabled);
 298   }
 299   else
 300   {
 301     *data->Contents = '\0';
 302     data->BufferPos = 0;
 303   }
 304
 305   LEAVE();
 306 }
 307
 308 static void Paste(struct InstData *data)
 309 {
 310   STRPTR str;
 311   LONG length;
 312
 313   ENTER();
 314
 315   if(ClipboardToString(&str, &length) == TRUE)
 316   {
 317     // clear the selection
 318     DeleteBlock(data);
 319
 320     if(data->MaxLength != 0 && strlen(data->Contents) + length > (ULONG)data->MaxLength - 1)
 321     {
 322       DisplayBeep(NULL);
 323       length = data->MaxLength - 1 - strlen(data->Contents);
 324     }
 325
 326     if(ExpandContentString(&data->Contents, length) == TRUE)
 327     {
 328       memmove(data->Contents + data->BufferPos + length, data->Contents + data->BufferPos, strlen(data->Contents + data->BufferPos)+1);
 329       memcpy(data->Contents + data->BufferPos, str, length);
 330       data->BufferPos += length;
 331     }
 332     else
 333     {
 334       E(DBF_ALWAYS, "content expansion by %ld bytes failed", length);
 335     }
 336
 337     SharedPoolFree(str);
 338   }
 339
 340   LEAVE();
 341 }
 342
 343 static void UndoRedo(struct InstData *data)
 344 {
 345   STRPTR oldcontents;
 346   UWORD oldpos;
 347
 348   ENTER();
 349
 350   // swap content and undo pointers
 351   oldcontents = data->Contents;
 352   data->Contents = data->Undo;
 353   data->Undo = oldcontents;
 354
 355   if(isFlagSet(data->Flags, FLG_RedoAvailable))
 356     clearFlag(data->Flags, FLG_RedoAvailable);
 357   else
 358     setFlag(data->Flags, FLG_RedoAvailable);
 359
 360   clearFlag(data->Flags, FLG_BlockEnabled);
 361
 362   // swap content and undo positions
 363   oldpos = data->BufferPos;
 364   data->BufferPos = data->UndoPos;
 365   data->UndoPos = oldpos;
 366
 367   LEAVE();
 368 }
 369
 370 static void RevertToOriginal(struct InstData *data)
 371 {
 372   STRPTR oldcontents;
 373
 374   ENTER();
 375
 376   // swap content and original pointers
 377   oldcontents = data->Contents;
 378   data->Contents = data->Original;
 379   data->Original = oldcontents;
 380
 381   setFlag(data->Flags, FLG_Original);
 382   clearFlag(data->Flags, FLG_BlockEnabled);
 383   data->BufferPos = strlen(data->Contents);
 384
 385   LEAVE();
 386 }
 387
 388 static BOOL ToggleCaseChar(struct InstData *data)
 389 {
 390   UBYTE key = *(data->Contents+data->BufferPos);
 391   BOOL result = FALSE;
 392
 393   ENTER();
 394
 395   if(data->BufferPos < strlen(data->Contents))
 396   {
 397     *(data->Contents+data->BufferPos) = IsLower(data->locale, key) ? ConvToUpper(data->locale, key) : ConvToLower(data->locale, key);
 398     data->BufferPos++;
 399     result = TRUE;
 400   }
 401
 402   RETURN(result);
 403   return result;
 404 }
 405
 406 static BOOL ToggleCaseWord(struct InstData *data)
 407 {
 408   UWORD Stop = NextWord(data->Contents, data->BufferPos, data->locale);
 409   BOOL result = FALSE;
 410
 411   ENTER();
 412
 413   while(data->BufferPos < Stop)
 414   {
 415     UBYTE key = *(data->Contents+data->BufferPos);
 416
 417     *(data->Contents+data->BufferPos) = IsLower(data->locale, key) ? ConvToUpper(data->locale, key) : ConvToLower(data->locale, key);
 418     data->BufferPos++;
 419     result = TRUE;
 420   }
 421
 422   RETURN(result);
 423   return result;
 424 }
 425
 426 static BOOL IncreaseNearNumber(struct InstData *data)
 427 {
 428   LONG pos;
 429   BOOL result = FALSE;
 430
 431   ENTER();
 432
 433   if((pos = FindDigit(data)) >= 0)
 434   {
 435     LONG  cut;
 436     ULONG  res;
 437
 438     if((cut = StrToLong(data->Contents+pos, (LONG *)&res)))
 439     {
 440       char string[12];
 441       char format[12];
 442
 443       res++;
 444       MySPrintf(format, "%%0%ldlu", cut);
 445       MySPrintf(string, format, res);
 446       Overwrite(string, pos, cut, data);
 447       result = TRUE;
 448     }
 449   }
 450
 451   RETURN(result);
 452   return result;
 453 }
 454
 455 static BOOL DecreaseNearNumber(struct InstData *data)
 456 {
 457   LONG pos;
 458   BOOL result = FALSE;
 459
 460   ENTER();
 461
 462   if((pos = FindDigit(data)) >= 0)
 463   {
 464     LONG cut;
 465     ULONG  res;
 466
 467     if((cut = StrToLong(data->Contents+pos, (LONG *)&res)))
 468     {
 469       if(res)
 470       {
 471         char *format;
 472         char string[12];
 473         char format2[12];
 474
 475         format = &format2[0];
 476         MySPrintf(format, "%%0%ldlu", cut);
 477         res--;
 478         MySPrintf(string, format, res);
 479         Overwrite(string, pos, cut, data);
 480         result = TRUE;
 481       }
 482     }
 483   }
 484
 485   RETURN(result);
 486   return result;
 487 }
 488
 489 static BOOL HexToDec(struct InstData *data)
 490 {
 491   LONG  cut = 0;
 492   UWORD pos = data->BufferPos;
 493   ULONG  res = 0;
 494   BOOL result = FALSE;
 495
 496   ENTER();
 497
 498   while(pos && IsHex(*(data->Contents+pos-1)))
 499     pos--;
 500
 501   while(IsHex(*(data->Contents+pos+cut)))
 502   {
 503     res = (result << 4) + DecimalValue(*(data->Contents+pos+cut));
 504     cut++;
 505   }
 506
 507   if(cut)
 508   {
 509     char string[12];
 510
 511     MySPrintf(string, "%lu", res);
 512     Overwrite(string, pos, cut, data);
 513     result = TRUE;
 514   }
 515
 516   RETURN(result);
 517   return result;
 518 }
 519
 520 static BOOL DecToHex(struct InstData *data)
 521 {
 522   LONG pos;
 523   BOOL result = FALSE;
 524
 525   ENTER();
 526
 527   if((pos = FindDigit(data)) >= 0)
 528   {
 529     LONG cut;
 530     ULONG  res;
 531
 532     if((cut = StrToLong(data->Contents+pos, (LONG *)&res)))
 533     {
 534       const char *format = "%lx";
 535       char string[12];
 536
 537       MySPrintf(string, format, res);
 538       Overwrite(string, pos, cut, data);
 539       result  = TRUE;
 540     }
 541   }
 542
 543   RETURN(result);
 544   return result;
 545 }
 546
 547 void TriggerNotify(struct IClass *cl, Object *obj)
 548 {
 549   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 550   struct TagItem tags[] =
 551   {
 552     { MUIA_String_Contents, (IPTR)data->Contents },
 553     { TAG_DONE,             0                    }
 554   };
 555
 556   ENTER();
 557
 558   // pass the attribute directly to our superclass as our own
 559   // handling of OM_SET will suppress the notification in case
 560   // the contents did not change
 561   if(isFlagClear(data->Flags, FLG_NoNotify))
 562   {
 563     DoSuperMethod(cl, obj, OM_SET, tags, NULL);
 564     clearFlag(data->Flags, FLG_NotifyQueued);
 565   }
 566   else
 567     setFlag(data->Flags, FLG_NotifyQueued);
 568
 569   LEAVE();
 570 }
 571
 572 ULONG ConvertKey(struct IntuiMessage *imsg)
 573 {
 574   struct InputEvent  event;
 575   unsigned char code = 0;
 576
 577   ENTER();
 578
 579   event.ie_NextEvent      = NULL;
 580   event.ie_Class          = IECLASS_RAWKEY;
 581   event.ie_SubClass       = 0;
 582   event.ie_Code           = imsg->Code;
 583   event.ie_Qualifier      = imsg->Qualifier;
 584   event.ie_EventAddress   = (APTR *) *((IPTR *)imsg->IAddress);
 585
 586   MapRawKey(&event, (STRPTR)&code, 1, NULL);
 587
 588   RETURN(code);
 589   return code;
 590 }
 591
 592 IPTR mDoAction(struct IClass *cl, Object *obj, struct MUIP_BetterString_DoAction *msg)
 593 {
 594   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 595   IPTR result = FALSE;
 596   BOOL edited = FALSE;
 597
 598   ENTER();
 599
 600   D(DBF_INPUT, "DoAction(%ld)");
 601
 602   switch(msg->action)
 603   {
 604     case MUIV_BetterString_DoAction_Cut:
 605     {
 606       CutBlock(data);
 607       edited = TRUE;
 608       result = TRUE;
 609     }
 610     break;
 611
 612     case MUIV_BetterString_DoAction_Copy:
 613     {
 614       CopyBlock(data);
 615       clearFlag(data->Flags, FLG_BlockEnabled);
 616       result = TRUE;
 617     }
 618     break;
 619
 620     case MUIV_BetterString_DoAction_Paste:
 621     {
 622       Paste(data);
 623       clearFlag(data->Flags, FLG_BlockEnabled);
 624       edited = TRUE;
 625       result = TRUE;
 626     }
 627     break;
 628
 629     case MUIV_BetterString_DoAction_Delete:
 630     {
 631       DeleteBlock(data);
 632       clearFlag(data->Flags, FLG_BlockEnabled);
 633       edited = TRUE;
 634       result = TRUE;
 635     }
 636     break;
 637
 638     case MUIV_BetterString_DoAction_SelectAll:
 639     {
 640       data->BlockStart = 0;
 641       data->BlockStop = strlen(data->Contents);
 642       setFlag(data->Flags, FLG_BlockEnabled);
 643       result = TRUE;
 644     }
 645     break;
 646
 647     case MUIV_BetterString_DoAction_SelectNone:
 648     {
 649       clearFlag(data->Flags, FLG_BlockEnabled);
 650       result = TRUE;
 651     }
 652     break;
 653
 654     case MUIV_BetterString_DoAction_Undo:
 655     case MUIV_BetterString_DoAction_Redo:
 656     {
 657       if(data->Undo &&
 658          (((msg->action == MUIV_BetterString_DoAction_Redo) && isFlagSet(data->Flags, FLG_RedoAvailable)) ||
 659           ((msg->action == MUIV_BetterString_DoAction_Undo) && isFlagClear(data->Flags, FLG_RedoAvailable))))
 660       {
 661         UndoRedo(data);
 662         clearFlag(data->Flags, FLG_BlockEnabled);
 663         edited = TRUE;
 664         result = TRUE;
 665       }
 666     }
 667     break;
 668
 669     case MUIV_BetterString_DoAction_Revert:
 670     {
 671       RevertToOriginal(data);
 672       clearFlag(data->Flags, FLG_BlockEnabled);
 673       edited = TRUE;
 674       result = TRUE;
 675     }
 676     break;
 677
 678     case MUIV_BetterString_DoAction_ToggleCase:
 679     {
 680       edited = result = ToggleCaseChar(data);
 681       clearFlag(data->Flags, FLG_BlockEnabled);
 682     }
 683     break;
 684
 685     case MUIV_BetterString_DoAction_ToggleCaseWord:
 686     {
 687       edited = result = ToggleCaseWord(data);
 688       clearFlag(data->Flags, FLG_BlockEnabled);
 689     }
 690     break;
 691
 692     case MUIV_BetterString_DoAction_IncreaseNum:
 693     {
 694       edited = result = IncreaseNearNumber(data);
 695       clearFlag(data->Flags, FLG_BlockEnabled);
 696     }
 697     break;
 698
 699     case MUIV_BetterString_DoAction_DecreaseNum:
 700     {
 701       edited = result = DecreaseNearNumber(data);
 702       clearFlag(data->Flags, FLG_BlockEnabled);
 703     }
 704     break;
 705
 706     case MUIV_BetterString_DoAction_HexToDec:
 707     {
 708       edited = result = HexToDec(data);
 709       clearFlag(data->Flags, FLG_BlockEnabled);
 710     }
 711     break;
 712
 713     case MUIV_BetterString_DoAction_DecToHex:
 714     {
 715       edited = result = DecToHex(data);
 716       clearFlag(data->Flags, FLG_BlockEnabled);
 717     }
 718     break;
 719
 720     case MUIV_BetterString_DoAction_NextFileComp:
 721     {
 722       edited = result = FileNameComplete(obj, FALSE, data);
 723       clearFlag(data->Flags, FLG_BlockEnabled);
 724     }
 725     break;
 726
 727     case MUIV_BetterString_DoAction_PrevFileComp:
 728     {
 729       edited = result = FileNameComplete(obj, TRUE, data);
 730       clearFlag(data->Flags, FLG_BlockEnabled);
 731     }
 732     break;
 733   }
 734
 735   MUI_Redraw(obj, MADF_DRAWUPDATE);
 736
 737   if(edited == TRUE)
 738     TriggerNotify(cl, obj);
 739
 740   RETURN(result);
 741   return result;
 742 }
 743
 744 IPTR mHandleInput(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
 745 {
 746   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
 747   IPTR result = 0;
 748   BOOL movement = FALSE;
 749   BOOL edited = FALSE;
 750   BOOL FNC = FALSE;
 751
 752   ENTER();
 753
 754   // handle the standard MUI keys first
 755   if(msg->muikey != MUIKEY_NONE)
 756   {
 757     switch(msg->muikey)
 758     {
 759       case MUIKEY_UP:
 760       {
 761         if(data->KeyUpFocus != NULL && _win(obj) != NULL)
 762         {
 763           set(_win(obj), MUIA_Window_ActiveObject, data->KeyUpFocus);
 764           result = MUI_EventHandlerRC_Eat;
 765         }
 766       }
 767       break;
 768
 769       case MUIKEY_DOWN:
 770       {
 771         if(data->KeyDownFocus != NULL && _win(obj) != NULL)
 772         {
 773           set(_win(obj), MUIA_Window_ActiveObject, data->KeyDownFocus);
 774           result = MUI_EventHandlerRC_Eat;
 775         }
 776       }
 777       break;
 778
 779       case MUIKEY_COPY:
 780       {
 781         CopyBlock(data);
 782         clearFlag(data->Flags, FLG_BlockEnabled);
 783         MUI_Redraw(obj, MADF_DRAWUPDATE);
 784         result = MUI_EventHandlerRC_Eat;
 785       }
 786       break;
 787
 788       case MUIKEY_CUT:
 789       {
 790         CutBlock(data);
 791         clearFlag(data->Flags, FLG_BlockEnabled);
 792         MUI_Redraw(obj, MADF_DRAWUPDATE);
 793         TriggerNotify(cl, obj);
 794         result = MUI_EventHandlerRC_Eat;
 795       }
 796       break;
 797
 798       case MUIKEY_PASTE:
 799       {
 800         Paste(data);
 801         clearFlag(data->Flags, FLG_BlockEnabled);
 802         MUI_Redraw(obj, MADF_DRAWUPDATE);
 803         TriggerNotify(cl, obj);
 804         result = MUI_EventHandlerRC_Eat;
 805       }
 806       break;
 807
 808       case MUIKEY_UNDO:
 809       case MUIKEY_REDO:
 810       {
 811         if(data->Undo && ((msg->muikey == MUIKEY_REDO && isFlagSet(data->Flags, FLG_RedoAvailable)) ||
 812                           (msg->muikey == MUIKEY_UNDO && isFlagClear(data->Flags, FLG_RedoAvailable))))
 813         {
 814           UndoRedo(data);
 815           clearFlag(data->Flags, FLG_BlockEnabled);
 816           MUI_Redraw(obj, MADF_DRAWUPDATE);
 817           TriggerNotify(cl, obj);
 818           result = MUI_EventHandlerRC_Eat;
 819         }
 820         else
 821           DisplayBeep(NULL);
 822       }
 823       break;
 824     }
 825   }
 826
 827   if(result == 0 && msg->imsg != NULL)
 828   {
 829     ULONG StringLength = strlen(data->Contents);
 830
 831     if(msg->imsg->Class == IDCMP_RAWKEY &&
 832     // msg->imsg->Code >= IECODE_KEY_CODE_FIRST &&
 833        msg->imsg->Code <= IECODE_KEY_CODE_LAST)
 834     {
 835       if(isFlagSet(data->Flags, FLG_Active))
 836       {
 837         BOOL input = TRUE;
 838
 839         if(isFlagClear(data->Flags, FLG_BlockEnabled))
 840           data->BlockStart = data->BufferPos;
 841
 842         if(isFlagSet(data->Flags, FLG_NoInput))
 843         {
 844           switch(msg->imsg->Code)
 845           {
 846             case RAWKEY_TAB:
 847             case RAWKEY_BACKSPACE:
 848             case RAWKEY_DEL:
 849               input = FALSE;
 850             break;
 851           }
 852         }
 853
 854         if(input == TRUE)
 855         {
 856           switch(msg->imsg->Code)
 857           {
 858             // Tab
 859             case RAWKEY_TAB:
 860             {
 861               if(isFlagSet(data->Flags, FLG_NoShortcuts) || isFlagClear(msg->imsg->Qualifier, IEQUALIFIER_RCOMMAND))
 862               {
 863                 RETURN(0);
 864                 return 0;
 865               }
 866
 867               if(!(edited = FileNameComplete(obj, isAnyFlagSet(msg->imsg->Qualifier, IEQUALIFIER_RSHIFT|IEQUALIFIER_LSHIFT), data)))
 868                 DisplayBeep(NULL);
 869
 870               FNC = TRUE;
 871             }
 872             break;
 873
 874             // Right
 875             case RAWKEY_CRSRRIGHT:
 876             {
 877               if(data->BufferPos < StringLength)
 878               {
 879                 if(isAnyFlagSet(msg->imsg->Qualifier, IEQUALIFIER_RSHIFT|IEQUALIFIER_LSHIFT))
 880                 {
 881                   data->BufferPos = StringLength;
 882                 }
 883                 else if(isAnyFlagSet(msg->imsg->Qualifier, IEQUALIFIER_RALT|IEQUALIFIER_LALT))
 884                 {
 885                   data->BufferPos = NextWord(data->Contents, data->BufferPos, data->locale);
 886                 }
 887                 else if(BlockEnabled(data) && isFlagClear(msg->imsg->Qualifier, IEQUALIFIER_CONTROL))
 888                 {
 889                   data->BufferPos = MAX(data->BlockStart, data->BlockStop);
 890                 }
 891                 else
 892                 {
 893                   data->BufferPos++;
 894                 }
 895               }
 896               movement = TRUE;
 897             }
 898             break;
 899
 900             // Left
 901             case RAWKEY_CRSRLEFT:
 902             {
 903               if(data->BufferPos)
 904               {
 905                 if(isAnyFlagSet(msg->imsg->Qualifier, IEQUALIFIER_RSHIFT|IEQUALIFIER_LSHIFT))
 906                 {
 907                   data->BufferPos = 0;
 908                 }
 909                 else if(isAnyFlagSet(msg->imsg->Qualifier, IEQUALIFIER_RALT|IEQUALIFIER_LALT))
 910                 {
 911                   data->BufferPos = PrevWord(data->Contents, data->BufferPos, data->locale);
 912                 }
 913                 else
 914                 {
 915                   if(BlockEnabled(data) && isFlagClear(msg->imsg->Qualifier, IEQUALIFIER_CONTROL))
 916                     data->BufferPos = MIN(data->BlockStart, data->BlockStop);
 917
 918                   if(data->BufferPos)
 919                     data->BufferPos--;
 920                 }
 921               }
 922               movement = TRUE;
 923             }
 924             break;
 925
 926             // Backspace
 927             case RAWKEY_BACKSPACE:
 928             {
 929               if(BlockEnabled(data))
 930               {
 931                 DeleteBlock(data);
 932               }
 933               else
 934               {
 935                 if(data->BufferPos != 0)
 936                 {
 937                   if(isAnyFlagSet(msg->imsg->Qualifier, IEQUALIFIER_RSHIFT|IEQUALIFIER_LSHIFT|IEQUALIFIER_CONTROL))
 938                   {
 939                     AddToUndo(data);
 940                     memmove(data->Contents, data->Contents+data->BufferPos, strlen(data->Contents+data->BufferPos)+1);
 941                     data->BufferPos = 0;
 942                   }
 943                   else if(isAnyFlagSet(msg->imsg->Qualifier, IEQUALIFIER_RALT|IEQUALIFIER_LALT))
 944                   {
 945                     UWORD NewPos = PrevWord(data->Contents, data->BufferPos, data->locale);
 946
 947                     AddToUndo(data);
 948                     memmove(data->Contents+NewPos, data->Contents+data->BufferPos, strlen(data->Contents+data->BufferPos)+1);
 949                     data->BufferPos = NewPos;
 950                   }
 951                   else
 952                   {
 953                     memmove(data->Contents+data->BufferPos-1, data->Contents+data->BufferPos, strlen(data->Contents+data->BufferPos)+1);
 954                     data->BufferPos--;
 955                   }
 956                 }
 957               }
 958               edited = TRUE;
 959             }
 960             break;
 961
 962             // Delete
 963             case RAWKEY_DEL:
 964             {
 965               if(BlockEnabled(data))
 966               {
 967                 DeleteBlock(data);
 968               }
 969               else
 970               {
 971                 if(data->BufferPos < StringLength)
 972                 {
 973                   if(isAnyFlagSet(msg->imsg->Qualifier, IEQUALIFIER_RSHIFT|IEQUALIFIER_LSHIFT) || isFlagSet(msg->imsg->Qualifier, IEQUALIFIER_CONTROL))
 974                   {
 975                     AddToUndo(data);
 976                     *(data->Contents+data->BufferPos) = '\0';
 977                   }
 978                   else if(isAnyFlagSet(msg->imsg->Qualifier, IEQUALIFIER_RALT|IEQUALIFIER_LALT))
 979                   {
 980                     STRPTR start = data->Contents+NextWord(data->Contents, data->BufferPos, data->locale);
 981
 982                     AddToUndo(data);
 983                     memmove(data->Contents+data->BufferPos, start, strlen(start)+1);
 984                   }
 985                   else
 986                   {
 987                     memmove(data->Contents+data->BufferPos, data->Contents+data->BufferPos+1, strlen(data->Contents+data->BufferPos+1)+1);
 988                   }
 989                 }
 990               }
 991               edited = TRUE;
 992             }
 993             break;
 994
 995             // Home
 996             case RAWKEY_HOME:
 997             {
 998               if(data->BufferPos)
 999                 data->BufferPos = 0;
1000
1001               movement = TRUE;
1002             }
1003             break;
1004
1005             // End
1006             case RAWKEY_END:
1007             {
1008               if(data->BufferPos < StringLength)
1009                 data->BufferPos = StringLength;
1010
1011               movement = TRUE;
1012             }
1013             break;
1014
1015             default:
1016             {
1017               if(data->Popup && msg->muikey == MUIKEY_POPUP)
1018               {
1019                 DoMethod(data->Popup, MUIM_Popstring_Open);
1020               }
1021               else
1022               {
1023                 UBYTE code = ConvertKey(msg->imsg);
1024
1025                 if((((code >= 32 && code <= 126) || code >= 160) && isFlagClear(msg->imsg->Qualifier, IEQUALIFIER_RCOMMAND)) ||
1026                    (code && isFlagSet(msg->imsg->Qualifier, IEQUALIFIER_CONTROL)))
1027                 {
1028                   if(isFlagClear(data->Flags, FLG_NoInput))
1029                   {
1030                     DeleteBlock(data);
1031
1032                     if((data->MaxLength == 0 || (ULONG)data->MaxLength-1 > strlen(data->Contents)) &&
1033                        Accept(code, data->Accept) && Reject(code, data->Reject))
1034                     {
1035                       if(ExpandContentString(&data->Contents, 1) == TRUE)
1036                       {
1037                         memmove(data->Contents+data->BufferPos+1, data->Contents+data->BufferPos, strlen(data->Contents + data->BufferPos)+1);
1038                         *(data->Contents+data->BufferPos) = code;
1039                         data->BufferPos++;
1040                         edited = TRUE;
1041                       }
1042                       else
1043                       {
1044                         E(DBF_ALWAYS, "content expansion by %ld bytes failed", 1);
1045                       }
1046                     }
1047                     else
1048                     {
1049                       DisplayBeep(NULL);
1050                     }
1051                   }
1052                 }
1053                 else
1054                 {
1055                   // if this betterstring object is a read-only object
1056                   // we only accept a view characters or otherwise reject
1057                   // the rawkey operation
1058                   if(isFlagSet(data->Flags, FLG_NoInput))
1059                   {
1060                     switch(code)
1061                     {
1062                       case '\r':
1063                       case 'c':
1064                       break;
1065
1066                       default:
1067                         RETURN(MUI_EventHandlerRC_Eat);
1068                         return MUI_EventHandlerRC_Eat;
1069                       break;
1070                     }
1071                   }
1072
1073                   // check if the user pressed return and if he has activated AdvanceOnCr or not
1074                   if(code == '\r')
1075                   {
1076                     if(isFlagClear(data->Flags, FLG_StayActive))
1077                     {
1078                       ULONG active;
1079
1080                       if(isFlagSet(data->Flags, FLG_AdvanceOnCr))
1081                       {
1082                         if(isAnyFlagSet(msg->imsg->Qualifier, IEQUALIFIER_RSHIFT|IEQUALIFIER_LSHIFT))
1083                           active = MUIV_Window_ActiveObject_Prev;
1084                         else
1085                           active = MUIV_Window_ActiveObject_Next;
1086                       }
1087                       else
1088                         active = MUIV_Window_ActiveObject_None;
1089
1090                       set(_win(obj), MUIA_Window_ActiveObject, active);
1091                     }
1092
1093                     set(obj, MUIA_String_Acknowledge, data->Contents);
1094
1095                     RETURN(MUI_EventHandlerRC_Eat);
1096                     return MUI_EventHandlerRC_Eat;
1097                   }
1098
1099                   // see if we should skip the default shorcuts or not
1100                   if(isFlagClear(data->Flags, FLG_NoShortcuts))
1101                   {
1102                     // depending on the pressed key code
1103                     // we perform different actions.
1104                     switch(code)
1105                     {
1106                       case 'g':
1107                       {
1108                         edited = ToggleCaseChar(data);
1109                       }
1110                       break;
1111
1112                       case 'G':
1113                       {
1114                         edited = ToggleCaseWord(data);
1115                       }
1116                       break;
1117
1118                       case 'c':
1119                         CopyBlock(data);
1120                       break;
1121
1122                       case 'x':
1123                         CutBlock(data);
1124                         edited = TRUE;
1125                       break;
1126
1127                       case 'v':
1128                         Paste(data);
1129                         edited = TRUE;
1130                       break;
1131
1132                       case 'i':
1133                       {
1134                         if((edited = IncreaseNearNumber(data)) == FALSE)
1135                           DisplayBeep(NULL);
1136                       }
1137                       break;
1138
1139                       case 'd':
1140                       {
1141                         if((edited = DecreaseNearNumber(data)) == FALSE)
1142                           DisplayBeep(NULL);
1143                       }
1144                       break;
1145
1146                       case '#':
1147                       {
1148                         if((edited = HexToDec(data)) == FALSE)
1149                           DisplayBeep(NULL);
1150                       }
1151                       break;
1152
1153                       case '$':
1154                       {
1155                         if((edited = DecToHex(data)) == FALSE)
1156                           DisplayBeep(NULL);
1157                       }
1158                       break;
1159
1160                       case 'q':
1161                       {
1162                         RevertToOriginal(data);
1163                         edited = TRUE;
1164                       }
1165                       break;
1166
1167                       case 'z':
1168                       case 'Z':
1169                       {
1170                         if(data->Undo && (((code == 'Z') && isFlagSet(data->Flags, FLG_RedoAvailable)) ||
1171                                           ((code == 'z') && isFlagClear(data->Flags, FLG_RedoAvailable))))
1172                         {
1173                           UndoRedo(data);
1174                           edited = TRUE;
1175                         }
1176                         else
1177                           DisplayBeep(NULL);
1178                       }
1179                       break;
1180
1181                       default:
1182                         clearFlag(msg->imsg->Qualifier, IEQUALIFIER_RSHIFT);
1183                         RETURN(0);
1184                         return 0;
1185                     }
1186                   }
1187                   else
1188                   {
1189                     clearFlag(msg->imsg->Qualifier, IEQUALIFIER_RSHIFT);
1190                     RETURN(0);
1191                     return 0;
1192                   }
1193                 }
1194               }
1195             }
1196             break;
1197           }
1198         }
1199
1200         if(data->FNCBuffer && !FNC)
1201         {
1202           struct FNCData *fncbuffer = data->FNCBuffer, *fncframe;
1203
1204           while(fncbuffer)
1205           {
1206             fncframe = fncbuffer;
1207             fncbuffer = fncbuffer->next;
1208             SharedPoolFree(fncframe);
1209           }
1210           data->FNCBuffer = NULL;
1211         }
1212
1213         if(movement && isFlagSet(msg->imsg->Qualifier, IEQUALIFIER_CONTROL))
1214           setFlag(data->Flags, FLG_BlockEnabled);
1215         else
1216           clearFlag(data->Flags, FLG_BlockEnabled);
1217
1218         if(isFlagSet(data->Flags, FLG_BlockEnabled))
1219           data->BlockStop = data->BufferPos;
1220
1221         MUI_Redraw(obj, MADF_DRAWUPDATE);
1222
1223         if(edited == TRUE)
1224           TriggerNotify(cl, obj);
1225
1226         result = MUI_EventHandlerRC_Eat;
1227       }
1228       else
1229       {
1230         if(data->CtrlChar && ConvertKey(msg->imsg) == data->CtrlChar)
1231         {
1232           set(_win(obj), MUIA_Window_ActiveObject, obj);
1233           result = MUI_EventHandlerRC_Eat;
1234         }
1235       }
1236     }
1237     else
1238     {
1239       D(DBF_INPUT, "%08lx: keycode: %08lx (%ld) %08lx (%ld)", obj, msg->imsg->Code, isFlagSet(data->Flags, FLG_Active), RAWKEY_TAB, msg->imsg->Code <= IECODE_KEY_CODE_LAST);
1240
1241       // check if the user pressed the TAB key for cycling to the next
1242       // mui object and if this object is part of the cyclechain
1243       if(msg->imsg->Class == IDCMP_RAWKEY && isFlagSet(data->Flags, FLG_Active) && isFlagSet(data->Flags, FLG_FreshActive))
1244       {
1245         // clear the FreshActive flag
1246         clearFlag(data->Flags, FLG_FreshActive);
1247         // no need to do an DoAction(SelectAll), because this effectively has been
1248         // done during MUIM_GoActive already
1249       }
1250
1251       // we check if this is a mousemove input message and if
1252       // so we check whether the mouse is currently over our
1253       // texteditor object or not.
1254       if(msg->imsg->Class == IDCMP_MOUSEMOVE)
1255       {
1256         BOOL isOverObject = FALSE;
1257
1258         D(DBF_INPUT, "IDCMP_MOUSEMOVE");
1259         if(_isinobject(obj, msg->imsg->MouseX, msg->imsg->MouseY))
1260         {
1261           #if defined(__MORPHOS__)
1262           if(IS_MORPHOS2)
1263             isOverObject = TRUE;
1264           #endif
1265
1266           if(isOverObject == FALSE)
1267           {
1268             struct Layer_Info *li = &(_screen(obj)->LayerInfo);
1269             struct Layer *layer;
1270
1271             // get the layer that belongs to the current mouse coordinates
1272             LockLayerInfo(li);
1273             layer = WhichLayer(li, _window(obj)->LeftEdge + msg->imsg->MouseX, _window(obj)->TopEdge + msg->imsg->MouseY);
1274             UnlockLayerInfo(li);
1275
1276             // if the mouse is currently over the object and over the object's
1277             // window we go and change the pointer to show the selection pointer
1278             if(layer != NULL && layer->Window == _window(obj))
1279               isOverObject = TRUE;
1280           }
1281         }
1282
1283         if(isOverObject == TRUE)
1284           ShowSelectPointer(obj, data);
1285         else
1286           HideSelectPointer(obj, data);
1287       }
1288       else if(msg->imsg->Class == IDCMP_MOUSEBUTTONS)
1289       {
1290         D(DBF_INPUT, "IDCMP_MOUSEBUTTONS");
1291         if(msg->imsg->Code == (IECODE_LBUTTON | IECODE_UP_PREFIX))
1292         {
1293           // forget the pressed mouse button
1294           clearFlag(data->Flags, FLG_MouseButtonDown);
1295
1296           if(isAnyFlagSet(data->ehnode.ehn_Events, /*IDCMP_MOUSEMOVE|*/IDCMP_INTUITICKS))
1297           {
1298             DoMethod(_win(obj), MUIM_Window_RemEventHandler, &data->ehnode);
1299          // clearFlag(data->ehnode.ehn_Events, IDCMP_MOUSEMOVE);
1300             clearFlag(data->ehnode.ehn_Events, IDCMP_INTUITICKS);
1301             DoMethod(_win(obj), MUIM_Window_AddEventHandler, &data->ehnode);
1302           }
1303
1304           // make sure to select the whole content in case the object was freshly activated
1305           // and the user just released the mousebutton (no matter if inside or outside)
1306           if(isFlagSet(data->Flags, FLG_FreshActive) && BlockEnabled(data) == FALSE &&
1307              ((data->SelectOnActive == TRUE && isFlagClear(data->Flags, FLG_ForceSelectOff)) || isFlagSet(data->Flags, FLG_ForceSelectOn)))
1308           {
1309             DoMethod(obj, MUIM_BetterString_DoAction, MUIV_BetterString_DoAction_SelectAll);
1310           }
1311
1312 #ifdef ALLOW_OUTSIDE_MARKING
1313           if(isFlagSet(data->Flags, FLG_Active) && isFlagSet(data->Flags, FLG_DragOutside))
1314           {
1315             Object *active;
1316             get(_win(obj), MUIA_Window_ActiveObject, &active);
1317             if(obj != active)
1318               E(DBF_STARTUP, "MUI error: %lx, %lx", active, obj);
1319
1320             WORD x = _mleft(obj);
1321             WORD y = _mtop(obj);
1322             WORD width = _mwidth(obj);
1323             WORD height = _font(obj)->tf_YSize;
1324
1325             if(!(msg->imsg->MouseX >= x && msg->imsg->MouseX < x+width && msg->imsg->MouseY >= y && msg->imsg->MouseY < y+height))
1326             {
1327               D(DBF_STARTUP, "Detected LMB+up outside (drag: %ld)", isFlagSet(data->Flags, FLG_DragOutside));
1328               set(_win(obj), MUIA_Window_ActiveObject, MUIV_Window_ActiveObject_None);
1329             }
1330           }
1331 #endif
1332
1333           // clear the FreshActive flag
1334           clearFlag(data->Flags, FLG_FreshActive);
1335         }
1336         else if(msg->imsg->Code == IECODE_LBUTTON)
1337         {
1338           WORD x = _mleft(obj);
1339           WORD y = _mtop(obj);
1340           WORD width = _mwidth(obj);
1341           WORD height = _font(obj)->tf_YSize;
1342
1343           // remember the pressed mouse button
1344           setFlag(data->Flags, FLG_MouseButtonDown);
1345
1346           if(msg->imsg->MouseX >= x && msg->imsg->MouseX < x+width && msg->imsg->MouseY >= y && msg->imsg->MouseY < y+height)
1347           {
1348             WORD offset = msg->imsg->MouseX - x;
1349             struct TextExtent tExtend;
1350
1351             offset -= AlignOffset(obj, data);
1352
1353             SetFont(&data->rport, _font(obj));
1354             data->BufferPos = data->DisplayPos + TextFit(&data->rport, data->Contents+data->DisplayPos, StringLength-data->DisplayPos, &tExtend, NULL, 1, offset+1, _font(obj)->tf_YSize);
1355
1356             if(data->BufferPos == data->BufferLastPos &&
1357                DoubleClick(data->StartSecs, data->StartMicros, msg->imsg->Seconds, msg->imsg->Micros))
1358             {
1359               // on a secret gadget we skip clickcount step 1 as
1360               // it might be misused to guess the words in the gadget.
1361               if(isFlagSet(data->Flags, FLG_Secret) && data->ClickCount == 0)
1362                 data->ClickCount++;
1363
1364               data->ClickCount++;
1365             }
1366             else if((data->SelectOnActive == TRUE && isFlagClear(data->Flags, FLG_ForceSelectOff)) ||
1367                     isFlagSet(data->Flags, FLG_ForceSelectOn))
1368             {
1369               // special handling for the "select on active" feature
1370               // this makes it possible to start a selection upon the first click within
1371               // the object *and* a full selection
1372               data->ClickCount = 3;
1373             }
1374             else
1375             {
1376               data->ClickCount = 0;
1377             }
1378
1379             // lets save the current bufferpos to the lastpos variable
1380             data->BufferLastPos = data->BufferPos;
1381
1382             data->StartSecs  = msg->imsg->Seconds;
1383             data->StartMicros  = msg->imsg->Micros;
1384
1385             switch(data->ClickCount)
1386             {
1387               case 0:
1388               {
1389                 if(isFlagClear(data->Flags, FLG_BlockEnabled) || isFlagClear(msg->imsg->Qualifier, IEQUALIFIER_CONTROL))
1390                   data->BlockStart = data->BufferPos;
1391               }
1392               break;
1393
1394               case 1:
1395               {
1396                 if(data->Contents[data->BufferPos] != '\0')
1397                 {
1398                   UWORD start = data->BufferPos;
1399                   UWORD stop  = data->BufferPos;
1400                   ULONG alpha = IsAlNum(data->locale, (UBYTE)*(data->Contents+data->BufferPos));
1401
1402                   while(start > 0 && alpha == (ULONG)IsAlNum(data->locale, (UBYTE)*(data->Contents+start-1)))
1403                     start--;
1404
1405                   while(alpha == (ULONG)IsAlNum(data->locale, (UBYTE)*(data->Contents+stop)) && *(data->Contents+stop) != '\0')
1406                     stop++;
1407
1408                   data->BlockStart = start;
1409                   data->BufferPos = stop;
1410                 }
1411               }
1412               break;
1413
1414               case 2:
1415               {
1416                 data->BlockStart = 0;
1417                 data->BufferPos = strlen(data->Contents);
1418               }
1419               break;
1420
1421               case 3:
1422               {
1423                 data->BlockStart = data->BufferPos;
1424                 data->ClickCount = 0;
1425               }
1426               break;
1427             }
1428             data->BlockStop = data->BufferPos;
1429             setFlag(data->Flags, FLG_BlockEnabled);
1430
1431             DoMethod(_win(obj), MUIM_Window_RemEventHandler, &data->ehnode);
1432          // setFlag(data->ehnode.ehn_Events, IDCMP_MOUSEMOVE);
1433             setFlag(data->ehnode.ehn_Events, IDCMP_INTUITICKS);
1434             DoMethod(_win(obj), MUIM_Window_AddEventHandler, &data->ehnode);
1435
1436             if(isFlagSet(data->Flags, FLG_Active))
1437               MUI_Redraw(obj, MADF_DRAWUPDATE);
1438             else
1439             {
1440               // set the active flag now already
1441               // this will be checked in MUIM_GoActive to distinguish between
1442               // activation by mouse and by keyboard/application
1443               setFlag(data->Flags, FLG_Active);
1444               set(_win(obj), MUIA_Window_ActiveObject, obj);
1445             }
1446
1447             result = MUI_EventHandlerRC_Eat;
1448           }
1449           else
1450           {
1451             data->ClickCount = 0;
1452             if(isFlagSet(data->Flags, FLG_Active) && isFlagClear(data->Flags, FLG_StayActive))
1453             {
1454 #ifdef ALLOW_OUTSIDE_MARKING
1455               D(DBF_STARTUP, "Clicked outside gadget");
1456               setFlag(data->Flags, FLG_DragOutside);
1457
1458            // DoMethod(_win(obj), MUIM_Window_RemEventHandler, &data->ehnode);
1459            // data->ehnode.ehn_Events |= IDCMP_MOUSEMOVE;
1460            // DoMethod(_win(obj), MUIM_Window_AddEventHandler, &data->ehnode);
1461 #else
1462               set(_win(obj), MUIA_Window_ActiveObject, MUIV_Window_ActiveObject_None);
1463 #endif
1464             }
1465           }
1466         }
1467       }
1468       else
1469       {
1470 #ifdef ALLOW_OUTSIDE_MARKING
1471         if(msg->imsg->Class == IDCMP_MOUSEMOVE)
1472         {
1473           clearFlag(data->Flags, FLG_DragOutside);
1474           D(DBF_STARTUP, "Detected drag");
1475         }
1476 #endif
1477         if((/*msg->imsg->Class == IDCMP_MOUSEMOVE ||*/ msg->imsg->Class == IDCMP_INTUITICKS) && isFlagSet(data->Flags, FLG_Active))
1478         {
1479           WORD x, width, mousex;
1480           struct TextExtent tExtend;
1481
1482           x = _mleft(obj);
1483           mousex = msg->imsg->MouseX - AlignOffset(obj, data);
1484           width = _mwidth(obj);
1485
1486           SetFont(&data->rport, _font(obj));
1487
1488           switch(data->ClickCount)
1489           {
1490             case 0:
1491             {
1492               if(mousex < x)
1493               {
1494                 if(data->DisplayPos)
1495                   data->DisplayPos--;
1496                 data->BufferPos = data->DisplayPos;
1497               }
1498               else
1499               {
1500                 if(mousex >= x+width)
1501                 {
1502                   if(data->DisplayPos < StringLength)
1503                   {
1504                     data->DisplayPos++;
1505                     data->BufferPos = data->DisplayPos + TextFit(&data->rport, data->Contents+data->DisplayPos, StringLength-data->DisplayPos, &tExtend, NULL, 1, _mwidth(obj), _font(obj)->tf_YSize);
1506                   }
1507                   else
1508                   {
1509                     data->BufferPos = StringLength;
1510                   }
1511                 }
1512                 else
1513                 {
1514                     WORD offset = mousex - x;
1515
1516 /*                  if(offset < 0)
1517                     data->BufferPos = 0;
1518                   else
1519 */                  data->BufferPos = data->DisplayPos + TextFit(&data->rport, data->Contents+data->DisplayPos, StringLength-data->DisplayPos, &tExtend, NULL, 1, offset+1, _font(obj)->tf_YSize);
1520                 }
1521               }
1522               data->BlockStop = data->BufferPos;
1523               MUI_Redraw(obj, MADF_DRAWUPDATE);
1524             }
1525             break;
1526
1527             case 1:
1528             {
1529               WORD offset = mousex - x;
1530               WORD newpos = 0;
1531
1532               if(mousex < x && data->DisplayPos)
1533               {
1534                 data->DisplayPos--;
1535                 newpos = data->DisplayPos;
1536               }
1537               else
1538               {
1539 //                offset -= AlignOffset(obj, data);
1540                 if(offset > 0)
1541                   newpos = data->DisplayPos + TextFit(&data->rport, data->Contents+data->DisplayPos, StringLength-data->DisplayPos, &tExtend, NULL, 1, offset+1, _font(obj)->tf_YSize);
1542               }
1543
1544               if(newpos >= data->BlockStart)
1545               {
1546                 while(IsAlNum(data->locale, (UBYTE)*(data->Contents+newpos)))
1547                   newpos++;
1548               }
1549               else
1550               {
1551                 while(newpos > 0 && IsAlNum(data->locale, (UBYTE)*(data->Contents+newpos-1)))
1552                   newpos--;
1553               }
1554
1555               if(data->BufferPos != newpos)
1556               {
1557                 data->BlockStop = data->BufferPos = newpos;
1558                 MUI_Redraw(obj, MADF_DRAWUPDATE);
1559               }
1560             }
1561             break;
1562           }
1563         }
1564       }
1565     }
1566   }
1567
1568   RETURN(result);
1569   return result;
1570 }
1571
1572 IPTR mInsert(struct IClass *cl, Object *obj, struct MUIP_BetterString_Insert *msg)
1573 {
1574   struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
1575   UWORD pos;
1576
1577   ENTER();
1578
1579   switch(msg->pos)
1580   {
1581 /*
1582     case MUIV_BetterString_Insert_StartOfString:
1583       pos = 0;
1584     break;
1585 */
1586
1587     case MUIV_BetterString_Insert_EndOfString:
1588       pos = strlen(data->Contents);
1589     break;
1590
1591     case MUIV_BetterString_Insert_BufferPos:
1592       pos = data->BufferPos;
1593     break;
1594
1595     default:
1596       pos = msg->pos;
1597     break;
1598   }
1599
1600   Overwrite(msg->text, pos, 0, data);
1601   clearFlag(data->Flags, FLG_BlockEnabled);
1602   MUI_Redraw(obj, MADF_DRAWUPDATE);
1603   // trigger a notification as we just changed the contents
1604   TriggerNotify(cl, obj);
1605
1606   RETURN(TRUE);
1607   return TRUE;
1608 }