workbench/libs/muimaster/classes/floattext.c

   1 /*
   2     Copyright © 2002-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #define DEBUG 0
   9 #include <aros/debug.h>
  10
  11 #include <exec/memory.h>
  12 #include <clib/alib_protos.h>
  13 #include <proto/exec.h>
  14 #include <proto/dos.h>
  15 #include <proto/intuition.h>
  16 #include <proto/utility.h>
  17 #include <proto/muimaster.h>
  18
  19 #include <string.h>
  20
  21 #include "mui.h"
  22 #include "muimaster_intern.h"
  23 #include "support.h"
  24 #include "support_classes.h"
  25 #include "floattext_private.h"
  26
  27 extern struct Library *MUIMasterBase;
  28
  29 // like strlen(), but \n ends string, too.
  30 static long MyStrLen(const char *ptr)
  31 {
  32     const char *start = ptr;
  33
  34     while (*ptr && (*ptr != '\n'))
  35         ptr++;
  36
  37     return (((long)ptr) - ((long)start));
  38 }
  39
  40 static void SetText(Object *obj, struct Floattext_DATA *data)
  41 {
  42     DoMethod(obj, MUIM_List_Clear);
  43
  44     if (data->text)
  45     {
  46         STRPTR pos = data->text;
  47         for (;;)
  48         {
  49             LONG len = MyStrLen(pos);
  50             DoMethod(obj, MUIM_List_InsertSingle, pos,
  51                 MUIV_List_Insert_Bottom);
  52             pos += len;
  53             if (*pos == '\0')
  54                 break;
  55             pos++;
  56         }
  57     }
  58 }
  59
  60 AROS_UFH3S(APTR, construct_func,
  61     AROS_UFHA(struct Hook *, hook, A0),
  62     AROS_UFHA(APTR, pool, A2),
  63     AROS_UFHA(STRPTR, entry, A1))
  64 {
  65     AROS_USERFUNC_INIT
  66
  67     // TODO: MUIA_Floattext_Justify
  68     struct Floattext_DATA *data = hook->h_Data;
  69
  70     STRPTR new;
  71     ULONG tabs = 0;
  72     ULONG i;
  73     ULONG slen = MyStrLen(entry);
  74     ULONG size = slen + 1;
  75
  76     // Count tabulators
  77     for (i = 0; i < slen; i++)
  78     {
  79         if (entry[i] == '\t')
  80             tabs++;
  81     }
  82     size += tabs * data->tabsize;       // Worst case
  83
  84     if ((new = AllocVecPooled(pool, size)))
  85     {
  86         ULONG oldpos = 0;
  87         ULONG newpos = 0;
  88         for (; oldpos < slen; oldpos++)
  89         {
  90             if (data->skipchars)
  91             {
  92                 if (strchr(data->skipchars, entry[oldpos]))
  93                 {
  94                     continue;
  95                 }
  96             }
  97
  98             if (entry[oldpos] == '\t')
  99             {
 100                 LONG spaces = data->tabsize - (newpos % data->tabsize);
 101                 for (; spaces > 0; spaces--)
 102                 {
 103                     new[newpos++] = ' ';
 104                 }
 105             }
 106             else
 107             {
 108                 new[newpos++] = entry[oldpos];
 109             }
 110         }
 111         new[newpos] = '\0';
 112     }
 113     return new;
 114
 115     AROS_USERFUNC_EXIT
 116 }
 117
 118 AROS_UFH3S(void, destruct_func,
 119     AROS_UFHA(struct Hook *, hook, A0),
 120     AROS_UFHA(APTR, pool, A2),
 121     AROS_UFHA(STRPTR, entry, A1))
 122 {
 123     AROS_USERFUNC_INIT
 124
 125     FreeVecPooled(pool, entry);
 126
 127     AROS_USERFUNC_EXIT
 128 }
 129
 130 IPTR Floattext__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 131 {
 132     struct Floattext_DATA *data;
 133     struct TagItem *tag;
 134     struct TagItem *tags;
 135
 136     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
 137
 138     if (!obj)
 139     {
 140         return 0;
 141     }
 142
 143     data = INST_DATA(cl, obj);
 144
 145     data->construct_hook.h_Entry = (HOOKFUNC) construct_func;
 146     data->construct_hook.h_Data = data;
 147     data->destruct_hook.h_Entry = (HOOKFUNC) destruct_func;
 148
 149     SetAttrs(obj, MUIA_List_ConstructHook, (IPTR) & data->construct_hook,
 150         MUIA_List_DestructHook, (IPTR) & data->destruct_hook, TAG_DONE);
 151
 152     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 153     {
 154         switch (tag->ti_Tag)
 155         {
 156         case MUIA_Floattext_Justify:
 157             data->justify = tag->ti_Data;
 158             break;
 159
 160
 161         case MUIA_Floattext_SkipChars:
 162             data->skipchars = (STRPTR) tag->ti_Data;
 163             break;
 164
 165         case MUIA_Floattext_TabSize:
 166             data->tabsize = tag->ti_Data;
 167             break;
 168
 169         case MUIA_Floattext_Text:
 170             data->text = StrDup((STRPTR) tag->ti_Data);
 171             break;
 172         }
 173     }
 174
 175     if (data->tabsize == 0)
 176         data->tabsize = 8;
 177     else if (data->tabsize > 20)
 178         data->tabsize = 20;
 179
 180     SetText(obj, data);
 181
 182     return (IPTR) obj;
 183 }
 184
 185 IPTR Floattext__OM_DISPOSE(struct IClass *cl, Object *obj,
 186     struct opSet *msg)
 187 {
 188     struct Floattext_DATA *data = INST_DATA(cl, obj);
 189
 190     FreeVec(data->text);
 191
 192     return DoSuperMethodA(cl, obj, (Msg) msg);
 193 }
 194
 195 IPTR Floattext__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 196 {
 197     struct Floattext_DATA *data = INST_DATA(cl, obj);
 198 #define STORE *(msg->opg_Storage)
 199
 200     switch (msg->opg_AttrID)
 201     {
 202     case MUIA_Floattext_Justify:
 203         STORE = data->justify;
 204         return 1;
 205
 206     case MUIA_Floattext_Text:
 207         STORE = (IPTR) data->text;
 208         return 1;
 209
 210     }
 211
 212 #undef STORE
 213
 214     return DoSuperMethodA(cl, obj, (Msg) msg);
 215 }
 216
 217 IPTR Floattext__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 218 {
 219     struct Floattext_DATA *data = INST_DATA(cl, obj);
 220     struct TagItem *tag;
 221     struct TagItem *tags;
 222     BOOL changed = FALSE;
 223
 224     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 225     {
 226         switch (tag->ti_Tag)
 227         {
 228         case MUIA_Floattext_Justify:
 229             data->justify = tag->ti_Data;
 230             changed = TRUE;
 231             break;
 232
 233         case MUIA_Floattext_SkipChars:
 234             data->skipchars = (STRPTR) tag->ti_Data;
 235             changed = TRUE;
 236             break;
 237
 238         case MUIA_Floattext_TabSize:
 239             data->tabsize = tag->ti_Data;
 240             changed = TRUE;
 241             break;
 242
 243         case MUIA_Floattext_Text:
 244             FreeVec(data->text);
 245             data->text = StrDup((STRPTR) tag->ti_Data);
 246             changed = TRUE;
 247             break;
 248
 249         }
 250     }
 251
 252     if (changed)                // To avoid recursion
 253     {
 254         if (data->tabsize == 0)
 255             data->tabsize = 8;
 256         else if (data->tabsize > 20)
 257             data->tabsize = 20;
 258
 259         SetText(obj, data);
 260     }
 261
 262     return DoSuperMethodA(cl, obj, (Msg) msg);
 263 }
 264
 265 #if ZUNE_BUILTIN_FLOATTEXT
 266 BOOPSI_DISPATCHER(IPTR, Floattext_Dispatcher, cl, obj, msg)
 267 {
 268     switch (msg->MethodID)
 269     {
 270     case OM_NEW:
 271         return Floattext__OM_NEW(cl, obj, msg);
 272     case OM_DISPOSE:
 273         return Floattext__OM_DISPOSE(cl, obj, msg);
 274     case OM_GET:
 275         return Floattext__OM_GET(cl, obj, msg);
 276     case OM_SET:
 277         return Floattext__OM_SET(cl, obj, msg);
 278
 279     default:
 280         return DoSuperMethodA(cl, obj, msg);
 281     }
 282 }
 283 BOOPSI_DISPATCHER_END
 284
 285 const struct __MUIBuiltinClass _MUI_Floattext_desc =
 286 {
 287     MUIC_Floattext,
 288     MUIC_List,
 289     sizeof(struct Floattext_DATA),
 290     (void *) Floattext_Dispatcher
 291 };
 292 #endif /* ZUNE_BUILTIN_FLOATTEXT */