~ubuntu-branches/debian/sid/cheese/sid

/* cheese-main.c generated by valac 0.12.0, the Vala compiler

 * generated from cheese-main.vala, do not modify */

 

/*

 * Copyright © 2010 Yuvaraj Pandian T <yuvipanda@yuvi.in>

 * Copyright © 2010 daniel g. siegel <dgsiegel@gnome.org>

 * Copyright © 2008 Filippo Argiolas <filippo.argiolas@gmail.com>

 *

 * Licensed under the GNU General Public License Version 2

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

 

#include <glib.h>

#include <glib-object.h>

#include <gtk/gtk.h>

#include <stdlib.h>

#include <string.h>

#include <gio/gio.h>

#include <glib/gi18n-lib.h>

#include <cheese-config.h>

#include <stdio.h>

#include <gst/gst.h>

#include <clutter/clutter.h>

#include <clutter-gtk/clutter-gtk.h>

 

 

#define CHEESE_TYPE_MAIN (cheese_main_get_type ())

#define CHEESE_MAIN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CHEESE_TYPE_MAIN, CheeseMain))

#define CHEESE_MAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CHEESE_TYPE_MAIN, CheeseMainClass))

#define CHEESE_IS_MAIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CHEESE_TYPE_MAIN))

#define CHEESE_IS_MAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CHEESE_TYPE_MAIN))

#define CHEESE_MAIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CHEESE_TYPE_MAIN, CheeseMainClass))

 

typedef struct _CheeseMain CheeseMain;

typedef struct _CheeseMainClass CheeseMainClass;

typedef struct _CheeseMainPrivate CheeseMainPrivate;

 

#define CHEESE_TYPE_MAIN_WINDOW (cheese_main_window_get_type ())

#define CHEESE_MAIN_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CHEESE_TYPE_MAIN_WINDOW, CheeseMainWindow))

#define CHEESE_MAIN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CHEESE_TYPE_MAIN_WINDOW, CheeseMainWindowClass))

#define CHEESE_IS_MAIN_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CHEESE_TYPE_MAIN_WINDOW))

#define CHEESE_IS_MAIN_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CHEESE_TYPE_MAIN_WINDOW))

#define CHEESE_MAIN_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CHEESE_TYPE_MAIN_WINDOW, CheeseMainWindowClass))

 

typedef struct _CheeseMainWindow CheeseMainWindow;

typedef struct _CheeseMainWindowClass CheeseMainWindowClass;

#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))

#define _g_free0(var) (var = (g_free (var), NULL))

#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

#define _g_option_context_free0(var) ((var == NULL) ? NULL : (var = (g_option_context_free (var), NULL)))

 

struct _CheeseMain {

        GtkApplication parent_instance;

        CheeseMainPrivate * priv;

};

 

struct _CheeseMainClass {

        GtkApplicationClass parent_class;

};

 

 

static gpointer cheese_main_parent_class = NULL;

static gboolean cheese_main_wide;

static gboolean cheese_main_wide = FALSE;

static gchar* cheese_main_device;

static gchar* cheese_main_device = NULL;

static gboolean cheese_main_version;

static gboolean cheese_main_version = FALSE;

static gboolean cheese_main_fullscreen;

static gboolean cheese_main_fullscreen = FALSE;

static CheeseMainWindow* cheese_main_main_window;

static CheeseMainWindow* cheese_main_main_window = NULL;

 

GType cheese_main_get_type (void) G_GNUC_CONST;

enum  {

        CHEESE_MAIN_DUMMY_PROPERTY

};

GType cheese_main_window_get_type (void) G_GNUC_CONST;

CheeseMain* cheese_main_new (const gchar* app_id, GApplicationFlags flags);

CheeseMain* cheese_main_construct (GType object_type, const gchar* app_id, GApplicationFlags flags);

void cheese_main_on_app_activate (CheeseMain* self);

CheeseMainWindow* cheese_main_window_new (void);

CheeseMainWindow* cheese_main_window_construct (GType object_type);

void cheese_main_window_setup_ui (CheeseMainWindow* self);

void cheese_main_window_set_startup_wide_mode (CheeseMainWindow* self);

void cheese_main_window_set_startup_fullscreen_mode (CheeseMainWindow* self);

static void _gtk_main_quit_gtk_widget_destroy (GtkWidget* _sender, gpointer self);

void cheese_main_window_setup_camera (CheeseMainWindow* self, const gchar* uri);

static gboolean cheese_main_real_local_command_line (GApplication* base, gchar*** arguments, gint* exit_status);

static void cheese_main_finalize (GObject* obj);

gint _vala_main (gchar** args, int args_length1);

static void _cheese_main_on_app_activate_g_application_activate (GApplication* _sender, gpointer self);

static gint _vala_array_length (gpointer array);

 

static const GOptionEntry CHEESE_MAIN_options[5] = {{"wide", 'w', 0, G_OPTION_ARG_NONE, &cheese_main_wide, "Start in wide mode", NULL}, {"device", 'd', 0, G_OPTION_ARG_FILENAME, &cheese_main_device, "Device to use as a camera", "DEVICE"}, {"version", 'v', 0, G_OPTION_ARG_NONE, &cheese_main_version, "Output version information and exit", NULL}, {"fullscreen", 'f', 0, G_OPTION_ARG_NONE, &cheese_main_fullscreen, "Start in fullscreen mode", NULL}, {NULL}};

 

CheeseMain* cheese_main_construct (GType object_type, const gchar* app_id, GApplicationFlags flags) {

        CheeseMain * self = NULL;

        g_return_val_if_fail (app_id != NULL, NULL);

        self = (CheeseMain*) g_object_new (object_type, "application-id", app_id, "flags", flags, NULL);

        return self;

}

 

 

CheeseMain* cheese_main_new (const gchar* app_id, GApplicationFlags flags) {

        return cheese_main_construct (CHEESE_TYPE_MAIN, app_id, flags);

}

 

 

static void _gtk_main_quit_gtk_widget_destroy (GtkWidget* _sender, gpointer self) {

        gtk_main_quit ();

}

 

 

void cheese_main_on_app_activate (CheeseMain* self) {

        GList* _tmp0_ = NULL;

        g_return_if_fail (self != NULL);

        _tmp0_ = gtk_application_get_windows ((GtkApplication*) self);

        if (_tmp0_ != NULL) {

                gtk_window_present ((GtkWindow*) cheese_main_main_window);

        } else {

                CheeseMainWindow* _tmp1_ = NULL;

                const gchar* _tmp2_ = NULL;

                GtkIconTheme* _tmp3_ = NULL;

                gchar* _tmp4_ = NULL;

                gchar* _tmp5_;

                _tmp1_ = cheese_main_window_new ();

                _g_object_unref0 (cheese_main_main_window);

                cheese_main_main_window = g_object_ref_sink (_tmp1_);

                _tmp2_ = _ ("Cheese");

                g_set_application_name (_tmp2_);

                gtk_window_set_default_icon_name ("cheese");

                _tmp3_ = gtk_icon_theme_get_default ();

                _tmp4_ = g_build_filename (PACKAGE_DATADIR, "icons", NULL);

                _tmp5_ = _tmp4_;

                gtk_icon_theme_append_search_path (_tmp3_, _tmp5_);

                _g_free0 (_tmp5_);

                cheese_main_window_setup_ui (cheese_main_main_window);

                if (cheese_main_wide) {

                        cheese_main_window_set_startup_wide_mode (cheese_main_main_window);

                }

                if (cheese_main_fullscreen) {

                        cheese_main_window_set_startup_fullscreen_mode (cheese_main_main_window);

                }

                gtk_window_set_application ((GtkWindow*) cheese_main_main_window, (GtkApplication*) self);

                g_signal_connect ((GtkWidget*) cheese_main_main_window, "destroy", (GCallback) _gtk_main_quit_gtk_widget_destroy, NULL);

                gtk_widget_show ((GtkWidget*) cheese_main_main_window);

                cheese_main_window_setup_camera (cheese_main_main_window, cheese_main_device);

        }

}

 

 

static gboolean cheese_main_real_local_command_line (GApplication* base, gchar*** arguments, gint* exit_status) {

        CheeseMain * self;

        gint _exit_status = 0;

        gboolean result = FALSE;

        gchar** local_args;

        gint local_args_length1;

        gint _local_args_size_;

        gint n_args;

        GError * _inner_error_ = NULL;

        self = (CheeseMain*) base;

        g_application_register ((GApplication*) self, NULL, &_inner_error_);

        if (_inner_error_ != NULL) {

                goto __catch0_g_error;

        }

        goto __finally0;

        __catch0_g_error:

        {

                GError * e;

                e = _inner_error_;

                _inner_error_ = NULL;

                fprintf (stdout, "Error: %s\n", e->message);

                _exit_status = 1;

                result = TRUE;

                _g_error_free0 (e);

                if (exit_status) {

                        *exit_status = _exit_status;

                }

                return result;

        }

        __finally0:

        if (_inner_error_ != NULL) {

                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

                g_clear_error (&_inner_error_);

                return FALSE;

        }

        local_args = *arguments;

        local_args_length1 = _vala_array_length (*arguments);

        _local_args_size_ = _vala_array_length (*arguments);

        n_args = local_args_length1;

        if (n_args <= 1) {

                gst_init (&local_args_length1, &local_args);

                g_application_activate ((GApplication*) self);

                _exit_status = 0;

        } else {

                const gchar* _tmp0_ = NULL;

                GOptionContext* _tmp1_ = NULL;

                GOptionContext* context;

                GOptionGroup* _tmp2_ = NULL;

                GOptionGroup* _tmp3_ = NULL;

                GOptionGroup* _tmp4_ = NULL;

                gboolean _tmp6_;

                _tmp0_ = _ ("- Take photos and videos from your webcam");

                _tmp1_ = g_option_context_new (_tmp0_);

                context = _tmp1_;

                g_option_context_set_help_enabled (context, TRUE);

                g_option_context_add_main_entries (context, CHEESE_MAIN_options, NULL);

                _tmp2_ = gtk_get_option_group (TRUE);

                g_option_context_add_group (context, _tmp2_);

                _tmp3_ = clutter_get_option_group ();

                g_option_context_add_group (context, _tmp3_);

                _tmp4_ = gst_init_get_option_group ();

                g_option_context_add_group (context, _tmp4_);

                g_option_context_parse (context, &local_args_length1, &local_args, &_inner_error_);

                if (_inner_error_ != NULL) {

                        _g_option_context_free0 (context);

                        if (_inner_error_->domain == G_OPTION_ERROR) {

                                goto __catch1_g_option_error;

                        }

                        _g_option_context_free0 (context);

                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

                        g_clear_error (&_inner_error_);

                        return FALSE;

                }

                _g_option_context_free0 (context);

                goto __finally1;

                __catch1_g_option_error:

                {

                        GError * e;

                        const gchar* _tmp5_ = NULL;

                        e = _inner_error_;

                        _inner_error_ = NULL;

                        fprintf (stdout, "%s\n", e->message);

                        _tmp5_ = _ ("Run '%s --help' to see a full list of available command line options.\n");

                        fprintf (stdout, _tmp5_, (*arguments)[0]);

                        _exit_status = 1;

                        result = TRUE;

                        _g_error_free0 (e);

                        if (exit_status) {

                                *exit_status = _exit_status;

                        }

                        return result;

                }

                __finally1:

                if (_inner_error_ != NULL) {

                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

                        g_clear_error (&_inner_error_);

                        return FALSE;

                }

                if (cheese_main_version) {

                        fprintf (stdout, "%s %s\n", PACKAGE_NAME, PACKAGE_VERSION);

                        _exit_status = 1;

                        result = TRUE;

                        if (exit_status) {

                                *exit_status = _exit_status;

                        }

                        return result;

                }

                _tmp6_ = g_application_get_is_remote ((GApplication*) self);

                if (_tmp6_) {

                        const gchar* _tmp7_ = NULL;

                        _tmp7_ = _ ("Another instance of Cheese is currently running\n");

                        fprintf (stdout, "%s", _tmp7_);

                        _exit_status = 1;

                        result = TRUE;

                        if (exit_status) {

                                *exit_status = _exit_status;

                        }

                        return result;

                } else {

                        gst_init (&local_args_length1, &local_args);

                        g_application_activate ((GApplication*) self);

                        _exit_status = 0;

                }

        }

        result = TRUE;

        if (exit_status) {

                *exit_status = _exit_status;

        }

        return result;

}

 

 

static void cheese_main_class_init (CheeseMainClass * klass) {

        cheese_main_parent_class = g_type_class_peek_parent (klass);

        G_APPLICATION_CLASS (klass)->local_command_line = cheese_main_real_local_command_line;

        G_OBJECT_CLASS (klass)->finalize = cheese_main_finalize;

}

 

 

static void cheese_main_instance_init (CheeseMain * self) {

}

 

 

static void cheese_main_finalize (GObject* obj) {

        CheeseMain * self;

        self = CHEESE_MAIN (obj);

        G_OBJECT_CLASS (cheese_main_parent_class)->finalize (obj);

}

 

 

GType cheese_main_get_type (void) {

        static volatile gsize cheese_main_type_id__volatile = 0;

        if (g_once_init_enter (&cheese_main_type_id__volatile)) {

                static const GTypeInfo g_define_type_info = { sizeof (CheeseMainClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) cheese_main_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (CheeseMain), 0, (GInstanceInitFunc) cheese_main_instance_init, NULL };

                GType cheese_main_type_id;

                cheese_main_type_id = g_type_register_static (GTK_TYPE_APPLICATION, "CheeseMain", &g_define_type_info, 0);

                g_once_init_leave (&cheese_main_type_id__volatile, cheese_main_type_id);

        }

        return cheese_main_type_id__volatile;

}

 

 

static void _cheese_main_on_app_activate_g_application_activate (GApplication* _sender, gpointer self) {

        cheese_main_on_app_activate (self);

}

 

 

gint _vala_main (gchar** args, int args_length1) {

        gint result = 0;

        CheeseMain* app = NULL;

        CheeseMain* _tmp0_ = NULL;

        gint _tmp1_;

        gint status;

        bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALEDIR);

        bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

        textdomain (GETTEXT_PACKAGE);

        gtk_clutter_init (&args_length1, &args);

        _tmp0_ = cheese_main_new ("org.gnome.Cheese", G_APPLICATION_FLAGS_NONE);

        _g_object_unref0 (app);

        app = _tmp0_;

        g_signal_connect_object ((GApplication*) app, "activate", (GCallback) _cheese_main_on_app_activate_g_application_activate, app, 0);

        _tmp1_ = g_application_run ((GApplication*) app, args_length1, args);

        status = _tmp1_;

        result = status;

        _g_object_unref0 (app);

        return result;

}

 

 

int main (int argc, char ** argv) {

        g_thread_init (NULL);

        g_type_init ();

        return _vala_main (argv, argc);

}

 

 

static gint _vala_array_length (gpointer array) {

        int length;

        length = 0;

        if (array) {

                while (((gpointer*) array)[length]) {

                        length++;

                }

        }

        return length;

}