static void impl_deactivate (TotemPlugin *plugin, TotemObject *totem) { TotemMediaPlayerKeysPlugin *pi = TOTEM_MEDIA_PLAYER_KEYS_PLUGIN (plugin); GtkWindow *window; if (pi->media_player_keys_proxy != NULL) { dbus_g_proxy_call (pi->media_player_keys_proxy, "ReleaseMediaPlayerKeys", NULL, G_TYPE_STRING, "Totem", G_TYPE_INVALID, G_TYPE_INVALID); g_object_unref (pi->media_player_keys_proxy); pi->media_player_keys_proxy = NULL; } if (pi->handler_id != 0) { window = totem_get_main_window (totem); if (window == NULL) return; g_signal_handler_disconnect (G_OBJECT (window), pi->handler_id); g_object_unref (window); } }
static gboolean impl_activate (TotemPlugin *plugin, TotemObject *totem, GError **error) { TotemYouTubePlugin *self = TOTEM_YOUTUBE_PLUGIN (plugin); GtkWindow *main_window; GtkBuilder *builder; guint i; self->totem = g_object_ref (totem); self->bvw = BACON_VIDEO_WIDGET (totem_get_video_widget (totem)); /* Set up the interface */ main_window = totem_get_main_window (totem); builder = totem_plugin_load_interface (plugin, "youtube.ui", TRUE, main_window, self); g_object_unref (main_window); self->search_entry = GTK_ENTRY (gtk_builder_get_object (builder, "yt_search_entry")); self->search_button = GTK_BUTTON (gtk_builder_get_object (builder, "yt_search_button")); self->notebook = GTK_NOTEBOOK (gtk_builder_get_object (builder, "yt_notebook")); /* Set up the tree view pages */ for (i = 0; i < NUM_TREE_VIEWS; i++) set_up_tree_view (self, builder, i); self->current_tree_view = SEARCH_TREE_VIEW; self->vbox = GTK_WIDGET (gtk_builder_get_object (builder, "yt_vbox")); gtk_widget_show_all (self->vbox); /* Add the sidebar page */ totem_add_sidebar_page (totem, "youtube", _("YouTube"), self->vbox); g_object_unref (builder); return TRUE; }
static void query_finished_cb (GObject *source_object, GAsyncResult *result, QueryData *data) { GtkWindow *window; GDataFeed *feed; GError *error = NULL; TotemYouTubePlugin *self = data->plugin; g_debug ("Search finished!"); feed = gdata_service_query_finish (GDATA_SERVICE (self->service), result, &error); /* Stop the progress bar; a little hacky, but it works */ self->progress_bar_increment[data->tree_view] = 1.0; increment_progress_bar_fraction (self, data->tree_view); if (feed != NULL) { /* Success! */ g_object_unref (feed); query_data_free (data); return; } /* Bail out if the operation was cancelled */ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) == TRUE) { /* Cancel the t-param and thumbnail threads, if applicable */ if (data->t_param_cancellable != NULL) g_cancellable_cancel (data->t_param_cancellable); if (data->thumbnail_cancellable != NULL) g_cancellable_cancel (data->thumbnail_cancellable); goto finish; } /* Error! */ window = totem_get_main_window (data->plugin->totem); if (g_error_matches (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR) == TRUE) { /* Hide the ugly technical message libgdata gives behind a nice one telling them it's out of date (which it likely is * if we're receiving a protocol error). */ totem_interface_error (_("Error Searching for Videos"), _("The response from the server could not be understood. " "Please check you are running the latest version of libgdata."), window); } else { /* Spew out the error message as provided */ totem_interface_error (_("Error Searching for Videos"), error->message, window); } g_object_unref (window); finish: g_error_free (error); query_data_free (data); return; }
static void impl_deactivate (PeasActivatable *plugin) { TotemGromitPlugin *pi = TOTEM_GROMIT_PLUGIN (plugin); GtkWindow *window; if (pi->priv->handler_id != 0) { window = totem_get_main_window (g_object_get_data (G_OBJECT (plugin), "object")); g_signal_handler_disconnect (G_OBJECT(window), pi->priv->handler_id); pi->priv->handler_id = 0; g_object_unref (window); } totem_gromit_clear (pi, TRUE); g_free (pi->priv->path); pi->priv->path = NULL; }
static void impl_activate (PeasActivatable *plugin) { TotemMediaPlayerKeysPlugin *pi = TOTEM_MEDIA_PLAYER_KEYS_PLUGIN (plugin); TotemObject *totem; GtkWindow *window; pi->priv->watch_id = g_bus_watch_name (G_BUS_TYPE_SESSION, "org.gnome.SettingsDaemon", G_BUS_NAME_WATCHER_FLAGS_NONE, (GBusNameAppearedCallback) name_appeared_cb, (GBusNameVanishedCallback) name_vanished_cb, g_object_ref (pi), (GDestroyNotify) g_object_unref); totem = g_object_get_data (G_OBJECT (plugin), "object"); window = totem_get_main_window (totem); pi->priv->handler_id = g_signal_connect (G_OBJECT (window), "focus-in-event", G_CALLBACK (on_window_focus_in_event), pi); g_object_unref (G_OBJECT (window)); }
static void impl_deactivate (PeasActivatable *plugin) { TotemMediaPlayerKeysPlugin *pi = TOTEM_MEDIA_PLAYER_KEYS_PLUGIN (plugin); GtkWindow *window; if (pi->priv->cancellable_init) { g_cancellable_cancel (pi->priv->cancellable_init); } if (pi->priv->cancellable) { g_cancellable_cancel (pi->priv->cancellable); } if (pi->priv->proxy != NULL) { g_object_unref (pi->priv->proxy); pi->priv->proxy = NULL; } if (pi->priv->handler_id != 0) { TotemObject *totem; totem = g_object_get_data (G_OBJECT (plugin), "object"); window = totem_get_main_window (totem); if (window == NULL) return; g_signal_handler_disconnect (G_OBJECT (window), pi->priv->handler_id); g_object_unref (window); pi->priv->handler_id = 0; } if (pi->priv->watch_id != 0) { g_bus_unwatch_name (pi->priv->watch_id); pi->priv->watch_id = 0; } }
static void impl_activate (PeasActivatable *plugin) { TotemGromitPlugin *pi = TOTEM_GROMIT_PLUGIN (plugin); GtkWindow *window; pi->priv->id = -1; pi->priv->pid = -1; if (!totem_gromit_available (pi)) { //FIXME #if 0 g_set_error_literal (error, TOTEM_PLUGIN_ERROR, TOTEM_PLUGIN_ERROR_ACTIVATION, _("The gromit binary was not found.")); return FALSE; #endif } window = totem_get_main_window (g_object_get_data (G_OBJECT (plugin), "object")); pi->priv->handler_id = g_signal_connect (G_OBJECT(window), "key-press-event", G_CALLBACK (on_window_key_press_event), plugin); g_object_unref (window); }
void open_in_web_browser_activate_cb (GtkAction *action, TotemYouTubePlugin *self) { GtkTreeSelection *selection; GtkTreeModel *model; GList *paths, *path; selection = gtk_tree_view_get_selection (self->tree_view[self->current_tree_view]); paths = gtk_tree_selection_get_selected_rows (selection, &model); for (path = paths; path != NULL; path = path->next) { GtkTreeIter iter; GDataYouTubeVideo *video; GDataLink *link; GError *error = NULL; if (gtk_tree_model_get_iter (model, &iter, (GtkTreePath*) (path->data)) == FALSE) continue; /* Get the HTML page for the video; its <link rel="alternate" ... /> */ gtk_tree_model_get (model, &iter, 3, &video, -1); link = gdata_entry_look_up_link (GDATA_ENTRY (video), GDATA_LINK_ALTERNATE); g_object_unref (video); /* Display the page */ if (gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (self->bvw)), gdata_link_get_uri (link), GDK_CURRENT_TIME, &error) == FALSE) { GtkWindow *window = totem_get_main_window (self->totem); totem_interface_error (_("Error Opening Video in Web Browser"), error->message, window); g_object_unref (window); g_error_free (error); } } g_list_foreach (paths, (GFunc) gtk_tree_path_free, NULL); g_list_free (paths); }
static gboolean impl_activate (TotemPlugin *plugin, TotemObject *totem, GError **error) { TotemOntopPlugin *pi = TOTEM_ONTOP_PLUGIN (plugin); pi->priv->window = totem_get_main_window (totem); pi->priv->bvw = BACON_VIDEO_WIDGET (totem_get_video_widget (totem)); pi->priv->totem = totem; pi->priv->handler_id = g_signal_connect (G_OBJECT (totem), "notify::playing", G_CALLBACK (property_notify_cb), pi); pi->priv->handler_id_metadata = g_signal_connect (G_OBJECT (pi->priv->bvw), "got-metadata", G_CALLBACK (got_metadata_cb), pi); update_from_state (pi->priv); return TRUE; }
static void resolve_t_param_cb (SoupSession *session, SoupMessage *message, TParamData *data) { gchar *video_uri = NULL; const gchar *video_id, *contents; gsize length; GMatchInfo *match_info; GtkTreeIter iter; TotemYouTubePlugin *self = data->plugin; /* Prevent cancellation */ g_cancellable_disconnect (data->cancellable, data->cancelled_id); /* Finish loading the page */ if (message->status_code != SOUP_STATUS_OK) { GtkWindow *window; /* Bail out if the operation was cancelled */ if (message->status_code == SOUP_STATUS_CANCELLED) goto free_data; /* Couldn't load the page contents; error */ window = totem_get_main_window (data->plugin->totem); totem_interface_error (_("Error Looking Up Video URI"), message->response_body->data, window); g_object_unref (window); goto free_data; } contents = message->response_body->data; length = message->response_body->length; video_id = gdata_youtube_video_get_video_id (GDATA_YOUTUBE_VIDEO (data->entry)); /* Check for the fmt_url_map parameter */ g_regex_match (self->regex, contents, 0, &match_info); if (g_match_info_matches (match_info) == TRUE) { gchar *fmt_url_map_escaped, *fmt_url_map; gchar **mappings, **i; GHashTable *fmt_table; gint connection_speed; /* We have a match */ fmt_url_map_escaped = g_match_info_fetch (match_info, 1); fmt_url_map = g_uri_unescape_string (fmt_url_map_escaped, NULL); g_free (fmt_url_map_escaped); /* The fmt_url_map parameter is in the following format: * fmt1|uri1,fmt2|uri2,fmt3|uri3,... * where fmtN is an identifier for the audio and video encoding and resolution as described here: * (http://en.wikipedia.org/wiki/YouTube#Quality_and_codecs) and uriN is the playback URI for that format. * * We parse it into a hash table from format to URI, and use that against a ranked list of preferred formats (based on the user's * connection speed) to determine the URI to use. */ fmt_table = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free); mappings = g_strsplit (fmt_url_map, ",", 0); for (i = mappings; *i != NULL; i++) { /* For the moment we just take the first format we get */ gchar **mapping; gint fmt; mapping = g_strsplit (*i, "|", 2); if (mapping[0] == NULL || mapping[1] == NULL) { g_warning ("Bad format-URI mapping: %s", *i); g_strfreev (mapping); continue; } fmt = atoi (mapping[0]); if (fmt < 1) { g_warning ("Badly-formed format: %s", mapping[0]); g_strfreev (mapping); continue; } g_hash_table_insert (fmt_table, GUINT_TO_POINTER ((guint) fmt), g_strdup (mapping[1])); g_strfreev (mapping); } g_strfreev (mappings); /* Starting with the highest connection speed we support, look for video URIs matching our connection speed. */ connection_speed = MIN (bacon_video_widget_get_connection_speed (self->bvw), (gint) G_N_ELEMENTS (fmt_preferences) - 1); for (; connection_speed >= 0; connection_speed--) { guint idx = (guint) connection_speed; video_uri = g_strdup (g_hash_table_lookup (fmt_table, GUINT_TO_POINTER (fmt_preferences [idx]))); /* Have we found a match yet? */ if (video_uri != NULL) { g_debug ("Using video URI for format %u (connection speed %u)", fmt_preferences[idx], idx); break; } } g_hash_table_destroy (fmt_table); } /* Fallback */ if (video_uri == NULL) { GDataMediaContent *content; /* We don't have a match, which is odd; fall back to the FLV URI as advertised by the YouTube API */ content = GDATA_MEDIA_CONTENT (gdata_youtube_video_look_up_content (GDATA_YOUTUBE_VIDEO (data->entry), "application/x-shockwave-flash")); if (content != NULL) { video_uri = g_strdup (gdata_media_content_get_uri (content)); g_debug ("Couldn't find the t param of entry %s; falling back to its FLV URI (\"%s\")", video_id, video_uri); } else { /* Cop out */ g_warning ("Couldn't find the t param of entry %s or its FLV URI.", video_uri); video_uri = NULL; } } g_match_info_free (match_info); /* Update the tree view with the new MRL */ if (gtk_tree_model_get_iter (GTK_TREE_MODEL (self->list_store[data->tree_view]), &iter, data->path) == TRUE) { gtk_list_store_set (self->list_store[data->tree_view], &iter, 2, video_uri, -1); g_debug ("Updated list store with new video URI (\"%s\") for entry %s", video_uri, video_id); } g_free (video_uri); free_data: /* Update the progress bar */ increment_progress_bar_fraction (self, data->tree_view); g_object_unref (data->cancellable); g_object_unref (data->plugin); g_object_unref (data->entry); gtk_tree_path_free (data->path); g_slice_free (TParamData, data); }
static gboolean impl_activate (TotemPlugin *plugin, TotemObject *totem, GError **error) { TotemMediaPlayerKeysPlugin *pi = TOTEM_MEDIA_PLAYER_KEYS_PLUGIN (plugin); DBusGConnection *connection; GError *err = NULL; GtkWindow *window; connection = dbus_g_bus_get (DBUS_BUS_SESSION, &err); if (connection == NULL) { g_warning ("Error connecting to D-Bus: %s", err->message); return FALSE; } /* Try the mate-settings-daemon version, * then the mate-control-center version of things */ pi->media_player_keys_proxy = dbus_g_proxy_new_for_name_owner (connection, "org.mate.SettingsDaemon", "/org/mate/SettingsDaemon/MediaKeys", "org.mate.SettingsDaemon.MediaKeys", NULL); if (pi->media_player_keys_proxy == NULL) { pi->media_player_keys_proxy = dbus_g_proxy_new_for_name_owner (connection, "org.mate.SettingsDaemon", "/org/mate/SettingsDaemon", "org.mate.SettingsDaemon", &err); } dbus_g_connection_unref (connection); if (err != NULL) { gboolean daemon_not_running; g_warning ("Failed to create dbus proxy for org.mate.SettingsDaemon: %s", err->message); daemon_not_running = (err->code == DBUS_GERROR_NAME_HAS_NO_OWNER); g_error_free (err); /* don't popup error if settings-daemon is not running, * ie when starting totem not under MATE desktop */ return daemon_not_running; } else { g_signal_connect_object (pi->media_player_keys_proxy, "destroy", G_CALLBACK (proxy_destroy), pi, 0); } dbus_g_proxy_call (pi->media_player_keys_proxy, "GrabMediaPlayerKeys", NULL, G_TYPE_STRING, "Totem", G_TYPE_UINT, 0, G_TYPE_INVALID, G_TYPE_INVALID); dbus_g_object_register_marshaller (totem_marshal_VOID__STRING_STRING, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal (pi->media_player_keys_proxy, "MediaPlayerKeyPressed", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (pi->media_player_keys_proxy, "MediaPlayerKeyPressed", G_CALLBACK (on_media_player_key_pressed), totem, NULL); window = totem_get_main_window (totem); pi->handler_id = g_signal_connect (G_OBJECT (window), "focus-in-event", G_CALLBACK (on_window_focus_in_event), pi); g_object_unref (G_OBJECT (window)); return TRUE; }