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
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);
}
}
}
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
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);
}
/* 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 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 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 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
drawing_area_color_set (DrawingArea *area,
GdkRGBA *color,
GtkColorButton *button)
{
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (button), color);
}
/* 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 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
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
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);
}
/* 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);
}
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);
}
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;
}
}
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
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);
}
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
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;
}
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);
}
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
}
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 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
}
