rom/intuition/drawimagestate.c

   1 /*
   2     Copyright © 1995-2007, 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     HISTORY
  72     29-10-95    digulla automatically created from
  73                 intuition_lib.fd and clib/intuition_protos.h
  74
  75 *****************************************************************************/
  76 {
  77     AROS_LIBFUNC_INIT
  78
  79     IPTR apen, bpen, drmd;
  80 #ifdef __MORPHOS__
  81     IPTR penmode;
  82 #endif
  83
  84     EXTENDWORD(leftOffset);
  85     EXTENDWORD(topOffset);
  86
  87     SANITY_CHECK(rp)
  88     SANITY_CHECK(image)
  89
  90     if (rp->Layer) LockLayer(0,rp->Layer);
  91
  92     /* Store important variables of the RastPort */
  93 #ifdef __MORPHOS__
  94     GetRPAttrs(rp,RPTAG_PenMode,(ULONG)&penmode,RPTAG_APen,(ULONG)&apen,
  95                RPTAG_BPen,(ULONG)&bpen,RPTAG_DrMd,(ULONG)&drmd,TAG_DONE);
  96 #else
  97     GetRPAttrs(rp,RPTAG_APen,(ULONG)&apen,
  98                RPTAG_BPen,(ULONG)&bpen,RPTAG_DrMd,(ULONG)&drmd,TAG_DONE);
  99 #endif
 100
 101     while(image)
 102     {
 103         if (image->Depth == CUSTOMIMAGEDEPTH)
 104         {
 105             struct impDraw method;
 106
 107             method.MethodID = IM_DRAW;
 108             method.imp_RPort = rp;
 109             method.imp_Offset.X = leftOffset;
 110             method.imp_Offset.Y = topOffset;
 111             method.imp_State = state;
 112             method.imp_DrInfo = drawInfo;
 113             DoMethodA ((Object *)image, (Msg)&method);
 114         }
 115         else
 116         {
 117             WORD    x, y, d;
 118             UWORD   shift;
 119             ULONG   planeonoff, planepick;
 120
 121         #if !USE_BLTBITMAPRASTPORT
 122
 123             ULONG   lastPen = 0;
 124             ULONG   pen = 0;
 125             UWORD   offset;
 126             UWORD   bitmask;
 127             UWORD * bits[8];
 128             WORD    xoff, yoff, plane;
 129
 130         #define START_BITMASK   0x8000
 131
 132             /* Change RastPort to the mode I need */
 133             SetDrMd (rp, JAM1);
 134
 135         #endif
 136
 137             /*  kprintf("*** Drawing Image %x. Next Image = %x\n widht = %d  height = %d  depth = %d  planepick = %d  planeonoff = %d\n",
 138             image,image->NextImage,
 139             image->Width,image->Height,image->Depth,image->PlanePick,image->PlaneOnOff);*/
 140
 141
 142             planepick  = image->PlanePick;
 143             planeonoff = image->PlaneOnOff & ~planepick;
 144
 145         #if USE_FASTPLANEPICK0
 146
 147             if (planepick == 0)
 148             {
 149                 SetAPen(rp, planeonoff);
 150                 RectFill(rp, leftOffset + image->LeftEdge,
 151                          topOffset  + image->TopEdge,
 152                          leftOffset + image->LeftEdge + image->Width  - 1,
 153                          topOffset  + image->TopEdge  + image->Height - 1);
 154
 155                 image = image->NextImage;
 156                 continue;
 157             }
 158
 159         #endif
 160
 161             /* Use x to store size of one image plane */
 162             x = ((image->Width + 15) >> 4) * image->Height;
 163             y = 0;
 164
 165             shift = 1;
 166
 167         #if USE_BLTBITMAPRASTPORT
 168             {
 169                 struct BitMap bitmap;
 170                 int depth;
 171
 172             #if 0
 173                 /* The "8" (instead of image->Depth) seems to be correct,
 174                    as for example DOpus uses prop gadget knob images with
 175                    a depth of 0 (planepick 0, planeonoff color) */
 176
 177                 depth = 8;
 178             #else
 179                 /* That makes far more sense than just a 8
 180                 * R.Schmidt...still doesn`t resolve some weird icon problem i have
 181                 */
 182                 //depth = rp->BitMap->Depth;
 183
 184                 /*
 185                 ** Be system friendly. - Piru
 186                 */
 187                 depth = GetBitMapAttr(rp->BitMap, BMA_DEPTH);
 188                 if (depth > 8)
 189                     depth = 8;
 190             #endif
 191                 InitBitMap(&bitmap, depth, image->Width, image->Height);
 192
 193                 for(d = 0; d < depth; d++)
 194                 {
 195                     if (planepick & shift)
 196                     {
 197                         bitmap.Planes[d] = (PLANEPTR)(image->ImageData + (y++) * x);
 198                     }
 199                     else
 200                     {
 201                         bitmap.Planes[d] = (planeonoff & shift) ? (PLANEPTR)-1 : NULL;
 202                     }
 203                     shift <<= 1;
 204                 }
 205
 206                 BltBitMapRastPort(&bitmap,
 207                                   0, 0,
 208                                   rp,
 209                                   leftOffset + image->LeftEdge, topOffset + image->TopEdge,
 210                                   image->Width, image->Height,
 211                                   0xC0);
 212             }
 213
 214         #else
 215
 216
 217             for(d = 0; d < image->Depth;d++)
 218             {
 219                 bits[d] = (planepick & shift) ? image->ImageData + (y++) * x : NULL;
 220                 shift <<= 1;
 221             }
 222
 223             offset  = 0;
 224
 225             yoff = image->TopEdge + topOffset;
 226
 227             for (y=0; y < image->Height; y++, yoff++)
 228             {
 229
 230                 bitmask = START_BITMASK;
 231
 232                 xoff = image->LeftEdge + leftOffset;
 233
 234                 for (x=0; x < image->Width; x++, xoff++)
 235                 {
 236                     pen = planeonoff;
 237                     shift = 1;
 238                     plane = 0;
 239
 240                     for(d = 0; d < image->Depth; d++)
 241                     {
 242                         if (planepick & shift)
 243                         {
 244                             UWORD dat;
 245
 246                             dat = bits[d][offset];
 247                             dat = AROS_WORD2BE(dat);
 248
 249                             if (dat & bitmask)
 250                             {
 251                                 pen |= shift;
 252                             }
 253                         }
 254
 255                         shift <<= 1;
 256                     }
 257
 258                     if (!x)
 259                     {
 260                         lastPen = pen;
 261                         Move (rp, xoff, yoff);
 262                     }
 263
 264                     if (pen != lastPen)
 265                     {
 266                         SetAPen (rp, lastPen);
 267                         Draw (rp, xoff, yoff);
 268                         lastPen = pen;
 269                     }
 270
 271                     bitmask >>= 1;
 272
 273                     if (!bitmask)
 274                     {
 275                         bitmask = START_BITMASK;
 276                         offset ++;
 277                     }
 278
 279                 } /* for (x=0; x < image->Width; x++, xoff++) */
 280
 281                 SetAPen (rp, pen);
 282                 Draw (rp, xoff-1, yoff);
 283
 284                 if (bitmask != START_BITMASK)
 285                     offset ++;
 286
 287             } /* for (y=0; y < image->Height; y++, yoff++) */
 288
 289         #endif
 290         }
 291
 292         image = image->NextImage;
 293     }
 294
 295 #ifdef __MORPHOS__
 296     SetRPAttrs(rp,RPTAG_APen,apen,RPTAG_BPen,bpen,RPTAG_DrMd,drmd,RPTAG_PenMode,penmode,TAG_DONE);
 297 #else
 298     SetRPAttrs(rp,RPTAG_APen,apen,RPTAG_BPen,bpen,RPTAG_DrMd,drmd,TAG_DONE);
 299 #endif
 300
 301     if (rp->Layer) UnlockLayer(rp->Layer);
 302
 303     AROS_LIBFUNC_EXIT
 304 } /* DrawImageState */