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         The function itself is a bug ;-) Remove it!
  46
  47     SEE ALSO
  48
  49     INTERNALS
  50
  51     HISTORY
  52
  53 *****************************************************************************/
  54 {
  55     AROS_LIBFUNC_INIT
  56
  57     APTR clip = (APTR)-1;
  58     ULONG disabled;
  59
  60     if (!(_flags(obj) & MADF_CANDRAW)) return;
  61
  62     if (_flags(obj) & MADF_INVIRTUALGROUP)
  63     {
  64         Object *wnd;
  65         Object *parent;
  66         struct Region *region = NULL;
  67
  68         get(obj,MUIA_WindowObject,&wnd);
  69         parent = obj;
  70
  71         while (get(parent,MUIA_Parent,&parent))
  72         {
  73             if (!parent) break;
  74             if (parent == wnd) break;
  75
  76             if (_flags(parent) & MADF_ISVIRTUALGROUP)
  77             {
  78                 struct Rectangle rect;
  79
  80                 rect.MinX = _mleft(parent);
  81                 rect.MinY = _mtop(parent);
  82                 rect.MaxX = _mright(parent);
  83                 rect.MaxY = _mbottom(parent);
  84
  85                 if (!region)
  86                 {
  87                     if ((region = NewRegion()))
  88                     {
  89                         OrRectRegion(region, &rect);
  90                     }
  91                 } else
  92                 {
  93                     AndRectRegion(region, &rect);
  94                 }
  95             }
  96         }
  97
  98         if (region)
  99         {
 100             clip = MUI_AddClipRegion(muiRenderInfo(obj),region);
 101         }
 102
 103     } /* if object is in a virtual group */
 104
 105     if (1)
 106     {
 107         struct Region *region;
 108         struct Rectangle *clip_rect;
 109         struct Layer *l;
 110
 111         clip_rect = &muiRenderInfo(obj)->mri_ClipRect;
 112
 113         if (muiRenderInfo(obj)->mri_Window)
 114         {
 115             l = muiRenderInfo(obj)->mri_Window->WLayer;
 116         }
 117         else
 118         {
 119             l = muiRenderInfo(obj)->mri_RastPort->Layer;
 120         }
 121
 122         if (l && (region = l->ClipRegion))
 123         {
 124             /* Maybe this should went to MUI_AddClipRegion() */
 125             clip_rect->MinX = MAX(_left(obj),region->bounds.MinX);
 126             clip_rect->MinY = MAX(_top(obj),region->bounds.MinY);
 127             clip_rect->MaxX = MIN(_right(obj),region->bounds.MaxX);
 128             clip_rect->MaxY = MIN(_bottom(obj),region->bounds.MaxY);
 129
 130         } else
 131         {
 132             clip_rect->MinX = _left(obj);
 133             clip_rect->MinY = _top(obj);
 134             clip_rect->MaxX = _right(obj);
 135             clip_rect->MaxY = _bottom(obj);
 136         }
 137     }
 138
 139     _flags(obj) = (_flags(obj) & ~MADF_DRAWFLAGS) | (flags & MADF_DRAWFLAGS);
 140
 141     DoMethod(obj, MUIM_Draw, 0);
 142
 143     if (get(obj, MUIA_Disabled, &disabled))
 144     {
 145         if (_parent(obj))
 146         {
 147             ULONG parentDisabled;
 148             if (get(_parent(obj), MUIA_Disabled, &parentDisabled))
 149             {
 150                 /* Let the parent draw the pattern... */
 151                 if (parentDisabled) disabled = FALSE;
 152             }
 153         }
 154
 155         if (disabled)
 156         {
 157 #ifdef __AROS__
 158 #if 0
 159             /*
 160               This aproach might be faster *provided* that the buffer is
 161               allocated and filled *once* at startup of muimaster.library.
 162
 163               In reality, the WritePixelArray() call has quite a big
 164               overhead, so you should only use this buffer if the gadget
 165               completely fits inside, and fall back to allocating a new
 166               buffer if the gadget is too big.
 167
 168               Perhaps a future optimization...
 169             */
 170             LONG  width  = 200;
 171             LONG  height = 100;
 172             LONG *buffer = AllocVec(width * height * sizeof(LONG), MEMF_ANY);
 173             LONG  x, y;
 174
 175             memset(buffer, 0xAA, width * height * sizeof(LONG));
 176
 177             for (y = 0; y < _height(obj); y += height)
 178             {
 179                 for (x = 0; x < _width(obj); x += width)
 180                 {
 181                     WritePixelArrayAlpha
 182                     (
 183                         buffer, 0, 0, width * sizeof(LONG),
 184                         _rp(obj), _left(obj) + x, _top(obj) + y,
 185                         x + width  > _width(obj)  ? _width(obj)  - x : width,
 186                         y + height > _height(obj) ? _height(obj) - y : height,
 187                         0xffffffff
 188                     );
 189                 }
 190             }
 191 #else
 192             LONG  width  = _width(obj);
 193             LONG  height = _height(obj);
 194             LONG *buffer = NULL;
 195
 196             if (GetBitMapAttr(_rp(obj)->BitMap, BMA_DEPTH) >= 15)
 197             {
 198                 buffer = AllocVec(width * sizeof(LONG), MEMF_ANY);
 199             }
 200
 201             if (buffer != NULL)
 202             {
 203                 memset(buffer, 0xAA, width * sizeof(LONG));
 204
 205                 WritePixelArrayAlpha
 206                 (
 207                     buffer, 0, 0, 0,
 208                     _rp(obj), _left(obj), _top(obj), width, height,
 209                     0xffffffff
 210                 );
 211                 FreeVec(buffer);
 212             }   else
 213 #endif
 214 #endif
 215             {
 216                 /* fallback */
 217                 const static UWORD pattern[] = { 0x8888, 0x2222, };
 218                 LONG fg = muiRenderInfo(obj)->mri_Pens[MPEN_SHADOW];
 219
 220                 SetDrMd(_rp(obj), JAM1);
 221                 SetAPen(_rp(obj), fg);
 222                 SetAfPt(_rp(obj), pattern, 1);
 223                 RectFill(_rp(obj), _left(obj), _top(obj), _right(obj), _bottom(obj));
 224                 SetAfPt(_rp(obj), NULL, 0);
 225             }
 226         }
 227     } /* if (object is disabled) */
 228
 229     /* copy buffer to window */
 230     if (muiRenderInfo(obj)->mri_BufferBM)
 231     {
 232         ClipBlit(&muiRenderInfo(obj)->mri_BufferRP, _left(obj), _top(obj),
 233                  muiRenderInfo(obj)->mri_Window->RPort, _left(obj), _top(obj),
 234                  _width(obj), _height(obj), 0xc0);
 235     }
 236
 237     if (clip != (APTR)-1)
 238     {
 239         /* This call actually also frees the region */
 240         MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
 241     }
 242
 243     AROS_LIBFUNC_EXIT
 244
 245         } /* MUIA_Redraw */