int main (int argc, char **argv) { GjsContext *js_context; GError *error; #ifdef GDK_WINDOWING_X11 XInitThreads (); #endif clutter_x11_set_use_argb_visual (TRUE); if (gtk_clutter_init (&argc, &argv) < 0) return EXIT_FAILURE; clutter_gst_init (0, NULL); parse_options (&argc, &argv); js_context = gjs_context_new_with_search_path (NULL); error = NULL; register_all_viewers (js_context); if (!gjs_context_eval (js_context, "const Main = imports.ui.main;\n" "Main.run();\n", -1, __FILE__, NULL, &error)) g_error("Failed to load main javascript: %s", error->message); return EXIT_SUCCESS; }
static void cheese_widget_class_init (CheeseWidgetClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); gtk_clutter_init (NULL, NULL); clutter_gst_init (NULL, NULL); object_class->finalize = cheese_widget_finalize; #if 0 object_class->set_property = cheese_widget_set_property; #endif object_class->get_property = cheese_widget_get_property; widget_class->realize = cheese_widget_realize; /** * CheeseWidget:state: * * Current state of the widget. * * Connect to notify::state signal to get notified about state * changes. Useful to update other widgets sensitiveness when the * camera is ready or to handle errors if camera setup fails. */ g_object_class_install_property (object_class, PROP_STATE, g_param_spec_enum ("state", NULL, NULL, CHEESE_TYPE_WIDGET_STATE, CHEESE_WIDGET_STATE_NONE, G_PARAM_READABLE)); g_type_class_add_private (klass, sizeof (CheeseWidgetPrivate)); }
int main(int argc, char *argv[]) { GstElement *pipeline, *sink; ClutterTimeline *timeline; ClutterActor *stage, *texture; /* clutter-gst takes care of initializing Clutter and GStreamer */ if (clutter_gst_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) { g_error ("Failed to initialize clutter\n"); return -1; } stage = clutter_stage_get_default (); /* Make a timeline */ timeline = clutter_timeline_new (1000); g_object_set(timeline, "loop", TRUE, NULL); /* Create new texture and disable slicing so the video is properly mapped onto it */ texture = CLUTTER_ACTOR (g_object_new (CLUTTER_TYPE_TEXTURE, "disable-slicing", TRUE, NULL)); g_signal_connect (texture, "size-change", G_CALLBACK (size_change), NULL); /* Build the GStreamer pipeline */ pipeline = gst_parse_launch ("playbin2 uri=http://docs.gstreamer.com/media/sintel_trailer-480p.webm", NULL); /* Instantiate the Clutter sink */ sink = gst_element_factory_make ("autocluttersink", NULL); if (sink == NULL) { /* Revert to the older cluttersink, in case autocluttersink was not found */ sink = gst_element_factory_make ("cluttersink", NULL); } if (sink == NULL) { g_printerr ("Unable to find a Clutter sink.\n"); return -1; } /* Link GStreamer with Clutter by passing the Clutter texture to the Clutter sink*/ g_object_set (sink, "texture", texture, NULL); /* Add the Clutter sink to the pipeline */ g_object_set (pipeline, "video-sink", sink, NULL); /* Start playing */ gst_element_set_state (pipeline, GST_STATE_PLAYING); /* start the timeline */ clutter_timeline_start (timeline); /* Add texture to the stage, and show it */ clutter_group_add (CLUTTER_GROUP (stage), texture); clutter_actor_show_all (stage); clutter_main(); /* Free resources */ gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (pipeline); return 0; }
int main (int argc, char *argv[]) { ClutterActor *vtexture; int i; clutter_gst_init (&argc, &argv); for (i = 0; ; i++) { g_debug("VideoTexure #%d", i); vtexture = clutter_gst_video_texture_new(); g_object_ref_sink (vtexture); g_object_unref (vtexture); } return EXIT_SUCCESS; }
static void gt_player_backend_gstreamer_clutter_class_init(GtPlayerBackendGstreamerClutterClass* klass) { GObjectClass* obj_class = G_OBJECT_CLASS(klass); static gboolean init = FALSE; obj_class->finalize = finalise; obj_class->get_property = get_property; obj_class->set_property = set_property; props[PROP_VOLUME] = g_param_spec_double("volume", "Volume", "Volume of player", 0.0, 1.0, 0.3, G_PARAM_READWRITE | G_PARAM_CONSTRUCT); props[PROP_PLAYING] = g_param_spec_boolean("playing", "Playing", "Whether playing", FALSE, G_PARAM_READABLE | G_PARAM_CONSTRUCT); props[PROP_URI] = g_param_spec_string("uri", "Uri", "Current uri", "", G_PARAM_READWRITE); props[PROP_BUFFER_FILL] = g_param_spec_double("buffer-fill", "Buffer fill", "Current buffer fill", 0, 1.0, 0, G_PARAM_READWRITE | G_PARAM_CONSTRUCT); g_object_class_override_property(obj_class, PROP_VOLUME, "volume"); g_object_class_override_property(obj_class, PROP_PLAYING, "playing"); g_object_class_override_property(obj_class, PROP_URI, "uri"); g_object_class_override_property(obj_class, PROP_BUFFER_FILL, "buffer-fill"); if (!init) { gint res = gtk_clutter_init(NULL, NULL); clutter_gst_init(NULL, NULL); init = TRUE; } }
void Platform::init(int* argc, char*** argv) { if(m_initialized) return; m_initialized = true; if (!g_thread_supported ()) g_thread_init (NULL); clutter_gst_init (argc, argv); m_stage = clutter_stage_get_default(); clutter_actor_set_size(m_stage, (gfloat)960, (gfloat)540); m_videoTexture = clutter_texture_new (); GstPlaybin::getInstance().init(m_videoTexture); clutter_container_add_actor (CLUTTER_CONTAINER (m_stage), m_videoTexture); g_signal_connect (CLUTTER_STAGE (m_stage), "fullscreen", G_CALLBACK (Platform::windowSizeChanged), this); g_signal_connect (CLUTTER_STAGE (m_stage), "unfullscreen", G_CALLBACK (Platform::windowSizeChanged), this); // g_signal_connect (CLUTTER_STAGE (m_stage), "event", G_CALLBACK (Platform::stageEvent), this); }
static void mex_base_init (int *argc, char ***argv) { static gsize initialised; if (g_once_init_enter (&initialised)) { /* initialize debugging infrastructure */ _mex_log_init_core_domains (); /* initialise Clutter */ if (!clutter_init (argc, argv)) g_error ("Failed to initialize clutter"); #ifdef USE_PLAYER_CLUTTER_GST clutter_gst_init (argc, argv); #endif mex_init_default_categories (); mex_init_load_grilo_plugins(); g_once_init_leave (&initialised, TRUE); } }
int main (int argc, char *argv[]) { GOptionContext *optcontext; GOptionEntry options[] = { { NULL } }; #ifdef ENABLE_DEBUG TpDebugSender *debug_sender; #endif GError *error = NULL; gint retval; GtkSettings *gtk_settings; /* Init */ g_thread_init (NULL); #ifdef GDK_WINDOWING_X11 /* We can't call clutter_gst_init() before gtk_clutter_init(), so no choice * but to intiialise X11 threading ourself */ XInitThreads (); #endif /* Clutter needs this */ gdk_disable_multidevice (); optcontext = g_option_context_new (N_("- Empathy Audio/Video Client")); g_option_context_add_group (optcontext, gst_init_get_option_group ()); g_option_context_add_group (optcontext, gtk_get_option_group (TRUE)); g_option_context_add_group (optcontext, cogl_get_option_group ()); g_option_context_add_group (optcontext, clutter_get_option_group_without_init ()); g_option_context_add_group (optcontext, gtk_clutter_get_option_group ()); g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE); if (!g_option_context_parse (optcontext, &argc, &argv, &error)) { g_print ("%s\nRun '%s --help' to see a full list of available command " "line options.\n", error->message, argv[0]); g_warning ("Error in empathy-call init: %s", error->message); return EXIT_FAILURE; } g_option_context_free (optcontext); clutter_gst_init (&argc, &argv); empathy_gtk_init (); g_set_application_name (_("Empathy Audio/Video Client")); /* Make empathy and empathy-call appear as the same app in gnome-shell */ gdk_set_program_class ("Empathy"); gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); gtk_settings = gtk_settings_get_default (); g_object_set (G_OBJECT (gtk_settings), "gtk-application-prefer-dark-theme", TRUE, NULL); app = gtk_application_new (EMPATHY_CALL_DBUS_NAME, G_APPLICATION_FLAGS_NONE); g_signal_connect (app, "activate", G_CALLBACK (activate_cb), NULL); #ifdef ENABLE_DEBUG /* Set up debug sender */ debug_sender = tp_debug_sender_dup (); g_log_set_default_handler (tp_debug_sender_log_handler, G_LOG_DOMAIN); #endif if (g_getenv ("EMPATHY_PERSIST") != NULL) { DEBUG ("Disable timer"); use_timer = FALSE; } call_windows = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL); /* the inactivity timeout can only be set while the application is held */ g_application_hold (G_APPLICATION (app)); g_application_set_inactivity_timeout (G_APPLICATION (app), TIMEOUT * 1000); g_application_release (G_APPLICATION (app)); retval = g_application_run (G_APPLICATION (app), argc, argv); g_hash_table_unref (call_windows); g_object_unref (app); tp_clear_object (&call_factory); #ifdef ENABLE_DEBUG g_object_unref (debug_sender); #endif return retval; }
int main (int argc, char *argv[]) { ClutterActor *video; /* So we can fade out at the end. */ clutter_x11_set_use_argb_visual (TRUE); if (clutter_gst_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return EXIT_FAILURE; if (argc < 2) { g_print ("Usage: %s [OPTIONS] <video file>\n", argv[0]); return EXIT_FAILURE; } if (!clutter_color_from_string (&bg_color, BG_COLOR)) { g_warning ("Invalid BG_COLOR"); exit (1); } stage = clutter_stage_new (); /* Clutter's full-screening code does not allow us to * set both that and _NET_WM_STATE_ABOVE, so do the state * management ourselves for now. */ #if 0 clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), TRUE); #endif /* Clutter will set maximum size restrictions (meaning not * full screen) unless I set this. */ clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE); clutter_stage_set_use_alpha (CLUTTER_STAGE (stage), TRUE); clutter_actor_set_background_color (stage, &bg_color); clutter_actor_set_layout_manager (stage, clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_FIXED, CLUTTER_BIN_ALIGNMENT_FIXED)); clutter_actor_realize (stage); set_above_and_fullscreen (); video = clutter_gst_video_texture_new (); clutter_actor_set_x_expand (video, TRUE); clutter_actor_set_y_expand (video, TRUE); clutter_actor_set_x_align (video, CLUTTER_ACTOR_ALIGN_CENTER); clutter_actor_set_y_align (video, CLUTTER_ACTOR_ALIGN_CENTER); set_idle_material (CLUTTER_GST_VIDEO_TEXTURE (video)); g_signal_connect (video, "eos", G_CALLBACK (on_video_texture_eos), NULL); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); clutter_media_set_filename (CLUTTER_MEDIA (video), argv[1]); clutter_stage_hide_cursor (CLUTTER_STAGE (stage)); clutter_actor_add_child (stage, video); g_signal_connect (stage, "key-press-event", G_CALLBACK (key_press_cb), NULL); clutter_media_set_playing (CLUTTER_MEDIA (video), TRUE); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
int main (int argc, char **argv) { PinPointRenderer *renderer; GOptionContext *context; GError *error = NULL; char *text = NULL; memcpy (&default_point, &pin_default_point, sizeof (default_point)); renderer = pp_clutter_renderer (); context = g_option_context_new ("- Presentations made easy"); g_option_context_add_main_entries (context, entries, NULL); g_option_context_add_group (context, clutter_get_option_group_without_init ()); g_option_context_add_group (context, cogl_get_option_group ()); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_print ("option parsing failed: %s\n", error->message); return EXIT_FAILURE; } pinfile = argv[1]; if (!pinfile) { g_print ("usage: %s [options] <presentation>\n", argv[0]); text = g_strdup ("[no-markup][transition=sheet][red]\n" "--\n" "usage: pinpoint [options] <presentation.txt>\n"); } else { if (!g_file_get_contents (pinfile, &text, NULL, NULL)) { g_print ("failed to load presentation from %s\n", pinfile); return -1; } } #ifdef USE_CLUTTER_GST clutter_gst_init (&argc, &argv); #else clutter_init (&argc, &argv); #endif #ifdef USE_DAX dax_init (&argc, &argv); #endif /* select the cairo renderer if we have requested pdf output */ if (pp_output_filename && g_str_has_suffix (pp_output_filename, ".pdf")) { #ifdef HAVE_PDF renderer = pp_cairo_renderer (); /* makes more sense to default to a white "stage" colour in PDFs*/ default_point.stage_color = "white"; #else g_warning ("Pinpoint was built without PDF support"); return EXIT_FAILURE; #endif } if (!pinfile) pp_rehearse = FALSE; if (pinfile) { GFile *file; file = g_file_new_for_commandline_arg (pinfile); pp_basedir = g_file_get_parent (file); g_object_unref (file); } renderer->init (renderer, pinfile); pp_parse_slides (renderer, text); g_free (text); if (pp_rehearse) { pp_rehearse_init (); printf ("Running in rehearsal mode, press ctrl+C to abort without saving timings back to %s\n", pinfile); } renderer->run (renderer); renderer->finalize (renderer); if (renderer->source) g_free (renderer->source); #if 0 if (pp_rehearse) pp_rehearse_save (); #endif g_list_free (pp_slides); return 0; }
int main (int argc, char *argv[]) { UserInterface *ui = NULL; GstEngine *engine = NULL; ClutterActor *video_texture; GstElement *sink; gboolean ok, fullscreen = FALSE; gint ret = 0; guint c, index, pos = 0; gchar *fileuri, *uri; gchar *file_list[argc]; GOptionContext *context; if (!g_thread_supported ()) g_thread_init (NULL); context = g_option_context_new ("<media file> - Play movie files"); ok = process_args (argc, argv, file_list, &fullscreen, context); if (!ok) goto quit; config_load (); // User Interface ui = g_new0 (UserInterface, 1); ui->fullscreen = fullscreen; video_texture = clutter_texture_new (); clutter_gst_init (&argc, &argv); // Gstreamer engine = g_new0 (GstEngine, 1); ui->engine = engine; sink = clutter_gst_video_sink_new (CLUTTER_TEXTURE (video_texture)); ok = engine_init (engine, sink); if (!ok) goto quit; ui->texture = video_texture; gst_bus_add_watch (engine->bus, bus_call, ui); gst_object_unref (engine->bus); if (gst_uri_is_valid (file_list[0])) uri = g_strdup (file_list[0]); else { fileuri = clean_uri (file_list[0]); uri = g_strdup_printf ("file://%s", fileuri); } engine_load_uri (engine, uri); interface_load_uri (ui, uri); load_user_interface (ui); change_state (engine, "Paused"); change_state (engine, "Playing"); clutter_main (); close_down (ui, engine); quit: g_option_context_free (context); return ret; }
/* snappy's main function */ int main (int argc, char *argv[]) { UserInterface *ui = NULL; GstEngine *engine = NULL; ClutterActor *video_texture; GstElement *sink; gboolean ok, blind = FALSE, fullscreen = FALSE, hide = FALSE, loop = FALSE; gboolean secret = FALSE, tags = FALSE; gint ret = 0; guint c, index, pos = 0; gchar *uri; gchar *suburi = NULL; gchar *version_str; GList *uri_list; GOptionContext *context; gchar *data_dir; #ifdef ENABLE_DBUS SnappyMP *mp_obj = NULL; #endif /* Try to find the path for our resources in case snappy was relocated */ data_dir = g_strdup(SNAPPY_DATA_DIR); if (!g_file_test(data_dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) { gchar *root_dir; #ifdef G_OS_WIN32 root_dir = g_win32_get_package_installation_directory_of_module(NULL); #elif !defined(G_OS_UNIX) gchar *exec_path; gchar *bin_dir; exec_path = g_file_read_link("/proc/self/exe", NULL); bin_dir = g_path_get_dirname(exec_path); root_dir = g_build_filename(bin_dir, "..", NULL); g_free(exec_path); g_free(bin_dir); #else root_dir = NULL; #endif if (root_dir != NULL) { data_dir = g_build_filename(root_dir, "share", "snappy", NULL); g_free(root_dir); } } if (!g_thread_supported ()) g_thread_init (NULL); context = g_option_context_new ("<media file> - Play movie files"); /* Process command arguments */ uri_list = process_args (argc, argv, &blind, &fullscreen, &hide, &loop, &secret, &suburi, &tags, context); if (uri_list == NULL) goto quit; /* User Interface */ ui = g_new (UserInterface, 1); ui->uri_list = uri_list; ui->blind = blind; ui->fullscreen = fullscreen; ui->hide = hide; ui->tags = tags; ui->data_dir = data_dir; interface_init (ui); video_texture = clutter_texture_new (); clutter_gst_init (&argc, &argv); version_str = gst_version_string (); GST_DEBUG_CATEGORY_INIT (_snappy_gst_debug, "snappy", 0, "snappy media player"); GST_DEBUG ("Initialised %s", version_str); /* Gstreamer engine */ engine = g_new (GstEngine, 1); sink = gst_element_factory_make ("autocluttersink", "cluttersink"); if (sink == NULL) { GST_DEBUG ("autocluttersink not found, falling back to cluttersink\n"); sink = gst_element_factory_make ("cluttersink", "cluttersink"); } g_object_set (G_OBJECT (sink), "texture", CLUTTER_TEXTURE (video_texture), NULL); ok = engine_init (engine, sink); if (!ok) goto quit; engine->secret = secret; engine->loop = loop; ui->engine = engine; ui->texture = video_texture; gst_bus_add_watch (engine->bus, bus_call, ui); gst_object_unref (engine->bus); /* Get uri to load */ uri = g_list_first (uri_list)->data; /* Load engine and start interface */ engine_load_uri (engine, uri); interface_start (ui, uri); /* Load subtitle file if available */ if (suburi != NULL) { suburi = clean_uri (suburi); set_subtitle_uri (engine, suburi); } /* Start playing */ change_state (engine, "Paused"); change_state (engine, "Playing"); #ifdef ENABLE_DBUS /* Start MPRIS Dbus object */ mp_obj = g_new (SnappyMP, 1); mp_obj->engine = engine; mp_obj->ui = ui; load_dlna (mp_obj); #endif /* Main loop */ clutter_main (); /* Close snappy */ close_down (ui, engine); #ifdef ENABLE_DBUS close_dlna (mp_obj); #endif quit: g_list_free (uri_list); g_option_context_free (context); return ret; }
/* snappy's main function */ int main (int argc, char *argv[]) { UserInterface *ui = NULL; GstEngine *engine = NULL; ClutterActor *video_texture; ClutterGstVideoSink *sink; gboolean ok, blind = FALSE, fullscreen = FALSE, hide = FALSE, loop = FALSE; gboolean secret = FALSE, tags = FALSE; gint ret = 0; gchar *uri = NULL; gchar *suburi = NULL; GList *uri_list; GOptionContext *context; gchar *data_dir; ClutterInitError ci_err; #ifdef ENABLE_DBUS SnappyMP *mp_obj = NULL; #endif context = g_option_context_new ("<media file> - Play movie files"); clutter_set_windowing_backend (CLUTTER_WINDOWING_X11); ci_err = gtk_clutter_init (&argc, &argv); if (ci_err != CLUTTER_INIT_SUCCESS) goto quit; /* Try to find the path for our resources in case snappy was relocated */ data_dir = g_strdup (SNAPPY_DATA_DIR); if (!g_file_test (data_dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) { gchar *root_dir; #ifdef G_OS_WIN32 root_dir = g_win32_get_package_installation_directory_of_module (NULL); #elif !defined(G_OS_UNIX) gchar *exec_path; gchar *bin_dir; exec_path = g_file_read_link ("/proc/self/exe", NULL); bin_dir = g_path_get_dirname (exec_path); root_dir = g_build_filename (bin_dir, "..", NULL); g_free (exec_path); g_free (bin_dir); #else root_dir = NULL; #endif if (root_dir != NULL) { data_dir = g_build_filename (root_dir, "share", "snappy", NULL); g_free (root_dir); } } /* Process command arguments */ uri_list = process_args (argc, argv, &blind, &fullscreen, &hide, &loop, &secret, &suburi, &tags, context); gst_init (&argc, &argv); clutter_gst_init (NULL, NULL); /* User Interface */ ui = g_new (UserInterface, 1); ui->uri_list = uri_list; ui->blind = blind; ui->fullscreen = fullscreen; ui->hide = hide; ui->tags = tags; ui->data_dir = data_dir; interface_init (ui); /* Gstreamer engine */ engine = g_new (GstEngine, 1); sink = clutter_gst_video_sink_new (); if (sink == NULL) { g_print ("ERROR: Failed to create clutter-gst sink element\n"); return FALSE; } video_texture = g_object_new (CLUTTER_TYPE_ACTOR, "content", g_object_new (CLUTTER_GST_TYPE_CONTENT, "sink", sink, NULL), "name", "texture", NULL); ok = engine_init (engine, sink); if (!ok) goto quit; engine->secret = secret; engine->loop = loop; ui->engine = engine; ui->texture = video_texture; gst_bus_add_watch (engine->bus, bus_call, ui); gst_object_unref (engine->bus); /* Get uri to load */ if (uri_list) { uri = g_list_first (uri_list)->data; /* based on video filename we can guess subtitle file (.srt files only) */ if (NULL == suburi) { gchar suburi_path_guessing[1024]; //buffer gchar *uri_no_extension = strip_filename_extension (uri); sprintf (suburi_path_guessing, "%s.srt", uri_no_extension); /* subtitle file exists, defaults for it */ if (g_file_test (g_filename_from_uri (suburi_path_guessing, NULL, NULL), G_FILE_TEST_EXISTS)) suburi = suburi_path_guessing; } } /* Load engine and start interface */ engine_load_uri (engine, uri); interface_start (ui, uri); /* Load subtitle file if available */ if (suburi != NULL) { suburi = clean_uri (suburi); set_subtitle_uri (engine, suburi); } /* Start playing if we have a URI to play */ if (uri) { change_state (engine, "Paused"); change_state (engine, "Playing"); } #ifdef ENABLE_DBUS /* Start MPRIS Dbus object */ mp_obj = g_new (SnappyMP, 1); mp_obj->engine = engine; mp_obj->ui = ui; load_dlna (mp_obj); #endif /* Main loop */ gtk_main (); /* Close snappy */ close_down (ui, engine); #ifdef ENABLE_DBUS close_dlna (mp_obj); #endif quit: g_list_free (uri_list); g_option_context_free (context); return ret; }
int main (int argc, char *argv[]) { GOptionContext *optcontext; GOptionEntry options[] = { { NULL } }; #ifdef ENABLE_DEBUG TpDebugSender *debug_sender; #endif GError *error = NULL; gint retval; /* Init */ g_thread_init (NULL); optcontext = g_option_context_new (N_("- Empathy Audio/Video Client")); g_option_context_add_group (optcontext, gst_init_get_option_group ()); g_option_context_add_group (optcontext, gtk_get_option_group (TRUE)); g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE); if (!g_option_context_parse (optcontext, &argc, &argv, &error)) { g_print ("%s\nRun '%s --help' to see a full list of available command " "line options.\n", error->message, argv[0]); g_warning ("Error in empathy-av init: %s", error->message); return EXIT_FAILURE; } g_option_context_free (optcontext); clutter_gst_init (&argc, &argv); empathy_gtk_init (); g_set_application_name (_("Empathy Audio/Video Client")); g_setenv ("PULSE_PROP_media.role", "phone", TRUE); /* Make empathy and empathy-av appear as the same app in gnome-shell */ gdk_set_program_class ("Empathy"); gtk_window_set_default_icon_name ("empathy"); textdomain (GETTEXT_PACKAGE); app = gtk_application_new (EMPATHY_AV_DBUS_NAME, G_APPLICATION_FLAGS_NONE); g_signal_connect (app, "activate", G_CALLBACK (activate_cb), NULL); #ifdef ENABLE_DEBUG /* Set up debug sender */ debug_sender = tp_debug_sender_dup (); g_log_set_default_handler (tp_debug_sender_log_handler, G_LOG_DOMAIN); #endif if (g_getenv ("EMPATHY_PERSIST") != NULL) { DEBUG ("Disable timer"); use_timer = FALSE; } /* the inactivity timeout can only be set while the application is held */ g_application_hold (G_APPLICATION (app)); g_application_set_inactivity_timeout (G_APPLICATION (app), TIMEOUT * 1000); g_application_release (G_APPLICATION (app)); retval = g_application_run (G_APPLICATION (app), argc, argv); g_object_unref (app); tp_clear_object (&call_factory); #ifdef ENABLE_DEBUG g_object_unref (debug_sender); #endif return retval; }
int main(int argc, char **argv) { GtkWidget *window; GtkWidget *stage; ClutterColor stage_color = { 0xff, 0xff, 0xff, 0xff }; ClutterTimeline *timeline, *clock; GError *error = NULL; HandCar *all; clutter_init(&argc, &argv); clutter_gst_init(&argc, &argv); gst_init(&argc, &argv); gtk_init(&argc, &argv); all = handcar_new (); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW(window), "Clutter Player"); g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(gtk_main_quit), NULL); stage = gtk_clutter_embed_new(); gtk_widget_set_size_request(stage, STAGE_WIDTH, STAGE_HEIGHT); gtk_container_add(GTK_CONTAINER(window), stage); all->stage_actor = gtk_clutter_embed_get_stage(GTK_CLUTTER_EMBED(stage)); clutter_container_add_actor(CLUTTER_CONTAINER(all->stage_actor), all->rect1); clutter_container_add_actor(CLUTTER_CONTAINER(all->stage_actor), all->rect2); clutter_container_add_actor(CLUTTER_CONTAINER(all->stage_actor), all->rect3); clutter_container_add_actor(CLUTTER_CONTAINER(all->stage_actor), all->btn_actor_play); clutter_container_add_actor(CLUTTER_CONTAINER(all->stage_actor), all->btn_actor_previous); clutter_container_add_actor(CLUTTER_CONTAINER(all->stage_actor), all->btn_actor_next); clutter_container_add_actor(CLUTTER_CONTAINER(all->stage_actor), all->label_actor); clutter_container_add_actor(CLUTTER_CONTAINER(all->stage_actor), all->label_time); clutter_container_add_actor(CLUTTER_CONTAINER(all->stage_actor), all->video); clutter_container_add_actor(CLUTTER_CONTAINER(all->stage_actor), all->entry_actor); clutter_stage_set_color(CLUTTER_STAGE(all->stage_actor), &stage_color); timeline = clutter_timeline_new (100, 5); g_signal_connect(G_OBJECT(timeline), "new-frame", G_CALLBACK(on_timeline_new_frame), (gpointer)all); clutter_timeline_set_loop(timeline, TRUE); clutter_timeline_start(timeline); clock = clutter_timeline_new (60, 2); g_signal_connect(G_OBJECT(clock), "new-frame", G_CALLBACK(on_update_clock), (gpointer)all); clutter_timeline_set_loop(clock, TRUE); clutter_timeline_start(clock); g_signal_connect (all->stage_actor, "motion-event", G_CALLBACK(mouse_over_lighten), (gpointer) all); g_signal_connect (all->stage_actor, "button-press-event", G_CALLBACK(on_click), (gpointer) all); clutter_actor_raise_top (all->entry_actor); gtk_widget_show_all(window); gtk_main(); return 0; }