/* * 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); }