libs/backends/GP_BackendVirtual.c

   1 /*****************************************************************************
   2  * This file is part of gfxprim library.                                     *
   3  *                                                                           *
   4  * Gfxprim is free software; you can redistribute it and/or                  *
   5  * modify it under the terms of the GNU Lesser General Public                *
   6  * License as published by the Free Software Foundation; either              *
   7  * version 2.1 of the License, or (at your option) any later version.        *
   8  *                                                                           *
   9  * Gfxprim is distributed in the hope that it will be useful,                *
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  12  * Lesser General Public License for more details.                           *
  13  *                                                                           *
  14  * You should have received a copy of the GNU Lesser General Public          *
  15  * License along with gfxprim; if not, write to the Free Software            *
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                        *
  17  * Boston, MA  02110-1301  USA                                               *
  18  *                                                                           *
  19  * Copyright (C) 2009-2012 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 #include <string.h>
  24
  25 #include "core/GP_Context.h"
  26 #include "core/GP_Blit.h"
  27 #include "core/GP_Debug.h"
  28
  29 #include "GP_BackendVirtual.h"
  30
  31 struct virt_priv {
  32         /* Original backend */
  33         GP_Backend *backend;
  34
  35         int flags;
  36 };
  37
  38 static void virt_flip(GP_Backend *self)
  39 {
  40         struct virt_priv *virt = GP_BACKEND_PRIV(self);
  41
  42         /* Convert and copy the buffer */
  43         GP_Blit(self->context, 0, 0, self->context->w, self->context->h,
  44                 virt->backend->context, 0, 0);
  45
  46         /* Call blit on original backend */
  47         virt->backend->Flip(virt->backend);
  48 }
  49
  50 static void virt_update_rect(GP_Backend *self, GP_Coord x0, GP_Coord y0,
  51                              GP_Coord x1, GP_Coord y1)
  52 {
  53         struct virt_priv *virt = GP_BACKEND_PRIV(self);
  54
  55         /* Convert and copy the buffer */
  56         GP_BlitXYXY(self->context, x0, y0, x1, y1,
  57                     virt->backend->context, x0, y0);
  58
  59         /* Call blit on original backend */
  60         virt->backend->UpdateRect(virt->backend, x0, y0, x1, y1);
  61 }
  62
  63 static int virt_set_attributes(struct GP_Backend *self,
  64                                uint32_t w, uint32_t h,
  65                                const char *caption)
  66 {
  67         struct virt_priv *virt = GP_BACKEND_PRIV(self);
  68         int ret;
  69
  70         ret = virt->backend->SetAttributes(virt->backend, w, h, caption);
  71
  72         if (ret)
  73                 return ret;
  74
  75         /* If backend was resized, update our buffer as well */
  76         if (h != 0 && w != 0)
  77                 GP_ContextResize(self->context, w, h);
  78
  79         return 0;
  80 }
  81
  82 static void virt_poll(GP_Backend *self)
  83 {
  84         struct virt_priv *virt = GP_BACKEND_PRIV(self);
  85
  86         virt->backend->Poll(virt->backend);
  87 }
  88
  89 static void virt_exit(GP_Backend *self)
  90 {
  91         struct virt_priv *virt = GP_BACKEND_PRIV(self);
  92
  93         GP_ContextFree(self->context);
  94
  95         if (virt->flags & GP_BACKEND_CALL_EXIT)
  96                 virt->backend->Exit(virt->backend);
  97
  98         free(self);
  99 }
 100
 101 GP_Backend *GP_BackendVirtualInit(GP_Backend *backend,
 102                                   GP_PixelType pixel_type, int flags)
 103 {
 104         GP_Backend *self;
 105         struct virt_priv *virt;
 106
 107         self = malloc(sizeof(GP_Backend) +
 108                       sizeof(struct virt_priv));
 109
 110         if (self == NULL) {
 111                 GP_DEBUG(1, "Malloc failed :(");
 112                 return NULL;
 113         }
 114
 115         memset(self, 0, sizeof(GP_Backend));
 116
 117         /* Create new buffer with different context type */
 118         self->context = GP_ContextAlloc(backend->context->w, backend->context->h,
 119                                         pixel_type);
 120
 121         if (self->context == NULL)
 122                 goto err0;
 123
 124         virt = GP_BACKEND_PRIV(self);
 125         virt->backend = backend;
 126         virt->flags = flags;
 127
 128         /* Initalize new backend */
 129         self->name          = "Virtual Backend";
 130         self->Flip          = virt_flip;
 131         self->UpdateRect    = virt_update_rect;
 132         self->Exit          = virt_exit;
 133
 134         if (backend->Poll)
 135                 self->Poll = virt_poll;
 136
 137         if (backend->SetAttributes)
 138                 self->SetAttributes = virt_set_attributes;
 139
 140         return self;
 141
 142 err0:
 143         free(self);
 144         return NULL;
 145 }