/*
* Open the window to select and type the picture properties
*/
void Picture_Properties_Button_Clicked (GObject *object)
{
GtkWidget *ScrollWindowPictureTypes, *PictureTypesWindow;
GtkWidget *type, *label, *desc;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkListStore *store;
GtkTreeIter type_iter_to_select, iter;
GtkTreeModel *model;
GtkWindow *parent_window = NULL;
GList *selection_list = NULL;
GList *l;
gint selection_nbr, selection_i = 1;
gint response;
EtPictureType pic_type;
g_return_if_fail (PictureEntryView != NULL);
parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object)));
if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window)))
{
g_warning("Could not get parent window\n");
return;
}
model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
selection_list = gtk_tree_selection_get_selected_rows(selection, NULL);
selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection));
for (l = selection_list; l != NULL; l = g_list_next (l))
{
GtkTreePath *path = l->data;
Picture *pic = NULL;
GtkTreeSelection *selectiontype;
gchar *title;
GtkTreePath *rowPath;
gboolean valid;
// Get corresponding picture
valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path);
if (valid)
gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1);
title = g_strdup_printf (_("Image Properties %d/%d"), selection_i++,
selection_nbr);
PictureTypesWindow = gtk_dialog_new_with_buttons(title,
parent_window,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
g_free(title);
gtk_dialog_set_default_response(GTK_DIALOG(PictureTypesWindow), GTK_RESPONSE_OK);
ScrollWindowPictureTypes = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowPictureTypes),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
store = gtk_list_store_new(PICTURE_TYPE_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_INT);
type = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref (store);
gtk_container_add(GTK_CONTAINER(ScrollWindowPictureTypes), type);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_title (column, _("Image Type"));
gtk_tree_view_column_set_attributes(column, renderer,
"text", PICTURE_TYPE_COLUMN_TEXT,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(type), column);
gtk_widget_set_size_request(type, 256, 256);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),ScrollWindowPictureTypes,TRUE,TRUE,0);
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
/* Load picture type (only Front Cover!). */
GtkTreeIter itertype;
gtk_list_store_insert_with_values (store, &itertype, G_MAXINT,
PICTURE_TYPE_COLUMN_TEXT,
_(Picture_Type_String (ET_PICTURE_TYPE_FRONT_COVER)),
PICTURE_TYPE_COLUMN_TYPE_CODE,
ET_PICTURE_TYPE_FRONT_COVER,
-1);
/* Line to select by default. */
type_iter_to_select = itertype;
break;
}
// Other tag types
default:
{
// Load pictures types
for (pic_type = ET_PICTURE_TYPE_OTHER; pic_type < ET_PICTURE_TYPE_UNDEFINED; pic_type++)
{
GtkTreeIter itertype;
gtk_list_store_insert_with_values (store, &itertype,
G_MAXINT,
PICTURE_TYPE_COLUMN_TEXT,
_(Picture_Type_String (pic_type)),
PICTURE_TYPE_COLUMN_TYPE_CODE,
pic_type, -1);
/* Line to select by default. */
if (pic->type == pic_type)
type_iter_to_select = itertype;
}
break;
}
}
// Select the line by default
selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type));
gtk_tree_selection_select_iter(selectiontype, &type_iter_to_select);
// Set visible the current selected line
rowPath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &type_iter_to_select);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(type), rowPath, NULL, FALSE, 0, 0);
gtk_tree_path_free(rowPath);
// Description of the picture
label = gtk_label_new (_("Image Description:"));
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),label,FALSE,FALSE,4);
// Entry for the description
desc = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),desc,FALSE,FALSE,0);
if (pic->description)
{
gchar *tmp = Try_To_Validate_Utf8_String(pic->description);
gtk_entry_set_text(GTK_ENTRY(desc), tmp);
g_free(tmp);
}
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
gtk_widget_set_sensitive(GTK_WIDGET(label), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(desc), FALSE);
break;
}
// Other tag types
default:
{
break;
}
}
gtk_widget_show_all(PictureTypesWindow);
response = gtk_dialog_run(GTK_DIALOG(PictureTypesWindow));
if (response == GTK_RESPONSE_OK)
{
GtkTreeModel *modeltype;
GtkTreeIter itertype;
modeltype = gtk_tree_view_get_model(GTK_TREE_VIEW(type));
selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type));
if (gtk_tree_selection_get_selected(selectiontype, &modeltype, &itertype))
{
gchar *buffer, *pic_info;
gint t;
gtk_tree_model_get(modeltype, &itertype,
PICTURE_TYPE_COLUMN_TYPE_CODE, &t, -1);
pic->type = t;
buffer = g_strdup(gtk_entry_get_text(GTK_ENTRY(desc)));
Strip_String(buffer);
if (pic->description)
g_free(pic->description);
/* If the entry was empty, buffer will be the empty string "".
* This can be safely passed to the underlying
* FLAC__metadata_object_picture_set_description(). See
* https://bugs.launchpad.net/ubuntu/+source/easytag/+bug/558804
* and https://bugzilla.redhat.com/show_bug.cgi?id=559828 for
* downstream bugs when 0 was passed instead. */
pic->description = buffer;
// Update value in the PictureEntryView
pic_info = Picture_Info(pic);
gtk_list_store_set(GTK_LIST_STORE(model), &iter,
PICTURE_COLUMN_TEXT, pic_info,
-1);
g_free(pic_info);
}
}
gtk_widget_destroy(PictureTypesWindow);
}
g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free);
}
static void
list__process_line (char *line,
gpointer data)
{
FrCommand7z *self = FR_COMMAND_7Z (data);
FrArchive *archive = FR_ARCHIVE (data);
char **fields;
FileData *fdata;
g_return_if_fail (line != NULL);
if (! self->list_started) {
if (strncmp (line, "p7zip Version ", 14) == 0) {
const char *ver_start;
int ver_len;
char version[256];
ver_start = _g_str_eat_spaces (line + 14);
ver_len = strchr (ver_start, ' ') - ver_start;
strncpy (version, ver_start, ver_len);
version[ver_len] = 0;
if (strcmp (version, "4.55") < 0)
self->old_style = TRUE;
else
self->old_style = FALSE;
}
else if (self->old_style && (strncmp (line, "Listing archive: ", 17) == 0))
self->list_started = TRUE;
else if (! self->old_style && (strcmp (line, "----------") == 0))
self->list_started = TRUE;
else if (strncmp (line, "Multivolume = ", 14) == 0) {
fields = g_strsplit (line, " = ", 2);
archive->multi_volume = (strcmp (fields[1], "+") == 0);
g_strfreev (fields);
}
return;
}
if (strcmp (line, "") == 0) {
if (self->fdata != NULL) {
if (self->fdata->original_path == NULL) {
file_data_free (self->fdata);
self->fdata = NULL;
}
else {
fdata = self->fdata;
if (fdata->dir)
fdata->name = _g_path_get_dir_name (fdata->full_path);
else
fdata->name = g_strdup (_g_path_get_basename (fdata->full_path));
fdata->path = _g_path_remove_level (fdata->full_path);
fr_archive_add_file (archive, fdata);
self->fdata = NULL;
}
}
return;
}
if (self->fdata == NULL)
self->fdata = file_data_new ();
fields = g_strsplit (line, " = ", 2);
if (g_strv_length (fields) < 2) {
g_strfreev (fields);
return;
}
fdata = self->fdata;
if (strcmp (fields[0], "Path") == 0) {
fdata->free_original_path = TRUE;
fdata->original_path = g_strdup (fields[1]);
fdata->full_path = g_strconcat ((fdata->original_path[0] != '/') ? "/" : "",
fdata->original_path,
(fdata->dir && (fdata->original_path[strlen (fdata->original_path) - 1] != '/')) ? "/" : "",
NULL);
}
else if (strcmp (fields[0], "Folder") == 0) {
fdata->dir = (strcmp (fields[1], "+") == 0);
}
else if (strcmp (fields[0], "Size") == 0) {
fdata->size = g_ascii_strtoull (fields[1], NULL, 10);
}
else if (strcmp (fields[0], "Modified") == 0) {
char **modified_fields;
modified_fields = g_strsplit (fields[1], " ", 2);
if (modified_fields[0] != NULL)
fdata->modified = mktime_from_string (modified_fields[0], modified_fields[1]);
g_strfreev (modified_fields);
}
else if (strcmp (fields[0], "Encrypted") == 0) {
if (strcmp (fields[1], "+") == 0)
fdata->encrypted = TRUE;
}
else if (strcmp (fields[0], "Method") == 0) {
if (strstr (fields[1], "AES") != NULL)
fdata->encrypted = TRUE;
}
else if (strcmp (fields[0], "Attributes") == 0) {
if (fields[1][0] == 'D')
fdata->dir = TRUE;
}
g_strfreev (fields);
}
/**
* gimp_session_info_read_geometry:
* @info: A #GimpSessionInfo
* @cevent A #GdkEventConfigure. If set, use the size from here
* instead of from the window allocation.
*
* Read geometry related information from the associated widget.
**/
void
gimp_session_info_read_geometry (GimpSessionInfo *info,
GdkEventConfigure *cevent)
{
GdkWindow *window;
GdkDisplay *display;
g_return_if_fail (GIMP_IS_SESSION_INFO (info));
g_return_if_fail (GTK_IS_WINDOW (info->p->widget));
window = gtk_widget_get_window (info->p->widget);
display = gtk_widget_get_display (info->p->widget);
if (window)
{
gint x, y;
GdkMonitor *monitor;
GdkRectangle geometry;
gtk_window_get_position (GTK_WINDOW (info->p->widget), &x, &y);
/* Don't write negative values to the sessionrc, they are
* interpreted as relative to the right, respective bottom edge
* of the display.
*/
info->p->x = MAX (0, x);
info->p->y = MAX (0, y);
monitor = gdk_display_get_monitor_at_point (display,
info->p->x, info->p->y);
gdk_monitor_get_geometry (monitor, &geometry);
/* Always store window coordinates relative to the monitor */
info->p->x -= geometry.x;
info->p->y -= geometry.y;
if (gimp_session_info_get_remember_size (info))
{
gtk_window_get_size (GTK_WINDOW (info->p->widget),
&info->p->width, &info->p->height);
}
else
{
info->p->width = 0;
info->p->height = 0;
}
info->p->monitor = DEFAULT_MONITOR;
if (monitor != gdk_display_get_primary_monitor (display))
info->p->monitor = monitor;
}
info->p->open = FALSE;
if (gimp_session_info_get_remember_if_open (info))
{
GimpDialogVisibilityState visibility;
visibility =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (info->p->widget),
GIMP_DIALOG_VISIBILITY_KEY));
switch (visibility)
{
case GIMP_DIALOG_VISIBILITY_UNKNOWN:
info->p->open = gtk_widget_get_visible (info->p->widget);
break;
case GIMP_DIALOG_VISIBILITY_INVISIBLE:
info->p->open = FALSE;
break;
case GIMP_DIALOG_VISIBILITY_HIDDEN:
case GIMP_DIALOG_VISIBILITY_VISIBLE:
/* Even if a dialog is hidden (with Windows->Hide docks) it
* is still considered open. It will be restored the next
* time GIMP starts
*/
info->p->open = TRUE;
break;
}
}
}
static void
gst_dvbsrc_set_property (GObject * _object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstDvbSrc *object;
g_return_if_fail (GST_IS_DVBSRC (_object));
object = GST_DVBSRC (_object);
switch (prop_id) {
case ARG_DVBSRC_ADAPTER:
object->adapter_number = g_value_get_int (value);
break;
case ARG_DVBSRC_FRONTEND:
object->frontend_number = g_value_get_int (value);
break;
case ARG_DVBSRC_DISEQC_SRC:
if (object->diseqc_src != g_value_get_int (value)) {
object->diseqc_src = g_value_get_int (value);
object->send_diseqc = TRUE;
}
GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_DISEQC_ID");
break;
case ARG_DVBSRC_FREQUENCY:
object->freq = g_value_get_uint (value);
GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_FREQUENCY (%d Hz)",
object->freq);
break;
case ARG_DVBSRC_POLARITY:
{
const char *s = NULL;
s = g_value_get_string (value);
if (s != NULL) {
object->pol = (s[0] == 'h' || s[0] == 'H') ? DVB_POL_H : DVB_POL_V;
GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_POLARITY");
GST_INFO_OBJECT (object, "\t%s", (s[0] == 'h'
|| s[0] == 'H') ? "DVB_POL_H" : "DVB_POL_V");
}
break;
}
case ARG_DVBSRC_PIDS:
{
gchar *pid_string;
pid_string = g_value_dup_string (value);
GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_PIDS %s", pid_string);
if (!strcmp (pid_string, "8192")) {
/* get the whole ts */
int pid_count = 1;
object->pids[0] = 8192;
while (pid_count < MAX_FILTERS) {
object->pids[pid_count++] = G_MAXUINT16;
}
} else {
int pid = 0;
int pid_count;
gchar **pids;
char **tmp;
tmp = pids = g_strsplit (pid_string, ":", MAX_FILTERS);
if (pid_string)
g_free (pid_string);
/* always add the PAT and CAT pids */
object->pids[0] = 0;
object->pids[1] = 1;
pid_count = 2;
while (*pids != NULL && pid_count < MAX_FILTERS) {
pid = strtol (*pids, NULL, 0);
if (pid > 1 && pid <= 8192) {
GST_INFO_OBJECT (object, "\tParsed Pid: %d", pid);
object->pids[pid_count] = pid;
pid_count++;
}
pids++;
}
while (pid_count < MAX_FILTERS) {
object->pids[pid_count++] = G_MAXUINT16;
}
g_strfreev (tmp);
}
/* if we are in playing or paused, then set filters now */
GST_INFO_OBJECT (object, "checking if playing for setting pes filters");
if (GST_ELEMENT (object)->current_state == GST_STATE_PLAYING ||
GST_ELEMENT (object)->current_state == GST_STATE_PAUSED) {
GST_INFO_OBJECT (object, "Setting pes filters now");
gst_dvbsrc_set_pes_filters (object);
}
}
break;
case ARG_DVBSRC_SYM_RATE:
object->sym_rate = g_value_get_uint (value);
GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_SYM_RATE to value %d",
object->sym_rate);
break;
case ARG_DVBSRC_BANDWIDTH:
object->bandwidth = g_value_get_enum (value);
break;
case ARG_DVBSRC_CODE_RATE_HP:
object->code_rate_hp = g_value_get_enum (value);
break;
case ARG_DVBSRC_CODE_RATE_LP:
object->code_rate_lp = g_value_get_enum (value);
break;
case ARG_DVBSRC_GUARD:
object->guard_interval = g_value_get_enum (value);
break;
case ARG_DVBSRC_MODULATION:
object->modulation = g_value_get_enum (value);
break;
case ARG_DVBSRC_TRANSMISSION_MODE:
object->transmission_mode = g_value_get_enum (value);
break;
case ARG_DVBSRC_HIERARCHY_INF:
object->hierarchy_information = g_value_get_enum (value);
break;
case ARG_DVBSRC_INVERSION:
object->inversion = g_value_get_enum (value);
break;
case ARG_DVBSRC_TUNE:{
GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_TUNE");
/* if we are in paused/playing state tune now, otherwise in ready to paused state change */
if (GST_STATE (object) > GST_STATE_READY) {
g_mutex_lock (&object->tune_mutex);
gst_dvbsrc_tune (object);
g_mutex_unlock (&object->tune_mutex);
}
break;
}
case ARG_DVBSRC_STATS_REPORTING_INTERVAL:
object->stats_interval = g_value_get_uint (value);
object->stats_counter = 0;
break;
case ARG_DVBSRC_TIMEOUT:
object->timeout = g_value_get_uint64 (value);
break;
case ARG_DVBSRC_DVB_BUFFER_SIZE:
object->dvb_buffer_size = g_value_get_uint (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
void weather_page_set_index(WeatherPage *page, gint index)
{
g_return_if_fail(page != NULL);
page->priv->index = index;
}
/* The current selection of a focusable actor (if focussed or not) is not available anymore
* (e.g. hidden or destroyed). So move selection at focusable actor to next available and
* selectable item.
*/
static void _xfdashboard_focusable_on_selection_unavailable(XfdashboardFocusable *self,
gpointer inUserData)
{
XfdashboardFocusableInterface *iface;
ClutterActor *oldSelection;
ClutterActor *newSelection;
gboolean success;
XfdashboardApplication *application;
g_return_if_fail(XFDASHBOARD_IS_FOCUSABLE(self));
g_return_if_fail(CLUTTER_IS_ACTOR(inUserData));
iface=XFDASHBOARD_FOCUSABLE_GET_IFACE(self);
oldSelection=CLUTTER_ACTOR(inUserData);
newSelection=NULL;
success=FALSE;
/* If application is not quitting then call virtual function to set selection
* which have to be available because this signal handler was set in
* xfdashboard_focusable_set_selection() when this virtual function was available
* and successfully called.
* If setting new selection was unsuccessful we set selection to nothing (NULL);
*/
application=xfdashboard_application_get_default();
if(!xfdashboard_application_is_quitting(application))
{
/* Get next selection */
newSelection=xfdashboard_focusable_find_selection(self, oldSelection, XFDASHBOARD_SELECTION_TARGET_NEXT);
/* Set new selection */
success=iface->set_selection(self, newSelection);
if(!success)
{
success=iface->set_selection(self, newSelection);
if(!success)
{
g_critical(_("Old selection %s at %s is unavailable but setting new selection either to %s or nothing failed!"),
G_OBJECT_TYPE_NAME(oldSelection),
G_OBJECT_TYPE_NAME(self),
newSelection ? G_OBJECT_TYPE_NAME(newSelection) : "<nil>");
}
/* Now reset new selection to NULL regardless if setting selection at
* focusable actor was successful or not. A critical warning was displayed
* if is was unsuccessful because setting nothing (NULL) must succeed usually.
*/
newSelection=NULL;
}
}
/* Regardless if setting selection was successful, remove signal handlers
* and styles from old selection.
*/
if(oldSelection)
{
/* Remove signal handlers at old selection*/
g_signal_handlers_disconnect_by_func(oldSelection,
G_CALLBACK(_xfdashboard_focusable_on_selection_unavailable),
self);
/* Remove style from old selection */
if(XFDASHBOARD_IS_STYLABLE(oldSelection))
{
xfdashboard_stylable_remove_pseudo_class(XFDASHBOARD_STYLABLE(oldSelection), "selected");
}
}
/* If setting selection was successful, set up signal handlers and styles at new selection */
if(success && newSelection)
{
/* Set up signal handlers to get notified if new selection
* is going to be unavailable (e.g. hidden or destroyed)
*/
g_signal_connect_swapped(newSelection,
"destroy",
G_CALLBACK(_xfdashboard_focusable_on_selection_unavailable),
self);
g_signal_connect_swapped(newSelection,
"hide",
G_CALLBACK(_xfdashboard_focusable_on_selection_unavailable),
self);
/* Check if this focusable actor has the focus because if it has
* the have to style new selection.
*/
if(_xfdashboard_focusable_has_focus(self) &&
XFDASHBOARD_IS_STYLABLE(newSelection))
{
xfdashboard_stylable_add_pseudo_class(XFDASHBOARD_STYLABLE(newSelection), "selected");
}
}
/* Emit signal because at least old selection has changed */
g_signal_emit(self, XfdashboardFocusableSignals[SIGNAL_SELECTION_CHANGED], 0, oldSelection, newSelection);
}
void
xcf_exit (Gimp *gimp)
{
g_return_if_fail (GIMP_IS_GIMP (gimp));
}
static void dcc_error_unknown_type(const char *type)
{
g_return_if_fail(type != NULL);
printformat(NULL, NULL, MSGLEVEL_DCC, IRCTXT_DCC_UNKNOWN_TYPE, type);
}
/**
* cockpit_web_response_file:
* @response: the response
* @path: escaped path, or NULL to get from response
* @roots: directories to look for file in
*
* Serve a file from disk as an HTTP response.
*/
void
cockpit_web_response_file (CockpitWebResponse *response,
const gchar *escaped,
gboolean cache_forever,
const gchar **roots)
{
const gchar *cache_control;
GError *error = NULL;
gchar *unescaped = NULL;
gchar *path = NULL;
GMappedFile *file = NULL;
const gchar *root;
GBytes *body;
g_return_if_fail (COCKPIT_IS_WEB_RESPONSE (response));
if (!escaped)
escaped = cockpit_web_response_get_path (response);
g_return_if_fail (escaped != NULL);
/* Someone is trying to escape the root directory, or access hidden files? */
unescaped = g_uri_unescape_string (escaped, NULL);
if (strstr (unescaped, "/.") || strstr (unescaped, "../") || strstr (unescaped, "//"))
{
g_debug ("%s: invalid path request", escaped);
cockpit_web_response_error (response, 404, NULL, "Not Found");
goto out;
}
again:
root = *(roots++);
if (root == NULL)
{
cockpit_web_response_error (response, 404, NULL, "Not Found");
goto out;
}
g_free (path);
path = g_build_filename (root, unescaped, NULL);
if (g_file_test (path, G_FILE_TEST_IS_DIR))
{
cockpit_web_response_error (response, 403, NULL, "Directory Listing Denied");
goto out;
}
/* As a double check of above behavior */
g_assert (path_has_prefix (path, root));
g_clear_error (&error);
file = g_mapped_file_new (path, FALSE, &error);
if (file == NULL)
{
if (g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT) ||
g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NAMETOOLONG))
{
g_debug ("%s: file not found in root: %s", escaped, root);
goto again;
}
else if (g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_PERM) ||
g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_ACCES) ||
g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_ISDIR))
{
cockpit_web_response_error (response, 403, NULL, "Access denied");
goto out;
}
else
{
g_warning ("%s: %s", path, error->message);
cockpit_web_response_error (response, 500, NULL, "Internal server error");
goto out;
}
}
body = g_mapped_file_get_bytes (file);
cache_control = cache_forever ? "max-age=31556926, public" : NULL;
cockpit_web_response_headers (response, 200, "OK", g_bytes_get_size (body),
"Cache-Control", cache_control,
NULL);
if (cockpit_web_response_queue (response, body))
cockpit_web_response_complete (response);
g_bytes_unref (body);
out:
g_free (unescaped);
g_clear_error (&error);
g_free (path);
if (file)
g_mapped_file_unref (file);
}
static void dcc_error_file_create(DCC_REC *dcc, const char *fname)
{
g_return_if_fail(dcc != NULL);
printformat(NULL, NULL, MSGLEVEL_DCC, IRCTXT_DCC_CANT_CREATE, fname);
}
static void dcc_error_get_not_found(const char *nick)
{
g_return_if_fail(nick != NULL);
printformat(NULL, NULL, MSGLEVEL_DCC, IRCTXT_DCC_GET_NOT_FOUND, nick);
}
static void
gst_moz_video_buffer_init(GstMozVideoBuffer* self)
{
g_return_if_fail(GST_IS_MOZ_VIDEO_BUFFER(self));
}
void PictureEntry_Update (Picture *pic, gboolean select_it)
{
GdkPixbufLoader *loader = 0;
GError *error = NULL;
g_return_if_fail (pic != NULL || PictureEntryView != NULL);
if (!pic->data)
{
PictureEntry_Clear();
return;
}
loader = gdk_pixbuf_loader_new();
if (loader)
{
if (gdk_pixbuf_loader_write(loader, pic->data, pic->size, &error))
{
GtkTreeSelection *selection;
GdkPixbuf *pixbuf;
if (!gdk_pixbuf_loader_close(loader, &error))
{
Log_Print(LOG_ERROR,_("Error with 'loader_close': %s"), error->message);
g_error_free(error);
}
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
if (pixbuf)
{
GtkListStore *picture_store;
GtkTreeIter iter1;
GdkPixbuf *scaled_pixbuf;
gint scaled_pixbuf_width;
gint scaled_pixbuf_height;
gchar *pic_info;
g_object_ref(pixbuf);
g_object_unref(loader);
// Keep aspect ratio of the picture
pic->width = gdk_pixbuf_get_width(pixbuf);
pic->height = gdk_pixbuf_get_height(pixbuf);
if (pic->width > pic->height)
{
scaled_pixbuf_width = 96;
scaled_pixbuf_height = 96 * pic->height / pic->width;
}else
{
scaled_pixbuf_width = 96 * pic->width / pic->height;
scaled_pixbuf_height = 96;
}
scaled_pixbuf = gdk_pixbuf_scale_simple(pixbuf,
scaled_pixbuf_width, scaled_pixbuf_height,
//GDK_INTERP_NEAREST); // Lower quality but better speed
GDK_INTERP_BILINEAR);
g_object_unref(pixbuf);
picture_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView)));
pic_info = Picture_Info(pic);
gtk_list_store_insert_with_values (picture_store, &iter1,
G_MAXINT,
PICTURE_COLUMN_PIC,
scaled_pixbuf,
PICTURE_COLUMN_TEXT,
pic_info,
PICTURE_COLUMN_DATA,
Picture_Copy_One (pic), -1);
g_free(pic_info);
if (select_it)
gtk_tree_selection_select_iter(selection, &iter1);
g_object_unref(scaled_pixbuf);
}else
{
GtkWidget *msgdialog;
g_object_unref(loader);
Log_Print (LOG_ERROR, "%s",
_("Cannot display the image because not enough data has been read to determine how to create the image buffer."));
msgdialog = gtk_message_dialog_new(GTK_WINDOW(MainWindow),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s",
_("Cannot display the image"));
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (msgdialog),
_("Not enough data has been read to determine how to create the image buffer."));
gtk_window_set_title (GTK_WINDOW (msgdialog),
_("Load Image File"));
gtk_dialog_run(GTK_DIALOG(msgdialog));
gtk_widget_destroy(msgdialog);
}
}else
{
Log_Print(LOG_ERROR,_("Error with 'loader_write': %s"), error->message);
g_error_free(error);
}
}
// Do also for next picture
if (pic->next)
PictureEntry_Update(pic->next, select_it);
return;
}
void Picture_Save_Button_Clicked (GObject *object)
{
GtkWidget *FileSelectionWindow;
GtkFileFilter *filter;
GtkWindow *parent_window = NULL;
static gchar *init_dir = NULL;
GtkTreeSelection *selection;
GList *selection_list = NULL;
GList *l;
GtkTreeModel *model;
gint selection_nbr, selection_i = 1;
g_return_if_fail (PictureEntryView != NULL);
parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object)));
if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window)))
{
g_warning("Could not get parent window\n");
return;
}
model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView));
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
selection_list = gtk_tree_selection_get_selected_rows(selection, NULL);
selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection));
for (l = selection_list; l != NULL; l = g_list_next (l))
{
GtkTreePath *path = l->data;
GtkTreeIter iter;
Picture *pic;
gchar *title;
gboolean valid;
gint response;
// Get corresponding picture
valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path);
if (valid)
gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1);
title = g_strdup_printf (_("Save Image %d/%d"), selection_i++,
selection_nbr);
FileSelectionWindow = gtk_file_chooser_dialog_new(title,
parent_window,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_OK,
NULL);
g_free(title);
// Add files filters
// "All files" filter
filter = gtk_file_filter_new ();
gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("All Files"));
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter));
// "PNG and JPEG" filter
filter = gtk_file_filter_new ();
gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("PNG and JPEG"));
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/jpeg");
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/png");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (FileSelectionWindow), GTK_FILE_FILTER(filter));
// Make this filter the default
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter));
// Set the default folder if defined
if (init_dir)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow),init_dir);
// Suggest a filename to the user
if ( pic->description && strlen(pic->description) )
{
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(FileSelectionWindow), pic->description); //filename in UTF8
}else
{
gchar *image_name = NULL;
switch (Picture_Format_From_Data(pic))
{
case PICTURE_FORMAT_JPEG :
image_name = g_strdup("image_name.jpg");
break;
case PICTURE_FORMAT_PNG :
image_name = g_strdup("image_name.png");
break;
case PICTURE_FORMAT_UNKNOWN :
image_name = g_strdup("image_name.ext");
break;
}
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(FileSelectionWindow), image_name); //filename in UTF8
g_free(image_name);
}
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (FileSelectionWindow),
TRUE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (FileSelectionWindow),
FALSE);
response = gtk_dialog_run(GTK_DIALOG(FileSelectionWindow));
if (response == GTK_RESPONSE_OK)
{
GFile *file;
GError *error = NULL;
// Save the directory selected for initialize next time
g_free(init_dir);
init_dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow));
file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (FileSelectionWindow));
if (!et_picture_save_file_data (pic, file, &error))
{
Log_Print (LOG_ERROR, _("Image file not saved: %s"),
error->message);
g_error_free (error);
}
g_object_unref (file);
}
gtk_widget_destroy(FileSelectionWindow);
}
g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free);
}
void
pidgin_xfer_dialog_update_xfer(PidginXferDialog *dialog,
PurpleXfer *xfer)
{
PidginXferUiData *data;
char *size_str, *remaining_str;
GtkTreeSelection *selection;
time_t current_time;
GtkTreeIter iter;
gboolean valid;
g_return_if_fail(dialog != NULL);
g_return_if_fail(xfer != NULL);
if ((data = PIDGINXFER(xfer)) == NULL)
return;
if (data->in_list == FALSE)
return;
current_time = time(NULL);
if (((current_time - data->last_updated_time) == 0) &&
(!purple_xfer_is_completed(xfer)))
{
/* Don't update the window more than once per second */
return;
}
data->last_updated_time = current_time;
size_str = purple_str_size_to_units(purple_xfer_get_size(xfer));
remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer));
gtk_list_store_set(xfer_dialog->model, &data->iter,
COLUMN_PROGRESS, purple_xfer_get_progress(xfer),
COLUMN_SIZE, size_str,
COLUMN_REMAINING, remaining_str,
-1);
g_free(size_str);
g_free(remaining_str);
if (purple_xfer_is_completed(xfer))
{
GdkPixbuf *pixbuf;
pixbuf = gtk_widget_render_icon(dialog->window,
PIDGIN_STOCK_FILE_DONE,
GTK_ICON_SIZE_MENU, NULL);
gtk_list_store_set(GTK_LIST_STORE(xfer_dialog->model), &data->iter,
COLUMN_STATUS, pixbuf,
COLUMN_REMAINING, _("Finished"),
-1);
g_object_unref(pixbuf);
}
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(xfer_dialog->tree));
update_title_progress(dialog);
if (xfer == dialog->selected_xfer)
update_detailed_info(xfer_dialog, xfer);
if (purple_xfer_is_completed(xfer) && dialog->auto_clear)
pidgin_xfer_dialog_remove_xfer(dialog, xfer);
else
update_buttons(dialog, xfer);
/*
* If all transfers are finished, and the pref is set, then
* close the dialog. Otherwise just exit this function.
*/
if (dialog->keep_open)
return;
valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dialog->model), &iter);
while (valid)
{
GValue val;
PurpleXfer *next;
val.g_type = 0;
gtk_tree_model_get_value(GTK_TREE_MODEL(dialog->model),
&iter, COLUMN_DATA, &val);
next = g_value_get_pointer(&val);
if (!purple_xfer_is_completed(next))
return;
valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(dialog->model), &iter);
}
/* If we got to this point then we know everything is finished */
pidgin_xfer_dialog_hide(dialog);
}
/**
* cockpit_web_response_error:
* @self: the response
* @status: the HTTP status code
* @headers: headers to include or NULL
* @format: printf format of error message
*
* Send an error message with a basic HTML page containing
* the error.
*/
void
cockpit_web_response_error (CockpitWebResponse *self,
guint code,
GHashTable *headers,
const gchar *format,
...)
{
va_list var_args;
gchar *reason = NULL;
const gchar *message;
GBytes *input = NULL;
GList *output, *l;
GError *error = NULL;
g_return_if_fail (COCKPIT_IS_WEB_RESPONSE (self));
if (format)
{
va_start (var_args, format);
reason = g_strdup_vprintf (format, var_args);
va_end (var_args);
message = reason;
}
else
{
switch (code)
{
case 400:
message = "Bad request";
break;
case 401:
message = "Not Authorized";
break;
case 403:
message = "Forbidden";
break;
case 404:
message = "Not Found";
break;
case 405:
message = "Method Not Allowed";
break;
case 413:
message = "Request Entity Too Large";
break;
case 502:
message = "Remote Page is Unavailable";
break;
case 500:
message = "Internal Server Error";
break;
default:
if (code < 100)
reason = g_strdup_printf ("%u Continue", code);
else if (code < 200)
reason = g_strdup_printf ("%u OK", code);
else if (code < 300)
reason = g_strdup_printf ("%u Moved", code);
else
reason = g_strdup_printf ("%u Failed", code);
message = reason;
break;
}
}
g_debug ("%s: returning error: %u %s", self->logname, code, message);
if (cockpit_web_failure_resource)
{
input = g_resources_lookup_data (cockpit_web_failure_resource, G_RESOURCE_LOOKUP_FLAGS_NONE, &error);
if (input == NULL)
{
g_critical ("couldn't load: %s: %s", cockpit_web_failure_resource, error->message);
g_error_free (error);
}
}
if (!input)
input = g_bytes_new_static (default_failure_template, strlen (default_failure_template));
if (headers)
{
if (!g_hash_table_lookup (headers, "Content-Type"))
g_hash_table_replace (headers, g_strdup ("Content-Type"), g_strdup ("text/html; charset=utf8"));
cockpit_web_response_headers_full (self, code, message, -1, headers);
}
else
{
cockpit_web_response_headers (self, code, message, -1, "Content-Type", "text/html; charset=utf8", NULL);
}
output = cockpit_template_expand (input, substitute_message, (gpointer)message);
g_bytes_unref (input);
for (l = output; l != NULL; l = g_list_next (l))
{
if (!cockpit_web_response_queue (self, l->data))
break;
}
if (l == NULL)
cockpit_web_response_complete (self);
g_list_free_full (output, (GDestroyNotify)g_bytes_unref);
g_free (reason);
}
void
pidgin_xfer_dialog_add_xfer(PidginXferDialog *dialog, PurpleXfer *xfer)
{
PidginXferUiData *data;
PurpleXferType type;
GdkPixbuf *pixbuf;
char *size_str, *remaining_str;
char *lfilename, *utf8;
g_return_if_fail(dialog != NULL);
g_return_if_fail(xfer != NULL);
purple_xfer_ref(xfer);
data = PIDGINXFER(xfer);
data->in_list = TRUE;
pidgin_xfer_dialog_show(dialog);
data->last_updated_time = 0;
type = purple_xfer_get_type(xfer);
size_str = purple_str_size_to_units(purple_xfer_get_size(xfer));
remaining_str = purple_str_size_to_units(purple_xfer_get_bytes_remaining(xfer));
pixbuf = gtk_widget_render_icon(dialog->window,
(type == PURPLE_XFER_RECEIVE
? PIDGIN_STOCK_DOWNLOAD
: PIDGIN_STOCK_UPLOAD),
GTK_ICON_SIZE_MENU, NULL);
gtk_list_store_append(dialog->model, &data->iter);
lfilename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
utf8 = g_filename_to_utf8(lfilename, -1, NULL, NULL, NULL);
g_free(lfilename);
lfilename = utf8;
gtk_list_store_set(dialog->model, &data->iter,
COLUMN_STATUS, pixbuf,
COLUMN_PROGRESS, 0.0,
COLUMN_FILENAME, (type == PURPLE_XFER_RECEIVE)
? purple_xfer_get_filename(xfer)
: lfilename,
COLUMN_SIZE, size_str,
COLUMN_REMAINING, _("Waiting for transfer to begin"),
COLUMN_DATA, xfer,
-1);
g_free(lfilename);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(dialog->tree));
g_object_unref(pixbuf);
g_free(size_str);
g_free(remaining_str);
dialog->num_transfers++;
ensure_row_selected(dialog);
update_title_progress(dialog);
}
void
purple_core_quit(void)
{
PurpleCoreUiOps *ops;
PurpleCore *core = purple_get_core();
g_return_if_fail(core != NULL);
/* The self destruct sequence has been initiated */
purple_signal_emit(purple_get_core(), "quitting");
/* Transmission ends */
purple_connections_disconnect_all();
/*
* Certificates must be destroyed before the SSL plugins, because
* PurpleCertificates contain pointers to PurpleCertificateSchemes,
* and the PurpleCertificateSchemes will be unregistered when the
* SSL plugin is uninit.
*/
purple_certificate_uninit();
/* Save .xml files, remove signals, etc. */
purple_smileys_uninit();
purple_idle_uninit();
purple_pounces_uninit();
purple_blist_uninit();
purple_ciphers_uninit();
purple_notify_uninit();
purple_conversations_uninit();
purple_connections_uninit();
purple_buddy_icons_uninit();
purple_accounts_uninit();
purple_savedstatuses_uninit();
purple_status_uninit();
purple_sound_uninit();
purple_xfers_uninit();
purple_proxy_uninit();
purple_dnsquery_uninit();
purple_imgstore_uninit();
purple_network_uninit();
/* The SSL plugins must be uninit before they're unloaded */
purple_ssl_uninit();
purple_debug_info("main", "Unloading all plugins\n");
purple_plugins_destroy_all();
ops = purple_core_get_ui_ops();
if (ops != NULL && ops->quit != NULL)
ops->quit();
/* Everything after this must not try to read any prefs */
purple_prefs_uninit();
purple_plugins_uninit();
#ifdef HAVE_DBUS
purple_dbus_uninit();
#endif
purple_cmds_uninit();
/* Everything after this cannot try to write things to the confdir */
purple_util_uninit();
purple_signals_uninit();
g_free(core->ui);
g_free(core);
#ifdef _WIN32
wpurple_cleanup();
#endif
_core = NULL;
}
static void
gplp_load_base (GOPluginLoader *loader, GOErrorInfo **ret_error)
{
static gchar const *python_file_extensions[] = {"py", "pyc", "pyo", NULL};
GnmPythonPluginLoader *loader_python = GNM_PYTHON_PLUGIN_LOADER (loader);
gchar const **file_ext;
GnmPython *py_object;
GnmPyInterpreter *py_interpreter_info;
gchar *full_module_file_name = NULL;
FILE *f;
GOPlugin *plugin = go_plugin_loader_get_plugin (loader);
GOErrorInfo *open_error = NULL;
PyObject *modules, *main_module, *main_module_dict;
GO_INIT_RET_ERROR_INFO (ret_error);
g_object_set_data (G_OBJECT (plugin), "python-loader", loader);
py_object = gnm_python_object_get (ret_error);
if (py_object == NULL)
return; /* gnm_python_object_get sets ret_error */
py_interpreter_info = gnm_python_new_interpreter (py_object, plugin);
if (py_interpreter_info == NULL) {
*ret_error = go_error_info_new_str (_("Cannot create new Python interpreter."));
gnm_python_clear_error_if_needed (py_object);
g_object_unref (py_object);
return;
}
for (file_ext = python_file_extensions; *file_ext != NULL; file_ext++) {
gchar *file_name = g_strconcat (
loader_python->module_name, ".", *file_ext, NULL);
gchar *path = g_build_filename (
go_plugin_get_dir_name (plugin),
file_name, NULL);
g_free (file_name);
if (g_file_test (path, G_FILE_TEST_EXISTS)) {
full_module_file_name = path;
break;
} else
g_free (path);
}
if (full_module_file_name == NULL) {
*ret_error = go_error_info_new_printf (
_("Module \"%s\" doesn't exist."),
loader_python->module_name);
gnm_python_destroy_interpreter (py_object, py_interpreter_info);
g_object_unref (py_object);
return;
}
f = gnumeric_fopen_error_info (full_module_file_name, "r", &open_error);
g_free (full_module_file_name);
if (f == NULL) {
*ret_error = open_error;
gnm_python_destroy_interpreter (py_object, py_interpreter_info);
g_object_unref (py_object);
return;
}
if (PyRun_SimpleFile (f, loader_python->module_name) != 0) {
(void) fclose (f);
*ret_error = go_error_info_new_printf (
_("Execution of module \"%s\" failed."),
loader_python->module_name);
gnm_python_destroy_interpreter (py_object, py_interpreter_info);
g_object_unref (py_object);
return;
}
(void) fclose (f);
modules = PyImport_GetModuleDict ();
g_return_if_fail (modules != NULL);
main_module = PyDict_GetItemString (modules, (char *) "__main__");
g_return_if_fail (main_module != NULL);
main_module_dict = PyModule_GetDict (main_module);
g_return_if_fail (main_module_dict != NULL);
loader_python->py_object = py_object;
loader_python->py_interpreter_info = py_interpreter_info;
loader_python->main_module = main_module;
loader_python->main_module_dict = main_module_dict;
}
/**
* push_gcm_client_deliver_async:
* @client: (in): A #PushGcmClient.
* @identities: (element-type PushGcmIdentity*): A #GList of #PushGcmIdentity.
* @message: A #PushGcmMessage.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @callback: A #GAsyncReadyCallback.
* @user_data: User data for @callback.
*
* Asynchronously deliver a #PushGcmMessage to one or more GCM enabled
* devices.
*/
void
push_gcm_client_deliver_async (PushGcmClient *client,
GList *identities,
PushGcmMessage *message,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
PushGcmClientPrivate *priv;
GSimpleAsyncResult *simple;
SoupMessage *request;
const gchar *registration_id;
const gchar *collapse_key;
JsonGenerator *g;
JsonObject *obj;
JsonObject *data;
JsonObject *mdata;
JsonArray *ar;
JsonNode *node;
GList *iter;
GList *list;
gchar *str;
gsize length;
guint time_to_live;
ENTRY;
g_return_if_fail(PUSH_IS_GCM_CLIENT(client));
g_return_if_fail(identities);
g_return_if_fail(PUSH_IS_GCM_MESSAGE(message));
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
g_return_if_fail(callback);
priv = client->priv;
request = soup_message_new("POST", PUSH_GCM_CLIENT_URL);
ar = json_array_new();
for (iter = identities; iter; iter = iter->next) {
g_assert(PUSH_IS_GCM_IDENTITY(iter->data));
registration_id = push_gcm_identity_get_registration_id(iter->data);
json_array_add_string_element(ar, registration_id);
}
str = g_strdup_printf("key=%s", priv->auth_token);
soup_message_headers_append(request->request_headers, "Authorization", str);
g_free(str);
soup_message_headers_append(request->request_headers,
"Accept",
"application/json");
data = json_object_new();
if ((collapse_key = push_gcm_message_get_collapse_key(message))) {
json_object_set_string_member(data, "collapse_key", collapse_key);
}
json_object_set_boolean_member(data,
"delay_while_idle",
push_gcm_message_get_delay_while_idle(message));
json_object_set_boolean_member(data,
"dry_run",
push_gcm_message_get_dry_run(message));
if ((time_to_live = push_gcm_message_get_time_to_live(message))) {
json_object_set_int_member(data, "time_to_live", time_to_live);
}
if ((mdata = push_gcm_message_get_data(message))) {
json_object_set_object_member(data, "data", mdata);
}
obj = json_object_new();
json_object_set_array_member(obj, "registration_ids", ar);
json_object_set_object_member(obj, "data", data);
node = json_node_new(JSON_NODE_OBJECT);
json_node_set_object(node, obj);
json_object_unref(obj);
g = json_generator_new();
json_generator_set_pretty(g, TRUE);
json_generator_set_indent(g, 2);
json_generator_set_root(g, node);
str = json_generator_to_data(g, &length);
json_node_free(node);
g_object_unref(g);
soup_message_set_request(request,
"application/json",
SOUP_MEMORY_TAKE,
str,
length);
simple = g_simple_async_result_new(G_OBJECT(client), callback, user_data,
push_gcm_client_deliver_async);
/*
* Keep the list of identities around until we receive our result.
* We need them to key with the resulting array.
*/
list = g_list_copy(identities);
g_list_foreach(list, (GFunc)g_object_ref, NULL);
g_object_set_data_full(G_OBJECT(simple),
"identities",
list,
_push_gcm_identities_free);
soup_session_queue_message(SOUP_SESSION(client),
request,
push_gcm_client_deliver_cb,
simple);
EXIT;
}
void
xcf_init (Gimp *gimp)
{
GimpPlugInProcedure *proc;
GFile *file;
GimpProcedure *procedure;
g_return_if_fail (GIMP_IS_GIMP (gimp));
/* So this is sort of a hack, but its better than it was before. To
* do this right there would be a file load-save handler type and
* the whole interface would change but there isn't, and currently
* the plug-in structure contains all the load-save info, so it
* makes sense to use that for the XCF load/save handlers, even
* though they are internal. The only thing it requires is using a
* PlugInProcDef struct. -josh
*/
/* gimp-xcf-save */
file = g_file_new_for_path ("gimp-xcf-save");
procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, file);
g_object_unref (file);
procedure->proc_type = GIMP_INTERNAL;
procedure->marshal_func = xcf_save_invoker;
proc = GIMP_PLUG_IN_PROCEDURE (procedure);
proc->menu_label = g_strdup (N_("GIMP XCF image"));
gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_ICON_NAME,
(const guint8 *) "gimp-wilber",
strlen ("gimp-wilber") + 1);
gimp_plug_in_procedure_set_image_types (proc, "RGB*, GRAY*, INDEXED*");
gimp_plug_in_procedure_set_file_proc (proc, "xcf", "", NULL);
gimp_plug_in_procedure_set_mime_type (proc, "image/xcf");
gimp_plug_in_procedure_set_handles_uri (proc);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-xcf-save");
gimp_procedure_set_static_strings (procedure,
"gimp-xcf-save",
"Saves file in the .xcf file format",
"The XCF file format has been designed "
"specifically for loading and saving "
"tiled and layered images in GIMP. "
"This procedure will save the specified "
"image in the xcf file format.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("dummy-param",
"Dummy Param",
"Dummy parameter",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_image_id ("image",
"Image",
"Input image",
gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_drawable_id ("drawable",
"Drawable",
"Active drawable of input image",
gimp, TRUE,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filename",
"Filename",
"The name of the file "
"to save the image in, "
"in the on-disk "
"character set and "
"encoding",
TRUE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("raw-filename",
"Raw filename",
"The basename of the "
"file, in UTF-8",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc);
g_object_unref (procedure);
/* gimp-xcf-load */
file = g_file_new_for_path ("gimp-xcf-load");
procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, file);
g_object_unref (file);
procedure->proc_type = GIMP_INTERNAL;
procedure->marshal_func = xcf_load_invoker;
proc = GIMP_PLUG_IN_PROCEDURE (procedure);
proc->menu_label = g_strdup (N_("GIMP XCF image"));
gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_ICON_NAME,
(const guint8 *) "gimp-wilber",
strlen ("gimp-wilber") + 1);
gimp_plug_in_procedure_set_image_types (proc, NULL);
gimp_plug_in_procedure_set_file_proc (proc, "xcf", "",
"0,string,gimp\\040xcf\\040");
gimp_plug_in_procedure_set_mime_type (proc, "image/xcf");
gimp_plug_in_procedure_set_handles_uri (proc);
gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-xcf-load");
gimp_procedure_set_static_strings (procedure,
"gimp-xcf-load",
"Loads file saved in the .xcf file format",
"The XCF file format has been designed "
"specifically for loading and saving "
"tiled and layered images in GIMP. "
"This procedure will load the specified "
"file.",
"Spencer Kimball & Peter Mattis",
"Spencer Kimball & Peter Mattis",
"1995-1996",
NULL);
gimp_procedure_add_argument (procedure,
gimp_param_spec_int32 ("dummy-param",
"Dummy Param",
"Dummy parameter",
G_MININT32, G_MAXINT32, 0,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("filename",
"Filename",
"The name of the file "
"to load, in the "
"on-disk character "
"set and encoding",
TRUE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_argument (procedure,
gimp_param_spec_string ("raw-filename",
"Raw filename",
"The basename of the "
"file, in UTF-8",
FALSE, FALSE, TRUE,
NULL,
GIMP_PARAM_READWRITE));
gimp_procedure_add_return_value (procedure,
gimp_param_spec_image_id ("image",
"Image",
"Output image",
gimp, FALSE,
GIMP_PARAM_READWRITE));
gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc);
g_object_unref (procedure);
}
void custom_completion_provider_populate (GtkSourceCompletionProvider* p, GtkSourceCompletionContext *context) {
g_return_if_fail (IS_CUSTOM_COMPLETION_PROVIDER(p));
CustomCompletionProvider *obj = (CustomCompletionProvider *) p;
METHOD1(obj, 2, Val_GtkSourceCompletionContext(context));
}
static void
gst_dvbsrc_get_property (GObject * _object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstDvbSrc *object;
g_return_if_fail (GST_IS_DVBSRC (_object));
object = GST_DVBSRC (_object);
switch (prop_id) {
case ARG_DVBSRC_ADAPTER:
g_value_set_int (value, object->adapter_number);
break;
case ARG_DVBSRC_FRONTEND:
g_value_set_int (value, object->frontend_number);
break;
case ARG_DVBSRC_FREQUENCY:
g_value_set_uint (value, object->freq);
break;
case ARG_DVBSRC_POLARITY:
if (object->pol == DVB_POL_H)
g_value_set_static_string (value, "H");
else
g_value_set_static_string (value, "V");
break;
case ARG_DVBSRC_SYM_RATE:
g_value_set_uint (value, object->sym_rate);
break;
case ARG_DVBSRC_DISEQC_SRC:
g_value_set_int (value, object->diseqc_src);
break;
case ARG_DVBSRC_BANDWIDTH:
g_value_set_enum (value, object->bandwidth);
break;
case ARG_DVBSRC_CODE_RATE_HP:
g_value_set_enum (value, object->code_rate_hp);
break;
case ARG_DVBSRC_CODE_RATE_LP:
g_value_set_enum (value, object->code_rate_lp);
break;
case ARG_DVBSRC_GUARD:
g_value_set_enum (value, object->guard_interval);
break;
case ARG_DVBSRC_MODULATION:
g_value_set_enum (value, object->modulation);
break;
case ARG_DVBSRC_TRANSMISSION_MODE:
g_value_set_enum (value, object->transmission_mode);
break;
case ARG_DVBSRC_HIERARCHY_INF:
g_value_set_enum (value, object->hierarchy_information);
break;
case ARG_DVBSRC_INVERSION:
g_value_set_enum (value, object->inversion);
break;
case ARG_DVBSRC_STATS_REPORTING_INTERVAL:
g_value_set_uint (value, object->stats_interval);
break;
case ARG_DVBSRC_TIMEOUT:
g_value_set_uint64 (value, object->timeout);
break;
case ARG_DVBSRC_DVB_BUFFER_SIZE:
g_value_set_uint (value, object->dvb_buffer_size);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
void custom_completion_provider_update_info
(GtkSourceCompletionProvider* p, GtkSourceCompletionProposal *proposal, GtkSourceCompletionInfo *info) {
g_return_if_fail (IS_CUSTOM_COMPLETION_PROVIDER(p));
CustomCompletionProvider *obj = (CustomCompletionProvider *) p;
METHOD2(obj, 6, Val_GtkSourceCompletionProposal(proposal), Val_GtkSourceCompletionInfo(info));
}
void weather_page_set_image(WeatherPage *page, gint widget, const gchar *uri)
{
g_return_if_fail(page != NULL && widget >=0 && widget < TOTAL_WIDGETS);
weather_widget_set_image(WEATHER_WIDGET(page->priv->widget[widget]), uri);
}
void custom_undo_manager_end_not_undoable_action (GtkSourceUndoManager* p) {
g_return_if_fail (IS_CUSTOM_UNDO_MANAGER(p));
CustomUndoManager *obj = (CustomUndoManager *) p;
METHOD1(obj, 5, Val_unit);
}
/**
* gimp_session_info_apply_geometry:
* @info:
* @monitor:
* @current_monitor:
*
* Apply the geometry stored in the session info object to the
* associated widget.
**/
void
gimp_session_info_apply_geometry (GimpSessionInfo *info,
GdkMonitor *current_monitor,
gboolean apply_stored_monitor)
{
GdkMonitor *monitor;
GdkRectangle rect;
GdkRectangle work_rect;
GdkGravity gravity;
GdkWindowHints hints;
gint width;
gint height;
g_return_if_fail (GIMP_IS_SESSION_INFO (info));
g_return_if_fail (GTK_IS_WINDOW (info->p->widget));
g_return_if_fail (GDK_IS_MONITOR (current_monitor));
monitor = current_monitor;
if (apply_stored_monitor)
{
GdkDisplay *display = gdk_monitor_get_display (current_monitor);
gint n_monitors;
n_monitors = gdk_display_get_n_monitors (display);
if (info->p->monitor != DEFAULT_MONITOR &&
monitor_number (info->p->monitor) < n_monitors)
{
monitor = info->p->monitor;
}
else
{
monitor = gdk_display_get_primary_monitor (display);
}
}
gdk_monitor_get_geometry (monitor, &rect);
gdk_monitor_get_workarea (monitor, &work_rect);
info->p->x += rect.x;
info->p->y += rect.y;
if (gimp_session_info_get_remember_size (info) &&
info->p->width > 0 &&
info->p->height > 0)
{
width = info->p->width;
height = info->p->height;
}
else
{
GtkRequisition requisition;
gtk_widget_get_preferred_size (info->p->widget, NULL, &requisition);
width = requisition.width;
height = requisition.height;
}
info->p->x = CLAMP (info->p->x,
work_rect.x,
work_rect.x + work_rect.width - width);
info->p->y = CLAMP (info->p->y,
work_rect.y,
work_rect.y + work_rect.height - height);
if (gimp_session_info_get_remember_size (info) &&
info->p->width > 0 &&
info->p->height > 0)
{
/* This used to call gtk_window_set_default_size() which worked
* fine in gtk2 and should continue to work, but doesn't for
* dock windows. gtk_window_resize() seems to work fine for all
* windows. Leave this comment here until we figured what's
* going on...
*
* XXX If we end up updating this code, also do the same to the
* gtk_window_resize() call in gimp_session_info_dialog_show()
* signal handler.
*/
#if 1
gtk_window_resize (GTK_WINDOW (info->p->widget),
info->p->width, info->p->height);
#else
gtk_window_set_default_size (GTK_WINDOW (info->p->widget),
info->p->width, info->p->height);
#endif
}
gtk_window_get_size (GTK_WINDOW (info->p->widget), &width, &height);
gravity = GDK_GRAVITY_NORTH_WEST;
if (info->p->right_align && info->p->bottom_align)
{
gravity = GDK_GRAVITY_SOUTH_EAST;
}
else if (info->p->right_align)
{
gravity = GDK_GRAVITY_NORTH_EAST;
}
else if (info->p->bottom_align)
{
gravity = GDK_GRAVITY_SOUTH_WEST;
}
if (gravity == GDK_GRAVITY_SOUTH_EAST ||
gravity == GDK_GRAVITY_NORTH_EAST)
info->p->x = work_rect.x + work_rect.width - width;
if (gravity == GDK_GRAVITY_SOUTH_WEST ||
gravity == GDK_GRAVITY_SOUTH_EAST)
info->p->y = work_rect.y + work_rect.height - height;
gtk_window_set_gravity (GTK_WINDOW (info->p->widget), gravity);
gtk_window_move (GTK_WINDOW (info->p->widget),
info->p->x, info->p->y);
hints = GDK_HINT_USER_POS;
if (gimp_session_info_get_remember_size (info))
hints |= GDK_HINT_USER_SIZE;
gtk_window_set_geometry_hints (GTK_WINDOW (info->p->widget),
NULL, NULL, hints);
/* Window managers and windowing systems suck. They have their own
* ideas about WM standards and when it's appropriate to honor
* user/application-set window positions and when not. Therefore,
* use brute force and "manually" position dialogs whenever they
* are shown. This is important especially for transient dialogs,
* because window managers behave even "smarter" then...
*/
if (GTK_IS_WINDOW (info->p->widget))
g_signal_connect (info->p->widget, "show",
G_CALLBACK (gimp_session_info_dialog_show),
info);
}
void custom_undo_manager_can_redo_changed (GtkSourceUndoManager* p) {
g_return_if_fail (IS_CUSTOM_UNDO_MANAGER(p));
CustomUndoManager *obj = (CustomUndoManager *) p;
METHOD1(obj, 7, Val_unit);
}
/**
* gimp_number_pair_entry_set_values:
* @entry: A #GimpNumberPairEntry widget.
* @left: Left number in the entry.
* @right: Right number in the entry.
*
* Forces setting the numbers displayed by a #GimpNumberPairEntry,
* ignoring if the user has set his/her own value. The state of
* user-override will not be changed.
*
* Since: 2.4
**/
void
gimp_number_pair_entry_set_values (GimpNumberPairEntry *entry,
gdouble left,
gdouble right)
{
GimpNumberPairEntryPrivate *priv;
GimpAspectType old_aspect;
gdouble old_ratio;
gdouble old_left_number;
gdouble old_right_number;
gboolean numbers_changed = FALSE;
gboolean ratio_changed = FALSE;
g_return_if_fail (GIMP_IS_NUMBER_PAIR_ENTRY (entry));
priv = GIMP_NUMBER_PAIR_ENTRY_GET_PRIVATE (entry);
/* Store current values */
old_left_number = priv->left_number;
old_right_number = priv->right_number;
old_ratio = gimp_number_pair_entry_get_ratio (entry);
old_aspect = gimp_number_pair_entry_get_aspect (entry);
/* Freeze notification */
g_object_freeze_notify (G_OBJECT (entry));
/* Set the new numbers and update the entry */
priv->left_number = left;
priv->right_number = right;
g_object_notify (G_OBJECT (entry), "left-number");
g_object_notify (G_OBJECT (entry), "right-number");
gimp_number_pair_entry_update_text (entry);
/* Find out what has changed */
if (fabs (old_ratio - gimp_number_pair_entry_get_ratio (entry)) > EPSILON)
{
g_object_notify (G_OBJECT (entry), "ratio");
ratio_changed = TRUE;
if (old_aspect != gimp_number_pair_entry_get_aspect (entry))
g_object_notify (G_OBJECT (entry), "aspect");
}
if (old_left_number != priv->left_number ||
old_right_number != priv->right_number)
{
numbers_changed = TRUE;
}
/* Thaw */
g_object_thaw_notify (G_OBJECT (entry));
/* Emit relevant signals */
if (numbers_changed)
g_signal_emit (entry, entry_signals[NUMBERS_CHANGED], 0);
if (ratio_changed)
g_signal_emit (entry, entry_signals[RATIO_CHANGED], 0);
}
/*
* To add a picture in the list -> call a FileSelectionWindow
*/
void Picture_Add_Button_Clicked (GObject *object)
{
GtkWidget *FileSelectionWindow;
GtkFileFilter *filter;
GtkWindow *parent_window = NULL;
static gchar *init_dir = NULL;
gint response;
g_return_if_fail (PictureEntryView != NULL);
parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object)));
if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window)))
{
g_warning("Could not get parent window\n");
return;
}
FileSelectionWindow = gtk_file_chooser_dialog_new(_("Add Images"),
parent_window,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
// Add files filters
// "All files" filter
filter = gtk_file_filter_new ();
gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("All Files"));
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter));
// "PNG and JPEG" filter
filter = gtk_file_filter_new ();
gtk_file_filter_set_name(GTK_FILE_FILTER(filter), _("PNG and JPEG"));
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/jpeg"); // Using mime type avoid problem of case sensitive with extensions
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filter), "image/png");
//gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*.jpeg"); // Warning: *.JPEG or *.JpEg files will not be displayed
//gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*.jpg");
//gtk_file_filter_add_pattern(GTK_FILE_FILTER(filter), "*.png");
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER (FileSelectionWindow), GTK_FILE_FILTER(filter));
// Make this filter the default
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(FileSelectionWindow), GTK_FILE_FILTER(filter));
// Behaviour following the tag type...
switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
{
case MP4_TAG:
{
// Only one file can be selected
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(FileSelectionWindow), FALSE);
break;
}
// Other tag types
default:
{
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(FileSelectionWindow), TRUE);
break;
}
}
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (FileSelectionWindow),
FALSE);
// Starting directory (the same of the current file)
if (ETCore->ETFileDisplayed)
{
gchar *cur_filename_utf8 = ((File_Name *)((GList *)ETCore->ETFileDisplayed->FileNameCur)->data)->value_utf8;
init_dir = g_path_get_dirname(cur_filename_utf8);
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow),init_dir);
}else
// Starting directory (the same than the previous one)
if (init_dir)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow),init_dir);
response = gtk_dialog_run(GTK_DIALOG(FileSelectionWindow));
if (response == GTK_RESPONSE_OK)
{
GtkTreeSelection *selection;
GSList *list;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
gtk_tree_selection_unselect_all(selection);
list = gtk_file_chooser_get_files (GTK_FILE_CHOOSER (FileSelectionWindow));
g_slist_foreach (list, (GFunc) et_picture_load_file, NULL);
g_slist_free_full (list, g_object_unref);
// Save the directory selected for initialize next time
g_free(init_dir);
init_dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(FileSelectionWindow));
}
if (ETCore->ETFileDisplayed)
{
ET_Save_File_Data_From_UI (ETCore->ETFileDisplayed);
ET_Display_File_Data_To_UI (ETCore->ETFileDisplayed);
}
gtk_widget_destroy(FileSelectionWindow);
}
