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