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