static void
ico_dialog_bpp_changed (GtkWidget *combo,
GObject *hbox)
{
GtkWidget *dialog;
gint32 layer;
gint layer_num;
gint bpp;
IcoSaveInfo *info;
dialog = gtk_widget_get_toplevel (combo);
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (combo), &bpp);
info = g_object_get_data (G_OBJECT (dialog), "save_info");
g_assert (info);
layer = GPOINTER_TO_INT (g_object_get_data (hbox, "icon_layer"));
layer_num = GPOINTER_TO_INT (g_object_get_data (hbox, "icon_layer_num"));
/* Update vector entry for later when we're actually saving,
and update the preview right away ... */
info->depths[layer_num] = bpp;
ico_dialog_update_icon_preview (dialog, layer, bpp);
}
operator int() const
{
gint value;
gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(this->gimpEnumComboBox), &value);
return value;
}
static void
save_dialog_version_changed (GtkComboBox *widget, SaveInfo *info)
{
gint version;
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &version);
if (version >= 3) {
g_object_set (G_OBJECT (info->ctl_lowres),
"sensitive", TRUE,
"active", info->lowres,
NULL);
g_object_set (G_OBJECT (info->ctl_crc),
"sensitive", TRUE,
"active", info->crc,
NULL);
} else {
g_object_set (G_OBJECT (info->ctl_lowres),
"sensitive", FALSE,
"active", TRUE,
NULL);
g_object_set (G_OBJECT (info->ctl_crc),
"sensitive", FALSE,
"active", FALSE,
NULL);
}
}
void
combo_get_active (GtkWidget * combo, PreviewData * p_data,
gint32 * layer_ID_add, gboolean status,
GdkPixbuf ** pixbuf_add, SizeInfo * size_info)
{
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (combo), layer_ID_add);
if (status == TRUE)
{
if (*pixbuf_add)
{
g_object_unref (G_OBJECT (*pixbuf_add));
}
gimp_drawable_offsets (*layer_ID_add, &(size_info->x_off), &(size_info->y_off));
size_info->x_off -= p_data->x_off;
size_info->y_off -= p_data->y_off;
size_info->width = gimp_drawable_width(*layer_ID_add);
size_info->height = gimp_drawable_height(*layer_ID_add);
size_info_scale(size_info, p_data->factor);
*pixbuf_add = gimp_drawable_get_thumbnail(*layer_ID_add, size_info->width, size_info->height, GIMP_PIXBUF_KEEP_ALPHA);
}
preview_build_pixbuf (p_data);
gtk_widget_queue_draw (p_data->area);
}
/* A function that is called when the button for adding an image
* was clicked */
static void
add_image_call (GtkWidget *widget,
gpointer img_combo)
{
GtkListStore *store;
GtkTreeIter iter;
gint32 image;
dnd_remove = FALSE;
gimp_int_combo_box_get_active (img_combo, &image);
store = GTK_LIST_STORE (model);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
PAGE_NUMBER, g_strdup_printf ("Page %d", multi_page.image_count+1),
THUMB, gimp_image_get_thumbnail (image, THUMB_WIDTH, THUMB_HEIGHT, GIMP_PIXBUF_SMALL_CHECKS),
IMAGE_NAME, gimp_image_get_name (image),
IMAGE_ID, image,
-1
);
multi_page.image_count++;
dnd_remove = TRUE;
}
static void
callback_res_order_changed (GtkWidget * res_order, gpointer data)
{
gint order;
PreviewData *p_data = PREVIEW_DATA (data);
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (res_order), &order);
p_data->vals->res_order = order;
callback_set_disc_warning (NULL, data);
}
static void
gimp_color_frame_menu_callback (GtkWidget *widget,
GimpColorFrame *frame)
{
gint value;
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value))
{
frame->frame_mode = value;
gimp_color_frame_update (frame);
}
}
static void dialog_marked_cb(GtkWidget *widget, gpointer data)
{
GimpDrawable **drawable = data;
gint32 marked_id;
gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(widget), &marked_id);
if (marked_id != colorizevals.marked_id) {
gimp_drawable_detach(*drawable);
colorizevals.marked_id = marked_id;
*drawable = gimp_drawable_get(marked_id);
}
}
static void
cm_combo_callback (GtkWidget *widget,
CmParamsType *mix)
{
gint value;
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value))
{
mix->output_channel = value;
cm_set_adjusters (mix);
}
}
static void
gimp_brush_select_mode_update (GtkWidget *widget,
GimpBrushSelect *select)
{
gint paint_mode;
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget),
&paint_mode))
{
gimp_context_set_paint_mode (GIMP_PDB_DIALOG (select)->context,
(GimpLayerModeEffects) paint_mode);
}
}
static void
webx_indexed_target_changed (WebxIndexedTarget *indexed)
{
gtk_widget_set_sensitive (GTK_WIDGET (indexed->remove_unused_w), TRUE);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->reuse_pal_w)))
{
if (!gimp_drawable_is_indexed (global_drawable_ID))
{ /* no user palette */
gtk_widget_set_sensitive (indexed->reuse_pal_w, FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (indexed->make_pal_w),
TRUE);
}
else
{
gtk_widget_set_sensitive (indexed->reuse_pal_w, TRUE);
gtk_widget_set_sensitive (indexed->remove_unused_w, FALSE);
indexed->palette_type = GIMP_REUSE_PALETTE;
}
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->make_pal_w)))
{
indexed->palette_type = GIMP_MAKE_PALETTE;
gtk_widget_set_sensitive (indexed->num_colors_w, TRUE);
gtk_widget_set_sensitive (indexed->remove_unused_w, FALSE);
}
else
{
gtk_widget_set_sensitive (indexed->num_colors_w, FALSE);
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->web_pal_w)))
{
indexed->palette_type = GIMP_WEB_PALETTE;
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->bw_pal_w)))
{
indexed->palette_type = GIMP_MONO_PALETTE;
}
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (indexed->dither_type_w),
&indexed->dither_type);
indexed->num_colors = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (indexed->num_colors_w));
indexed->remove_unused = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->remove_unused_w));
indexed->alpha_dither = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (indexed->alpha_dither_w));
webx_target_changed (WEBX_TARGET (indexed));
}
void dialogSourceChangedCallback(GimpIntComboBox *widget, PlugInVals *vals) {
gint value;
#ifdef DEBUG
g_warning("dialogSourceChangedCallback");
#endif
if (gimp_int_combo_box_get_active(widget,&value)) {
vals->image_drawable_id = value;
vals->output_drawable_id = value;
update_image(vals);
renderPreview(vals);
}
}
static void
print_size_info_center_changed (GtkWidget *combo)
{
gint value;
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (combo), &value))
{
info.data->center = value;
print_size_info_update_offsets ();
if (info.preview)
print_preview_set_image_offsets (PRINT_PREVIEW (info.preview),
info.data->offset_x,
info.data->offset_y);
}
}
static void
subsampling_changed (GtkWidget *combo,
GtkObject *entry)
{
gint value;
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (combo), &value);
jsvals.subsmp = value;
/* smoothing is not supported with nonstandard sampling ratios */
gimp_scale_entry_set_sensitive (entry,
jsvals.subsmp != JPEG_SUBSAMPLING_2x1_1x1_1x1 &&
jsvals.subsmp != JPEG_SUBSAMPLING_1x2_1x1_1x1);
make_preview ();
}
void
rcm_combo_callback (GtkWidget *widget,
gpointer data)
{
gint value;
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value);
Current.reduced = rcm_reduce_image (Current.drawable, Current.mask,
MAX_PREVIEW_SIZE, value);
gtk_widget_set_size_request (Current.Bna->before,
Current.reduced->width,
Current.reduced->height);
gtk_widget_set_size_request (Current.Bna->after,
Current.reduced->width,
Current.reduced->height);
}
static void
levels_channel_callback (GtkWidget *widget,
GimpLevelsTool *tool)
{
gint value;
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &value))
{
tool->channel = value;
gimp_histogram_view_set_channel (GIMP_HISTOGRAM_VIEW (tool->hist_view),
tool->channel);
/* FIXME: hack */
if (! tool->color)
tool->channel = (tool->channel == GIMP_HISTOGRAM_ALPHA) ? 1 : 0;
levels_update (tool, ALL);
}
}
/* ----------------------------
* p_selectionComboCallback
* ----------------------------
*
*/
static void
p_selectionComboCallback (GtkWidget *widget)
{
gint idValue;
if(gap_debug)
{
printf("p_selectionComboCallback START\n");
}
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &idValue);
if(gap_debug)
{
printf("p_selectionComboCallback idValue:%d\n", idValue);
}
glob_vals.alt_selection = idValue;
} /* end p_selectionComboCallback */
void dialogStopPathChangedCallback(GtkWidget *widget, PlugInVals *vals) {
gint value;
#ifdef DEBUG
g_warning("dialogStopPathChangedCallback");
#endif
if (GTK_WIDGET_SENSITIVE(widget)) {
//if (gtk_widget_get_sensitive(widget)) {
if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(widget),&value)) {
vals->stop_path_id = value;
} else {
vals->stop_path_id = -1;
}
} else {
vals->stop_path_id = -1;
}
update_stop_path(vals);
renderPreview(vals);
}
void dialogMaskChangedCallback(GtkWidget *widget, PlugInVals *vals) {
gint value;
#ifdef DEBUG
g_warning("dialogMaskChangedCallback");
#endif
if (GTK_WIDGET_SENSITIVE(widget)) {
//if (gtk_widget_get_sensitive(widget)) {
if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(widget),&value)) {
vals->mask_drawable_id = value;
} else {
vals->mask_drawable_id = -1;
}
} else {
vals->mask_drawable_id = gimp_image_get_selection(gimp_drawable_get_image(vals->image_drawable_id));
}
update_mask(vals);
renderPreview(vals);
}
/*
* gfig_style_set_style_from_context() sets the values in the specified
* style to those that appear in the style control widgets f
*/
void
gfig_style_set_style_from_context (Style *style)
{
Style *current_style;
GimpRGB color;
gint value;
style->name = "object";
current_style = gfig_context_get_current_style ();
gimp_color_button_get_color (GIMP_COLOR_BUTTON (gfig_context->fg_color_button),
&color);
if (gfig_context->debug_styles)
g_printerr ("Setting foreground color to %lg %lg %lg\n",
color.r, color.g, color.b);
gfig_rgba_copy (&style->foreground, &color);
gimp_color_button_get_color (GIMP_COLOR_BUTTON (gfig_context->bg_color_button),
&color);
gfig_rgba_copy (&style->background, &color);
style->brush_name = current_style->brush_name;
if (!style->pattern || strcmp (style->pattern, current_style->pattern))
{
style->pattern = g_strdup (current_style->pattern); /* why strduping? */
}
style->gradient = current_style->gradient;
if (gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (gfig_context->fillstyle_combo), &value))
style->fill_type = value;
/* FIXME when there is an opacity control widget to read */
style->fill_opacity = 100.;
style->paint_type = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (gfig_context->paint_type_toggle));
}
static void
brushdmenuselect (GtkWidget *widget,
gpointer data)
{
GimpPixelRgn src_rgn;
guchar *src_row;
guchar *src;
gint id;
gint bpp;
gint x, y;
ppm_t *p;
gint x1, y1, x2, y2;
gint row;
GimpDrawable *drawable;
gint rowstride;
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (widget), &id);
if (id == -1)
return;
if (brush_from_file == 2)
return; /* Not finished GUI-building yet */
if (brush_from_file)
{
#if 0
unselectall (brush_list);
#endif
preset_save_button_set_sensitive (FALSE);
}
gtk_adjustment_set_value (brush_gamma_adjust, 1.0);
gtk_adjustment_set_value (brush_aspect_adjust, 0.0);
drawable = gimp_drawable_get (id);
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
bpp = gimp_drawable_bpp (drawable->drawable_id);
ppm_kill (&brushppm);
ppm_new (&brushppm, x2 - x1, y2 - y1);
p = &brushppm;
rowstride = p->width * 3;
src_row = g_new (guchar, (x2 - x1) * bpp);
gimp_pixel_rgn_init (&src_rgn, drawable,
0, 0, x2 - x1, y2 - y1,
FALSE, FALSE);
if (bpp == 3)
{ /* RGB */
int bpr = (x2 - x1) * 3;
for (row = 0, y = y1; y < y2; row++, y++)
{
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
memcpy (p->col + row*rowstride, src_row, bpr);
}
}
else
{ /* RGBA (bpp > 3) GrayA (bpp == 2) or Gray */
gboolean is_gray = ((bpp > 3) ? TRUE : FALSE);
for (row = 0, y = y1; y < y2; row++, y++)
{
guchar *tmprow = p->col + row * rowstride;
guchar *tmprow_ptr;
gimp_pixel_rgn_get_row (&src_rgn, src_row, x1, y, (x2 - x1));
src = src_row;
tmprow_ptr = tmprow;
/* Possible micro-optimization here:
* src_end = src + src_rgn.bpp * (x2-x1);
* for ( ; src < src_end ; src += src_rgn.bpp)
*/
for (x = x1; x < x2; x++)
{
*(tmprow_ptr++) = src[0];
*(tmprow_ptr++) = src[is_gray ? 1 : 0];
*(tmprow_ptr++) = src[is_gray ? 2 : 0];
src += src_rgn.bpp;
}
}
}
g_free (src_row);
if (bpp >= 3)
pcvals.color_brushes = 1;
else
pcvals.color_brushes = 0;
brush_from_file = 0;
update_brush_preview (NULL);
}
static gboolean
webpage_dialog (void)
{
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *image;
GtkWidget *label;
GtkWidget *entry;
GtkSizeGroup *sizegroup;
GtkAdjustment *adjustment;
GtkWidget *spinbutton;
GtkWidget *combo;
gint active;
gint status;
gboolean ret = FALSE;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Create from webpage"), PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("Cre_ate"), GTK_RESPONSE_OK,
NULL);
gimp_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
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, FALSE, FALSE, 0);
gtk_widget_show (hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
image = gtk_image_new_from_icon_name (GIMP_ICON_WEB,
GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
gtk_widget_show (image);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
label = gtk_label_new (_("Enter location (URI):"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_widget_set_size_request (entry, 400, -1);
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
if (webpagevals.url)
gtk_entry_set_text (GTK_ENTRY (entry),
webpagevals.url);
gtk_widget_show (entry);
sizegroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
/* Width */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox),
hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Width (pixels):"));
gtk_size_group_add_widget (sizegroup, label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
adjustment = gtk_adjustment_new (webpagevals.width,
1, 8192, 1, 10, 0);
spinbutton = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0);
gtk_widget_show (spinbutton);
/* Font size */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox),
hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Font size:"));
gtk_size_group_add_widget (sizegroup, label);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = gimp_int_combo_box_new (_("Huge"), 16,
_("Large"), 14,
C_("web-page", "Default"), 12,
_("Small"), 10,
_("Tiny"), 8,
NULL);
switch (webpagevals.font_size)
{
case 16:
case 14:
case 12:
case 10:
case 8:
active = webpagevals.font_size;
break;
default:
active = 12;
}
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (combo), active);
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
gtk_widget_show (combo);
g_object_unref (sizegroup);
status = gimp_dialog_run (GIMP_DIALOG (dialog));
if (status == GTK_RESPONSE_OK)
{
g_free (webpagevals.url);
webpagevals.url = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)));
webpagevals.width = (gint) gtk_adjustment_get_value (adjustment);
gimp_int_combo_box_get_active (GIMP_INT_COMBO_BOX (combo),
&webpagevals.font_size);
ret = TRUE;
}
gtk_widget_destroy (dialog);
return ret;
}
