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); }