void
glade_gtk_color_button_set_property (GladeWidgetAdaptor * adaptor,
GObject * object,
const gchar * id, const GValue * value)
{
GladeProperty *property;
GladeWidget *gwidget = glade_widget_get_from_gobject (object);
if (!strcmp (id, "color"))
{
if ((property = glade_widget_get_property (gwidget, "color")) != NULL &&
glade_property_get_enabled (property) && g_value_get_boxed (value))
{
GdkColor *color = g_value_get_boxed (value);
GdkRGBA copy;
copy.red = color->red / 65535.0;
copy.green = color->green / 65535.0;
copy.blue = color->blue / 65535.0;
copy.alpha = 1.0;
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (object), ©);
}
}
else if (!strcmp (id, "rgba"))
{
if ((property = glade_widget_get_property (gwidget, "rgba")) != NULL &&
glade_property_get_enabled (property) && g_value_get_boxed (value))
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (object),
(GdkRGBA *) g_value_get_boxed (value));
}
else
GWA_GET_CLASS (GTK_TYPE_BUTTON)->set_property (adaptor, object, id, value);
}
static void
v_gradient_swap_button_clicked_cb (GtkButton *button,
gpointer user_data)
{
GthContactSheetThemeDialog *self = user_data;
GdkRGBA color1;
GdkRGBA color2;
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (GET_WIDGET ("v_gradient_1_colorpicker")), &color1);
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (GET_WIDGET ("v_gradient_2_colorpicker")), &color2);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (GET_WIDGET ("v_gradient_2_colorpicker")), &color1);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (GET_WIDGET ("v_gradient_1_colorpicker")), &color2);
update_preview (self);
}
/* Change the sticky note title and color */
void stickynote_change_properties (StickyNote *note)
{
char *color_str = NULL;
gtk_entry_set_text(GTK_ENTRY(note->w_entry),
gtk_label_get_text (GTK_LABEL (note->w_title)));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(note->w_def_color),
note->color == NULL);
if (note->color)
color_str = g_strdup (note->color);
else
{
color_str = g_settings_get_string (stickynotes->settings, "default-color");
}
if (color_str)
{
GdkRGBA color;
gdk_rgba_parse (&color, color_str);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (note->w_color), &color);
g_free (color_str);
}
if (note->font_color)
color_str = g_strdup (note->font_color);
else
{
color_str = g_settings_get_string (stickynotes->settings, "default-font-color");
}
if (color_str)
{
GdkRGBA font_color;
gdk_rgba_parse (&font_color, color_str);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (note->w_font_color), &font_color);
g_free (color_str);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(note->w_def_font),
note->font == NULL);
if (note->font)
gtk_font_button_set_font_name (GTK_FONT_BUTTON (note->w_font),
note->font);
gtk_widget_show (note->w_properties);
stickynotes_save();
}
void set_button_state(BUTTONS_STATE state, EDITOR *e)
{
#ifdef HAVE_GTK_34
GdkRGBA rgba;
#else
GdkColor color;
#endif
gtk_toggle_tool_button_set_active(e->toolitems.bold, state.bold);
gtk_toggle_tool_button_set_active(e->toolitems.italic, state.italic);
gtk_toggle_tool_button_set_active(e->toolitems.underline, state.underline);
gtk_toggle_tool_button_set_active(e->toolitems.strike, state.strike);
gtk_combo_box_set_active((GtkComboBox *)e->toolitems.cb, state.style);
if (state.color) {
XI_message(("state.color: %s", state.color));
#ifdef HAVE_GTK_34
if (gdk_rgba_parse(&rgba, state.color))
gtk_color_chooser_set_rgba((GtkColorChooser *)
e->toolitems.color,
&rgba);
#else
if (gdk_color_parse(state.color, &color))
gtk_color_button_set_color((GtkColorButton *)
e->toolitems.color,
&color);
#endif
}
}
void gui_update(struct dt_iop_module_t *self)
{
dt_iop_module_t *module = (dt_iop_module_t *)self;
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 *)module->params;
dt_bauhaus_slider_set(g->opacity, p->opacity);
dt_bauhaus_slider_set_soft(g->scale, p->scale);
dt_bauhaus_slider_set(g->rotate, p->rotate);
dt_bauhaus_slider_set(g->x_offset, p->xoffset);
dt_bauhaus_slider_set(g->y_offset, p->yoffset);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->align[p->alignment]), TRUE);
_combo_box_set_active_text(g->watermarks, p->filename);
dt_bauhaus_combobox_set(g->sizeto, p->sizeto);
gtk_entry_set_text(GTK_ENTRY(g->text), p->text);
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->colorpick), &color);
gtk_font_button_set_font_name(GTK_FONT_BUTTON(g->fontsel), p->font);
}
void init(dt_iop_module_t *module)
{
module->params = calloc(1, sizeof(dt_iop_watermark_params_t));
module->params_size = sizeof(dt_iop_watermark_params_t);
module->default_params = calloc(1, sizeof(dt_iop_watermark_params_t));
module->default_enabled = 0;
module->priority = 969; // module order created by iop_dependencies.py, do not edit!
module->params_size = sizeof(dt_iop_watermark_params_t);
module->gui_data = NULL;
dt_iop_watermark_params_t tmp = (dt_iop_watermark_params_t){
100.0, 100.0, 0.0, 0.0, 4, 0.0, DT_SCALE_IMAGE, { "darktable.svg" }, { "" }, {0.0, 0.0, 0.0}, {"DejaVu Sans 10"}
}; // opacity,scale,xoffs,yoffs,alignment
memcpy(module->params, &tmp, sizeof(dt_iop_watermark_params_t));
memcpy(module->default_params, &tmp, sizeof(dt_iop_watermark_params_t));
}
static void
drawing_area_color_set (DrawingArea *area,
GdkRGBA *color,
GtkColorButton *button)
{
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (button), color);
}
static void
profile_palette_notify_colorpickers_cb (GSettings *profile,
const char *key,
GtkWidget *editor)
{
GtkWidget *w;
GtkBuilder *builder;
gs_free GdkRGBA *colors;
gsize n_colors, i;
g_assert (strcmp (key, TERMINAL_PROFILE_PALETTE_KEY) == 0);
builder = g_object_get_data (G_OBJECT (editor), "builder");
g_assert (builder != NULL);
colors = terminal_g_settings_get_rgba_palette (profile, TERMINAL_PROFILE_PALETTE_KEY, &n_colors);
n_colors = MIN (n_colors, TERMINAL_PALETTE_SIZE);
for (i = 0; i < n_colors; i++)
{
char name[32];
GdkRGBA old_color;
g_snprintf (name, sizeof (name), "palette-colorpicker-%" G_GSIZE_FORMAT, i + 1);
w = (GtkWidget *) gtk_builder_get_object (builder, name);
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (w), &old_color);
if (!rgba_equal (&old_color, &colors[i]))
{
g_signal_handlers_block_by_func (w, G_CALLBACK (palette_color_notify_cb), profile);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (w), &colors[i]);
g_signal_handlers_unblock_by_func (w, G_CALLBACK (palette_color_notify_cb), profile);
}
}
}
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
static void
color_changed (GObject *object, GParamSpec *pspec, gpointer data)
{
GtkColorChooser *cb = GTK_COLOR_CHOOSER (data);
GValue val = G_VALUE_INIT;
GdkColor *color;
GdkRGBA rgba;
g_value_init (&val, GDK_TYPE_COLOR);
get_property_value (object, pspec, &val);
color = g_value_get_boxed (&val);
rgba.red = color->red / 65535.0;
rgba.green = color->green / 65535.0;
rgba.blue = color->blue / 65535.0;
rgba.alpha = 1.0;
if (g_value_get_boxed (&val))
{
block_controller (G_OBJECT (cb));
gtk_color_chooser_set_rgba (cb, &rgba);
unblock_controller (G_OBJECT (cb));
}
g_value_unset (&val);
}
/* Color has changed at settings */
static void _plugin_on_settings_color_change(GObject *inObject,
GParamSpec *inSpec,
gpointer inUserData)
{
XfdashboardClockViewSettings *settings;
GtkColorButton *button;
ClutterColor *settingsColor;
GdkRGBA widgetColor;
g_return_if_fail(XFDASHBOARD_IS_CLOCK_VIEW_SETTINGS(inObject));
g_return_if_fail(GTK_IS_COLOR_BUTTON(inUserData));
settings=XFDASHBOARD_CLOCK_VIEW_SETTINGS(inObject);
button=GTK_COLOR_BUTTON(inUserData);
/* Get current color from settings */
g_object_get(G_OBJECT(settings), g_param_spec_get_name(inSpec), &settingsColor, NULL);
/* Convert color for color button */
widgetColor.red=settingsColor->red/255.0f;
widgetColor.green=settingsColor->green/255.0f;
widgetColor.blue=settingsColor->blue/255.0f;
widgetColor.alpha=settingsColor->alpha/255.0f;
/* Set converted color at color button */
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(button), &widgetColor);
#else
gtk_color_button_set_rgba(button, &widgetColor);
#endif
}
void WebColorPickerGtk::showColorPicker(const Color& color)
{
if (!m_client)
return;
m_initialColor = color;
if (!m_colorChooser) {
GtkWidget* toplevel = gtk_widget_get_toplevel(m_webView);
m_colorChooser = gtk_color_chooser_dialog_new(_("Select Color"), WebCore::widgetIsOnscreenToplevelWindow(toplevel) ? GTK_WINDOW(toplevel) : nullptr);
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(m_colorChooser), &m_initialColor);
g_signal_connect(m_colorChooser, "notify::rgba", G_CALLBACK(WebColorPickerGtk::colorChooserDialogRGBAChangedCallback), this);
g_signal_connect(m_colorChooser, "response", G_CALLBACK(WebColorPickerGtk::colorChooserDialogResponseCallback), this);
} else
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(m_colorChooser), &m_initialColor);
gtk_widget_show(m_colorChooser);
}
static void
color_chooser_widget_color_activated (GtkColorChooser *chooser,
GdkRGBA *color,
gpointer user_data)
{
/* Because we are simulating the double-click by accepting only
* single click, the color in the swatch is actually not selected,
* so we must do it manually */
gtk_color_chooser_set_rgba (chooser, color);
}
static void
xhairs_opacity_notify_cb (GSettings *settings, gchar *key, GtkColorButton *button)
{
GdkRGBA rgba;
gdouble opacity;
opacity = g_settings_get_double (settings, key);
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &rgba);
rgba.alpha = opacity * 65535;
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (button), &rgba);
}
void set_color(SettingItem * item, gchar * s)
{
#if GTK_CHECK_VERSION(3, 4, 0)
GdkRGBA c;
gdk_rgba_parse(&c,s);
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(item->widget),&c);
#else
GdkColor c;
gdk_color_parse(s,&c);
gtk_color_button_set_color(GTK_COLOR_BUTTON(item->widget),&c);
#endif
}
static void
init_xhairs_color_opacity (GtkColorButton *color_button, GSettings *settings)
{
gchar *color_setting;
GdkRGBA rgba;
color_setting = g_settings_get_string (settings, "cross-hairs-color");
gdk_rgba_parse (&rgba, color_setting);
rgba.alpha = g_settings_get_double (settings, "cross-hairs-opacity");
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (color_button), &rgba);
}
void wxColourButton::UpdateColour()
{
#ifdef __WXGTK4__
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(m_widget), m_colour);
#elif defined(__WXGTK3__)
wxGCC_WARNING_SUPPRESS(deprecated-declarations)
gtk_color_button_set_rgba(GTK_COLOR_BUTTON(m_widget), m_colour);
wxGCC_WARNING_RESTORE()
#else
gtk_color_button_set_color(GTK_COLOR_BUTTON(m_widget), m_colour.GetColor());
#endif
}
static void
bjb_selection_toolbar_set_item_visibility (BjbSelectionToolbar *self)
{
BjbSelectionToolbarPrivate *priv;
GList *l, *selection;
GdkRGBA color;
g_return_if_fail (BJB_IS_SELECTION_TOOLBAR (self));
priv = self->priv;
selection = bjb_main_view_get_selected_items (priv->view);
/* Color */
gtk_widget_set_sensitive (priv->toolbar_color, FALSE);
for (l=selection; l !=NULL; l=l->next)
{
if (!biji_item_has_color (l->data))
{
gtk_widget_set_sensitive (priv->toolbar_color, FALSE);
break;
}
else if (BIJI_IS_NOTE_OBJ (l->data))
{
if (biji_note_obj_get_rgba (BIJI_NOTE_OBJ (l->data), &color))
{
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (priv->toolbar_color), &color);
gtk_widget_set_sensitive (priv->toolbar_color, TRUE);
break;
}
}
}
/* Organize */
gtk_widget_set_sensitive (priv->toolbar_tag, TRUE);
for (l=selection; l!=NULL; l=l->next)
{
if (!biji_item_is_collectable (l->data))
{
gtk_widget_set_sensitive (priv->toolbar_tag, FALSE);
break;
}
}
g_list_free (selection);
}
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 update_colorpicker_color(GtkWidget *colorpicker, float hue, float sat)
{
float rgb[3];
hsl2rgb(rgb, hue, sat, 0.5);
GdkRGBA color = (GdkRGBA){.red = rgb[0], .green = rgb[1], .blue = rgb[2], .alpha = 1.0 };
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(colorpicker), &color);
}
static inline void update_saturation_slider_end_color(GtkWidget *slider, float hue)
{
float rgb[3];
hsl2rgb(rgb, hue, 1.0, 0.5);
dt_bauhaus_slider_set_stop(slider, 1.0, rgb[0], rgb[1], rgb[2]);
}
static gboolean
run_color_chooser_dialog (gpointer user_data)
{
EColorChooserWidgetPrivate *priv;
GtkWidget *parent_window;
GtkWidget *parent_chooser;
GtkWidget *dialog;
GtkWidget *chooser;
parent_chooser = user_data;
g_object_set (
G_OBJECT (parent_chooser), "show-editor", FALSE, NULL);
parent_window = g_object_get_data (G_OBJECT (parent_chooser), "window");
if (!parent_window)
parent_window = gtk_widget_get_toplevel (parent_chooser);
dialog = gtk_dialog_new_with_buttons (
N_("Choose custom color"),
GTK_WINDOW (parent_window),
GTK_DIALOG_MODAL,
_("_Cancel"), GTK_RESPONSE_REJECT,
_("_OK"), GTK_RESPONSE_ACCEPT, NULL);
chooser = gtk_color_chooser_widget_new ();
g_object_set (G_OBJECT (chooser), "show-editor", TRUE, NULL);
gtk_box_pack_start (
GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
chooser, TRUE, TRUE, 5);
gtk_widget_show_all (chooser);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
GdkRGBA color;
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (chooser), &color);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (parent_chooser), &color);
g_signal_emit_by_name (parent_chooser, "color-activated", &color);
}
gtk_widget_destroy (dialog);
priv = E_COLOR_CHOOSER_WIDGET_GET_PRIVATE (parent_chooser);
priv->showing_editor = FALSE;
return FALSE;
}
static void colourgui_set_colour_widget(GtkBuilder *builder,
const char *widget_name, GdkRGBA *colour, gboolean ignore)
{
GtkWidget *widget;
if (!colour)
return;
widget = GTK_WIDGET(gtk_builder_get_object(builder, widget_name));
/* Setting a colour doesn't seem to cause a change signal so
* explicitly raise one if necessary */
capplet_ignore_changes = TRUE;
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(widget), colour);
capplet_ignore_changes = FALSE;
if (!ignore)
g_signal_emit_by_name(widget, "color-set");
}
static void
gtk_color_button_clicked (GtkButton *b)
{
GtkColorButton *button = GTK_COLOR_BUTTON (b);
/* if dialog already exists, make sure it's shown and raised */
ensure_dialog (button);
gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (button->priv->cs_dialog),
button->priv->use_alpha);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (button->priv->cs_dialog),
&button->priv->rgba);
gtk_window_present (GTK_WINDOW (button->priv->cs_dialog));
}
static void
menu_color_change_cb (col_sel * sel)
{
GtkWidget *selector;
gchar title[20];
GdkRGBA rgba;
sprintf (title, "Choose color #%d", sel->index);
selector = gtk_color_chooser_dialog_new(title, NULL);
sel->selector = selector;
rgba = *gtk_databox_graph_get_color (sel->graph);
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(sel->selector), &rgba);
gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(sel->selector), FALSE);
g_signal_connect(G_OBJECT(sel->selector), "response", G_CALLBACK(get_color_cb), (gpointer)sel);
gtk_widget_show (GTK_WIDGET (sel->selector));
return;
}
GtkWidget *
do_paint (GtkWidget *toplevel)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *draw_area, *headerbar, *colorbutton;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
draw_area = drawing_area_new ();
gtk_container_add (GTK_CONTAINER (window), draw_area);
headerbar = gtk_header_bar_new ();
gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), "Paint");
gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (headerbar), TRUE);
colorbutton = gtk_color_button_new ();
g_signal_connect (colorbutton, "color-set",
G_CALLBACK (color_button_color_set), draw_area);
g_signal_connect (draw_area, "color-set",
G_CALLBACK (drawing_area_color_set), colorbutton);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (colorbutton),
&(GdkRGBA) { 0, 0, 0, 1 });
gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), colorbutton);
gtk_window_set_titlebar (GTK_WINDOW (window), headerbar);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
static void
entry_apply (GtkWidget *entry,
GtkColorEditor *editor)
{
GdkRGBA color;
gchar *text;
if (!editor->priv->text_changed)
return;
text = gtk_editable_get_chars (GTK_EDITABLE (editor->priv->entry), 0, -1);
if (gdk_rgba_parse (&color, text))
{
color.alpha = gtk_adjustment_get_value (editor->priv->a_adj);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (editor), &color);
}
editor->priv->text_changed = FALSE;
g_free (text);
}
static void
rgba_changed (GObject *object, GParamSpec *pspec, gpointer data)
{
GtkColorChooser *cb = GTK_COLOR_CHOOSER (data);
GValue val = G_VALUE_INIT;
GdkRGBA *color;
GdkRGBA cb_color;
g_value_init (&val, GDK_TYPE_RGBA);
get_property_value (object, pspec, &val);
color = g_value_get_boxed (&val);
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (cb), &cb_color);
if (color != NULL && !gdk_rgba_equal (color, &cb_color))
{
block_controller (G_OBJECT (cb));
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cb), color);
unblock_controller (G_OBJECT (cb));
}
g_value_unset (&val);
}
static void
gtk_color_editor_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkColorEditor *ce = GTK_COLOR_EDITOR (object);
GtkColorChooser *cc = GTK_COLOR_CHOOSER (object);
switch (prop_id)
{
case PROP_RGBA:
gtk_color_chooser_set_rgba (cc, g_value_get_boxed (value));
break;
case PROP_USE_ALPHA:
gtk_color_editor_set_use_alpha (ce, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
on_value_changed(GtkWidget *widget, gpointer data)
{
GdkRGBA rgba;
uint8_t red, green, blue;
struct gtk_common_data *mdata = data;
struct sol_rgb color;
red = gtk_spin_button_get_value_as_int
(GTK_SPIN_BUTTON(g_object_get_data
(G_OBJECT(mdata->widget), "spin_r")));
green = gtk_spin_button_get_value_as_int
(GTK_SPIN_BUTTON(g_object_get_data
(G_OBJECT(mdata->widget), "spin_g")));
blue = gtk_spin_button_get_value_as_int
(GTK_SPIN_BUTTON(g_object_get_data
(G_OBJECT(mdata->widget), "spin_b")));
rgba.red = (gdouble)red / COLOR_VALUE_MAX;
rgba.green = (gdouble)green / COLOR_VALUE_MAX;
rgba.blue = (gdouble)blue / COLOR_VALUE_MAX;
rgba.alpha = 1.0;
gtk_color_chooser_set_rgba
(GTK_COLOR_CHOOSER(g_object_get_data(G_OBJECT(mdata->widget),
"rgb_button")), &rgba);
color.red = red;
color.red_max = COLOR_VALUE_MAX;
color.green = green;
color.green_max = COLOR_VALUE_MAX;
color.blue = blue;
color.blue_max = COLOR_VALUE_MAX;
sol_flow_send_rgb_packet(mdata->node,
SOL_FLOW_NODE_TYPE_GTK_RGB_EDITOR__OUT__OUT,
&color);
}
G_MODULE_EXPORT void
gw_settingswindow_sync_swatch_color_cb (GSettings *settings, gchar *KEY, gpointer data)
{
//Declarations
GwSettingsWindow *window;
GtkColorChooser *swatch;
GdkRGBA color;
char hex_color_string[20];
//Initializations
window = GW_SETTINGSWINDOW (gtk_widget_get_ancestor (GTK_WIDGET (data), GW_TYPE_SETTINGSWINDOW));
g_return_if_fail (window != NULL);
swatch = GTK_COLOR_CHOOSER (data);
lw_preferences_get_string (hex_color_string, settings, KEY, 20);
g_assert (swatch != NULL);
if (gdk_rgba_parse (&color, hex_color_string) == TRUE)
{
G_GNUC_EXTENSION g_signal_handlers_block_by_func (swatch, gw_settingswindow_swatch_color_changed_cb, window);
gtk_color_chooser_set_rgba (swatch, &color);
G_GNUC_EXTENSION g_signal_handlers_unblock_by_func (swatch, gw_settingswindow_swatch_color_changed_cb, window);
}
}
void gui_update(struct dt_iop_module_t *self)
{
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;
dt_bauhaus_slider_set(g->size, p->size * 100.0f);
// ----- Aspect
int k = 0;
for(; k < DT_IOP_BORDERS_ASPECT_COUNT; k++)
{
if(fabsf(p->aspect - g->aspect_ratios[k]) < 0.0001f)
{
dt_bauhaus_combobox_set(g->aspect, k);
break;
}
}
if(k == DT_IOP_BORDERS_ASPECT_COUNT)
{
dt_bauhaus_combobox_set_text(g->aspect, p->aspect_text);
dt_bauhaus_combobox_set(g->aspect, -1);
}
// ----- aspect orientation
dt_bauhaus_combobox_set(g->aspect_orient, p->aspect_orient);
// ----- Position H
for(k = 0; k < DT_IOP_BORDERS_POSITION_H_COUNT; k++)
{
if(fabsf(p->pos_h - g->pos_h_ratios[k]) < 0.0001f)
{
dt_bauhaus_combobox_set(g->pos_h, k);
break;
}
}
if(k == DT_IOP_BORDERS_POSITION_H_COUNT)
{
dt_bauhaus_combobox_set_text(g->pos_h, p->pos_h_text);
dt_bauhaus_combobox_set(g->pos_h, -1);
}
// ----- Position V
for(k = 0; k < DT_IOP_BORDERS_POSITION_V_COUNT; k++)
{
if(fabsf(p->pos_v - g->pos_v_ratios[k]) < 0.0001f)
{
dt_bauhaus_combobox_set(g->pos_v, k);
break;
}
}
if(k == DT_IOP_BORDERS_POSITION_V_COUNT)
{
dt_bauhaus_combobox_set_text(g->pos_v, p->pos_v_text);
dt_bauhaus_combobox_set(g->pos_v, -1);
}
dt_bauhaus_slider_set(g->frame_size, p->frame_size * 100.0f);
dt_bauhaus_slider_set(g->frame_offset, p->frame_offset * 100.0f);
// ----- Border Color
GdkRGBA c = (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->colorpick), &c);
// ----- Frame Color
GdkRGBA fc = (GdkRGBA){
.red = p->frame_color[0], .green = p->frame_color[1], .blue = p->frame_color[2], .alpha = 1.0
};
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(g->frame_colorpick), &fc);
}
void init(dt_iop_module_t *module)
{
// module->data = malloc(sizeof(dt_iop_borders_data_t));
module->params = calloc(1, sizeof(dt_iop_borders_params_t));
module->default_params = calloc(1, sizeof(dt_iop_borders_params_t));
module->default_enabled = 0;
module->params_size = sizeof(dt_iop_borders_params_t);
module->gui_data = NULL;
module->priority = 953; // module order created by iop_dependencies.py, do not edit!
}
void cleanup(dt_iop_module_t *module)
{
free(module->params);
module->params = NULL;
}
static gboolean borders_draw(GtkWidget *widget, cairo_t *cr, dt_iop_module_t *self)
{
if(darktable.gui->reset) return FALSE;
if(self->picked_output_color_max[0] < 0) return FALSE;
if(self->request_color_pick == DT_REQUEST_COLORPICK_OFF) return FALSE;
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;
// interrupt if no valid color reading
if(self->picked_color_min[0] == INFINITY) return FALSE;
if(fabsf(p->color[0] - self->picked_color[0]) < 0.0001f
&& fabsf(p->color[1] - self->picked_color[1]) < 0.0001f
&& fabsf(p->color[2] - self->picked_color[2]) < 0.0001f)
{
// interrupt infinite loops
return FALSE;
}
if(fabsf(p->frame_color[0] - self->picked_color[0]) < 0.0001f
&& fabsf(p->frame_color[1] - self->picked_color[1]) < 0.0001f
&& fabsf(p->frame_color[2] - self->picked_color[2]) < 0.0001f)
{
// interrupt infinite loops
return FALSE;
}
GdkRGBA c = (GdkRGBA){.red = self->picked_color[0],
.green = self->picked_color[1],
.blue = self->picked_color[2],
.alpha = 1.0 };
if(g->active_colorpick == g->frame_colorpick)
{
p->frame_color[0] = self->picked_color[0];
p->frame_color[1] = self->picked_color[1];
p->frame_color[2] = self->picked_color[2];
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(g->frame_colorpick), &c);
}
else
{
p->color[0] = self->picked_color[0];
p->color[1] = self->picked_color[1];
p->color[2] = self->picked_color[2];
gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(g->colorpick), &c);
}
dt_dev_add_history_item(darktable.develop, self, TRUE);
return FALSE;
}
static void aspect_changed(GtkWidget *combo, dt_iop_module_t *self)
{
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;
int which = dt_bauhaus_combobox_get(combo);
const char *text = dt_bauhaus_combobox_get_text(combo);
if(which < 0)
{
p->aspect = DT_IOP_BORDERS_ASPECT_CONSTANT_VALUE;
if(text)
{
const char *c = text;
const char *end = text + strlen(text);
while(*c != ':' && *c != '/' && c < end) c++;
if(c < end - 1)
{
// *c = '\0'; // not needed, atof will stop there.
c++;
p->aspect = atof(text) / atof(c);
g_strlcpy(p->aspect_text, text, sizeof(p->aspect_text));
}
}
}
else if(which < DT_IOP_BORDERS_ASPECT_COUNT)
{
g_strlcpy(p->aspect_text, text, sizeof(p->aspect_text));
p->aspect = g->aspect_ratios[which];
}
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
