static void load_dialog_resolution_callback (GimpSizeEntry *res, const gchar *filename) { SvgLoadVals vals = { 0.0, 0, 0 }; load_vals.resolution = vals.resolution = gimp_size_entry_get_refval (res, 0); if (!load_rsvg_size (filename, &vals, NULL)) return; g_signal_handlers_block_by_func (size, load_dialog_size_callback, NULL); gimp_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE); gimp_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE); g_signal_handlers_unblock_by_func (size, load_dialog_size_callback, NULL); if (gimp_size_entry_get_unit (size) != GIMP_UNIT_PIXEL) { ratio_x = gimp_size_entry_get_refval (size, 0) / vals.width; ratio_y = gimp_size_entry_get_refval (size, 1) / vals.height; } svg_width = vals.width; svg_height = vals.height; load_dialog_set_ratio (ratio_x, ratio_y); }
static void print_size_info_size_changed (GtkWidget *widget) { gdouble width; gdouble height; gdouble xres; gdouble yres; gdouble scale; scale = gimp_unit_get_factor (gimp_size_entry_get_unit (info.size_entry)); width = gimp_size_entry_get_value (info.size_entry, WIDTH); height = gimp_size_entry_get_value (info.size_entry, HEIGHT); xres = scale * info.image_width / MAX (0.0001, width); yres = scale * info.image_height / MAX (0.0001, height); print_size_info_set_resolution (&info, xres, yres); info.data->offset_x = gimp_size_entry_get_refval (info.size_entry, LEFT); info.data->offset_y = gimp_size_entry_get_refval (info.size_entry, TOP); print_preview_set_image_offsets (PRINT_PREVIEW (info.preview), info.data->offset_x, info.data->offset_y); }
static void entry_callback (GtkWidget *widget, gpointer data) { static gdouble x = -1.0; static gdouble y = -1.0; gdouble new_x; gdouble new_y; new_x = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); new_y = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); if (gimp_chain_button_get_active (GIMP_CHAIN_BUTTON (data))) { if (new_x != x) { y = new_y = x = new_x; gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 1, y); } if (new_y != y) { x = new_x = y = new_y; gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 0, x); } } else { x = new_x; y = new_y; } }
static void offset_response (GtkWidget *widget, gint response_id, OffsetDialog *dialog) { if (response_id == GTK_RESPONSE_OK) { GimpImage *image = dialog->image; if (image) { GimpDrawable *drawable = gimp_image_get_active_drawable (image); gint offset_x; gint offset_y; offset_x = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (dialog->off_se), 0)); offset_y = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (dialog->off_se), 1)); gimp_drawable_offset (drawable, dialog->context, dialog->fill_type & WRAP_AROUND ? TRUE : FALSE, dialog->fill_type & FILL_MASK, offset_x, offset_y); gimp_image_flush (image); } } gtk_widget_destroy (dialog->dialog); }
static void print_size_info_resolution_changed (GtkWidget *widget) { GimpSizeEntry *entry = info.resolution_entry; gdouble xres = gimp_size_entry_get_refval (entry, 0); gdouble yres = gimp_size_entry_get_refval (entry, 1); print_size_info_set_resolution (&info, xres, yres); }
/* * CenterFrame entry callback */ static void nova_center_coords_update (GimpSizeEntry *coords, NovaCenter *center) { pvals.xcenter = gimp_size_entry_get_refval (coords, 0); pvals.ycenter = gimp_size_entry_get_refval (coords, 1); gimp_preview_invalidate (center->preview); }
static void update_values (void) { GtkWidget *entry; entry = g_object_get_data (G_OBJECT (main_dialog), "width"); grid_cfg.hwidth = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 0)); grid_cfg.vwidth = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 1)); grid_cfg.iwidth = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 2)); entry = g_object_get_data (G_OBJECT (main_dialog), "space"); grid_cfg.hspace = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 0)); grid_cfg.vspace = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 1)); grid_cfg.ispace = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 2)); entry = g_object_get_data (G_OBJECT (main_dialog), "offset"); grid_cfg.hoffset = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 0)); grid_cfg.voffset = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 1)); grid_cfg.ioffset = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 2)); }
static void change_radius_callback (GtkWidget *coord, gpointer data) { GimpPreview *preview = GIMP_PREVIEW (data); dogvals.inner = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 0); dogvals.outer = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 1); gimp_preview_invalidate (preview); }
static void update_pixelsize (GimpSizeEntry *sizeentry, GimpPreview *preview) { pvals.pixelwidth = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (sizeentry), 0); pvals.pixelheight = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (sizeentry), 1); gimp_preview_invalidate (preview); }
static void gimp_coordinates_chainbutton_toggled (GimpChainButton *button, GimpSizeEntry *entry) { if (gimp_chain_button_get_active (button)) { GimpCoordinatesData *data; data = g_object_get_data (G_OBJECT (entry), "coordinates-data"); data->orig_x = gimp_size_entry_get_refval (entry, 0); data->orig_y = gimp_size_entry_get_refval (entry, 1); } }
static void gimp_text_style_editor_size_changed (GimpSizeEntry *entry, GimpTextStyleEditor *editor) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (editor->buffer); GList *insert_tags; GList *remove_tags; if (gtk_text_buffer_get_has_selection (buffer)) { GtkTextIter start, end; gdouble points; gtk_text_buffer_get_selection_bounds (buffer, &start, &end); points = gimp_units_to_points (gimp_size_entry_get_refval (entry, 0), GIMP_UNIT_PIXEL, editor->resolution_y); gimp_text_buffer_set_size (editor->buffer, &start, &end, PANGO_SCALE * points); } insert_tags = gimp_text_style_editor_list_tags (editor, &remove_tags); gimp_text_buffer_set_insert_tags (editor->buffer, insert_tags, remove_tags); }
static void shift_amount_callback (GtkWidget *widget, gpointer data) { GimpPreview *preview = GIMP_PREVIEW (data); shvals.shift_amount = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); gimp_preview_invalidate (preview); }
static void load_dialog_size_callback (GtkWidget *widget, gpointer data) { if (gimp_chain_button_get_active (GIMP_CHAIN_BUTTON (constrain))) { gdouble x = gimp_size_entry_get_refval (size, 0) / (gdouble) wmf_width; gdouble y = gimp_size_entry_get_refval (size, 1) / (gdouble) wmf_height; if (x != ratio_x) { load_dialog_set_ratio (x, x); } else if (y != ratio_y) { load_dialog_set_ratio (y, y); } } }
static void spread_preview_update (GimpPreview *preview, GtkWidget *size) { GimpDrawable *drawable; SpreadParam_t param; gint x, y, bpp; guchar *buffer, *dest; gint x_off, y_off; gint width, height; drawable = gimp_drawable_preview_get_drawable (GIMP_DRAWABLE_PREVIEW (preview)); param.pft = gimp_pixel_fetcher_new (drawable, FALSE); param.gr = g_rand_new (); param.x_amount = (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (size), 0) + 1) / 2; param.y_amount = (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (size), 1) + 1) / 2; param.width = drawable->width; param.height = drawable->height; gimp_preview_get_size (preview, &width, &height); bpp = drawable->bpp; dest = buffer = g_new (guchar, width * height * bpp); gimp_preview_get_position (preview, &x_off, &y_off); for (y = 0 ; y < height ; y++) for (x = 0 ; x < width ; x++) { spread_func (x + x_off, y + y_off, dest, bpp, ¶m); dest += bpp; } gimp_preview_draw_buffer (preview, buffer, width * bpp); g_free (buffer); g_rand_free (param.gr); }
static void rotate_center_changed (GtkWidget *widget, GimpTransformTool *tr_tool) { gdouble px = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); gdouble py = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); if ((px != tr_tool->trans_info[PIVOT_X]) || (py != tr_tool->trans_info[PIVOT_Y])) { gimp_draw_tool_pause (GIMP_DRAW_TOOL (tr_tool)); tr_tool->trans_info[PIVOT_X] = px; tr_tool->trans_info[PIVOT_Y] = py; tr_tool->px = px; tr_tool->py = py; gimp_transform_tool_push_internal_undo (tr_tool); gimp_transform_tool_recalc_matrix (tr_tool); gimp_draw_tool_resume (GIMP_DRAW_TOOL (tr_tool)); } }
static void load_dialog_resolution_callback (GimpSizeEntry *res, const gchar *filename) { WmfLoadVals vals = { 0.0, 0, 0 }; load_vals.resolution = vals.resolution = gimp_size_entry_get_refval (res, 0); if (!load_wmf_size (filename, &vals)) return; wmf_width = vals.width; wmf_height = vals.height; load_dialog_set_ratio (ratio_x, ratio_y); }
static void gimp_text_style_editor_size_changed (GimpSizeEntry *entry, GimpTextStyleEditor *editor) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (editor->buffer); GtkTextIter start, end; gdouble points; if (! gtk_text_buffer_get_selection_bounds (buffer, &start, &end)) { return; } points = gimp_units_to_points (gimp_size_entry_get_refval (entry, 0), GIMP_UNIT_PIXEL, editor->resolution_y); gimp_text_buffer_set_size (editor->buffer, &start, &end, PANGO_SCALE * points); }
static void size_query_box_response (GtkWidget *widget, gint response_id, QueryBox *query_box) { gdouble size; GimpUnit unit; query_box_disconnect (query_box); /* Get the sizeentry data */ size = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (query_box->entry), 0); unit = gimp_size_entry_get_unit (GIMP_SIZE_ENTRY (query_box->entry)); /* Call the user defined callback */ if (response_id == GTK_RESPONSE_OK) (* (GimpQuerySizeCallback) query_box->callback) (query_box->qbox, size, unit, query_box->callback_data); query_box_destroy (query_box); }
static gboolean spread_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *frame; GtkWidget *size; GimpUnit unit; gdouble xres; gdouble yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Spread"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); frame = gimp_frame_new (_("Spread Amount")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* Get the image resolution and unit */ gimp_image_get_resolution (image_ID, &xres, &yres); unit = gimp_image_get_unit (image_ID); /* sizeentries */ size = gimp_coordinates_new (unit, "%a", TRUE, FALSE, -1, GIMP_SIZE_ENTRY_UPDATE_SIZE, spvals.spread_amount_x == spvals.spread_amount_y, FALSE, _("_Horizontal:"), spvals.spread_amount_x, xres, 0, MAX (drawable->width, drawable->height), 0, 0, _("_Vertical:"), spvals.spread_amount_y, yres, 0, MAX (drawable->width, drawable->height), 0, 0); gtk_container_add (GTK_CONTAINER (frame), size); gtk_widget_show (size); g_signal_connect (preview, "invalidated", G_CALLBACK (spread_preview_update), size); g_signal_connect_swapped (size, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); spread_preview_update (GIMP_PREVIEW (preview), size); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { spvals.spread_amount_x = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (size), 0); spvals.spread_amount_y = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (size), 1); } gtk_widget_destroy (dialog); return run; }
static gboolean tile_dialog (gint32 image_ID, gint32 drawable_ID) { GtkWidget *dlg; GtkWidget *vbox; GtkWidget *frame; GtkWidget *sizeentry; GtkWidget *chainbutton; GtkWidget *toggle; gint width; gint height; gdouble xres; gdouble yres; GimpUnit unit; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); width = gimp_drawable_width (drawable_ID); height = gimp_drawable_height (drawable_ID); unit = gimp_image_get_unit (image_ID); gimp_image_get_resolution (image_ID, &xres, &yres); tvals.new_width = width; tvals.new_height = height; dlg = gimp_dialog_new (_("Tile"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); frame = gimp_frame_new (_("Tile to New Size")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); sizeentry = gimp_coordinates_new (unit, "%a", TRUE, TRUE, 8, GIMP_SIZE_ENTRY_UPDATE_SIZE, tvals.constrain, TRUE, _("_Width:"), width, xres, 1, GIMP_MAX_IMAGE_SIZE, 0, width, _("_Height:"), height, yres, 1, GIMP_MAX_IMAGE_SIZE, 0, height); gtk_container_add (GTK_CONTAINER (frame), sizeentry); gtk_table_set_row_spacing (GTK_TABLE (sizeentry), 1, 6); gtk_widget_show (sizeentry); chainbutton = GTK_WIDGET (GIMP_COORDINATES_CHAINBUTTON (sizeentry)); toggle = gtk_check_button_new_with_mnemonic (_("C_reate new image")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), tvals.new_image); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &tvals.new_image); gtk_widget_show (dlg); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); if (run) { tvals.new_width = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (sizeentry), 0)); tvals.new_height = RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (sizeentry), 1)); tvals.constrain = gimp_chain_button_get_active (GIMP_CHAIN_BUTTON (chainbutton)); } gtk_widget_destroy (dlg); return run; }
static void gimp_coordinates_callback (GtkWidget *widget, GimpCoordinatesData *data) { gdouble new_x; gdouble new_y; new_x = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); new_y = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); if (gimp_chain_button_get_active (data->chainbutton)) { if (data->chain_constrains_ratio) { if ((data->orig_x != 0) && (data->orig_y != 0)) { if (ROUND (new_x) != ROUND (data->last_x)) { data->last_x = new_x; new_y = (new_x * data->orig_y) / data->orig_x; gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 1, new_y); data->last_y = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); } else if (ROUND (new_y) != ROUND (data->last_y)) { data->last_y = new_y; new_x = (new_y * data->orig_x) / data->orig_y; gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 0, new_x); data->last_x = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); } } } else { if (new_x != data->last_x) { new_y = new_x; gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 1, new_x); data->last_y = data->last_x = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 1); } else if (new_y != data->last_y) { new_x = new_y; gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (widget), 0, new_y); data->last_x = data->last_y = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (widget), 0); } } } else { if (new_x != data->last_x) data->last_x = new_x; if (new_y != data->last_y) data->last_y = new_y; } }
static gint dog_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *button; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *coord; GimpUnit unit; gdouble xres; gdouble yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("DoG Edge Detect"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview); gtk_widget_show (preview); g_signal_connect (preview, "invalidated", G_CALLBACK (preview_update_preview), drawable); frame = gimp_frame_new (_("Smoothing Parameters")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* Get the image resolution and unit */ gimp_image_get_resolution (image_ID, &xres, &yres); unit = gimp_image_get_unit (image_ID); coord = gimp_coordinates_new (unit, "%a", TRUE, FALSE, -1, GIMP_SIZE_ENTRY_UPDATE_SIZE, FALSE, TRUE, _("_Radius 1:"), dogvals.inner, xres, 0, 8 * MAX (drawable->width, drawable->height), 0, 0, _("R_adius 2:"), dogvals.outer, yres, 0, 8 * MAX (drawable->width, drawable->height), 0, 0); gtk_container_add (GTK_CONTAINER (frame), coord); gtk_widget_show (coord); gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (coord), 1); g_signal_connect (coord, "value-changed", G_CALLBACK (change_radius_callback), preview); button = gtk_check_button_new_with_mnemonic (_("_Normalize")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dogvals.normalize); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dogvals.normalize); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (button); button = gtk_check_button_new_with_mnemonic (_("_Invert")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dogvals.invert); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dogvals.invert); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (button); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { dogvals.inner = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 0); dogvals.outer = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 1); } gtk_widget_destroy (dialog); return run; }
static gboolean load_dialog (const gchar *filename) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *image; GtkWidget *table; GtkWidget *table2; GtkWidget *abox; GtkWidget *res; GtkWidget *label; GtkWidget *spinbutton; GtkObject *adj; guchar *pixels; gboolean run = FALSE; WmfLoadVals vals = { WMF_DEFAULT_RESOLUTION, - WMF_PREVIEW_SIZE, - WMF_PREVIEW_SIZE }; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Render Windows Metafile"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, LOAD_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); /* The WMF preview */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (abox), frame); gtk_widget_show (frame); pixels = wmf_get_pixbuf (filename, &vals.width, &vals.height); image = gimp_preview_area_new (); gtk_widget_set_size_request (image, vals.width, vals.height); gtk_container_add (GTK_CONTAINER (frame), image); gtk_widget_show (image); g_signal_connect (image, "size-allocate", G_CALLBACK (wmf_preview_callback), pixels); size_label = gtk_label_new (NULL); gtk_label_set_justify (GTK_LABEL (size_label), GTK_JUSTIFY_CENTER); gtk_misc_set_alignment (GTK_MISC (size_label), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (vbox), size_label, TRUE, TRUE, 4); gtk_widget_show (size_label); /* query the initial size after the size label is created */ vals.resolution = load_vals.resolution; load_wmf_size (filename, &vals); wmf_width = vals.width; wmf_height = vals.height; table = gtk_table_new (7, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2); gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0); gtk_widget_show (table); /* Width and Height */ label = gtk_label_new (_("Width:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); label = gtk_label_new (_("Height:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); size = GIMP_SIZE_ENTRY (gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE)); gtk_table_set_col_spacing (GTK_TABLE (size), 1, 6); gimp_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL); gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0); gtk_widget_show (GTK_WIDGET (size)); gimp_size_entry_set_refval_boundaries (size, 0, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval_boundaries (size, 1, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval (size, 0, wmf_width); gimp_size_entry_set_refval (size, 1, wmf_height); gimp_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE); gimp_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE); g_signal_connect (size, "value-changed", G_CALLBACK (load_dialog_size_callback), NULL); /* Scale ratio */ hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); table2 = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table2), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table2), 0, 4); gtk_box_pack_start (GTK_BOX (hbox), table2, FALSE, FALSE, 0); spinbutton = gimp_spin_button_new (&xadj, ratio_x, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_width, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_width, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1); gtk_widget_show (spinbutton); g_signal_connect (xadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_X ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&yadj, ratio_y, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) wmf_height, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) wmf_height, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2); gtk_widget_show (spinbutton); g_signal_connect (yadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_Y ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); /* the constrain ratio chainbutton */ constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (constrain), TRUE); gtk_table_attach_defaults (GTK_TABLE (table2), constrain, 1, 2, 0, 2); gtk_widget_show (constrain); gimp_help_set_help_data (GIMP_CHAIN_BUTTON (constrain)->button, _("Constrain aspect ratio"), NULL); gtk_widget_show (table2); /* Resolution */ label = gtk_label_new (_("Resolution:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"), FALSE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); gtk_table_set_col_spacing (GTK_TABLE (res), 1, 6); gtk_table_attach (GTK_TABLE (table), res, 1, 2, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (res); /* don't let the resolution become too small ? does libwmf tend to crash with very small resolutions */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (res), 0, 5.0, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (res), 0, load_vals.resolution); g_signal_connect (res, "value-changed", G_CALLBACK (load_dialog_resolution_callback), (gpointer) filename); gtk_widget_show (dialog); if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK) { load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0)); load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1)); run = TRUE; } gtk_widget_destroy (GTK_WIDGET (dialog)); return run; }
static void mblur_center_update (GimpSizeEntry *entry) { mbvals.center_x = gimp_size_entry_get_refval (entry, 0); mbvals.center_y = gimp_size_entry_get_refval (entry, 1); }
static void print_size_info_set_resolution (PrintSizeInfo *info, gdouble xres, gdouble yres) { PrintData *data = info->data; gdouble offset_x; gdouble offset_y; gdouble offset_x_max; gdouble offset_y_max; if (info->chain && gimp_chain_button_get_active (info->chain)) { if (xres != data->xres) yres = xres; else xres = yres; } data->xres = xres; data->yres = yres; g_signal_handlers_block_by_func (info->resolution_entry, print_size_info_resolution_changed, NULL); gimp_size_entry_set_refval (info->resolution_entry, 0, xres); gimp_size_entry_set_refval (info->resolution_entry, 1, yres); g_signal_handlers_unblock_by_func (info->resolution_entry, print_size_info_resolution_changed, NULL); g_signal_handlers_block_by_func (info->size_entry, print_size_info_size_changed, NULL); gimp_size_entry_set_value (info->size_entry, WIDTH, info->image_width * gimp_unit_get_factor (data->unit) / xres); gimp_size_entry_set_value (info->size_entry, HEIGHT, info->image_height * gimp_unit_get_factor (data->unit) / yres); g_signal_handlers_unblock_by_func (info->size_entry, print_size_info_size_changed, NULL); gimp_size_info_get_max_offsets (&offset_x_max, &offset_y_max); offset_x = gimp_size_entry_get_refval (info->size_entry, LEFT); offset_y = gimp_size_entry_get_refval (info->size_entry, TOP); offset_x = CLAMP (offset_x, 0, offset_x_max); offset_y = CLAMP (offset_y, 0, offset_y_max); data->offset_x = offset_x; data->offset_y = offset_y; print_size_info_update_offsets (); print_preview_set_image_dpi (PRINT_PREVIEW (info->preview), data->xres, data->yres); print_preview_set_image_offsets (PRINT_PREVIEW (info->preview), data->offset_x, data->offset_y); print_preview_set_image_offsets_max (PRINT_PREVIEW (info->preview), offset_x_max, offset_y_max); }
/** * resolution_calibrate_dialog: * @resolution_entry: a #GimpSizeEntry to connect the dialog to * @pixbuf: an optional #GdkPixbuf for the upper left corner * * Displays a dialog that allows the user to interactively determine * her monitor resolution. This dialog runs it's own GTK main loop and * is connected to a #GimpSizeEntry handling the resolution to be set. **/ void resolution_calibrate_dialog (GtkWidget *resolution_entry, GdkPixbuf *pixbuf) { GtkWidget *dialog; GtkWidget *table; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *ruler; GtkWidget *label; GdkScreen *screen; GdkRectangle rect; gint monitor; g_return_if_fail (GIMP_IS_SIZE_ENTRY (resolution_entry)); g_return_if_fail (GTK_WIDGET_REALIZED (resolution_entry)); g_return_if_fail (pixbuf == NULL || GDK_IS_PIXBUF (pixbuf)); /* this dialog can only exist once */ if (calibrate_entry) return; dialog = gimp_dialog_new (_("Calibrate Monitor Resolution"), "gimp-resolution-calibration", gtk_widget_get_toplevel (resolution_entry), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); screen = gtk_widget_get_screen (dialog); monitor = gdk_screen_get_monitor_at_window (screen, resolution_entry->window); gdk_screen_get_monitor_geometry (screen, monitor, &rect); ruler_width = rect.width - 300 - (rect.width % 100); ruler_height = rect.height - 300 - (rect.height % 100); table = gtk_table_new (4, 4, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), table); gtk_widget_show (table); if (pixbuf) { GtkWidget *image = gtk_image_new_from_pixbuf (pixbuf); gtk_table_attach (GTK_TABLE (table), image, 0, 1, 0, 1, GTK_SHRINK, GTK_SHRINK, 4, 4); gtk_widget_show (image); } ruler = gimp_ruler_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_size_request (ruler, ruler_width, 32); gimp_ruler_set_range (GIMP_RULER (ruler), 0, ruler_width, ruler_width); gtk_table_attach (GTK_TABLE (table), ruler, 1, 3, 0, 1, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (ruler); ruler = gimp_ruler_new (GTK_ORIENTATION_VERTICAL); gtk_widget_set_size_request (ruler, 32, ruler_height); gimp_ruler_set_range (GIMP_RULER (ruler), 0, ruler_height, ruler_height); gtk_table_attach (GTK_TABLE (table), ruler, 0, 1, 1, 3, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (ruler); vbox = gtk_vbox_new (FALSE, 12); gtk_table_attach (GTK_TABLE (table), vbox, 1, 2, 1, 2, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_widget_show (vbox); label = gtk_label_new (_("Measure the rulers and enter their lengths:")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_SCALE, PANGO_SCALE_LARGE, PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD, -1); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); calibrate_xres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (resolution_entry), 0); calibrate_yres = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (resolution_entry), 1); calibrate_entry = gimp_coordinates_new (GIMP_UNIT_INCH, "%p", FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE, FALSE, FALSE, _("_Horizontal:"), ruler_width, calibrate_xres, 1, GIMP_MAX_IMAGE_SIZE, 0, 0, _("_Vertical:"), ruler_height, calibrate_yres, 1, GIMP_MAX_IMAGE_SIZE, 0, 0); gtk_widget_hide (GTK_WIDGET (GIMP_COORDINATES_CHAINBUTTON (calibrate_entry))); g_signal_connect (dialog, "destroy", G_CALLBACK (gtk_widget_destroyed), &calibrate_entry); gtk_box_pack_end (GTK_BOX (hbox), calibrate_entry, FALSE, FALSE, 0); gtk_widget_show (calibrate_entry); gtk_widget_show (dialog); switch (gimp_dialog_run (GIMP_DIALOG (dialog))) { case GTK_RESPONSE_OK: { GtkWidget *chain_button; gdouble x, y; x = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (calibrate_entry), 0); y = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (calibrate_entry), 1); calibrate_xres = (gdouble) ruler_width * calibrate_xres / x; calibrate_yres = (gdouble) ruler_height * calibrate_yres / y; chain_button = GIMP_COORDINATES_CHAINBUTTON (resolution_entry); if (ABS (x - y) > GIMP_MIN_RESOLUTION) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), FALSE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (resolution_entry), 0, calibrate_xres); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (resolution_entry), 1, calibrate_yres); } default: break; } gtk_widget_destroy (dialog); }
static GimpPDBStatusType load_dialog (const gchar *filename, GError **load_error) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *image; GdkPixbuf *preview; GtkWidget *table; GtkWidget *table2; GtkWidget *abox; GtkWidget *res; GtkWidget *label; GtkWidget *spinbutton; GtkWidget *toggle; GtkWidget *toggle2; GtkObject *adj; gboolean run; GError *error = NULL; SvgLoadVals vals = { SVG_DEFAULT_RESOLUTION, - SVG_PREVIEW_SIZE, - SVG_PREVIEW_SIZE }; preview = load_rsvg_pixbuf (filename, &vals, &error); if (! preview) { /* Do not rely on librsvg setting GError on failure! */ g_set_error (load_error, error ? error->domain : 0, error ? error->code : 0, _("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (filename), error ? error->message : _("Unknown reason")); g_clear_error (&error); return GIMP_PDB_EXECUTION_ERROR; } gimp_ui_init (PLUG_IN_BINARY, FALSE); /* Scalable Vector Graphics is SVG, should perhaps not be translated */ dialog = gimp_dialog_new (_("Render Scalable Vector Graphics"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, LOAD_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); /* The SVG preview */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (abox), frame); gtk_widget_show (frame); image = gtk_image_new_from_pixbuf (preview); gtk_container_add (GTK_CONTAINER (frame), image); gtk_widget_show (image); size_label = gtk_label_new (NULL); gtk_label_set_justify (GTK_LABEL (size_label), GTK_JUSTIFY_CENTER); gtk_misc_set_alignment (GTK_MISC (size_label), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (vbox), size_label, TRUE, TRUE, 4); gtk_widget_show (size_label); /* query the initial size after the size label is created */ vals.resolution = load_vals.resolution; load_rsvg_size (filename, &vals, NULL); svg_width = vals.width; svg_height = vals.height; table = gtk_table_new (7, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2); gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0); gtk_widget_show (table); /* Width and Height */ label = gtk_label_new (_("Width:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); label = gtk_label_new (_("Height:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); size = GIMP_SIZE_ENTRY (gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE)); gtk_table_set_col_spacing (GTK_TABLE (size), 1, 6); gimp_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL); gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0); gtk_widget_show (GTK_WIDGET (size)); gimp_size_entry_set_refval_boundaries (size, 0, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval_boundaries (size, 1, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval (size, 0, svg_width); gimp_size_entry_set_refval (size, 1, svg_height); gimp_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE); gimp_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE); g_signal_connect (size, "value-changed", G_CALLBACK (load_dialog_size_callback), NULL); /* Scale ratio */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); table2 = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table2), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table2), 0, 4); gtk_box_pack_start (GTK_BOX (hbox), table2, FALSE, FALSE, 0); spinbutton = gimp_spin_button_new (&xadj, ratio_x, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) svg_width, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) svg_width, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1); gtk_widget_show (spinbutton); g_signal_connect (xadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_X ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&yadj, ratio_y, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) svg_height, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) svg_height, 0.01, 0.1, 0, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2); gtk_widget_show (spinbutton); g_signal_connect (yadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_Y ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); /* the constrain ratio chainbutton */ constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (constrain), TRUE); gtk_table_attach_defaults (GTK_TABLE (table2), constrain, 1, 2, 0, 2); gtk_widget_show (constrain); gimp_help_set_help_data (GIMP_CHAIN_BUTTON (constrain)->button, _("Constrain aspect ratio"), NULL); gtk_widget_show (table2); /* Resolution */ label = gtk_label_new (_("Resolution:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"), FALSE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); gtk_table_set_col_spacing (GTK_TABLE (res), 1, 6); gtk_table_attach (GTK_TABLE (table), res, 1, 2, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (res); /* don't let the resolution become too small, librsvg tends to crash with very small resolutions */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (res), 0, 5.0, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (res), 0, load_vals.resolution); g_signal_connect (res, "value-changed", G_CALLBACK (load_dialog_resolution_callback), (gpointer) filename); /* Path Import */ toggle = gtk_check_button_new_with_mnemonic (_("Import _paths")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), load_vals.import); gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 5, 6, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("Import path elements of the SVG so they " "can be used with the GIMP path tool"), NULL); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &load_vals.import); toggle2 = gtk_check_button_new_with_mnemonic (_("Merge imported paths")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle2), load_vals.merge); gtk_table_attach (GTK_TABLE (table), toggle2, 0, 2, 6, 7, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (toggle2); g_signal_connect (toggle2, "toggled", G_CALLBACK (gimp_toggle_button_update), &load_vals.merge); g_object_bind_property (toggle, "active", toggle2, "sensitive", G_BINDING_SYNC_CREATE); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0)); load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1)); } gtk_widget_destroy (dialog); return run ? GIMP_PDB_SUCCESS : GIMP_PDB_CANCEL; }
GList * gimp_text_style_editor_list_tags (GimpTextStyleEditor *editor, GList **remove_tags) { GList *toggles; GList *tags = NULL; g_return_val_if_fail (GIMP_IS_TEXT_STYLE_EDITOR (editor), NULL); g_return_val_if_fail (remove_tags != NULL, NULL); *remove_tags = NULL; for (toggles = editor->toggles; toggles; toggles = g_list_next (toggles)) { GtkTextTag *tag = g_object_get_data (toggles->data, "tag"); if (gtk_toggle_button_get_active (toggles->data)) { tags = g_list_prepend (tags, tag); } else { *remove_tags = g_list_prepend (*remove_tags, tag); } } { GtkTextTag *tag; GList *list; gdouble pixels; gdouble points; for (list = editor->buffer->size_tags; list; list = g_list_next (list)) *remove_tags = g_list_prepend (*remove_tags, list->data); pixels = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (editor->size_entry), 0); points = gimp_units_to_points (pixels, GIMP_UNIT_PIXEL, editor->resolution_y); tag = gimp_text_buffer_get_size_tag (editor->buffer, PANGO_SCALE * points); tags = g_list_prepend (tags, tag); } { GtkTextTag *tag; GList *list; const gchar *font_name; for (list = editor->buffer->font_tags; list; list = g_list_next (list)) *remove_tags = g_list_prepend (*remove_tags, list->data); font_name = gimp_context_get_font_name (editor->context); tag = gimp_text_buffer_get_font_tag (editor->buffer, font_name); tags = g_list_prepend (tags, tag); } { GtkTextTag *tag; GList *list; GimpRGB color; for (list = editor->buffer->color_tags; list; list = g_list_next (list)) *remove_tags = g_list_prepend (*remove_tags, list->data); gimp_color_button_get_color (GIMP_COLOR_BUTTON (editor->color_button), &color); tag = gimp_text_buffer_get_color_tag (editor->buffer, &color); tags = g_list_prepend (tags, tag); } *remove_tags = g_list_reverse (*remove_tags); return g_list_reverse (tags); }