workbench/libs/muimaster/classes/text.c

   1 /*
   2     Copyright  1999, David Le Corfec.
   3     Copyright  2002-2006, The AROS Development Team.
   4     All rights reserved.
   5
   6     $Id$
   7 */
   8
   9 #include <string.h>
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <exec/types.h>
  13
  14 #include <clib/alib_protos.h>
  15 #include <proto/exec.h>
  16 #include <proto/intuition.h>
  17 #include <proto/graphics.h>
  18 #include <proto/utility.h>
  19 #include <proto/dos.h>
  20 #include <proto/muimaster.h>
  21
  22 #include "mui.h"
  23 #include "muimaster_intern.h"
  24 #include "support.h"
  25 #include "textengine.h"
  26
  27 extern struct Library *MUIMasterBase;
  28
  29 //#define MYDEBUG 1
  30 #include "debug.h"
  31
  32
  33 struct MUI_TextData
  34 {
  35     ULONG mtd_Flags;
  36     STRPTR contents;
  37     CONST_STRPTR preparse;
  38     TEXT hichar;
  39     ZText *ztext;
  40     LONG xpixel;        /* needed for cursor up/down movements, can be -1 */
  41     struct MUI_EventHandlerNode ehn;
  42
  43     LONG update;        /* type of update: 1 - everything,
  44                          * 2 - insert char, no scroll */
  45 };
  46
  47 #define MTDF_SETMIN    (1<<0)
  48 #define MTDF_SETMAX    (1<<1)
  49 #define MTDF_SETVMAX   (1<<2)
  50 #define MTDF_HICHAR    (1<<3)
  51 #define MTDF_HICHARIDX (1<<4)
  52
  53
  54 static const int __version = 1;
  55 static const int __revision = 1;
  56
  57 static void setup_text(struct MUI_TextData *data, Object *obj);
  58
  59 /**************************************************************************
  60 OM_NEW
  61 **************************************************************************/
  62 IPTR Text__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
  63 {
  64     struct MUI_TextData *data;
  65     struct TagItem *tags, *tag;
  66
  67     obj = (Object *) DoSuperMethodA(cl, obj, (Msg) msg);
  68     if (!obj)
  69         return FALSE;
  70
  71     data = INST_DATA(cl, obj);
  72     data->mtd_Flags = MTDF_SETMIN | MTDF_SETVMAX;
  73
  74     /* parse initial taglist */
  75
  76     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
  77     {
  78         switch (tag->ti_Tag)
  79         {
  80         case MUIA_Text_Contents:
  81             if (tag->ti_Data)
  82                 data->contents = StrDup((STRPTR) tag->ti_Data);
  83             break;
  84
  85         case MUIA_Text_HiChar:
  86             data->hichar = tag->ti_Data;
  87             _handle_bool_tag(data->mtd_Flags, tag->ti_Data, MTDF_HICHAR);
  88             break;
  89
  90         case MUIA_Text_HiCharIdx:
  91             data->hichar = tag->ti_Data;
  92             _handle_bool_tag(data->mtd_Flags, tag->ti_Data, MTDF_HICHARIDX);
  93             break;
  94
  95         case MUIA_Text_PreParse:
  96             data->preparse = StrDup((STRPTR) tag->ti_Data);
  97             break;
  98
  99         case MUIA_Text_SetMin:
 100             _handle_bool_tag(data->mtd_Flags, tag->ti_Data, MTDF_SETMIN);
 101             break;
 102
 103         case MUIA_Text_SetMax:
 104             _handle_bool_tag(data->mtd_Flags, tag->ti_Data, MTDF_SETMAX);
 105             break;
 106
 107         case MUIA_Text_SetVMax:
 108             _handle_bool_tag(data->mtd_Flags, tag->ti_Data, MTDF_SETVMAX);
 109             break;
 110
 111         }
 112     }
 113
 114     if (!data->preparse)
 115         data->preparse = StrDup("");
 116     if (!data->contents)
 117         data->contents = StrDup("");
 118
 119     if (!data->contents || !data->preparse)
 120     {
 121         CoerceMethod(cl, obj, OM_DISPOSE);
 122         return (IPTR) NULL;
 123     }
 124
 125 /*      D(bug("Text_New(0x%lx)\n", obj)); */
 126
 127     data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS;
 128     data->ehn.ehn_Priority = 0;
 129     data->ehn.ehn_Flags = 0;
 130     data->ehn.ehn_Object = obj;
 131     data->ehn.ehn_Class = cl;
 132
 133     data->xpixel = -1;
 134
 135     return (IPTR) obj;
 136 }
 137
 138 /**************************************************************************
 139 OM_DISPOSE
 140 **************************************************************************/
 141 IPTR Text__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 142 {
 143     struct MUI_TextData *data = INST_DATA(cl, obj);
 144
 145     FreeVec(data->contents);
 146     FreeVec((APTR) data->preparse);
 147
 148     return DoSuperMethodA(cl, obj, msg);
 149 }
 150
 151 /**************************************************************************
 152 OM_SET
 153 **************************************************************************/
 154 IPTR Text__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
 155 {
 156     struct MUI_TextData *data = INST_DATA(cl, obj);
 157     struct TagItem *tags = msg->ops_AttrList;
 158     struct TagItem *tag;
 159
 160     while ((tag = NextTagItem(&tags)) != NULL)
 161     {
 162         switch (tag->ti_Tag)
 163         {
 164         case MUIA_Text_Contents:
 165             {
 166                 char *new_contents =
 167                     StrDup(((char *)tag->ti_Data) ? (char *)tag->
 168                     ti_Data : "");
 169                 if (new_contents)
 170                 {
 171                     if (data->ztext)
 172                     {
 173                         zune_text_destroy(data->ztext);
 174                         data->ztext = NULL;
 175                     }
 176                     FreeVec(data->contents);
 177                     data->contents = new_contents;
 178                     if (_flags(obj) & MADF_SETUP)
 179                         setup_text(data, obj);
 180                     MUI_Redraw(obj, MADF_DRAWOBJECT); /* should be optimized */
 181                 }
 182             }
 183             break;
 184
 185         case MUIA_Text_PreParse:
 186             {
 187                 char *new_preparse =
 188                     StrDup(((char *)tag->ti_Data) ? (char *)tag->
 189                     ti_Data : "");
 190                 if (new_preparse)
 191                 {
 192                     if (data->ztext)
 193                     {
 194                         zune_text_destroy(data->ztext);
 195                         data->ztext = NULL;
 196                     }
 197                     FreeVec((APTR) data->preparse);
 198                     data->preparse = new_preparse;
 199                     if (_flags(obj) & MADF_SETUP)
 200                         setup_text(data, obj);
 201                     MUI_Redraw(obj, MADF_DRAWOBJECT); /* should be optimized */
 202                 }
 203             }
 204             break;
 205
 206         case MUIA_Selected:
 207             D(bug("Text_Set(%p) : MUIA_Selected val=%ld sss=%d\n", obj,
 208                     tag->ti_Data, ! !(_flags(obj) & MADF_SHOWSELSTATE)));
 209             break;
 210         }
 211     }
 212
 213     return DoSuperMethodA(cl, obj, (Msg) msg);
 214 }
 215
 216
 217 /**************************************************************************
 218 OM_GET
 219 **************************************************************************/
 220 IPTR Text__OM_GET(struct IClass *cl, Object *obj, struct opGet *msg)
 221 {
 222     struct MUI_TextData *data = INST_DATA(cl, obj);
 223
 224 #define STORE *(msg->opg_Storage)
 225     switch (msg->opg_AttrID)
 226     {
 227     case MUIA_Text_Contents:
 228         STORE = (IPTR) data->contents;
 229         return TRUE;
 230
 231     case MUIA_Text_PreParse:
 232         STORE = (IPTR) data->preparse;
 233         return TRUE;
 234
 235     case MUIA_Version:
 236         STORE = __version;
 237         return TRUE;
 238
 239     case MUIA_Revision:
 240         STORE = __revision;
 241         return TRUE;
 242     }
 243     return DoSuperMethodA(cl, obj, (Msg) msg);
 244 #undef STORE
 245 }
 246
 247 /**************************************************************************
 248 ...
 249 **************************************************************************/
 250 static void setup_text(struct MUI_TextData *data, Object *obj)
 251 {
 252     if (data->mtd_Flags & MTDF_HICHAR)
 253     {
 254         data->ztext = zune_text_new(data->preparse, data->contents,
 255             ZTEXT_ARG_HICHAR, data->hichar);
 256     }
 257     else if (data->mtd_Flags & MTDF_HICHARIDX)
 258     {
 259         data->ztext = zune_text_new(data->preparse, data->contents,
 260             ZTEXT_ARG_HICHARIDX, data->hichar);
 261     }
 262     else
 263     {
 264         data->ztext = zune_text_new(data->preparse, data->contents,
 265             ZTEXT_ARG_NONE, 0);
 266     }
 267     zune_text_get_bounds(data->ztext, obj);
 268
 269 /*      D(bug("muimaster.library/text.c: ZText of 0x%lx at 0x%lx\n", */
 270 /*          obj, data->ztext)); */
 271 }
 272
 273 /**************************************************************************
 274 MUIM_Setup
 275 **************************************************************************/
 276 IPTR Text__MUIM_Setup(struct IClass *cl, Object *obj,
 277     struct MUIP_Setup *msg)
 278 {
 279     struct MUI_TextData *data = INST_DATA(cl, obj);
 280
 281     if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
 282         return FALSE;
 283
 284     setup_text(data, obj);
 285
 286     DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR) & data->ehn);
 287     return TRUE;
 288 }
 289
 290 /**************************************************************************
 291 MUIM_Cleanup
 292 **************************************************************************/
 293 IPTR Text__MUIM_Cleanup(struct IClass *cl, Object *obj,
 294     struct MUIP_Cleanup *msg)
 295 {
 296     struct MUI_TextData *data = INST_DATA(cl, obj);
 297
 298     DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR) & data->ehn);
 299
 300     if (data->ztext)
 301     {
 302         zune_text_destroy(data->ztext);
 303         data->ztext = NULL;
 304     }
 305
 306     return (DoSuperMethodA(cl, obj, (Msg) msg));
 307 }
 308
 309 /**************************************************************************
 310 MUIM_Show
 311 **************************************************************************/
 312 IPTR Text__MUIM_Show(struct IClass *cl, Object *obj,
 313     struct MUIP_Show *msg)
 314 {
 315     //struct MUI_TextData *data = INST_DATA(cl, obj);
 316
 317     if (!(DoSuperMethodA(cl, obj, (Msg) msg)))
 318         return FALSE;
 319
 320     return TRUE;
 321 }
 322
 323 /**************************************************************************
 324 MUIM_Hide
 325 **************************************************************************/
 326 IPTR Text__MUIM_Hide(struct IClass *cl, Object *obj,
 327     struct MUIP_Hide *msg)
 328 {
 329     //struct MUI_TextData *data = INST_DATA(cl, obj);
 330     return DoSuperMethodA(cl, obj, (Msg) msg);
 331 }
 332
 333 /**************************************************************************
 334 MUIM_AskMinMax
 335 **************************************************************************/
 336 IPTR Text__MUIM_AskMinMax(struct IClass *cl, Object *obj,
 337     struct MUIP_AskMinMax *msg)
 338 {
 339     int height;
 340     struct MUI_TextData *data = INST_DATA(cl, obj);
 341
 342     DoSuperMethodA(cl, obj, (Msg) msg);
 343
 344     height = data->ztext->height;
 345     if (_font(obj)->tf_YSize > height)
 346         height = _font(obj)->tf_YSize;
 347 /*      D(bug("YSize=%ld\n", _font(obj)->tf_YSize)); */
 348
 349
 350     msg->MinMaxInfo->MinWidth += data->ztext->width;
 351     msg->MinMaxInfo->DefWidth += data->ztext->width;
 352     msg->MinMaxInfo->MaxWidth += data->ztext->width;
 353
 354     msg->MinMaxInfo->MinHeight += height;
 355     msg->MinMaxInfo->DefHeight += height;
 356
 357     if (!(data->mtd_Flags & MTDF_SETVMAX))
 358         msg->MinMaxInfo->MaxHeight += MUI_MAXMAX;
 359     else
 360         msg->MinMaxInfo->MaxHeight += height;
 361
 362     if (!(data->mtd_Flags & MTDF_SETMAX))
 363         msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
 364
 365     if (!(data->mtd_Flags & MTDF_SETMIN))
 366         msg->MinMaxInfo->MinWidth = 0;
 367
 368     D(bug
 369         ("Text_AskMinMax 0x%lx (%s): Min=%ldx%ld Max=%ldx%ld Def=%ldx%ld\n",
 370             obj, data->contents, msg->MinMaxInfo->MinWidth,
 371             msg->MinMaxInfo->MinHeight, msg->MinMaxInfo->MaxWidth,
 372             msg->MinMaxInfo->MaxHeight, msg->MinMaxInfo->DefWidth,
 373             msg->MinMaxInfo->DefHeight));
 374
 375     return TRUE;
 376 }
 377
 378 /**************************************************************************
 379 MUIM_Draw
 380 **************************************************************************/
 381 IPTR Text__MUIM_Draw(struct IClass *cl, Object *obj,
 382     struct MUIP_Draw *msg)
 383 {
 384     struct MUI_TextData *data = INST_DATA(cl, obj);
 385     Object *act = NULL;
 386     APTR clip;
 387
 388 /*    D(bug("muimaster.library/text.c: Draw Text Object at " */
 389 /*        "0x%lx %ldx%ldx%ldx%ld\n", obj, _left(obj), _top(obj), */
 390 /*        _right(obj), _bottom(obj))); */
 391
 392     DoSuperMethodA(cl, obj, (Msg) msg);
 393
 394     if ((msg->flags & MADF_DRAWUPDATE) && !data->update)
 395         return 0;
 396
 397     if (!(msg->flags & MADF_DRAWUPDATE))
 398         data->update = 0;
 399
 400     if (msg->flags & MADF_DRAWUPDATE && data->update == 1)
 401     {
 402         DoMethod(obj, MUIM_DrawBackground, _mleft(obj), _mtop(obj),
 403             _mwidth(obj), _mheight(obj), _mleft(obj), _mtop(obj), 0);
 404     }
 405
 406     clip = MUI_AddClipping(muiRenderInfo(obj), _mleft(obj), _mtop(obj),
 407         _mwidth(obj), _mheight(obj));
 408
 409     SetAPen(_rp(obj), _pens(obj)[MPEN_TEXT]);
 410
 411     {
 412         get(_win(obj), MUIA_Window_ActiveObject, &act);
 413         {
 414             int y = (_mheight(obj) - data->ztext->height) / 2;
 415             zune_text_draw(data->ztext, obj,
 416                 _mleft(obj), _mright(obj), _mtop(obj) + y);
 417         }
 418     }
 419
 420     MUI_RemoveClipping(muiRenderInfo(obj), clip);
 421     data->update = 0;
 422     return TRUE;
 423 }
 424
 425 /**************************************************************************
 426 MUIM_Export : to export an object's "contents" to a dataspace object.
 427 **************************************************************************/
 428 IPTR Text__MUIM_Export(struct IClass *cl, Object *obj,
 429     struct MUIP_Export *msg)
 430 {
 431     //struct MUI_TextData *data = INST_DATA(cl, obj);
 432     //STRPTR id;
 433
 434 #if 0
 435     if ((id = muiNotifyData(obj)->mnd_ObjectID))
 436     {
 437         DoMethod(msg->dataspace, MUIM_Dataspace_AddString,
 438             _U(id), _U("contents"), _U(data->contents));
 439     }
 440 #endif
 441     return 0;
 442 }
 443
 444
 445 /**************************************************************************
 446 MUIM_Import : to import an object's "contents" from a dataspace object.
 447 **************************************************************************/
 448 IPTR Text__MUIM_Import(struct IClass *cl, Object *obj,
 449     struct MUIP_Import *msg)
 450 {
 451     //STRPTR id;
 452     //STRPTR s;
 453
 454 #if 0
 455     if ((id = muiNotifyData(obj)->mnd_ObjectID))
 456     {
 457         if ((s = (STRPTR) DoMethod(msg->dataspace,
 458                     MUIM_Dataspace_FindString, _U(id), _U("contents"))))
 459         {
 460             set(obj, MUIA_Text_Contents, _U(s));
 461         }
 462     }
 463 #endif
 464     return 0;
 465 }
 466
 467
 468 BOOPSI_DISPATCHER(IPTR, Text_Dispatcher, cl, obj, msg)
 469 {
 470     switch (msg->MethodID)
 471     {
 472     case OM_NEW:
 473         return Text__OM_NEW(cl, obj, (struct opSet *)msg);
 474     case OM_DISPOSE:
 475         return Text__OM_DISPOSE(cl, obj, msg);
 476     case OM_SET:
 477         return Text__OM_SET(cl, obj, (struct opSet *)msg);
 478     case OM_GET:
 479         return Text__OM_GET(cl, obj, (struct opGet *)msg);
 480
 481     case MUIM_AskMinMax:
 482         return Text__MUIM_AskMinMax(cl, obj, (APTR) msg);
 483     case MUIM_Draw:
 484         return Text__MUIM_Draw(cl, obj, (APTR) msg);
 485     case MUIM_Setup:
 486         return Text__MUIM_Setup(cl, obj, (APTR) msg);
 487     case MUIM_Cleanup:
 488         return Text__MUIM_Cleanup(cl, obj, (APTR) msg);
 489     case MUIM_Show:
 490         return Text__MUIM_Show(cl, obj, (APTR) msg);
 491     case MUIM_Hide:
 492         return Text__MUIM_Hide(cl, obj, (APTR) msg);
 493     case MUIM_Export:
 494         return Text__MUIM_Export(cl, obj, (APTR) msg);
 495     case MUIM_Import:
 496         return Text__MUIM_Import(cl, obj, (APTR) msg);
 497     }
 498
 499     return DoSuperMethodA(cl, obj, msg);
 500 }
 501 BOOPSI_DISPATCHER_END
 502
 503 /*
 504 * Class descriptor.
 505 */
 506 const struct __MUIBuiltinClass _MUI_Text_desc =
 507 {
 508     MUIC_Text,
 509     MUIC_Area,
 510     sizeof(struct MUI_TextData),
 511     (void *) Text_Dispatcher
 512 };