static gboolean nova_center_update (GtkWidget *widget, NovaCenter *center, gint x, gint y) { gint tx, ty; gimp_preview_untransform (center->preview, x, y, &tx, &ty); nova_center_cursor_draw (center); g_signal_handlers_block_by_func (center->coords, nova_center_coords_update, center); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (center->coords), 0, tx); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (center->coords), 1, ty); g_signal_handlers_unblock_by_func (center->coords, nova_center_coords_update, center); nova_center_coords_update (GIMP_SIZE_ENTRY (center->coords), center); return TRUE; }
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 nova_center_update (GtkWidget *widget, NovaCenter *center, gint x, gint y) { gint tx, ty; GimpPreviewArea *area = GIMP_PREVIEW_AREA (center->preview->area); GtkAllocation allocation; gtk_widget_get_allocation (GTK_WIDGET (area), &allocation); x -= (allocation.width - area->width) / 2; y -= (allocation.height - area->height) / 2; gimp_preview_untransform (center->preview, x, y, &tx, &ty); g_signal_handlers_block_by_func (center->coords, nova_center_coords_update, center); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (center->coords), 0, tx); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (center->coords), 1, ty); g_signal_handlers_unblock_by_func (center->coords, nova_center_coords_update, center); nova_center_coords_update (GIMP_SIZE_ENTRY (center->coords), center); gtk_widget_queue_draw (center->preview->area); }
static void print_size_info_update_offsets (void) { PrintData *data = info.data; gdouble offset_x_max; gdouble offset_y_max; gimp_size_info_get_max_offsets (&offset_x_max, &offset_y_max); g_signal_handlers_block_by_func (info.size_entry, print_size_info_size_changed, NULL); print_size_info_center_none_block (); gimp_size_entry_set_refval_boundaries (info.size_entry, LEFT, 0, offset_x_max); gimp_size_entry_set_refval_boundaries (info.size_entry, RIGHT, 0, offset_x_max); gimp_size_entry_set_refval_boundaries (info.size_entry, TOP, 0, offset_y_max); gimp_size_entry_set_refval_boundaries (info.size_entry, BOTTOM, 0, offset_y_max); switch (data->center) { case CENTER_NONE: break; case CENTER_HORIZONTALLY: data->offset_x = offset_x_max / 2.0; break; case CENTER_VERTICALLY: data->offset_y = offset_y_max / 2.0; break; case CENTER_BOTH: data->offset_x = offset_x_max / 2.0; data->offset_y = offset_y_max / 2.0; break; } gimp_size_entry_set_refval (info.size_entry, LEFT, data->offset_x); gimp_size_entry_set_refval (info.size_entry, RIGHT, offset_x_max - data->offset_x); gimp_size_entry_set_refval (info.size_entry, TOP, info.data->offset_y); gimp_size_entry_set_refval (info.size_entry, BOTTOM, offset_y_max - data->offset_y); print_size_info_center_none_unblock (); g_signal_handlers_unblock_by_func (info.size_entry, print_size_info_size_changed, NULL); }
static void offset_half_xy_callback (GtkWidget *widget, OffsetDialog *dialog) { GimpImage *image = dialog->image; if (image) { GimpItem *item = GIMP_ITEM (gimp_image_get_active_drawable (image)); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (dialog->off_se), 0, gimp_item_get_width (item) / 2); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (dialog->off_se), 1, gimp_item_get_height (item) / 2); } }
static void gimp_text_style_editor_set_size (GimpTextStyleEditor *editor, GtkTextTag *size_tag) { gint size = 0; gdouble pixels; if (size_tag) size = gimp_text_tag_get_size (size_tag); g_signal_handlers_block_by_func (editor->size_entry, gimp_text_style_editor_size_changed, editor); pixels = gimp_units_to_pixels ((gdouble) size / PANGO_SCALE, GIMP_UNIT_POINT, editor->resolution_y); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (editor->size_entry), 0, pixels); if (size == 0) { GtkWidget *spinbutton; spinbutton = gimp_size_entry_get_help_widget (GIMP_SIZE_ENTRY (editor->size_entry), 0); gtk_entry_set_text (GTK_ENTRY (spinbutton), ""); } g_signal_handlers_unblock_by_func (editor->size_entry, gimp_text_style_editor_size_changed, editor); }
/** * gimp_query_size_box: * @title: The query box dialog's title. * @parent: The dialog's parent widget. * @help_func: The help function to show this dialog's help page. * @help_id: A string identifying this dialog's help page. * @message: A string which will be shown above the dialog's entry widget. * @initial: The initial value. * @lower: The lower boundary of the range of possible values. * @upper: The upper boundray of the range of possible values. * @digits: The number of decimal digits the #GimpSizeEntry provide in * "pixel" mode. * @unit: The unit initially shown by the #GimpUnitMenu. * @resolution: The resolution (in dpi) which will be used for pixel/unit * calculations. * @dot_for_dot: %TRUE if the #GimpUnitMenu's initial unit should be "pixels". * @object: The object this query box is associated with. * @signal: The object's signal which will cause the query box * to be closed. * @callback: The function which will be called when the user selects "OK". * @data: The callback's user data. * * Creates a new #GtkDialog that queries the user for a size using a * #GimpSizeEntry. * * Returns: A pointer to the new #GtkDialog. **/ GtkWidget * gimp_query_size_box (const gchar *title, GtkWidget *parent, GimpHelpFunc help_func, const gchar *help_id, const gchar *message, gdouble initial, gdouble lower, gdouble upper, gint digits, GimpUnit unit, gdouble resolution, gboolean dot_for_dot, GObject *object, const gchar *signal, GimpQuerySizeCallback callback, gpointer data) { QueryBox *query_box; GtkWidget *sizeentry; GtkWidget *spinbutton; query_box = create_query_box (title, parent, help_func, help_id, G_CALLBACK (size_query_box_response), "dialog-question", message, GTK_STOCK_OK, GTK_STOCK_CANCEL, object, signal, G_CALLBACK (callback), data); if (! query_box) return NULL; sizeentry = gimp_size_entry_new (1, unit, "%p", TRUE, FALSE, FALSE, 12, GIMP_SIZE_ENTRY_UPDATE_SIZE); if (dot_for_dot) gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (sizeentry), GIMP_UNIT_PIXEL); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (sizeentry), 0, resolution, FALSE); gimp_size_entry_set_refval_digits (GIMP_SIZE_ENTRY (sizeentry), 0, digits); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (sizeentry), 0, lower, upper); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (sizeentry), 0, initial); spinbutton = gimp_size_entry_get_help_widget (GIMP_SIZE_ENTRY (sizeentry), 0); gtk_entry_set_activates_default (GTK_ENTRY (spinbutton), TRUE); gtk_box_pack_start (GTK_BOX (query_box->vbox), sizeentry, FALSE, FALSE, 0); gimp_size_entry_grab_focus (GIMP_SIZE_ENTRY (sizeentry)); gtk_widget_show (sizeentry); query_box->entry = sizeentry; return query_box->qbox; }
static void gimp_rotate_tool_dialog_update (GimpTransformTool *tr_tool) { GimpRotateTool *rotate = GIMP_ROTATE_TOOL (tr_tool); gtk_adjustment_set_value (rotate->angle_adj, gimp_rad_to_deg (tr_tool->trans_info[ANGLE])); g_signal_handlers_block_by_func (rotate->sizeentry, rotate_center_changed, tr_tool); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (rotate->sizeentry), 0, tr_tool->trans_info[PIVOT_X]); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (rotate->sizeentry), 1, tr_tool->trans_info[PIVOT_Y]); g_signal_handlers_unblock_by_func (rotate->sizeentry, rotate_center_changed, tr_tool); }
static void load_dialog_set_ratio (gdouble x, gdouble y) { ratio_x = x; ratio_y = y; g_signal_handlers_block_by_func (size, load_dialog_size_callback, NULL); gimp_size_entry_set_refval (size, 0, wmf_width * x); gimp_size_entry_set_refval (size, 1, wmf_height * y); g_signal_handlers_unblock_by_func (size, load_dialog_size_callback, NULL); g_signal_handlers_block_by_func (xadj, load_dialog_ratio_callback, NULL); g_signal_handlers_block_by_func (yadj, load_dialog_ratio_callback, NULL); gtk_adjustment_set_value (GTK_ADJUSTMENT (xadj), x); gtk_adjustment_set_value (GTK_ADJUSTMENT (yadj), y); g_signal_handlers_unblock_by_func (xadj, load_dialog_ratio_callback, NULL); g_signal_handlers_unblock_by_func (yadj, load_dialog_ratio_callback, NULL); }
static void gimp_text_style_editor_set_default_size (GimpTextStyleEditor *editor) { gdouble pixels = gimp_units_to_pixels (editor->text->font_size, editor->text->unit, editor->resolution_y); g_signal_handlers_block_by_func (editor->size_entry, gimp_text_style_editor_size_changed, editor); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (editor->size_entry), 0, pixels); g_signal_handlers_unblock_by_func (editor->size_entry, gimp_text_style_editor_size_changed, editor); }
static gboolean mblur_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *frame; GtkWidget *table; GtkWidget *entry; GtkWidget *spinbutton; GtkWidget *label; GtkWidget *button; GtkObject *adj; gdouble xres, yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Motion Blur"), 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); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (mblur), drawable); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); frame = gimp_int_radio_group_new (TRUE, _("Blur Type"), G_CALLBACK (mblur_radio_button_update), &mbvals.mblur_type, mbvals.mblur_type, _("_Linear"), MBLUR_LINEAR, NULL, _("_Radial"), MBLUR_RADIAL, NULL, _("_Zoom"), MBLUR_ZOOM, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); center = gimp_frame_new (_("Blur Center")); gtk_box_pack_start (GTK_BOX (hbox), center, FALSE, FALSE, 0); gtk_widget_show (center); vbox = gtk_vbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (center), vbox); gtk_widget_show (vbox); gimp_image_get_resolution (image_ID, &xres, &yres); entry = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 5, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_table_set_row_spacings (GTK_TABLE (entry), 2); gtk_table_set_col_spacing (GTK_TABLE (entry), 0, 6); gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 6); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_widget_show (entry); g_signal_connect (entry, "value-changed", G_CALLBACK (mblur_center_update), NULL); g_signal_connect_swapped (entry, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); spinbutton = gimp_spin_button_new (&adj, 1, 0, 1, 1, 10, 1, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, xres, TRUE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 0, mbvals.center_x); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_X:"), 0, 0, 0.0); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 1, yres, TRUE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 1, mbvals.center_y); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Y:"), 1, 0, 0.0); button = gtk_check_button_new_with_mnemonic (_("Blur _outward")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), mbvals.blur_outward); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &mbvals.blur_outward); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); dir_button = button; frame = gimp_frame_new (_("Blur Parameters")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); length = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("L_ength:"), 150, 3, mbvals.length, 1.0, MBLUR_LENGTH_MAX, 1.0, 8.0, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (length, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &mbvals.length); g_signal_connect_swapped (length, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); angle = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Angle:"), 150, 3, mbvals.angle, 0.0, 360.0, 1.0, 15.0, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (angle, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &mbvals.angle); g_signal_connect_swapped (angle, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); mblur_set_sensitivity (); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static gint dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dlg; GtkWidget *main_vbox; GtkWidget *vbox; GtkSizeGroup *group; GtkWidget *label; GtkWidget *preview; GtkWidget *button; GtkWidget *width; GtkWidget *space; GtkWidget *offset; GtkWidget *chain_button; GtkWidget *table; GimpUnit unit; gdouble xres; gdouble yres; gboolean run; g_return_val_if_fail (main_dialog == NULL, FALSE); gimp_ui_init (PLUG_IN_BINARY, TRUE); main_dialog = dlg = gimp_dialog_new (_("Grid"), PLUG_IN_ROLE, 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)); /* Get the image resolution and unit */ gimp_image_get_resolution (image_ID, &xres, &yres); unit = gimp_image_get_unit (image_ID); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), main_vbox, TRUE, TRUE, 0); 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); g_signal_connect (preview, "invalidated", G_CALLBACK (update_preview), drawable); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); /* The width entries */ width = gimp_size_entry_new (3, /* number_of_fields */ unit, /* unit */ "%a", /* unit_format */ TRUE, /* menu_show_pixels */ TRUE, /* menu_show_percent */ FALSE, /* show_refval */ SPIN_BUTTON_WIDTH, /* spinbutton_usize */ GIMP_SIZE_ENTRY_UPDATE_SIZE); /* update_policy */ gtk_box_pack_start (GTK_BOX (vbox), width, FALSE, FALSE, 0); gtk_widget_show (width); /* set the unit back to pixels, since most times we will want pixels */ gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (width), GIMP_UNIT_PIXEL); /* set the resolution to the image resolution */ gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (width), 0, xres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (width), 1, yres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (width), 2, xres, TRUE); /* set the size (in pixels) that will be treated as 0% and 100% */ gimp_size_entry_set_size (GIMP_SIZE_ENTRY (width), 0, 0.0, drawable->height); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (width), 1, 0.0, drawable->width); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (width), 2, 0.0, drawable->width); /* set upper and lower limits (in pixels) */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (width), 0, 0.0, drawable->height); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (width), 1, 0.0, drawable->width); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (width), 2, 0.0, MAX (drawable->width, drawable->height)); gtk_table_set_row_spacing (GTK_TABLE (width), 0, 6); gtk_table_set_col_spacings (GTK_TABLE (width), 6); gtk_table_set_col_spacing (GTK_TABLE (width), 2, 12); /* initialize the values */ gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (width), 0, grid_cfg.hwidth); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (width), 1, grid_cfg.vwidth); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (width), 2, grid_cfg.iwidth); /* attach labels */ gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (width), _("Horizontal\nLines"), 0, 1, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (width), _("Vertical\nLines"), 0, 2, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (width), _("Intersection"), 0, 3, 0.0); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (width), _("Width:"), 1, 0, 0.0); group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); gtk_size_group_add_widget (group, label); g_object_unref (group); /* put a chain_button under the size_entries */ chain_button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); if (grid_cfg.hwidth == grid_cfg.vwidth) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (width), chain_button, 1, 3, 2, 3); gtk_widget_show (chain_button); /* connect to the 'value-changed' signal because we have to take care * of keeping the entries in sync when the chainbutton is active */ g_signal_connect (width, "value-changed", G_CALLBACK (entry_callback), chain_button); g_signal_connect_swapped (width, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* The spacing entries */ space = gimp_size_entry_new (3, /* number_of_fields */ unit, /* unit */ "%a", /* unit_format */ TRUE, /* menu_show_pixels */ TRUE, /* menu_show_percent */ FALSE, /* show_refval */ SPIN_BUTTON_WIDTH, /* spinbutton_usize */ GIMP_SIZE_ENTRY_UPDATE_SIZE); /* update_policy */ gtk_box_pack_start (GTK_BOX (vbox), space, FALSE, FALSE, 0); gtk_widget_show (space); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (space), GIMP_UNIT_PIXEL); /* set the resolution to the image resolution */ gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (space), 0, xres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (space), 1, yres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (space), 2, xres, TRUE); /* set the size (in pixels) that will be treated as 0% and 100% */ gimp_size_entry_set_size (GIMP_SIZE_ENTRY (space), 0, 0.0, drawable->height); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (space), 1, 0.0, drawable->width); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (space), 2, 0.0, drawable->width); /* set upper and lower limits (in pixels) */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (space), 0, 1.0, drawable->height); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (space), 1, 1.0, drawable->width); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (space), 2, 0.0, MAX (drawable->width, drawable->height)); gtk_table_set_col_spacings (GTK_TABLE (space), 6); gtk_table_set_col_spacing (GTK_TABLE (space), 2, 12); /* initialize the values */ gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (space), 0, grid_cfg.hspace); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (space), 1, grid_cfg.vspace); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (space), 2, grid_cfg.ispace); /* attach labels */ label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (space), _("Spacing:"), 1, 0, 0.0); gtk_size_group_add_widget (group, label); /* put a chain_button under the spacing_entries */ chain_button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); if (grid_cfg.hspace == grid_cfg.vspace) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (space), chain_button, 1, 3, 2, 3); gtk_widget_show (chain_button); /* connect to the 'value-changed' and "unit-changed" signals because * we have to take care of keeping the entries in sync when the * chainbutton is active */ g_signal_connect (space, "value-changed", G_CALLBACK (entry_callback), chain_button); g_signal_connect (space, "unit-changed", G_CALLBACK (entry_callback), chain_button); g_signal_connect_swapped (space, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* The offset entries */ offset = gimp_size_entry_new (3, /* number_of_fields */ unit, /* unit */ "%a", /* unit_format */ TRUE, /* menu_show_pixels */ TRUE, /* menu_show_percent */ FALSE, /* show_refval */ SPIN_BUTTON_WIDTH, /* spinbutton_usize */ GIMP_SIZE_ENTRY_UPDATE_SIZE); /* update_policy */ gtk_box_pack_start (GTK_BOX (vbox), offset, FALSE, FALSE, 0); gtk_widget_show (offset); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (offset), GIMP_UNIT_PIXEL); /* set the resolution to the image resolution */ gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (offset), 0, xres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (offset), 1, yres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (offset), 2, xres, TRUE); /* set the size (in pixels) that will be treated as 0% and 100% */ gimp_size_entry_set_size (GIMP_SIZE_ENTRY (offset), 0, 0.0, drawable->height); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (offset), 1, 0.0, drawable->width); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (offset), 2, 0.0, drawable->width); /* set upper and lower limits (in pixels) */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (offset), 0, 0.0, drawable->height); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (offset), 1, 0.0, drawable->width); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (offset), 2, 0.0, MAX (drawable->width, drawable->height)); gtk_table_set_col_spacings (GTK_TABLE (offset), 6); gtk_table_set_col_spacing (GTK_TABLE (offset), 2, 12); /* initialize the values */ gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (offset), 0, grid_cfg.hoffset); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (offset), 1, grid_cfg.voffset); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (offset), 2, grid_cfg.ioffset); /* attach labels */ label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (offset), _("Offset:"), 1, 0, 0.0); gtk_size_group_add_widget (group, label); /* this is a weird hack: we put a table into the offset table */ table = gtk_table_new (3, 3, FALSE); gtk_table_attach_defaults (GTK_TABLE (offset), table, 1, 4, 2, 3); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 10); gtk_table_set_col_spacing (GTK_TABLE (table), 1, 12); /* put a chain_button under the offset_entries */ chain_button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); if (grid_cfg.hoffset == grid_cfg.voffset) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), chain_button, 0, 2, 0, 1); gtk_widget_show (chain_button); /* connect to the 'value-changed' and "unit-changed" signals because * we have to take care of keeping the entries in sync when the * chainbutton is active */ g_signal_connect (offset, "value-changed", G_CALLBACK (entry_callback), chain_button); g_signal_connect (offset, "unit-changed", G_CALLBACK (entry_callback), chain_button); g_signal_connect_swapped (offset, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); /* put a chain_button under the color_buttons */ chain_button = gimp_chain_button_new (GIMP_CHAIN_BOTTOM); if (gimp_rgba_distance (&grid_cfg.hcolor, &grid_cfg.vcolor) < 0.0001) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), chain_button, 0, 2, 2, 3); gtk_widget_show (chain_button); /* attach color selectors */ hcolor_button = gimp_color_button_new (_("Horizontal Color"), COLOR_BUTTON_WIDTH, 16, &grid_cfg.hcolor, GIMP_COLOR_AREA_SMALL_CHECKS); gimp_color_button_set_update (GIMP_COLOR_BUTTON (hcolor_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), hcolor_button, 0, 1, 1, 2); gtk_widget_show (hcolor_button); g_signal_connect (hcolor_button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &grid_cfg.hcolor); g_signal_connect (hcolor_button, "color-changed", G_CALLBACK (color_callback), chain_button); g_signal_connect_swapped (hcolor_button, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); vcolor_button = gimp_color_button_new (_("Vertical Color"), COLOR_BUTTON_WIDTH, 16, &grid_cfg.vcolor, GIMP_COLOR_AREA_SMALL_CHECKS); gimp_color_button_set_update (GIMP_COLOR_BUTTON (vcolor_button), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), vcolor_button, 1, 2, 1, 2); gtk_widget_show (vcolor_button); g_signal_connect (vcolor_button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &grid_cfg.vcolor); g_signal_connect (vcolor_button, "color-changed", G_CALLBACK (color_callback), chain_button); g_signal_connect_swapped (vcolor_button, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); button = gimp_color_button_new (_("Intersection Color"), COLOR_BUTTON_WIDTH, 16, &grid_cfg.icolor, GIMP_COLOR_AREA_SMALL_CHECKS); gimp_color_button_set_update (GIMP_COLOR_BUTTON (button), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), button, 2, 3, 1, 2); gtk_widget_show (button); g_signal_connect (button, "color-changed", G_CALLBACK (gimp_color_button_get_color), &grid_cfg.icolor); g_signal_connect_swapped (button, "color-changed", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (table); gtk_widget_show (dlg); g_object_set_data (G_OBJECT (dlg), "width", width); g_object_set_data (G_OBJECT (dlg), "space", space); g_object_set_data (G_OBJECT (dlg), "offset", offset); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); if (run) update_values (); gtk_widget_destroy (dlg); return run; }
static GtkWidget * print_size_frame (PrintData *data, GtkSizeGroup *label_group, GtkSizeGroup *entry_group) { GtkWidget *entry; GtkWidget *height; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *chain; GtkWidget *frame; GtkWidget *label; GtkObject *adj; gdouble image_width; gdouble image_height; image_width = (info.image_width * gimp_unit_get_factor (data->unit) / data->xres); image_height = (info.image_height * gimp_unit_get_factor (data->unit) / data->yres); frame = gimp_frame_new (_("Size")); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /* the print size entry */ hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); entry = gimp_size_entry_new (1, data->unit, "%p", FALSE, FALSE, FALSE, SB_WIDTH, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0); gtk_widget_show (entry); info.size_entry = GIMP_SIZE_ENTRY (entry); gtk_table_set_row_spacings (GTK_TABLE (entry), 2); gtk_table_set_col_spacing (GTK_TABLE (entry), 0, 6); gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 6); height = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (height), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), height, 1, 2, 0, 1); gtk_widget_show (height); gtk_size_group_add_widget (entry_group, height); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Width:"), 0, 0, 0.0); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Height:"), 1, 0, 0.0); gtk_size_group_add_widget (label_group, label); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, data->xres, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 1, data->yres, FALSE); gimp_size_entry_set_value (GIMP_SIZE_ENTRY (entry), 0, image_width); gimp_size_entry_set_value (GIMP_SIZE_ENTRY (entry), 1, image_height); /* the resolution entry */ hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); entry = gimp_size_entry_new (1, data->image_unit, _("pixels/%a"), FALSE, FALSE, FALSE, SB_WIDTH, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0); gtk_widget_show (entry); info.resolution_entry = GIMP_SIZE_ENTRY (entry); gtk_table_set_row_spacings (GTK_TABLE (entry), 2); gtk_table_set_col_spacing (GTK_TABLE (entry), 0, 6); gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 6); height = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 0, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (height), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), height, 1, 2, 0, 1); gtk_widget_show (height); gtk_size_group_add_widget (entry_group, height); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_X resolution:"), 0, 0, 0.0); gtk_size_group_add_widget (label_group, label); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Y resolution:"), 1, 0, 0.0); gtk_size_group_add_widget (label_group, label); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (entry), 0, GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (entry), 1, GIMP_MIN_RESOLUTION, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 0, data->xres); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 1, data->yres); chain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chain), TRUE); gtk_table_attach (GTK_TABLE (entry), chain, 2, 3, 0, 2, GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (chain); info.chain = GIMP_CHAIN_BUTTON (chain); g_signal_connect (info.resolution_entry, "value-changed", G_CALLBACK (print_size_info_resolution_changed), NULL); g_signal_connect (info.size_entry, "unit-changed", G_CALLBACK (print_size_info_unit_changed), NULL); return frame; }
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; } }
LayerOptionsDialog * layer_options_dialog_new (GimpImage *image, GimpLayer *layer, GimpContext *context, GtkWidget *parent, const gchar *layer_name, GimpFillType layer_fill_type, const gchar *title, const gchar *role, const gchar *stock_id, const gchar *desc, const gchar *help_id) { LayerOptionsDialog *options; GimpViewable *viewable; GtkWidget *vbox; GtkWidget *table; GtkWidget *label; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *frame; GtkWidget *button; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (layer == NULL || GIMP_IS_LAYER (layer), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); options = g_slice_new0 (LayerOptionsDialog); options->image = image; options->context = context; options->layer = layer; options->fill_type = layer_fill_type; if (layer) viewable = GIMP_VIEWABLE (layer); else viewable = GIMP_VIEWABLE (image); options->dialog = gimp_viewable_dialog_new (viewable, context, title, role, stock_id, desc, parent, gimp_standard_help_func, help_id, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_object_weak_ref (G_OBJECT (options->dialog), (GWeakNotify) layer_options_dialog_free, options); gtk_dialog_set_alternative_button_order (GTK_DIALOG (options->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_set_spacing (GTK_BOX (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (options->dialog))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); table = gtk_table_new (layer ? 1 : 3, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table), 0, 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 6); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); gtk_widget_show (table); /* The name label and entry */ options->name_entry = gtk_entry_new (); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Layer _name:"), 0.0, 0.5, options->name_entry, 1, FALSE); gtk_entry_set_activates_default (GTK_ENTRY (options->name_entry), TRUE); gtk_entry_set_text (GTK_ENTRY (options->name_entry), layer_name); if (! layer) { gdouble xres; gdouble yres; gimp_image_get_resolution (image, &xres, &yres); /* The size labels */ 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, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK, 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, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK, 0, 0); gtk_widget_show (label); /* The size sizeentry */ spinbutton = gimp_spin_button_new (&adjustment, 1, 1, 1, 1, 10, 0, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); options->size_se = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, TRUE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_table_set_col_spacing (GTK_TABLE (options->size_se), 1, 4); gtk_table_set_row_spacing (GTK_TABLE (options->size_se), 0, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (options->size_se), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (options->size_se), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gtk_table_attach (GTK_TABLE (table), options->size_se, 1, 2, 1, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (options->size_se); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (options->size_se), GIMP_UNIT_PIXEL); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 0, xres, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (options->size_se), 1, yres, FALSE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 0, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (options->size_se), 1, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 0, 0, gimp_image_get_width (image)); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (options->size_se), 1, 0, gimp_image_get_height (image)); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 0, gimp_image_get_width (image)); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (options->size_se), 1, gimp_image_get_height (image)); /* The radio frame */ frame = gimp_enum_radio_frame_new_with_range (GIMP_TYPE_FILL_TYPE, GIMP_FOREGROUND_FILL, GIMP_TRANSPARENT_FILL, gtk_label_new (_("Layer Fill Type")), G_CALLBACK (gimp_radio_button_update), &options->fill_type, &button); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), options->fill_type); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); } else { GimpContainer *filters; GtkWidget *frame; GtkWidget *view; /* For text layers add a toggle to control "auto-rename" */ if (gimp_item_is_text_layer (GIMP_ITEM (layer))) { options->rename_toggle = gtk_check_button_new_with_mnemonic (_("Set name from _text")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (options->rename_toggle), GIMP_TEXT_LAYER (layer)->auto_rename); gtk_table_attach (GTK_TABLE (table), options->rename_toggle, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (options->rename_toggle); g_signal_connect (options->rename_toggle, "toggled", G_CALLBACK (layer_options_dialog_toggle_rename), options); } frame = gimp_frame_new ("Active Filters"); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); filters = gimp_drawable_get_filters (GIMP_DRAWABLE (layer)); view = gimp_container_tree_view_new (filters, context, GIMP_VIEW_SIZE_SMALL, 0); gtk_container_add (GTK_CONTAINER (frame), view); gtk_widget_show (view); } return options; }
GtkWidget * offset_dialog_new (GimpDrawable *drawable, GimpContext *context, GtkWidget *parent) { GimpItem *item; OffsetDialog *dialog; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *button; GtkWidget *spinbutton; GtkWidget *frame; GtkWidget *radio_button; GtkAdjustment *adjustment; gdouble xres; gdouble yres; const gchar *title = NULL; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); dialog = g_slice_new0 (OffsetDialog); dialog->context = context; dialog->fill_type = gimp_drawable_has_alpha (drawable) | WRAP_AROUND; item = GIMP_ITEM (drawable); dialog->image = gimp_item_get_image (item); gimp_image_get_resolution (dialog->image, &xres, &yres); if (GIMP_IS_LAYER (drawable)) title = _("Offset Layer"); else if (GIMP_IS_LAYER_MASK (drawable)) title = _("Offset Layer Mask"); else if (GIMP_IS_CHANNEL (drawable)) title = _("Offset Channel"); else g_warning ("%s: unexpected drawable type", G_STRFUNC); dialog->dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (drawable), context, _("Offset"), "gimp-drawable-offset", GIMP_STOCK_TOOL_MOVE, title, parent, gimp_standard_help_func, GIMP_HELP_LAYER_OFFSET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, /* offset, used as a verb */ _("_Offset"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), FALSE); g_object_weak_ref (G_OBJECT (dialog->dialog), (GWeakNotify) offset_dialog_free, dialog); g_signal_connect (dialog->dialog, "response", G_CALLBACK (offset_response), dialog); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog->dialog))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); /* The offset frame */ frame = gimp_frame_new (_("Offset")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); adjustment = (GtkAdjustment *) gtk_adjustment_new (1, 1, 1, 1, 10, 0); spinbutton = gtk_spin_button_new (adjustment, 1.0, 2); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); dialog->off_se = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, TRUE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_table_set_col_spacing (GTK_TABLE (dialog->off_se), 0, 4); gtk_table_set_col_spacing (GTK_TABLE (dialog->off_se), 1, 4); gtk_table_set_row_spacing (GTK_TABLE (dialog->off_se), 0, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (dialog->off_se), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (dialog->off_se), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (dialog->off_se), _("_X:"), 0, 0, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (dialog->off_se), _("_Y:"), 1, 0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), dialog->off_se, FALSE, FALSE, 0); gtk_widget_show (dialog->off_se); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (dialog->off_se), GIMP_UNIT_PIXEL); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (dialog->off_se), 0, xres, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (dialog->off_se), 1, yres, FALSE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (dialog->off_se), 0, - gimp_item_get_width (item), gimp_item_get_width (item)); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (dialog->off_se), 1, - gimp_item_get_height (item), gimp_item_get_height (item)); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (dialog->off_se), 0, 0, gimp_item_get_width (item)); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (dialog->off_se), 1, 0, gimp_item_get_height (item)); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (dialog->off_se), 0, 0); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (dialog->off_se), 1, 0); button = gtk_button_new_with_mnemonic (_("By width/_2, height/2")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (offset_half_xy_callback), dialog); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); button = gtk_button_new_with_mnemonic ("By _width/2"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (offset_half_x_callback), dialog); button = gtk_button_new_with_mnemonic ("By _height/2"); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (offset_half_y_callback), dialog); /* The edge behavior frame */ frame = gimp_int_radio_group_new (TRUE, _("Edge Behavior"), G_CALLBACK (gimp_radio_button_update), &dialog->fill_type, dialog->fill_type, _("W_rap around"), WRAP_AROUND, NULL, _("Fill with _background color"), GIMP_OFFSET_BACKGROUND, NULL, _("Make _transparent"), GIMP_OFFSET_TRANSPARENT, &radio_button, NULL); if (! gimp_drawable_has_alpha (drawable)) gtk_widget_set_sensitive (radio_button, FALSE); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); return dialog->dialog; }
static gboolean shift_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *frame; GtkWidget *size_entry; GtkWidget *vertical; GtkWidget *horizontal; GimpUnit unit; gdouble xres; gdouble yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Shift"), PLUG_IN_ROLE, 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_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_vbox, TRUE, TRUE, 0); 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); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (shift), drawable); frame = gimp_int_radio_group_new (FALSE, NULL, G_CALLBACK (gimp_radio_button_update), &shvals.orientation, shvals.orientation, _("Shift _horizontally"), HORIZONTAL, &horizontal, _("Shift _vertically"), VERTICAL, &vertical, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); g_signal_connect_swapped (horizontal, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); g_signal_connect_swapped (vertical, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); /* Get the image resolution and unit */ gimp_image_get_resolution (image_ID, &xres, &yres); unit = gimp_image_get_unit (image_ID); size_entry = gimp_size_entry_new (1, unit, "%a", TRUE, FALSE, FALSE, SPIN_BUTTON_WIDTH, GIMP_SIZE_ENTRY_UPDATE_SIZE); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (size_entry), GIMP_UNIT_PIXEL); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (size_entry), 0, xres, TRUE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (size_entry), 0, 1.0, 200.0); gtk_table_set_col_spacing (GTK_TABLE (size_entry), 0, 4); gtk_table_set_col_spacing (GTK_TABLE (size_entry), 2, 12); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (size_entry), 0, (gdouble) shvals.shift_amount); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (size_entry), _("Shift _amount:"), 1, 0, 0.0); g_signal_connect (size_entry, "value-changed", G_CALLBACK (shift_amount_callback), preview); gtk_box_pack_start (GTK_BOX (main_vbox), size_entry, FALSE, FALSE, 0); gtk_widget_show (size_entry); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
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); }
/** * gimp_coordinates_new: * @unit: The initial unit of the #GimpUnitMenu. * @unit_format: A printf-like unit-format string as is used with * gimp_unit_menu_new(). * @menu_show_pixels: %TRUE if the #GimpUnitMenu should contain an item * for GIMP_UNIT_PIXEL. * @menu_show_percent: %TRUE if the #GimpUnitMenu should contain an item * for GIMP_UNIT_PERCENT. * @spinbutton_width: The horizontal size of the #GimpSizeEntry's * #GtkSpinButton's. * @update_policy: The update policy for the #GimpSizeEntry. * @chainbutton_active: %TRUE if the attached #GimpChainButton should be * active. * @chain_constrains_ratio: %TRUE if the chainbutton should constrain the * fields' aspect ratio. If %FALSE, the values will * be constrained. * @xlabel: The label for the X coordinate. * @x: The initial value of the X coordinate. * @xres: The horizontal resolution in DPI. * @lower_boundary_x: The lower boundary of the X coordinate. * @upper_boundary_x: The upper boundary of the X coordinate. * @xsize_0: The X value which will be treated as 0%. * @xsize_100: The X value which will be treated as 100%. * @ylabel: The label for the Y coordinate. * @y: The initial value of the Y coordinate. * @yres: The vertical resolution in DPI. * @lower_boundary_y: The lower boundary of the Y coordinate. * @upper_boundary_y: The upper boundary of the Y coordinate. * @ysize_0: The Y value which will be treated as 0%. * @ysize_100: The Y value which will be treated as 100%. * * Convenience function that creates a #GimpSizeEntry with two fields for x/y * coordinates/sizes with a #GimpChainButton attached to constrain either the * two fields' values or the ratio between them. * * Returns: The new #GimpSizeEntry. **/ GtkWidget * gimp_coordinates_new (GimpUnit unit, const gchar *unit_format, gboolean menu_show_pixels, gboolean menu_show_percent, gint spinbutton_width, GimpSizeEntryUpdatePolicy update_policy, gboolean chainbutton_active, gboolean chain_constrains_ratio, const gchar *xlabel, gdouble x, gdouble xres, gdouble lower_boundary_x, gdouble upper_boundary_x, gdouble xsize_0, /* % */ gdouble xsize_100, /* % */ const gchar *ylabel, gdouble y, gdouble yres, gdouble lower_boundary_y, gdouble upper_boundary_y, gdouble ysize_0, /* % */ gdouble ysize_100 /* % */) { GimpCoordinatesData *data; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *sizeentry; GtkWidget *chainbutton; spinbutton = gimp_spin_button_new (&adjustment, 1, 0, 1, 1, 10, 0, 1, 2); if (spinbutton_width > 0) { if (spinbutton_width < 17) gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), spinbutton_width); else gtk_widget_set_size_request (spinbutton, spinbutton_width, -1); } sizeentry = gimp_size_entry_new (1, unit, unit_format, menu_show_pixels, menu_show_percent, FALSE, spinbutton_width, update_policy); gtk_table_set_col_spacing (GTK_TABLE (sizeentry), 0, 4); gtk_table_set_col_spacing (GTK_TABLE (sizeentry), 2, 4); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (sizeentry), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (sizeentry), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (sizeentry), (update_policy == GIMP_SIZE_ENTRY_UPDATE_RESOLUTION) || (menu_show_pixels == FALSE) ? GIMP_UNIT_INCH : GIMP_UNIT_PIXEL); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (sizeentry), 0, xres, TRUE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (sizeentry), 1, yres, TRUE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (sizeentry), 0, lower_boundary_x, upper_boundary_x); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (sizeentry), 1, lower_boundary_y, upper_boundary_y); if (menu_show_percent) { gimp_size_entry_set_size (GIMP_SIZE_ENTRY (sizeentry), 0, xsize_0, xsize_100); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (sizeentry), 1, ysize_0, ysize_100); } gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (sizeentry), 0, x); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (sizeentry), 1, y); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (sizeentry), xlabel, 0, 0, 0.0); gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (sizeentry), ylabel, 1, 0, 0.0); chainbutton = gimp_chain_button_new (GIMP_CHAIN_RIGHT); if (chainbutton_active) gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (chainbutton), TRUE); gtk_table_attach (GTK_TABLE (sizeentry), chainbutton, 2, 3, 0, 2, GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (chainbutton); data = g_slice_new (GimpCoordinatesData); data->chainbutton = GIMP_CHAIN_BUTTON (chainbutton); data->chain_constrains_ratio = chain_constrains_ratio; data->orig_x = x; data->orig_y = y; data->last_x = x; data->last_y = y; g_object_set_data_full (G_OBJECT (sizeentry), "coordinates-data", data, (GDestroyNotify) gimp_coordinates_data_free); g_signal_connect (sizeentry, "value-changed", G_CALLBACK (gimp_coordinates_callback), data); g_object_set_data (G_OBJECT (sizeentry), "chainbutton", chainbutton); g_signal_connect (chainbutton, "toggled", G_CALLBACK (gimp_coordinates_chainbutton_toggled), sizeentry); return sizeentry; }
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 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; }
/** * 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); }