libs/backends/GP_BackendInit.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_Debug.h"
  26
  27 #include "GP_Backends.h"
  28 #include "GP_BackendInit.h"
  29
  30 static void backend_sdl_help(FILE *help, const char *err)
  31 {
  32         if (help == NULL)
  33                 return;
  34
  35         if (err != NULL)
  36                 fprintf(help, "ERROR: %s\n", err);
  37
  38         fprintf(help, "libSDL backend\n"
  39                       "--------------\n"
  40                       "SDL:[FS]:[WxH]\n"
  41                       " FS  - Full Screen mode\n"
  42                       " WxH - Display Size\n");
  43 }
  44
  45 static int sdl_params_to_flags(const char *param, GP_Size *w, GP_Size *h,
  46                                uint8_t *flags, FILE *help)
  47 {
  48         if (!strcasecmp(param, "FS")) {
  49                 *flags |= GP_SDL_FULLSCREEN;
  50                 return 0;
  51         }
  52
  53         /*
  54          * Accepts only string with format "intxint" or "intXint"
  55          */
  56         int sw, sh;
  57         unsigned int n;
  58
  59         if (sscanf(param, "%i%*[xX]%i%n", &sw, &sh, &n) == 2 && n == strlen(param)) {
  60                 *w = sw;
  61                 *h = sh;
  62                 return 0;
  63         }
  64
  65         backend_sdl_help(help, "SDL: Invalid parameters");
  66         return 1;
  67 }
  68
  69 static GP_Backend *backend_sdl_init(char *params, const char *caption,
  70                                     FILE *help)
  71 {
  72         if (params == NULL)
  73                 return GP_BackendSDLInit(0, 0, 0, 0, caption);
  74
  75         GP_Size w = 0, h = 0;
  76         uint8_t flags = GP_SDL_RESIZABLE;
  77
  78         char *s = params;
  79
  80         for (;;) {
  81                 switch (*s) {
  82                 case ':':
  83                         (*s) = '\0';
  84                         if (sdl_params_to_flags(params, &w, &h, &flags, help))
  85                                 return NULL;
  86                         s++;
  87                         params = s;
  88                 break;
  89                 case '\0':
  90                         if (sdl_params_to_flags(params, &w, &h, &flags, help))
  91                                 return NULL;
  92
  93                         return GP_BackendSDLInit(w, h, 0, flags, caption);
  94                 break;
  95                 }
  96                 s++;
  97         }
  98 }
  99
 100 static void backend_fb_help(FILE *help, const char *err)
 101 {
 102         if (help == NULL)
 103                 return;
 104
 105         if (err != NULL)
 106                 fprintf(help, "ERROR: %s\n", err);
 107
 108         fprintf(help, "LinuxFB backend\n"
 109                       "--------------\n"
 110                       "FB:[/dev/fbX]\n");
 111 }
 112
 113 static GP_Backend *backend_fb_init(char *params, const char *caption,
 114                                    FILE *help)
 115 {
 116         const char *fb = "/dev/fb0";
 117
 118         (void) help;
 119         (void) caption;
 120
 121         if (params != NULL)
 122                 fb = params;
 123
 124         return GP_BackendLinuxFBInit(fb, 1);
 125 }
 126
 127 static void backend_x11_help(FILE *help, const char *err)
 128 {
 129         if (help == NULL)
 130                 return;
 131
 132         if (err != NULL)
 133                 fprintf(help, "ERROR: %s\n", err);
 134
 135         fprintf(help, "X11 backend\n"
 136                       "--------------\n"
 137                       "X11:WxH:[ROOT_WIN]\n\n"
 138                       "ROOT_WIN - starts the backend in the root window\n"
 139                       "           (w and h, if set, are ignored)\n");
 140 }
 141
 142 static int x11_params_to_flags(const char *param, GP_Size *w, GP_Size *h,
 143                                enum GP_BackendX11Flags *flags, FILE *help)
 144 {
 145         if (!strcasecmp(param, "ROOT_WIN")) {
 146                 *flags |= GP_X11_USE_ROOT_WIN;
 147                 return 0;
 148         }
 149
 150         /*
 151          * Accepts only string with format "intxint" or "intXint"
 152          */
 153         int sw, sh;
 154         unsigned int n;
 155
 156         if (sscanf(param, "%i%*[xX]%i%n", &sw, &sh, &n) == 2 && n == strlen(param)) {
 157                 *w = sw;
 158                 *h = sh;
 159                 return 0;
 160         }
 161
 162         backend_sdl_help(help, "X11: Invalid parameters");
 163         return 1;
 164 }
 165
 166
 167 static GP_Backend *backend_x11_init(char *params, const char *caption,
 168                                     FILE *help)
 169 {
 170         GP_Size w = 640, h = 480;
 171         enum GP_BackendX11Flags flags = 0;
 172
 173         if (params == NULL)
 174                 return GP_BackendX11Init(NULL, 0, 0, w, h, caption, 0);
 175
 176         char *s = params;
 177
 178         for (;;) {
 179                 switch (*s) {
 180                 case ':':
 181                         (*s) = '\0';
 182                         if (x11_params_to_flags(params, &w, &h, &flags, help))
 183                                 return NULL;
 184                         s++;
 185                         params = s;
 186                 break;
 187                 case '\0':
 188                         if (x11_params_to_flags(params, &w, &h, &flags, help))
 189                                 return NULL;
 190
 191                         return GP_BackendX11Init(NULL, 0, 0, w, h, caption, flags);
 192                 break;
 193                 }
 194                 s++;
 195         }
 196 }
 197
 198 static const char *backend_names[] = {
 199         "SDL", /* libSDL            */
 200         "FB",  /* Linux Framebuffer */
 201         "X11", /* X11 window system */
 202         NULL,
 203 };
 204
 205 static GP_Backend *(*backend_inits[])(char *, const char *, FILE *) = {
 206         backend_sdl_init,
 207         backend_fb_init,
 208         backend_x11_init,
 209         NULL,
 210 };
 211
 212 static void (*backend_helps[])(FILE *help, const char *err) = {
 213         backend_sdl_help,
 214         backend_fb_help,
 215         backend_x11_help,
 216         NULL,
 217 };
 218
 219 static void print_help(FILE *help, char *err)
 220 {
 221         int i;
 222
 223         if (help == NULL)
 224                 return;
 225
 226         if (err != NULL) {
 227                 fprintf(help, "ERROR: %s\n", err);
 228                 fprintf(help, "\n");
 229         }
 230
 231         fprintf(help, "Backends usage\n"
 232                       "--------------\n\n");
 233
 234         for (i = 0; backend_helps[i] != NULL; i++) {
 235                 backend_helps[i](help, NULL);
 236                 fprintf(help, "\n");
 237         }
 238 }
 239
 240 static int get_backend(const char *name)
 241 {
 242         int i;
 243
 244         for (i = 0; backend_names[i] != 0; i++)
 245                 if (!strcasecmp(name, backend_names[i]))
 246                         return i;
 247
 248         return -1;
 249 }
 250
 251 static GP_Backend *init_backend(const char *name, char *params,
 252                                 const char *caption, FILE *help)
 253 {
 254         int i = get_backend(name);
 255
 256         if (i < 0) {
 257                 GP_DEBUG(1, "Invalid backend name '%s'", name);
 258                 print_help(help, "Invalid backend name");
 259                 return NULL;
 260         }
 261
 262         return backend_inits[i](params, caption, help);
 263 }
 264
 265 GP_Backend *GP_BackendInit(const char *params, const char *caption, FILE *help)
 266 {
 267         if (params == NULL) {
 268                 print_help(help, NULL);
 269                 return NULL;
 270         }
 271
 272         /* parse backend name */
 273         int i, len = strlen(params);
 274         char buf[len+1], *backend_params = NULL;
 275
 276         strcpy(buf, params);
 277
 278         for (i = 0; i < len; i++) {
 279                 if (buf[i] == ':') {
 280                         buf[i] = '\0';
 281                         backend_params = buf + i + 1;
 282                         break;
 283                 }
 284         }
 285
 286         GP_DEBUG(1, "Have backend name '%s' params '%s'", buf, backend_params);
 287
 288         return init_backend(buf, backend_params, caption, help);
 289 }