static void header_label_style_set(GtkWidget *widget)
{
static gint recursive = 0;
GtkStyle *style;
if (recursive > 0)
return;
++recursive;
style = gtk_widget_get_style(widget);
gtk_widget_modify_fg(widget, GTK_STATE_NORMAL, &style->fg[GTK_STATE_SELECTED]);
--recursive;
}
GtkWidget *
hard_drive_status_tile_new ()
{
GtkWidget *tile;
GtkWidget *image;
GtkWidget *header;
GtkWidget *subheader;
AtkObject *accessible;
char *name;
image = gtk_image_new ();
slab_load_image (GTK_IMAGE (image), GTK_ICON_SIZE_BUTTON, "utilities-system-monitor");
name = g_strdup (_("_System Monitor"));
header = gtk_label_new (name);
gtk_label_set_use_underline (GTK_LABEL (header), TRUE);
gtk_misc_set_alignment (GTK_MISC (header), 0.0, 0.5);
subheader = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (subheader), 0.0, 0.5);
gtk_widget_modify_fg (subheader, GTK_STATE_NORMAL,
&subheader->style->fg[GTK_STATE_INSENSITIVE]);
tile = g_object_new (HARD_DRIVE_STATUS_TILE_TYPE, "tile-uri", "tile://hard-drive-status",
"nameplate-image", image, "nameplate-header", header, "nameplate-subheader",
subheader, NULL);
TILE (tile)->actions = g_new0 (TileAction *, 1);
TILE (tile)->n_actions = 1;
TILE (tile)->actions[HARD_DRIVE_STATUS_TILE_ACTION_OPEN] =
tile_action_new (TILE (tile), open_hard_drive_tile, NULL,
TILE_ACTION_OPENS_NEW_WINDOW);
TILE (tile)->default_action = TILE (tile)->actions[HARD_DRIVE_STATUS_TILE_ACTION_OPEN];
g_signal_connect (G_OBJECT (tile), "hide", G_CALLBACK (tile_hide_event_cb), NULL);
g_signal_connect (G_OBJECT (tile), "show", G_CALLBACK (tile_show_event_cb), NULL);
accessible = gtk_widget_get_accessible (tile);
atk_object_set_name (accessible, name);
gtk_label_set_mnemonic_widget (GTK_LABEL (header), GTK_WIDGET (tile));
g_free (name);
return GTK_WIDGET (tile);
}
gpointer sokoke_xfce_header_new(const gchar* header, const gchar *icon)
{
GtkWidget* entry;
GtkWidget* xfce_heading;
GtkWidget* hbox;
GtkWidget* vbox;
GtkWidget* image;
GtkWidget* label;
GtkWidget* separator;
gchar* markup;
entry = gtk_entry_new();
xfce_heading = gtk_event_box_new();
gtk_widget_modify_bg(xfce_heading,
GTK_STATE_NORMAL,
>k_widget_get_style(entry)->base[GTK_STATE_NORMAL]);
hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
if (icon)
image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_DIALOG);
else
image = gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_DIALOG);
label = gtk_label_new(NULL);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_widget_modify_fg(label,
GTK_STATE_NORMAL,
>k_widget_get_style(entry)->text[GTK_STATE_NORMAL]);
markup = g_strdup_printf("<span size='large' weight='bold'>%s</span>", header);
gtk_label_set_markup(GTK_LABEL(label), markup);
gtk_misc_set_alignment (GTK_MISC(label), 0, 0.5);
g_free(markup);
gtk_widget_destroy (entry);
gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(xfce_heading), hbox);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), xfce_heading, FALSE, FALSE, 0);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);
return vbox;
}
static inline void
update_colorpicker_fg(
GtkWidget* colorpicker,
float hue,
float sat)
{
float rgb[3];
GdkColor c;
hsl2rgb(rgb, hue, sat, 0.5);
c.red = rgb[0]*65535.0;
c.green = rgb[1]*65535.0;
c.blue = rgb[2]*65535.0;
gtk_widget_modify_fg(colorpicker,GTK_STATE_NORMAL,&c);
}
static void private_cb_label_style_set (GtkWidget * widget, GtkStyle * old_style)
{
static gboolean recursive = 0;
GtkStyle *style;
if (recursive > 0)
return;
++recursive;
style = gtk_widget_get_style (widget);
gtk_widget_modify_fg (widget, GTK_STATE_NORMAL,
&style->fg[GTK_STATE_SELECTED]);
--recursive;
}
static void create_char(int index)
{
int i;
// dbg("create_char %d\n", index);
if (!hbox_edit) {
dbg("create_char: !hbox_edit\n");
return;
}
GdkColor fg;
gdk_color_parse(gcin_win_color_fg, &fg);
GdkColor color_bg;
gdk_color_parse(tsin_phrase_line_color, &color_bg);
i = index;
{
if (chars[i].vbox)
return;
GtkWidget *event_box = gtk_event_box_new();
gtk_event_box_set_visible_window (GTK_EVENT_BOX(event_box), FALSE);
chars[i].vbox = event_box;
g_signal_connect (G_OBJECT (event_box), "button-press-event", G_CALLBACK (mouse_char_callback), GINT_TO_POINTER(index));
gtk_box_pack_start (GTK_BOX (hbox_edit), event_box, FALSE, FALSE, 0);
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add(GTK_CONTAINER(event_box), vbox);
GtkWidget *label = gtk_label_new(NULL);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
set_label_font_size(label, gcin_font_size);
chars[i].label = label;
if (gcin_win_color_use) {
#if !GTK_CHECK_VERSION(2,91,6)
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &fg);
#else
GdkRGBA rgbfg;
gdk_rgba_parse(&rgbfg, gdk_color_to_string(&fg));
gtk_widget_override_color(label, GTK_STATE_FLAG_NORMAL, &rgbfg);
#endif
}
gtk_widget_show_all(event_box);
}
}
/*
Creates label
*/
GtkWidget* libui_gtk_label_new (char *text, gboolean change_size, int width_label, int height_label, gboolean change_color, GdkColor *color)
{
GtkWidget *widget;
widget = gtk_label_new (text);
/* Set label's sizes */
gtk_widget_set_size_request (widget, width_label, height_label);
if (color != NULL)
/* Set text color */
gtk_widget_modify_fg (widget, GTK_STATE_NORMAL, color);
return widget;
}
int main_move_cursor(struct layout *l, struct key_map *km)
{
char buf[] = "AI_00";
struct named_element *e;
GdkColor h_color, n_color;
char sta[] = "000";
gdk_color_parse("red", &h_color);
gdk_color_parse(FG_COLOR_TEXT, &n_color);
if (l->state.main_selected >= 0) {
sprintf(buf, "AL_%02i", l->state.main_selected);
e = get_element(l, buf);
gtk_widget_modify_fg(e->widget, GTK_STATE_NORMAL, &n_color);
}
if (km->keyval == KEY_DN || km->keyval == KEY_PGDN) {
if (l->state.main_selected < 7)
l->state.main_selected++;
} else if (km->keyval == KEY_UP || km->keyval == KEY_PGUP) {
if (l->state.main_selected > -1)
l->state.main_selected--;
}
snprintf(sta, sizeof(sta), "%d", l->state.main_selected);
ui_send(l->state.last_ui_fd, "STATIONINFO", sta);
if (l->state.main_selected < 0)
return 0;
sprintf(buf, "AL_%02i", l->state.main_selected);
e = get_element(l, buf);
gtk_widget_modify_fg(e->widget, GTK_STATE_NORMAL, &h_color);
return 0;
}
void gui_update(dt_iop_module_t *self)
{
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"));
GdkColor c;
c.red = p->color[0]*65535.0;
c.green = p->color[1]*65535.0;
c.blue = p->color[2]*65535.0;
gtk_widget_modify_fg(GTK_WIDGET(g->colorpicker), GTK_STATE_NORMAL, &c);
}
/*! \brief Set the status text color
*
* \par Function Description
* Changes the status text color to show if the current editing
* action is active or not.
*
* \param [in,out] view This GschemBottomWidget
* \param [in] active The state to visualise
*/
void
gschem_bottom_widget_set_status_text_color (GschemBottomWidget *widget, gboolean active)
{
g_return_if_fail (widget != NULL);
GdkColor color;
if (active) {
gdk_color_parse ("green", &color);
} else {
gdk_color_parse ("black", &color);
}
gtk_widget_modify_fg (GTK_WIDGET (widget->status_label), GTK_STATE_NORMAL, &color);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_gtkWidgetSetForeground
(JNIEnv *env, jobject obj, jint red, jint green, jint blue)
{
GdkColor color;
GtkWidget *widget;
void *ptr;
gdk_threads_enter ();
ptr = gtkpeer_get_widget (env, obj);
color.red = (red / 255.0) * 65535;
color.green = (green / 255.0) * 65535;
color.blue = (blue / 255.0) * 65535;
widget = find_fg_color_widget (GTK_WIDGET (ptr));
gtk_widget_modify_fg (widget, GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg (widget, GTK_STATE_ACTIVE, &color);
gtk_widget_modify_fg (widget, GTK_STATE_PRELIGHT, &color);
gdk_threads_leave ();
}
/*! \brief Set the status text color
*
* \par Function Description
* Changes the status text color to show if the current editing
* action is active or not.
*
* \param [in,out] view This GschemBottomWidget
* \param [in] active The state to visualise
*/
void
gschem_bottom_widget_set_status_text_color (GschemBottomWidget *widget, gboolean active)
{
g_return_if_fail (widget != NULL);
const GdkColor* color = NULL;
if (active) {
color = &widget->status_active_color;
} else {
color = &widget->status_inactive_color;
}
gtk_widget_modify_fg (GTK_WIDGET (widget->status_label), GTK_STATE_NORMAL, color);
}
GtkWidget *make_item(gint index)
{
GtkWidget *fixed_item;
GtkWidget *event_box;
GtkWidget *image;
GtkWidget *label;
const gchar *img_file;
GdkColor color1;
gdk_color_parse ("white", &color1);
fixed_item = gtk_fixed_new();
img_file = item_normal_imgs[index];
image = gtk_image_new_from_file(img_file);
gtk_widget_show(image);
const gchar *text = item_labels[index];
label = gtk_label_new(text);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
gtk_widget_set_size_request(label, label_width, label_height);
ITEM_IMG *item_img = (ITEM_IMG *)malloc(sizeof(ITEM_IMG));
item_img->image = image;
item_img->index = index;
item_list = g_list_append(item_list, (gpointer)item_img);
event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(event_box), image);
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), FALSE);
gtk_widget_show(event_box);
g_signal_connect(G_OBJECT(event_box), "enter_notify_event",
G_CALLBACK(item_enter), (gpointer)item_img);
g_signal_connect(G_OBJECT(event_box), "leave_notify_event",
G_CALLBACK(item_leave), (gpointer)item_img);
g_signal_connect(G_OBJECT(event_box), "button_press_event",
G_CALLBACK(item_press), (gpointer)item_img);
gtk_fixed_put(GTK_FIXED(fixed_item), event_box, 0, 0);
gtk_widget_set_size_request(label, 110, 40);
gtk_widget_modify_fg(label, GTK_STATE_NORMAL, &color1);
gtk_fixed_put(GTK_FIXED(fixed_item), label, 0, label_pos_y);
gtk_widget_show_all(fixed_item);
return fixed_item;
}
static void set_color(GtkWidget *widget, gint color)
{
GdkColor c;
if (color == COLOR_RED) {
c.red = 0xffff;
c.green = 0;
c.blue = 0;
} else {
c.red = 0;
c.green = 0xffff;
c.blue = 0;
}
gtk_widget_modify_fg(widget, GTK_STATE_NORMAL, &c);
}
/*! \brief Display the magnetic net indicator in the status bar
*
* \param [in] widget This GschemBottomWidget
* \param [in] pspec The parameter that changed
* \param [in] unused
*/
static void
update_magnetic_net_label (GschemBottomWidget *widget, GParamSpec *pspec, gpointer unused)
{
g_return_if_fail (widget != NULL);
GdkColor color;
gdk_color_parse (widget->magnetic_net_mode ? "purple" : "darkgray", &color);
gtk_widget_modify_fg (GTK_WIDGET (widget->magnetic_net_label),
GTK_STATE_NORMAL,
&color);
gtk_label_set_markup (GTK_LABEL (widget->magnetic_net_label),
widget->magnetic_net_mode ?
"MN: <b>ON</b>" : "MN: off");
}
/*! \brief Display the rubber band indicator in the status bar
*
* \param [in] widget This GschemBottomWidget
* \param [in] pspec The parameter that changed
* \param [in] unused
*/
static void
update_rubber_band_label (GschemBottomWidget *widget, GParamSpec *pspec, gpointer unused)
{
g_return_if_fail (widget != NULL);
GdkColor color;
gdk_color_parse (widget->rubber_band_mode ? "green" : "blue", &color);
gtk_widget_modify_fg (GTK_WIDGET (widget->rubber_band_label),
GTK_STATE_NORMAL,
&color);
gtk_label_set_markup (GTK_LABEL (widget->rubber_band_label),
widget->rubber_band_mode ?
"RB: <b>ON</b>" : "RB: off");
}
static inline void
render_backdrop_area(GtkExperimentTranscript *trans, gint64 current_time_px)
{
GtkWidget *widget = GTK_WIDGET(trans);
gint y_start, y_end;
GdkColor color;
GdkColor *bg = &widget->style->bg[gtk_widget_get_state(widget)];
if (!gtk_experiment_transcript_get_use_backdrop_area(trans))
return;
if (gtk_experiment_transcript_get_reverse_mode(trans)) {
y_end = current_time_px - TIME_TO_PX(trans->priv->backdrop.start);
y_start = current_time_px - TIME_TO_PX(trans->priv->backdrop.end);
} else {
y_start = widget->allocation.height -
(current_time_px - TIME_TO_PX(trans->priv->backdrop.start));
y_end = widget->allocation.height -
(current_time_px - TIME_TO_PX(trans->priv->backdrop.end));
}
if ((y_start < 0 && y_end < 0) ||
(y_start > widget->allocation.height &&
y_end > widget->allocation.height))
return;
y_start = CLAMP(y_start, 0, widget->allocation.height);
y_end = CLAMP(y_end, 0, widget->allocation.height);
color.pixel = 0;
color.red = MAX((gint)bg->red - BACKDROP_VALUE, 0);
color.blue = MAX((gint)bg->blue - BACKDROP_VALUE, 0);
color.green = MAX((gint)bg->green - BACKDROP_VALUE, 0);
if (!color.red && !color.blue && !color.green) {
color.red = MIN((gint)bg->red + BACKDROP_VALUE, G_MAXUINT16);
color.blue = MIN((gint)bg->blue + BACKDROP_VALUE, G_MAXUINT16);
color.green = MIN((gint)bg->green + BACKDROP_VALUE, G_MAXUINT16);
}
gtk_widget_modify_fg(widget, gtk_widget_get_state(widget), &color);
gdk_draw_rectangle(GDK_DRAWABLE(trans->priv->layer_text),
widget->style->fg_gc[gtk_widget_get_state(widget)],
TRUE,
0, y_start,
widget->allocation.width, y_end - y_start);
}
static gint
luaH_label_newindex(lua_State *L, luakit_token_t token)
{
size_t len;
widget_t *w = luaH_checkwidget(L, 1);
const gchar *tmp;
GdkColor c;
PangoFontDescription *font;
switch(token)
{
case L_TK_TEXT:
gtk_label_set_markup(GTK_LABEL(w->widget),
luaL_checklstring(L, 3, &len));
break;
case L_TK_FG:
tmp = luaL_checklstring(L, 3, &len);
if (!gdk_color_parse(tmp, &c)) {
warn("invalid color: %s", tmp);
return 0;
}
gtk_widget_modify_fg(GTK_WIDGET(w->widget), GTK_STATE_NORMAL, &c);
g_object_set_data_full(G_OBJECT(w->widget), "fg", g_strdup(tmp), g_free);
break;
case L_TK_FONT:
tmp = luaL_checklstring(L, 3, &len);
font = pango_font_description_from_string(tmp);
gtk_widget_modify_font(GTK_WIDGET(w->widget), font);
pango_font_description_free(font);
g_object_set_data_full(G_OBJECT(w->widget), "font", g_strdup(tmp), g_free);
break;
case L_TK_SELECTABLE:
gtk_label_set_selectable(GTK_LABEL(w->widget), luaH_checkboolean(L, 3));
break;
default:
warn("unknown property: %s", luaL_checkstring(L, 2));
return 0;
}
return luaH_object_emit_property_signal(L, 1);
}
/*
Creates label using a descriptor
*/
GtkWidget* libui_gtk_label_new_with_descriptor (char *text, char *descriptor, int width_label, int height_label, GdkColor *color)
{
GtkWidget *widget;
widget = gtk_label_new (text);
/* Modify font */
gtk_widget_modify_font (widget, pango_font_description_from_string (descriptor));
/* Set label's sizes */
gtk_widget_set_size_request (widget, width_label, height_label);
if (color != NULL)
/* Set text color */
gtk_widget_modify_fg (widget, GTK_STATE_NORMAL, color);
return widget;
}
void button_set_text1(GtkWidget *entry, gpointer data)
{
GdkColor color;
PangoFontDescription *pfd;
g_return_if_fail(entry != NULL);
g_return_if_fail(entry != NULL);
pfd = pango_font_description_from_string("Simsun");
pango_font_description_set_size (pfd, 20 * PANGO_SCALE);
gtk_widget_modify_font(GTK_WIDGET(entry),pfd);
pango_font_description_free(pfd);
gdk_color_parse ("RED", &color);
gtk_widget_modify_fg (entry, GTK_STATE_NORMAL, &color);
//gdk_color_parse ("GREEN", &color);
//gtk_widget_modify_bg (lable, GTK_STATE_NORMAL, &color);
//gdk_color_parse ("BLUE", &color);
//gtk_widget_modify_base (lable, GTK_STATE_NORMAL, &color);
}
static gboolean vi_list_item_leave_notify_event(GtkWidget *widget,
GdkEventCrossing *event, struct vi_list_item_t *item)
{
PangoAttrList *attrs;
PangoAttribute *underline_attr;
GdkWindow *window;
window = gtk_widget_get_parent_window(widget);
gdk_window_set_cursor(window, NULL);
attrs = gtk_label_get_attributes(GTK_LABEL(item->label));
underline_attr = pango_attr_underline_new(PANGO_UNDERLINE_NONE);
pango_attr_list_change(attrs, underline_attr);
gtk_widget_modify_fg(item->label, GTK_STATE_NORMAL, &item->label_color);
return FALSE;
}
/* createDrawingArea
* Creates the main drawing area
*
* @return void
*/
void createDrawingArea () {
// Background color
GdkColor color;
gdk_color_parse("#458B00", &color);
// Creates drawing area with the specified dimensions and background color
this.drawingArea = gtk_drawing_area_new();
gtk_drawing_area_size((GtkDrawingArea*) this.drawingArea, canvas_width, canvas_height);
gtk_widget_modify_bg((GtkWidget*) this.drawingArea, GTK_STATE_NORMAL, &color);
gdk_color_parse("#FFA824", &color);
gtk_widget_modify_fg((GtkWidget*) this.drawingArea, GTK_STATE_NORMAL, &color);
// Attach events to the drawing area
gtk_signal_connect((GtkObject*) this.drawingArea, "expose_event", G_CALLBACK(gtk_expose_event), NULL);
gtk_signal_connect((GtkObject*) this.drawingArea, "configure_event", G_CALLBACK(gtk_configure_event), NULL);
gtk_container_add((GtkContainer*) this.vbox, this.drawingArea);
}
static GtkWidget *create_ms_header (MenuStart *ms)
{
GtkWidget *box;
GtkStyle *style, *labelstyle;
GtkWidget *hbox;
gchar *markup;
ms->title = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (ms->title), TRUE);
markup = g_strjoin ("", "<big><b>", _("Menu"), "</b></big>", NULL);
gtk_label_set_markup (GTK_LABEL (ms->title), markup);
g_free (markup);
ms->menu_image = gtk_image_new_from_stock
("gtk-index", GTK_ICON_SIZE_LARGE_TOOLBAR);
box = gtk_event_box_new ();
style = gtk_widget_get_style (box);
labelstyle = gtk_widget_get_style (ms->title);
gtk_widget_modify_bg (GTK_WIDGET (box), GTK_STATE_NORMAL,
&style->bg[GTK_STATE_SELECTED]);
gtk_widget_modify_fg (GTK_WIDGET (ms->title), GTK_STATE_NORMAL,
&style->fg[GTK_STATE_SELECTED]);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 10);
gtk_box_pack_start (GTK_BOX (hbox), ms->menu_image, FALSE, FALSE, 1);
gtk_box_pack_start (GTK_BOX (hbox), ms->title, FALSE, FALSE, 1);
gtk_container_add (GTK_CONTAINER (box), hbox);
g_signal_connect_after (G_OBJECT (ms->title), "style_set",
G_CALLBACK (private_cb_label_style_set),
NULL);
g_signal_connect_after (G_OBJECT (box), "style_set",
G_CALLBACK (private_cb_eventbox_style_set),
NULL);
gtk_widget_show_all (box);
return box;
}
void select_font_color(GtkWidget *widget, gpointer label)
{
GtkResponseType result;
GtkColorSelection *colorsel;
GtkWidget *dialog = gtk_color_selection_dialog_new("Select Font Color");
result = gtk_dialog_run(GTK_DIALOG(dialog));
if(result == GTK_RESPONSE_OK)
{
GdkColor color;
colorsel = GTK_COLOR_SELECTION(GTK_COLOR_SELECTION_DIALOG(dialog)->colorsel);
gtk_color_selection_get_current_color(colorsel, &color);
gtk_widget_modify_fg(GTK_WIDGET(label), GTK_STATE_NORMAL, &color);
}
gtk_widget_destroy(dialog);
}
static void
hue_callback(GtkDarktableGradientSlider *slider, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_splittoning_params_t *p = (dt_iop_splittoning_params_t *)self->params;
dt_iop_splittoning_gui_data_t *g = (dt_iop_splittoning_gui_data_t *)self->gui_data;
double hue=0;
double saturation=0;
float color[3];
GtkWidget *preview;
GtkDarktableGradientSlider *sslider=NULL;
if( slider == g->gslider1 )
{
// Shadows
p->shadow_hue=hue=dtgtk_gradient_slider_get_value(slider);
saturation=p->shadow_saturation;
preview=GTK_WIDGET(g->colorpick1);
sslider=g->gslider2;
}
else
{
p->highlight_hue=hue=dtgtk_gradient_slider_get_value(slider);
saturation=p->highlight_saturation;
preview=GTK_WIDGET(g->colorpick2);
sslider=g->gslider4;
}
hsl2rgb(color,hue,saturation,0.5);
GdkColor c;
c.red=color[0]*65535.0;
c.green=color[1]*65535.0;
c.blue=color[2]*65535.0;
dtgtk_gradient_slider_set_stop(sslider,1.0,c); // Update saturation end color
gtk_widget_modify_fg(preview,GTK_STATE_NORMAL,&c); // update color preview
if(self->dt->gui->reset) return;
gtk_widget_draw(GTK_WIDGET(sslider),NULL);
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
void CreateButton (GtkWidget *table)
{
for (int i= 0; i< NumberofButtons ; i++) {
if(bt_list[i].btLabel!="+/-")
{
GtkWidget *button= gtk_button_new_with_label (bt_list[i].btLabel);
g_signal_connect (button, "clicked", G_CALLBACK (bt_clicked), bt_list[i].btLabel);
gtk_table_attach_defaults(GTK_TABLE(table), button,bt_list[i].col,bt_list[i].col+1, bt_list[i].row, bt_list[i].row+1);
gtk_widget_show (button);
bt_list[i].widget =button;
if(bt_list[i].btLabel=="+"||bt_list[i].btLabel=="-"||bt_list[i].btLabel=="*"||bt_list[i].btLabel=="="||bt_list[i].btLabel=="/"||bt_list[i].btLabel=="C")
{
GdkColor color;
gdk_color_parse ("blue", &color);
gtk_widget_modify_fg( GTK_WIDGET(button), GTK_STATE_NORMAL, &color);
}
}
}
}
void gui_update(struct dt_iop_module_t *self)
{
dt_iop_module_t *module = (dt_iop_module_t *)self;
dt_iop_colorize_gui_data_t *g = (dt_iop_colorize_gui_data_t *)self->gui_data;
dt_iop_colorize_params_t *p = (dt_iop_colorize_params_t *)module->params;
dtgtk_gradient_slider_set_value(g->gslider1,p->hue);
dtgtk_gradient_slider_set_value(g->gslider2,p->saturation);
dtgtk_slider_set_value(g->scale1, p->lightness);
dtgtk_slider_set_value(g->scale2, p->source_lightness_mix);
float color[3];
hsl2rgb(color,p->hue,p->saturation,0.5);
GdkColor c;
c.red=color[0]*65535.0;
c.green=color[1]*65535.0;
c.blue=color[2]*65535.0;
gtk_widget_modify_fg(GTK_WIDGET(g->colorpick1),GTK_STATE_NORMAL,&c);
}
static void
frame_colorpick_callback (GtkDarktableButton *button, 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);
GtkColorSelectionDialog *csd = GTK_COLOR_SELECTION_DIALOG(gtk_color_selection_dialog_new(_("select frame line color")));
gtk_window_set_transient_for(GTK_WINDOW(csd), GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)));
GtkWidget *okButton, *cancelButton = 0;
g_object_get(G_OBJECT(csd), "ok-button", &okButton, NULL);
g_object_get(G_OBJECT(csd), "cancel-button", &cancelButton, NULL);
g_signal_connect (G_OBJECT (okButton), "clicked",
G_CALLBACK (colorpick_button_callback), csd);
g_signal_connect (G_OBJECT (cancelButton), "clicked",
G_CALLBACK (colorpick_button_callback), csd);
GtkColorSelection *cs = GTK_COLOR_SELECTION(gtk_color_selection_dialog_get_color_selection(csd));
GdkColor c;
c.red = 65535 * p->frame_color[0];
c.green = 65535 * p->frame_color[1];
c.blue = 65535 * p->frame_color[2];
gtk_color_selection_set_current_color(cs, &c);
if(gtk_dialog_run(GTK_DIALOG(csd)) == GTK_RESPONSE_ACCEPT)
{
gtk_color_selection_get_current_color(cs, &c);
p->frame_color[0] = c.red /65535.0;
p->frame_color[1] = c.green/65535.0;
p->frame_color[2] = c.blue /65535.0;
gtk_widget_modify_fg(GTK_WIDGET(g->frame_colorpick), GTK_STATE_NORMAL, &c);
}
gtk_widget_destroy(GTK_WIDGET(csd));
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
static void
override_style(GtkWidget *widget, GtkStyle *previous_style) {
GtkStateType state;
GtkStyle *style;
GdkColor fg;
GdkColor bg;
style = gtk_style_copy (widget->style);
if (previous_style == NULL
|| (previous_style != NULL
&& (previous_style->bg[GTK_STATE_NORMAL].red != style->bg[GTK_STATE_NORMAL].red
|| previous_style->bg[GTK_STATE_NORMAL].green != style->bg[GTK_STATE_NORMAL].green
|| previous_style->bg[GTK_STATE_NORMAL].blue != style->bg[GTK_STATE_NORMAL].blue))) {
state = (GtkStateType) 0;
while (state < (GtkStateType) G_N_ELEMENTS (widget->style->bg)) {
color_reverse (&style->bg[state], &bg);
gtk_widget_modify_bg (widget, state, &bg);
state++;
}
}
if (previous_style == NULL
|| (previous_style != NULL
&& (previous_style->fg[GTK_STATE_NORMAL].red != style->fg[GTK_STATE_NORMAL].red
|| previous_style->fg[GTK_STATE_NORMAL].green != style->fg[GTK_STATE_NORMAL].green
|| previous_style->fg[GTK_STATE_NORMAL].blue != style->fg[GTK_STATE_NORMAL].blue))) {
state = (GtkStateType) 0;
while (state < (GtkStateType) G_N_ELEMENTS (widget->style->fg)) {
color_reverse (&style->fg[state], &fg);
gtk_widget_modify_fg (widget, state, &fg);
state++;
}
}
g_object_unref (style);
}
/**
* @brief Build the GUI
*
* @return
*/
GtkWidget* buildVolumeUI() {
GtkWidget* label;
volumeFrame=gtk_frame_new("AF Gain");
gtk_widget_modify_bg(volumeFrame,GTK_STATE_NORMAL,&background);
gtk_widget_modify_fg(gtk_frame_get_label_widget(GTK_FRAME(volumeFrame)),GTK_STATE_NORMAL,&white);
volumeScale=gtk_hscale_new_with_range(0.0,100.0,10.0);
g_signal_connect(G_OBJECT(volumeScale),"value-changed",G_CALLBACK(volumeChanged),NULL);
gtk_range_set_value((GtkRange*)volumeScale,volume);
gtk_widget_set_size_request(GTK_WIDGET(volumeScale),150,25);
gtk_widget_show(volumeScale);
gtk_container_add(GTK_CONTAINER(volumeFrame),volumeScale);
gtk_widget_set_size_request(volumeFrame,200,55);
gtk_widget_show(volumeFrame);
SetRXOutputGain(0,0,volume/100.0);
return volumeFrame;
}
