workbench/classes/zune/texteditor/mcc/ExportHook.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 <stdio.h>
  24 #include <string.h>
  25
  26 #include <exec/memory.h>
  27 #include <proto/exec.h>
  28
  29 #include "private.h"
  30 #include "Debug.h"
  31
  32 struct Buffer
  33 {
  34   STRPTR  buffer;
  35   STRPTR  pointer;
  36   ULONG   flow;
  37   ULONG   size;
  38 };
  39
  40 /// ExportHookFunc()
  41 HOOKPROTONO(ExportHookFunc, STRPTR, struct ExportMessage *emsg)
  42 {
  43   struct Buffer *buf = emsg->UserData;
  44   struct InstData *data = emsg->data;
  45   STRPTR result = NULL;
  46
  47   ENTER();
  48
  49   // create a temporary buffer if we don't have one yet
  50   if(buf == NULL)
  51   {
  52     if((buf = AllocVecShared(sizeof(*buf), MEMF_CLEAR)) != NULL)
  53     {
  54       if(data != NULL)
  55       {
  56         // respect our pool's threshold size
  57         buf->buffer = AllocVecPooled(data->mypool, 512);
  58         buf->size = 512;
  59       }
  60       else
  61       {
  62         buf->buffer = AllocVecShared(1024, MEMF_CLEAR);
  63         buf->size = 1024;
  64       }
  65     }
  66
  67     if(buf != NULL)
  68     {
  69       buf->pointer = buf->buffer;
  70       buf->flow = 0;
  71     }
  72   }
  73
  74   if(buf != NULL && buf->buffer != NULL)
  75   {
  76     LONG expand = emsg->Length * 10;
  77
  78     if(buf->buffer+buf->size < buf->pointer+expand)
  79     {
  80       // remember the current buffer, size and offset
  81       STRPTR oldbuf = buf->buffer;
  82       ULONG oldsize = buf->size;
  83       ULONG offset = buf->pointer - oldbuf;
  84
  85       // allocate an expanded buffer
  86       if(data != NULL)
  87       {
  88         // respect our pool's threshold size
  89         buf->buffer = AllocVecPooled(data->mypool, oldsize+expand+512);
  90         buf->size = oldsize+expand+512;
  91       }
  92       else
  93       {
  94         buf->buffer = AllocVecShared(oldsize+expand+1024, MEMF_CLEAR);
  95         buf->size = oldsize+expand+1024;
  96       }
  97
  98       if(buf->buffer != NULL)
  99       {
 100         buf->pointer = buf->buffer+offset;
 101
 102         memcpy(buf->buffer, oldbuf, offset);
 103       }
 104       else
 105       {
 106         W(DBF_BLOCK, "failed to allocate temporary buffer");
 107         emsg->failure = TRUE;
 108       }
 109
 110       // free the old buffer
 111       if(data != NULL)
 112         FreeVecPooled(data->mypool, oldbuf);
 113       else
 114         FreeVec(oldbuf);
 115     }
 116
 117     if(emsg->failure == FALSE)
 118     {
 119       LONG length;
 120       struct LineStyle *styles = emsg->Styles;
 121       struct LineColor *colors = emsg->Colors;
 122       LONG lastpos = 0;
 123       UWORD currentstyle = 0;
 124       ULONG hookType = (IPTR)hook->h_Data;
 125       STRPTR startx;
 126
 127       // if this hook is of plain type we have consider highlighting as well.
 128       if(hookType == MUIV_TextEditor_ExportHook_Plain && emsg->Highlight == TRUE)
 129       {
 130         *buf->pointer++ = '\033';
 131         *buf->pointer++ = 'h';
 132       }
 133
 134       if(hookType == MUIV_TextEditor_ExportHook_Plain && emsg->Flow != buf->flow)
 135       {
 136         *buf->pointer++ = '\033';
 137
 138         switch(emsg->Flow)
 139         {
 140           case MUIV_TextEditor_Flow_Right:
 141             *buf->pointer++ = 'r';
 142           break;
 143
 144           case MUIV_TextEditor_Flow_Center:
 145             *buf->pointer++ = 'c';
 146           break;
 147
 148           case MUIV_TextEditor_Flow_Left:
 149           default:
 150             *buf->pointer++ = 'l';
 151           break;
 152         }
 153
 154         buf->flow = emsg->Flow;
 155       }
 156
 157       if(emsg->Separator != LNSF_None)
 158       {
 159         if(hookType == MUIV_TextEditor_ExportHook_Plain)
 160           snprintf(buf->pointer, buf->size-(buf->pointer-buf->buffer), "\033[s:%d]", emsg->Separator);
 161         else
 162           strlcpy(buf->pointer, isFlagSet(emsg->Separator, LNSF_Thick) ? "<tsb>" : "<sb>", buf->size-(buf->pointer-buf->buffer));
 163
 164         buf->pointer += strlen(buf->pointer);
 165       }
 166
 167       // define some start values.
 168       startx = buf->pointer;
 169       length = emsg->Length-emsg->SkipFront-emsg->SkipBack;
 170       lastpos = emsg->SkipFront;
 171
 172       if((styles != NULL || colors != NULL) &&
 173          (hookType == MUIV_TextEditor_ExportHook_EMail || hookType == MUIV_TextEditor_ExportHook_Plain))
 174       {
 175         LONG pos;
 176         WORD style;
 177         BOOL coloured = FALSE;
 178         UWORD colour_state = 7;
 179         LONG nextStyleColumn;
 180         LONG nextColorColumn;
 181
 182         if(styles == NULL)
 183           nextStyleColumn = EOS;
 184         else
 185           nextStyleColumn = styles[0].column;
 186
 187         if(colors == NULL)
 188           nextColorColumn = EOC;
 189         else
 190           nextColorColumn = colors[0].column;
 191
 192         while(length > 0 && (nextStyleColumn != EOS || nextColorColumn != EOC))
 193         {
 194           BOOL isColorChange;
 195           LONG len;
 196
 197           SHOWVALUE(DBF_EXPORT, nextStyleColumn);
 198           SHOWVALUE(DBF_EXPORT, nextColorColumn);
 199
 200           // check whether a style change or a color change is first to be handled
 201           if((coloured == TRUE  && nextStyleColumn <  nextColorColumn) ||
 202              (coloured == FALSE && nextStyleColumn <= nextColorColumn))
 203           {
 204             pos = styles->column - 1;
 205             style = styles->style;
 206             isColorChange = FALSE;
 207             // remember the next style change column
 208             styles++;
 209             nextStyleColumn = styles->column;
 210           }
 211           else
 212           {
 213             pos = colors->column - 1;
 214             style = colors->color;
 215             isColorChange = TRUE;
 216             // remember the next style change column
 217             colors++;
 218             nextColorColumn = colors->column;
 219           }
 220
 221           // skip styles&colors which below lastpos
 222           if(pos < lastpos)
 223             continue;
 224
 225           // depending on how much we export
 226           // we have to fire up the style convert routines.
 227           if(pos-lastpos <= length)
 228           {
 229             len = pos-lastpos;
 230             memcpy(buf->pointer, emsg->Contents+lastpos, len);
 231             buf->pointer += len;
 232
 233             if(hookType == MUIV_TextEditor_ExportHook_EMail)
 234             {
 235               if(isColorChange == TRUE)
 236               {
 237                 if((coloured = (style == colour_state ? TRUE : FALSE)))
 238                 {
 239                   *buf->pointer++ = '#';
 240                   colour_state ^= 7;
 241                 }
 242               }
 243               else
 244               {
 245                 switch(style)
 246                 {
 247                   case UNDERLINE:
 248                   case ~UNDERLINE:
 249                   {
 250                     *buf->pointer++ = '_';
 251                   }
 252                   break;
 253
 254                   case BOLD:
 255                   case ~BOLD:
 256                   {
 257                     *buf->pointer++ = '*';
 258                   }
 259                   break;
 260
 261                   case ITALIC:
 262                   case ~ITALIC:
 263                   {
 264                     *buf->pointer++ = '/';
 265                   }
 266                   break;
 267                 }
 268               }
 269             }
 270             else if(hookType == MUIV_TextEditor_ExportHook_Plain)
 271             {
 272               if(isColorChange == TRUE)
 273               {
 274                 D(DBF_EXPORT, "exporting color %ld of column %ld", style, pos+1);
 275                 snprintf(buf->pointer, buf->size-(buf->pointer-buf->buffer), "\033p[%d]", style);
 276                 buf->pointer += strlen(buf->pointer);
 277               }
 278               else
 279               {
 280                 switch(style)
 281                 {
 282                   case BOLD:
 283                   {
 284                     D(DBF_EXPORT, "exporting bold style of column %ld", pos+1);
 285                     *buf->pointer++ = '\033';
 286                     *buf->pointer++ = 'b';
 287                     setFlag(currentstyle, BOLD);
 288                   }
 289                   break;
 290
 291                   case ITALIC:
 292                   {
 293                     D(DBF_EXPORT, "exporting italic style of column %ld", pos+1);
 294                     *buf->pointer++ = '\033';
 295                     *buf->pointer++ = 'i';
 296                     setFlag(currentstyle, ITALIC);
 297                   }
 298                   break;
 299
 300                   case UNDERLINE:
 301                   {
 302                     D(DBF_EXPORT, "exporting underline style of column %ld", pos+1);
 303                     *buf->pointer++ = '\033';
 304                     *buf->pointer++ = 'u';
 305                     setFlag(currentstyle, UNDERLINE);
 306                   }
 307                   break;
 308
 309                   case ~BOLD:
 310                   case ~ITALIC:
 311                   case ~UNDERLINE:
 312                   {
 313                     currentstyle &= style;
 314
 315                     if(pos+1 != styles->column || styles->style < 0x8000)
 316                     {
 317                       D(DBF_EXPORT, "exporting plain style of column %ld", pos+1);
 318                       *buf->pointer++ = '\033';
 319                       *buf->pointer++ = 'n';
 320
 321                       if(isFlagSet(currentstyle, UNDERLINE))
 322                       {
 323                         *buf->pointer++ = '\033';
 324                         *buf->pointer++ = 'u';
 325                       }
 326
 327                       if(isFlagSet(currentstyle, BOLD))
 328                       {
 329                         *buf->pointer++ = '\033';
 330                         *buf->pointer++ = 'b';
 331                       }
 332
 333                       if(isFlagSet(currentstyle, ITALIC))
 334                       {
 335                         *buf->pointer++ = '\033';
 336                         *buf->pointer++ = 'i';
 337                       }
 338                     }
 339                   }
 340                   break;
 341                 }
 342               }
 343             }
 344           }
 345           else
 346           {
 347             len = length;
 348             memcpy(buf->pointer, emsg->Contents+lastpos, len);
 349             buf->pointer += len;
 350           }
 351
 352           length -= len;
 353
 354           if(length == -1)
 355             length = 0;
 356
 357           lastpos = pos;
 358         }
 359       }
 360
 361       if(length > 0)
 362       {
 363         memcpy(buf->pointer, emsg->Contents+lastpos, length);
 364         buf->pointer += length;
 365       }
 366
 367       // NUL terminate our buffer string
 368       *buf->pointer = '\0';
 369
 370       while(emsg->ExportWrap != 0 && buf->pointer-startx > emsg->ExportWrap)
 371       {
 372         LONG max = emsg->ExportWrap+1;
 373
 374         if(startx[emsg->ExportWrap] != '\n')
 375         {
 376           while(--max && *(startx+max) != ' ')
 377             ; // empty while
 378         }
 379
 380         if(max)
 381         {
 382           *(startx += max) = '\n';
 383         }
 384         else
 385         {
 386           while(++startx < buf->pointer && *(startx) != ' ')
 387             ; // empty while
 388
 389           if(buf->pointer != startx)
 390           {
 391             *startx = '\n';
 392           }
 393         }
 394       }
 395     }
 396
 397     if(emsg->Last == TRUE)
 398     {
 399       // free the temporary struct after we processed the last line
 400       result = buf->buffer;
 401       FreeVec(buf);
 402     }
 403     else
 404     {
 405       // return the temporary struct for the next call
 406       result = (STRPTR)buf;
 407     }
 408   }
 409   else
 410   {
 411     W(DBF_BLOCK, "failed to allocate temporary buffer");
 412     SHOWVALUE(DBF_BLOCK, buf);
 413     if(buf != NULL)
 414       SHOWVALUE(DBF_BLOCK, buf->buffer);
 415     emsg->failure = TRUE;
 416   }
 417
 418   RETURN(result);
 419   return result;
 420 }
 421
 422 MakeHookWithData(ExportHookPlain, ExportHookFunc, MUIV_TextEditor_ExportHook_Plain);
 423 MakeHookWithData(ExportHookEMail, ExportHookFunc, MUIV_TextEditor_ExportHook_EMail);
 424 MakeHookWithData(ExportHookNoStyle, ExportHookFunc, MUIV_TextEditor_ExportHook_NoStyle);
 425
 426 ///