workbench/libs/muimaster/mui_redraw.c

   1 /*
   2     Copyright © 2003-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <string.h>
   7 #include <clib/alib_protos.h>
   8 #include <intuition/classusr.h>
   9 #include <graphics/gfxmacros.h>
  10 #include <cybergraphx/cybergraphics.h>
  11 #include <proto/graphics.h>
  12 #include <proto/intuition.h>
  13 #include <proto/muimaster.h>
  14 #include <proto/cybergraphics.h>
  15
  16 #include "muimaster_intern.h"
  17 #include "mui.h"
  18 #include "support.h"
  19
  20 #include "debug.h"
  21
  22 /*****************************************************************************
  23
  24     NAME */
  25         AROS_LH2(VOID, MUI_Redraw,
  26
  27 /*  SYNOPSIS */
  28         AROS_LHA(Object *, obj, A0),
  29         AROS_LHA(ULONG, flags, D0),
  30
  31 /*  LOCATION */
  32         struct Library *, MUIMasterBase, 17, MUIMaster)
  33
  34 /*  FUNCTION
  35
  36     INPUTS
  37
  38     RESULT
  39
  40     NOTES
  41
  42     EXAMPLE
  43
  44     BUGS
  45
  46     SEE ALSO
  47
  48     INTERNALS
  49
  50     HISTORY
  51
  52 *****************************************************************************/
  53 {
  54     AROS_LIBFUNC_INIT
  55
  56     APTR clip = (APTR)-1;
  57     IPTR disabled;
  58
  59     if (!(_flags(obj) & MADF_CANDRAW)) return;
  60
  61     if (_flags(obj) & MADF_INVIRTUALGROUP)
  62     {
  63         Object *wnd;
  64         Object *parent;
  65         struct Region *region = NULL;
  66
  67         get(obj,MUIA_WindowObject,&wnd);
  68         parent = obj;
  69
  70         while (get(parent,MUIA_Parent,&parent))
  71         {
  72             if (!parent) break;
  73             if (parent == wnd) break;
  74
  75             if (_flags(parent) & MADF_ISVIRTUALGROUP)
  76             {
  77                 struct Rectangle rect;
  78
  79                 rect.MinX = _mleft(parent);
  80                 rect.MinY = _mtop(parent);
  81                 rect.MaxX = _mright(parent);
  82                 rect.MaxY = _mbottom(parent);
  83
  84                 if (!region)
  85                 {
  86                     if ((region = NewRegion()))
  87                     {
  88                         OrRectRegion(region, &rect);
  89                     }
  90                 } else
  91                 {
  92                     AndRectRegion(region, &rect);
  93                 }
  94             }
  95         }
  96
  97         if (region)
  98         {
  99             clip = MUI_AddClipRegion(muiRenderInfo(obj),region);
 100         }
 101
 102     } /* if object is in a virtual group */
 103
 104     if (1)
 105     {
 106         struct Region *region;
 107         struct Rectangle *clip_rect;
 108         struct Layer *l;
 109
 110         clip_rect = &muiRenderInfo(obj)->mri_ClipRect;
 111
 112         if (muiRenderInfo(obj)->mri_Window)
 113         {
 114             l = muiRenderInfo(obj)->mri_Window->WLayer;
 115         }
 116         else
 117         {
 118             l = muiRenderInfo(obj)->mri_RastPort->Layer;
 119         }
 120
 121         if (l && (region = l->ClipRegion))
 122         {
 123             /* Maybe this should went to MUI_AddClipRegion() */
 124             clip_rect->MinX = MAX(_left(obj),region->bounds.MinX);
 125             clip_rect->MinY = MAX(_top(obj),region->bounds.MinY);
 126             clip_rect->MaxX = MIN(_right(obj),region->bounds.MaxX);
 127             clip_rect->MaxY = MIN(_bottom(obj),region->bounds.MaxY);
 128
 129         } else
 130         {
 131             clip_rect->MinX = _left(obj);
 132             clip_rect->MinY = _top(obj);
 133             clip_rect->MaxX = _right(obj);
 134             clip_rect->MaxY = _bottom(obj);
 135         }
 136     }
 137
 138     _flags(obj) = (_flags(obj) & ~MADF_DRAWFLAGS) | (flags & MADF_DRAWFLAGS);
 139
 140     DoMethod(obj, MUIM_Draw, 0);
 141
 142     if (get(obj, MUIA_Disabled, &disabled))
 143     {
 144 #if 0
 145         /*
 146           Commented out, because group childs were drawn wrongly
 147           when they have been disabled while window is open.
 148         */
 149         if (_parent(obj))
 150         {
 151             IPTR parentDisabled;
 152             if (get(_parent(obj), MUIA_Disabled, &parentDisabled))
 153             {
 154                 /* Let the parent draw the pattern... */
 155                 if (parentDisabled) disabled = FALSE;
 156             }
 157         }
 158 #endif
 159
 160         if (disabled)
 161         {
 162 #ifdef __AROS__
 163 #if 0
 164             /*
 165               This aproach might be faster *provided* that the buffer is
 166               allocated and filled *once* at startup of muimaster.library.
 167
 168               In reality, the WritePixelArray() call has quite a big
 169               overhead, so you should only use this buffer if the gadget
 170               completely fits inside, and fall back to allocating a new
 171               buffer if the gadget is too big.
 172
 173               Perhaps a future optimization...
 174             */
 175             LONG  width  = 200;
 176             LONG  height = 100;
 177             LONG *buffer = AllocVec(width * height * sizeof(LONG), MEMF_ANY);
 178             LONG  x, y;
 179
 180             memset(buffer, 0xAA, width * height * sizeof(LONG));
 181
 182             for (y = 0; y < _height(obj); y += height)
 183             {
 184                 for (x = 0; x < _width(obj); x += width)
 185                 {
 186                     WritePixelArrayAlpha
 187                     (
 188                         buffer, 0, 0, width * sizeof(LONG),
 189                         _rp(obj), _left(obj) + x, _top(obj) + y,
 190                         x + width  > _width(obj)  ? _width(obj)  - x : width,
 191                         y + height > _height(obj) ? _height(obj) - y : height,
 192                         0xffffffff
 193                     );
 194                 }
 195             }
 196 #else
 197             LONG  width  = _width(obj);
 198             LONG  height = _height(obj);
 199             LONG *buffer = NULL;
 200
 201             if (GetBitMapAttr(_rp(obj)->BitMap, BMA_DEPTH) >= 15)
 202             {
 203                 buffer = AllocVec(width * sizeof(LONG), MEMF_ANY);
 204             }
 205
 206             if (buffer != NULL)
 207             {
 208                 memset(buffer, 0xAA, width * sizeof(LONG));
 209
 210                 WritePixelArrayAlpha
 211                 (
 212                     buffer, 0, 0, 0,
 213                     _rp(obj), _left(obj), _top(obj), width, height,
 214                     0xffffffff
 215                 );
 216                 FreeVec(buffer);
 217             }   else
 218 #endif
 219 #endif
 220             {
 221                 /* fallback */
 222                 const static UWORD pattern[] = { 0x8888, 0x2222, };
 223                 LONG fg = muiRenderInfo(obj)->mri_Pens[MPEN_SHADOW];
 224
 225                 SetDrMd(_rp(obj), JAM1);
 226                 SetAPen(_rp(obj), fg);
 227                 SetAfPt(_rp(obj), pattern, 1);
 228                 RectFill(_rp(obj), _left(obj), _top(obj), _right(obj), _bottom(obj));
 229                 SetAfPt(_rp(obj), NULL, 0);
 230             }
 231         }
 232     } /* if (object is disabled) */
 233
 234     /* copy buffer to window */
 235     if (muiRenderInfo(obj)->mri_BufferBM)
 236     {
 237         ClipBlit(&muiRenderInfo(obj)->mri_BufferRP, _left(obj), _top(obj),
 238                  muiRenderInfo(obj)->mri_Window->RPort, _left(obj), _top(obj),
 239                  _width(obj), _height(obj), 0xc0);
 240     }
 241
 242     if (clip != (APTR)-1)
 243     {
 244         /* This call actually also frees the region */
 245         MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
 246     }
 247
 248     AROS_LIBFUNC_EXIT
 249
 250 } /* MUIA_Redraw */