workbench/classes/zune/texteditor/mcc/ImportHook.c

   1 /***************************************************************************
   2
   3  TextEditor.mcc - Textediting MUI Custom Class
   4  Copyright (C) 1997-2000 Allan Odgaard
   5  Copyright (C) 2005-2014 TextEditor.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  TextEditor class Support Site:  http://www.sf.net/projects/texteditor-mcc
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #include <string.h>
  24
  25 #include <proto/dos.h>
  26 #include <proto/exec.h>
  27
  28 #include "private.h"
  29 #include "Debug.h"
  30
  31 /*************************************************************************/
  32
  33
  34
  35 /*************************************************************************/
  36 /// GetHex()
  37 static LONG GetHex(const char *src)
  38 {
  39   LONG result = -1;
  40
  41   ENTER();
  42
  43   if((src[0] >= '0' && src[0] <= '9'))
  44     result = src[0] - '0';
  45   else if((src[0] >= 'a' && src[0] <= 'f'))
  46     result = src[0] - 'a' + 10;
  47   else if((src[0] >= 'A' && src[0] <= 'F'))
  48     result = src[0] - 'A' + 10;
  49
  50   RETURN(result);
  51   return result;
  52 }
  53
  54 ///
  55 /// GetQP()
  56 /************************************************************************
  57  Convert a =XX string to its value (into *val). Returns TRUE if
  58  conversion was successful; in that case *src_ptr will be advanced as well.
  59 *************************************************************************/
  60 static BOOL GetQP(const char **src_ptr, unsigned char *val)
  61 {
  62   unsigned char v;
  63   const char *src = *src_ptr;
  64   int rc;
  65   BOOL result = FALSE;
  66
  67   ENTER();
  68
  69   if((rc = GetHex(src)) != -1)
  70   {
  71     v = rc << 4;
  72
  73     if((rc = GetHex(src)) != -1)
  74     {
  75       v |= rc;
  76       *val = v;
  77       *src_ptr = src + 2;
  78
  79       result = TRUE;
  80     }
  81   }
  82
  83   RETURN(result);
  84   return result;
  85 }
  86
  87 ///
  88 /// GetLong()
  89 /************************************************************************
  90  Reads out the next value at *src_ptr and advances src_ptr.
  91  Returns TRUE if succedded else FALSE
  92 *************************************************************************/
  93 static BOOL GetLong(const char **src_ptr, LONG *val)
  94 {
  95   LONG chars;
  96   BOOL result = FALSE;
  97
  98   ENTER();
  99
 100   if((chars = StrToLong(*src_ptr, val)) != -1)
 101   {
 102     *src_ptr += chars;
 103
 104     result = TRUE;
 105   }
 106
 107   RETURN(result);
 108   return result;
 109 }
 110
 111 ///
 112 /// FindEOL()
 113 /************************************************************************
 114  Returns the end of line in the current line (pointing at the linefeed).
 115  If a 0 byte is encountered it returns the pointer to the 0 byte.
 116
 117  This function also counts the number of tabs within this line.
 118 *************************************************************************/
 119 static const char *FindEOL(const char *src, int *tabs_ptr)
 120 {
 121   int tabs = 0;
 122   char c;
 123   const char *eol = src;
 124
 125   ENTER();
 126
 127   while((c = *eol) != '\0')
 128   {
 129     if(c == '\t')
 130       tabs++;
 131     else if(c == '\r' || c == '\n')
 132       break;
 133
 134     eol++;
 135   }
 136
 137   if(tabs_ptr != NULL)
 138     *tabs_ptr = tabs;
 139
 140   RETURN(eol);
 141   return eol;
 142 }
 143
 144 ///
 145 /// ContainsText()
 146 /************************************************************************
 147  searches through a string and returns TRUE if the string contains
 148  any text (except newlines) until the stopchar is found
 149 *************************************************************************/
 150 static BOOL ContainsText(const char *str, const char stopchar)
 151 {
 152   BOOL contains = FALSE;
 153
 154   ENTER();
 155
 156   if(str != NULL)
 157   {
 158     while(contains == FALSE && *str >= ' ')
 159     {
 160       if(*str == stopchar)
 161         break;
 162       else if(*str > ' ') // greater than 0x20 (space) == readable text
 163         contains = TRUE;
 164
 165       str++;
 166     }
 167   }
 168
 169   RETURN(contains);
 170   return contains;
 171 }
 172
 173 ///
 174 /// PlainImportHookFunc()
 175 /************************************************************************
 176  The plain import hook. It supports following escape sequences:
 177
 178   <ESC> + u      Set the soft style to underline.
 179   <ESC> + b      Set the soft style to bold.
 180   <ESC> + i      Set the soft style to italic.
 181   <ESC> + n      Set the soft style back to normal.
 182   <ESC> + h      Highlight the current line.
 183   <ESC> + p[x]   Change to color x, where x is taken from the colormap.
 184                  0 means normal. The color is reset for each new line.
 185
 186
 187  The following sequences are only valid at the beginning of a line.
 188
 189   <ESC> + l      Left justify current and following lines.
 190   <ESC> + r      Right justify current and following lines.
 191   <ESC> + c      Center current and following lines.
 192   <ESC> + [s:x]  Create a separator. x is a bit combination of flags:
 193                  Placement (mutually exclusive):
 194                      1 = Top
 195                      2 = Middle
 196                      4 = Bottom
 197                  Cosmetical:
 198                      8 = StrikeThru   - Draw separator ontop of text.
 199                      16 = Thick        - Make separator extra thick.
 200
 201  Note: Tabs are converted to the number of spaces specified in the
 202        TE.mcc object used
 203
 204 *************************************************************************/
 205 HOOKPROTONHNO(PlainImportHookFunc, STRPTR, struct ImportMessage *msg)
 206 {
 207   STRPTR result = NULL;
 208   const char *eol;
 209   const char *src = msg->Data;
 210   int tabs = 0;
 211
 212   ENTER();
 213
 214   // check for a valid TAB size
 215   if(msg->TabSize <= 0)
 216   {
 217     E(DBF_IMPORT, "invalid TAB size %ld", msg->TabSize);
 218     // assume the default TAB size to avoid a division by zero
 219     msg->TabSize = 4;
 220   }
 221
 222   if((eol = FindEOL(src, msg->ConvertTabs == FALSE ? NULL : &tabs)) != NULL)
 223   {
 224     int len;
 225     struct LineNode *line = msg->linenode;
 226     LONG wrap = msg->ImportWrap;
 227     ULONG allocatedContents;
 228
 229     len = eol - src + (msg->TabSize * tabs);
 230
 231     // allocate memory for the contents plus the trailing LF and NUL bytes
 232     allocatedContents = len+2;
 233     if((line->Contents = AllocVecPooled(msg->PoolHandle, allocatedContents)) != NULL)
 234     {
 235       unsigned char *dest_start = (unsigned char *)line->Contents;
 236       unsigned char *dest = dest_start;
 237       unsigned char *dest_word_start = dest_start;
 238       unsigned char *src_word_start = (unsigned char *)src;
 239
 240       /* Style and color state */
 241       int state = 0;
 242
 243       struct Grow style_grow;
 244       struct Grow color_grow;
 245
 246       struct LineStyle newStyle;
 247       struct LineColor newColor;
 248
 249       InitGrow(&style_grow, msg->PoolHandle, sizeof(newStyle));
 250       InitGrow(&color_grow, msg->PoolHandle, sizeof(newColor));
 251
 252       // remember the allocation size
 253       line->allocatedContents = allocatedContents;
 254
 255       // Copy loop
 256       while(src < eol)
 257       {
 258         unsigned char c = *src++;
 259
 260         if(c == '\t' && msg->ConvertTabs == TRUE)
 261         {
 262           LONG i;
 263
 264           for(i=(dest - dest_start) % msg->TabSize; i < msg->TabSize; i++)
 265             *dest++ = ' ';
 266
 267           continue;
 268         }
 269         else if(c == '\033') // ESC sequence
 270         {
 271           c = *src++;
 272           switch(c)
 273           {
 274             case 'b':
 275             {
 276               if(isFlagClear(state, BOLD))
 277               {
 278                 newStyle.column = dest - dest_start + 1;
 279                 newStyle.style = BOLD;
 280                 D(DBF_IMPORT, "adding bold style at column %ld", newStyle.column);
 281                 AddToGrow(&style_grow, &newStyle);
 282                 setFlag(state, BOLD);
 283               }
 284             }
 285             break;
 286
 287             case 'i':
 288             {
 289               if(isFlagClear(state, ITALIC))
 290               {
 291                 newStyle.column = dest - dest_start + 1;
 292                 newStyle.style = ITALIC;
 293                 D(DBF_IMPORT, "adding italic style at column %ld", newStyle.column);
 294                 AddToGrow(&style_grow, &newStyle);
 295                 setFlag(state, ITALIC);
 296               }
 297             }
 298             break;
 299
 300             case 'u':
 301             {
 302               if(isFlagClear(state, UNDERLINE))
 303               {
 304                 newStyle.column = dest - dest_start + 1;
 305                 newStyle.style = UNDERLINE;
 306                 D(DBF_IMPORT, "adding underline style at column %ld", newStyle.column);
 307                 AddToGrow(&style_grow, &newStyle);
 308                 setFlag(state, UNDERLINE);
 309               }
 310             }
 311             break;
 312
 313             case 'h':
 314             {
 315               line->Highlight = TRUE;
 316             }
 317             break;
 318
 319             case 'n':
 320             {
 321               if(isFlagSet(state, BOLD))
 322               {
 323                 newStyle.column = dest - dest_start + 1;
 324                 newStyle.style = ~BOLD;
 325                 D(DBF_IMPORT, "removing bold style at column %ld", newStyle.column);
 326                 AddToGrow(&style_grow, &newStyle);
 327                 clearFlag(state, BOLD);
 328               }
 329               if(isFlagSet(state, ITALIC))
 330               {
 331                 newStyle.column = dest - dest_start + 1;
 332                 newStyle.style = ~ITALIC;
 333                 D(DBF_IMPORT, "removing italic style at column %ld", newStyle.column);
 334                 AddToGrow(&style_grow, &newStyle);
 335                 clearFlag(state, ITALIC);
 336               }
 337               if(isFlagSet(state, UNDERLINE))
 338               {
 339                 newStyle.column = dest - dest_start + 1;
 340                 newStyle.style = ~UNDERLINE;
 341                 D(DBF_IMPORT, "removing italic style at column %ld", newStyle.column);
 342                 AddToGrow(&style_grow, &newStyle);
 343                 clearFlag(state, UNDERLINE);
 344               }
 345             }
 346             break;
 347
 348             case 'l':
 349             {
 350               line->Flow = MUIV_TextEditor_Flow_Left;
 351               D(DBF_IMPORT, "left aligned text flow");
 352             }
 353             break;
 354
 355             case 'c':
 356             {
 357               line->Flow = MUIV_TextEditor_Flow_Center;
 358               D(DBF_IMPORT, "centered flow");
 359             }
 360             break;
 361
 362             case 'r':
 363             {
 364               line->Flow = MUIV_TextEditor_Flow_Right;
 365               D(DBF_IMPORT, "right aligned text flow");
 366             }
 367             break;
 368
 369             case 'p':
 370             {
 371               if(*src == '[')
 372               {
 373                 LONG pen;
 374
 375                 src++;
 376
 377                 if(GetLong(&src, &pen) == TRUE)
 378                 {
 379                   if(*src == ']')
 380                   {
 381                     newColor.column = dest - dest_start + 1;
 382                     newColor.color = pen;
 383                     D(DBF_IMPORT, "adding color %ld at column %ld", newColor.color, newColor.column);
 384                     AddToGrow(&color_grow, &newColor);
 385
 386                     if(pen == 0)
 387                       state ^= COLOURED;
 388                     else
 389                       setFlag(state, COLOURED);
 390
 391                     src++;
 392                   }
 393                 }
 394               }
 395             }
 396             break;
 397
 398             case '[':
 399             {
 400               if(*src == 's')
 401               {
 402                 src++;
 403                 if(*src == ':')
 404                 {
 405                   LONG flags;
 406
 407                   src++;
 408
 409                   if(GetLong(&src, &flags) == TRUE)
 410                   {
 411                     if(*src == ']')
 412                     {
 413                       line->Separator = flags;
 414                       src++;
 415                     }
 416                   }
 417                 }
 418               }
 419             }
 420             break;
 421           }
 422
 423           continue;
 424         }
 425
 426         if(c == ' ')
 427         {
 428           // src is already advanced
 429           src_word_start = (unsigned char *)src;
 430           dest_word_start = dest;
 431         }
 432
 433         if(wrap != 0 && dest - dest_start >= wrap)
 434         {
 435           /* Only leave the loop, if we really have added some characters
 436            * (at least one word) to the line */
 437           if(dest_word_start != dest_start)
 438           {
 439             /* src points to the real word start, but we add one when we return eol */
 440             eol = (char *)(src_word_start - 1);
 441             dest = dest_word_start;
 442             break;
 443           }
 444         }
 445
 446         *dest++ = c;
 447       } /* while (src < eol) */
 448
 449       // terminate the color array, but only if there are any colors at all
 450       if(color_grow.itemCount > 0)
 451       {
 452         // ensure that we terminate the clip with color 0
 453         if(isFlagSet(state, COLOURED))
 454         {
 455           D(DBF_IMPORT, "removing color as termination");
 456           newColor.column = strlen(line->Contents)+1;
 457           newColor.color = 0;
 458           AddToGrow(&color_grow, &newColor);
 459         }
 460
 461         newColor.column = EOC;
 462         newColor.color = 0;
 463         AddToGrow(&color_grow, &newColor);
 464       }
 465
 466       D(DBF_IMPORT, "added %ld color sections", color_grow.itemCount);
 467       line->Colors = (struct LineColor *)color_grow.array;
 468
 469       // terminate the style array, but only if there are any styles at all
 470       if(style_grow.itemCount > 0)
 471       {
 472         LONG lastColumn = strlen(line->Contents)+1;
 473
 474         // ensure that we terminate the clip with plain style
 475         if(isFlagSet(state, BOLD))
 476         {
 477           D(DBF_IMPORT, "removing bold style as termination");
 478           newStyle.column = lastColumn;
 479           newStyle.style = ~BOLD;
 480           AddToGrow(&style_grow, &newStyle);
 481         }
 482         if(isFlagSet(state, ITALIC))
 483         {
 484           D(DBF_IMPORT, "removing italic style as termination");
 485           newStyle.column = lastColumn;
 486           newStyle.style = ~ITALIC;
 487           AddToGrow(&style_grow, &newStyle);
 488         }
 489         if(isFlagSet(state, UNDERLINE))
 490         {
 491           D(DBF_IMPORT, "removing underline style as termination");
 492           newStyle.column = lastColumn;
 493           newStyle.style = ~UNDERLINE;
 494           AddToGrow(&style_grow, &newStyle);
 495         }
 496
 497         newStyle.column = EOS;
 498         newStyle.style = 0;
 499         AddToGrow(&style_grow, &newStyle);
 500       }
 501
 502       D(DBF_IMPORT, "added %ld style sections", style_grow.itemCount);
 503       line->Styles = (struct LineStyle *)style_grow.array;
 504
 505       *dest++ = '\n';
 506       *dest = 0;
 507
 508       line->Length = dest - dest_start; /* this excludes \n */
 509     }
 510
 511     if(eol != NULL && eol[0] != '\0')
 512     {
 513       eol++;
 514       result = (STRPTR)eol;
 515     }
 516   }
 517
 518   RETURN(result);
 519   return result;
 520 }
 521 MakeHook(ImPlainHook, PlainImportHookFunc);
 522
 523 ///
 524 /// MimeImport()
 525 /************************************************************************
 526  The MIME import hook. It supports following escape sequences:
 527
 528   <ESC> + u      Set the soft style to underline.
 529   <ESC> + b      Set the soft style to bold.
 530   <ESC> + i      Set the soft style to italic.
 531   <ESC> + n      Set the soft style back to normal.
 532   <ESC> + h      Highlight the current line.
 533   <ESC> + p[x]   Change to color x, where x is taken from the colormap.
 534                  0 means normal. The color is reset for each new line.
 535
 536
 537  The following sequences are only valid at the beginning of a line.
 538
 539   <ESC> + l      Left justify current and following lines.
 540   <ESC> + r      Right justify current and following lines.
 541   <ESC> + c      Center current and following lines.
 542   <ESC> + [s:x]  Create a separator. x is a bit combination of flags:
 543                  Placement (mutually exclusive):
 544                      1 = Top
 545                      2 = Middle
 546                      4 = Bottom
 547                  Cosmetical:
 548                      8 = StrikeThru   - Draw separator ontop of text.
 549                      16 = Thick        - Make separator extra thick.
 550
 551  Note: Tabs are converted to the number of spaces specified in the
 552        TE.mcc object used
 553
 554 *************************************************************************/
 555 static STRPTR MimeImport(struct ImportMessage *msg, LONG type)
 556 {
 557   STRPTR result = NULL;
 558   const char *eol;
 559   const char *src = msg->Data;
 560   int tabs=0;
 561
 562   ENTER();
 563
 564   if((eol = FindEOL(src, msg->ConvertTabs == FALSE ? NULL : &tabs)) != NULL)
 565   {
 566     int len;
 567     struct LineNode *line = msg->linenode;
 568     LONG wrap = msg->ImportWrap;
 569     ULONG allocatedContents;
 570
 571     len = eol - src + (msg->TabSize * tabs);
 572
 573     // allocate some more memory for the possible quote mark '>', note that if
 574     // a '=' is detected at the end of a line this memory is not sufficient!
 575     allocatedContents = len+4;
 576     if((line->Contents = AllocVecPooled(msg->PoolHandle, allocatedContents)) != NULL)
 577     {
 578       BOOL lastWasSeparator = TRUE;
 579       unsigned char *dest_start = (unsigned char *)line->Contents;
 580       unsigned char *dest = dest_start;
 581       unsigned char *dest_word_start = dest_start;
 582       unsigned char *src_word_start = (unsigned char *)src;
 583
 584       /* Style and color state */
 585       int state = 0;
 586       int escstate = 0;
 587       int shownext = 0;
 588
 589       struct Grow style_grow;
 590       struct Grow color_grow;
 591
 592       struct LineStyle newStyle;
 593       struct LineColor newColor;
 594
 595       InitGrow(&style_grow, msg->PoolHandle, sizeof(newStyle));
 596       InitGrow(&color_grow, msg->PoolHandle, sizeof(newColor));
 597
 598       // remember the allocation size
 599       line->allocatedContents = allocatedContents;
 600
 601       if(src[0] == '>')
 602         line->Highlight = TRUE;
 603       else if(src[0] == '<')
 604       {
 605         if(src[1] == 's' && src[2] == 'b' && src[3] == '>')
 606         {
 607           line->Separator = LNSF_Middle;
 608           src += 4;
 609           line->Flow = MUIV_TextEditor_Flow_Center;
 610           line->clearFlow = TRUE;
 611         }
 612         else if(src[1] == 't' && src[2] == 's' && src[3] == 'b' && src[4] == '>')
 613         {
 614           src += 5;
 615           line->Separator = LNSF_Thick|LNSF_Middle;
 616           line->Flow = MUIV_TextEditor_Flow_Center;
 617           line->clearFlow = TRUE;
 618         }
 619       }
 620
 621       if(type == 2)
 622       {
 623         *dest++ = '>';
 624         line->Highlight = TRUE;
 625       }
 626
 627       // Copy loop
 628       while (src < eol)
 629       {
 630         unsigned char c = *src++;
 631
 632         if(c == '\n')
 633         {
 634           lastWasSeparator = TRUE;
 635         }
 636         else if(c == '\t' && msg->ConvertTabs == TRUE)
 637         {
 638           LONG i;
 639
 640           for(i=(dest - dest_start) % msg->TabSize; i < msg->TabSize; i++)
 641             *dest++ = ' ';
 642
 643           lastWasSeparator = TRUE;
 644
 645           continue;
 646         }
 647         else if(c == '/')
 648         {
 649           if(escstate == 0)
 650           {
 651             if(shownext & ITALIC)
 652               shownext ^= ITALIC;
 653             else if(isFlagSet(state, ITALIC) || (lastWasSeparator == TRUE && ContainsText(src, '/') == TRUE))
 654             {
 655               newStyle.column = dest - dest_start + 1;
 656               newStyle.style = isFlagSet(state, ITALIC) ? ~ITALIC : ITALIC;
 657               AddToGrow(&style_grow, &newStyle);
 658               state ^= ITALIC;
 659
 660               lastWasSeparator = TRUE;
 661               continue;
 662             }
 663             else
 664               shownext |= ITALIC;
 665           }
 666
 667           lastWasSeparator = TRUE;
 668         }
 669         else if(c == '*')
 670         {
 671           if(escstate == 0)
 672           {
 673             if(shownext & BOLD)
 674               shownext ^= BOLD;
 675             else if(isFlagSet(state, BOLD) || (lastWasSeparator == TRUE && ContainsText(src, '*') == TRUE))
 676             {
 677               newStyle.column = dest - dest_start + 1;
 678               newStyle.style = isFlagSet(state, BOLD) ? ~BOLD : BOLD;
 679               AddToGrow(&style_grow, &newStyle);
 680               state ^= BOLD;
 681
 682               lastWasSeparator = TRUE;
 683               continue;
 684             }
 685             else
 686               shownext |= BOLD;
 687           }
 688
 689           lastWasSeparator = TRUE;
 690         }
 691         else if(c == '_')
 692         {
 693           if(escstate == 0)
 694           {
 695             if(shownext & UNDERLINE)
 696               shownext ^= UNDERLINE;
 697             else if(isFlagSet(state, UNDERLINE) || (lastWasSeparator == TRUE && ContainsText(src, '_') == TRUE))
 698             {
 699               newStyle.column = dest - dest_start + 1;
 700               newStyle.style = isFlagSet(state, UNDERLINE) ? ~UNDERLINE : UNDERLINE;
 701               AddToGrow(&style_grow, &newStyle);
 702               state ^= UNDERLINE;
 703
 704               lastWasSeparator = TRUE;
 705               continue;
 706             }
 707             else
 708               shownext |= UNDERLINE;
 709           }
 710
 711           lastWasSeparator = TRUE;
 712         }
 713         else if(c == '#')
 714         {
 715           if(escstate == 0)
 716           {
 717             if(shownext & COLOURED)
 718               shownext ^= COLOURED;
 719             else if(isFlagSet(state, COLOURED) || (lastWasSeparator == TRUE && ContainsText(src, '#') == TRUE))
 720             {
 721               newColor.column = dest - dest_start + 1;
 722               newColor.color = isFlagSet(state, COLOURED) ? 0 : 7;
 723               AddToGrow(&style_grow, &newStyle);
 724               state ^= COLOURED;
 725
 726               lastWasSeparator = TRUE;
 727               continue;
 728             }
 729             else
 730               shownext |= COLOURED;
 731           }
 732
 733           lastWasSeparator = TRUE;
 734         }
 735         else if(c == '=')
 736         {
 737           // This is a concatenated line
 738           if(type > 0 && GetQP(&src, &c) == FALSE)
 739           {
 740             int i;
 741
 742             i = 0;
 743             if(src[0] == '\r')
 744               i++;
 745
 746             if(src[i] == '\n')
 747             {
 748               unsigned char *new_dest_start;
 749
 750               src += i + 1;
 751
 752               if((eol = FindEOL(src, msg->ConvertTabs == FALSE ? NULL : &tabs)) == NULL)
 753                 break;
 754
 755               /* The size of the dest buffer has to be increased now */
 756               len += eol - src + (msg->TabSize * tabs);
 757
 758               if((new_dest_start = (unsigned char*)AllocVecPooled(msg->PoolHandle, len + 4)) == NULL)
 759                 break;
 760
 761               memcpy(new_dest_start, dest_start, dest - dest_start);
 762               FreeVecPooled(msg->PoolHandle,dest_start);
 763
 764               /* Update all dest variables */
 765               dest_word_start = new_dest_start + (dest_word_start - dest_start);
 766               dest = new_dest_start + (dest - dest_start);
 767               line->Contents = (char *)new_dest_start;
 768               dest_start = (unsigned char *)line->Contents;
 769
 770               lastWasSeparator = FALSE;
 771               continue;
 772             }
 773           }
 774         }
 775         else if(c == '\033') // like the plain import hook we manage ESC sequences as well
 776         {
 777           switch(*src++)
 778           {
 779             case 'b':
 780             {
 781               newStyle.column = dest - dest_start + 1;
 782               newStyle.style = BOLD;
 783               AddToGrow(&style_grow, &newStyle);
 784               setFlag(escstate, BOLD);
 785             }
 786             break;
 787
 788             case 'i':
 789             {
 790               newStyle.column = dest - dest_start + 1;
 791               newStyle.style = ITALIC;
 792               AddToGrow(&style_grow, &newStyle);
 793               setFlag(escstate, ITALIC);
 794             }
 795             break;
 796
 797             case 'u':
 798             {
 799               newStyle.column = dest - dest_start + 1;
 800               newStyle.style = UNDERLINE;
 801               AddToGrow(&style_grow, &newStyle);
 802               setFlag(escstate, UNDERLINE);
 803             }
 804             break;
 805
 806             case 'h':
 807             {
 808               line->Highlight = TRUE;
 809             }
 810             break;
 811
 812             case 'n':
 813             {
 814               if(isFlagSet(state, BOLD))
 815               {
 816                 newStyle.column = dest - dest_start + 1;
 817                 newStyle.style = ~BOLD;
 818                 AddToGrow(&style_grow, &newStyle);
 819                 clearFlag(state, BOLD);
 820                 clearFlag(escstate, BOLD);
 821               }
 822               if(isFlagSet(state, ITALIC))
 823               {
 824                 newStyle.column = dest - dest_start + 1;
 825                 newStyle.style = ~ITALIC;
 826                 AddToGrow(&style_grow, &newStyle);
 827                 clearFlag(state, ITALIC);
 828                 clearFlag(escstate, ITALIC);
 829               }
 830               if(isFlagSet(state, UNDERLINE))
 831               {
 832                 newStyle.column = dest - dest_start + 1;
 833                 newStyle.style = ~UNDERLINE;
 834                 AddToGrow(&style_grow, &newStyle);
 835                 clearFlag(state, UNDERLINE);
 836                 clearFlag(escstate, UNDERLINE);
 837               }
 838             }
 839             break;
 840
 841             case 'l':
 842             {
 843               line->Flow = MUIV_TextEditor_Flow_Left;
 844             }
 845             break;
 846
 847             case 'c':
 848             {
 849               line->Flow = MUIV_TextEditor_Flow_Center;
 850             }
 851             break;
 852
 853             case 'r':
 854             {
 855               line->Flow = MUIV_TextEditor_Flow_Right;
 856             }
 857             break;
 858
 859             case 'p':
 860             {
 861               if(*src == '[')
 862               {
 863                 LONG pen;
 864
 865                 src++;
 866
 867                 if(GetLong(&src, &pen) == TRUE)
 868                 {
 869                   if(*src == ']')
 870                   {
 871                     newColor.column = dest - dest_start + 1;
 872                     newColor.color = pen;
 873                     AddToGrow(&color_grow, &newColor);
 874
 875                     if(pen == 0)
 876                       escstate ^= COLOURED;
 877                     else
 878                       escstate |= COLOURED;
 879
 880                     src++;
 881                   }
 882                 }
 883               }
 884             }
 885             break;
 886
 887             case '[':
 888             {
 889               if(*src == 's')
 890               {
 891                 src++;
 892                 if(*src == ':')
 893                 {
 894                   LONG flags;
 895
 896                   src++;
 897
 898                   if(GetLong(&src, &flags) == TRUE)
 899                   {
 900                     if(*src == ']')
 901                     {
 902                       line->Separator = flags;
 903                       src++;
 904                     }
 905                   }
 906                 }
 907               }
 908             }
 909             break;
 910           }
 911
 912           lastWasSeparator = FALSE;
 913           continue;
 914         }
 915
 916         if(c == ' ')
 917         {
 918           /* src is already advanced */
 919           src_word_start = (unsigned char *)src;
 920           dest_word_start = dest;
 921
 922           lastWasSeparator = TRUE;
 923         }
 924         else if(c == '\n')
 925         {
 926           lastWasSeparator = TRUE;
 927         }
 928         else
 929         {
 930           lastWasSeparator = FALSE;
 931         }
 932
 933         if(wrap != 0 && dest - dest_start >= wrap)
 934         {
 935           /* Only leave the loop, if we really have added some characters
 936            * (at least one word) to the line */
 937           if(dest_word_start != dest_start)
 938           {
 939             /* src points to the real word start, but we add one when we return eol */
 940             eol = (char *)(src_word_start - 1);
 941             dest = dest_word_start;
 942             break;
 943           }
 944         }
 945
 946         *dest++ = c;
 947       } /* while (src < eol) */
 948
 949       // terminate the color array, but only if there are any colors at all
 950       if(color_grow.itemCount > 0)
 951       {
 952         newColor.column = EOC;
 953         newColor.color = 0;
 954         AddToGrow(&color_grow, &newColor);
 955       }
 956
 957       line->Colors = (struct LineColor *)color_grow.array;
 958
 959       // terminate the style array, but only if there are any styles at all
 960       if(style_grow.itemCount > 0)
 961       {
 962         newStyle.column = EOS;
 963         newStyle.style = 0;
 964         AddToGrow(&style_grow, &newStyle);
 965       }
 966
 967       line->Styles = (struct LineStyle *)style_grow.array;
 968
 969       *dest++ = '\n';
 970       *dest = 0;
 971
 972       line->Length = dest - dest_start; /* this excludes \n */
 973     }
 974
 975     if(eol != NULL && eol[0] != '\0')
 976     {
 977       eol++;
 978       result = (STRPTR)eol;
 979     }
 980   }
 981
 982   RETURN(result);
 983   return result;
 984 }
 985
 986 ///
 987 /// EMailImportHookFunc()
 988 HOOKPROTONHNO(EMailImportHookFunc, STRPTR , struct ImportMessage *msg)
 989 {
 990   return MimeImport(msg, 0);
 991 }
 992 MakeHook(ImEMailHook, EMailImportHookFunc);
 993
 994 ///
 995 /// MIMEImportHookFunc()
 996 HOOKPROTONHNO(MIMEImportHookFunc, STRPTR, struct ImportMessage *msg)
 997 {
 998   return MimeImport(msg, 1);
 999 }
1000 MakeHook(ImMIMEHook, MIMEImportHookFunc);
1001
1002 ///
1003 /// MIMEQuoteImportHookFunc()
1004 HOOKPROTONHNO(MIMEQuoteImportHookFunc, STRPTR, struct ImportMessage *msg)
1005 {
1006   return MimeImport(msg, 2);
1007 }
1008 MakeHook(ImMIMEQuoteHook, MIMEQuoteImportHookFunc);
1009
1010 ///
1011