int
clip_GTK_TREESELECTIONGETSELECTED(ClipMachine * cm)
{
C_object *ctreesel = _fetch_co_arg(cm);
C_object *cmodel = _fetch_cobject(cm, _clip_par(cm, 2));
ClipVar *cviter = _clip_par(cm, 3);
C_object *citer;
GtkTreeModel *model;
gboolean ret;
CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));
memset(Iter, 0, sizeof(Iter));
if (cmodel)
{
model = GTK_TREE_MODEL(cmodel->object);
ret = gtk_tree_selection_get_selected(GTK_TREE_SELECTION(ctreesel->object),
&model, Iter);
}
else
ret = gtk_tree_selection_get_selected(GTK_TREE_SELECTION(ctreesel->object),
NULL, Iter);
if (ret && Iter)
{
citer = _list_get_cobject(cm,Iter);
if (!citer) citer = _register_object(cm,Iter,GTK_TYPE_TREE_ITER, cviter, NULL);
if (citer) _clip_mclone(cm, cviter,&citer->obj);
}
_clip_retl(cm, ret);
return 0;
err:
return 1;
}
static void
on_view_selection_changed (GtkTreeSelection *selection, SeahorseKeyserverResults *self)
{
g_return_if_fail (SEAHORSE_IS_KEYSERVER_RESULTS (self));
g_return_if_fail (GTK_IS_TREE_SELECTION (selection));
g_idle_add ((GSourceFunc)fire_selection_changed, self);
}
static void
thunar_uca_chooser_selection_changed (ThunarUcaChooser *uca_chooser,
GtkTreeSelection *selection)
{
GtkTreeModel *model;
GtkTreePath *path = NULL;
GtkTreeIter iter;
gboolean selected;
g_return_if_fail (THUNAR_UCA_IS_CHOOSER (uca_chooser));
g_return_if_fail (GTK_IS_TREE_SELECTION (selection));
/* check if we have currently selected an item */
selected = gtk_tree_selection_get_selected (selection, &model, &iter);
if (G_LIKELY (selected))
{
/* determine the path for the selected iter */
path = gtk_tree_model_get_path (model, &iter);
}
/* change sensitivity of "Edit" and "Delete" appropritately */
gtk_widget_set_sensitive (uca_chooser->edit_button, selected);
gtk_widget_set_sensitive (uca_chooser->delete_button, selected);
/* change sensitivity of "Move Up" and "Move Down" appropritately */
gtk_widget_set_sensitive (uca_chooser->up_button, selected && gtk_tree_path_get_indices (path)[0] > 0);
gtk_widget_set_sensitive (uca_chooser->down_button, selected && gtk_tree_path_get_indices (path)[0] < gtk_tree_model_iter_n_children (model, NULL) - 1);
/* release path (if any) */
if (G_LIKELY (path != NULL))
gtk_tree_path_free (path);
}
static void
gnc_plugin_page_owner_tree_selection_changed_cb (GtkTreeSelection *selection,
GncPluginPageOwnerTree *page)
{
GtkActionGroup *action_group;
GtkTreeView *view;
GncOwner *owner = NULL;
gboolean sensitive;
gboolean is_readwrite = !qof_book_is_readonly(gnc_get_current_book());
g_return_if_fail(GNC_IS_PLUGIN_PAGE_OWNER_TREE(page));
if (!selection)
{
sensitive = FALSE;
}
else
{
g_return_if_fail(GTK_IS_TREE_SELECTION(selection));
view = gtk_tree_selection_get_tree_view (selection);
owner = gnc_tree_view_owner_get_selected_owner (GNC_TREE_VIEW_OWNER(view));
sensitive = (owner != NULL);
}
action_group = gnc_plugin_page_get_action_group(GNC_PLUGIN_PAGE(page));
gnc_plugin_update_actions (action_group, actions_requiring_owner_always,
"sensitive", sensitive);
gnc_plugin_update_actions (action_group, actions_requiring_owner_rw,
"sensitive", sensitive && is_readwrite);
g_signal_emit (page, plugin_page_signals[OWNER_SELECTED], 0, owner);
}
static void
e_webdav_discover_content_selection_changed_cb (GtkTreeSelection *selection,
GtkDialog *dialog)
{
g_return_if_fail (GTK_IS_TREE_SELECTION (selection));
g_return_if_fail (GTK_IS_DIALOG (dialog));
gtk_dialog_set_response_sensitive (dialog, GTK_RESPONSE_ACCEPT,
gtk_tree_selection_count_selected_rows (selection) > 0);
}
int
clip_GTK_TREESELECTIONGETSELECTEDROWS(ClipMachine * ClipMachineMemory)
{
C_object *ctreesel = _fetch_co_arg(ClipMachineMemory);
ClipVar *mod = ARGPTR(ClipMachineMemory, 2);
GtkTreeModel *model;
C_object *cmodel;
GList *list;
long l;
ClipVar *ret = RETPTR(ClipMachineMemory);
CHECKOPT2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(ctreesel, GTK_IS_TREE_SELECTION(ctreesel->object));
list = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(ctreesel->object), &model);
l = g_list_length(list);
_clip_array(ClipMachineMemory, ret, 1, &l);
for (l = 0; list; list = g_list_next(list), l++)
{
C_object *cpath;
GtkTreePath *path;
path = GTK_TREE_PATH(list->data);
cpath = _list_get_cobject(ClipMachineMemory, path);
if (!cpath)
cpath = _register_object(ClipMachineMemory, path, GTK_TYPE_TREE_PATH, NULL, NULL);
if (cpath)
_clip_aset(ClipMachineMemory, ret, &cpath->obj, 1, &l);
}
if (model)
{
cmodel = _list_get_cobject(ClipMachineMemory, model);
if (!cmodel)
cmodel = _register_object(ClipMachineMemory, model, GTK_TYPE_TREE_MODEL, NULL, NULL);
if (cmodel)
_clip_mclone(ClipMachineMemory, mod, &cmodel->obj);
}
g_list_foreach(list, (GFunc) (gtk_tree_path_free), NULL);
g_list_free(list);
return 0;
err:
return 1;
}
int
clip_GTK_TREESELECTIONCOUNTSELECTEDROWS(ClipMachine * cm)
{
C_object *ctreesel = _fetch_co_arg(cm);
CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));
_clip_retni(cm, gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(ctreesel->object)));
return 0;
err:
return 1;
}
int
clip_GTK_TREESELECTIONCOUNTSELECTEDROWS(ClipMachine * ClipMachineMemory)
{
C_object *ctreesel = _fetch_co_arg(ClipMachineMemory);
CHECKOPT2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(ctreesel, GTK_IS_TREE_SELECTION(ctreesel->object));
_clip_retni(ClipMachineMemory, gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(ctreesel->object)));
return 0;
err:
return 1;
}
int
clip_GTK_TREESELECTIONSETMODE(ClipMachine * cm)
{
C_object *ctreesel = _fetch_co_arg(cm);
GtkSelectionMode mode = _clip_parni(cm, 2);
CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));
CHECKARG(2, NUMERIC_t);
gtk_tree_selection_set_mode(GTK_TREE_SELECTION(ctreesel->object), mode);
return 0;
err:
return 1;
}
static void
book_tree_selection_changed_cb (GtkTreeSelection *selection, DhBookTree *tree)
{
GtkTreeIter iter;
DhLink *link;
g_return_if_fail (GTK_IS_TREE_SELECTION (selection));
g_return_if_fail (DH_IS_BOOK_TREE (tree));
if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
gtk_tree_model_get (GTK_TREE_MODEL (tree->priv->store), &iter, COL_LINK, &link, -1);
d(g_print ("emiting '%s'\n", link->uri));
g_signal_emit (tree, signals[LINK_SELECTED], 0, link);
}
}
int
clip_GTK_TREESELECTIONSELECTRANGE(ClipMachine * cm)
{
C_object *ctreesel = _fetch_co_arg(cm);
C_object *cpath1 = _fetch_cobject(cm, _clip_spar(cm, 2));
C_object *cpath2 = _fetch_cobject(cm, _clip_spar(cm, 3));
CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));
CHECKCOBJ(cpath1,GTK_IS_TREE_PATH(cpath1->object)); CHECKCOBJ(cpath2,GTK_IS_TREE_PATH(cpath2->object));
gtk_tree_selection_select_range(GTK_TREE_SELECTION(ctreesel->object),
GTK_TREE_PATH(cpath1->object), GTK_TREE_PATH(cpath2->object));
return 0;
err:
return 1;
}
int
clip_GTK_TREESELECTIONGETMODE(ClipMachine * ClipMachineMemory)
{
C_object *ctreesel = _fetch_co_arg(ClipMachineMemory);
GtkSelectionMode mode;
CHECKOPT2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(ctreesel, GTK_IS_TREE_SELECTION(ctreesel->object));
mode = gtk_tree_selection_get_mode(GTK_TREE_SELECTION(ctreesel->object));
_clip_retni(ClipMachineMemory, mode);
return 0;
err:
return 1;
}
int
clip_GTK_TREESELECTIONGETTREEVIEW(ClipMachine * cm)
{
C_object *ctreesel = _fetch_co_arg(cm);
GtkTreeView *view;
C_widget *cwid;
CHECKOPT2(1, MAP_t, NUMERIC_t); CHECKCOBJ(ctreesel,GTK_IS_TREE_SELECTION(ctreesel->object));
view = gtk_tree_selection_get_tree_view(GTK_TREE_SELECTION(ctreesel->object));
if (!view) goto err;
cwid = _register_widget(cm, GTK_WIDGET(view), NULL);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
int
clip_GTK_TREESELECTIONSELECTRANGE(ClipMachine * ClipMachineMemory)
{
C_object *ctreesel = _fetch_co_arg(ClipMachineMemory);
C_object *cpath1 = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
C_object *cpath2 = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3));
CHECKOPT2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(ctreesel, GTK_IS_TREE_SELECTION(ctreesel->object));
CHECKCOBJ(cpath1, GTK_IS_TREE_PATH(cpath1->object));
CHECKCOBJ(cpath2, GTK_IS_TREE_PATH(cpath2->object));
gtk_tree_selection_select_range(GTK_TREE_SELECTION(ctreesel->object),
GTK_TREE_PATH(cpath1->object), GTK_TREE_PATH(cpath2->object));
return 0;
err:
return 1;
}
static void
thunar_uca_chooser_exchange (ThunarUcaChooser *uca_chooser,
GtkTreeSelection *selection,
GtkTreeModel *model,
GtkTreeIter *iter_a,
GtkTreeIter *iter_b)
{
g_return_if_fail (THUNAR_UCA_IS_CHOOSER (uca_chooser));
g_return_if_fail (GTK_IS_TREE_SELECTION (selection));
g_return_if_fail (GTK_IS_TREE_MODEL (model));
g_return_if_fail (iter_a != NULL);
g_return_if_fail (iter_b != NULL);
/* perform the move */
thunar_uca_model_exchange (THUNAR_UCA_MODEL (model), iter_a, iter_b);
/* tell the chooser that the selection may have changed */
thunar_uca_chooser_selection_changed (uca_chooser, selection);
/* sync the model to persistent storage */
thunar_uca_chooser_save (uca_chooser, THUNAR_UCA_MODEL (model));
}
/*******************************************************
* csv_export_account_changed_cb
*
* update account list after selection changed
*******************************************************/
static void
csv_export_account_changed_cb (GtkTreeSelection *selection,
gpointer user_data)
{
CsvExportInfo *info = user_data;
GtkAssistant *assistant = GTK_ASSISTANT(info->window);
gint num = gtk_assistant_get_current_page (assistant);
GtkWidget *page = gtk_assistant_get_nth_page (assistant, num);
GncTreeViewAccount *view;
g_return_if_fail(GTK_IS_TREE_SELECTION(selection));
info->csva.num_accounts = update_accounts_tree (info);
/* Enable the Forward Assistant Button if we have accounts */
if (info->csva.num_accounts > 0)
gtk_assistant_set_page_complete (assistant, page, TRUE);
else
gtk_assistant_set_page_complete (assistant, page, FALSE);
view = GNC_TREE_VIEW_ACCOUNT(info->csva.account_treeview);
info->csva.account_list = gnc_tree_view_account_get_selected_accounts (view);
}
static void
update_preview (Browser *br)
{
LibraryPart *library_part;
gdouble new_x, new_y, x1, y1, x2, y2;
gdouble text_width;
gdouble width, height;
GooCanvasBounds bounds;
gdouble scale;
cairo_matrix_t transf, affine;
gchar *part_name;
char *description;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeSelection *selection;
// Get the current selected row
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (br->list));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (br->list));
if (!GTK_IS_TREE_SELECTION (selection)) return;
if (!gtk_tree_selection_get_selected (selection, NULL, &iter)) {
return;
}
gtk_tree_model_get (model, &iter, 0, &part_name, -1);
library_part = library_get_part (br->library, part_name);
// If there is already a preview part-item, destroy its group and create a
// new one.
if (br->preview != NULL) {
goo_canvas_item_remove (GOO_CANVAS_ITEM (br->preview));
}
br->preview = GOO_CANVAS_GROUP (goo_canvas_group_new (
goo_canvas_get_root_item (GOO_CANVAS (br->canvas)),
NULL));
goo_canvas_set_bounds (GOO_CANVAS (br->canvas), 0.0, 0.0, 250.0, 110.0);
g_object_get (br->preview,
"width", &width,
"height", &height,
NULL);
if (!library_part)
return;
part_item_create_canvas_items_for_preview (br->preview, library_part);
// Unconstraint the canvas width & height to adjust for the part description
g_object_set (br->preview,
"width", -1.0,
"height", -1.0,
NULL);
// Get the coordonates */
goo_canvas_item_get_bounds (GOO_CANVAS_ITEM (br->preview), &bounds);
x1 = bounds.x1;
x2 = bounds.x2;
y1 = bounds.y1;
y2 = bounds.y2;
// Translate in such a way that the canvas centre remains in (0, 0)
cairo_matrix_init_translate (&transf, -(x2 + x1) / 2.0f + PREVIEW_WIDTH / 2,
-(y2 + y1) / 2.0f + PREVIEW_HEIGHT / 2);
// Compute the scale of the widget
if ((x2 - x1 != 0) || (y2 - y1 != 0)) {
if ((x2 - x1) < (y2 - y1))
scale = 0.60f * PREVIEW_HEIGHT / (y2 - y1);
else
scale = 0.60f * PREVIEW_WIDTH / (x2 - x1);
}
else
scale = 5;
cairo_matrix_init_scale (&affine, scale, scale);
cairo_matrix_multiply (&transf, &transf, &affine);
// Apply the transformation
goo_canvas_item_set_transform (GOO_CANVAS_ITEM (br->preview), &transf);
// Compute the motion to centre the Preview widget
new_x = 100 + (PREVIEW_WIDTH - x1 - x2) / 2;
new_y = (PREVIEW_HEIGHT - y1 - y2) / 2 - 10;
// Apply the transformation
if (scale > 5.0) scale = 3.0;
goo_canvas_item_set_simple_transform (GOO_CANVAS_ITEM (br->preview),
new_x,
new_y,
scale,
0.0);
description = g_strdup (library_part->description);
wrap_string (description, 20);
g_object_set (br->description,
"text", description,
NULL);
g_free (description);
g_object_get (G_OBJECT (br->description),
"width", &text_width,
NULL);
goo_canvas_item_set_simple_transform (GOO_CANVAS_ITEM (br->description),
50.0,
-20.0,
1.0,
0.0);
g_free (part_name);
}
gint play_iter(GtkTreeIter * playiter, gint restart_second)
{
gchar *subtitle = NULL;
gchar *audiofile = NULL;
GtkTreePath *path;
gchar *uri = NULL;
gint count;
gint playlist;
gchar *title = NULL;
gchar *artist = NULL;
gchar *album = NULL;
gchar *audio_codec;
gchar *video_codec = NULL;
GtkAllocation alloc;
gchar *demuxer = NULL;
gboolean playable = TRUE;
gint width;
gint height;
gfloat length_value;
gint i;
gpointer pixbuf;
gchar *buffer = NULL;
gchar *message = NULL;
MetaData *metadata;
#ifdef GTK2_12_ENABLED
GtkRecentData *recent_data;
#ifdef GIO_ENABLED
GFile *file;
GFileInfo *file_info;
#endif
#endif
/*
if (!(gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) == MEDIA_STATE_UNKNOWN ||
gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) == MEDIA_STATE_QUIT)) {
while (gmtk_media_player_get_state(GMTK_MEDIA_PLAYER(media)) != MEDIA_STATE_UNKNOWN) {
gtk_main_iteration();
}
}
*/
if (gtk_list_store_iter_is_valid(playliststore, playiter)) {
gtk_tree_model_get(GTK_TREE_MODEL(playliststore), playiter, ITEM_COLUMN, &uri,
DESCRIPTION_COLUMN, &title, LENGTH_VALUE_COLUMN, &length_value,
ARTIST_COLUMN, &artist,
ALBUM_COLUMN, &album,
AUDIO_CODEC_COLUMN, &audio_codec,
VIDEO_CODEC_COLUMN, &video_codec,
VIDEO_WIDTH_COLUMN, &width,
VIDEO_HEIGHT_COLUMN, &height,
DEMUXER_COLUMN, &demuxer,
COVERART_COLUMN, &pixbuf,
SUBTITLE_COLUMN, &subtitle,
AUDIOFILE_COLUMN, &audiofile,
COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist, PLAYABLE_COLUMN, &playable, -1);
if (GTK_IS_TREE_SELECTION(selection)) {
path = gtk_tree_model_get_path(GTK_TREE_MODEL(playliststore), playiter);
if (path) {
gtk_tree_selection_select_path(selection, path);
if (GTK_IS_WIDGET(list))
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(list), path, NULL, FALSE, 0, 0);
buffer = gtk_tree_path_to_string(path);
g_free(buffer);
gtk_tree_path_free(path);
}
}
gtk_list_store_set(playliststore, playiter, COUNT_COLUMN, count + 1, -1);
} else {
if (verbose > 1)
printf("iter is invalid, nothing to play\n");
return 0;
}
if (verbose) {
printf("playing - %s\n", uri);
printf("is playlist %i\n", playlist);
}
gmtk_get_allocation(GTK_WIDGET(media), &alloc);
if (width == 0 || height == 0) {
alloc.width = 16;
alloc.height = 16;
} else {
alloc.width = width;
alloc.height = height;
}
//printf("setting window size to %i x %i\n", alloc.width, alloc.height);
gtk_widget_size_allocate(GTK_WIDGET(media), &alloc);
while (gtk_events_pending())
gtk_main_iteration();
/*
// wait for metadata to be available on this item
if (!streaming_media(uri) && !device_name(uri)) {
i = 0;
if (playable) {
while (demuxer == NULL && i < 50) {
g_free(title);
g_free(artist);
g_free(album);
g_free(audio_codec);
g_free(video_codec);
g_free(demuxer);
g_free(subtitle);
g_free(audiofile);
if (gtk_list_store_iter_is_valid(playliststore, playiter)) {
gtk_tree_model_get(GTK_TREE_MODEL(playliststore), playiter, LENGTH_VALUE_COLUMN,
&length_value, DESCRIPTION_COLUMN, &title, ARTIST_COLUMN,
&artist, ALBUM_COLUMN, &album, AUDIO_CODEC_COLUMN,
&audio_codec, VIDEO_CODEC_COLUMN, &video_codec,
VIDEO_WIDTH_COLUMN, &width, VIDEO_HEIGHT_COLUMN, &height,
DEMUXER_COLUMN, &demuxer, COVERART_COLUMN, &pixbuf,
SUBTITLE_COLUMN, &subtitle, AUDIOFILE_COLUMN, &audiofile,
COUNT_COLUMN, &count, PLAYLIST_COLUMN, &playlist,
PLAYABLE_COLUMN, &playable, -1);
if (!playable) {
if (verbose)
printf("%s is not marked as playable (%i)\n", uri, i);
play_next();
return 0;
}
} else {
if (verbose)
printf("Current iter is not valid\n");
return 1; // error condition
}
gtk_main_iteration();
i++;
if (demuxer == NULL)
g_usleep(10000);
}
} else {
if (verbose)
printf("%s is not marked as playable\n", uri);
play_next();
return 0;
}
}
*/
// reset audio meter
for (i = 0; i < METER_BARS; i++) {
buckets[i] = 0;
max_buckets[i] = 0;
}
gmtk_media_tracker_set_text(tracker, _("Playing"));
gmtk_media_tracker_set_position(tracker, (gfloat) restart_second);
gmtk_media_tracker_set_length(tracker, length_value);
message = g_strdup_printf("<small>\n");
if (title == NULL) {
title = g_filename_display_basename(uri);
}
buffer = g_markup_printf_escaped("\t<big><b>%s</b></big>\n", title);
message = g_strconcat(message, buffer, NULL);
g_free(buffer);
if (artist != NULL) {
buffer = g_markup_printf_escaped("\t<i>%s</i>\n", artist);
message = g_strconcat(message, buffer, NULL);
g_free(buffer);
}
if (album != NULL) {
buffer = g_markup_printf_escaped("\t%s\n", album);
message = g_strconcat(message, buffer, NULL);
g_free(buffer);
}
//buffer = g_markup_printf_escaped("\n\t%s\n", uri);
//message = g_strconcat(message, buffer, NULL);
//g_free(buffer);
message = g_strconcat(message, "</small>", NULL);
// probably not much cover art for random video files
if (pixbuf == NULL && video_codec == NULL && !streaming_media(uri) && control_id == 0 && !playlist) {
metadata = (MetaData *) g_new0(MetaData, 1);
metadata->uri = g_strdup(uri);
if (title != NULL)
metadata->title = g_strstrip(g_strdup(title));
if (artist != NULL)
metadata->artist = g_strstrip(g_strdup(artist));
if (album != NULL)
metadata->album = g_strstrip(g_strdup(album));
g_thread_create(get_cover_art, metadata, FALSE, NULL);
} else {
gtk_image_clear(GTK_IMAGE(cover_art));
}
g_strlcpy(idledata->media_info, message, 1024);
g_strlcpy(idledata->display_name, title, 1024);
g_free(message);
message = gm_tempname(NULL, "mplayer-af_exportXXXXXX");
g_strlcpy(idledata->af_export, message, 1024);
g_free(message);
message = g_strdup("");
if (title == NULL) {
title = g_filename_display_basename(uri);
}
//buffer = g_markup_printf_escaped("\t<b>%s</b>\n", title);
//message = g_strconcat(message, buffer, NULL);
//g_free(buffer);
if (artist != NULL) {
buffer = g_markup_printf_escaped("\t<i>%s</i>\n", artist);
message = g_strconcat(message, buffer, NULL);
g_free(buffer);
}
if (album != NULL) {
buffer = g_markup_printf_escaped("\t%s\n", album);
message = g_strconcat(message, buffer, NULL);
g_free(buffer);
}
g_strlcpy(idledata->media_notification, message, 1024);
g_free(message);
if (control_id == 0) {
set_media_label(idledata);
} else {
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem_view_info), FALSE);
}
if (subtitles)
gtk_container_forall(GTK_CONTAINER(subtitles), remove_langs, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(menuitem_edit_select_sub_lang), FALSE);
if (tracks)
gtk_container_forall(GTK_CONTAINER(tracks), remove_langs, NULL);
gtk_widget_set_sensitive(GTK_WIDGET(menuitem_edit_select_audio_lang), FALSE);
lang_group = NULL;
audio_group = NULL;
if (subtitle != NULL) {
gmtk_media_player_set_attribute_string(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_SUBTITLE_FILE, subtitle);
g_free(subtitle);
subtitle = NULL;
}
if (audiofile != NULL) {
gmtk_media_player_set_attribute_string(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_AUDIO_TRACK_FILE, audiofile);
g_free(audiofile);
audiofile = NULL;
}
/*
if (g_ascii_strcasecmp(thread_data->filename, "") != 0) {
if (!device_name(thread_data->filename) && !streaming_media(thread_data->filename)) {
if (!g_file_test(thread_data->filename, G_FILE_TEST_EXISTS)) {
error_msg = g_strdup_printf("%s not found\n", thread_data->filename);
dialog =
gtk_message_dialog_new(NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", error_msg);
gtk_window_set_title(GTK_WINDOW(dialog), "GNOME MPlayer Error");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return 1;
}
}
}
*/
#ifdef GTK2_12_ENABLED
#ifdef GIO_ENABLED
// don't put it on the recent list, if it is running in plugin mode
if (control_id == 0 && !streaming_media(uri)) {
recent_data = (GtkRecentData *) g_new0(GtkRecentData, 1);
if (artist != NULL && strlen(artist) > 0) {
recent_data->display_name = g_strdup_printf("%s - %s", artist, title);
} else {
recent_data->display_name = g_strdup(title);
}
g_strlcpy(idledata->display_name, recent_data->display_name, 1024);
file = g_file_new_for_uri(uri);
file_info = g_file_query_info(file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME, G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (file_info) {
recent_data->mime_type = g_strdup(g_file_info_get_content_type(file_info));
g_object_unref(file_info);
}
g_object_unref(file);
recent_data->app_name = g_strdup("gnome-mplayer");
recent_data->app_exec = g_strdup("gnome-mplayer %u");
if (recent_data->mime_type != NULL) {
gtk_recent_manager_add_full(recent_manager, uri, recent_data);
g_free(recent_data->mime_type);
}
g_free(recent_data->app_name);
g_free(recent_data->app_exec);
g_free(recent_data);
}
#endif
#endif
g_free(title);
g_free(artist);
g_free(album);
if (demuxer != NULL) {
g_strlcpy(idledata->demuxer, demuxer, 64);
g_free(demuxer);
} else {
g_strlcpy(idledata->demuxer, "", 64);
}
last_x = 0;
last_y = 0;
idledata->width = width;
idledata->height = height;
idledata->retry_on_full_cache = FALSE;
idledata->cachepercent = -1.0;
g_strlcpy(idledata->info, uri, 1024);
set_media_info(idledata);
streaming = 0;
gm_store = gm_pref_store_new("gnome-mplayer");
forcecache = gm_pref_store_get_boolean(gm_store, FORCECACHE);
gm_pref_store_free(gm_store);
if (g_ascii_strcasecmp(uri, "dvdnav://") == 0) {
gtk_widget_show(menu_event_box);
} else {
gtk_widget_hide(menu_event_box);
}
if (autostart) {
g_idle_add(hide_buttons, idledata);
js_state = STATE_PLAYING;
if (g_str_has_prefix(uri, "mmshttp") || g_str_has_prefix(uri, "http") || g_str_has_prefix(uri, "mms")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_NETWORK);
} else if (g_str_has_prefix(uri, "dvd") || g_str_has_prefix(uri, "dvdnav")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVD);
} else if (g_str_has_prefix(uri, "cdda")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_CD);
} else if (g_str_has_prefix(uri, "cddb")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_CD);
} else if (g_str_has_prefix(uri, "vcd")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_VCD);
} else if (g_str_has_prefix(uri, "tv")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_TV);
} else if (g_str_has_prefix(uri, "dvb")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_DVB);
} else if (g_str_has_prefix(uri, "file")) {
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_FILE);
} else {
// if all else fails it must be a network type
gmtk_media_player_set_media_type(GMTK_MEDIA_PLAYER(media), TYPE_NETWORK);
}
gmtk_media_player_set_attribute_boolean(GMTK_MEDIA_PLAYER(media), ATTRIBUTE_PLAYLIST, playlist);
gmtk_media_player_set_uri(GMTK_MEDIA_PLAYER(media), uri);
gmtk_media_player_set_state(GMTK_MEDIA_PLAYER(media), MEDIA_STATE_PLAY);
}
return 0;
}
/* Setting '/theme' changed either at widget or at xfconf property */
static void _xfdashboard_settings_widget_changed_theme(XfdashboardSettings *self, GtkTreeSelection *inSelection)
{
XfdashboardSettingsPrivate *priv;
GtkTreeModel *model;
GtkTreeIter iter;
gchar *themeDisplayName;
gchar *themeComment;
gchar *themeAuthor;
gchar *themeVersion;
gchar *themeScreenshot;
gchar *themeFilename;
gchar *themeName;
g_return_if_fail(XFDASHBOARD_IS_SETTINGS(self));
g_return_if_fail(GTK_IS_TREE_SELECTION(inSelection));
priv=self->priv;
themeDisplayName=NULL;
themeComment=NULL;
themeAuthor=NULL;
themeVersion=NULL;
themeScreenshot=NULL;
themeFilename=NULL;
themeName=NULL;
/* Get selected entry from widget */
if(gtk_tree_selection_get_selected(inSelection, &model, &iter))
{
/* Get data from model */
gtk_tree_model_get(model,
&iter,
COLUMN_THEME_NAME, &themeName,
COLUMN_THEME_FILE, &themeFilename,
COLUMN_THEME_DISPLAY_NAME, &themeDisplayName,
COLUMN_THEME_DESCRIPTION, &themeComment,
COLUMN_THEME_AUTHORS, &themeAuthor,
COLUMN_THEME_VERSION, &themeVersion,
COLUMN_THEME_SCREENSHOTS, &themeScreenshot,
-1);
}
/* Set text in labels */
if(themeDisplayName)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeName), themeDisplayName);
gtk_widget_show(priv->widgetThemeName);
gtk_widget_show(priv->widgetThemeNameLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeName);
gtk_widget_hide(priv->widgetThemeNameLabel);
}
if(themeComment)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeDescription), themeComment);
gtk_widget_show(priv->widgetThemeDescription);
gtk_widget_show(priv->widgetThemeDescriptionLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeDescription);
gtk_widget_hide(priv->widgetThemeDescriptionLabel);
}
if(themeAuthor)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeAuthor), themeAuthor);
gtk_widget_show(priv->widgetThemeAuthor);
gtk_widget_show(priv->widgetThemeAuthorLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeAuthor);
gtk_widget_hide(priv->widgetThemeAuthorLabel);
}
if(themeVersion)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeVersion), themeVersion);
gtk_widget_show(priv->widgetThemeVersion);
gtk_widget_show(priv->widgetThemeVersionLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeVersion);
gtk_widget_hide(priv->widgetThemeVersionLabel);
}
/* Set screenshot */
if(themeScreenshot)
{
gchar *screenshotFile;
GdkPixbuf *screenshotImage;
screenshotFile=NULL;
screenshotImage=NULL;
/* Get screenshot file but resolve relative path if needed */
if(!g_path_is_absolute(themeScreenshot))
{
GFile *file;
GFile *parentPath;
gchar *themePath;
file=NULL;
parentPath=NULL;
themePath=NULL;
/* Resolve relative path relative to theme path */
file=g_file_new_for_path(themeFilename);
if(file) parentPath=g_file_get_parent(file);
if(parentPath) themePath=g_file_get_path(parentPath);
if(themePath) screenshotFile=g_build_filename(themePath, themeScreenshot, NULL);
/* Release allocated resources */
if(themePath) g_free(themePath);
if(parentPath) g_object_unref(parentPath);
if(file) g_object_unref(file);
}
else
{
/* Path is absolute so just create a copy */
screenshotFile=g_strdup(themeScreenshot);
}
/* If screenshot file exists set up and show image
* otherwise hide image.
*/
if(screenshotFile &&
g_file_test(screenshotFile, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))
{
GError *error;
gint width;
gint height;
error=NULL;
/* Check if screenshot fits into widget without scaling or
* scale it to maximum size but preserve aspect ratio.
*/
if(gdk_pixbuf_get_file_info(screenshotFile, &width, &height))
{
if(width<MAX_SCREENSHOT_WIDTH)
{
screenshotImage=gdk_pixbuf_new_from_file(screenshotFile,
&error);
}
else
{
screenshotImage=gdk_pixbuf_new_from_file_at_scale(screenshotFile,
MAX_SCREENSHOT_WIDTH,
-1,
TRUE,
&error);
}
if(error)
{
g_warning("Could not load screenshot: %s",
error ? error->message : _("Unknown error"));
/* Release allocated resources */
if(error) g_error_free(error);
if(screenshotImage)
{
g_object_unref(screenshotImage);
screenshotImage=NULL;
}
}
}
}
if(screenshotImage)
{
gtk_image_set_from_pixbuf(GTK_IMAGE(priv->widgetThemeScreenshot), screenshotImage);
gtk_widget_show(priv->widgetThemeScreenshot);
}
else
{
gtk_widget_hide(priv->widgetThemeScreenshot);
}
/* Release allocated resources */
if(screenshotImage) g_object_unref(screenshotImage);
if(screenshotFile) g_free(screenshotFile);
}
else
{
gtk_widget_hide(priv->widgetThemeScreenshot);
}
/* Set value at xfconf property if it must be changed */
if(themeName)
{
gchar *currentTheme;
currentTheme=xfconf_channel_get_string(priv->xfconfChannel, "/theme", DEFAULT_THEME);
if(g_strcmp0(currentTheme, themeName))
{
xfconf_channel_set_string(priv->xfconfChannel, "/theme", themeName);
}
g_free(currentTheme);
}
/* Release allocated resources */
if(themeDisplayName) g_free(themeDisplayName);
if(themeComment) g_free(themeComment);
if(themeAuthor) g_free(themeAuthor);
if(themeVersion) g_free(themeVersion);
if(themeScreenshot) g_free(themeScreenshot);
if(themeFilename) g_free(themeFilename);
if(themeName) g_free(themeName);
}
