void gui_init(struct dt_iop_module_t *self)
{
// init the slider (more sophisticated layouts are possible with gtk tables and boxes):
self->gui_data = malloc(sizeof(dt_iop_anlfyeni_gui_data_t));
dt_iop_anlfyeni_gui_data_t *g = (dt_iop_anlfyeni_gui_data_t *)self->gui_data;
dt_iop_anlfyeni_params_t *p = (dt_iop_anlfyeni_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox), TRUE, TRUE, 5);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.001, 0.07, 0.001, p->alpha, 3));
g_object_set (GTK_OBJECT(g->scale1), "tooltip-text", _("sensitivity of edge detection"), (char *)NULL);
dtgtk_slider_set_label(g->scale1,_("sensitivity"));
// dtgtk_slider_set_accel(g->scale1,darktable.control->accels_darkroom,"<Darktable>/darkroom/modules/local_contrast_2/sensitivity");
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 6.0000, 0.010, p->scale, 3));
g_object_set (GTK_OBJECT(g->scale2), "tooltip-text", _("spatial extent of the effect around edges"), (char *)NULL);
dtgtk_slider_set_label(g->scale2,_("scale"));
// dtgtk_slider_set_accel(g->scale2,darktable.control->accels_darkroom,"<Darktable>/darkroom/modules/local_contrast_2/scale");
g->scale3 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 10.0000, 0.001, p->strength, 3));
g_object_set (GTK_OBJECT(g->scale3), "tooltip-text", _("strength of the local contrast"), (char *)NULL);
dtgtk_slider_set_label(g->scale3,_("strength"));
// dtgtk_slider_set_accel(g->scale3,darktable.control->accels_darkroom,"<Darktable>/darkroom/modules/local_contrast_2/strength");
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale3), TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (alpha_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (scale_callback), self);
g_signal_connect (G_OBJECT (g->scale3), "value-changed",
G_CALLBACK (strength_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_rlce_gui_data_t));
dt_iop_rlce_gui_data_t *g = (dt_iop_rlce_gui_data_t *)self->gui_data;
dt_iop_rlce_params_t *p = (dt_iop_rlce_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox1 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->vbox2 = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox1), FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox2), TRUE, TRUE, 5);
g->label1 = dtgtk_reset_label_new(_("radius"), self, &p->radius, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), g->label1, TRUE, TRUE, 0);
g->label2 = dtgtk_reset_label_new(_("amount"), self, &p->slope, sizeof(float));
gtk_box_pack_start(GTK_BOX(g->vbox1), g->label2, TRUE, TRUE, 0);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 256.0, 1.0, p->radius, 0));
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,1.0, 3.0, 0.05, p->slope, 2));
//dtgtk_slider_set_format_type(g->scale2,DARKTABLE_SLIDER_FORMAT_PERCENT);
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox2), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("size of features to preserve"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("strength of the effect"), (char *)NULL);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (radius_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (slope_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_grain_gui_data_t));
dt_iop_grain_gui_data_t *g = (dt_iop_grain_gui_data_t *)self->gui_data;
dt_iop_grain_params_t *p = (dt_iop_grain_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox), TRUE, TRUE, 5);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 100.0, 3200.0, 20.0, p->scale*53.3, 0));
dtgtk_slider_set_snap(g->scale1, 20);
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 0.0, 100.0, 1.0, p->strength, 2));
dtgtk_slider_set_format_type(g->scale2,DARKTABLE_SLIDER_FORMAT_PERCENT);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the grain size (~iso of the film)"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("the strength of applied grain"), (char *)NULL);
dtgtk_slider_set_label(g->scale1,_("coarseness"));
dtgtk_slider_set_unit(g->scale1,"ISO");
dtgtk_slider_set_label(g->scale2,_("strength"));
dtgtk_slider_set_unit(g->scale2,"%");
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (scale_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (strength_callback), self);
}
static gboolean _slider_entry_key_event(GtkWidget* widget, GdkEventKey* event, gpointer data)
{
if (event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter)
_slider_entry_commit(DTGTK_SLIDER(data));
if (event->keyval==GDK_KEY_Escape || event->keyval==GDK_KEY_Tab)
_slider_entry_abort(DTGTK_SLIDER(data));
else if( // Masking allowed keys...
event->keyval == GDK_KEY_minus || event->keyval == GDK_KEY_KP_Subtract ||
event->keyval == GDK_KEY_plus || event->keyval == GDK_KEY_KP_Add ||
event->keyval == GDK_KEY_period || event->keyval == GDK_KEY_KP_Decimal ||
event->keyval == GDK_KEY_Left ||
event->keyval == GDK_KEY_Right ||
event->keyval == GDK_KEY_Delete ||
event->keyval == GDK_KEY_BackSpace ||
event->keyval == GDK_KEY_0 || event->keyval == GDK_KEY_KP_0 ||
event->keyval == GDK_KEY_1 || event->keyval == GDK_KEY_KP_1 ||
event->keyval == GDK_KEY_2 || event->keyval == GDK_KEY_KP_2 ||
event->keyval == GDK_KEY_3 || event->keyval == GDK_KEY_KP_3 ||
event->keyval == GDK_KEY_4 || event->keyval == GDK_KEY_KP_4 ||
event->keyval == GDK_KEY_5 || event->keyval == GDK_KEY_KP_5 ||
event->keyval == GDK_KEY_6 || event->keyval == GDK_KEY_KP_6 ||
event->keyval == GDK_KEY_7 || event->keyval == GDK_KEY_KP_7 ||
event->keyval == GDK_KEY_8 || event->keyval == GDK_KEY_KP_8 ||
event->keyval == GDK_KEY_9 || event->keyval == GDK_KEY_KP_9
)
{
return FALSE;
}
// Prevent all other keys within entry
return TRUE;
}
void gui_init (dt_iop_module_t *self)
{
// init the slider (more sophisticated layouts are possible with gtk tables and boxes):
self->gui_data = malloc(sizeof(dt_iop_colorcontrast_gui_data_t));
dt_iop_colorcontrast_gui_data_t *g = (dt_iop_colorcontrast_gui_data_t *)self->gui_data;
dt_iop_colorcontrast_params_t *p = (dt_iop_colorcontrast_params_t *)self->params;
g->a_scale = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 0.0, 5.0, 0.01, p->a_steepness, 2));
dtgtk_slider_set_label(g->a_scale,_("green vs magenta"));
g->b_scale = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 0.0, 5.0, 0.01, p->b_steepness, 2));
dtgtk_slider_set_label(g->b_scale,_("blue vs yellow"));
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
g->vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->vbox), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->a_scale), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->b_scale), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->a_scale), "tooltip-text",
_("steepness of the a* curve in Lab"), (char *)NULL);
g_object_set(G_OBJECT(g->b_scale), "tooltip-text",
_("steepness of the b* curve in Lab"), (char *)NULL);
g_signal_connect(G_OBJECT(g->a_scale), "value-changed",
G_CALLBACK(a_slider_callback), self);
g_signal_connect(G_OBJECT(g->b_scale), "value-changed",
G_CALLBACK(b_slider_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_relight_gui_data_t));
dt_iop_relight_gui_data_t *g = (dt_iop_relight_gui_data_t *)self->gui_data;
dt_iop_relight_params_t *p = (dt_iop_relight_params_t *)self->params;
self->widget = gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING);
g_signal_connect (G_OBJECT (self->widget), "expose-event", G_CALLBACK (expose), self);
/* adding the labels */
g->scale1 = DTGTK_SLIDER (dtgtk_slider_new_with_range (DARKTABLE_SLIDER_BAR,-2.0, 2.0,0.05, p->ev, 2));
g->scale2 = DTGTK_SLIDER (dtgtk_slider_new_with_range (DARKTABLE_SLIDER_BAR,2, 10, 0.5, p->width, 1));
dtgtk_slider_set_label(g->scale1, _("exposure"));
dtgtk_slider_set_unit(g->scale1, "EV");
dtgtk_slider_set_force_sign(g->scale1, TRUE);
dtgtk_slider_set_label(g->scale2, _("width"));
/* lightnessslider */
GtkBox *hbox=GTK_BOX (gtk_hbox_new (FALSE,2));
int lightness=32768;
g->gslider1=DTGTK_GRADIENT_SLIDER (dtgtk_gradient_slider_new_with_color ((GdkColor)
{
0,0,0,0
},(GdkColor)
{
0,lightness,lightness,lightness
}));
g_object_set(G_OBJECT (g->gslider1), "tooltip-text", _("select the center of fill-light"), (char *)NULL);
g_signal_connect (G_OBJECT (g->gslider1), "value-changed",
G_CALLBACK (center_callback), self);
g->tbutton1 = DTGTK_TOGGLEBUTTON (dtgtk_togglebutton_new (dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
gtk_widget_set_size_request(GTK_WIDGET(g->tbutton1),22,22);
g_signal_connect (G_OBJECT (g->tbutton1), "toggled",
G_CALLBACK (picker_callback), self);
gtk_box_pack_start (hbox,GTK_WIDGET (g->gslider1),TRUE,TRUE,0);
gtk_box_pack_start (hbox,GTK_WIDGET (g->tbutton1),FALSE,FALSE,0);
/* add controls to widget ui */
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET (g->scale1),TRUE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET (hbox), TRUE,FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET (g->scale2),TRUE,FALSE,0);
g_object_set(G_OBJECT(g->tbutton1), "tooltip-text", _("toggle tool for picking median lightness in image"), (char *)NULL);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the fill-light in EV"), (char *)NULL);
/* xgettext:no-c-format */
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("width of fill-light area defined in zones"), (char *)NULL);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (ev_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (width_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_channelmixer_gui_data_t));
dt_iop_channelmixer_gui_data_t *g = (dt_iop_channelmixer_gui_data_t *)self->gui_data;
dt_iop_channelmixer_params_t *p = (dt_iop_channelmixer_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
g->dtlabel1 = DTGTK_LABEL( dtgtk_label_new(_("output channel"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT) );
g->combo1 = GTK_COMBO_BOX( gtk_combo_box_new_text() );
gtk_combo_box_append_text(g->combo1,_("hue"));
gtk_combo_box_append_text(g->combo1,_("saturation"));
gtk_combo_box_append_text(g->combo1,_("lightness"));
gtk_combo_box_append_text(g->combo1,_("red"));
gtk_combo_box_append_text(g->combo1,_("green"));
gtk_combo_box_append_text(g->combo1,_("blue"));
gtk_combo_box_append_text(g->combo1,_("gray"));
gtk_combo_box_set_active(g->combo1, CHANNEL_RED );
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->dtlabel1), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->combo1), TRUE, TRUE, 5);
g->dtlabel2 = DTGTK_LABEL( dtgtk_label_new(_("source channels"), DARKTABLE_LABEL_TAB | DARKTABLE_LABEL_ALIGN_RIGHT) );
GtkBox *hbox = GTK_BOX( gtk_hbox_new(FALSE, 0));
g->vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->vbox), TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->dtlabel2), TRUE, TRUE, 5);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,-2.0, 2.0, 0.005, p->red[CHANNEL_RED] , 3));
g_object_set (GTK_OBJECT(g->scale1), "tooltip-text", _("amount of red channel in the output channel"), (char *)NULL);
dtgtk_slider_set_label(g->scale1,_("red"));
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,-2.0, 2.0, 0.005, p->green[CHANNEL_RED] , 3));
g_object_set (GTK_OBJECT(g->scale2), "tooltip-text", _("amount of green channel in the output channel"), (char *)NULL);
dtgtk_slider_set_label(g->scale2,_("green"));
g->scale3 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,-2.0, 2.0, 0.005, p->blue[CHANNEL_RED] , 3));
g_object_set (GTK_OBJECT(g->scale3), "tooltip-text", _("amount of blue channel in the output channel"), (char *)NULL);
dtgtk_slider_set_label(g->scale3,_("blue"));
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(g->vbox), GTK_WIDGET(g->scale3), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 5);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (red_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (green_callback), self);
g_signal_connect (G_OBJECT (g->scale3), "value-changed",
G_CALLBACK (blue_callback), self);
g_signal_connect (G_OBJECT (g->combo1), "changed",
G_CALLBACK (output_callback), self);
}
static gboolean _slider_postponed_value_change(gpointer data)
{
gboolean i_own_lock = dt_control_gdk_lock();
if (DTGTK_SLIDER(data)->is_changed==TRUE)
{
g_signal_emit_by_name(G_OBJECT(data),"value-changed");
if(DTGTK_SLIDER(data)->type==DARKTABLE_SLIDER_VALUE)
DTGTK_SLIDER(data)->is_changed=FALSE;
}
if (i_own_lock) dt_control_gdk_unlock();
return DTGTK_SLIDER(data)->is_dragging; // This is called by the gtk mainloop and is threadsafe
}
static gboolean _slider_enter_notify_event(GtkWidget *widget, GdkEventCrossing *event)
{
gtk_widget_set_state(widget,(event->type == GDK_ENTER_NOTIFY)?GTK_STATE_PRELIGHT:GTK_STATE_NORMAL);
gtk_widget_queue_draw(widget);
DTGTK_SLIDER(widget)->prev_x_root=event->x_root;
return FALSE;
}
static void _slider_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
{
g_return_if_fail(widget != NULL);
g_return_if_fail(DTGTK_IS_SLIDER(widget));
g_return_if_fail(allocation != NULL);
gtk_widget_set_allocation(widget, allocation);
GTK_WIDGET_CLASS(_slider_parent_class)->size_allocate(widget, allocation);
if(gtk_widget_get_realized(widget))
{
gdk_window_move_resize(gtk_widget_get_window(widget), allocation->x, allocation->y, allocation->width,
allocation->height);
if(DTGTK_SLIDER(widget)->is_entry_active == FALSE) gtk_widget_hide(DTGTK_SLIDER(widget)->entry);
}
}
static gboolean _slider_button_press(GtkWidget *widget, GdkEventButton *event)
{
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
GtkDarktableSlider *slider=DTGTK_SLIDER(widget);
if( event->button==3)
{
/* right mouse button, bring up the in place edit*/
char sv[32]= {0};
slider->is_entry_active=TRUE;
gdouble value = gtk_adjustment_get_value(slider->adjustment);
sprintf(sv,"%.*f",slider->digits,value);
gtk_entry_set_text (GTK_ENTRY(slider->entry),sv);
gtk_widget_show (GTK_WIDGET(slider->entry));
gtk_widget_grab_focus (GTK_WIDGET(slider->entry));
gtk_widget_queue_draw (widget);
}
else if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
{
/* handle single button press */
if (event->x > (allocation.width - DTGTK_SLIDER_ADJUST_BUTTON_WIDTH - DTGTK_SLIDER_BORDER_WIDTH))
{
/* press event in arrow up/down area of slider control*/
float value = gtk_adjustment_get_value(slider->adjustment);
if (event->y > (allocation.height/2.0))
value -= gtk_adjustment_get_step_increment(slider->adjustment);
else
value += gtk_adjustment_get_step_increment(slider->adjustment);
if(slider->snapsize) value = slider->snapsize * (((int)value)/slider->snapsize);
gtk_adjustment_set_value(slider->adjustment, value);
gtk_widget_queue_draw(widget);
g_signal_emit_by_name(G_OBJECT(widget),"value-changed");
}
else
{
slider->is_dragging=TRUE;
slider->prev_x_root=event->x_root;
if( slider->type==DARKTABLE_SLIDER_BAR) slider->is_changed=TRUE;
#if 0 // Deprecate
g_timeout_add(DTGTK_SLIDER_VALUE_CHANGED_DELAY, _slider_postponed_value_change, widget);
#endif
}
}
else if(event->button == 1 && event->type == GDK_2BUTTON_PRESS)
{
if(event->x < slider->labelwidth && event->y < slider->labelheight)
{
/* left mouse second click of doubleclick event */
slider->is_dragging=FALSE; // otherwise button_release will overwrite our changes
gtk_adjustment_set_value(slider->adjustment, slider->default_value);
gtk_widget_queue_draw(widget);
g_signal_emit_by_name(G_OBJECT(widget),"value-changed");
}
}
return TRUE;
}
static void
gain_callback (GtkWidget *slider, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
if(self->dt->gui->reset) return;
dt_iop_exposure_params_t *p = (dt_iop_exposure_params_t *)self->params;
p->gain = dtgtk_slider_get_value(DTGTK_SLIDER(slider));
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
static gboolean slider_reset_callback(GtkAccelGroup *accel_group,
GObject *acceleratable, guint keyval,
GdkModifierType modifier, gpointer data)
{
GtkDarktableSlider *slider=DTGTK_SLIDER(data);
gtk_adjustment_set_value(slider->adjustment, slider->default_value);
gtk_widget_draw(GTK_WIDGET(slider),NULL);
g_signal_emit_by_name(G_OBJECT(slider),"value-changed");
return TRUE;
}
void gui_init (dt_iop_module_t *self)
{
// init the slider (more sophisticated layouts are possible with gtk tables and boxes):
self->gui_data = malloc(sizeof(dt_iop_useless_gui_data_t));
dt_iop_useless_gui_data_t *g = (dt_iop_useless_gui_data_t *)self->gui_data;
g->scale = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_VALUE, 1, 100, 1, 50, 0));
dtgtk_slider_set_accel(g->scale,darktable.control->accels_darkroom,"<Darktable>/darkroom/plugins/useless/useless");
self->widget = GTK_WIDGET(g->scale);
g_signal_connect (G_OBJECT (g->scale), "value-changed",
G_CALLBACK (slider_callback), self);
}
static void
autoexpp_callback (GtkDarktableSlider *slider, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
if(self->dt->gui->reset) return;
if(!self->request_color_pick) return;
dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data;
const float white = fmaxf(fmaxf(self->picked_color_max[0], self->picked_color_max[1]), self->picked_color_max[2])
* (1.0-dtgtk_slider_get_value(DTGTK_SLIDER(g->autoexpp)));
exposure_set_white(self, white);
}
GtkWidget *dtgtk_slider_new_with_range (darktable_slider_type_t type,gdouble min,gdouble max,gdouble step,gdouble value, gint digits)
{
GtkAdjustment *adj = (GtkAdjustment *)gtk_adjustment_new (value, min, max, step, step, 0);
GtkDarktableSlider *slider=DTGTK_SLIDER(dtgtk_slider_new(adj));
slider->default_value=value;
slider->type=type;
slider->digits=digits;
slider->is_entry_active=FALSE;
slider->snapsize = 0;
slider->labelwidth = slider->labelheight = 0;
return GTK_WIDGET(slider);
}
static gboolean _slider_scroll_event(GtkWidget *widget, GdkEventScroll *event)
{
double inc = gtk_adjustment_get_step_increment(DTGTK_SLIDER(widget)->adjustment);
DTGTK_SLIDER(widget)->is_sensibility_key_pressed = (event->state & GDK_CONTROL_MASK) ? TRUE : FALSE;
inc *= (DTGTK_SLIDER(widget)->is_sensibility_key_pressed == TRUE) ? 1.0 : DTGTK_VALUE_SENSITIVITY;
float value = gtk_adjustment_get_value(DTGTK_SLIDER(widget)->adjustment)
+ ((event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_RIGHT) ? inc : -inc);
if(DTGTK_SLIDER(widget)->snapsize)
value = DTGTK_SLIDER(widget)->snapsize * (((int)value) / DTGTK_SLIDER(widget)->snapsize);
gtk_adjustment_set_value(DTGTK_SLIDER(widget)->adjustment, value);
gtk_widget_queue_draw(widget);
g_signal_emit_by_name(G_OBJECT(widget), "value-changed");
return TRUE;
}
static gboolean _slider_motion_notify(GtkWidget *widget, GdkEventMotion *event)
{
GtkDarktableSlider *slider = DTGTK_SLIDER(widget);
slider->is_sensibility_key_pressed = (event->state & GDK_CONTROL_MASK) ? TRUE : FALSE;
if(slider->is_dragging == TRUE)
{
// First get some dimension info
GdkRectangle vr;
_slider_get_value_area(widget, &vr);
if((slider->prev_x_root < (gint)event->x_root))
slider->motion_direction = 1;
else if(slider->prev_x_root > (gint)event->x_root)
slider->motion_direction = -1;
// Adjust rect to match dimensions for bar
vr.x += DTGTK_SLIDER_BORDER_WIDTH * 2;
vr.width -= (DTGTK_SLIDER_BORDER_WIDTH * 4);
gint vmx = event->x - vr.x;
if(slider->type == DARKTABLE_SLIDER_VALUE
|| (slider->type == DARKTABLE_SLIDER_BAR && slider->is_sensibility_key_pressed == TRUE))
{
gdouble inc = gtk_adjustment_get_step_increment(slider->adjustment);
if(DARKTABLE_SLIDER_VALUE && !slider->is_sensibility_key_pressed) inc *= DTGTK_VALUE_SENSITIVITY;
gdouble value
= gtk_adjustment_get_value(slider->adjustment)
+ (((slider->prev_x_root <= (gint)event->x_root) && slider->motion_direction == 1) ? (inc)
: -(inc));
if(slider->snapsize) value = slider->snapsize * (((int)value) / slider->snapsize);
gtk_adjustment_set_value(slider->adjustment, value);
slider->is_changed = TRUE;
}
else if(slider->type == DARKTABLE_SLIDER_BAR)
{
if(vmx >= 0 && vmx <= vr.width)
{
float value = _slider_translate_pos_to_value(slider->adjustment, &vr, vmx);
if(slider->snapsize) value = slider->snapsize * (((int)value) / slider->snapsize);
gtk_adjustment_set_value(slider->adjustment, value);
}
}
g_signal_emit_by_name(G_OBJECT(widget), "value-changed");
gtk_widget_queue_draw(widget);
slider->prev_x_root = event->x_root;
}
return FALSE;
}
static gboolean slider_decrease_callback(GtkAccelGroup *accel_group,
GObject *acceleratable, guint keyval,
GdkModifierType modifier, gpointer data)
{
GtkDarktableSlider *slider=DTGTK_SLIDER(data);
float value = gtk_adjustment_get_value(slider->adjustment);
value -= gtk_adjustment_get_step_increment(slider->adjustment);
if(slider->snapsize) value = slider->snapsize * (((int)value)/slider->snapsize);
gtk_adjustment_set_value(slider->adjustment, value);
gtk_widget_draw(GTK_WIDGET(slider),NULL);
g_signal_emit_by_name(G_OBJECT(slider),"value-changed");
return TRUE;
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_shrecovery_gui_data_t));
dt_iop_shrecovery_gui_data_t *g = (dt_iop_shrecovery_gui_data_t *)self->gui_data;
dt_iop_shrecovery_params_t *p = (dt_iop_shrecovery_params_t *)self->params;
self->widget = gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,-2.0, 6.0, 0.01, p->strength, 2));
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.1, 0.9, 0.01, p->mu, 2));
g->scale3 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.05, 0.6, 0.01, p->sigma, 2));
g->scale4 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 2.0, 64.0, 1, p->size_limit, 0));
dtgtk_slider_set_snap(g->scale4, 1);
dtgtk_slider_set_label(g->scale1,_("strength"));
dtgtk_slider_set_label(g->scale2,_("mean"));
dtgtk_slider_set_label(g->scale3,_("deviation"));
dtgtk_slider_set_label(g->scale4,_("minimal pyramid limit"));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale3), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->scale4), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->scale1), "tooltip-text", _("the strength of lighten"), (char *)NULL);
g_object_set(G_OBJECT(g->scale2), "tooltip-text", _("optimal exposedness"), (char *)NULL);
g_object_set(G_OBJECT(g->scale3), "tooltip-text", _("exposedness deviation"), (char *)NULL);
g_object_set(G_OBJECT(g->scale4), "tooltip-text", _("minimal pyramid limit size"), (char *)NULL);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (strength_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (mu_callback), self);
g_signal_connect (G_OBJECT (g->scale3), "value-changed",
G_CALLBACK (sigma_callback), self);
g_signal_connect (G_OBJECT (g->scale4), "value-changed",
G_CALLBACK (size_limit_callback), self);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_lowlight_gui_data_t));
dt_iop_lowlight_gui_data_t *c = (dt_iop_lowlight_gui_data_t *)self->gui_data;
dt_iop_lowlight_params_t *p = (dt_iop_lowlight_params_t *)self->params;
c->transition_curve = dt_draw_curve_new(0.0, 1.0, CATMULL_ROM);
(void)dt_draw_curve_add_point(c->transition_curve, p->transition_x[DT_IOP_LOWLIGHT_BANDS-2]-1.0, p->transition_y[DT_IOP_LOWLIGHT_BANDS-2]);
for(int k=0; k<DT_IOP_LOWLIGHT_BANDS; k++) (void)dt_draw_curve_add_point(c->transition_curve, p->transition_x[k], p->transition_y[k]);
(void)dt_draw_curve_add_point(c->transition_curve, p->transition_x[1]+1.0, p->transition_y[1]);
c->mouse_x = c->mouse_y = c->mouse_pick = -1.0;
c->dragging = 0;
c->x_move = -1;
c->mouse_radius = 1.0/DT_IOP_LOWLIGHT_BANDS;
self->widget = GTK_WIDGET(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
c->area = GTK_DRAWING_AREA(gtk_drawing_area_new());
gtk_drawing_area_size(c->area, 195, 195);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(c->area),FALSE, FALSE, 0);
gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK);
g_signal_connect (G_OBJECT (c->area), "expose-event",
G_CALLBACK (lowlight_expose), self);
g_signal_connect (G_OBJECT (c->area), "button-press-event",
G_CALLBACK (lowlight_button_press), self);
g_signal_connect (G_OBJECT (c->area), "button-release-event",
G_CALLBACK (lowlight_button_release), self);
g_signal_connect (G_OBJECT (c->area), "motion-notify-event",
G_CALLBACK (lowlight_motion_notify), self);
g_signal_connect (G_OBJECT (c->area), "leave-notify-event",
G_CALLBACK (lowlight_leave_notify), self);
g_signal_connect (G_OBJECT (c->area), "scroll-event",
G_CALLBACK (lowlight_scrolled), self);
c->scale_blueness = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 100.0, 5.0, p->blueness, 2));
dtgtk_slider_set_default_value(c->scale_blueness, p->blueness);
dtgtk_slider_set_label(c->scale_blueness,_("blue shift"));
dtgtk_slider_set_unit(c->scale_blueness,"%");
dtgtk_slider_set_format_type(c->scale_blueness,DARKTABLE_SLIDER_FORMAT_PERCENT);
g_object_set(G_OBJECT(c->scale_blueness), "tooltip-text", _("blueness in shadows"), (char *)NULL);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(c->scale_blueness), TRUE, TRUE, 5);
g_signal_connect (G_OBJECT (c->scale_blueness), "value-changed",
G_CALLBACK (blueness_callback), self);
}
static gboolean slider_edit_callback(GtkAccelGroup *accel_group,
GObject *acceleratable, guint keyval,
GdkModifierType modifier, gpointer data)
{
GtkDarktableSlider *slider=DTGTK_SLIDER(data);
char sv[32]= {0};
slider->is_entry_active=TRUE;
gdouble value = gtk_adjustment_get_value(slider->adjustment);
sprintf(sv,"%.*f",slider->digits,value);
gtk_entry_set_text (GTK_ENTRY(slider->entry),sv);
gtk_widget_show (GTK_WIDGET(slider->entry));
gtk_widget_grab_focus (GTK_WIDGET(slider->entry));
gtk_widget_queue_draw (GTK_WIDGET(slider));
return TRUE;
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_profile_gamma_gui_data_t));
dt_iop_profile_gamma_gui_data_t *g = (dt_iop_profile_gamma_gui_data_t *)self->gui_data;
dt_iop_profile_gamma_params_t *p = (dt_iop_profile_gamma_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
GtkWidget *vbox = gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(vbox), TRUE, TRUE, 5);
g->scale1 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 1.0, 0.0001,p->linear,4));
g_object_set (GTK_OBJECT(g->scale1), "tooltip-text", _("linear part"), (char *)NULL);
dtgtk_slider_set_label(g->scale1,_("linear"));
g->scale2 = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 1.0, 0.0001,p->gamma,4));
g_object_set (GTK_OBJECT(g->scale2), "tooltip-text", _("gamma exponential factor"), (char *)NULL);
dtgtk_slider_set_label(g->scale2,_("gamma"));
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->scale1), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->scale2), TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (g->scale1), "value-changed",
G_CALLBACK (linear_callback), self);
g_signal_connect (G_OBJECT (g->scale2), "value-changed",
G_CALLBACK (gamma_callback), self);
}
// TODO: some quality/compression stuff in case "off" is selected
void gui_init(dt_imageio_module_format_t *self)
{
dt_imageio_j2k_gui_t *gui = (dt_imageio_j2k_gui_t *)malloc(sizeof(dt_imageio_j2k_gui_t));
self->gui_data = (void *)gui;
self->widget = gtk_vbox_new(TRUE, 5);
GtkWidget *hbox = gtk_hbox_new(TRUE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox, TRUE, TRUE, 0);
int format_last = dt_conf_get_int("plugins/imageio/format/j2k/format");
int preset_last = dt_conf_get_int("plugins/imageio/format/j2k/preset");
int quality_last = dt_conf_get_int("plugins/imageio/format/j2k/quality");
GtkWidget *radiobutton = gtk_radio_button_new_with_label(NULL, _("jp2"));
gui->jp2 = GTK_TOGGLE_BUTTON(radiobutton);
gtk_box_pack_start(GTK_BOX(hbox), radiobutton, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(radiobutton), "toggled", G_CALLBACK(radiobutton_changed), (gpointer)JP2_CFMT);
if(format_last == JP2_CFMT) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton), TRUE);
radiobutton = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radiobutton), _("j2k"));
gui->j2k = GTK_TOGGLE_BUTTON(radiobutton);
gtk_box_pack_start(GTK_BOX(hbox), radiobutton, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(radiobutton), "toggled", G_CALLBACK(radiobutton_changed), (gpointer)J2K_CFMT);
if(format_last == J2K_CFMT) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton), TRUE);
gui->quality = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 1, 100, 1, 97, 0));
dtgtk_slider_set_label(gui->quality,_("quality"));
dtgtk_slider_set_default_value(gui->quality, 97);
if(quality_last > 0 && quality_last <= 100)
dtgtk_slider_set_value(gui->quality, quality_last);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(gui->quality), TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (gui->quality), "value-changed", G_CALLBACK (quality_changed), (gpointer)0);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(self->widget), hbox, TRUE, TRUE, 0);
GtkWidget *label = gtk_label_new(_("dcp mode"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
GtkWidget *combo = gtk_combo_box_new_text();
gui->preset = GTK_COMBO_BOX(combo);
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("off"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("cinema2k, 24fps"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("cinema2k, 48fps"));
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("cinema4k, 24fps"));
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), preset_last);
gtk_box_pack_start(GTK_BOX(hbox), combo, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(combobox_changed), NULL);
// TODO: options for "off"
}
static gboolean
expose (GtkWidget *widget, GdkEventExpose *event, dt_iop_module_t *self)
{
if(darktable.gui->reset) return FALSE;
if(self->picked_color_max[0] < 0) return FALSE;
if(!self->request_color_pick) return FALSE;
dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data;
const float white = fmaxf(fmaxf(self->picked_color_max[0], self->picked_color_max[1]), self->picked_color_max[2])
* (1.0-dtgtk_slider_get_value(DTGTK_SLIDER(g->autoexpp)));
const float black = fminf(fminf(self->picked_color_min[0], self->picked_color_min[1]), self->picked_color_min[2]);
exposure_set_white(self, white);
exposure_set_black(self, black);
return FALSE;
}
static void exposure_set_white(struct dt_iop_module_t *self, const float white)
{
dt_iop_exposure_params_t *p = (dt_iop_exposure_params_t *)self->params;
float exposure = white2exposure(white);
if (p->exposure == exposure) return;
p->exposure = exposure;
if (p->black >= white) exposure_set_black(self, white-0.01);
dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data;
darktable.gui->reset = 1;
dtgtk_slider_set_value(DTGTK_SLIDER(g->exposure), p->exposure);
darktable.gui->reset = 0;
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
void
gui_init (dt_imageio_module_format_t *self)
{
dt_imageio_jpeg_gui_data_t *g = (dt_imageio_jpeg_gui_data_t *)malloc(sizeof(dt_imageio_jpeg_gui_data_t));
self->gui_data = g;
// construct gui with jpeg specific options:
GtkWidget *box = gtk_hbox_new(FALSE, 20);
self->widget = box;
// quality slider
g->quality = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR, 0, 100, 1, 97, 0));
dtgtk_slider_set_label(g->quality,_("quality"));
dtgtk_slider_set_default_value(g->quality, 97);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->quality), TRUE, TRUE, 0);
g_signal_connect (G_OBJECT (g->quality), "value-changed",
G_CALLBACK (quality_changed),
(gpointer)0);
// TODO: add more options: subsample dreggn
}
static void exposure_set_black(struct dt_iop_module_t *self, const float black)
{
dt_iop_exposure_params_t *p = (dt_iop_exposure_params_t *)self->params;
float b = black;
if (p->black == b) return;
p->black = b;
if (p->black >= exposure2white(p->exposure))
{
exposure_set_white(self, p->black+0.01);
}
dt_iop_exposure_gui_data_t *g = (dt_iop_exposure_gui_data_t *)self->gui_data;
darktable.gui->reset = 1;
dtgtk_slider_set_value(DTGTK_SLIDER(g->black), p->black);
darktable.gui->reset = 0;
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_vibrance_gui_data_t));
dt_iop_vibrance_gui_data_t *g = (dt_iop_vibrance_gui_data_t *)self->gui_data;
dt_iop_vibrance_params_t *p = (dt_iop_vibrance_params_t *)self->params;
self->widget = GTK_WIDGET(gtk_hbox_new(FALSE, 0));
GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, DT_GUI_IOP_MODULE_CONTROL_SPACING));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(vbox), TRUE, TRUE, 5);
g->amount_scale = DTGTK_SLIDER(dtgtk_slider_new_with_range(DARKTABLE_SLIDER_BAR,0.0, 100.0, 1, p->amount, 0));
dtgtk_slider_set_format_type(g->amount_scale,DARKTABLE_SLIDER_FORMAT_PERCENT);
dtgtk_slider_set_label(g->amount_scale,_("vibrance"));
dtgtk_slider_set_unit(g->amount_scale,"%");
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(g->amount_scale), TRUE, TRUE, 0);
g_object_set(G_OBJECT(g->amount_scale), "tooltip-text", _("the amount of vibrance"), (char *)NULL);
g_signal_connect (G_OBJECT (g->amount_scale), "value-changed",
G_CALLBACK (amount_callback), self);
}
static gboolean _slider_button_release(GtkWidget *widget, GdkEventButton *event)
{
GtkDarktableSlider *slider = DTGTK_SLIDER(widget);
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
if(event->button == 1)
{
/* if x is in slider bar */
if(event->x < (allocation.width - DTGTK_SLIDER_ADJUST_BUTTON_WIDTH - DTGTK_SLIDER_BORDER_WIDTH)
&& event->x >= 0)
{
if(slider->type == DARKTABLE_SLIDER_BAR && !slider->is_sensibility_key_pressed && slider->is_dragging)
{
// First get some dimension info
GdkRectangle vr;
_slider_get_value_area(widget, &vr);
// Adjust rect to match dimensions for bar
vr.x += DTGTK_SLIDER_BORDER_WIDTH * 2;
vr.width -= (DTGTK_SLIDER_BORDER_WIDTH * 4);
gint vmx = event->x - vr.x;
if(vmx >= 0 && vmx <= vr.width)
{
float value = _slider_translate_pos_to_value(slider->adjustment, &vr, vmx);
if(slider->snapsize) value = slider->snapsize * (((int)value) / slider->snapsize);
gtk_adjustment_set_value(slider->adjustment, value);
}
gtk_widget_queue_draw(widget);
slider->prev_x_root = event->x_root;
}
}
slider->is_dragging = FALSE;
g_signal_emit_by_name(G_OBJECT(widget), "value-changed");
}
return TRUE;
}
