workbench/libs/muimaster/penspec.c

   1 /*
   2     Copyright © 2003-2015, The AROS Development Team. All rights reserved.
   3
   4     $Id$
   5 */
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <proto/dos.h>
  10 #include <proto/graphics.h>
  11
  12 /*  #define MYDEBUG 1 */
  13 #include "debug.h"
  14 #include "penspec.h"
  15 #include "muimaster_intern.h"
  16 #include "mui.h"
  17 #include "support.h"
  18
  19 extern struct Library *MUIMasterBase;
  20
  21 /* From ASCII to internal representation */
  22 BOOL zune_pen_spec_to_intern(const struct MUI_PenSpec *spec,
  23     struct MUI_PenSpec_intern *intern)
  24 {
  25     if (!spec || !intern)
  26         return FALSE;
  27
  28     memset(intern, 0, sizeof(*intern));
  29
  30     D(bug("zune_pen_spec_to_intern: parsing %s\n", spec->buf));
  31     switch (spec->buf[0])
  32     {
  33     case 'm':
  34         if (!StrToLong(spec->buf + 1, &intern->p_mui))
  35             return FALSE;
  36         intern->p_type = PST_MUI;
  37         break;
  38
  39     case 'p':
  40         if (!StrToLong(spec->buf + 1, &intern->p_cmap))
  41             return FALSE;
  42         intern->p_type = PST_CMAP;
  43         break;
  44
  45     case 's':
  46         if (!StrToLong(spec->buf + 1, &intern->p_sys))
  47             return FALSE;
  48         intern->p_type = PST_SYS;
  49         break;
  50
  51     case 'r':
  52     default:
  53         {
  54             const char *s;
  55             const char *t;
  56
  57             s = spec->buf;
  58             if (*s == 'r')
  59             {
  60                 s++;
  61             }
  62             t = s;
  63             intern->p_rgb.red = strtoul(s, (char **)&s, 16);
  64             if (s == t)
  65                 return FALSE;
  66
  67             s++;
  68             t = s;
  69             intern->p_rgb.green = strtoul(s, (char **)&s, 16);
  70             if (s == t)
  71                 return FALSE;
  72
  73             s++;
  74             t = s;
  75             intern->p_rgb.blue = strtoul(s, (char **)&s, 16);
  76             if (s == t)
  77                 return FALSE;
  78
  79             intern->p_type = PST_RGB;
  80             break;
  81         }
  82     }
  83     return TRUE;
  84 }
  85
  86 BOOL zune_pen_string_to_intern(CONST_STRPTR spec,
  87     struct MUI_PenSpec_intern *intern)
  88 {
  89     return zune_pen_spec_to_intern((const struct MUI_PenSpec *)spec,
  90         intern);
  91 }
  92
  93 BOOL zune_pen_intern_to_spec(const struct MUI_PenSpec_intern *intern,
  94     struct MUI_PenSpec *spec)
  95 {
  96     if (!spec || !intern)
  97         return FALSE;
  98
  99     switch (intern->p_type)
 100     {
 101     case PST_MUI:
 102         spec->buf[0] = 'm';
 103         sprintf(spec->buf + 1, "%ld", (long)intern->p_mui);
 104         break;
 105
 106     case PST_CMAP:
 107         spec->buf[0] = 'p';
 108         sprintf(spec->buf + 1, "%ld", (long)intern->p_cmap);
 109         break;
 110
 111     case PST_RGB:
 112         spec->buf[0] = 'r';
 113         sprintf(spec->buf + 1, "%08lx,%08lx,%08lx",
 114             (long)intern->p_rgb.red, (long)intern->p_rgb.green,
 115             (long)intern->p_rgb.blue);
 116         break;
 117
 118     case PST_SYS:
 119         spec->buf[0] = 's';
 120         sprintf(spec->buf + 1, "%ld", (long)intern->p_sys);
 121         break;
 122
 123     default:
 124         return FALSE;
 125     }
 126     return TRUE;
 127 }
 128
 129 void zune_penspec_fill_muipen(struct MUI_PenSpec_intern *psi, LONG muipen)
 130 {
 131     if (psi)
 132     {
 133         psi->p_type = PST_MUI;
 134         psi->p_mui = muipen;
 135     }
 136 }
 137
 138 void zune_penspec_fill_rgb(struct MUI_PenSpec_intern *psi, ULONG r, ULONG g,
 139     ULONG b)
 140 {
 141     if (psi)
 142     {
 143         psi->p_type = PST_RGB;
 144         psi->p_rgb.red = r;
 145         psi->p_rgb.green = g;
 146         psi->p_rgb.blue = b;
 147     }
 148 }
 149
 150 static void set_pen_from_rgb(struct MUI_PenSpec_intern *psi,
 151     struct ColorMap *cm, ULONG r, ULONG g, ULONG b)
 152 {
 153     LONG pen;
 154     struct TagItem obp_tags[] = {
 155         {OBP_FailIfBad, FALSE},
 156         {TAG_DONE, 0L}
 157     };
 158
 159     pen = ObtainBestPenA(cm, r, g, b, obp_tags);
 160     if (pen == -1)
 161     {
 162         psi->p_is_allocated = FALSE;
 163         psi->p_pen = FindColor(cm, r, g, b, -1);
 164     }
 165     else
 166     {
 167         psi->p_is_allocated = TRUE;
 168         psi->p_pen = pen;
 169     }
 170 }
 171
 172 BOOL zune_penspec_setup(struct MUI_PenSpec_intern *psi,
 173     struct MUI_RenderInfo *mri)
 174 {
 175     if (!psi || !mri)
 176         return FALSE;
 177
 178     D(bug("zune_penspec_setup(%lx) type=%ld\n", psi, psi->p_type));
 179     psi->p_mri = mri;
 180
 181     switch (psi->p_type)
 182     {
 183     case PST_MUI:
 184         if ((psi->p_mui >= 0) && (psi->p_mui < MPEN_COUNT))
 185             psi->p_pen = mri->mri_Pens[psi->p_mui];
 186         else
 187             return FALSE;
 188         break;
 189
 190     case PST_CMAP:
 191         {
 192             psi->p_pen = (psi->p_cmap >= 0) ?
 193                 psi->p_cmap : mri->mri_Colormap->Count + psi->p_cmap;
 194             if ((psi->p_pen >= 0)
 195                 && (psi->p_pen < mri->mri_Colormap->Count))
 196                 psi->p_is_allocated = FALSE;
 197             else
 198                 return FALSE;
 199             break;
 200         }
 201     case PST_RGB:
 202         set_pen_from_rgb(psi, mri->mri_Colormap,
 203             psi->p_rgb.red, psi->p_rgb.green, psi->p_rgb.blue);
 204         D(bug("zune_penspec_setup(%lx)=%ld RGB(%lx,%lx,%lx)\n", psi,
 205                 psi->p_pen, psi->p_rgb.red, psi->p_rgb.green,
 206                 psi->p_rgb.blue));
 207         break;
 208
 209     case PST_SYS:
 210         break;
 211
 212     default:
 213         return FALSE;
 214     }
 215     return TRUE;
 216 }
 217
 218 BOOL zune_penspec_cleanup(struct MUI_PenSpec_intern *psi)
 219 {
 220     if (!psi || !psi->p_mri)
 221         return FALSE;
 222
 223     switch (psi->p_type)
 224     {
 225     case PST_MUI:
 226         break;
 227
 228     case PST_CMAP:
 229         if (psi->p_is_allocated)
 230             ReleasePen(psi->p_mri->mri_Colormap, psi->p_pen);
 231         break;
 232
 233     case PST_RGB:
 234         if (psi->p_is_allocated)
 235             ReleasePen(psi->p_mri->mri_Colormap, psi->p_pen);
 236         break;
 237
 238     case PST_SYS:
 239         break;
 240
 241     default:
 242         return FALSE;
 243     }
 244     return TRUE;
 245 }
 246
 247 void zune_penspec_drawdirect(struct MUI_PenSpec_intern *psi,
 248     struct RastPort *rp, struct MUI_RenderInfo *mri, LONG left, LONG top,
 249     LONG right, LONG bottom)
 250 {
 251     if (!psi || !mri || !rp)
 252         return;
 253
 254     if (psi->p_type == PST_RGB)
 255     {
 256         D(bug("drawing with %lx, pen=%ld, at %ld, %ld => %ld, %ld\n",
 257                 psi, psi->p_pen, left, top, right, bottom));
 258     }
 259     SetAPen(rp, psi->p_pen);
 260     RectFill(rp, left, top, right, bottom);
 261 }
 262
 263 void zune_penspec_draw(struct MUI_PenSpec_intern *psi,
 264     struct MUI_RenderInfo *mri, LONG left, LONG top, LONG right,
 265     LONG bottom)
 266 {
 267     zune_penspec_drawdirect(psi, mri->mri_RastPort, mri, left, top, right,
 268         bottom);
 269 }