| /* GStreamer Editing Services | |
| * Copyright (C) 2010 Brandon Lewis <brandon.lewis@collabora.co.uk> | |
| * 2010 Nokia Corporation | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Library General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2 of the License, or (at your option) any later version. | |
| * | |
| * This library 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 | |
| * Library General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Library General Public | |
| * License along with this library; if not, write to the | |
| * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, | |
| * Boston, MA 02110-1301, USA. | |
| */ | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <gtk/gtk.h> | |
| #include <glib.h> | |
| #include <glib/gprintf.h> | |
| #include <ges/ges.h> | |
| /* Application Data ********************************************************/ | |
| /** | |
| * Contains most of the application data so that signal handlers | |
| * and other callbacks have easy access. | |
| */ | |
| typedef struct App | |
| { | |
| /* back-end objects */ | |
| GESTimeline *timeline; | |
| GESPipeline *pipeline; | |
| GESLayer *layer; | |
| GESTrack *audio_track; | |
| GESTrack *video_track; | |
| guint audio_tracks; | |
| guint video_tracks; | |
| /* application state */ | |
| gchar *pending_uri; | |
| int n_objects; | |
| int n_selected; | |
| GList *selected_objects; | |
| GType selected_type; | |
| gboolean first_selected; | |
| gboolean last_selected; | |
| gboolean ignore_input; | |
| GstState state; | |
| GtkListStore *model; | |
| GtkTreeSelection *selection; | |
| /* widgets */ | |
| GtkWidget *main_window; | |
| GtkWidget *add_effect_dlg; | |
| GtkWidget *properties; | |
| GtkWidget *filesource_properties; | |
| GtkWidget *text_properties; | |
| GtkWidget *generic_duration; | |
| GtkWidget *background_properties; | |
| GtkWidget *audio_effect_entry; | |
| GtkWidget *video_effect_entry; | |
| GtkHScale *duration; | |
| GtkHScale *in_point; | |
| GtkHScale *volume; | |
| GtkAction *add_file; | |
| GtkAction *add_effect; | |
| GtkAction *add_test; | |
| GtkAction *add_title; | |
| GtkAction *add_transition; | |
| GtkAction *delete; | |
| GtkAction *play; | |
| GtkAction *stop; | |
| GtkAction *move_up; | |
| GtkAction *move_down; | |
| GtkToggleAction *audio_track_action; | |
| GtkToggleAction *video_track_action; | |
| GtkComboBox *halign; | |
| GtkComboBox *valign; | |
| GtkComboBox *background_type; | |
| GtkEntry *text; | |
| GtkEntry *seconds; | |
| GtkSpinButton *frequency; | |
| } App; | |
| static int n_instances = 0; | |
| /* Prototypes for auto-connected signal handlers ***************************/ | |
| /** | |
| * These are declared non-static for signal auto-connection | |
| */ | |
| gboolean window_delete_event_cb (GtkWidget * window, GdkEvent * event, | |
| App * app); | |
| void new_activate_cb (GtkMenuItem * item, App * app); | |
| void open_activate_cb (GtkMenuItem * item, App * app); | |
| void save_as_activate_cb (GtkMenuItem * item, App * app); | |
| void launch_project_activate_cb (GtkMenuItem * item, App * app); | |
| void quit_item_activate_cb (GtkMenuItem * item, App * app); | |
| void delete_activate_cb (GtkAction * item, App * app); | |
| void play_activate_cb (GtkAction * item, App * app); | |
| void stop_activate_cb (GtkAction * item, App * app); | |
| void move_up_activate_cb (GtkAction * item, App * app); | |
| void move_down_activate_cb (GtkAction * item, App * app); | |
| void add_effect_activate_cb (GtkAction * item, App * app); | |
| void add_file_activate_cb (GtkAction * item, App * app); | |
| void add_text_activate_cb (GtkAction * item, App * app); | |
| void add_test_activate_cb (GtkAction * item, App * app); | |
| void audio_track_activate_cb (GtkToggleAction * item, App * app); | |
| void video_track_activate_cb (GtkToggleAction * item, App * app); | |
| void add_transition_activate_cb (GtkAction * item, App * app); | |
| void app_selection_changed_cb (GtkTreeSelection * selection, App * app); | |
| void halign_changed_cb (GtkComboBox * widget, App * app); | |
| void valign_changed_cb (GtkComboBox * widget, App * app); | |
| void background_type_changed_cb (GtkComboBox * widget, App * app); | |
| void frequency_value_changed_cb (GtkSpinButton * widget, App * app); | |
| void on_apply_effect_cb (GtkButton * button, App * app); | |
| void on_cancel_add_effect_cb (GtkButton * button, App * app); | |
| gboolean add_effect_dlg_delete_event_cb (GtkWidget * widget, GdkEvent * event, | |
| gpointer * app); | |
| gboolean | |
| duration_scale_change_value_cb (GtkRange * range, | |
| GtkScrollType unused, gdouble value, App * app); | |
| gboolean | |
| in_point_scale_change_value_cb (GtkRange * range, | |
| GtkScrollType unused, gdouble value, App * app); | |
| gboolean | |
| volume_change_value_cb (GtkRange * range, | |
| GtkScrollType unused, gdouble value, App * app); | |
| /* UI state functions *******************************************************/ | |
| /** | |
| * Update properties of UI elements that depend on more than one thing. | |
| */ | |
| static void | |
| update_effect_sensitivity (App * app) | |
| { | |
| GList *i; | |
| gboolean ok = TRUE; | |
| /* effects will work for multiple FileSource */ | |
| for (i = app->selected_objects; i; i = i->next) { | |
| if (!GES_IS_URI_CLIP (i->data)) { | |
| ok = FALSE; | |
| break; | |
| } | |
| } | |
| gtk_action_set_sensitive (app->add_effect, | |
| ok && (app->n_selected > 0) && (app->state != GST_STATE_PLAYING) | |
| && (app->state != GST_STATE_PAUSED)); | |
| } | |
| static void | |
| update_delete_sensitivity (App * app) | |
| { | |
| /* delete will work for multiple items */ | |
| gtk_action_set_sensitive (app->delete, | |
| (app->n_selected > 0) && (app->state != GST_STATE_PLAYING) | |
| && (app->state != GST_STATE_PAUSED)); | |
| } | |
| static void | |
| update_add_transition_sensitivity (App * app) | |
| { | |
| gtk_action_set_sensitive (app->add_transition, | |
| (app->state != GST_STATE_PLAYING) && (app->state != GST_STATE_PAUSED)); | |
| } | |
| static void | |
| update_move_up_down_sensitivity (App * app) | |
| { | |
| gboolean can_move; | |
| can_move = (app->n_selected == 1) && | |
| (app->state != GST_STATE_PLAYING) && (app->state != GST_STATE_PAUSED); | |
| gtk_action_set_sensitive (app->move_up, can_move && (!app->first_selected)); | |
| gtk_action_set_sensitive (app->move_down, can_move && (!app->last_selected)); | |
| } | |
| static void | |
| update_play_sensitivity (App * app) | |
| { | |
| gtk_action_set_sensitive (app->play, app->n_objects); | |
| } | |
| /* Backend callbacks ********************************************************/ | |
| static void | |
| test_source_notify_volume_changed_cb (GESClip * clip, GParamSpec * | |
| unused G_GNUC_UNUSED, App * app) | |
| { | |
| gdouble volume; | |
| g_object_get (G_OBJECT (clip), "volume", &volume, NULL); | |
| gtk_range_set_value (GTK_RANGE (app->volume), volume); | |
| } | |
| static void | |
| layer_notify_valid_changed_cb (GObject * object, GParamSpec * unused | |
| G_GNUC_UNUSED, App * app) | |
| { | |
| update_play_sensitivity (app); | |
| } | |
| static gboolean | |
| find_row_for_object (GtkListStore * model, GtkTreeIter * ret, GESClip * clip) | |
| { | |
| gtk_tree_model_get_iter_first ((GtkTreeModel *) model, ret); | |
| while (gtk_list_store_iter_is_valid (model, ret)) { | |
| GESClip *clip2; | |
| gtk_tree_model_get ((GtkTreeModel *) model, ret, 2, &clip2, -1); | |
| if (clip2 == clip) { | |
| gst_object_unref (clip2); | |
| return TRUE; | |
| } | |
| gst_object_unref (clip2); | |
| gtk_tree_model_iter_next ((GtkTreeModel *) model, ret); | |
| } | |
| return FALSE; | |
| } | |
| /* this callback is registered for every clip, and updates the | |
| * corresponding duration cell in the model */ | |
| static void | |
| clip_notify_duration_cb (GESClip * clip, | |
| GParamSpec * arg G_GNUC_UNUSED, App * app) | |
| { | |
| GtkTreeIter iter; | |
| guint64 duration = 0; | |
| g_object_get (clip, "duration", &duration, NULL); | |
| find_row_for_object (app->model, &iter, clip); | |
| gtk_list_store_set (app->model, &iter, 1, duration, -1); | |
| } | |
| /* these guys are only connected to filesources that are the target of the | |
| * current selection */ | |
| static void | |
| filesource_notify_duration_cb (GESClip * clip, | |
| GParamSpec * arg G_GNUC_UNUSED, App * app) | |
| { | |
| guint64 duration, max_inpoint; | |
| duration = GES_TIMELINE_ELEMENT_DURATION (clip); | |
| max_inpoint = GES_TIMELINE_ELEMENT_MAX_DURATION (clip) - duration; | |
| gtk_range_set_value (GTK_RANGE (app->duration), duration); | |
| gtk_range_set_fill_level (GTK_RANGE (app->in_point), max_inpoint); | |
| if (max_inpoint < GES_TIMELINE_ELEMENT_INPOINT (clip)) | |
| g_object_set (clip, "in-point", max_inpoint, NULL); | |
| } | |
| static void | |
| filesource_notify_max_duration_cb (GESClip * clip, | |
| GParamSpec * arg G_GNUC_UNUSED, App * app) | |
| { | |
| gtk_range_set_range (GTK_RANGE (app->duration), 0, (gdouble) | |
| GES_TIMELINE_ELEMENT_MAX_DURATION (clip)); | |
| gtk_range_set_range (GTK_RANGE (app->in_point), 0, (gdouble) | |
| GES_TIMELINE_ELEMENT_MAX_DURATION (clip)); | |
| } | |
| static void | |
| filesource_notify_in_point_cb (GESClip * clip, | |
| GParamSpec * arg G_GNUC_UNUSED, App * app) | |
| { | |
| gtk_range_set_value (GTK_RANGE (app->in_point), | |
| GES_TIMELINE_ELEMENT_INPOINT (clip)); | |
| } | |
| static void | |
| app_update_first_last_selected (App * app) | |
| { | |
| GtkTreePath *path; | |
| /* keep track of whether the first or last items are selected */ | |
| path = gtk_tree_path_new_from_indices (0, -1); | |
| app->first_selected = | |
| gtk_tree_selection_path_is_selected (app->selection, path); | |
| gtk_tree_path_free (path); | |
| path = gtk_tree_path_new_from_indices (app->n_objects - 1, -1); | |
| app->last_selected = | |
| gtk_tree_selection_path_is_selected (app->selection, path); | |
| gtk_tree_path_free (path); | |
| } | |
| static void | |
| object_count_changed (App * app) | |
| { | |
| app_update_first_last_selected (app); | |
| update_move_up_down_sensitivity (app); | |
| update_play_sensitivity (app); | |
| } | |
| static void | |
| title_source_text_changed_cb (GESClip * clip, | |
| GParamSpec * arg G_GNUC_UNUSED, App * app) | |
| { | |
| GtkTreeIter iter; | |
| gchar *text; | |
| g_object_get (clip, "text", &text, NULL); | |
| if (text) { | |
| find_row_for_object (app->model, &iter, clip); | |
| gtk_list_store_set (app->model, &iter, 0, text, -1); | |
| } | |
| } | |
| static void | |
| layer_object_added_cb (GESLayer * layer, GESClip * clip, App * app) | |
| { | |
| GtkTreeIter iter; | |
| gchar *description; | |
| GST_INFO ("layer clip added cb %p %p %p", layer, clip, app); | |
| gtk_list_store_append (app->model, &iter); | |
| if (GES_IS_URI_CLIP (clip)) { | |
| g_object_get (G_OBJECT (clip), "uri", &description, NULL); | |
| gtk_list_store_set (app->model, &iter, 0, description, 2, clip, -1); | |
| } | |
| else if (GES_IS_TITLE_CLIP (clip)) { | |
| gtk_list_store_set (app->model, &iter, 2, clip, -1); | |
| g_signal_connect (G_OBJECT (clip), "notify::text", | |
| G_CALLBACK (title_source_text_changed_cb), app); | |
| title_source_text_changed_cb (clip, NULL, app); | |
| } | |
| else if (GES_IS_TEST_CLIP (clip)) { | |
| gtk_list_store_set (app->model, &iter, 2, clip, 0, "Test Source", -1); | |
| } | |
| else if (GES_IS_BASE_TRANSITION_CLIP (clip)) { | |
| gtk_list_store_set (app->model, &iter, 2, clip, 0, "Transition", -1); | |
| } | |
| g_signal_connect (G_OBJECT (clip), "notify::duration", | |
| G_CALLBACK (clip_notify_duration_cb), app); | |
| clip_notify_duration_cb (clip, NULL, app); | |
| app->n_objects++; | |
| object_count_changed (app); | |
| } | |
| static void | |
| layer_object_removed_cb (GESLayer * layer, GESClip * clip, App * app) | |
| { | |
| GtkTreeIter iter; | |
| GST_INFO ("layer clip removed cb %p %p %p", layer, clip, app); | |
| if (!find_row_for_object (GTK_LIST_STORE (app->model), &iter, clip)) { | |
| gst_print ("clip deleted but we don't own it"); | |
| return; | |
| } | |
| app->n_objects--; | |
| object_count_changed (app); | |
| gtk_list_store_remove (app->model, &iter); | |
| } | |
| static void | |
| layer_object_moved_cb (GESClip * layer, GESClip * clip, | |
| gint old, gint new, App * app) | |
| { | |
| GtkTreeIter a, b; | |
| GtkTreePath *path; | |
| /* we can take the old position as given, but the new position might have to | |
| * be adjusted. */ | |
| new = new < 0 ? (app->n_objects - 1) : new; | |
| path = gtk_tree_path_new_from_indices (old, -1); | |
| gtk_tree_model_get_iter (GTK_TREE_MODEL (app->model), &a, path); | |
| gtk_tree_path_free (path); | |
| path = gtk_tree_path_new_from_indices (new, -1); | |
| gtk_tree_model_get_iter (GTK_TREE_MODEL (app->model), &b, path); | |
| gtk_tree_path_free (path); | |
| gtk_list_store_swap (app->model, &a, &b); | |
| app_selection_changed_cb (app->selection, app); | |
| update_move_up_down_sensitivity (app); | |
| } | |
| static void | |
| pipeline_state_changed_cb (App * app) | |
| { | |
| gboolean playing_or_paused; | |
| if (app->state == GST_STATE_PLAYING) | |
| gtk_action_set_stock_id (app->play, GTK_STOCK_MEDIA_PAUSE); | |
| else | |
| gtk_action_set_stock_id (app->play, GTK_STOCK_MEDIA_PLAY); | |
| update_delete_sensitivity (app); | |
| update_add_transition_sensitivity (app); | |
| update_move_up_down_sensitivity (app); | |
| playing_or_paused = (app->state == GST_STATE_PLAYING) || | |
| (app->state == GST_STATE_PAUSED); | |
| gtk_action_set_sensitive (app->add_file, !playing_or_paused); | |
| gtk_action_set_sensitive (app->add_title, !playing_or_paused); | |
| gtk_action_set_sensitive (app->add_test, !playing_or_paused); | |
| gtk_action_set_sensitive ((GtkAction *) app->audio_track_action, | |
| !playing_or_paused); | |
| gtk_action_set_sensitive ((GtkAction *) app->video_track_action, | |
| !playing_or_paused); | |
| gtk_widget_set_sensitive (app->properties, !playing_or_paused); | |
| } | |
| static void | |
| project_bus_message_cb (GstBus * bus, GstMessage * message, | |
| GMainLoop * mainloop) | |
| { | |
| switch (GST_MESSAGE_TYPE (message)) { | |
| case GST_MESSAGE_ERROR: | |
| gst_printerr ("ERROR\n"); | |
| g_main_loop_quit (mainloop); | |
| break; | |
| case GST_MESSAGE_EOS: | |
| gst_printerr ("Done\n"); | |
| g_main_loop_quit (mainloop); | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| static void | |
| bus_message_cb (GstBus * bus, GstMessage * message, App * app) | |
| { | |
| const GstStructure *s; | |
| s = gst_message_get_structure (message); | |
| switch (GST_MESSAGE_TYPE (message)) { | |
| case GST_MESSAGE_ERROR: | |
| gst_print ("ERROR\n"); | |
| break; | |
| case GST_MESSAGE_EOS: | |
| gst_element_set_state (GST_ELEMENT (app->pipeline), GST_STATE_READY); | |
| break; | |
| case GST_MESSAGE_STATE_CHANGED: | |
| if (s && GST_MESSAGE_SRC (message) == GST_OBJECT_CAST (app->pipeline)) { | |
| GstState old, new, pending; | |
| gst_message_parse_state_changed (message, &old, &new, &pending); | |
| app->state = new; | |
| pipeline_state_changed_cb (app); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| /* Static UI Callbacks ******************************************************/ | |
| static gboolean | |
| check_time (const gchar * time) | |
| { | |
| static GRegex *re = NULL; | |
| if (!re) { | |
| if (NULL == (re = | |
| g_regex_new ("^[0-9][0-9]:[0-5][0-9]:[0-5][0-9](\\.[0-9]+)?$", | |
| G_REGEX_EXTENDED, 0, NULL))) | |
| return FALSE; | |
| } | |
| if (g_regex_match (re, time, 0, NULL)) | |
| return TRUE; | |
| return FALSE; | |
| } | |
| static guint64 | |
| str_to_time (const gchar * str) | |
| { | |
| guint64 ret; | |
| guint64 h, m; | |
| gdouble s; | |
| gchar buf[15]; | |
| buf[0] = str[0]; | |
| buf[1] = str[1]; | |
| buf[2] = '\0'; | |
| h = strtoull (buf, NULL, 10); | |
| buf[0] = str[3]; | |
| buf[1] = str[4]; | |
| buf[2] = '\0'; | |
| m = strtoull (buf, NULL, 10); | |
| strncpy (buf, &str[6], sizeof (buf) - 1); | |
| buf[sizeof (buf) - 1] = '\0'; | |
| s = strtod (buf, NULL); | |
| ret = (h * 3600 * GST_SECOND) + | |
| (m * 60 * GST_SECOND) + ((guint64) (s * GST_SECOND)); | |
| return ret; | |
| } | |
| static void | |
| text_notify_text_changed_cb (GtkEntry * widget, GParamSpec * unused, App * app) | |
| { | |
| GList *tmp; | |
| const gchar *text; | |
| if (app->ignore_input) | |
| return; | |
| text = gtk_entry_get_text (widget); | |
| for (tmp = app->selected_objects; tmp; tmp = tmp->next) { | |
| g_object_set (G_OBJECT (tmp->data), "text", text, NULL); | |
| } | |
| } | |
| static void | |
| seconds_notify_text_changed_cb (GtkEntry * widget, GParamSpec * unused, | |
| App * app) | |
| { | |
| GList *tmp; | |
| const gchar *text; | |
| if (app->ignore_input) | |
| return; | |
| text = gtk_entry_get_text (app->seconds); | |
| if (!check_time (text)) { | |
| gtk_entry_set_icon_from_stock (app->seconds, | |
| GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_DIALOG_WARNING); | |
| } else { | |
| gtk_entry_set_icon_from_stock (app->seconds, | |
| GTK_ENTRY_ICON_SECONDARY, NULL); | |
| for (tmp = app->selected_objects; tmp; tmp = tmp->next) { | |
| g_object_set (GES_CLIP (tmp->data), "duration", | |
| (guint64) str_to_time (text), NULL); | |
| } | |
| } | |
| } | |
| static void | |
| duration_cell_func (GtkTreeViewColumn * column, GtkCellRenderer * renderer, | |
| GtkTreeModel * model, GtkTreeIter * iter, gpointer user) | |
| { | |
| gchar buf[30]; | |
| guint64 duration; | |
| gtk_tree_model_get (model, iter, 1, &duration, -1); | |
| g_snprintf (buf, sizeof (buf), "%u:%02u:%02u.%09u", GST_TIME_ARGS (duration)); | |
| g_object_set (renderer, "text", &buf, NULL); | |
| } | |
| /* UI Initialization ********************************************************/ | |
| static void | |
| connect_to_filesource (GESClip * clip, App * app) | |
| { | |
| g_signal_connect (G_OBJECT (clip), "notify::max-duration", | |
| G_CALLBACK (filesource_notify_max_duration_cb), app); | |
| filesource_notify_max_duration_cb (clip, NULL, app); | |
| g_signal_connect (G_OBJECT (clip), "notify::duration", | |
| G_CALLBACK (filesource_notify_duration_cb), app); | |
| filesource_notify_duration_cb (clip, NULL, app); | |
| g_signal_connect (G_OBJECT (clip), "notify::in-point", | |
| G_CALLBACK (filesource_notify_in_point_cb), app); | |
| filesource_notify_in_point_cb (clip, NULL, app); | |
| } | |
| static void | |
| disconnect_from_filesource (GESClip * clip, App * app) | |
| { | |
| g_signal_handlers_disconnect_by_func (G_OBJECT (clip), | |
| filesource_notify_duration_cb, app); | |
| g_signal_handlers_disconnect_by_func (G_OBJECT (clip), | |
| filesource_notify_max_duration_cb, app); | |
| } | |
| static void | |
| connect_to_title_source (GESClip * clip, App * app) | |
| { | |
| GESTitleClip *titleclip; | |
| titleclip = GES_TITLE_CLIP (clip); | |
| gtk_combo_box_set_active (app->halign, | |
| ges_title_clip_get_halignment (titleclip)); | |
| gtk_combo_box_set_active (app->valign, | |
| ges_title_clip_get_valignment (titleclip)); | |
| gtk_entry_set_text (app->text, ges_title_clip_get_text (titleclip)); | |
| } | |
| static void | |
| disconnect_from_title_source (GESClip * clip, App * app) | |
| { | |
| } | |
| static void | |
| connect_to_test_source (GESClip * clip, App * app) | |
| { | |
| GObjectClass *klass; | |
| GParamSpecDouble *pspec; | |
| GESTestClip *testclip; | |
| testclip = GES_TEST_CLIP (clip); | |
| gtk_combo_box_set_active (app->background_type, | |
| ges_test_clip_get_vpattern (testclip)); | |
| g_signal_connect (G_OBJECT (testclip), "notify::volume", | |
| G_CALLBACK (test_source_notify_volume_changed_cb), app); | |
| test_source_notify_volume_changed_cb (clip, NULL, app); | |
| klass = G_OBJECT_GET_CLASS (G_OBJECT (testclip)); | |
| pspec = G_PARAM_SPEC_DOUBLE (g_object_class_find_property (klass, "volume")); | |
| gtk_range_set_range (GTK_RANGE (app->volume), pspec->minimum, pspec->maximum); | |
| pspec = G_PARAM_SPEC_DOUBLE (g_object_class_find_property (klass, "freq")); | |
| gtk_spin_button_set_range (app->frequency, pspec->minimum, pspec->maximum); | |
| gtk_spin_button_set_value (app->frequency, | |
| ges_test_clip_get_frequency (GES_TEST_CLIP (clip))); | |
| } | |
| static void | |
| disconnect_from_test_source (GESClip * clip, App * app) | |
| { | |
| g_signal_handlers_disconnect_by_func (G_OBJECT (clip), | |
| test_source_notify_volume_changed_cb, app); | |
| } | |
| static void | |
| connect_to_object (GESClip * clip, App * app) | |
| { | |
| gchar buf[30]; | |
| guint64 duration; | |
| app->ignore_input = TRUE; | |
| duration = GES_TIMELINE_ELEMENT_DURATION (clip); | |
| g_snprintf (buf, sizeof (buf), "%02u:%02u:%02u.%09u", | |
| GST_TIME_ARGS (duration)); | |
| gtk_entry_set_text (app->seconds, buf); | |
| if (GES_IS_URI_CLIP (clip)) { | |
| connect_to_filesource (clip, app); | |
| } else if (GES_IS_TITLE_CLIP (clip)) { | |
| connect_to_title_source (clip, app); | |
| } else if (GES_IS_TEST_CLIP (clip)) { | |
| connect_to_test_source (clip, app); | |
| } | |
| app->ignore_input = FALSE; | |
| } | |
| static void | |
| disconnect_from_object (GESClip * clip, App * app) | |
| { | |
| if (GES_IS_URI_CLIP (clip)) { | |
| disconnect_from_filesource (clip, app); | |
| } else if (GES_IS_TITLE_CLIP (clip)) { | |
| disconnect_from_title_source (clip, app); | |
| } else if (GES_IS_TEST_CLIP (clip)) { | |
| disconnect_from_test_source (clip, app); | |
| } | |
| } | |
| static GtkListStore * | |
| get_video_patterns (void) | |
| { | |
| GEnumClass *enum_class; | |
| GESTestClip *tr; | |
| GESTestClipClass *klass; | |
| GParamSpec *pspec; | |
| GEnumValue *v; | |
| GtkListStore *m; | |
| GtkTreeIter i; | |
| m = gtk_list_store_new (1, G_TYPE_STRING); | |
| tr = ges_test_clip_new (); | |
| klass = GES_TEST_CLIP_GET_CLASS (tr); | |
| pspec = g_object_class_find_property (G_OBJECT_CLASS (klass), "vpattern"); | |
| enum_class = G_ENUM_CLASS (g_type_class_ref (pspec->value_type)); | |
| for (v = enum_class->values; v->value_nick != NULL; v++) { | |
| gtk_list_store_append (m, &i); | |
| gtk_list_store_set (m, &i, 0, v->value_name, -1); | |
| } | |
| g_type_class_unref (enum_class); | |
| gst_object_unref (tr); | |
| return m; | |
| } | |
| #define GET_WIDGET(dest,name,type) {\ | |
| if (!(dest =\ | |
| type(gtk_builder_get_object(builder, name))))\ | |
| goto fail;\ | |
| } | |
| static void | |
| layer_added_cb (GESTimeline * timeline, GESLayer * layer, App * app) | |
| { | |
| if (!GES_IS_LAYER (layer)) { | |
| GST_ERROR ("This timeline contains a layer type other than " | |
| "GESLayer. Timeline editing disabled"); | |
| return; | |
| } | |
| if (!(app->layer)) { | |
| app->layer = layer; | |
| } | |
| if (layer != app->layer) { | |
| GST_ERROR ("This demo doesn't support editing timelines with multiple" | |
| " layers"); | |
| return; | |
| } | |
| g_signal_connect (app->layer, "clip-added", | |
| G_CALLBACK (layer_object_added_cb), app); | |
| g_signal_connect (app->layer, "clip-removed", | |
| G_CALLBACK (layer_object_removed_cb), app); | |
| g_signal_connect (app->layer, "object-moved", | |
| G_CALLBACK (layer_object_moved_cb), app); | |
| g_signal_connect (app->layer, "notify::valid", | |
| G_CALLBACK (layer_notify_valid_changed_cb), app); | |
| } | |
| static void | |
| update_track_actions (App * app) | |
| { | |
| g_signal_handlers_disconnect_by_func (app->audio_track_action, | |
| audio_track_activate_cb, app); | |
| g_signal_handlers_disconnect_by_func (app->video_track_action, | |
| video_track_activate_cb, app); | |
| gtk_toggle_action_set_active (app->audio_track_action, app->audio_tracks); | |
| gtk_toggle_action_set_active (app->video_track_action, app->video_tracks); | |
| gtk_action_set_sensitive ((GtkAction *) app->audio_track_action, | |
| app->audio_tracks <= 1); | |
| gtk_action_set_sensitive ((GtkAction *) app->video_track_action, | |
| app->video_tracks <= 1); | |
| g_signal_connect (G_OBJECT (app->audio_track_action), "activate", | |
| G_CALLBACK (audio_track_activate_cb), app); | |
| g_signal_connect (G_OBJECT (app->video_track_action), "activate", | |
| G_CALLBACK (video_track_activate_cb), app); | |
| } | |
| static void | |
| track_added_cb (GESTimeline * timeline, GESTrack * track, App * app) | |
| { | |
| if (track->type == GES_TRACK_TYPE_AUDIO) { | |
| app->audio_tracks++; | |
| if (!app->audio_track) | |
| app->audio_track = track; | |
| } | |
| if (track->type == GES_TRACK_TYPE_VIDEO) { | |
| app->video_tracks++; | |
| if (!app->video_track) | |
| app->video_track = track; | |
| } | |
| update_track_actions (app); | |
| } | |
| static void | |
| track_removed_cb (GESTimeline * timeline, GESTrack * track, App * app) | |
| { | |
| if (track->type == GES_TRACK_TYPE_AUDIO) | |
| app->audio_tracks--; | |
| if (track->type == GES_TRACK_TYPE_VIDEO) | |
| app->video_tracks--; | |
| update_track_actions (app); | |
| } | |
| static gboolean | |
| create_ui (App * app) | |
| { | |
| GtkBuilder *builder; | |
| GtkTreeView *timeline; | |
| GtkTreeViewColumn *duration_col; | |
| GtkCellRenderer *duration_renderer; | |
| GtkCellRenderer *background_type_renderer; | |
| GtkListStore *backgrounds; | |
| GstBus *bus; | |
| /* construct widget tree */ | |
| builder = gtk_builder_new (); | |
| gtk_builder_add_from_file (builder, "ges-ui.glade", NULL); | |
| /* get a bunch of widgets from the XML tree */ | |
| GET_WIDGET (timeline, "timeline_treeview", GTK_TREE_VIEW); | |
| GET_WIDGET (app->properties, "properties", GTK_WIDGET); | |
| GET_WIDGET (app->filesource_properties, "filesource_properties", GTK_WIDGET); | |
| GET_WIDGET (app->text_properties, "text_properties", GTK_WIDGET); | |
| GET_WIDGET (app->main_window, "window", GTK_WIDGET); | |
| GET_WIDGET (app->add_effect_dlg, "add_effect_dlg", GTK_WIDGET); | |
| GET_WIDGET (app->audio_effect_entry, "entry1", GTK_WIDGET); | |
| GET_WIDGET (app->video_effect_entry, "entry2", GTK_WIDGET); | |
| GET_WIDGET (app->duration, "duration_scale", GTK_HSCALE); | |
| GET_WIDGET (app->in_point, "in_point_scale", GTK_HSCALE); | |
| GET_WIDGET (app->halign, "halign", GTK_COMBO_BOX); | |
| GET_WIDGET (app->valign, "valign", GTK_COMBO_BOX); | |
| GET_WIDGET (app->text, "text", GTK_ENTRY); | |
| GET_WIDGET (duration_col, "duration_column", GTK_TREE_VIEW_COLUMN); | |
| GET_WIDGET (duration_renderer, "duration_renderer", GTK_CELL_RENDERER); | |
| GET_WIDGET (app->add_file, "add_file", GTK_ACTION); | |
| GET_WIDGET (app->add_effect, "add_effect", GTK_ACTION); | |
| GET_WIDGET (app->add_title, "add_text", GTK_ACTION); | |
| GET_WIDGET (app->add_test, "add_test", GTK_ACTION); | |
| GET_WIDGET (app->add_transition, "add_transition", GTK_ACTION); | |
| GET_WIDGET (app->delete, "delete", GTK_ACTION); | |
| GET_WIDGET (app->play, "play", GTK_ACTION); | |
| GET_WIDGET (app->stop, "stop", GTK_ACTION); | |
| GET_WIDGET (app->move_up, "move_up", GTK_ACTION); | |
| GET_WIDGET (app->move_down, "move_down", GTK_ACTION); | |
| GET_WIDGET (app->seconds, "seconds", GTK_ENTRY); | |
| GET_WIDGET (app->generic_duration, "generic_duration", GTK_WIDGET); | |
| GET_WIDGET (app->background_type, "background_type", GTK_COMBO_BOX); | |
| GET_WIDGET (app->background_properties, "background_properties", GTK_WIDGET); | |
| GET_WIDGET (app->frequency, "frequency", GTK_SPIN_BUTTON); | |
| GET_WIDGET (app->volume, "volume", GTK_HSCALE); | |
| GET_WIDGET (app->audio_track_action, "audio_track", GTK_TOGGLE_ACTION); | |
| GET_WIDGET (app->video_track_action, "video_track", GTK_TOGGLE_ACTION); | |
| /* get text notifications */ | |
| g_signal_connect (app->text, "notify::text", | |
| G_CALLBACK (text_notify_text_changed_cb), app); | |
| g_signal_connect (app->seconds, "notify::text", | |
| G_CALLBACK (seconds_notify_text_changed_cb), app); | |
| /* we care when the tree selection changes */ | |
| if (!(app->selection = gtk_tree_view_get_selection (timeline))) | |
| goto fail; | |
| gtk_tree_selection_set_mode (app->selection, GTK_SELECTION_MULTIPLE); | |
| g_signal_connect (app->selection, "changed", | |
| G_CALLBACK (app_selection_changed_cb), app); | |
| /* create the model for the treeview */ | |
| if (!(app->model = | |
| gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_OBJECT))) | |
| goto fail; | |
| gtk_tree_view_set_model (timeline, GTK_TREE_MODEL (app->model)); | |
| /* register custom cell data function */ | |
| gtk_tree_view_column_set_cell_data_func (duration_col, duration_renderer, | |
| duration_cell_func, NULL, NULL); | |
| /* initialize combo boxes */ | |
| if (!(backgrounds = get_video_patterns ())) | |
| goto fail; | |
| if (!(background_type_renderer = gtk_cell_renderer_text_new ())) | |
| goto fail; | |
| gtk_combo_box_set_model (app->background_type, (GtkTreeModel *) | |
| backgrounds); | |
| gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (app->background_type), | |
| background_type_renderer, FALSE); | |
| gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (app->background_type), | |
| background_type_renderer, "text", 0); | |
| g_signal_connect (app->timeline, "layer-added", G_CALLBACK | |
| (layer_added_cb), app); | |
| g_signal_connect (app->timeline, "track-added", G_CALLBACK | |
| (track_added_cb), app); | |
| g_signal_connect (app->timeline, "track-removed", G_CALLBACK | |
| (track_removed_cb), app); | |
| /* register callbacks on GES objects */ | |
| bus = gst_pipeline_get_bus (GST_PIPELINE (app->pipeline)); | |
| gst_bus_add_signal_watch (bus); | |
| g_signal_connect (bus, "message", G_CALLBACK (bus_message_cb), app); | |
| /* success */ | |
| gtk_builder_connect_signals (builder, app); | |
| gst_object_unref (G_OBJECT (builder)); | |
| return TRUE; | |
| fail: | |
| gst_object_unref (G_OBJECT (builder)); | |
| return FALSE; | |
| } | |
| #undef GET_WIDGET | |
| /* application methods ******************************************************/ | |
| static void selection_foreach (GtkTreeModel * model, GtkTreePath * path, | |
| GtkTreeIter * iter, gpointer user); | |
| static void | |
| app_toggle_playpause (App * app) | |
| { | |
| if (app->state != GST_STATE_PLAYING) { | |
| gst_element_set_state (GST_ELEMENT (app->pipeline), GST_STATE_PLAYING); | |
| } else { | |
| gst_element_set_state (GST_ELEMENT (app->pipeline), GST_STATE_PAUSED); | |
| } | |
| } | |
| static void | |
| app_stop_playback (App * app) | |
| { | |
| if ((app->state != GST_STATE_NULL) && (app->state != GST_STATE_READY)) { | |
| gst_element_set_state (GST_ELEMENT (app->pipeline), GST_STATE_READY); | |
| } | |
| } | |
| typedef struct | |
| { | |
| GList *objects; | |
| guint n; | |
| } select_info; | |
| static void | |
| app_update_selection (App * app) | |
| { | |
| GList *cur; | |
| GType type; | |
| select_info info = { NULL, 0 }; | |
| /* clear old selection */ | |
| for (cur = app->selected_objects; cur; cur = cur->next) { | |
| disconnect_from_object (cur->data, app); | |
| gst_object_unref (cur->data); | |
| cur->data = NULL; | |
| } | |
| g_list_free (app->selected_objects); | |
| app->selected_objects = NULL; | |
| app->n_selected = 0; | |
| /* get new selection */ | |
| gtk_tree_selection_selected_foreach (GTK_TREE_SELECTION (app->selection), | |
| selection_foreach, &info); | |
| app->selected_objects = info.objects; | |
| app->n_selected = info.n; | |
| type = G_TYPE_NONE; | |
| if (app->selected_objects) { | |
| type = G_TYPE_FROM_INSTANCE (app->selected_objects->data); | |
| for (cur = app->selected_objects; cur; cur = cur->next) { | |
| if (type != G_TYPE_FROM_INSTANCE (cur->data)) { | |
| type = G_TYPE_NONE; | |
| break; | |
| } | |
| } | |
| } | |
| if (type != G_TYPE_NONE) { | |
| for (cur = app->selected_objects; cur; cur = cur->next) { | |
| connect_to_object (cur->data, app); | |
| } | |
| } | |
| app->selected_type = type; | |
| app_update_first_last_selected (app); | |
| } | |
| static void | |
| selection_foreach (GtkTreeModel * model, GtkTreePath * path, GtkTreeIter | |
| * iter, gpointer user) | |
| { | |
| select_info *info = (select_info *) user; | |
| GESClip *clip; | |
| gtk_tree_model_get (model, iter, 2, &clip, -1); | |
| info->objects = g_list_append (info->objects, clip); | |
| info->n++; | |
| return; | |
| } | |
| static GList * | |
| app_get_selected_objects (App * app) | |
| { | |
| return g_list_copy (app->selected_objects); | |
| } | |
| static void | |
| app_delete_objects (App * app, GList * objects) | |
| { | |
| GList *cur; | |
| for (cur = objects; cur; cur = cur->next) { | |
| ges_layer_remove_clip (app->layer, GES_CLIP (cur->data)); | |
| cur->data = NULL; | |
| } | |
| g_list_free (objects); | |
| } | |
| /* the following two methods assume exactly one clip is selected and that the | |
| * requested action is valid */ | |
| static void | |
| app_move_selected_up (App * app) | |
| { | |
| GST_FIXME ("This function is not implement, please implement it :)"); | |
| } | |
| static void | |
| app_add_effect_on_selected_clips (App * app, const gchar * bin_desc) | |
| { | |
| GList *objects, *tmp; | |
| GESTrackElement *effect = NULL; | |
| /* No crash if the video is playing */ | |
| gst_element_set_state (GST_ELEMENT (app->pipeline), GST_STATE_PAUSED); | |
| objects = ges_layer_get_clips (app->layer); | |
| for (tmp = objects; tmp; tmp = tmp->next) { | |
| effect = GES_TRACK_ELEMENT (ges_effect_new (bin_desc)); | |
| ges_container_add (GES_CONTAINER (tmp->data), | |
| GES_TIMELINE_ELEMENT (effect)); | |
| gst_object_unref (tmp->data); | |
| } | |
| } | |
| gboolean | |
| add_effect_dlg_delete_event_cb (GtkWidget * widget, GdkEvent * event, | |
| gpointer * app) | |
| { | |
| gtk_widget_hide (((App *) app)->add_effect_dlg); | |
| return TRUE; | |
| } | |
| void | |
| on_cancel_add_effect_cb (GtkButton * button, App * app) | |
| { | |
| gtk_widget_hide (app->add_effect_dlg); | |
| } | |
| void | |
| on_apply_effect_cb (GtkButton * button, App * app) | |
| { | |
| const gchar *effect; | |
| effect = gtk_entry_get_text (GTK_ENTRY (app->video_effect_entry)); | |
| if (g_strcmp0 (effect, "")) | |
| app_add_effect_on_selected_clips (app, effect); | |
| gtk_entry_set_text (GTK_ENTRY (app->video_effect_entry), ""); | |
| effect = gtk_entry_get_text (GTK_ENTRY (app->audio_effect_entry)); | |
| if (g_strcmp0 (effect, "")) | |
| app_add_effect_on_selected_clips (app, effect); | |
| gtk_entry_set_text (GTK_ENTRY (app->audio_effect_entry), ""); | |
| gtk_widget_hide (app->add_effect_dlg); | |
| } | |
| static void | |
| app_move_selected_down (App * app) | |
| { | |
| GST_FIXME ("This function is not implement, please implement it :)"); | |
| } | |
| static void | |
| app_add_file (App * app, gchar * uri) | |
| { | |
| GESClip *clip; | |
| GST_DEBUG ("adding file %s", uri); | |
| clip = GES_CLIP (ges_uri_clip_new (uri)); | |
| ges_timeline_element_set_start (GES_TIMELINE_ELEMENT (clip), | |
| ges_layer_get_duration (app->layer)); | |
| ges_layer_add_clip (app->layer, clip); | |
| } | |
| static void | |
| app_launch_project (App * app, gchar * uri) | |
| { | |
| GESTimeline *timeline; | |
| GMainLoop *mainloop; | |
| GESPipeline *pipeline; | |
| GstBus *bus; | |
| GESProject *project; | |
| uri = g_strsplit (uri, "//", 2)[1]; | |
| printf ("we will launch this uri : %s\n", uri); | |
| project = ges_project_new (uri); | |
| timeline = GES_TIMELINE (ges_asset_extract (GES_ASSET (project), NULL)); | |
| pipeline = ges_pipeline_new (); | |
| bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline)); | |
| mainloop = g_main_loop_new (NULL, FALSE); | |
| ges_pipeline_set_timeline (pipeline, timeline); | |
| ges_pipeline_set_mode (pipeline, GES_PIPELINE_MODE_PREVIEW_VIDEO); | |
| gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING); | |
| gst_bus_add_signal_watch (bus); | |
| g_signal_connect (bus, "message", G_CALLBACK (project_bus_message_cb), | |
| mainloop); | |
| g_main_loop_run (mainloop); | |
| g_object_unref (project); | |
| } | |
| static void | |
| app_add_title (App * app) | |
| { | |
| GESClip *clip; | |
| GST_DEBUG ("adding title"); | |
| clip = GES_CLIP (ges_title_clip_new ()); | |
| g_object_set (G_OBJECT (clip), "duration", GST_SECOND, | |
| "start", ges_layer_get_duration (app->layer), NULL); | |
| ges_layer_add_clip (app->layer, clip); | |
| } | |
| static void | |
| app_add_test (App * app) | |
| { | |
| GESClip *clip; | |
| GST_DEBUG ("adding test"); | |
| clip = GES_CLIP (ges_test_clip_new ()); | |
| g_object_set (G_OBJECT (clip), "duration", GST_SECOND, | |
| "start", ges_layer_get_duration (app->layer), NULL); | |
| ges_layer_add_clip (app->layer, clip); | |
| } | |
| static void | |
| app_add_transition (App * app) | |
| { | |
| GST_FIXME ("This function is not implement, please implement it :)"); | |
| } | |
| static void | |
| app_save_to_uri (App * app, gchar * uri) | |
| { | |
| ges_timeline_save_to_uri (app->timeline, uri, NULL, FALSE, NULL); | |
| } | |
| static void | |
| app_add_audio_track (App * app) | |
| { | |
| if (app->audio_tracks) | |
| return; | |
| app->audio_track = GES_TRACK (ges_audio_track_new ()); | |
| ges_timeline_add_track (app->timeline, app->audio_track); | |
| } | |
| static void | |
| app_remove_audio_track (App * app) | |
| { | |
| if (!app->audio_tracks) | |
| return; | |
| ges_timeline_remove_track (app->timeline, app->audio_track); | |
| app->audio_track = NULL; | |
| } | |
| static void | |
| app_add_video_track (App * app) | |
| { | |
| if (app->video_tracks) | |
| return; | |
| app->video_track = GES_TRACK (ges_video_track_new ()); | |
| ges_timeline_add_track (app->timeline, app->video_track); | |
| } | |
| static void | |
| app_remove_video_track (App * app) | |
| { | |
| if (!app->video_tracks) | |
| return; | |
| ges_timeline_remove_track (app->timeline, app->video_track); | |
| app->video_track = NULL; | |
| } | |
| static void | |
| app_dispose (App * app) | |
| { | |
| if (app) { | |
| if (app->pipeline) { | |
| gst_element_set_state (GST_ELEMENT (app->pipeline), GST_STATE_NULL); | |
| gst_object_unref (app->pipeline); | |
| } | |
| g_free (app); | |
| } | |
| n_instances--; | |
| if (n_instances == 0) { | |
| gtk_main_quit (); | |
| } | |
| } | |
| static App * | |
| app_init (void) | |
| { | |
| App *ret; | |
| ret = g_new0 (App, 1); | |
| n_instances++; | |
| ret->selected_type = G_TYPE_NONE; | |
| if (!(ret->timeline = ges_timeline_new ())) | |
| goto fail; | |
| if (!(ret->pipeline = ges_pipeline_new ())) | |
| goto fail; | |
| if (!ges_pipeline_set_timeline (ret->pipeline, ret->timeline)) | |
| goto fail; | |
| if (!(create_ui (ret))) | |
| goto fail; | |
| return ret; | |
| fail: | |
| app_dispose (ret); | |
| return NULL; | |
| } | |
| static App * | |
| app_new (void) | |
| { | |
| App *ret; | |
| GESTrack *a = NULL, *v = NULL; | |
| ret = app_init (); | |
| /* add base audio and video track */ | |
| if (!(a = GES_TRACK (ges_audio_track_new ()))) | |
| goto fail; | |
| if (!(ges_timeline_add_track (ret->timeline, a))) | |
| goto fail; | |
| if (!(v = GES_TRACK (ges_video_track_new ()))) | |
| goto fail; | |
| if (!(ges_timeline_add_track (ret->timeline, v))) | |
| goto fail; | |
| if (!(ret->layer = ges_layer_new ())) | |
| goto fail; | |
| if (!(ges_timeline_add_layer (ret->timeline, ret->layer))) | |
| goto fail; | |
| ret->audio_track = a; | |
| ret->video_track = v; | |
| return ret; | |
| fail: | |
| if (a) | |
| gst_object_unref (a); | |
| if (v) | |
| gst_object_unref (v); | |
| app_dispose (ret); | |
| return NULL; | |
| } | |
| static gboolean | |
| load_file_async (App * app) | |
| { | |
| ges_timeline_load_from_uri (app->timeline, app->pending_uri, NULL); | |
| g_free (app->pending_uri); | |
| app->pending_uri = NULL; | |
| return FALSE; | |
| } | |
| static gboolean | |
| app_new_from_uri (gchar * uri) | |
| { | |
| App *ret; | |
| ret = app_init (); | |
| ret->pending_uri = g_strdup (uri); | |
| g_idle_add ((GSourceFunc) load_file_async, ret); | |
| return FALSE; | |
| } | |
| /* UI callbacks ************************************************************/ | |
| gboolean | |
| window_delete_event_cb (GtkWidget * window, GdkEvent * event, App * app) | |
| { | |
| app_dispose (app); | |
| return FALSE; | |
| } | |
| void | |
| new_activate_cb (GtkMenuItem * item, App * app) | |
| { | |
| app_new (); | |
| } | |
| void | |
| launch_project_activate_cb (GtkMenuItem * item, App * app) | |
| { | |
| GtkFileChooserDialog *dlg; | |
| GtkFileFilter *filter; | |
| GST_DEBUG ("add file signal handler"); | |
| filter = gtk_file_filter_new (); | |
| gtk_file_filter_set_name (filter, "pitivi projects"); | |
| gtk_file_filter_add_pattern (filter, "*.xptv"); | |
| dlg = (GtkFileChooserDialog *) | |
| gtk_file_chooser_dialog_new ("Preview Project...", | |
| GTK_WINDOW (app->main_window), | |
| GTK_FILE_CHOOSER_ACTION_OPEN, | |
| GTK_STOCK_CANCEL, | |
| GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); | |
| gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dlg), filter); | |
| g_object_set (G_OBJECT (dlg), "select-multiple", FALSE, NULL); | |
| if (gtk_dialog_run ((GtkDialog *) dlg) == GTK_RESPONSE_OK) { | |
| gchar *uri; | |
| uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dlg)); | |
| gtk_widget_destroy ((GtkWidget *) dlg); | |
| app_launch_project (app, uri); | |
| } | |
| } | |
| void | |
| open_activate_cb (GtkMenuItem * item, App * app) | |
| { | |
| GtkFileChooserDialog *dlg; | |
| GST_DEBUG ("add file signal handler"); | |
| dlg = (GtkFileChooserDialog *) gtk_file_chooser_dialog_new ("Open Project...", | |
| GTK_WINDOW (app->main_window), | |
| GTK_FILE_CHOOSER_ACTION_OPEN, | |
| GTK_STOCK_CANCEL, | |
| GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); | |
| g_object_set (G_OBJECT (dlg), "select-multiple", FALSE, NULL); | |
| if (gtk_dialog_run ((GtkDialog *) dlg) == GTK_RESPONSE_OK) { | |
| gchar *uri; | |
| uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dlg)); | |
| app_new_from_uri (uri); | |
| g_free (uri); | |
| } | |
| gtk_widget_destroy ((GtkWidget *) dlg); | |
| } | |
| void | |
| save_as_activate_cb (GtkMenuItem * item, App * app) | |
| { | |
| GtkFileChooserDialog *dlg; | |
| GST_DEBUG ("save as signal handler"); | |
| dlg = (GtkFileChooserDialog *) | |
| gtk_file_chooser_dialog_new ("Save project as...", | |
| GTK_WINDOW (app->main_window), GTK_FILE_CHOOSER_ACTION_SAVE, | |
| GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, | |
| NULL); | |
| g_object_set (G_OBJECT (dlg), "select-multiple", FALSE, NULL); | |
| if (gtk_dialog_run ((GtkDialog *) dlg) == GTK_RESPONSE_OK) { | |
| gchar *uri; | |
| uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dlg)); | |
| app_save_to_uri (app, uri); | |
| g_free (uri); | |
| } | |
| gtk_widget_destroy ((GtkWidget *) dlg); | |
| } | |
| void | |
| quit_item_activate_cb (GtkMenuItem * item, App * app) | |
| { | |
| gtk_main_quit (); | |
| } | |
| void | |
| delete_activate_cb (GtkAction * item, App * app) | |
| { | |
| /* get a gslist of selected track elements */ | |
| GList *objects = NULL; | |
| objects = app_get_selected_objects (app); | |
| app_delete_objects (app, objects); | |
| } | |
| void | |
| add_effect_activate_cb (GtkAction * item, App * app) | |
| { | |
| gtk_widget_show_all (app->add_effect_dlg); | |
| } | |
| void | |
| add_file_activate_cb (GtkAction * item, App * app) | |
| { | |
| GtkFileChooserDialog *dlg; | |
| GST_DEBUG ("add file signal handler"); | |
| dlg = (GtkFileChooserDialog *) gtk_file_chooser_dialog_new ("Add File...", | |
| GTK_WINDOW (app->main_window), | |
| GTK_FILE_CHOOSER_ACTION_OPEN, | |
| GTK_STOCK_CANCEL, | |
| GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); | |
| g_object_set (G_OBJECT (dlg), "select-multiple", TRUE, NULL); | |
| if (gtk_dialog_run ((GtkDialog *) dlg) == GTK_RESPONSE_OK) { | |
| GSList *uris; | |
| GSList *cur; | |
| uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (dlg)); | |
| for (cur = uris; cur; cur = cur->next) | |
| app_add_file (app, cur->data); | |
| g_slist_free (uris); | |
| } | |
| gtk_widget_destroy ((GtkWidget *) dlg); | |
| } | |
| void | |
| add_text_activate_cb (GtkAction * item, App * app) | |
| { | |
| app_add_title (app); | |
| } | |
| void | |
| add_test_activate_cb (GtkAction * item, App * app) | |
| { | |
| app_add_test (app); | |
| } | |
| void | |
| add_transition_activate_cb (GtkAction * item, App * app) | |
| { | |
| app_add_transition (app); | |
| } | |
| void | |
| play_activate_cb (GtkAction * item, App * app) | |
| { | |
| app_toggle_playpause (app); | |
| } | |
| void | |
| stop_activate_cb (GtkAction * item, App * app) | |
| { | |
| app_stop_playback (app); | |
| } | |
| void | |
| move_up_activate_cb (GtkAction * item, App * app) | |
| { | |
| app_move_selected_up (app); | |
| } | |
| void | |
| move_down_activate_cb (GtkAction * item, App * app) | |
| { | |
| app_move_selected_down (app); | |
| } | |
| void | |
| audio_track_activate_cb (GtkToggleAction * item, App * app) | |
| { | |
| if (gtk_toggle_action_get_active (item)) { | |
| app_add_audio_track (app); | |
| } else { | |
| app_remove_audio_track (app); | |
| } | |
| } | |
| void | |
| video_track_activate_cb (GtkToggleAction * item, App * app) | |
| { | |
| if (gtk_toggle_action_get_active (item)) { | |
| app_add_video_track (app); | |
| } else { | |
| app_remove_video_track (app); | |
| } | |
| } | |
| void | |
| app_selection_changed_cb (GtkTreeSelection * selection, App * app) | |
| { | |
| app_update_selection (app); | |
| update_delete_sensitivity (app); | |
| update_effect_sensitivity (app); | |
| update_add_transition_sensitivity (app); | |
| update_move_up_down_sensitivity (app); | |
| gtk_widget_set_visible (app->properties, app->n_selected > 0); | |
| gtk_widget_set_visible (app->filesource_properties, | |
| app->selected_type == GES_TYPE_URI_CLIP); | |
| gtk_widget_set_visible (app->text_properties, | |
| app->selected_type == GES_TYPE_TITLE_CLIP); | |
| gtk_widget_set_visible (app->generic_duration, | |
| app->selected_type != G_TYPE_NONE && | |
| app->selected_type != G_TYPE_INVALID); | |
| gtk_widget_set_visible (app->background_properties, | |
| app->selected_type == GES_TYPE_TEST_CLIP); | |
| } | |
| gboolean | |
| duration_scale_change_value_cb (GtkRange * range, GtkScrollType unused, | |
| gdouble value, App * app) | |
| { | |
| GList *i; | |
| for (i = app->selected_objects; i; i = i->next) { | |
| guint64 duration, maxduration; | |
| maxduration = GES_TIMELINE_ELEMENT_MAX_DURATION (i->data); | |
| duration = (value < maxduration ? (value > 0 ? value : 0) : maxduration); | |
| g_object_set (G_OBJECT (i->data), "duration", (guint64) duration, NULL); | |
| } | |
| return TRUE; | |
| } | |
| gboolean | |
| in_point_scale_change_value_cb (GtkRange * range, GtkScrollType unused, | |
| gdouble value, App * app) | |
| { | |
| GList *i; | |
| for (i = app->selected_objects; i; i = i->next) { | |
| guint64 in_point, maxduration; | |
| maxduration = GES_TIMELINE_ELEMENT_MAX_DURATION (i->data) - | |
| GES_TIMELINE_ELEMENT_DURATION (i->data); | |
| in_point = (value < maxduration ? (value > 0 ? value : 0) : maxduration); | |
| g_object_set (G_OBJECT (i->data), "in-point", (guint64) in_point, NULL); | |
| } | |
| return TRUE; | |
| } | |
| void | |
| halign_changed_cb (GtkComboBox * widget, App * app) | |
| { | |
| GList *tmp; | |
| int active; | |
| if (app->ignore_input) | |
| return; | |
| active = gtk_combo_box_get_active (app->halign); | |
| for (tmp = app->selected_objects; tmp; tmp = tmp->next) { | |
| g_object_set (G_OBJECT (tmp->data), "halignment", active, NULL); | |
| } | |
| } | |
| void | |
| valign_changed_cb (GtkComboBox * widget, App * app) | |
| { | |
| GList *tmp; | |
| int active; | |
| if (app->ignore_input) | |
| return; | |
| active = gtk_combo_box_get_active (app->valign); | |
| for (tmp = app->selected_objects; tmp; tmp = tmp->next) { | |
| g_object_set (G_OBJECT (tmp->data), "valignment", active, NULL); | |
| } | |
| } | |
| void | |
| background_type_changed_cb (GtkComboBox * widget, App * app) | |
| { | |
| GList *tmp; | |
| gint p; | |
| if (app->ignore_input) | |
| return; | |
| p = gtk_combo_box_get_active (widget); | |
| for (tmp = app->selected_objects; tmp; tmp = tmp->next) { | |
| g_object_set (G_OBJECT (tmp->data), "vpattern", (gint) p, NULL); | |
| } | |
| } | |
| void | |
| frequency_value_changed_cb (GtkSpinButton * widget, App * app) | |
| { | |
| GList *tmp; | |
| gdouble value; | |
| if (app->ignore_input) | |
| return; | |
| value = gtk_spin_button_get_value (widget); | |
| for (tmp = app->selected_objects; tmp; tmp = tmp->next) { | |
| g_object_set (G_OBJECT (tmp->data), "freq", (gdouble) value, NULL); | |
| } | |
| } | |
| gboolean | |
| volume_change_value_cb (GtkRange * widget, GtkScrollType unused, gdouble | |
| value, App * app) | |
| { | |
| GList *tmp; | |
| value = value >= 0 ? (value <= 2.0 ? value : 2.0) : 0; | |
| for (tmp = app->selected_objects; tmp; tmp = tmp->next) { | |
| g_object_set (G_OBJECT (tmp->data), "volume", (gdouble) value, NULL); | |
| } | |
| return TRUE; | |
| } | |
| /* main *********************************************************************/ | |
| int | |
| main (int argc, char *argv[]) | |
| { | |
| App *app; | |
| /* intialize GStreamer and GES */ | |
| gst_init (&argc, &argv); | |
| ges_init (); | |
| /* initialize UI */ | |
| gtk_init (&argc, &argv); | |
| if ((app = app_new ())) { | |
| gtk_main (); | |
| } | |
| return 0; | |
| } |