rom/intuition/drawimagestate.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     Copyright © 2001-2003, The MorphOS Development Team. All Rights Reserved.
   4     $Id$
   5 */
   6
   7 #include <proto/graphics.h>
   8 #include <proto/layers.h>
   9 #include "intuition_intern.h"
  10 #include <intuition/classusr.h>
  11 #include <proto/alib.h>
  12
  13 #include <aros/macros.h>
  14
  15 #undef DEBUG
  16 #define DEBUG 0
  17 #   include <aros/debug.h>
  18 //#include <proto/arossupport.h>
  19
  20 #define USE_BLTBITMAPRASTPORT 1
  21 #define USE_FASTPLANEPICK0    1
  22
  23 /*****************************************************************************
  24
  25     NAME */
  26 #include <graphics/rastport.h>
  27 #include <graphics/rpattr.h>
  28 #include <intuition/intuition.h>
  29 #include <intuition/imageclass.h>
  30 #include <proto/intuition.h>
  31
  32         AROS_LH6(void, DrawImageState,
  33
  34 /*  SYNOPSIS */
  35         AROS_LHA(struct RastPort *, rp,         A0),
  36         AROS_LHA(struct Image    *, image,      A1),
  37         AROS_LHA(LONG             , leftOffset, D0),
  38         AROS_LHA(LONG             , topOffset,  D1),
  39         AROS_LHA(ULONG            , state,      D2),
  40         AROS_LHA(struct DrawInfo *, drawInfo,   A2),
  41
  42 /*  LOCATION */
  43         struct IntuitionBase *, IntuitionBase, 103, Intuition)
  44
  45 /*  FUNCTION
  46         This function renders an image in a certain state.
  47
  48     INPUTS
  49         rp - Render in this RastPort
  50         image - Render this image
  51         leftOffset, topOffset - Add this offset to the position stored in the
  52             image.
  53         state - Which state (see intuition/imageclass.h for possible
  54             values).
  55         drawInfo - The DrawInfo from the screen.
  56
  57     RESULT
  58         None.
  59
  60     NOTES
  61         DrawImageState(), handles both boopsi and conventional images.
  62
  63     EXAMPLE
  64
  65     BUGS
  66
  67     SEE ALSO
  68
  69     INTERNALS
  70
  71 *****************************************************************************/
  72 {
  73     AROS_LIBFUNC_INIT
  74
  75     struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
  76     struct LayersBase *LayersBase = GetPrivIBase(IntuitionBase)->LayersBase;
  77     IPTR apen, bpen, drmd;
  78 #ifdef __MORPHOS__
  79     IPTR penmode;
  80 #endif
  81
  82     EXTENDWORD(leftOffset);
  83     EXTENDWORD(topOffset);
  84
  85     SANITY_CHECK(rp)
  86     SANITY_CHECK(image)
  87
  88     if (rp->Layer) LockLayer(0,rp->Layer);
  89
  90     /* Store important variables of the RastPort */
  91 #ifdef __MORPHOS__
  92     GetRPAttrs(rp, RPTAG_PenMode, &penmode, RPTAG_APen, &apen,
  93                RPTAG_BPen, &bpen, RPTAG_DrMd, &drmd, TAG_DONE);
  94 #else
  95     GetRPAttrs(rp, RPTAG_APen, &apen,
  96                RPTAG_BPen, &bpen, RPTAG_DrMd, &drmd, TAG_DONE);
  97 #endif
  98
  99     while(image)
 100     {
 101         if (image->Depth == CUSTOMIMAGEDEPTH)
 102         {
 103             struct impDraw method;
 104
 105             method.MethodID = IM_DRAW;
 106             method.imp_RPort = rp;
 107             method.imp_Offset.X = leftOffset;
 108             method.imp_Offset.Y = topOffset;
 109             method.imp_State = state;
 110             method.imp_DrInfo = drawInfo;
 111             DoMethodA ((Object *)image, (Msg)&method);
 112         }
 113         else
 114         {
 115             WORD    x, y, d;
 116             UWORD   shift;
 117             ULONG   planeonoff, planepick;
 118
 119         #if !USE_BLTBITMAPRASTPORT
 120
 121             ULONG   lastPen = 0;
 122             ULONG   pen = 0;
 123             UWORD   offset;
 124             UWORD   bitmask;
 125             UWORD * bits[8];
 126             WORD    xoff, yoff, plane;
 127
 128         #define START_BITMASK   0x8000
 129
 130             /* Change RastPort to the mode I need */
 131             SetDrMd (rp, JAM1);
 132
 133         #endif
 134
 135             /*  kprintf("*** Drawing Image %x. Next Image = %x\n widht = %d  height = %d  depth = %d  planepick = %d  planeonoff = %d\n",
 136             image,image->NextImage,
 137             image->Width,image->Height,image->Depth,image->PlanePick,image->PlaneOnOff);*/
 138
 139
 140             planepick  = image->PlanePick;
 141             planeonoff = image->PlaneOnOff & ~planepick;
 142
 143         #if USE_FASTPLANEPICK0
 144
 145             if (planepick == 0)
 146             {
 147                 SetAPen(rp, planeonoff);
 148                 RectFill(rp, leftOffset + image->LeftEdge,
 149                          topOffset  + image->TopEdge,
 150                          leftOffset + image->LeftEdge + image->Width  - 1,
 151                          topOffset  + image->TopEdge  + image->Height - 1);
 152
 153                 image = image->NextImage;
 154                 continue;
 155             }
 156
 157         #endif
 158
 159             /* Use x to store size of one image plane */
 160             x = ((image->Width + 15) >> 4) * image->Height;
 161             y = 0;
 162
 163             shift = 1;
 164
 165         #if USE_BLTBITMAPRASTPORT
 166             {
 167                 struct BitMap bitmap;
 168                 int depth;
 169                 int imagedepth = image->Depth;
 170
 171             #if 0
 172                 /* The "8" (instead of image->Depth) seems to be correct,
 173                    as for example DOpus uses prop gadget knob images with
 174                    a depth of 0 (planepick 0, planeonoff color) */
 175
 176                 depth = 8;
 177             #else
 178                 /* That makes far more sense than just a 8
 179                 * R.Schmidt...still doesn`t resolve some weird icon problem i have
 180                 */
 181                 //depth = rp->BitMap->Depth;
 182
 183                 /*
 184                 ** Be system friendly. - Piru
 185                 */
 186                 depth = GetBitMapAttr(rp->BitMap, BMA_DEPTH);
 187                 if (depth > 8)
 188                     depth = 8;
 189             #endif
 190                 InitBitMap(&bitmap, depth, image->Width, image->Height);
 191
 192                 for(d = 0; d < depth; d++)
 193                 {
 194                     /* Don't use more planes than image->depth. This solves
 195                        corrupt images of Garshneblanker's FlyingToaster which
 196                        uses a PlanePick of 0xff. */
 197                     if ((imagedepth > 0) && (planepick & shift))
 198                     {
 199                         imagedepth--;
 200                         bitmap.Planes[d] = (PLANEPTR)(image->ImageData + (y++) * x);
 201                     }
 202                     else
 203                     {
 204                         bitmap.Planes[d] = (planeonoff & shift) ? (PLANEPTR)-1 : NULL;
 205                     }
 206                     shift <<= 1;
 207                 }
 208
 209                 BltBitMapRastPort(&bitmap,
 210                                   0, 0,
 211                                   rp,
 212                                   leftOffset + image->LeftEdge, topOffset + image->TopEdge,
 213                                   image->Width, image->Height,
 214                                   (state == IDS_SELECTED) ? 0x30 : 0xC0);
 215             }
 216
 217         #else
 218
 219
 220             for(d = 0; d < image->Depth;d++)
 221             {
 222                 bits[d] = (planepick & shift) ? image->ImageData + (y++) * x : NULL;
 223                 shift <<= 1;
 224             }
 225
 226             offset  = 0;
 227
 228             yoff = image->TopEdge + topOffset;
 229
 230             for (y=0; y < image->Height; y++, yoff++)
 231             {
 232
 233                 bitmask = START_BITMASK;
 234
 235                 xoff = image->LeftEdge + leftOffset;
 236
 237                 for (x=0; x < image->Width; x++, xoff++)
 238                 {
 239                     pen = planeonoff;
 240                     shift = 1;
 241                     plane = 0;
 242
 243                     for(d = 0; d < image->Depth; d++)
 244                     {
 245                         if (planepick & shift)
 246                         {
 247                             UWORD dat;
 248
 249                             dat = bits[d][offset];
 250                             dat = AROS_WORD2BE(dat);
 251
 252                             if (dat & bitmask)
 253                             {
 254                                 pen |= shift;
 255                             }
 256                         }
 257
 258                         shift <<= 1;
 259                     }
 260
 261                     if (!x)
 262                     {
 263                         lastPen = pen;
 264                         Move (rp, xoff, yoff);
 265                     }
 266
 267                     if (pen != lastPen)
 268                     {
 269                         SetAPen (rp, lastPen);
 270                         Draw (rp, xoff, yoff);
 271                         lastPen = pen;
 272                     }
 273
 274                     bitmask >>= 1;
 275
 276                     if (!bitmask)
 277                     {
 278                         bitmask = START_BITMASK;
 279                         offset ++;
 280                     }
 281
 282                 } /* for (x=0; x < image->Width; x++, xoff++) */
 283
 284                 SetAPen (rp, pen);
 285                 Draw (rp, xoff-1, yoff);
 286
 287                 if (bitmask != START_BITMASK)
 288                     offset ++;
 289
 290             } /* for (y=0; y < image->Height; y++, yoff++) */
 291
 292         #endif
 293         }
 294
 295         image = image->NextImage;
 296     }
 297
 298 #ifdef __MORPHOS__
 299     SetRPAttrs(rp,RPTAG_APen,apen,RPTAG_BPen,bpen,RPTAG_DrMd,drmd,RPTAG_PenMode,penmode,TAG_DONE);
 300 #else
 301     SetRPAttrs(rp,RPTAG_APen,apen,RPTAG_BPen,bpen,RPTAG_DrMd,drmd,TAG_DONE);
 302 #endif
 303
 304     if (rp->Layer) UnlockLayer(rp->Layer);
 305
 306     AROS_LIBFUNC_EXIT
 307 } /* DrawImageState */