bool wxColourButton::Create( wxWindow *parent, wxWindowID id,
const wxColour &col,
const wxPoint &pos, const wxSize &size,
long style, const wxValidator& validator,
const wxString &name )
{
if (!PreCreation( parent, pos, size ) ||
!wxControl::CreateBase(parent, id, pos, size, style, validator, name))
{
wxFAIL_MSG( wxT("wxColourButton creation failed") );
return false;
}
m_colour = col;
#ifdef __WXGTK3__
m_widget = gtk_color_button_new_with_rgba(m_colour);
#else
m_widget = gtk_color_button_new_with_color( m_colour.GetColor() );
#endif
g_object_ref(m_widget);
// GtkColourButton signals
g_signal_connect(m_widget, "color-set",
G_CALLBACK(gtk_clrbutton_setcolor_callback), this);
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size);
return true;
}
void gui_update(dt_iop_module_t *self)
{
self->request_color_pick = DT_REQUEST_COLORPICK_OFF;
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
gtk_widget_set_visible(GTK_WIDGET(g->pickerbuttons), TRUE);
dtgtk_reset_label_set_text(g->label, _("color of film material"));
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(g->colorpicker), &color);
}
void gui_init(dt_iop_module_t *self)
{
self->gui_data = g_malloc0(sizeof(dt_iop_invert_gui_data_t));
dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data;
dt_iop_invert_params_t *p = (dt_iop_invert_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
g->label = DTGTK_RESET_LABEL(dtgtk_reset_label_new("", self, &p->color, 3 * sizeof(float)));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->label), TRUE, TRUE, 0);
g->pickerbuttons = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(g->pickerbuttons), TRUE, TRUE, 0);
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
g->colorpicker = gtk_color_button_new_with_rgba(&color);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpicker), DT_PIXEL_APPLY_DPI(75), DT_PIXEL_APPLY_DPI(24));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpicker), FALSE);
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpicker), _("select color of film material"));
g_signal_connect(G_OBJECT(g->colorpicker), "color-set", G_CALLBACK(colorpicker_callback), self);
gtk_box_pack_start(GTK_BOX(g->pickerbuttons), GTK_WIDGET(g->colorpicker), TRUE, TRUE, 0);
g->picker = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT);
g_object_set(G_OBJECT(g->picker), "tooltip-text", _("pick color of film material from image"), (char *)NULL);
gtk_widget_set_size_request(g->picker, DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
g_signal_connect(G_OBJECT(g->picker), "toggled", G_CALLBACK(request_pick_toggled), self);
gtk_box_pack_start(GTK_BOX(g->pickerbuttons), g->picker, TRUE, TRUE, 5);
g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(draw), self);
}
void gui_cleanup(dt_iop_module_t *self)
{
g_free(self->gui_data);
self->gui_data = NULL;
}
static inline void gui_init_tab(struct dt_iop_module_t *self, const char *name, GtkWidget **ppcolor,
const GdkRGBA *c, GtkWidget **pphue, GtkWidget **ppsaturation)
{
gtk_box_pack_start(GTK_BOX(self->widget), dt_ui_section_label_new(name), FALSE, FALSE, 5);
// color button
GtkWidget *color;
*ppcolor = color = gtk_color_button_new_with_rgba(c);
gtk_widget_set_size_request(GTK_WIDGET(color), DT_PIXEL_APPLY_DPI(32), DT_PIXEL_APPLY_DPI(32));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(color), FALSE);
gtk_color_button_set_title(GTK_COLOR_BUTTON(color), _("select tone color"));
// hue slider
GtkWidget *hue;
*pphue = hue = (dt_bauhaus_slider_new_with_range_and_feedback(self, 0.0f, 1.0f, 0.01f, 0.0f, 2, 0));
dt_bauhaus_slider_set_stop(hue, 0.0f, 1.0f, 0.0f, 0.0f);
dt_bauhaus_widget_set_label(hue, NULL, _("hue"));
dt_bauhaus_slider_set_stop(hue, 0.166f, 1.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(hue, 0.322f, 0.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(hue, 0.498f, 0.0f, 1.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 0.664f, 0.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 0.830f, 1.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 1.0f, 1.0f, 0.0f, 0.0f);
g_object_set(G_OBJECT(hue), "tooltip-text", _("select the hue tone"), (char *)NULL);
// saturation slider
GtkWidget *saturation;
*ppsaturation = saturation = dt_bauhaus_slider_new_with_range(self, 0.0f, 1.0f, 0.01f, 0.0f, 2);
dt_bauhaus_widget_set_label(saturation, NULL, _("saturation"));
dt_bauhaus_slider_set_stop(saturation, 0.0f, 0.2f, 0.2f, 0.2f);
dt_bauhaus_slider_set_stop(saturation, 1.0f, 1.0f, 1.0f, 1.0f);
g_object_set(G_OBJECT(saturation), "tooltip-text", _("select the saturation tone"), (char *)NULL);
// pack the widgets
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hue), FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), GTK_WIDGET(saturation), FALSE, TRUE, 0);
GtkWidget *hbox = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), GTK_WIDGET(color), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0);
}
static inline int gui_init_tab(struct dt_iop_module_t *self, int line, const char *name, GtkWidget **ppcolor,
const GdkRGBA *c, GtkWidget **pphue, GtkWidget **ppsaturation)
{
GtkGrid *grid = GTK_GRID(self->widget);
gtk_grid_attach(grid, dt_ui_section_label_new(name), 0, line++, 2, 1);
// color button
GtkWidget *color;
*ppcolor = color = gtk_color_button_new_with_rgba(c);
gtk_widget_set_size_request(GTK_WIDGET(color), DT_PIXEL_APPLY_DPI(32), DT_PIXEL_APPLY_DPI(32));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(color), FALSE);
gtk_color_button_set_title(GTK_COLOR_BUTTON(color), _("select tone color"));
// hue slider
GtkWidget *hue;
*pphue = hue = (dt_bauhaus_slider_new_with_range_and_feedback(self, 0.0f, 1.0f, 0.01f, 0.0f, 2, 0));
dt_bauhaus_slider_set_stop(hue, 0.0f, 1.0f, 0.0f, 0.0f);
dt_bauhaus_widget_set_label(hue, NULL, _("hue"));
dt_bauhaus_slider_set_stop(hue, 0.166f, 1.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(hue, 0.322f, 0.0f, 1.0f, 0.0f);
dt_bauhaus_slider_set_stop(hue, 0.498f, 0.0f, 1.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 0.664f, 0.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 0.830f, 1.0f, 0.0f, 1.0f);
dt_bauhaus_slider_set_stop(hue, 1.0f, 1.0f, 0.0f, 0.0f);
g_object_set(G_OBJECT(hue), "tooltip-text", _("select the hue tone"), (char *)NULL);
// saturation slider
GtkWidget *saturation;
*ppsaturation = saturation = dt_bauhaus_slider_new_with_range(self, 0.0f, 1.0f, 0.01f, 0.0f, 2);
dt_bauhaus_widget_set_label(saturation, NULL, _("saturation"));
dt_bauhaus_slider_set_stop(saturation, 0.0f, 0.2f, 0.2f, 0.2f);
dt_bauhaus_slider_set_stop(saturation, 1.0f, 1.0f, 1.0f, 1.0f);
g_object_set(G_OBJECT(saturation), "tooltip-text", _("select the saturation tone"), (char *)NULL);
// pack the widgets
gtk_widget_set_hexpand(hue, TRUE); // make sure that the color picker doesn't become HUGE
gtk_grid_attach(grid, hue, 0, line, 1, 1);
gtk_grid_attach(grid, color, 1, line++, 1, 2);
gtk_grid_attach(grid, saturation, 0, line++, 1, 1);
return line;
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE color;
GtkWidget* widget;
rb_scan_args(argc, argv, "01", &color);
if (NIL_P(color)){
widget = gtk_color_button_new();
} else {
GType gtype = RVAL2GTYPE(color);
if (gtype == GDK_TYPE_COLOR) {
widget = gtk_color_button_new_with_color(RVAL2GDKCOLOR(color));
} else {
widget = gtk_color_button_new_with_rgba(RVAL2GDKRGBA(color));
}
}
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
void sensor_config_dialog_create(SensorsApplet *sensors_applet) {
GtkTreeModel *model;
GtkTreeIter iter;
GtkWidget *content_area;
SensorConfigDialog *config_dialog;
GtkListStore *icon_store;
IconType count;
GdkPixbuf *pixbuf;
#if GTK_CHECK_VERSION (3, 0, 0)
GdkRGBA graph_color;
#else
GdkColor graph_color;
#endif
gchar *sensor_label;
gchar *header_text;
/* instance variables for data */
gdouble low_value, high_value, multiplier, offset;
gboolean alarm_enable;
gchar *low_alarm_command, *high_alarm_command;
gint alarm_timeout;
IconType icon_type;
gchar *graph_color_string;
config_dialog = g_new0(SensorConfigDialog, 1);
config_dialog->sensors_applet = sensors_applet;
gtk_tree_selection_get_selected(sensors_applet->selection,
&model,
&iter);
/* get current values of alarm and its enable */
gtk_tree_model_get(model, &iter,
LOW_VALUE_COLUMN, &low_value,
HIGH_VALUE_COLUMN, &high_value,
ALARM_ENABLE_COLUMN, &alarm_enable,
LOW_ALARM_COMMAND_COLUMN, &low_alarm_command,
HIGH_ALARM_COMMAND_COLUMN, &high_alarm_command,
ALARM_TIMEOUT_COLUMN, &alarm_timeout,
MULTIPLIER_COLUMN, &multiplier,
OFFSET_COLUMN, &offset,
ICON_TYPE_COLUMN, &icon_type,
GRAPH_COLOR_COLUMN, &graph_color_string,
LABEL_COLUMN, &sensor_label,
-1);
header_text = g_strdup_printf("%s - %s", _("Sensor Properties"), sensor_label);
config_dialog->dialog = gtk_dialog_new_with_buttons(header_text,
GTK_WINDOW(sensors_applet->prefs_dialog->dialog),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_HELP,
GTK_RESPONSE_HELP,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_icon_name(GTK_WINDOW(config_dialog->dialog),
"sensors-applet");
g_free(header_text);
g_free(sensor_label);
g_object_set(config_dialog->dialog,
"border-width", 12,
NULL);
g_signal_connect(config_dialog->dialog,
"response",
G_CALLBACK(sensor_config_dialog_response),
config_dialog);
/* graph stuff */
header_text = g_markup_printf_escaped("<b>%s</b>", _("Graph"));
config_dialog->graph_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
#if GTK_CHECK_VERSION (3, 0, 0)
gdk_rgba_parse(&graph_color, graph_color_string);
config_dialog->graph_color_button = GTK_COLOR_BUTTON(gtk_color_button_new_with_rgba(&graph_color));
#else
gdk_color_parse(graph_color_string, &graph_color);
config_dialog->graph_color_button = GTK_COLOR_BUTTON(gtk_color_button_new_with_color(&graph_color));
#endif
config_dialog->graph_color_button_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->graph_color_button,
"xalign", 0.0,
"xscale", 0.0,
NULL);
gtk_color_button_set_title(config_dialog->graph_color_button, _("Graph Color"));
config_dialog->graph_color_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Graph _color"),
"mnemonic-widget", config_dialog->graph_color_button,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
g_signal_connect(config_dialog->graph_color_button, "color-set",
G_CALLBACK(sensor_config_dialog_graph_color_set),
config_dialog);
/* icon stuff */
header_text = g_markup_printf_escaped("<b>%s</b>", _("Icon"));
config_dialog->icon_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
/* icon type */
icon_store = gtk_list_store_new(1, GDK_TYPE_PIXBUF);
/* populate list with icons */
for (count = CPU_ICON; count < NUM_ICONS; count++) {
pixbuf = sensors_applet_load_icon(count);
if (pixbuf) {
gtk_list_store_insert(icon_store, &iter, count);
gtk_list_store_set(icon_store, &iter,
0, pixbuf,
-1);
/* let list hold icons */
g_object_unref(pixbuf);
}
}
config_dialog->icon_type_combo_box = GTK_COMBO_BOX(gtk_combo_box_new_with_model(GTK_TREE_MODEL(icon_store)));
config_dialog->icon_type_combo_box_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->icon_type_combo_box,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->icon_renderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(config_dialog->icon_type_combo_box),
GTK_CELL_RENDERER(config_dialog->icon_renderer),
FALSE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(config_dialog->icon_type_combo_box),
GTK_CELL_RENDERER(config_dialog->icon_renderer),
"pixbuf", 0);
gtk_combo_box_set_active(config_dialog->icon_type_combo_box,
icon_type);
g_signal_connect(config_dialog->icon_type_combo_box, "changed",
G_CALLBACK(sensor_config_dialog_icon_type_changed),
config_dialog);
config_dialog->icon_type_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Sensor _icon"),
"mnemonic-widget", config_dialog->icon_type_combo_box,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
header_text = g_markup_printf_escaped("<b>%s</b>", _("Scaling Parameters"));
config_dialog->scale_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
/* do multiplier and offset widgets */
config_dialog->multiplier_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 1.0,
"lower", 0.001,
"upper", 1000.0,
"step-increment", 0.1,
"page-increment", 1.0,
"page-size", 1.0,
NULL);
config_dialog->multiplier_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", config_dialog->multiplier_adjust,
"digits", VALUE_DECIMAL_PLACES,
"value", multiplier,
"width-chars", SPINBUTTON_WIDTH_CHARS,
NULL);
config_dialog->multiplier_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->multiplier_spinbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->multiplier_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Sensor value _multiplier"),
"mnemonic-widget", config_dialog->multiplier_spinbutton,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
g_signal_connect(config_dialog->multiplier_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_multiplier_changed), config_dialog);
config_dialog->offset_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 0.0,
"lower", -1000.000,
"upper", 1000.000,
"step-increment", 0.01,
"page-increment", 1.0,
"page-size", 1.0,
NULL);
config_dialog->offset_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", config_dialog->offset_adjust,
"digits", VALUE_DECIMAL_PLACES,
"value", (gdouble)offset,
"width-chars", SPINBUTTON_WIDTH_CHARS,
NULL);
config_dialog->offset_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->offset_spinbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->offset_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Sensor value _offset"),
"mnemonic-widget", config_dialog->offset_spinbutton,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
g_signal_connect(config_dialog->offset_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_offset_changed), config_dialog);
/* now do alarm widgets */
header_text = g_markup_printf_escaped("<b>%s</b>", _("Sensor Limits"));
config_dialog->limits_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
config_dialog->low_value_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 0.0,
"lower", -100000.0,
"upper", 100000.0,
"step-increment", 1.0,
"page-increment", 10.0,
"page-size", 100.0,
NULL);
config_dialog->low_value_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", config_dialog->low_value_adjust,
"digits", VALUE_DECIMAL_PLACES,
"value", low_value,
"width-chars", SPINBUTTON_WIDTH_CHARS,
NULL);
config_dialog->low_value_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->low_value_spinbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->low_value_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Sensor _low value"),
"mnemonic-widget", config_dialog->low_value_spinbutton,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
g_signal_connect(config_dialog->low_value_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_low_value_changed), config_dialog);
config_dialog->high_value_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 0.0,
"lower", -100000.0,
"upper", 100000.0,
"step-increment", 1.0,
"page-increment", 10.0,
"page-size", 100.0,
NULL);
config_dialog->high_value_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", config_dialog->high_value_adjust,
"digits", VALUE_DECIMAL_PLACES,
"value", high_value,
"width-chars", SPINBUTTON_WIDTH_CHARS,
NULL);
config_dialog->high_value_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->high_value_spinbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->high_value_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Sensor _high value"),
"mnemonic-widget", config_dialog->high_value_spinbutton,
"use-underline", TRUE,
"xalign", 0.0,
NULL);
g_signal_connect(config_dialog->high_value_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_high_value_changed), config_dialog);
header_text = g_markup_printf_escaped("<b>%s</b>", _("Alarm"));
config_dialog->alarm_header = g_object_new(GTK_TYPE_LABEL,
"use-markup", TRUE,
"label", header_text,
"xalign", 0.0,
NULL);
g_free(header_text);
config_dialog->alarm_timeout_adjust = g_object_new(GTK_TYPE_ADJUSTMENT,
"value", 0.0,
"lower", 0.0,
"upper", 10000.0,
"step-increment", 1.0,
"page-increment", 10.0,
"page-size", 100.0,
NULL);
config_dialog->alarm_timeout_spinbutton = g_object_new(GTK_TYPE_SPIN_BUTTON,
"adjustment", config_dialog->alarm_timeout_adjust,
"digits", 0,
"value", (gdouble)alarm_timeout,
"width-chars", SPINBUTTON_WIDTH_CHARS,
"sensitive", alarm_enable,
NULL);
config_dialog->alarm_timeout_spinbutton_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->alarm_timeout_spinbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
config_dialog->alarm_timeout_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Alarm _repeat interval (secs)"),
"mnemonic-widget", config_dialog->alarm_timeout_spinbutton,
"use-underline", TRUE,
"xalign", 0.0,
"sensitive", alarm_enable,
NULL);
g_signal_connect(config_dialog->alarm_timeout_spinbutton, "value-changed", G_CALLBACK(sensor_config_dialog_alarm_timeout_changed), config_dialog);
config_dialog->low_alarm_command_entry = g_object_new(GTK_TYPE_ENTRY,
"text", low_alarm_command,
"width-chars", 25,
"sensitive", alarm_enable,
NULL);
g_free(low_alarm_command);
config_dialog->low_alarm_command_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("Lo_w alarm command"),
"mnemonic-widget", config_dialog->low_alarm_command_entry,
"xalign", 0.0,
"sensitive", alarm_enable,
NULL);
g_signal_connect(config_dialog->low_alarm_command_entry,
"changed",
G_CALLBACK(sensor_config_dialog_low_alarm_command_edited),
config_dialog);
config_dialog->high_alarm_command_entry = g_object_new(GTK_TYPE_ENTRY,
"text", high_alarm_command,
"width-chars", 25,
"sensitive", alarm_enable,
NULL);
g_free(high_alarm_command);
config_dialog->high_alarm_command_label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"label", _("Hi_gh alarm command"),
"mnemonic-widget", config_dialog->high_alarm_command_entry,
"xalign", 0.0,
"sensitive", alarm_enable,
NULL);
g_signal_connect(config_dialog->high_alarm_command_entry,
"changed",
G_CALLBACK(sensor_config_dialog_high_alarm_command_edited),
config_dialog);
config_dialog->alarm_enable_checkbutton = g_object_new(GTK_TYPE_CHECK_BUTTON,
"use-underline", TRUE,
"label", _("_Enable alarm"),
"active", alarm_enable,
"xalign", 0.0,
NULL);
config_dialog->alarm_enable_aligner = g_object_new(GTK_TYPE_ALIGNMENT,
"child", config_dialog->alarm_enable_checkbutton,
"xalign", 0.0,
"xscale", 0.0,
NULL);
g_signal_connect(config_dialog->alarm_enable_checkbutton, "toggled", G_CALLBACK(sensor_config_dialog_alarm_toggled), config_dialog);
config_dialog->size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->multiplier_spinbutton));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->offset_spinbutton));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->low_value_spinbutton));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->high_value_spinbutton));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->alarm_timeout_spinbutton));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->icon_type_combo_box));
gtk_size_group_add_widget(config_dialog->size_group,
GTK_WIDGET(config_dialog->graph_color_button));
g_object_unref(config_dialog->size_group);
config_dialog->table = g_object_new(GTK_TYPE_TABLE,
"column-spacing", 5,
"homogeneous", FALSE,
"n-columns", 3,
"n-rows", 15,
"row-spacing", 6,
"column-spacing", 12,
NULL);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->scale_header),
0, 2,
0, 1);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->multiplier_label),
1, 2,
1, 2);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->multiplier_spinbutton_aligner),
2, 3,
1, 2);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->offset_label),
1, 2,
2, 3);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->offset_spinbutton_aligner),
2, 3,
2, 3);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->limits_header),
0, 2,
3, 4);
/* now pack alarm widgets */
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->low_value_label),
1, 2,
4, 5);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->low_value_spinbutton_aligner),
2, 3,
4, 5);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->high_value_label),
1, 2,
5, 6);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->high_value_spinbutton_aligner),
2, 3,
5, 6);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->alarm_header),
0, 2,
6, 7);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->alarm_enable_aligner),
1, 2,
7, 8);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->alarm_timeout_label),
1, 2,
8, 9);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->alarm_timeout_spinbutton_aligner),
2, 3,
8, 9);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->low_alarm_command_label),
1, 2,
9, 10);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->low_alarm_command_entry),
2, 3,
9, 10);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->high_alarm_command_label),
1, 2,
10, 11);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->high_alarm_command_entry),
2, 3,
10, 11);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->icon_header),
0, 2,
11, 12);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->icon_type_label),
1, 2,
12, 13);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->icon_type_combo_box_aligner),
2, 3,
12, 13);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->graph_header),
0, 2,
13, 14);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->graph_color_label),
1, 2,
14, 15);
gtk_table_attach_defaults(config_dialog->table,
GTK_WIDGET(config_dialog->graph_color_button_aligner),
2, 3,
14, 15);
content_area = gtk_dialog_get_content_area (GTK_DIALOG(config_dialog->dialog));
gtk_box_pack_start(GTK_BOX(content_area), GTK_WIDGET(config_dialog->table), FALSE, FALSE, 0);
gtk_widget_show_all(config_dialog->dialog);
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_watermark_gui_data_t));
dt_iop_watermark_gui_data_t *g = (dt_iop_watermark_gui_data_t *)self->gui_data;
dt_iop_watermark_params_t *p = (dt_iop_watermark_params_t *)self->params;
int line = 0;
self->widget = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_BAUHAUS_SPACE);
gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10));
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("content")), 0, line++, 3, 1);
// Add the marker combobox
gchar configdir[PATH_MAX] = { 0 };
gchar datadir[PATH_MAX] = { 0 };
dt_loc_get_datadir(datadir, sizeof(datadir));
dt_loc_get_user_config_dir(configdir, sizeof(configdir));
GtkWidget *label = dtgtk_reset_label_new(_("marker"), self, &p->filename, sizeof(p->filename));
g->watermarks = dt_bauhaus_combobox_new(self);
gtk_widget_set_hexpand(GTK_WIDGET(g->watermarks), TRUE);
char *tooltip = g_strdup_printf(_("SVG watermarks in %s/watermarks or %s/watermarks"), configdir, datadir);
gtk_widget_set_tooltip_text(g->watermarks, tooltip);
g_free(tooltip);
g->refresh = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->watermarks, label, GTK_POS_RIGHT, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->refresh, g->watermarks, GTK_POS_RIGHT, 1, 1);
// Watermark color
float red = dt_conf_get_float("plugins/darkroom/watermark/color_red");
float green = dt_conf_get_float("plugins/darkroom/watermark/color_green");
float blue = dt_conf_get_float("plugins/darkroom/watermark/color_blue");
GdkRGBA color = (GdkRGBA){.red = red, .green = green, .blue = blue, .alpha = 1.0 };
label = dtgtk_reset_label_new(_("color"), self, &p->color, 3 * sizeof(float));
g->colorpick = gtk_color_button_new_with_rgba(&color);
gtk_widget_set_tooltip_text(g->colorpick, _("watermark color, tag:\n$(WATERMARK_COLOR)"));
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select watermark color"));
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->colorpick, label, GTK_POS_RIGHT, 2, 1);
// Simple text
label = gtk_label_new(_("text"));
gtk_widget_set_halign(label, GTK_ALIGN_START);
g->text = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(g->text), 1);
gtk_widget_set_tooltip_text(g->text, _("text string, tag:\n$(WATERMARK_TEXT)"));
dt_gui_key_accel_block_on_focus_connect(g->text);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->text, label, GTK_POS_RIGHT, 2, 1);
gchar *str = dt_conf_get_string("plugins/darkroom/watermark/text");
gtk_entry_set_text(GTK_ENTRY(g->text), str);
g_free(str);
// Text font
label = dtgtk_reset_label_new(_("font"), self, &p->font, sizeof(p->font));
str = dt_conf_get_string("plugins/darkroom/watermark/font");
g->fontsel = gtk_font_button_new_with_font(str==NULL?"DejaVu Sans 10":str);
GList *childs = gtk_container_get_children(GTK_CONTAINER(gtk_bin_get_child(GTK_BIN(g->fontsel))));
gtk_label_set_ellipsize(GTK_LABEL(childs->data), PANGO_ELLIPSIZE_MIDDLE);
g_list_free(childs);
gtk_widget_set_tooltip_text(g->fontsel, _("text font, tags:\n$(WATERMARK_FONT_FAMILY)\n"
"$(WATERMARK_FONT_STYLE)\n$(WATERMARK_FONT_WEIGHT)"));
gtk_font_button_set_show_size (GTK_FONT_BUTTON(g->fontsel), FALSE);
g_free(str);
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), g->fontsel, label, GTK_POS_RIGHT, 2, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("properties")), 0, line++, 3, 1);
// Add opacity/scale sliders to table
g->opacity = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->opacity, 0);
dt_bauhaus_slider_set_format(g->opacity, "%.f%%");
dt_bauhaus_widget_set_label(g->opacity, NULL, _("opacity"));
g->scale = dt_bauhaus_slider_new_with_range(self, 1.0, 100.0, 1.0, p->scale, 0);
dt_bauhaus_slider_enable_soft_boundaries(g->scale, 1.0, 500.0);
dt_bauhaus_slider_set_format(g->scale, "%.f%%");
dt_bauhaus_widget_set_label(g->scale, NULL, _("scale"));
g->rotate = dt_bauhaus_slider_new_with_range(self, -180.0, 180.0, 1.0, p->rotate, 2);
dt_bauhaus_slider_set_format(g->rotate, "%.02f°");
dt_bauhaus_widget_set_label(g->rotate, NULL, _("rotation"));
gtk_grid_attach(GTK_GRID(self->widget), g->opacity, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->scale, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->rotate, 0, line++, 3, 1);
g->sizeto = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_add(g->sizeto, C_("size", "image"));
dt_bauhaus_combobox_add(g->sizeto, _("larger border"));
dt_bauhaus_combobox_add(g->sizeto, _("smaller border"));
dt_bauhaus_combobox_set(g->sizeto, p->sizeto);
dt_bauhaus_widget_set_label(g->sizeto, NULL, _("scale on"));
gtk_widget_set_tooltip_text(g->sizeto, _("size is relative to"));
gtk_grid_attach(GTK_GRID(self->widget), g->sizeto, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("position")), 0, line++, 3, 1);
// Create the 3x3 gtk table toggle button table...
label = dtgtk_reset_label_new(_("alignment"), self, &p->alignment, sizeof(p->alignment));
GtkWidget *bat = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
gtk_grid_set_column_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3));
for(int i = 0; i < 9; i++)
{
g->align[i] = dtgtk_togglebutton_new(dtgtk_cairo_paint_alignment, CPF_STYLE_FLAT | (CPF_SPECIAL_FLAG << i));
gtk_widget_set_size_request(GTK_WIDGET(g->align[i]), DT_PIXEL_APPLY_DPI(16), DT_PIXEL_APPLY_DPI(16));
gtk_grid_attach(GTK_GRID(bat), GTK_WIDGET(g->align[i]), i%3, i/3, 1, 1);
g_signal_connect(G_OBJECT(g->align[i]), "toggled", G_CALLBACK(alignment_callback), self);
}
gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1);
gtk_grid_attach_next_to(GTK_GRID(self->widget), bat, label, GTK_POS_RIGHT, 2, 1);
// x/y offset
g->x_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->xoffset, 3);
dt_bauhaus_slider_set_format(g->x_offset, "%.3f");
dt_bauhaus_widget_set_label(g->x_offset, NULL, _("x offset"));
g->y_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->yoffset, 3);
dt_bauhaus_slider_set_format(g->y_offset, "%.3f");
dt_bauhaus_widget_set_label(g->y_offset, NULL, _("y offset"));
gtk_grid_attach(GTK_GRID(self->widget), g->x_offset, 0, line++, 3, 1);
gtk_grid_attach(GTK_GRID(self->widget), g->y_offset, 0, line++, 3, 1);
// Let's add some tooltips and hook up some signals...
gtk_widget_set_tooltip_text(g->opacity, _("the opacity of the watermark"));
gtk_widget_set_tooltip_text(g->scale, _("the scale of the watermark"));
gtk_widget_set_tooltip_text(g->rotate, _("the rotation of the watermark"));
g_signal_connect(G_OBJECT(g->opacity), "value-changed", G_CALLBACK(opacity_callback), self);
g_signal_connect(G_OBJECT(g->scale), "value-changed", G_CALLBACK(scale_callback), self);
g_signal_connect(G_OBJECT(g->rotate), "value-changed", G_CALLBACK(rotate_callback), self);
g_signal_connect(G_OBJECT(g->x_offset), "value-changed", G_CALLBACK(xoffset_callback), self);
g_signal_connect(G_OBJECT(g->y_offset), "value-changed", G_CALLBACK(yoffset_callback), self);
g_signal_connect(G_OBJECT(g->refresh), "clicked", G_CALLBACK(refresh_callback), self);
refresh_watermarks(self);
g_signal_connect(G_OBJECT(g->watermarks), "value-changed", G_CALLBACK(watermark_callback), self);
g_signal_connect(G_OBJECT(g->sizeto), "value-changed", G_CALLBACK(sizeto_callback), self);
g_signal_connect(G_OBJECT(g->text), "changed", G_CALLBACK(text_callback), self);
g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self);
g_signal_connect(G_OBJECT(g->fontsel), "font-set", G_CALLBACK(fontsel_callback), self);
}
void gui_cleanup(struct dt_iop_module_t *self)
{
free(self->gui_data);
self->gui_data = NULL;
}
void gui_init(struct dt_iop_module_t *self)
{
self->gui_data = malloc(sizeof(dt_iop_borders_gui_data_t));
dt_iop_borders_gui_data_t *g = (dt_iop_borders_gui_data_t *)self->gui_data;
dt_iop_borders_params_t *p = (dt_iop_borders_params_t *)self->params;
self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE);
g->size = dt_bauhaus_slider_new_with_range(self, 0.0, 50.0, 0.5, p->size * 100.0, 2);
dt_bauhaus_widget_set_label(g->size, NULL, _("border size"));
dt_bauhaus_slider_set_format(g->size, "%.2f%%");
g_signal_connect(G_OBJECT(g->size), "value-changed", G_CALLBACK(size_callback), self);
gtk_widget_set_tooltip_text(g->size, _("size of the border in percent of the full image"));
gtk_box_pack_start(GTK_BOX(self->widget), g->size, TRUE, TRUE, 0);
g->aspect = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->aspect, 1);
dt_bauhaus_widget_set_label(g->aspect, NULL, _("aspect"));
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect, TRUE, TRUE, 0);
gui_init_aspect(self);
g_signal_connect(G_OBJECT(g->aspect), "value-changed", G_CALLBACK(aspect_changed), self);
gtk_widget_set_tooltip_text(g->aspect, _("select the aspect ratio or right click and type your own (w:h)"));
g->aspect_orient = dt_bauhaus_combobox_new(self);
dt_bauhaus_widget_set_label(g->aspect_orient, NULL, _("orientation"));
dt_bauhaus_combobox_add(g->aspect_orient, _("auto"));
dt_bauhaus_combobox_add(g->aspect_orient, _("portrait"));
dt_bauhaus_combobox_add(g->aspect_orient, _("landscape"));
gtk_widget_set_tooltip_text(g->aspect_orient, _("aspect ratio orientation of the image with border"));
g_signal_connect(G_OBJECT(g->aspect_orient), "value-changed", G_CALLBACK(aspect_orient_changed), self);
gtk_box_pack_start(GTK_BOX(self->widget), g->aspect_orient, TRUE, TRUE, 0);
g->pos_h = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->pos_h, 1);
dt_bauhaus_widget_set_label(g->pos_h, NULL, _("horizontal position"));
gtk_box_pack_start(GTK_BOX(self->widget), g->pos_h, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(g->pos_h), "value-changed", G_CALLBACK(position_h_changed), self);
gtk_widget_set_tooltip_text(g->pos_h, _("select the horizontal position ratio relative to top "
"or right click and type your own (y:h)"));
g->pos_v = dt_bauhaus_combobox_new(self);
dt_bauhaus_combobox_set_editable(g->pos_v, 1);
dt_bauhaus_widget_set_label(g->pos_v, NULL, _("vertical position"));
gtk_box_pack_start(GTK_BOX(self->widget), g->pos_v, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(g->pos_v), "value-changed", G_CALLBACK(position_v_changed), self);
gtk_widget_set_tooltip_text(g->pos_v, _("select the vertical position ratio relative to left "
"or right click and type your own (x:w)"));
gui_init_positions(self);
g->frame_size = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_size * 100.0, 2);
dt_bauhaus_widget_set_label(g->frame_size, NULL, _("frame line size"));
dt_bauhaus_slider_set_format(g->frame_size, "%.2f%%");
g_signal_connect(G_OBJECT(g->frame_size), "value-changed", G_CALLBACK(frame_size_callback), self);
gtk_widget_set_tooltip_text(g->frame_size, _("size of the frame line in percent of min border width"));
gtk_box_pack_start(GTK_BOX(self->widget), g->frame_size, TRUE, TRUE, 0);
g->frame_offset = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_offset * 100.0, 2);
dt_bauhaus_widget_set_label(g->frame_offset, NULL, _("frame line offset"));
dt_bauhaus_slider_set_format(g->frame_offset, "%.2f%%");
g_signal_connect(G_OBJECT(g->frame_offset), "value-changed", G_CALLBACK(frame_offset_callback), self);
gtk_widget_set_tooltip_text(g->frame_offset, _("offset of the frame line beginning on picture side"));
gtk_box_pack_start(GTK_BOX(self->widget), g->frame_offset, TRUE, TRUE, 0);
GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 };
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
g->colorpick = gtk_color_button_new_with_rgba(&color);
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE);
gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select border color"));
GtkWidget *label = dtgtk_reset_label_new(_("border color"), self, &p->color, 3 * sizeof(float));
g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self);
g->border_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
gtk_widget_set_tooltip_text(GTK_WIDGET(g->border_picker), _("pick border color from image"));
gtk_widget_set_size_request(GTK_WIDGET(g->border_picker), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
g_signal_connect(G_OBJECT(g->border_picker), "toggled", G_CALLBACK(request_pick_toggled_border), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->border_picker), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
g->frame_colorpick = gtk_color_button_new_with_rgba(&color);
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->frame_colorpick), FALSE);
gtk_color_button_set_title(GTK_COLOR_BUTTON(g->frame_colorpick), _("select frame line color"));
gtk_widget_set_size_request(GTK_WIDGET(g->frame_colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
label = dtgtk_reset_label_new(_("frame line color"), self, &p->color, 3 * sizeof(float));
g_signal_connect(G_OBJECT(g->frame_colorpick), "color-set", G_CALLBACK(frame_colorpick_color_set), self);
g->frame_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT));
gtk_widget_set_tooltip_text(GTK_WIDGET(g->frame_picker), _("pick frame line color from image"));
gtk_widget_set_size_request(GTK_WIDGET(g->frame_picker), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24));
g_signal_connect(G_OBJECT(g->frame_picker), "toggled", G_CALLBACK(request_pick_toggled_frame), self);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_colorpick), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_picker), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(borders_draw), self);
}
void reload_defaults(dt_iop_module_t *self)
{
dt_iop_borders_params_t tmp = (dt_iop_borders_params_t){ { 1.0f, 1.0f, 1.0f },
DT_IOP_BORDERS_ASPECT_CONSTANT_VALUE,
"constant border",
0,
0.1f,
0.5f,
"1/2",
0.5f,
"1/2",
0.0f,
0.5f,
{ 0.0f, 0.0f, 0.0f },
TRUE };
memcpy(self->params, &tmp, sizeof(dt_iop_borders_params_t));
memcpy(self->default_params, &tmp, sizeof(dt_iop_borders_params_t));
self->default_enabled = 0;
}
}
bscope_draw ();
}
static void color_set_cb (GtkWidget * chooser)
{
GdkRGBA rgba;
gtk_color_button_get_rgba ((GtkColorButton *) chooser, & rgba);
int red = round (rgba.red * 255);
int green = round (rgba.green * 255);
int blue = round (rgba.blue * 255);
color = (red << 16) | (green << 8) | blue;
}
static void /* GtkWidget */ * bscope_get_color_chooser (void)
{
GdkRGBA rgba = {
.red = ((color & 0xff0000) >> 16) / 255.0,
.green = ((color & 0xff00) >> 8) / 255.0,
.blue = (color & 0xff) / 255.0};
GtkWidget * chooser = gtk_color_button_new_with_rgba (& rgba);
gtk_color_button_set_use_alpha ((GtkColorButton *) chooser, FALSE);
g_signal_connect (chooser, "color-set", (GCallback) color_set_cb, NULL);
return chooser;
}
