[mutter/wip/wayland-work: 43/44] wayland: use the new mutter-launch capabilities to handle TTY and VT



commit 94cb641d08a75a8658ebaee59de0907147a10c22
Author: Giovanni Campagna <gcampagn redhat com>
Date:   Thu Aug 22 14:37:47 2013 +0200

    wayland: use the new mutter-launch capabilities to handle TTY and VT
    
    Integrate MetaTTY with meta-weston-launch, into a new MetaLauncher
    helper, that takes care of talking with the setuid helper, calling
    set/dropMaster as appropriate and opening the evdev devices when
    asked by clutter.
    In the future, this object could be made to talk to logind instead
    of our private helper, or the helper could be turned into a systemd
    daemon.
    
    https://bugzilla.gnome.org/show_bug.cgi?id=705861

 src/Makefile.am                    |    2 -
 src/core/keybindings.c             |    8 +-
 src/core/main.c                    |   35 ---
 src/wayland/meta-tty.c             |  436 ------------------------------------
 src/wayland/meta-tty.h             |   50 ----
 src/wayland/meta-wayland-private.h |    7 +-
 src/wayland/meta-wayland.c         |   88 +-------
 src/wayland/meta-weston-launch.c   |  387 +++++++++++++++++++++++++-------
 src/wayland/meta-weston-launch.h   |   60 +++---
 9 files changed, 352 insertions(+), 721 deletions(-)
---
diff --git a/src/Makefile.am b/src/Makefile.am
index b899a25..cf4c6df 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -183,8 +183,6 @@ libmutter_wayland_la_SOURCES =                      \
        $(mutter_built_sources)
 
 libmutter_wayland_la_SOURCES +=                        \
-       wayland/meta-tty.c                      \
-       wayland/meta-tty.h                      \
        wayland/meta-wayland.c                  \
        wayland/meta-wayland-private.h          \
        wayland/meta-xwayland-private.h         \
diff --git a/src/core/keybindings.c b/src/core/keybindings.c
index cb86c15..07a182a 100644
--- a/src/core/keybindings.c
+++ b/src/core/keybindings.c
@@ -4124,17 +4124,17 @@ handle_switch_vt (MetaDisplay    *display,
 {
     gint vt = binding->handler->data;
     MetaWaylandCompositor *compositor;
-    MetaTTY *tty;
+    MetaLauncher *launcher;
 
     compositor = meta_wayland_compositor_get_default ();
-    tty = meta_wayland_compositor_get_tty (compositor);
+    launcher = meta_wayland_compositor_get_launcher (compositor);
 
-    if (tty)
+    if (launcher)
       {
         GError *error;
 
         error = NULL;
-        if (!meta_tty_activate_vt (tty, vt, &error))
+        if (!meta_launcher_activate_vt (launcher, vt, &error))
           {
             g_warning ("Failed to switch VT: %s", error->message);
             g_error_free (error);
diff --git a/src/core/main.c b/src/core/main.c
index c1d45ed..0d60537 100644
--- a/src/core/main.c
+++ b/src/core/main.c
@@ -372,28 +372,6 @@ on_sigterm (gpointer user_data)
   return G_SOURCE_REMOVE;
 }
 
-static void
-crash_handler (int signum)
-{
-  char buffer[256];
-  MetaWaylandCompositor *compositor;
-  MetaTTY *tty;
-
-  snprintf (buffer, 256, "Fatal server error: %d\n", signum);
-  write (STDERR_FILENO, buffer, strlen (buffer));
-
-  compositor = meta_wayland_compositor_get_default ();
-  tty = meta_wayland_compositor_get_tty (compositor);
-
-  /* Passing FALSE ensures that we only do ioctls, which is
-     safe from a signal handler */
-  if (tty)
-    meta_tty_reset (tty, FALSE);
-
-  /* We can't continue with the default handling, so just exit here */
-  _exit(1);
-}
-
 /**
  * meta_init: (skip)
  *
@@ -422,19 +400,6 @@ meta_init (void)
   if (getenv ("MUTTER_SLEEP_INIT"))
     sleep (60);
 
-  if (meta_is_wayland_compositor ())
-    {
-      act.sa_handler = crash_handler;
-
-      /* Ignore if we can't register signal handlers, worse
-         that can happen one needs the sysrq to get out of the VT */
-      sigaction (SIGABRT, &act, NULL);
-      sigaction (SIGSEGV, &act, NULL);
-      sigaction (SIGBUS, &act, NULL);
-      sigaction (SIGFPE, &act, NULL);
-      sigaction (SIGTRAP, &act, NULL);
-    }
-
   g_unix_signal_add (SIGTERM, on_sigterm, NULL);
 
   if (g_getenv ("MUTTER_VERBOSE"))
diff --git a/src/wayland/meta-wayland-private.h b/src/wayland/meta-wayland-private.h
index b5bc01b..38c3d49 100644
--- a/src/wayland/meta-wayland-private.h
+++ b/src/wayland/meta-wayland-private.h
@@ -28,7 +28,7 @@
 #include <cairo.h>
 
 #include "window-private.h"
-#include "meta-tty.h"
+#include "meta-weston-launch.h"
 #include <meta/meta-cursor-tracker.h>
 
 typedef struct _MetaWaylandCompositor MetaWaylandCompositor;
@@ -149,9 +149,8 @@ struct _MetaWaylandCompositor
   struct wl_client *xwayland_client;
   struct wl_resource *xserver_resource;
 
-  MetaTTY *tty;
+  MetaLauncher *launcher;
   int drm_fd;
-  GSocket *weston_launch;
 
   MetaWaylandSeat *seat;
 
@@ -345,7 +344,7 @@ void                    meta_wayland_compositor_repick          (MetaWaylandComp
 void                    meta_wayland_compositor_set_input_focus (MetaWaylandCompositor *compositor,
                                                                  MetaWindow            *window);
 
-MetaTTY                *meta_wayland_compositor_get_tty         (MetaWaylandCompositor *compositor);
+MetaLauncher           *meta_wayland_compositor_get_launcher    (MetaWaylandCompositor *compositor);
 gboolean                meta_wayland_compositor_is_native       (MetaWaylandCompositor *compositor);
 
 void                    meta_wayland_surface_free               (MetaWaylandSurface    *surface);
diff --git a/src/wayland/meta-wayland.c b/src/wayland/meta-wayland.c
index 10c2975..1c84314 100644
--- a/src/wayland/meta-wayland.c
+++ b/src/wayland/meta-wayland.c
@@ -24,7 +24,6 @@
 #include <clutter/clutter.h>
 #include <clutter/wayland/clutter-wayland-compositor.h>
 #include <clutter/wayland/clutter-wayland-surface.h>
-#include <clutter/evdev/clutter-evdev.h>
 
 #include <glib.h>
 #include <sys/time.h>
@@ -1538,65 +1537,6 @@ on_monitors_changed (MetaMonitorManager    *monitors,
   compositor->outputs = meta_wayland_compositor_update_outputs (compositor, monitors);
 }
 
-static int
-env_get_fd (const char *env)
-{
-  const char *value;
-
-  value = g_getenv (env);
-
-  if (value == NULL)
-    return -1;
-  else
-    return g_ascii_strtoll (value, NULL, 10);
-}
-
-static void
-on_our_vt_enter (MetaTTY               *tty,
-                MetaWaylandCompositor *compositor)
-{
-  GError *error;
-
-  error = NULL;
-  if (!meta_weston_launch_set_master (compositor->weston_launch,
-                                     compositor->drm_fd, TRUE, &error))
-    {
-      g_warning ("Failed to become DRM master: %s", error->message);
-      g_error_free (error);
-    }
-
-  clutter_evdev_reclaim_devices ();
-}
-
-static void
-on_our_vt_leave (MetaTTY               *tty,
-                MetaWaylandCompositor *compositor)
-{
-  GError *error;
-
-  error = NULL;
-  if (!meta_weston_launch_set_master (compositor->weston_launch,
-                                     compositor->drm_fd, FALSE, &error))
-    {
-      g_warning ("Failed to release DRM master: %s", error->message);
-      g_error_free (error);
-    }
-
-  clutter_evdev_release_devices ();
-}
-
-static int
-on_evdev_device_open (const char  *path,
-                     int          flags,
-                     gpointer     user_data,
-                     GError     **error)
-{
-  MetaWaylandCompositor *compositor = user_data;
-
-  return meta_weston_launch_open_input_device (compositor->weston_launch,
-                                              path, flags, error);
-}
-
 static void
 set_gnome_env (const char *name,
               const char *value)
@@ -1635,7 +1575,6 @@ meta_wayland_init (void)
   ClutterBackend *backend;
   CoglContext *cogl_context;
   CoglRenderer *cogl_renderer;
-  int weston_launch_fd;
   char *display_name;
 
   memset (compositor, 0, sizeof (MetaWaylandCompositor));
@@ -1673,12 +1612,8 @@ meta_wayland_init (void)
 
   clutter_wayland_set_compositor_display (compositor->wayland_display);
 
-  weston_launch_fd = env_get_fd ("WESTON_LAUNCHER_SOCK");
-  if (weston_launch_fd >= 0)
-    {
-      compositor->weston_launch = g_socket_new_from_fd (weston_launch_fd, NULL);
-      clutter_evdev_set_open_callback (on_evdev_device_open, compositor);
-    }
+  if (getenv ("WESTON_LAUNCHER_SOCK"))
+      compositor->launcher = meta_launcher_new ();
 
   if (clutter_init (NULL, NULL) != CLUTTER_INIT_SUCCESS)
     g_error ("Failed to initialize Clutter");
@@ -1699,17 +1634,10 @@ meta_wayland_init (void)
     {
       GError *error;
 
-      /* Running on bare metal, let's initalize DRM master and VT handling */
-      compositor->tty = meta_tty_new ();
-      if (compositor->tty)
-       {
-         g_signal_connect (compositor->tty, "enter", G_CALLBACK (on_our_vt_enter), compositor);
-         g_signal_connect (compositor->tty, "leave", G_CALLBACK (on_our_vt_leave), compositor);
-       }
+      meta_launcher_set_drm_fd (compositor->launcher, compositor->drm_fd);
 
       error = NULL;
-      if (!meta_weston_launch_set_master (compositor->weston_launch,
-                                         compositor->drm_fd, TRUE, &error))
+      if (!meta_launcher_set_master (compositor->launcher, TRUE, &error))
        {
          g_error ("Failed to become DRM master: %s", error->message);
          g_error_free (error);
@@ -1788,13 +1716,13 @@ meta_wayland_finalize (void)
   compositor = meta_wayland_compositor_get_default ();
 
   meta_xwayland_stop (compositor);
-  g_clear_object (&compositor->tty);
+  g_clear_object (&compositor->launcher);
 }
 
-MetaTTY *
-meta_wayland_compositor_get_tty (MetaWaylandCompositor *compositor)
+MetaLauncher *
+meta_wayland_compositor_get_launcher (MetaWaylandCompositor *compositor)
 {
-  return compositor->tty;
+  return compositor->launcher;
 }
 
 gboolean
diff --git a/src/wayland/meta-weston-launch.c b/src/wayland/meta-weston-launch.c
index 225ef2e..ea9461e 100644
--- a/src/wayland/meta-weston-launch.c
+++ b/src/wayland/meta-weston-launch.c
@@ -22,6 +22,9 @@
 #include <gio/gio.h>
 #include <gio/gunixfdmessage.h>
 
+#include <clutter/clutter.h>
+#include <clutter/evdev/clutter-evdev.h>
+
 #include <glib.h>
 #include <sys/time.h>
 #include <string.h>
@@ -40,6 +43,40 @@
 
 #include "meta-weston-launch.h"
 
+struct _MetaLauncherClass
+{
+  GObjectClass parent_class;
+
+  void (*enter) (MetaLauncher *);
+  void (*leave) (MetaLauncher *);
+};
+
+struct _MetaLauncher
+{
+  GObject parent;
+
+  GSocket *weston_launch;
+  int drm_fd;
+
+  gboolean vt_switched;
+
+  GMainContext *nested_context;
+  GMainLoop *nested_loop;
+
+  GSource *inner_source;
+  GSource *outer_source;
+};
+
+enum {
+  SIGNAL_ENTER,
+  SIGNAL_LEAVE,
+  SIGNAL_LAST
+};
+
+static int signals[SIGNAL_LAST];
+
+G_DEFINE_TYPE (MetaLauncher, meta_launcher, G_TYPE_OBJECT);
+
 static gboolean
 send_message_to_wl (GSocket                *weston_launch,
                    void                   *message,
@@ -98,106 +135,298 @@ send_message_to_wl (GSocket                *weston_launch,
 }          
 
 gboolean
-meta_weston_launch_set_master (GSocket   *weston_launch,
-                              int        drm_fd,
-                              gboolean   master,
-                              GError   **error)
+meta_launcher_set_master (MetaLauncher  *self,
+                         gboolean       master,
+                         GError       **error)
 {
-  if (weston_launch)
+  struct weston_launcher_set_master message;
+  GSocketControlMessage *cmsg;
+  gboolean ok;
+
+  message.header.opcode = WESTON_LAUNCHER_DRM_SET_MASTER;
+  message.set_master = master;
+
+  cmsg = g_unix_fd_message_new ();
+  if (g_unix_fd_message_append_fd (G_UNIX_FD_MESSAGE (cmsg),
+                                  self->drm_fd, error) == FALSE)
     {
-      struct weston_launcher_set_master message;
-      GSocketControlMessage *cmsg;
-      gboolean ok;
+      g_object_unref (cmsg);
+      return FALSE;
+    }
 
-      message.header.opcode = WESTON_LAUNCHER_DRM_SET_MASTER;
-      message.set_master = master;
+  ok = send_message_to_wl (self->weston_launch, &message,
+                          sizeof message, cmsg, NULL, error);
 
-      cmsg = g_unix_fd_message_new ();
-      if (g_unix_fd_message_append_fd (G_UNIX_FD_MESSAGE (cmsg),
-                                      drm_fd, error) == FALSE)
-       {
-         g_object_unref (cmsg);
-         return FALSE;
-       }
+  g_object_unref (cmsg);
+  return ok;
+}
 
-      ok = send_message_to_wl (weston_launch, &message, sizeof message, cmsg, NULL, error);
+int
+meta_launcher_open_input_device (MetaLauncher  *self,
+                                const char    *name,
+                                int            flags,
+                                GError       **error)
+{
+  struct weston_launcher_open *message;
+  GSocketControlMessage *cmsg;
+  gboolean ok;
+  gsize size;
+  int *fds, n_fd;
+  int ret;
 
+  size = sizeof (struct weston_launcher_open) + strlen (name) + 1;
+  message = g_malloc (size);
+  message->header.opcode = WESTON_LAUNCHER_OPEN;
+  message->flags = flags;
+  strcpy (message->path, name);
+  message->path[strlen(name)] = 0;
+
+  ok = send_message_to_wl (self->weston_launch, message, size,
+                          NULL, &cmsg, error);
+
+  if (ok)
+    {
+      g_assert (G_IS_UNIX_FD_MESSAGE (cmsg));
+
+      fds = g_unix_fd_message_steal_fds (G_UNIX_FD_MESSAGE (cmsg), &n_fd);
+      g_assert (n_fd == 1);
+
+      ret = fds[0];
+      g_free (fds);
       g_object_unref (cmsg);
-      return ok;
     }
   else
+    ret = -1;
+
+  g_free (message);
+  return ret;
+}
+
+static void
+meta_launcher_finalize (GObject *object)
+{
+  MetaLauncher *launcher = META_LAUNCHER (object);
+
+  g_source_destroy (launcher->outer_source);
+  g_source_destroy (launcher->inner_source);
+
+  g_main_loop_unref (launcher->nested_loop);
+  g_main_context_unref (launcher->nested_context);
+
+  g_object_unref (launcher->weston_launch);
+
+  G_OBJECT_CLASS (meta_launcher_parent_class)->finalize (object);
+}
+
+static void
+meta_launcher_enter (MetaLauncher *launcher)
+{
+  GError *error;
+
+  error = NULL;
+  if (!meta_launcher_set_master (launcher, TRUE, &error))
     {
-      int ret;
+      g_critical ("Failed to become DRM master: %s", error->message);
+      g_error_free (error);
+    }
 
-      if (master)
-       ret = drmSetMaster (drm_fd);
-      else
-       ret = drmDropMaster (drm_fd);
-
-      if (ret < 0)
-       {
-         g_set_error (error, G_IO_ERROR, g_io_error_from_errno (-ret),
-                      "Failed to set DRM master directly: %s", strerror (-ret));
-         return FALSE;
-       }
-      else
-       return TRUE;
+  clutter_evdev_reclaim_devices ();
+}
+
+static void
+meta_launcher_leave (MetaLauncher *launcher)
+{
+  GError *error;
+
+  error = NULL;
+  if (!meta_launcher_set_master (launcher, FALSE, &error))
+    {
+      g_critical ("Failed to release DRM master: %s", error->message);
+      g_error_free (error);
     }
+
+  clutter_evdev_release_devices ();
 }
 
-int
-meta_weston_launch_open_input_device (GSocket    *weston_launch,
-                                     const char *name,
-                                     int         flags,
-                                     GError    **error)
+
+static int
+on_evdev_device_open (const char  *path,
+                     int          flags,
+                     gpointer     user_data,
+                     GError     **error)
+{
+  MetaLauncher *launcher = user_data;
+
+  return meta_launcher_open_input_device (launcher, path, flags, error);
+}
+
+static void
+handle_vt_enter (MetaLauncher *launcher)
 {
-  if (weston_launch)
+  g_assert (launcher->vt_switched);
+
+  g_main_loop_quit (launcher->nested_loop);
+}
+
+static void
+handle_request_vt_switch (MetaLauncher *launcher)
+{
+  struct weston_launcher_message message;
+  GError *error;
+  gboolean ok;
+
+  g_signal_emit (launcher, signals[SIGNAL_LEAVE], 0);
+
+  message.opcode = WESTON_LAUNCHER_CONFIRM_VT_SWITCH;
+
+  error = NULL;
+  ok = send_message_to_wl (launcher->weston_launch, &message,
+                          sizeof (message), NULL, NULL, &error);
+  if (!ok) {
+    g_warning ("Failed to acknowledge VT switch: %s", error->message);
+    g_error_free (error);
+
+    return;
+  }
+
+  g_assert (!launcher->vt_switched);
+  launcher->vt_switched = TRUE;
+
+  /* We can't do anything at this point, because we don't
+     have input devices and we don't have the DRM master,
+     so let's run a nested busy loop until the VT is reentered */
+  g_main_loop_run (launcher->nested_loop);
+
+  g_assert (launcher->vt_switched);
+  launcher->vt_switched = FALSE;
+
+  g_signal_emit (launcher, signals[SIGNAL_ENTER], 0);
+}
+
+static void
+on_socket_readable (GSocket      *socket,
+                   GIOCondition  condition,
+                   gpointer      user_data)
+{
+  MetaLauncher *launcher = user_data;
+  struct weston_launcher_message header;
+  gssize read;
+  GError *error;
+
+  if ((condition & G_IO_IN) == 0)
+    return;
+
+  error = NULL;
+  read = g_socket_receive (socket, (char*)&header, sizeof(header), NULL, &error);
+  if (read < (gssize)sizeof(header))
     {
-      struct weston_launcher_open *message;
-      GSocketControlMessage *cmsg;
-      gboolean ok;
-      gsize size;
-      int *fds, n_fd;
-      int ret;
-
-      size = sizeof (struct weston_launcher_open) + strlen (name) + 1;
-      message = g_malloc (size);
-      message->header.opcode = WESTON_LAUNCHER_OPEN;
-      message->flags = flags;
-      strcpy (message->path, name);
-      message->path[strlen(name)] = 0;
-
-      ok = send_message_to_wl (weston_launch, message, size,
-                              NULL, &cmsg, error);
-
-      if (ok)
-       {
-         g_assert (G_IS_UNIX_FD_MESSAGE (cmsg));
-
-         fds = g_unix_fd_message_steal_fds (G_UNIX_FD_MESSAGE (cmsg), &n_fd);
-         g_assert (n_fd == 1);
-
-         ret = fds[0];
-         g_free (fds);
-         g_object_unref (cmsg);
-       }
-      else
-       ret = -1;
+      g_warning ("Error reading from weston-launcher socket: %s", error->message);
+      g_error_free (error);
+      return;
+    }
 
-      g_free (message);
-      return ret;
+  switch (header.opcode)
+    {
+    case WESTON_LAUNCHER_SERVER_REQUEST_VT_SWITCH:
+      handle_request_vt_switch (launcher);
+      break;
+
+    case WESTON_LAUNCHER_SERVER_VT_ENTER:
+      handle_vt_enter (launcher);
+      break;
     }
+}
+
+static int
+env_get_fd (const char *env)
+{
+  const char *value;
+
+  value = g_getenv (env);
+
+  if (value == NULL)
+    return -1;
   else
-    {
-      int ret;
+    return g_ascii_strtoll (value, NULL, 10);
+}
 
-      ret = open (name, flags, 0);
+static void
+meta_launcher_init (MetaLauncher *self)
+{
+  int launch_fd;
 
-      if (ret < 0)
-       g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno),
-                    "Failed to open input device directly: %s", strerror (errno));
+  launch_fd = env_get_fd ("WESTON_LAUNCHER_SOCK");
+  if (launch_fd < 0)
+    g_error ("Invalid mutter-launch socket");
 
-      return ret;
-    }
+  self->weston_launch = g_socket_new_from_fd (launch_fd, NULL);
+
+  clutter_evdev_set_open_callback (on_evdev_device_open, self);
+
+  self->nested_context = g_main_context_new ();
+  self->nested_loop = g_main_loop_new (self->nested_context, FALSE);
+
+  self->outer_source = g_socket_create_source (self->weston_launch, G_IO_IN, NULL);
+  g_source_set_callback (self->outer_source, (GSourceFunc)on_socket_readable, self, NULL);
+  g_source_attach (self->outer_source, NULL);
+  g_source_unref (self->outer_source);
+
+  self->inner_source = g_socket_create_source (self->weston_launch, G_IO_IN, NULL);
+  g_source_set_callback (self->inner_source, (GSourceFunc)on_socket_readable, self, NULL);
+  g_source_attach (self->inner_source, self->nested_context);
+  g_source_unref (self->inner_source);
+}
+
+static void
+meta_launcher_class_init (MetaLauncherClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  object_class->finalize = meta_launcher_finalize;
+
+  klass->enter = meta_launcher_enter;
+  klass->leave = meta_launcher_leave;
+
+  signals[SIGNAL_ENTER] = g_signal_new ("enter",
+                                       G_TYPE_FROM_CLASS (klass),
+                                       G_SIGNAL_RUN_FIRST,
+                                       G_STRUCT_OFFSET (MetaLauncherClass, enter),
+                                       NULL, NULL, /* accumulator */
+                                       g_cclosure_marshal_VOID__VOID,
+                                       G_TYPE_NONE, 0);
+
+  signals[SIGNAL_LEAVE] = g_signal_new ("leave",
+                                       G_TYPE_FROM_CLASS (klass),
+                                       G_SIGNAL_RUN_FIRST,
+                                       G_STRUCT_OFFSET (MetaLauncherClass, leave),
+                                       NULL, NULL, /* accumulator */
+                                       g_cclosure_marshal_VOID__VOID,
+                                       G_TYPE_NONE, 0);
 }
 
+MetaLauncher *
+meta_launcher_new (void)
+{
+  return g_object_new (META_TYPE_LAUNCHER, NULL);
+}
+
+gboolean
+meta_launcher_activate_vt (MetaLauncher  *launcher,
+                          int            vt,
+                          GError       **error)
+{
+  struct weston_launcher_activate_vt message;
+
+  message.header.opcode = WESTON_LAUNCHER_ACTIVATE_VT;
+  message.vt = vt;
+
+  return send_message_to_wl (launcher->weston_launch, &message,
+                            sizeof (message), NULL, NULL, error);
+}
+
+void
+meta_launcher_set_drm_fd (MetaLauncher *launcher,
+                         int           drm_fd)
+{
+  launcher->drm_fd = drm_fd;
+}
diff --git a/src/wayland/meta-weston-launch.h b/src/wayland/meta-weston-launch.h
index f642ba9..ccb08f3 100644
--- a/src/wayland/meta-weston-launch.h
+++ b/src/wayland/meta-weston-launch.h
@@ -21,36 +21,34 @@
 #define META_WESTON_LAUNCH_H
 
 #include <glib-object.h>
-
-/* Keep this in sync with weston-launch */
-
-enum weston_launcher_opcode {
-       WESTON_LAUNCHER_OPEN,
-       WESTON_LAUNCHER_DRM_SET_MASTER
-};
-
-struct weston_launcher_message {
-       int opcode;
-};
-
-struct weston_launcher_open {
-       struct weston_launcher_message header;
-       int flags;
-       char path[0];
-};
-
-struct weston_launcher_set_master {
-       struct weston_launcher_message header;
-       int set_master;
-};
-
-gboolean meta_weston_launch_set_master (GSocket   *weston_launch,
-                                       int        drm_fd,
-                                       gboolean   master,
-                                       GError   **error);
-int      meta_weston_launch_open_input_device (GSocket     *weston_launch,
-                                              const char  *name,
-                                              int          flags,
-                                              GError     **error);
+#include "weston-launch.h"
+
+#define META_TYPE_LAUNCHER              (meta_launcher_get_type())
+#define META_LAUNCHER(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), META_TYPE_LAUNCHER, 
MetaLauncher))
+#define META_LAUNCHER_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), META_TYPE_LAUNCHER, 
MetaLauncherClass))
+#define META_IS_LAUNCHER(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), META_TYPE_LAUNCHER))
+#define META_IS_LAUNCHER_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), META_TYPE_LAUNCHER))
+#define META_LAUNCHER_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), META_LAUNCHER, MetaLauncherClass))
+
+typedef struct _MetaLauncher      MetaLauncher;
+typedef struct _MetaLauncherClass MetaLauncherClass;
+
+GType             meta_launcher_get_type                (void) G_GNUC_CONST;
+
+MetaLauncher     *meta_launcher_new                     (void);
+
+gboolean          meta_launcher_activate_vt             (MetaLauncher  *self,
+                                                        int            number,
+                                                        GError       **error);
+
+void              meta_launcher_set_drm_fd              (MetaLauncher  *self,
+                                                        int            drm_fd);
+gboolean          meta_launcher_set_master              (MetaLauncher  *self,
+                                                        gboolean       master,
+                                                        GError       **error);
+int               meta_launcher_open_input_device       (MetaLauncher  *self,
+                                                        const char    *name,
+                                                        int            flags,
+                                                        GError       **error);
 
 #endif


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]