rom/intuition/allocscreenbuffer.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/cybergraphics.h>
   9 #include <exec/exec.h>
  10 #include <cybergraphx/cybergraphics.h>
  11 #include "intuition_intern.h"
  12 /*****************************************************************************
  13
  14     NAME */
  15 #include <intuition/screens.h>
  16 #include <proto/intuition.h>
  17
  18     AROS_LH3(struct ScreenBuffer *, AllocScreenBuffer,
  19
  20 /*  SYNOPSIS */
  21          AROS_LHA(struct Screen *, screen, A0),
  22          AROS_LHA(struct BitMap *, bitmap, A1),
  23          AROS_LHA(ULONG          , flags, D0),
  24
  25 /*  LOCATION */
  26          struct IntuitionBase *, IntuitionBase, 128, Intuition)
  27
  28 /*  FUNCTION
  29     Allocate a ScreenBuffer (and BitMap) for double or multiple
  30     buffering in Intuition screens. Use this function to obtain a
  31     ScreenBuffer for the screen's initial BitMap and for all other
  32     BitMaps you want to swap in.
  33
  34     This function also allocates a DBufInfo from graphics.library
  35     The returned ScreenBuffer contains a pointer to that DBufInfo.
  36     See graphics.library/AllocDBufInfo() for more information on
  37     how to use this struct to obtain info when it is safe to render
  38     into an old buffer and when to switch.
  39
  40     INPUTS
  41     screen - Screen to double-buffer
  42     bitmap - You may pre-allocate a BitMap for CUSTOMBITMAP screens,
  43         and pass the pointer to get a ScreenBuffer referring to it.
  44         If you specify NULL, intuition will allocate the BitMap for
  45         you. For non-CUSTOMBITMAP screens this parameter must be NULL.
  46     flags - A combination of these flags:
  47         SB_SCREEN_BITMAP for non-CUSTOMBITMAP screens to get a
  48         ScreenBuffer referring to the screen's actual BitMap
  49         (For CUSTOMBITMAP screens just pass the BitMap you used for
  50         OpenScreen() as the bitmap parameter)
  51         SB_COPY_BITMAP to copy the screen's BitMap intto the
  52         ScreenBuffer's BitMap. Use this to get intuition rendered
  53         stuff into your bitmap (such as menu-bars or gadgets).
  54         May be omitted if the screen has no intuition rendered stuff,
  55         as well as for allocating a ScreenBuffer for the screen's
  56         initial BitMap.
  57
  58
  59     RESULT
  60     Pointer to the allocated ScreenBuffer or NULL if function failed.
  61
  62     NOTES
  63     You may render into the resulting BitMap.
  64     Use the sb_DBufInfo field to access graphics.library's ViewPort
  65     buffering features to e.g check if it is safe to reuse the previous
  66     BitMap. Otherwise you risk to write into the on-screen BitMap and
  67     damage menu or gadget rendering.
  68
  69     EXAMPLE
  70
  71     BUGS
  72
  73     SEE ALSO
  74     FreeScreenBuffer(), ChangeScreenBuffer()
  75
  76     INTERNALS
  77
  78     HISTORY
  79
  80 *****************************************************************************/
  81 {
  82     AROS_LIBFUNC_INIT
  83
  84     struct IntScreenBuffer *ScreenBuffer = NULL;
  85
  86     DEBUG_ALLOCSCREENBUFFER(dprintf("AllocScreenBuffer: Screen 0x%lx BitMap 0x%lx Flags 0x%lx\n",
  87                                     screen, bitmap, flags));
  88
  89     if (screen)
  90     {
  91         if ((ScreenBuffer = AllocMem(sizeof (struct IntScreenBuffer),
  92                                      MEMF_CLEAR)))
  93         {
  94             if ((ScreenBuffer->sb.sb_DBufInfo =
  95                         AllocDBufInfo(&screen->ViewPort)))
  96             {
  97                 if (!bitmap)
  98                 {
  99                     /* Get a bitmap */
 100                     if (flags & SB_SCREEN_BITMAP)
 101                     {
 102                         bitmap = screen->RastPort.BitMap;
 103                     }
 104                     else
 105                     {
 106                         ScreenBuffer->free_bitmap = TRUE;
 107
 108                         bitmap = AllocBitMap(GetBitMapAttr(screen->RastPort.BitMap,BMA_WIDTH),
 109                                              GetBitMapAttr(screen->RastPort.BitMap,BMA_HEIGHT),
 110                                              GetBitMapAttr(screen->RastPort.BitMap,BMA_DEPTH),
 111                                              BMF_MINPLANES|BMF_DISPLAYABLE|BMF_CLEAR,
 112                                              screen->RastPort.BitMap);
 113
 114                         if (NULL == bitmap)
 115                         {
 116                             FreeDBufInfo(ScreenBuffer->sb.sb_DBufInfo);
 117                             FreeMem(ScreenBuffer, sizeof(struct IntScreenBuffer));
 118                             DEBUG_ALLOCSCREENBUFFER(dprintf("AllocScreenBuffer: failed\n"));
 119
 120                             return NULL;
 121                         }
 122                     }
 123                 }
 124
 125                 ScreenBuffer->sb.sb_BitMap = bitmap;
 126
 127                 if (flags & SB_COPY_BITMAP)
 128                 {
 129                     BltBitMap(screen->RastPort.BitMap,
 130                               0,
 131                               0,
 132                               bitmap,
 133                               0,
 134                               0,
 135                               screen->Width,
 136                               screen->Height,
 137                               0x0c0, /* copy */
 138                               ~0,
 139                               NULL);
 140                 }
 141
 142                 DEBUG_ALLOCSCREENBUFFER(dprintf("AllocScreenBuffer: ScreenBuffer 0x%lx BitMap 0x%lx DBufInfo 0x%lx\n",
 143                                                 ScreenBuffer, bitmap, ScreenBuffer->sb.sb_DBufInfo));
 144
 145                 return &ScreenBuffer->sb;
 146             }
 147
 148             FreeMem(ScreenBuffer, sizeof(struct IntScreenBuffer));
 149         }
 150     }
 151
 152     DEBUG_ALLOCSCREENBUFFER(dprintf("AllocScreenBuffer: no mem\n"));
 153
 154     return NULL;
 155
 156     AROS_LIBFUNC_EXIT
 157 } /* AllocScreenBuffer */