void changeColor(GtkColorButton *cb, gpointer data)
{
GtkStyleContext *context;
GdkRGBA fg, bg;
char *css;
GError *err = NULL;
context = gtk_widget_get_style_context(button);
if (current != NULL) {
gtk_style_context_remove_provider(context, GTK_STYLE_PROVIDER(current));
g_object_unref(current);
}
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(foreground), &fg);
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(background), &bg);
css = g_strdup_printf(CSSFormat,
(int) (fg.red * 255),
(int) (fg.green * 255),
(int) (fg.blue * 255),
(int) (bg.red * 255),
(int) (bg.green * 255),
(int) (bg.blue * 255));
current = gtk_css_provider_new();
if (gtk_css_provider_load_from_data(current, css, -1, &err) == FALSE)
g_error("error parsing CSS: %s", err->message);
gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER(current), GTK_STYLE_PROVIDER_PRIORITY_USER);
g_free(css);
}
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);
}
static void
gtk_color_editor_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkColorEditor *ce = GTK_COLOR_EDITOR (object);
GtkColorChooser *cc = GTK_COLOR_CHOOSER (object);
switch (prop_id)
{
case PROP_RGBA:
{
GdkRGBA color;
gtk_color_chooser_get_rgba (cc, &color);
g_value_set_boxed (value, &color);
}
break;
case PROP_USE_ALPHA:
g_value_set_boolean (value, gtk_widget_get_visible (ce->priv->a_slider));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
dialog_response (GtkDialog *dialog,
gint response,
gpointer data)
{
if (response == GTK_RESPONSE_CANCEL)
gtk_widget_hide (GTK_WIDGET (dialog));
else if (response == GTK_RESPONSE_OK)
{
GtkColorButton *button = GTK_COLOR_BUTTON (data);
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (dialog),
&button->priv->rgba);
gtk_widget_hide (GTK_WIDGET (dialog));
gtk_widget_queue_draw (button->priv->draw_area);
g_signal_emit (button, color_button_signals[COLOR_SET], 0);
g_object_freeze_notify (G_OBJECT (button));
g_object_notify (G_OBJECT (button), "color");
g_object_notify (G_OBJECT (button), "alpha");
g_object_notify (G_OBJECT (button), "rgba");
g_object_thaw_notify (G_OBJECT (button));
}
}
/* ----------------------------- GtkColorButton ------------------------------ */
static void
glade_gtk_color_button_refresh_color (GtkColorButton * button,
GladeWidget * gbutton)
{
GladeProperty *property;
GdkRGBA rgba = { 0, };
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &rgba);
if ((property = glade_widget_get_property (gbutton, "color")) != NULL)
{
if (glade_property_get_enabled (property))
{
GdkColor color = { 0, };
color.red = (gint16) (rgba.red * 65535);
color.green = (gint16) (rgba.green * 65535);
color.blue = (gint16) (rgba.blue * 65535);
glade_command_set_property (property, &color);
}
}
if ((property = glade_widget_get_property (gbutton, "rgba")) != NULL)
{
if (glade_property_get_enabled (property))
glade_command_set_property (property, &rgba);
}
}
static void
pgd_annot_color_changed (GtkButton *button,
GParamSpec *pspec,
PgdAnnotsDemo *demo)
{
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &demo->annot_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);
}
}
}
/* A new color was chosen at color button */
static void _plugin_on_color_button_color_chosen(GtkColorButton *inButton,
gpointer inUserData)
{
GdkRGBA widgetColor;
ClutterColor settingsColor;
PluginWidgetSettingsMap *mapping;
g_return_if_fail(GTK_IS_COLOR_BUTTON(inButton));
/* Get color from color button */
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(inButton), &widgetColor);
#else
gtk_color_button_get_rgba(inButton, &widgetColor);
#endif
/* Convert color for settings */
settingsColor.red=MIN(255, (gint)(widgetColor.red*255.0f));
settingsColor.green=MIN(255, (gint)(widgetColor.green*255.0f));
settingsColor.blue=MIN(255, (gint)(widgetColor.blue*255.0f));
settingsColor.alpha=MIN(255, (gint)(widgetColor.alpha*255.0f));
/* Set converted color at settings */
mapping=(PluginWidgetSettingsMap*)g_object_get_data(G_OBJECT(inButton), CONFIGURATION_MAPPING);
if(mapping) g_object_set(G_OBJECT(mapping->settings), mapping->property, &settingsColor, NULL);
}
static void
color_button_color_set (GtkColorButton *button,
DrawingArea *draw_area)
{
GdkRGBA color;
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &color);
drawing_area_set_color (draw_area, &color);
}
static void
bg_color_callback (GtkWidget * widget, gpointer data)
{
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (widget),
&properties.bgcolour);
set_background_color (properties.bgcolour);
clear_game_area ();
conf_set_background_color (&properties.bgcolour);
}
void
on_background_color_set(GtkColorButton *button, ChimaraGlk *glk)
{
GdkRGBA color;
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(button), &color);
g_object_set(current_tag,
"background-rgba", &color,
"background-set", TRUE,
NULL);
}
static void chooser_get_aosd_color (GtkColorChooser * chooser, aosd_color_t * color)
{
GdkRGBA rgba;
gtk_color_chooser_get_rgba (chooser, & rgba);
color->red = rint (rgba.red * 65535.0);
color->green = rint (rgba.green * 65535.0);
color->blue = rint (rgba.blue * 65535.0);
color->alpha = rint (rgba.alpha * 65535.0);
}
G_MODULE_EXPORT void on_colorbutton_results_highlight_color_set(GtkColorChooser *color_chooser,
worddic *worddic){
gtk_color_chooser_get_rgba(color_chooser,
worddic->conf->results_highlight_color);
g_object_set(worddic->conf->highlight, "background-rgba",
worddic->conf->results_highlight_color, NULL);
worddic_conf_save(worddic->settings, worddic->conf);
}
void XAP_UnixDialog_FontChooser::fgColorChanged(void)
{
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER(m_colorSelector),
&m_currentFGColor);
UT_RGBColor * rgbcolor = UT_UnixGdkColorToRGBColor(m_currentFGColor);
UT_HashColor hash_color;
const char * c = hash_color.setColor(*rgbcolor);
addOrReplaceVecProp("color", c + 1);
delete rgbcolor;
updatePreview();
}
static void
pgd_annot_color_changed (GtkButton *button,
GParamSpec *pspec,
PgdAnnotsDemo *demo)
{
#if GTK_CHECK_VERSION(3,4,0)
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &demo->annot_color);
#else
gtk_color_button_get_rgba (GTK_COLOR_BUTTON (button), &demo->annot_color);
#endif
}
G_MODULE_EXPORT void on_colorbutton_notes_color_set(GtkColorChooser *color_chooser,
worddic *worddic){
gtk_color_chooser_get_rgba(color_chooser,
worddic->conf->notes.color);
g_object_set(worddic->conf->notes.tag, "foreground-rgba",
worddic->conf->notes.color, NULL);
worddic_conf_save(worddic->settings, worddic->conf);
}
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);
}
static const char *colourgui_read_colour_widget(ColourGUI *cg,
const char *widget_name)
{
GtkColorButton *button =
GTK_COLOR_BUTTON(gtk_builder_get_object(cg->capp.builder,
widget_name));
GdkRGBA colour;
g_return_val_if_fail(button, NULL);
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(button), &colour);
return colourgui_name_colour(&colour);
}
//================================================================
int GUI_Color_select (int *ir, int *ig, int *ib) {
//================================================================
/// \code
/// GUI_Color_select select-color-Dialog. Modal (wait).
/// Returns 3 colors as 16-bit-integers.
/// Returncode 0=OK; -1=cancel.
/// \endcode
int iRes; // response
GtkWidget *wdlg;
GtkWidget *wSel;
// GdkColor rgb; // 3 x short
GdkRGBA rgb;
// printf("GUI_ColSel\n");
// wdlg = gtk_color_selection_dialog_new ("select color ..");
wdlg = gtk_color_chooser_dialog_new ("select color ..", NULL);
// stay on top (modal)
// gtk_window_set_transient_for (GTK_WINDOW(wdlg), GTK_WINDOW(UI_MainWin));
// start waiting; does not return until user clicks button.
iRes = gtk_dialog_run (GTK_DIALOG (wdlg)); // wait (modal) !
printf(" iRes=%d\n",iRes);
// -6=_CANCEL, -5=_OK -4=
if((iRes == GTK_RESPONSE_CANCEL) ||
(iRes == GTK_RESPONSE_DELETE_EVENT)) {
gtk_widget_destroy (wdlg);
return -1;
}
// wSel = gtk_color_selection_dialog_get_color_selection (
// GTK_COLOR_SELECTION_DIALOG(wdlg));
// gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (wSel), &rgb);
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (wdlg), &rgb);
// printf(" sel.Col = %lf %lf %lf\n",rgb.red,rgb.green,rgb.blue);
*ir = (int) (rgb.red * 65535.);
*ig = (int) (rgb.green * 65535.);
*ib = (int) (rgb.blue * 65535.);
gtk_widget_destroy (wdlg);
// printf(" sel.Col = %d %d %d\n",*ir,*ig,*ib);
return 0;
}
void XAP_UnixDialog_FontChooser::bgColorChanged(void)
{
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER(m_bgcolorSelector),
&m_currentBGColor);
UT_RGBColor * rgbcolor = UT_UnixGdkColorToRGBColor(m_currentBGColor);
UT_HashColor hash_color;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_checkTransparency), FALSE);
m_currentBGColorTransparent = false;
// test for funkyColor-has-been-changed-to-sane-color case
addOrReplaceVecProp("bgcolor", hash_color.setColor(*rgbcolor) + 1);
delete rgbcolor;
updatePreview();
}
static void mirror_colour(ColourGUI *cg, const char *source_widget_name,
const char *target_widget, const char *target_option)
{
GdkRGBA colour;
const char *colour_name;
gtk_color_chooser_get_rgba(
GTK_COLOR_CHOOSER(gtk_builder_get_object(cg->capp.builder,
source_widget_name)),
&colour);
colour_name = colourgui_name_colour(&colour);
colourgui_set_colour_widget(cg->capp.builder, target_widget, &colour, TRUE);
capplet_set_string(cg->capp.options, target_option, colour_name);
}
static gboolean
handle_color_sel (GtkDialog *dialog,
gint response_id, GOColor *res)
{
if (response_id == GTK_RESPONSE_OK) {
GtkColorChooser *chooser = g_object_get_data (G_OBJECT (dialog), CCW_KEY);
GdkRGBA gdk;
gtk_color_chooser_get_rgba (chooser, &gdk);
*res = GO_COLOR_FROM_GDK_RGBA (gdk);
}
/* destroy _before_ we emit */
gtk_widget_destroy (GTK_WIDGET (dialog));
return response_id == GTK_RESPONSE_OK;
}
/* Properties Dialog Callback : Apply color */
void properties_apply_color_cb(StickyNote *note)
{
char *color_str = NULL;
char *font_color_str = NULL;
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(note->w_def_color)))
{
#if GTK_CHECK_VERSION (3, 0, 0)
GdkRGBA color, font_color;
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (note->w_color), &color);
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (note->w_font_color), &font_color);
color_str = gdk_rgba_to_string (&color);
font_color_str = gdk_rgba_to_string (&font_color);
#else
GdkColor color, font_color;
gtk_color_button_get_color (GTK_COLOR_BUTTON (note->w_color), &color);
gtk_color_button_get_color (GTK_COLOR_BUTTON (note->w_font_color), &font_color);
color_str = g_strdup_printf ("#%.2x%.2x%.2x",
color.red / 256,
color.green / 256,
color.blue / 256);
font_color_str = g_strdup_printf ("#%.2x%.2x%.2x",
font_color.red / 256,
font_color.green / 256,
font_color.blue / 256);
#endif
}
stickynote_set_color (note, color_str, font_color_str, TRUE);
g_free (color_str);
g_free (font_color_str);
}
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
get_color_cb(GtkDialog *dialog, gint response_id, gpointer user_data)
{
GdkRGBA rgba;
col_sel *sel = (col_sel *)user_data;
g_return_if_fail (GTK_IS_DATABOX (sel->box));
if (response_id == GTK_RESPONSE_OK)
{
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(dialog), &rgba);
gtk_databox_graph_set_color (sel->graph, &rgba);
gtk_widget_queue_draw (GTK_WIDGET (sel->box));
}
gtk_widget_destroy(GTK_WIDGET(dialog));
}
static void
xhairs_color_opacity_changed (GtkColorButton *button, ZoomOptionsPrivate *priv)
{
GdkRGBA rgba;
gchar *color_string;
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &rgba);
color_string = g_strdup_printf ("#%02x%02x%02x",
TO_HEX(rgba.red),
TO_HEX(rgba.green),
TO_HEX(rgba.blue));
g_settings_set_string (priv->settings, "cross-hairs-color", color_string);
g_free (color_string);
g_settings_set_double (priv->settings, "cross-hairs-opacity", rgba.alpha);
}
static void colorpick_color_set(GtkColorButton *widget, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
if(self->dt->gui->reset) return;
dt_iop_watermark_params_t *p = (dt_iop_watermark_params_t *)self->params;
GdkRGBA c;
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &c);
p->color[0] = c.red;
p->color[1] = c.green;
p->color[2] = c.blue;
dt_conf_set_float("plugins/darkroom/watermark/color_red", p->color[0]);
dt_conf_set_float("plugins/darkroom/watermark/color_green", p->color[1]);
dt_conf_set_float("plugins/darkroom/watermark/color_blue", p->color[2]);
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
static void
palette_color_notify_cb (GtkColorButton *button,
GParamSpec *pspec,
GSettings *profile)
{
GtkWidget *editor;
GdkRGBA color;
guint i;
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (button), &color);
i = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (button), "palette-entry-index"));
editor = gtk_widget_get_toplevel (GTK_WIDGET (button));
g_signal_handlers_block_by_func (profile, G_CALLBACK (profile_palette_notify_colorpickers_cb), editor);
modify_palette_entry (profile, i, &color);
g_signal_handlers_unblock_by_func (profile, G_CALLBACK (profile_palette_notify_colorpickers_cb), editor);
}
static void
color_modified (GtkColorButton *cb, GParamSpec *ignored, ObjectProperty *p)
{
GdkRGBA rgba;
GdkColor color;
GValue val = G_VALUE_INIT;
gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (cb), &rgba);
color.red = 65535 * rgba.red;
color.green = 65535 * rgba.green;
color.blue = 65535 * rgba.blue;
g_value_init (&val, p->spec->value_type);
g_value_set_boxed (&val, &color);
set_property_value (p->obj, p->spec, &val);
g_value_unset (&val);
}
static void frame_colorpick_color_set(GtkColorButton *widget, dt_iop_module_t *self)
{
if(self->dt->gui->reset) return;
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;
// turn off the other color picker so that this tool actually works ...
gtk_toggle_button_set_active(g->frame_picker, FALSE);
gtk_toggle_button_set_active(g->border_picker, FALSE);
GdkRGBA c;
gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &c);
p->frame_color[0] = c.red;
p->frame_color[1] = c.green;
p->frame_color[2] = c.blue;
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
