cairo-util.c \
cairo-util.h
-toolkit_libs = \
- libtoytoolkit.a \
+toolkit_libs = \
+ libtoytoolkit.a \
+ ../shared/libconfig-parser.la \
$(CLIENT_LIBS) $(CAIRO_EGL_LIBS) -lrt -lm
flower_SOURCES = flower.c
struct display *display;
struct clickdot *clickdot;
- display = display_create(&argc, &argv, NULL);
+ display = display_create(argc, argv);
if (display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
desktop.unlock_task.run = unlock_dialog_finish;
wl_list_init(&desktop.outputs);
- desktop.display = display_create(&argc, &argv, NULL);
+ desktop.display = display_create(argc, argv);
if (desktop.display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
{
struct display *d;
- d = display_create(&argc, &argv, NULL);
+ d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
/**
* \brief command line options for eventdemo
- *
- * see
- * http://developer.gimp.org/api/2.0/glib/glib-Commandline-option-parser.html
*/
-static const GOptionEntry option_entries[] = {
- {"title", 0, 0, G_OPTION_ARG_STRING,
- &title, "Set the window title to TITLE", "TITLE"},
- {"width", 'w', 0, G_OPTION_ARG_INT,
- &width, "Set the window's width to W", "W"},
- {"height", 'h', 0, G_OPTION_ARG_INT,
- &height, "Set the window's height to H", "H"},
- {"maxwidth", 0, 0, G_OPTION_ARG_INT,
- &width_max, "Set the window's maximum width to W", "W"},
- {"maxheight", 0, 0, G_OPTION_ARG_INT,
- &height_max, "Set the window's maximum height to H", "H"},
- {"noborder", 'b', 0, G_OPTION_ARG_NONE,
- &noborder, "Don't draw window borders", 0},
- {"log-redraw", 0, 0, G_OPTION_ARG_NONE,
- &log_redraw, "Log redraw events to stdout", 0},
- {"log-resize", 0, 0, G_OPTION_ARG_NONE,
- &log_resize, "Log resize events to stdout", 0},
- {"log-focus", 0, 0, G_OPTION_ARG_NONE,
- &log_focus, "Log keyboard focus events to stdout", 0},
- {"log-key", 0, 0, G_OPTION_ARG_NONE,
- &log_key, "Log key events to stdout", 0},
- {"log-button", 0, 0, G_OPTION_ARG_NONE,
- &log_button, "Log button events to stdout", 0},
- {"log-motion", 0, 0, G_OPTION_ARG_NONE,
- &log_motion, "Log motion events to stdout", 0},
- {NULL}
+static const struct weston_option eventdemo_options[] = {
+ { WESTON_OPTION_STRING, "title", 0, &title },
+ { WESTON_OPTION_INTEGER, "width", 'w', &width },
+ { WESTON_OPTION_INTEGER, "height", 'h', &height },
+ { WESTON_OPTION_INTEGER, "max-width", 0, &width_max },
+ { WESTON_OPTION_INTEGER, "max-height", 0, &height_max },
+ { WESTON_OPTION_BOOLEAN, "no-border", 'b', &noborder },
+ { WESTON_OPTION_BOOLEAN, "log-redraw", '0', &log_redraw },
+ { WESTON_OPTION_BOOLEAN, "log-resize", '0', &log_resize },
+ { WESTON_OPTION_BOOLEAN, "log-focus", '0', &log_focus },
+ { WESTON_OPTION_BOOLEAN, "log-key", '0', &log_key },
+ { WESTON_OPTION_BOOLEAN, "log-button", '0', &log_button },
+ { WESTON_OPTION_BOOLEAN, "log-motion", '0', &log_motion },
};
/**
struct display *d;
struct eventdemo *e;
+ argc = parse_options(eventdemo_options,
+ ARRAY_LENGTH(eventdemo_options), argc, argv);
+
/* Connect to the display and have the arguments parsed */
- d = display_create(&argc, &argv, option_entries);
+ d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
struct display *d;
struct timeval tv;
- d = display_create(&argc, &argv, NULL);
+ d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
{
struct display *d;
- d = display_create(&argc, &argv, NULL);
+ d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
return image;
}
-static const GOptionEntry option_entries[] = {
- { NULL }
-};
-
int
main(int argc, char *argv[])
{
struct display *d;
int i;
- d = display_create(&argc, &argv, option_entries);
+ d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
struct display *display;
struct resizor *resizor;
- display = display_create(&argc, &argv, NULL);
+ display = display_create(argc, argv);
if (display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
struct display *d;
int size;
- d = display_create(&argc, &argv, NULL);
+ d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
uint32_t id;
struct tablet_shell *shell;
- display = display_create(&argc, &argv, NULL);
+ display = display_create(argc, argv);
if (display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
return 0;
}
-static const GOptionEntry option_entries[] = {
- { "fullscreen", 'f', 0, G_OPTION_ARG_NONE,
- &option_fullscreen, "Run in fullscreen mode" },
- { NULL }
+static const struct weston_option terminal_options[] = {
+ { WESTON_OPTION_BOOLEAN, "fullscreen", 'f', &option_fullscreen },
};
int main(int argc, char *argv[])
struct terminal *terminal;
const char *shell;
- d = display_create(&argc, &argv, option_entries);
+ argc = parse_options(terminal_options,
+ ARRAY_LENGTH(terminal_options), argc, argv);
+
+ d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
static int option_fullscreen;
-static const GOptionEntry option_entries[] = {
- { "fullscreen", 'f', 0, G_OPTION_ARG_NONE,
- &option_fullscreen, "Run in fullscreen mode" },
- { NULL }
+static const struct weston_option view_options[] = {
+ { WESTON_OPTION_BOOLEAN, "fullscreen", 0, &option_fullscreen },
};
int
struct display *d;
int i;
- d = display_create(&argc, &argv, option_entries);
+ argc = parse_options(view_options,
+ ARRAY_LENGTH(view_options), argc, argv);
+
+ d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
const char *option_xkb_variant = "";
const char *option_xkb_options = "";
-static const GOptionEntry xkb_option_entries[] = {
- { "xkb-layout", 0, 0, G_OPTION_ARG_STRING,
- &option_xkb_layout, "XKB Layout" },
- { "xkb-variant", 0, 0, G_OPTION_ARG_STRING,
- &option_xkb_variant, "XKB Variant" },
- { "xkb-options", 0, 0, G_OPTION_ARG_STRING,
- &option_xkb_options, "XKB Options" },
- { NULL }
+static const struct weston_option xkb_options[] = {
+ { WESTON_OPTION_STRING, "xkb-layout", 0, &option_xkb_layout },
+ { WESTON_OPTION_STRING, "xkb-variant", 0, &option_xkb_variant },
+ { WESTON_OPTION_STRING, "xkb-options", 0, &option_xkb_options },
};
static const cairo_user_data_key_t surface_data_key;
}
struct display *
-display_create(int *argc, char **argv[], const GOptionEntry *option_entries)
+display_create(int argc, char *argv[])
{
struct display *d;
- GOptionContext *context;
- GOptionGroup *xkb_option_group;
- GError *error;
g_type_init();
- context = g_option_context_new(NULL);
- if (option_entries)
- g_option_context_add_main_entries(context, option_entries, "Wayland View");
-
- xkb_option_group = g_option_group_new("xkb",
- "Keyboard options",
- "Show all XKB options",
- NULL, NULL);
- g_option_group_add_entries(xkb_option_group, xkb_option_entries);
- g_option_context_add_group (context, xkb_option_group);
-
- if (!g_option_context_parse(context, argc, argv, &error)) {
- fprintf(stderr, "option parsing failed: %s\n", error->message);
- exit(EXIT_FAILURE);
- }
-
- g_option_context_free(context);
+ argc = parse_options(xkb_options,
+ ARRAY_LENGTH(xkb_options), argc, argv);
d = malloc(sizeof *d);
if (d == NULL)
#define _WINDOW_H_
#include <xkbcommon/xkbcommon.h>
-#include <glib.h>
#include <wayland-client.h>
#include <cairo.h>
+#include "../shared/config-parser.h"
struct window;
struct widget;
};
struct display *
-display_create(int *argc, char **argv[], const GOptionEntry *option_entries);
+display_create(int argc, char *argv[]);
void
display_destroy(struct display *display);
}
}
-static const GOptionEntry option_entries[] = {
- { "demo", 0, 0, G_OPTION_ARG_NONE, &demo_mode,
- "Run as a regular application, not a screensaver.", NULL },
- { NULL }
+static const struct weston_option wscreensaver_options[] = {
+ { WESTON_OPTION_BOOLEAN, "demo", 0, &demo_mode },
};
int main(int argc, char *argv[])
init_frand();
- d = display_create(&argc, &argv, option_entries);
+ argc = parse_options(wscreensaver_options,
+ ARRAY_LENGTH(wscreensaver_options), argc, argv);
+
+ d = display_create(argc, argv);
if (d == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return EXIT_FAILURE;
noinst_LTLIBRARIES = libconfig-parser.la
libconfig_parser_la_SOURCES = \
config-parser.c \
+ option-parser.c \
config-parser.h
char *
config_file_path(const char *name);
+enum weston_option_type {
+ WESTON_OPTION_INTEGER,
+ WESTON_OPTION_UNSIGNED_INTEGER,
+ WESTON_OPTION_STRING,
+ WESTON_OPTION_BOOLEAN,
+};
+
+struct weston_option {
+ enum weston_option_type type;
+ const char *name;
+ int short_name;
+ void *data;
+};
+
+int
+parse_options(const struct weston_option *options,
+ int count, int argc, char *argv[]);
+
#endif /* CONFIGPARSER_H */
--- /dev/null
+/*
+ * Copyright © 2012 Kristian Høgsberg
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "config-parser.h"
+
+static void
+handle_option(const struct weston_option *option, char *value)
+{
+ switch (option->type) {
+ case WESTON_OPTION_INTEGER:
+ * (int32_t *) option->data = strtol(value, NULL, 0);
+ return;
+ case WESTON_OPTION_UNSIGNED_INTEGER:
+ * (uint32_t *) option->data = strtoul(value, NULL, 0);
+ return;
+ case WESTON_OPTION_STRING:
+ * (char **) option->data = strdup(value);
+ return;
+ case WESTON_OPTION_BOOLEAN:
+ * (int32_t *) option->data = 1;
+ return;
+ default:
+ assert(0);
+ }
+}
+
+int
+parse_options(const struct weston_option *options,
+ int count, int argc, char *argv[])
+{
+ int i, j, k, len = 0;
+
+ for (i = 1, j = 1; i < argc; i++) {
+ for (k = 0; k < count; k++) {
+ if (options[k].name)
+ len = strlen(options[k].name);
+ if (options[k].name &&
+ argv[i][0] == '-' &&
+ argv[i][1] == '-' &&
+ strncmp(options[k].name, &argv[i][2], len) == 0 &&
+ (argv[i][len + 2] == '=' || argv[i][len + 2] == '\0')) {
+ handle_option(&options[k], &argv[i][len + 3]);
+ break;
+ } else if (options[k].short_name &&
+ argv[i][0] == '-' &&
+ options[k].short_name == argv[i][1]) {
+ handle_option(&options[k], &argv[i][2]);
+ break;
+ }
+ }
+ if (k == count)
+ argv[j++] = argv[i];
+ }
+ argv[j] = NULL;
+
+ return j;
+}
weston_LDFLAGS = -export-dynamic
weston_CFLAGS = $(GCC_CFLAGS)
-weston_LDADD = \
- $(COMPOSITOR_LIBS) $(DLOPEN_LIBS) $(XSERVER_LAUNCHER_LIBS) -lm
+weston_LDADD = \
+ $(COMPOSITOR_LIBS) $(DLOPEN_LIBS) $(XSERVER_LAUNCHER_LIBS) -lm \
+ ../shared/libconfig-parser.la
weston_SOURCES = \
compositor.c \
return &ec->base;
}
-struct weston_compositor *
-backend_init(struct wl_display *display, char *options);
-
WL_EXPORT struct weston_compositor *
-backend_init(struct wl_display *display, char *options)
+backend_init(struct wl_display *display, int argc, char *argv[])
{
- int connector = 0, i;
- const char *seat;
- char *p, *value;
- int tty = 0;
-
- static char * const tokens[] = { "connector", "seat", "tty", NULL };
-
- p = options;
- seat = default_seat;
- while (i = getsubopt(&p, tokens, &value), i != -1) {
- switch (i) {
- case 0:
- connector = strtol(value, NULL, 0);
- break;
- case 1:
- seat = value;
- break;
- case 2:
- tty = strtol(value, NULL, 0);
- break;
- }
- }
+ int connector = 0, tty = 0;
+ const char *seat = default_seat;
+
+ const struct weston_option drm_options[] = {
+ { WESTON_OPTION_INTEGER, "connector", 0, &connector },
+ { WESTON_OPTION_STRING, "seat", 0, &seat },
+ { WESTON_OPTION_INTEGER, "tty", 0, &tty },
+ };
+
+ parse_options(drm_options, ARRAY_LENGTH(drm_options), argc, argv);
return drm_compositor_create(display, connector, seat, tty);
}
return &ec->base;
}
-struct weston_compositor *
-backend_init(struct wl_display *display, char *options);
-
WL_EXPORT struct weston_compositor *
-backend_init(struct wl_display *display, char *options)
+backend_init(struct wl_display *display, int argc, char *argv[])
{
- int connector = 0, i;
+ int connector = 0, tty = 0;
const char *seat;
- char *p, *value;
- int tty = 0;
- static char * const tokens[] = { "connector", "seat", "tty", NULL };
-
- p = options;
- seat = default_seat;
- while (i = getsubopt(&p, tokens, &value), i != -1) {
- switch (i) {
- case 0:
- connector = strtol(value, NULL, 0);
- break;
- case 1:
- seat = value;
- break;
- case 2:
- tty = strtol(value, NULL, 0);
- break;
- }
- }
+ const struct weston_option wfd_options[] = {
+ { WESTON_OPTION_INTEGER, "connector", 0, &connector },
+ { WESTON_OPTION_STRING, "seat", 0, &seat },
+ { WESTON_OPTION_INTEGER, "tty", 0, &tty },
+ };
+
+ parse_options(&wfd_options, ARRAY_LENGTH(wfd_options), argc, argv);
return wfd_compositor_create(display, connector, seat, tty);
}
return &c->base;
}
-struct weston_compositor *
-backend_init(struct wl_display *display, char *options);
-
WL_EXPORT struct weston_compositor *
-backend_init(struct wl_display *display, char *options)
+backend_init(struct wl_display *display, int argc, char *argv[])
{
- int width = 1024, height = 640, i;
- char *p, *value, *display_name = NULL;
-
- static char * const tokens[] = { "width", "height", "display", NULL };
-
- p = options;
- while (i = getsubopt(&p, tokens, &value), i != -1) {
- switch (i) {
- case 0:
- width = strtol(value, NULL, 0);
- break;
- case 1:
- height = strtol(value, NULL, 0);
- break;
- case 2:
- display_name = strdup(value);
- break;
- }
- }
+ int width = 1024, height = 640;
+ char *display_name = NULL;
+
+ const struct weston_option wayland_options[] = {
+ { WESTON_OPTION_INTEGER, "width", 0, &width },
+ { WESTON_OPTION_INTEGER, "height", 0, &height },
+ { WESTON_OPTION_STRING, "display", 0, &display_name },
+ };
+
+ parse_options(wayland_options,
+ ARRAY_LENGTH(wayland_options), argc, argv);
return wayland_compositor_create(display, width, height, display_name);
}
return &c->base;
}
-struct weston_compositor *
-backend_init(struct wl_display *display, char *options);
-
WL_EXPORT struct weston_compositor *
-backend_init(struct wl_display *display, char *options)
+backend_init(struct wl_display *display, int argc, char *argv[])
{
- int width = 1024, height = 640, fullscreen = 0, count = 1, i;
- char *p, *value;
+ int width = 1024, height = 640, fullscreen = 0, count = 1;
- static char * const tokens[] = {
- "width", "height", "fullscreen", "output-count", NULL
+ const struct weston_option x11_options[] = {
+ { WESTON_OPTION_INTEGER, "width", 0, &width },
+ { WESTON_OPTION_INTEGER, "height", 0, &height },
+ { WESTON_OPTION_BOOLEAN, "fullscreen", 0, &fullscreen },
+ { WESTON_OPTION_INTEGER, "output-count", 0, &count },
};
-
- p = options;
- while (i = getsubopt(&p, tokens, &value), i != -1) {
- switch (i) {
- case 0:
- width = strtol(value, NULL, 0);
- break;
- case 1:
- height = strtol(value, NULL, 0);
- break;
- case 2:
- fullscreen = 1;
- break;
- case 3:
- count = strtol(value, NULL, 0);
- break;
- }
- }
+
+ parse_options(x11_options, ARRAY_LENGTH(x11_options), argc, argv);
return x11_compositor_create(display,
width, height, count, fullscreen);
#include <math.h>
#include <linux/input.h>
#include <dlfcn.h>
-#include <getopt.h>
#include <signal.h>
#include <setjmp.h>
#include <execinfo.h>
#include <wayland-server.h>
#include "compositor.h"
-static const char *option_socket_name = NULL;
-
static struct wl_list child_process_list;
static jmp_buf segv_jmp_buf;
struct wl_event_source *signals[4];
struct wl_event_loop *loop;
struct sigaction segv_action;
- int o, xserver = 0;
void *shell_module, *backend_module;
int (*shell_init)(struct weston_compositor *ec);
struct weston_compositor
- *(*backend_init)(struct wl_display *display, char *options);
+ *(*backend_init)(struct wl_display *display,
+ int argc, char *argv[]);
+ int i;
char *backend = NULL;
- char *backend_options = "";
char *shell = NULL;
- char *p;
- int option_idle_time = 300;
- int i;
-
- static const char opts[] = "B:b:o:S:i:s:x";
- static const struct option longopts[ ] = {
- { "backend", 1, NULL, 'B' },
- { "backend-options", 1, NULL, 'o' },
- { "socket", 1, NULL, 'S' },
- { "idle-time", 1, NULL, 'i' },
- { "shell", 1, NULL, 's' },
- { "xserver", 0, NULL, 'x' },
- { NULL, }
+ int32_t idle_time = 300;
+ int32_t xserver;
+ char *socket_name = NULL;
+
+ const struct weston_option core_options[] = {
+ { WESTON_OPTION_STRING, "backend", 'B', &backend },
+ { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
+ { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
+ { WESTON_OPTION_STRING, "shell", 's', &shell },
+ { WESTON_OPTION_BOOLEAN, "xserver", 0, &xserver },
};
- while (o = getopt_long(argc, argv, opts, longopts, &o), o > 0) {
- switch (o) {
- case 'B':
- backend = optarg;
- break;
- case 'o':
- backend_options = optarg;
- break;
- case 'S':
- option_socket_name = optarg;
- break;
- case 'i':
- option_idle_time = strtol(optarg, &p, 0);
- if (*p != '\0') {
- fprintf(stderr,
- "invalid idle time option: %s\n",
- optarg);
- exit(EXIT_FAILURE);
- }
- break;
- case 's':
- shell = optarg;
- break;
- case 'x':
- xserver = 1;
- break;
- }
- }
+ argc = parse_options(core_options,
+ ARRAY_LENGTH(core_options), argc, argv);
display = wl_display_create();
if (!shell_init)
exit(EXIT_FAILURE);
- ec = backend_init(display, backend_options);
+ ec = backend_init(display, argc, argv);
if (ec == NULL) {
fprintf(stderr, "failed to create compositor\n");
exit(EXIT_FAILURE);
}
- ec->option_idle_time = option_idle_time;
- ec->idle_time = option_idle_time;
+ for (i = 1; argv[i]; i++)
+ fprintf(stderr, "unhandled option: %s\n", argv[i]);
+ if (argv[1])
+ exit(EXIT_FAILURE);
+
+ ec->option_idle_time = idle_time;
+ ec->idle_time = idle_time;
#ifdef BUILD_XSERVER_LAUNCHER
if (xserver)
if (shell_init(ec) < 0)
exit(EXIT_FAILURE);
- if (wl_display_add_socket(display, option_socket_name)) {
+ if (wl_display_add_socket(display, socket_name)) {
fprintf(stderr, "failed to add socket: %m\n");
exit(EXIT_FAILURE);
}
#include <EGL/eglext.h>
#include "matrix.h"
+#include "../shared/config-parser.h"
struct weston_transform {
struct weston_matrix matrix;
void
weston_surface_destroy(struct weston_surface *surface);
+struct weston_compositor *
+backend_init(struct wl_display *display, int argc, char *argv[]);
+
#endif