~pishuilu1128/unity-china-video-scope/unity-china-video-scope

/* remote-video-main.c generated by valac 0.20.1, the Vala compiler

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

 

/*

 * Copyright (C) 2012 Canonical Ltd

 *

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

 * it under the terms of the GNU General Public License version 3 as

 * published by the Free Software Foundation.

 *

 * 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 <stdlib.h>

#include <string.h>

#include <unity.h>

#include <gio/gio.h>

#include <glib/gi18n-lib.h>

#include <locale.h>

#include <unity-extras.h>

 

 

#define UNITY_VIDEO_LENS_TYPE_REMOTE_VIDEO_SCOPE (unity_video_lens_remote_video_scope_get_type ())

#define UNITY_VIDEO_LENS_REMOTE_VIDEO_SCOPE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), UNITY_VIDEO_LENS_TYPE_REMOTE_VIDEO_SCOPE, UnityVideoLensRemoteVideoScope))

#define UNITY_VIDEO_LENS_REMOTE_VIDEO_SCOPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), UNITY_VIDEO_LENS_TYPE_REMOTE_VIDEO_SCOPE, UnityVideoLensRemoteVideoScopeClass))

#define UNITY_VIDEO_LENS_IS_REMOTE_VIDEO_SCOPE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), UNITY_VIDEO_LENS_TYPE_REMOTE_VIDEO_SCOPE))

#define UNITY_VIDEO_LENS_IS_REMOTE_VIDEO_SCOPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), UNITY_VIDEO_LENS_TYPE_REMOTE_VIDEO_SCOPE))

#define UNITY_VIDEO_LENS_REMOTE_VIDEO_SCOPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), UNITY_VIDEO_LENS_TYPE_REMOTE_VIDEO_SCOPE, UnityVideoLensRemoteVideoScopeClass))

 

typedef struct _UnityVideoLensRemoteVideoScope UnityVideoLensRemoteVideoScope;

typedef struct _UnityVideoLensRemoteVideoScopeClass UnityVideoLensRemoteVideoScopeClass;

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

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

 

 

extern UnityDeprecatedScope* unity_video_lens_scope;

UnityDeprecatedScope* unity_video_lens_scope = NULL;

extern GApplication* unity_video_lens_app;

GApplication* unity_video_lens_app = NULL;

 

#define UNITY_VIDEO_LENS_BUS_NAME "net.launchpad.scope.YoukuVideos"

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

#define CONFIG_PACKAGE "unity-china-video-scope"

#define CONFIG_LOCALEDIR "/usr/share/locale"

static void ___lambda2_ (void);

UnityVideoLensRemoteVideoScope* unity_video_lens_remote_video_scope_new (void);

UnityVideoLensRemoteVideoScope* unity_video_lens_remote_video_scope_construct (GType object_type);

GType unity_video_lens_remote_video_scope_get_type (void) G_GNUC_CONST;

static void ____lambda2__unity_extras_create_scope_callback (gpointer self);

 

 

static void ___lambda2_ (void) {

        UnityVideoLensRemoteVideoScope* _tmp0_;

        UnityDeprecatedScope* _tmp1_;

        GError * _inner_error_ = NULL;

        _tmp0_ = unity_video_lens_remote_video_scope_new ();

        _g_object_unref0 (unity_video_lens_scope);

        unity_video_lens_scope = (UnityDeprecatedScope*) _tmp0_;

        _tmp1_ = unity_video_lens_scope;

        unity_deprecated_scope_base_export ((UnityDeprecatedScopeBase*) _tmp1_, &_inner_error_);

        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;

        }

}

 

 

static void ____lambda2__unity_extras_create_scope_callback (gpointer self) {

        ___lambda2_ ();

}

 

 

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

        gint result = 0;

        GApplication* _tmp4_;

        GApplication* _tmp5_;

        gint _tmp6_ = 0;

        GError * _inner_error_ = NULL;

        g_set_prgname ("unity-remote-video-scope");

        textdomain (CONFIG_PACKAGE);

        bindtextdomain (CONFIG_PACKAGE, CONFIG_LOCALEDIR);

        bind_textdomain_codeset (CONFIG_PACKAGE, "UTF-8");

        setlocale (LC_ALL, "");

        {

                GApplication* _tmp0_ = NULL;

                GApplication* _tmp1_;

                _tmp0_ = unity_extras_dbus_own_name (UNITY_VIDEO_LENS_BUS_NAME, ____lambda2__unity_extras_create_scope_callback, NULL, &_inner_error_);

                _tmp1_ = _tmp0_;

                if (_inner_error_ != NULL) {

                        goto __catch0_g_error;

                }

                _g_object_unref0 (unity_video_lens_app);

                unity_video_lens_app = _tmp1_;

        }

        goto __finally0;

        __catch0_g_error:

        {

                GError* e = NULL;

                GError* _tmp2_;

                const gchar* _tmp3_;

                e = _inner_error_;

                _inner_error_ = NULL;

                _tmp2_ = e;

                _tmp3_ = _tmp2_->message;

                g_warning ("remote-video-main.vala:47: Failed to start video lens daemon: %s\n", _tmp3_);

                result = 1;

                _g_error_free0 (e);

                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 0;

        }

        _tmp4_ = unity_video_lens_app;

        if (_tmp4_ == NULL) {

                g_warning ("remote-video-main.vala:53: %s", "Another instance of the Unity Videos Lens " "already appears to be running.\nBailing out.\n");

                result = 2;

                return result;

        }

        _tmp5_ = unity_video_lens_app;

        _tmp6_ = g_application_run (_tmp5_, 0, NULL);

        result = _tmp6_;

        return result;

}

 

 

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

        g_type_init ();

        return unity_video_lens_main (argv, argc);

}