static void
cm_blue_scale_callback (GtkAdjustment *adjustment,
CmParamsType *mix)
{
if (mix->monochrome)
{
mix->black.blue_gain = gtk_adjustment_get_value (adjustment) / 100.0;
}
else
{
switch (mix->output_channel)
{
case CM_RED_CHANNEL:
mix->red.blue_gain = gtk_adjustment_get_value (adjustment) / 100.0;
break;
case CM_GREEN_CHANNEL:
mix->green.blue_gain = gtk_adjustment_get_value (adjustment) / 100.0;
break;
case CM_BLUE_CHANNEL:
mix->blue.blue_gain = gtk_adjustment_get_value (adjustment) / 100.0;
break;
}
}
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
dialog_scale_update (GtkAdjustment *adjustment,
gdouble *value)
{
gimp_double_adjustment_update (adjustment, value);
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
mblur_radio_button_update (GtkWidget *widget,
gpointer data)
{
gimp_radio_button_update (widget, data);
mblur_set_sensitivity ();
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
/*
* 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
alienmap2_toggle_update (GtkWidget *widget,
gpointer data)
{
gimp_toggle_button_update (widget, data);
alienmap2_set_sensitive ();
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
alienmap2_radio_update (GtkWidget *widget,
gpointer data)
{
gimp_radio_button_update (widget, data);
alienmap2_set_labels ();
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
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
cm_preserve_luminosity_callback (GtkWidget *widget,
CmParamsType *mix)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
mix->preserve_luminosity = TRUE;
else
mix->preserve_luminosity = FALSE;
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
dialog_recursive_callback (GtkWidget *widget,
gpointer data)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
filter_type |= FILTER_RECURSIVE;
else
filter_type &= ~FILTER_RECURSIVE;
gimp_preview_invalidate (GIMP_PREVIEW (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
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
vpropagate_toggle_button_update (GtkWidget *widget,
gpointer data)
{
gint i, result;
gimp_toggle_button_update (widget, data);
for (i = result = 0; i < 4; i++)
result |= (direction_mask_vec[i] ? 1 : 0) << i;
vpvals.direction_mask = result;
vpvals.propagating_channel = ((propagate_alpha ? PROPAGATING_ALPHA : 0) |
(propagate_value ? PROPAGATING_VALUE : 0));
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
cm_update_ui (CmParamsType *mix)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->monochrome_toggle),
mix->monochrome);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (mix->preserve_luminosity_toggle),
mix->preserve_luminosity);
gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (mix->combo),
mix->output_channel);
cm_set_adjusters (mix);
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
static void
gimp_scrolled_preview_v_scroll (GtkAdjustment *vadj,
GimpPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview);
preview->yoff = gtk_adjustment_get_value (vadj);
gimp_preview_area_set_offsets (GIMP_PREVIEW_AREA (preview->area),
preview->xoff, preview->yoff);
if (! (priv->in_drag || priv->frozen))
{
gimp_preview_draw (preview);
gimp_preview_invalidate (preview);
}
}
/**
* gimp_scrolled_preview_thaw:
* @preview: a #GimpScrolledPreview
*
* While the @preview is frozen, it is not going to redraw itself in
* response to scroll events.
*
* This function should only be used to implement widgets derived from
* #GimpScrolledPreview. There is no point in calling this from a plug-in.
*
* Since: GIMP 2.4
**/
void
gimp_scrolled_preview_thaw (GimpScrolledPreview *preview)
{
GimpScrolledPreviewPrivate *priv;
g_return_if_fail (GIMP_IS_SCROLLED_PREVIEW (preview));
priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview);
g_return_if_fail (priv->frozen > 0);
priv->frozen--;
if (! priv->frozen)
{
gimp_preview_draw (GIMP_PREVIEW (preview));
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
}
static void
cm_monochrome_callback (GtkWidget *widget,
CmParamsType *mix)
{
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
{
mix->old_output_channel = mix->output_channel;
mix->monochrome = TRUE;
gtk_widget_set_sensitive (mix->combo, FALSE);
}
else
{
mix->output_channel = mix->old_output_channel;
mix->monochrome = FALSE;
gtk_widget_set_sensitive (mix->combo, TRUE);
}
cm_set_adjusters (mix);
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
void
temporarily_reset (GtkWidget * w, gpointer data)
{
static double threshold;
static double low;
int do_reset = !!data;
int current = settings.preview_channel;
if (do_reset)
{
if (channels > 2)
{
threshold = settings.colour_thresholds[current];
low = settings.colour_low[current];
settings.colour_thresholds[current] = 0.0;
settings.colour_low[current] = 1.0;
}
else
{
threshold = settings.gray_thresholds[current];
low = settings.gray_low[current];
settings.gray_thresholds[current] = 0.0;
settings.gray_low[current] = 1.0;
}
}
else
{
if (channels > 2)
{
settings.colour_thresholds[current] = threshold;
settings.colour_low[current] = low;
}
else
{
settings.gray_thresholds[current] = threshold;
settings.gray_low[current] = low;
}
}
gimp_preview_invalidate ((GimpPreview *) preview);
}
// GTK event handler for the graph widget
static gint graph_events (GtkWidget *widget, GdkEvent *event, PluginData *pd)
{
static GdkCursorType cursor_type = GDK_TOP_LEFT_ARROW;
int tx, ty, index, dist;
gdk_window_get_pointer (pd->graph->window, &tx, &ty, NULL);
if (event->type == GDK_EXPOSE)
{
if (pd->graph_pixmap == NULL)
pd->graph_pixmap = gdk_pixmap_new (pd->graph->window, GRAPH_WIDTH, GRAPH_HEIGHT, -1);
graph_redraw (pd);
}
else if (event->type == GDK_BUTTON_PRESS)
{
// Button press: add or grab a point
index = gdkpoint_bisect(tx, pd->curve_user.user_points, pd->curve_user.count);
if (index < pd->curve_user.count)
{
dist = pd->curve_user.user_points[index].x - tx;
}
if (index > 0 && tx - pd->curve_user.user_points[index-1].x < dist)
{
index -= 1;
dist = tx - pd->curve_user.user_points[index].x;
}
if (dist <= GRAPH_HOTSPOT || pd->curve_user.count == USER_POINT_COUNT)
pd->point_grabbed = curve_move_point(index, tx, ty, &pd->curve_user);
else
pd->point_grabbed = curve_add_point(tx, ty, &pd->curve_user);
pd->curve_user_changed = TRUE;
graph_redraw (pd);
gimp_preview_invalidate(GIMP_PREVIEW(pd->preview));
}
else if (event->type == GDK_BUTTON_RELEASE)
{
// Button release: move a point and remove it if requested
if (pd->point_grabbed >= 0) {
if (tx < 0 && pd->point_grabbed > 0) // if point is not first, remove it
curve_remove_point(pd->point_grabbed, &pd->curve_user);
else if (tx >= GRAPH_WIDTH && pd->point_grabbed+1 < pd->curve_user.count) // if point is not last, remove it
curve_remove_point(pd->point_grabbed, &pd->curve_user);
else
curve_move_point(pd->point_grabbed, CLAMPED(tx, 0,GRAPH_WIDTH-1), CLAMPED(ty, 0,GRAPH_HEIGHT-1), &pd->curve_user);
pd->point_grabbed = -1;
pd->curve_user_changed = TRUE;
graph_redraw (pd);
if (pd->do_preview_hd)
preview_hd(NULL, pd);
gimp_preview_invalidate(GIMP_PREVIEW(pd->preview));
}
}
else if (event->type == GDK_MOTION_NOTIFY)
{
// Mouse move: move a previously grabbed point
if (pd->point_grabbed >= 0){
pd->point_grabbed = curve_move_point(pd->point_grabbed, CLAMPED(tx, 0,GRAPH_WIDTH-1), CLAMPED(ty, 0,GRAPH_HEIGHT-1), &pd->curve_user);
pd->curve_user_changed = TRUE;
graph_redraw (pd);
gimp_preview_invalidate(GIMP_PREVIEW(pd->preview));
}
}
return FALSE;
}
static gboolean
gimp_scrolled_preview_area_event (GtkWidget *area,
GdkEvent *event,
GimpScrolledPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview);
GdkEventButton *button_event = (GdkEventButton *) event;
GdkCursor *cursor;
switch (event->type)
{
case GDK_BUTTON_PRESS:
switch (button_event->button)
{
case 1:
case 2:
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (area),
GDK_FLEUR);
if (gdk_pointer_grab (gtk_widget_get_window (area), TRUE,
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK,
NULL, cursor,
gdk_event_get_time (event)) == GDK_GRAB_SUCCESS)
{
gtk_widget_get_pointer (area, &priv->drag_x, &priv->drag_y);
priv->drag_xoff = GIMP_PREVIEW (preview)->xoff;
priv->drag_yoff = GIMP_PREVIEW (preview)->yoff;
priv->in_drag = TRUE;
gtk_grab_add (area);
}
gdk_cursor_unref (cursor);
break;
case 3:
return TRUE;
}
break;
case GDK_BUTTON_RELEASE:
if (priv->in_drag &&
(button_event->button == 1 || button_event->button == 2))
{
gdk_display_pointer_ungrab (gtk_widget_get_display (area),
gdk_event_get_time (event));
gtk_grab_remove (area);
priv->in_drag = FALSE;
}
break;
case GDK_MOTION_NOTIFY:
if (priv->in_drag)
{
GdkEventMotion *mevent = (GdkEventMotion *) event;
GtkAdjustment *hadj;
GtkAdjustment *vadj;
gint x, y;
hadj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
vadj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
gtk_widget_get_pointer (area, &x, &y);
x = priv->drag_xoff - (x - priv->drag_x);
y = priv->drag_yoff - (y - priv->drag_y);
x = CLAMP (x,
gtk_adjustment_get_lower (hadj),
gtk_adjustment_get_upper (hadj) -
gtk_adjustment_get_page_size (hadj));
y = CLAMP (y,
gtk_adjustment_get_lower (vadj),
gtk_adjustment_get_upper (vadj) -
gtk_adjustment_get_page_size (vadj));
if (GIMP_PREVIEW (preview)->xoff != x ||
GIMP_PREVIEW (preview)->yoff != y)
{
gtk_adjustment_set_value (hadj, x);
gtk_adjustment_set_value (vadj, y);
gimp_preview_draw (GIMP_PREVIEW (preview));
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
gdk_event_request_motions (mevent);
}
break;
case GDK_SCROLL:
{
GdkEventScroll *sevent = (GdkEventScroll *) event;
GdkScrollDirection direction = sevent->direction;
GtkAdjustment *adj;
gfloat value;
/* Ctrl-Scroll is reserved for zooming */
if (sevent->state & GDK_CONTROL_MASK)
return FALSE;
if (sevent->state & GDK_SHIFT_MASK)
switch (direction)
{
case GDK_SCROLL_UP: direction = GDK_SCROLL_LEFT; break;
case GDK_SCROLL_DOWN: direction = GDK_SCROLL_RIGHT; break;
case GDK_SCROLL_LEFT: direction = GDK_SCROLL_UP; break;
case GDK_SCROLL_RIGHT: direction = GDK_SCROLL_DOWN; break;
}
switch (direction)
{
case GDK_SCROLL_UP:
case GDK_SCROLL_DOWN:
default:
adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
break;
case GDK_SCROLL_RIGHT:
case GDK_SCROLL_LEFT:
adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
break;
}
value = gtk_adjustment_get_value (adj);
switch (direction)
{
case GDK_SCROLL_UP:
case GDK_SCROLL_LEFT:
value -= gtk_adjustment_get_page_increment (adj) / 2;
break;
case GDK_SCROLL_DOWN:
case GDK_SCROLL_RIGHT:
value += gtk_adjustment_get_page_increment (adj) / 2;
break;
}
gtk_adjustment_set_value (adj,
CLAMP (value,
gtk_adjustment_get_lower (adj),
gtk_adjustment_get_upper (adj) -
gtk_adjustment_get_page_size (adj)));
}
break;
default:
break;
}
return FALSE;
}
