libs/backends/GP_Backend.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-2013 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 #include <inttypes.h>
  24 #include <poll.h>
  25
  26 #include "core/GP_Common.h"
  27 #include "core/GP_Transform.h"
  28 #include "core/GP_Debug.h"
  29
  30 #include "input/GP_EventQueue.h"
  31 #include "input/GP_TimeStamp.h"
  32
  33 #include "backends/GP_Backend.h"
  34
  35 void GP_BackendFlip(GP_Backend *backend)
  36 {
  37         if (backend->Flip != NULL)
  38                 backend->Flip(backend);
  39 }
  40
  41 void GP_BackendUpdateRectXYXY(GP_Backend *backend,
  42                               GP_Coord x0, GP_Coord y0,
  43                               GP_Coord x1, GP_Coord y1)
  44 {
  45         if (backend->UpdateRect == NULL)
  46                 return;
  47
  48         GP_TRANSFORM_POINT(backend->pixmap, x0, y0);
  49         GP_TRANSFORM_POINT(backend->pixmap, x1, y1);
  50
  51         if (x1 < x0)
  52                 GP_SWAP(x0, x1);
  53
  54         if (y1 < y0)
  55                 GP_SWAP(y0, y1);
  56
  57         if (x0 < 0) {
  58                 GP_WARN("Negative x coordinate %i, clipping to 0", x0);
  59                 x0 = 0;
  60         }
  61
  62         if (y0 < 0) {
  63                 GP_WARN("Negative y coordinate %i, clipping to 0", y0);
  64                 y0 = 0;
  65         }
  66
  67         GP_Coord w = backend->pixmap->w;
  68
  69         if (x1 >= w) {
  70                 GP_WARN("Too large x coordinate %i, clipping to %u", x1, w - 1);
  71                 x1 = w - 1;
  72         }
  73
  74         GP_Coord h = backend->pixmap->h;
  75
  76         if (y1 >= h) {
  77                 GP_WARN("Too large y coordinate %i, clipping to %u", y1, h - 1);
  78                 y1 = h - 1;
  79         }
  80
  81         backend->UpdateRect(backend, x0, y0, x1, y1);
  82 }
  83
  84
  85 int GP_BackendResize(GP_Backend *backend, uint32_t w, uint32_t h)
  86 {
  87         if (backend->SetAttributes == NULL)
  88                 return 1;
  89
  90         if (w == 0)
  91                 w = backend->pixmap->w;
  92
  93         if (h == 0)
  94                 h = backend->pixmap->h;
  95
  96         if (backend->pixmap->w == w && backend->pixmap->h == h)
  97                 return 0;
  98
  99         return backend->SetAttributes(backend, w, h, NULL);
 100 }
 101
 102 int GP_BackendResizeAck(GP_Backend *self)
 103 {
 104         GP_DEBUG(2, "Calling backend %s ResizeAck()", self->name);
 105
 106         if (self->ResizeAck)
 107                 return self->ResizeAck(self);
 108
 109         return 0;
 110 }
 111
 112 static uint32_t pushevent_callback(GP_Timer *self)
 113 {
 114         GP_Event ev;
 115
 116         ev.type = GP_EV_TMR;
 117         gettimeofday(&ev.time, NULL);
 118         ev.val.tmr = self;
 119
 120         GP_EventQueuePut(self->_priv, &ev);
 121
 122         return 0;
 123 }
 124
 125 void GP_BackendAddTimer(GP_Backend *self, GP_Timer *timer)
 126 {
 127         if (timer->Callback == NULL) {
 128                 timer->Callback = pushevent_callback;
 129                 timer->_priv = &self->event_queue;
 130         }
 131
 132         GP_TimerQueueInsert(&self->timers, GP_GetTimeStamp(), timer);
 133 }
 134
 135 void GP_BackendRemTimer(GP_Backend *self, GP_Timer *timer)
 136 {
 137         GP_TimerQueueRemove(&self->timers, timer);
 138 }
 139
 140 void GP_BackendPoll(GP_Backend *self)
 141 {
 142         self->Poll(self);
 143
 144         if (self->timers)
 145                 GP_TimerQueueProcess(&self->timers, GP_GetTimeStamp());
 146 }
 147
 148 static void wait_timers_fd(GP_Backend *self, uint64_t now)
 149 {
 150         int timeout;
 151
 152         timeout = self->timers->expires - now;
 153
 154         struct pollfd fd = {.fd = self->fd, .events = POLLIN, fd.revents = 0};
 155
 156         if (poll(&fd, 1, timeout))
 157                 self->Poll(self);
 158
 159         now = GP_GetTimeStamp();
 160
 161         GP_TimerQueueProcess(&self->timers, now);
 162 }
 163
 164 /*
 165  * Polling for backends that does not expose FD to wait on (namely SDL).
 166  */
 167 static void wait_timers_poll(GP_Backend *self)
 168 {
 169         for (;;) {
 170                 uint64_t now = GP_GetTimeStamp();
 171
 172                 if (GP_TimerQueueProcess(&self->timers, now))
 173                         return;
 174
 175                 self->Poll(self);
 176
 177                 if (GP_BackendEventsQueued(self))
 178                         return;
 179
 180                 usleep(10000);
 181         }
 182 }
 183
 184 void GP_BackendWait(GP_Backend *self)
 185 {
 186         if (self->timers) {
 187                 uint64_t now = GP_GetTimeStamp();
 188
 189                 /* Get rid of possibly expired timers */
 190                 if (GP_TimerQueueProcess(&self->timers, now))
 191                         return;
 192
 193                 /* Wait for events or timer expiration */
 194                 if (self->fd != -1)
 195                         wait_timers_fd(self, now);
 196                 else
 197                         wait_timers_poll(self);
 198
 199                 return;
 200         }
 201
 202         self->Wait(self);
 203 }
 204
 205 int GP_BackendWaitEvent(GP_Backend *self, GP_Event *ev)
 206 {
 207         int ret;
 208
 209         for (;;) {
 210                 if ((ret = GP_BackendGetEvent(self, ev)))
 211                         return ret;
 212
 213                 GP_BackendWait(self);
 214         }
 215 }
 216
 217 int GP_BackendPollEvent(GP_Backend *self, GP_Event *ev)
 218 {
 219         int ret;
 220
 221         if ((ret = GP_BackendGetEvent(self, ev)))
 222                 return ret;
 223
 224         GP_BackendPoll(self);
 225
 226         if ((ret = GP_BackendGetEvent(self, ev)))
 227                 return ret;
 228
 229         return 0;
 230 }