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 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 inline void gui_init_tab(struct dt_iop_module_t *self, const char *name, GtkWidget **ppcolor, const GdkRGBA *c, GtkWidget **pphue, GtkWidget **ppsaturation) { gtk_box_pack_start(GTK_BOX(self->widget), dt_ui_section_label_new(name), FALSE, FALSE, 5); // color button GtkWidget *color; *ppcolor = color = gtk_color_button_new_with_rgba(c); gtk_widget_set_size_request(GTK_WIDGET(color), DT_PIXEL_APPLY_DPI(32), DT_PIXEL_APPLY_DPI(32)); gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(color), FALSE); gtk_color_button_set_title(GTK_COLOR_BUTTON(color), _("select tone color")); // hue slider GtkWidget *hue; *pphue = hue = (dt_bauhaus_slider_new_with_range_and_feedback(self, 0.0f, 1.0f, 0.01f, 0.0f, 2, 0)); dt_bauhaus_slider_set_stop(hue, 0.0f, 1.0f, 0.0f, 0.0f); dt_bauhaus_widget_set_label(hue, NULL, _("hue")); dt_bauhaus_slider_set_stop(hue, 0.166f, 1.0f, 1.0f, 0.0f); dt_bauhaus_slider_set_stop(hue, 0.322f, 0.0f, 1.0f, 0.0f); dt_bauhaus_slider_set_stop(hue, 0.498f, 0.0f, 1.0f, 1.0f); dt_bauhaus_slider_set_stop(hue, 0.664f, 0.0f, 0.0f, 1.0f); dt_bauhaus_slider_set_stop(hue, 0.830f, 1.0f, 0.0f, 1.0f); dt_bauhaus_slider_set_stop(hue, 1.0f, 1.0f, 0.0f, 0.0f); g_object_set(G_OBJECT(hue), "tooltip-text", _("select the hue tone"), (char *)NULL); // saturation slider GtkWidget *saturation; *ppsaturation = saturation = dt_bauhaus_slider_new_with_range(self, 0.0f, 1.0f, 0.01f, 0.0f, 2); dt_bauhaus_widget_set_label(saturation, NULL, _("saturation")); dt_bauhaus_slider_set_stop(saturation, 0.0f, 0.2f, 0.2f, 0.2f); dt_bauhaus_slider_set_stop(saturation, 1.0f, 1.0f, 1.0f, 1.0f); g_object_set(G_OBJECT(saturation), "tooltip-text", _("select the saturation tone"), (char *)NULL); // pack the widgets GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hue), FALSE, TRUE, 0); gtk_box_pack_end(GTK_BOX(vbox), GTK_WIDGET(saturation), FALSE, TRUE, 0); GtkWidget *hbox = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(hbox), GTK_WIDGET(color), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0); }
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; }
static inline int gui_init_tab(struct dt_iop_module_t *self, int line, const char *name, GtkWidget **ppcolor, const GdkRGBA *c, GtkWidget **pphue, GtkWidget **ppsaturation) { GtkGrid *grid = GTK_GRID(self->widget); gtk_grid_attach(grid, dt_ui_section_label_new(name), 0, line++, 2, 1); // color button GtkWidget *color; *ppcolor = color = gtk_color_button_new_with_rgba(c); gtk_widget_set_size_request(GTK_WIDGET(color), DT_PIXEL_APPLY_DPI(32), DT_PIXEL_APPLY_DPI(32)); gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(color), FALSE); gtk_color_button_set_title(GTK_COLOR_BUTTON(color), _("select tone color")); // hue slider GtkWidget *hue; *pphue = hue = (dt_bauhaus_slider_new_with_range_and_feedback(self, 0.0f, 1.0f, 0.01f, 0.0f, 2, 0)); dt_bauhaus_slider_set_stop(hue, 0.0f, 1.0f, 0.0f, 0.0f); dt_bauhaus_widget_set_label(hue, NULL, _("hue")); dt_bauhaus_slider_set_stop(hue, 0.166f, 1.0f, 1.0f, 0.0f); dt_bauhaus_slider_set_stop(hue, 0.322f, 0.0f, 1.0f, 0.0f); dt_bauhaus_slider_set_stop(hue, 0.498f, 0.0f, 1.0f, 1.0f); dt_bauhaus_slider_set_stop(hue, 0.664f, 0.0f, 0.0f, 1.0f); dt_bauhaus_slider_set_stop(hue, 0.830f, 1.0f, 0.0f, 1.0f); dt_bauhaus_slider_set_stop(hue, 1.0f, 1.0f, 0.0f, 0.0f); g_object_set(G_OBJECT(hue), "tooltip-text", _("select the hue tone"), (char *)NULL); // saturation slider GtkWidget *saturation; *ppsaturation = saturation = dt_bauhaus_slider_new_with_range(self, 0.0f, 1.0f, 0.01f, 0.0f, 2); dt_bauhaus_widget_set_label(saturation, NULL, _("saturation")); dt_bauhaus_slider_set_stop(saturation, 0.0f, 0.2f, 0.2f, 0.2f); dt_bauhaus_slider_set_stop(saturation, 1.0f, 1.0f, 1.0f, 1.0f); g_object_set(G_OBJECT(saturation), "tooltip-text", _("select the saturation tone"), (char *)NULL); // pack the widgets gtk_widget_set_hexpand(hue, TRUE); // make sure that the color picker doesn't become HUGE gtk_grid_attach(grid, hue, 0, line, 1, 1); gtk_grid_attach(grid, color, 1, line++, 1, 2); gtk_grid_attach(grid, saturation, 0, line++, 1, 1); return line; }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_watermark_gui_data_t)); 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 *)self->params; int line = 0; self->widget = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(self->widget), DT_BAUHAUS_SPACE); gtk_grid_set_column_spacing(GTK_GRID(self->widget), DT_PIXEL_APPLY_DPI(10)); gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("content")), 0, line++, 3, 1); // Add the marker combobox gchar configdir[PATH_MAX] = { 0 }; gchar datadir[PATH_MAX] = { 0 }; dt_loc_get_datadir(datadir, sizeof(datadir)); dt_loc_get_user_config_dir(configdir, sizeof(configdir)); GtkWidget *label = dtgtk_reset_label_new(_("marker"), self, &p->filename, sizeof(p->filename)); g->watermarks = dt_bauhaus_combobox_new(self); gtk_widget_set_hexpand(GTK_WIDGET(g->watermarks), TRUE); char *tooltip = g_strdup_printf(_("SVG watermarks in %s/watermarks or %s/watermarks"), configdir, datadir); gtk_widget_set_tooltip_text(g->watermarks, tooltip); g_free(tooltip); g->refresh = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER); gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(self->widget), g->watermarks, label, GTK_POS_RIGHT, 1, 1); gtk_grid_attach_next_to(GTK_GRID(self->widget), g->refresh, g->watermarks, GTK_POS_RIGHT, 1, 1); // Watermark color float red = dt_conf_get_float("plugins/darkroom/watermark/color_red"); float green = dt_conf_get_float("plugins/darkroom/watermark/color_green"); float blue = dt_conf_get_float("plugins/darkroom/watermark/color_blue"); GdkRGBA color = (GdkRGBA){.red = red, .green = green, .blue = blue, .alpha = 1.0 }; label = dtgtk_reset_label_new(_("color"), self, &p->color, 3 * sizeof(float)); g->colorpick = gtk_color_button_new_with_rgba(&color); gtk_widget_set_tooltip_text(g->colorpick, _("watermark color, tag:\n$(WATERMARK_COLOR)")); gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE); gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24)); gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select watermark color")); gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(self->widget), g->colorpick, label, GTK_POS_RIGHT, 2, 1); // Simple text label = gtk_label_new(_("text")); gtk_widget_set_halign(label, GTK_ALIGN_START); g->text = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(g->text), 1); gtk_widget_set_tooltip_text(g->text, _("text string, tag:\n$(WATERMARK_TEXT)")); dt_gui_key_accel_block_on_focus_connect(g->text); gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(self->widget), g->text, label, GTK_POS_RIGHT, 2, 1); gchar *str = dt_conf_get_string("plugins/darkroom/watermark/text"); gtk_entry_set_text(GTK_ENTRY(g->text), str); g_free(str); // Text font label = dtgtk_reset_label_new(_("font"), self, &p->font, sizeof(p->font)); str = dt_conf_get_string("plugins/darkroom/watermark/font"); g->fontsel = gtk_font_button_new_with_font(str==NULL?"DejaVu Sans 10":str); GList *childs = gtk_container_get_children(GTK_CONTAINER(gtk_bin_get_child(GTK_BIN(g->fontsel)))); gtk_label_set_ellipsize(GTK_LABEL(childs->data), PANGO_ELLIPSIZE_MIDDLE); g_list_free(childs); gtk_widget_set_tooltip_text(g->fontsel, _("text font, tags:\n$(WATERMARK_FONT_FAMILY)\n" "$(WATERMARK_FONT_STYLE)\n$(WATERMARK_FONT_WEIGHT)")); gtk_font_button_set_show_size (GTK_FONT_BUTTON(g->fontsel), FALSE); g_free(str); gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(self->widget), g->fontsel, label, GTK_POS_RIGHT, 2, 1); gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("properties")), 0, line++, 3, 1); // Add opacity/scale sliders to table g->opacity = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 1.0, p->opacity, 0); dt_bauhaus_slider_set_format(g->opacity, "%.f%%"); dt_bauhaus_widget_set_label(g->opacity, NULL, _("opacity")); g->scale = dt_bauhaus_slider_new_with_range(self, 1.0, 100.0, 1.0, p->scale, 0); dt_bauhaus_slider_enable_soft_boundaries(g->scale, 1.0, 500.0); dt_bauhaus_slider_set_format(g->scale, "%.f%%"); dt_bauhaus_widget_set_label(g->scale, NULL, _("scale")); g->rotate = dt_bauhaus_slider_new_with_range(self, -180.0, 180.0, 1.0, p->rotate, 2); dt_bauhaus_slider_set_format(g->rotate, "%.02f°"); dt_bauhaus_widget_set_label(g->rotate, NULL, _("rotation")); gtk_grid_attach(GTK_GRID(self->widget), g->opacity, 0, line++, 3, 1); gtk_grid_attach(GTK_GRID(self->widget), g->scale, 0, line++, 3, 1); gtk_grid_attach(GTK_GRID(self->widget), g->rotate, 0, line++, 3, 1); g->sizeto = dt_bauhaus_combobox_new(self); dt_bauhaus_combobox_add(g->sizeto, C_("size", "image")); dt_bauhaus_combobox_add(g->sizeto, _("larger border")); dt_bauhaus_combobox_add(g->sizeto, _("smaller border")); dt_bauhaus_combobox_set(g->sizeto, p->sizeto); dt_bauhaus_widget_set_label(g->sizeto, NULL, _("scale on")); gtk_widget_set_tooltip_text(g->sizeto, _("size is relative to")); gtk_grid_attach(GTK_GRID(self->widget), g->sizeto, 0, line++, 3, 1); gtk_grid_attach(GTK_GRID(self->widget), dt_ui_section_label_new(_("position")), 0, line++, 3, 1); // Create the 3x3 gtk table toggle button table... label = dtgtk_reset_label_new(_("alignment"), self, &p->alignment, sizeof(p->alignment)); GtkWidget *bat = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3)); gtk_grid_set_column_spacing(GTK_GRID(bat), DT_PIXEL_APPLY_DPI(3)); for(int i = 0; i < 9; i++) { g->align[i] = dtgtk_togglebutton_new(dtgtk_cairo_paint_alignment, CPF_STYLE_FLAT | (CPF_SPECIAL_FLAG << i)); gtk_widget_set_size_request(GTK_WIDGET(g->align[i]), DT_PIXEL_APPLY_DPI(16), DT_PIXEL_APPLY_DPI(16)); gtk_grid_attach(GTK_GRID(bat), GTK_WIDGET(g->align[i]), i%3, i/3, 1, 1); g_signal_connect(G_OBJECT(g->align[i]), "toggled", G_CALLBACK(alignment_callback), self); } gtk_grid_attach(GTK_GRID(self->widget), label, 0, line++, 1, 1); gtk_grid_attach_next_to(GTK_GRID(self->widget), bat, label, GTK_POS_RIGHT, 2, 1); // x/y offset g->x_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->xoffset, 3); dt_bauhaus_slider_set_format(g->x_offset, "%.3f"); dt_bauhaus_widget_set_label(g->x_offset, NULL, _("x offset")); g->y_offset = dt_bauhaus_slider_new_with_range(self, -1.0, 1.0, 0.001, p->yoffset, 3); dt_bauhaus_slider_set_format(g->y_offset, "%.3f"); dt_bauhaus_widget_set_label(g->y_offset, NULL, _("y offset")); gtk_grid_attach(GTK_GRID(self->widget), g->x_offset, 0, line++, 3, 1); gtk_grid_attach(GTK_GRID(self->widget), g->y_offset, 0, line++, 3, 1); // Let's add some tooltips and hook up some signals... gtk_widget_set_tooltip_text(g->opacity, _("the opacity of the watermark")); gtk_widget_set_tooltip_text(g->scale, _("the scale of the watermark")); gtk_widget_set_tooltip_text(g->rotate, _("the rotation of the watermark")); g_signal_connect(G_OBJECT(g->opacity), "value-changed", G_CALLBACK(opacity_callback), self); g_signal_connect(G_OBJECT(g->scale), "value-changed", G_CALLBACK(scale_callback), self); g_signal_connect(G_OBJECT(g->rotate), "value-changed", G_CALLBACK(rotate_callback), self); g_signal_connect(G_OBJECT(g->x_offset), "value-changed", G_CALLBACK(xoffset_callback), self); g_signal_connect(G_OBJECT(g->y_offset), "value-changed", G_CALLBACK(yoffset_callback), self); g_signal_connect(G_OBJECT(g->refresh), "clicked", G_CALLBACK(refresh_callback), self); refresh_watermarks(self); g_signal_connect(G_OBJECT(g->watermarks), "value-changed", G_CALLBACK(watermark_callback), self); g_signal_connect(G_OBJECT(g->sizeto), "value-changed", G_CALLBACK(sizeto_callback), self); g_signal_connect(G_OBJECT(g->text), "changed", G_CALLBACK(text_callback), self); g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self); g_signal_connect(G_OBJECT(g->fontsel), "font-set", G_CALLBACK(fontsel_callback), self); } void gui_cleanup(struct dt_iop_module_t *self) { free(self->gui_data); self->gui_data = NULL; }
void gui_init(struct dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_borders_gui_data_t)); 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; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_BAUHAUS_SPACE); g->size = dt_bauhaus_slider_new_with_range(self, 0.0, 50.0, 0.5, p->size * 100.0, 2); dt_bauhaus_widget_set_label(g->size, NULL, _("border size")); dt_bauhaus_slider_set_format(g->size, "%.2f%%"); g_signal_connect(G_OBJECT(g->size), "value-changed", G_CALLBACK(size_callback), self); gtk_widget_set_tooltip_text(g->size, _("size of the border in percent of the full image")); gtk_box_pack_start(GTK_BOX(self->widget), g->size, TRUE, TRUE, 0); g->aspect = dt_bauhaus_combobox_new(self); dt_bauhaus_combobox_set_editable(g->aspect, 1); dt_bauhaus_widget_set_label(g->aspect, NULL, _("aspect")); gtk_box_pack_start(GTK_BOX(self->widget), g->aspect, TRUE, TRUE, 0); gui_init_aspect(self); g_signal_connect(G_OBJECT(g->aspect), "value-changed", G_CALLBACK(aspect_changed), self); gtk_widget_set_tooltip_text(g->aspect, _("select the aspect ratio or right click and type your own (w:h)")); g->aspect_orient = dt_bauhaus_combobox_new(self); dt_bauhaus_widget_set_label(g->aspect_orient, NULL, _("orientation")); dt_bauhaus_combobox_add(g->aspect_orient, _("auto")); dt_bauhaus_combobox_add(g->aspect_orient, _("portrait")); dt_bauhaus_combobox_add(g->aspect_orient, _("landscape")); gtk_widget_set_tooltip_text(g->aspect_orient, _("aspect ratio orientation of the image with border")); g_signal_connect(G_OBJECT(g->aspect_orient), "value-changed", G_CALLBACK(aspect_orient_changed), self); gtk_box_pack_start(GTK_BOX(self->widget), g->aspect_orient, TRUE, TRUE, 0); g->pos_h = dt_bauhaus_combobox_new(self); dt_bauhaus_combobox_set_editable(g->pos_h, 1); dt_bauhaus_widget_set_label(g->pos_h, NULL, _("horizontal position")); gtk_box_pack_start(GTK_BOX(self->widget), g->pos_h, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(g->pos_h), "value-changed", G_CALLBACK(position_h_changed), self); gtk_widget_set_tooltip_text(g->pos_h, _("select the horizontal position ratio relative to top " "or right click and type your own (y:h)")); g->pos_v = dt_bauhaus_combobox_new(self); dt_bauhaus_combobox_set_editable(g->pos_v, 1); dt_bauhaus_widget_set_label(g->pos_v, NULL, _("vertical position")); gtk_box_pack_start(GTK_BOX(self->widget), g->pos_v, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(g->pos_v), "value-changed", G_CALLBACK(position_v_changed), self); gtk_widget_set_tooltip_text(g->pos_v, _("select the vertical position ratio relative to left " "or right click and type your own (x:w)")); gui_init_positions(self); g->frame_size = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_size * 100.0, 2); dt_bauhaus_widget_set_label(g->frame_size, NULL, _("frame line size")); dt_bauhaus_slider_set_format(g->frame_size, "%.2f%%"); g_signal_connect(G_OBJECT(g->frame_size), "value-changed", G_CALLBACK(frame_size_callback), self); gtk_widget_set_tooltip_text(g->frame_size, _("size of the frame line in percent of min border width")); gtk_box_pack_start(GTK_BOX(self->widget), g->frame_size, TRUE, TRUE, 0); g->frame_offset = dt_bauhaus_slider_new_with_range(self, 0.0, 100.0, 0.5, p->frame_offset * 100.0, 2); dt_bauhaus_widget_set_label(g->frame_offset, NULL, _("frame line offset")); dt_bauhaus_slider_set_format(g->frame_offset, "%.2f%%"); g_signal_connect(G_OBJECT(g->frame_offset), "value-changed", G_CALLBACK(frame_offset_callback), self); gtk_widget_set_tooltip_text(g->frame_offset, _("offset of the frame line beginning on picture side")); gtk_box_pack_start(GTK_BOX(self->widget), g->frame_offset, TRUE, TRUE, 0); GdkRGBA color = (GdkRGBA){.red = p->color[0], .green = p->color[1], .blue = p->color[2], .alpha = 1.0 }; GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); g->colorpick = gtk_color_button_new_with_rgba(&color); gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE); gtk_widget_set_size_request(GTK_WIDGET(g->colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24)); gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("select border color")); GtkWidget *label = dtgtk_reset_label_new(_("border color"), self, &p->color, 3 * sizeof(float)); g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(colorpick_color_set), self); g->border_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT)); gtk_widget_set_tooltip_text(GTK_WIDGET(g->border_picker), _("pick border color from image")); gtk_widget_set_size_request(GTK_WIDGET(g->border_picker), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24)); g_signal_connect(G_OBJECT(g->border_picker), "toggled", G_CALLBACK(request_pick_toggled_border), self); gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->colorpick), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->border_picker), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0); box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); g->frame_colorpick = gtk_color_button_new_with_rgba(&color); gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->frame_colorpick), FALSE); gtk_color_button_set_title(GTK_COLOR_BUTTON(g->frame_colorpick), _("select frame line color")); gtk_widget_set_size_request(GTK_WIDGET(g->frame_colorpick), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24)); label = dtgtk_reset_label_new(_("frame line color"), self, &p->color, 3 * sizeof(float)); g_signal_connect(G_OBJECT(g->frame_colorpick), "color-set", G_CALLBACK(frame_colorpick_color_set), self); g->frame_picker = GTK_TOGGLE_BUTTON(dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT)); gtk_widget_set_tooltip_text(GTK_WIDGET(g->frame_picker), _("pick frame line color from image")); gtk_widget_set_size_request(GTK_WIDGET(g->frame_picker), DT_PIXEL_APPLY_DPI(24), DT_PIXEL_APPLY_DPI(24)); g_signal_connect(G_OBJECT(g->frame_picker), "toggled", G_CALLBACK(request_pick_toggled_frame), self); gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_colorpick), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(g->frame_picker), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), box, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(borders_draw), self); } void reload_defaults(dt_iop_module_t *self) { dt_iop_borders_params_t tmp = (dt_iop_borders_params_t){ { 1.0f, 1.0f, 1.0f }, DT_IOP_BORDERS_ASPECT_CONSTANT_VALUE, "constant border", 0, 0.1f, 0.5f, "1/2", 0.5f, "1/2", 0.0f, 0.5f, { 0.0f, 0.0f, 0.0f }, TRUE }; memcpy(self->params, &tmp, sizeof(dt_iop_borders_params_t)); memcpy(self->default_params, &tmp, sizeof(dt_iop_borders_params_t)); self->default_enabled = 0; }
// GtkBuilder generated dialog, using fixed widgets to closely match // the Windows layout, with some changes for color selector GtkWidget * XAP_UnixDialog_FontChooser::constructWindowContents(GtkWidget *) { GtkTreeSelection *selection; GtkWidget *vboxMain; GtkWidget *notebookMain; GtkWidget *labelFont; GtkWidget *labelStyle; GtkWidget *listFonts; GtkWidget *labelSize; GtkWidget *lblEffects; GtkWidget *grEffectRows; GtkWidget *checkbuttonStrikeout; GtkWidget *checkbuttonUnderline; GtkWidget *checkbuttonOverline; GtkWidget *checkbuttonHidden; GtkWidget *checkbuttonSubscript; GtkWidget *checkbuttonSuperscript; GtkWidget *listStyles; GtkWidget *listSizes; GtkWidget *hbox1; GtkWidget *colorSelector; GtkWidget *colorBGSelector; GtkWidget *labelTabFont; GtkWidget *labelTabColor; GtkWidget *labelTabBGColor; GtkWidget *frame4; // the entry is a special drawing area full of one // of our graphics contexts GtkWidget *entryArea; const XAP_StringSet * pSS = m_pApp->getStringSet(); vboxMain = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (vboxMain); notebookMain = gtk_notebook_new (); gtk_widget_show (notebookMain); gtk_box_pack_start (GTK_BOX (vboxMain), notebookMain, 1, 1, 0); gtk_container_set_border_width (GTK_CONTAINER (notebookMain), 8); GtkWidget *grid1; GtkWidget *scrolledwindow1; GtkWidget *scrolledwindow2; GtkWidget *scrolledwindow3; // GtkWidget *hboxForEncoding; grid1 = gtk_grid_new(); g_object_set(G_OBJECT(grid1), "row-spacing", 6, "column-spacing", 12, "border-width", 12, NULL); gtk_widget_show(grid1); std::string s; // Label for first page of the notebook pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_FontTab,s); labelTabFont = gtk_label_new (s.c_str()); gtk_widget_show (labelTabFont); // // Make first page of the notebook // gtk_notebook_append_page(GTK_NOTEBOOK(notebookMain), grid1, labelTabFont); pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_FontLabel,s); labelFont = gtk_label_new (s.c_str()); gtk_widget_set_halign(labelFont, GTK_ALIGN_CENTER); gtk_widget_show(labelFont); gtk_grid_attach(GTK_GRID(grid1), labelFont, 0, 0, 1, 1); scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show (scrolledwindow1); gtk_grid_attach(GTK_GRID(grid1), scrolledwindow1, 0, 1, 1, 3); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); listFonts = createFontTabTreeView(); gtk_widget_show (listFonts); gtk_container_add (GTK_CONTAINER (scrolledwindow1), listFonts); pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_StyleLabel,s); labelStyle = gtk_label_new (s.c_str()); gtk_widget_set_halign(labelStyle, GTK_ALIGN_CENTER); gtk_widget_show (labelStyle); gtk_grid_attach(GTK_GRID(grid1), labelStyle, 1, 0, 1, 1); scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow2); gtk_grid_attach(GTK_GRID(grid1), scrolledwindow2, 1, 1, 1, 1); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_NEVER, GTK_POLICY_NEVER); listStyles = createFontTabTreeView(); gtk_widget_set_name (listStyles, "listStyles"); gtk_widget_show (listStyles); gtk_container_add (GTK_CONTAINER (scrolledwindow2), listStyles); pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_SizeLabel,s); labelSize = gtk_label_new (s.c_str()); gtk_widget_set_halign(labelSize, GTK_ALIGN_CENTER); gtk_widget_show (labelSize); gtk_grid_attach(GTK_GRID(grid1), labelSize, 2, 0, 1, 1); scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow3); gtk_grid_attach(GTK_GRID(grid1), scrolledwindow3, 2, 1, 1, 1); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); listSizes = createFontTabTreeView(); gtk_widget_show (listSizes); gtk_container_add (GTK_CONTAINER (scrolledwindow3), listSizes); grEffectRows = gtk_grid_new(); g_object_set(G_OBJECT(grEffectRows), "row-spacing", 6, "column-spacing", 12, "margin-top", 12, NULL); gtk_widget_show (grEffectRows); gtk_grid_attach(GTK_GRID(grid1), grEffectRows, 1, 2, 2, 1); pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_EffectsFrameLabel,s); s = std::string("<b>") + s + "</b>"; lblEffects = gtk_label_new (s.c_str()); g_object_set(lblEffects, "use-markup", true, "xalign", 0., NULL); gtk_widget_show(lblEffects); gtk_grid_attach(GTK_GRID(grEffectRows), lblEffects, 0, 0, 4, 1); pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_StrikeoutCheck,s); checkbuttonStrikeout = gtk_check_button_new_with_label (s.c_str()); gtk_widget_set_margin_start(checkbuttonStrikeout, 18); gtk_widget_show (checkbuttonStrikeout); gtk_grid_attach(GTK_GRID(grEffectRows), checkbuttonStrikeout, 0, 1, 1, 1); pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_UnderlineCheck,s); checkbuttonUnderline = gtk_check_button_new_with_label (s.c_str()); gtk_widget_show (checkbuttonUnderline); gtk_grid_attach(GTK_GRID(grEffectRows), checkbuttonUnderline, 1, 1, 1, 1); pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_OverlineCheck,s); checkbuttonOverline = gtk_check_button_new_with_label (s.c_str()); gtk_widget_show (checkbuttonOverline); gtk_grid_attach(GTK_GRID(grEffectRows), checkbuttonOverline, 2, 1, 1, 1); pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_HiddenCheck,s); checkbuttonHidden = gtk_check_button_new_with_label (s.c_str()); gtk_widget_show (checkbuttonHidden); gtk_grid_attach(GTK_GRID(grEffectRows), checkbuttonHidden, 3, 1, 1, 1); /* subscript/superscript */ pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_SubScript,s); checkbuttonSubscript = gtk_check_button_new_with_label (s.c_str()); gtk_widget_set_margin_start(checkbuttonSubscript, 18); gtk_widget_show (checkbuttonSubscript); gtk_grid_attach(GTK_GRID(grEffectRows), checkbuttonSubscript, 0, 2, 1, 1); pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_SuperScript,s); checkbuttonSuperscript = gtk_check_button_new_with_label (s.c_str()); gtk_widget_show (checkbuttonSuperscript); gtk_grid_attach(GTK_GRID(grEffectRows), checkbuttonSuperscript, 1, 2, 1, 1); /* Notebook page for ForeGround Color Selector */ hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_widget_show (hbox1); // Label for second page of the notebook pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_ColorTab,s); labelTabColor = gtk_label_new (s.c_str()); gtk_widget_show (labelTabColor); // // Make second page of the notebook // gtk_notebook_append_page(GTK_NOTEBOOK(notebookMain), hbox1,labelTabColor); colorSelector = gtk_color_chooser_widget_new (); gtk_container_set_border_width(GTK_CONTAINER(colorSelector), 6); gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(colorSelector), FALSE); gtk_widget_show (colorSelector); gtk_box_pack_start (GTK_BOX (hbox1), colorSelector, TRUE, TRUE, 0); /*Notebook page for Background Color Selector*/ GtkWidget * vboxBG = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (vboxBG); // Label for third page of the notebook pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_BGColorTab,s); labelTabBGColor = gtk_label_new (s.c_str()); gtk_widget_show (labelTabBGColor); // // Make third page of the notebook // gtk_notebook_append_page(GTK_NOTEBOOK(notebookMain), vboxBG,labelTabBGColor); colorBGSelector = gtk_color_chooser_widget_new (); gtk_container_set_border_width(GTK_CONTAINER(colorBGSelector), 6); gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(colorBGSelector), FALSE); gtk_widget_show (colorBGSelector); gtk_box_pack_start (GTK_BOX (vboxBG), colorBGSelector, TRUE, TRUE, 0); // // Make a toggle button to set hightlight color transparent // pSS->getValueUTF8(XAP_STRING_ID_DLG_UFS_TransparencyCheck,s); GtkWidget * checkbuttonTrans = gtk_check_button_new_with_label (s.c_str()); gtk_container_set_border_width(GTK_CONTAINER(checkbuttonTrans), 6); gtk_widget_show (checkbuttonTrans); gtk_box_pack_start (GTK_BOX (vboxBG), checkbuttonTrans, TRUE, TRUE, 0); /* frame with preview */ frame4 = gtk_frame_new (NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame4), GTK_SHADOW_NONE); gtk_widget_show (frame4); gtk_box_pack_start (GTK_BOX (vboxMain), frame4, FALSE, FALSE, PREVIEW_BOX_BORDER_WIDTH_PIXELS); // setting the height takes into account the border applied on all // sides, so we need to double the single border width gtk_widget_set_size_request (frame4, -1, PREVIEW_BOX_HEIGHT_PIXELS + (PREVIEW_BOX_BORDER_WIDTH_PIXELS * 2)); gtk_container_set_border_width (GTK_CONTAINER (frame4), PREVIEW_BOX_BORDER_WIDTH_PIXELS); entryArea = gtk_drawing_area_new(); gtk_widget_set_events(entryArea, GDK_EXPOSURE_MASK); g_signal_connect(G_OBJECT(entryArea), "draw", G_CALLBACK(s_drawing_area_draw), NULL); gtk_widget_set_size_request (entryArea, -1, PREVIEW_BOX_HEIGHT_PIXELS); gtk_widget_show (entryArea); gtk_container_add (GTK_CONTAINER (frame4), entryArea); // save out to members for callback and class access m_fontList = listFonts; m_styleList = listStyles; m_sizeList = listSizes; m_colorSelector = colorSelector; m_bgcolorSelector = colorBGSelector; m_preview = entryArea; m_checkStrikeOut = checkbuttonStrikeout; m_checkUnderline = checkbuttonUnderline; m_checkOverline = checkbuttonOverline; m_checkSubScript = checkbuttonSubscript; m_checkSuperScript = checkbuttonSuperscript; m_checkHidden = checkbuttonHidden; m_checkTransparency = checkbuttonTrans; // bind signals to things g_signal_connect(G_OBJECT(m_checkUnderline), "toggled", G_CALLBACK(s_underline_toggled), static_cast<gpointer>(this)); g_signal_connect(G_OBJECT(m_checkOverline), "toggled", G_CALLBACK(s_overline_toggled), static_cast<gpointer>(this)); g_signal_connect(G_OBJECT(m_checkStrikeOut), "toggled", G_CALLBACK(s_strikeout_toggled), static_cast<gpointer>(this)); g_signal_connect(G_OBJECT(m_checkHidden), "toggled", G_CALLBACK(s_hidden_toggled), static_cast<gpointer>(this)); m_iSubScriptId = g_signal_connect(G_OBJECT(m_checkSubScript), "toggled", G_CALLBACK(s_subscript_toggled), static_cast<gpointer>(this)); m_iSuperScriptId = g_signal_connect(G_OBJECT(m_checkSuperScript), "toggled", G_CALLBACK(s_superscript_toggled), static_cast<gpointer>(this)); g_signal_connect(G_OBJECT(m_checkTransparency), "toggled", G_CALLBACK(s_transparency_toggled), static_cast<gpointer>(this)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listFonts)); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(s_select_row_font), static_cast<gpointer>(this)); selection = NULL; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listStyles)); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(s_select_row_style), static_cast<gpointer>(this)); selection = NULL; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listSizes)); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(s_select_row_size), static_cast<gpointer>(this)); selection = NULL; // This is a catch-all color selector callback which catches any // real-time updating of the color so we can refresh our preview // text g_signal_connect(G_OBJECT(colorSelector), #if GTK_CHECK_VERSION(3,4,0) "color-activated", #else "color-changed", //"event", #endif G_CALLBACK(s_color_update), static_cast<gpointer>(this)); g_signal_connect(G_OBJECT(colorBGSelector), #if GTK_CHECK_VERSION(3,4,0) "color-activated", #else "color-changed", //"event", #endif G_CALLBACK(s_bgcolor_update), static_cast<gpointer>(this)); gtk_widget_set_can_focus(listFonts, true); gtk_widget_set_can_focus(listStyles, true); gtk_widget_set_can_focus(listSizes, true); // Make the tab focus list more sensible // font -> syle -> size -> other options ... GList* focusList = NULL; focusList = g_list_append(focusList, scrolledwindow1); focusList = g_list_append(focusList, scrolledwindow2); focusList = g_list_append(focusList, scrolledwindow3); focusList = g_list_append(focusList, grEffectRows); gtk_container_set_focus_chain(GTK_CONTAINER(grid1), focusList); g_list_free(focusList); gtk_widget_grab_focus(scrolledwindow1); const gchar * text; GtkTreeModel* model; GtkTreeIter iter; // update the styles list model = gtk_tree_view_get_model(GTK_TREE_VIEW(m_styleList)); gtk_list_store_clear(GTK_LIST_STORE(model)); text = pSS->getValue(XAP_STRING_ID_DLG_UFS_StyleRegular); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set(GTK_LIST_STORE(model), &iter, TEXT_COLUMN, text, -1); text = pSS->getValue(XAP_STRING_ID_DLG_UFS_StyleItalic); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set(GTK_LIST_STORE(model), &iter, TEXT_COLUMN, text, -1); text = pSS->getValue(XAP_STRING_ID_DLG_UFS_StyleBold); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set(GTK_LIST_STORE(model), &iter, TEXT_COLUMN, text, -1); text = pSS->getValue(XAP_STRING_ID_DLG_UFS_StyleBoldItalic); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set(GTK_LIST_STORE(model), &iter, TEXT_COLUMN, text, -1); model = gtk_tree_view_get_model(GTK_TREE_VIEW(m_sizeList)); gtk_list_store_clear(GTK_LIST_STORE(model)); // TODO perhaps populate the list based on the selected font/style? { int sz = XAP_EncodingManager::fontsizes_mapping.size(); for (int i = 0; i < sz; ++i) { text = XAP_EncodingManager::fontsizes_mapping.nth2(i); gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set(GTK_LIST_STORE(model), &iter, TEXT_COLUMN, text, -1); } } return vboxMain; }
/* Plugin configuration function */ static GObject* plugin_configure(XfdashboardPlugin *self, gpointer inUserData) { GtkWidget *layout; GtkWidget *widgetLabel; GtkWidget *widgetValue; XfdashboardClockViewSettings *settings; /* Get settings of plugin */ settings=xfdashboard_clock_view_settings_new(); /* Create layout widget */ layout=gtk_grid_new(); gtk_grid_set_column_spacing(GTK_GRID(layout), 8); /* Add widget to choose hour color */ widgetLabel=gtk_label_new(_("Hour color:")); gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END); gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 0, 1, 1); widgetValue=gtk_color_button_new(); #if GTK_CHECK_VERSION(3, 4, 0) gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE); #else gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE); #endif gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for hour hand")); _plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "hour-color"); gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1); /* Add widget to choose minute color */ widgetLabel=gtk_label_new(_("Minute color:")); gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END); gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 1, 1, 1); widgetValue=gtk_color_button_new(); #if GTK_CHECK_VERSION(3, 4, 0) gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE); #else gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE); #endif gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for minute hand")); _plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "minute-color"); gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1); /* Add widget to choose second color */ widgetLabel=gtk_label_new(_("Second color:")); gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END); gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 2, 1, 1); widgetValue=gtk_color_button_new(); #if GTK_CHECK_VERSION(3, 4, 0) gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE); #else gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE); #endif gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for second hand")); _plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "second-color"); gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1); /* Add widget to choose minute color */ widgetLabel=gtk_label_new(_("Background color:")); gtk_widget_set_halign(widgetLabel, GTK_ALIGN_END); gtk_grid_attach(GTK_GRID(layout), widgetLabel, 0, 3, 1, 1); widgetValue=gtk_color_button_new(); #if GTK_CHECK_VERSION(3, 4, 0) gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(widgetValue), TRUE); #else gtk_color_button_set_use_alpha(GTK_COLOR_BUTTON(widgetValue), TRUE); #endif gtk_color_button_set_title(GTK_COLOR_BUTTON(widgetValue), _("Choose color for background of second hand")); _plugin_configure_setup_color_button(GTK_COLOR_BUTTON(widgetValue), settings, "background-color"); gtk_grid_attach_next_to(GTK_GRID(layout), widgetValue, widgetLabel, GTK_POS_RIGHT, 1, 1); /* Release allocated resources */ if(settings) g_object_unref(settings); /* Make all widgets visible */ gtk_widget_show_all(layout); /* Return layout widget containing all other widgets */ return(G_OBJECT(layout)); }
static GtkWidget * property_editor (GObject *object, GParamSpec *spec, GtkInspectorPropEditor *editor) { GtkWidget *prop_edit; GtkAdjustment *adj; gchar *msg; GType type = G_PARAM_SPEC_TYPE (spec); if (type == G_TYPE_PARAM_INT) { adj = gtk_adjustment_new (G_PARAM_SPEC_INT (spec)->default_value, G_PARAM_SPEC_INT (spec)->minimum, G_PARAM_SPEC_INT (spec)->maximum, 1, MAX ((G_PARAM_SPEC_INT (spec)->maximum - G_PARAM_SPEC_INT (spec)->minimum) / 10, 1), 0.0); prop_edit = gtk_spin_button_new (adj, 1.0, 0); g_object_connect_property (object, spec, G_CALLBACK (int_changed), adj, G_OBJECT (adj)); connect_controller (G_OBJECT (adj), "value_changed", object, spec, G_CALLBACK (int_modified)); } else if (type == G_TYPE_PARAM_UINT) { adj = gtk_adjustment_new (G_PARAM_SPEC_UINT (spec)->default_value, G_PARAM_SPEC_UINT (spec)->minimum, G_PARAM_SPEC_UINT (spec)->maximum, 1, MAX ((G_PARAM_SPEC_UINT (spec)->maximum - G_PARAM_SPEC_UINT (spec)->minimum) / 10, 1), 0.0); prop_edit = gtk_spin_button_new (adj, 1.0, 0); g_object_connect_property (object, spec, G_CALLBACK (uint_changed), adj, G_OBJECT (adj)); connect_controller (G_OBJECT (adj), "value_changed", object, spec, G_CALLBACK (uint_modified)); } else if (type == G_TYPE_PARAM_FLOAT) { adj = gtk_adjustment_new (G_PARAM_SPEC_FLOAT (spec)->default_value, G_PARAM_SPEC_FLOAT (spec)->minimum, G_PARAM_SPEC_FLOAT (spec)->maximum, 0.1, MAX ((G_PARAM_SPEC_FLOAT (spec)->maximum - G_PARAM_SPEC_FLOAT (spec)->minimum) / 10, 0.1), 0.0); prop_edit = gtk_spin_button_new (adj, 0.1, 2); g_object_connect_property (object, spec, G_CALLBACK (float_changed), adj, G_OBJECT (adj)); connect_controller (G_OBJECT (adj), "value_changed", object, spec, G_CALLBACK (float_modified)); } else if (type == G_TYPE_PARAM_DOUBLE) { adj = gtk_adjustment_new (G_PARAM_SPEC_DOUBLE (spec)->default_value, G_PARAM_SPEC_DOUBLE (spec)->minimum, G_PARAM_SPEC_DOUBLE (spec)->maximum, 0.1, MAX ((G_PARAM_SPEC_DOUBLE (spec)->maximum - G_PARAM_SPEC_DOUBLE (spec)->minimum) / 10, 0.1), 0.0); prop_edit = gtk_spin_button_new (adj, 0.1, 2); g_object_connect_property (object, spec, G_CALLBACK (double_changed), adj, G_OBJECT (adj)); connect_controller (G_OBJECT (adj), "value_changed", object, spec, G_CALLBACK (double_modified)); } else if (type == G_TYPE_PARAM_STRING) { prop_edit = gtk_entry_new (); g_object_connect_property (object, spec, G_CALLBACK (string_changed), prop_edit, G_OBJECT (prop_edit)); connect_controller (G_OBJECT (prop_edit), "changed", object, spec, G_CALLBACK (string_modified)); } else if (type == G_TYPE_PARAM_BOOLEAN) { prop_edit = gtk_toggle_button_new_with_label (""); g_object_connect_property (object, spec, G_CALLBACK (bool_changed), prop_edit, G_OBJECT (prop_edit)); connect_controller (G_OBJECT (prop_edit), "toggled", object, spec, G_CALLBACK (bool_modified)); } else if (type == G_TYPE_PARAM_ENUM) { { GtkWidget *box; GEnumClass *eclass; GtkWidget *first; gint j; prop_edit = gtk_scrolled_window_new (NULL, NULL); g_object_set (prop_edit, "expand", TRUE, "hscrollbar-policy", GTK_POLICY_NEVER, "vscrollbar-policy", GTK_POLICY_NEVER, NULL); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (box); gtk_container_add (GTK_CONTAINER (prop_edit), box); eclass = G_ENUM_CLASS (g_type_class_ref (spec->value_type)); j = 0; first = NULL; while (j < eclass->n_values) { GtkWidget *b; b = gtk_radio_button_new_with_label_from_widget ((GtkRadioButton*)first, eclass->values[j].value_name); if (first == NULL) first = b; g_object_set_data (G_OBJECT (b), "index", GINT_TO_POINTER (j)); gtk_widget_show (b); gtk_box_pack_start (GTK_BOX (box), b, FALSE, FALSE, 0); connect_controller (G_OBJECT (b), "toggled", object, spec, G_CALLBACK (enum_modified)); ++j; } if (j >= 10) g_object_set (prop_edit, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL); g_type_class_unref (eclass); g_object_connect_property (object, spec, G_CALLBACK (enum_changed), prop_edit, G_OBJECT (prop_edit)); } } else if (type == G_TYPE_PARAM_FLAGS) { { GtkWidget *box; GFlagsClass *fclass; gint j; prop_edit = gtk_scrolled_window_new (NULL, NULL); g_object_set (prop_edit, "expand", TRUE, "hscrollbar-policy", GTK_POLICY_NEVER, "vscrollbar-policy", GTK_POLICY_NEVER, NULL); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (box); gtk_container_add (GTK_CONTAINER (prop_edit), box); fclass = G_FLAGS_CLASS (g_type_class_ref (spec->value_type)); for (j = 0; j < fclass->n_values; j++) { GtkWidget *b; b = gtk_check_button_new_with_label (fclass->values[j].value_name); g_object_set_data (G_OBJECT (b), "index", GINT_TO_POINTER (j)); gtk_widget_show (b); gtk_box_pack_start (GTK_BOX (box), b, FALSE, FALSE, 0); connect_controller (G_OBJECT (b), "toggled", object, spec, G_CALLBACK (flags_modified)); } if (j >= 10) g_object_set (prop_edit, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL); g_type_class_unref (fclass); g_object_connect_property (object, spec, G_CALLBACK (flags_changed), prop_edit, G_OBJECT (prop_edit)); } } else if (type == G_TYPE_PARAM_UNICHAR) { prop_edit = gtk_entry_new (); gtk_entry_set_max_length (GTK_ENTRY (prop_edit), 1); g_object_connect_property (object, spec, G_CALLBACK (unichar_changed), prop_edit, G_OBJECT (prop_edit)); connect_controller (G_OBJECT (prop_edit), "changed", object, spec, G_CALLBACK (unichar_modified)); } else if (type == G_TYPE_PARAM_POINTER) { prop_edit = gtk_label_new (""); g_object_connect_property (object, spec, G_CALLBACK (pointer_changed), prop_edit, G_OBJECT (prop_edit)); } else if (type == G_TYPE_PARAM_OBJECT) { GtkWidget *label, *button; prop_edit = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); label = gtk_label_new (""); button = gtk_button_new_with_label (_("Properties")); g_signal_connect_swapped (button, "clicked", G_CALLBACK (object_properties), editor); gtk_container_add (GTK_CONTAINER (prop_edit), label); gtk_container_add (GTK_CONTAINER (prop_edit), button); gtk_widget_show (label); gtk_widget_show (button); g_object_connect_property (object, spec, G_CALLBACK (object_changed), prop_edit, G_OBJECT (label)); } else if (type == G_TYPE_PARAM_BOXED && G_PARAM_SPEC_VALUE_TYPE (spec) == GDK_TYPE_RGBA) { prop_edit = gtk_color_chooser_widget_new (); gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (prop_edit), TRUE); g_object_connect_property (object, spec, G_CALLBACK (rgba_changed), prop_edit, G_OBJECT (prop_edit)); connect_controller (G_OBJECT (prop_edit), "notify::rgba", object, spec, G_CALLBACK (rgba_modified)); } else if (type == G_TYPE_PARAM_BOXED && G_PARAM_SPEC_VALUE_TYPE (spec) == g_type_from_name ("GdkColor")) { prop_edit = gtk_color_chooser_widget_new (); gtk_color_chooser_set_use_alpha (GTK_COLOR_CHOOSER (prop_edit), FALSE); g_object_connect_property (object, spec, G_CALLBACK (color_changed), prop_edit, G_OBJECT (prop_edit)); connect_controller (G_OBJECT (prop_edit), "notify::rgba", object, spec, G_CALLBACK (color_modified)); } else if (type == G_TYPE_PARAM_BOXED && G_PARAM_SPEC_VALUE_TYPE (spec) == PANGO_TYPE_FONT_DESCRIPTION) { prop_edit = gtk_font_chooser_widget_new (); g_object_connect_property (object, spec, G_CALLBACK (font_changed), prop_edit, G_OBJECT (prop_edit)); connect_controller (G_OBJECT (prop_edit), "notify::font-desc", object, spec, G_CALLBACK (font_modified)); } else { msg = g_strdup_printf (_("Uneditable property type: %s"), g_type_name (G_PARAM_SPEC_TYPE (spec))); prop_edit = gtk_label_new (msg); g_free (msg); gtk_widget_set_halign (prop_edit, GTK_ALIGN_START); gtk_widget_set_valign (prop_edit, GTK_ALIGN_CENTER); } if (g_param_spec_get_blurb (spec)) gtk_widget_set_tooltip_text (prop_edit, g_param_spec_get_blurb (spec)); notify_property (object, spec); return prop_edit; }
NS_IMETHODIMP nsColorPicker::Open(nsIColorPickerShownCallback *aColorPickerShownCallback) { // Input color string should be 7 length (i.e. a string representing a valid // simple color) if (mInitialColor.Length() != 7) { return NS_ERROR_FAILURE; } const nsAString& withoutHash = StringTail(mInitialColor, 6); nscolor color; if (!NS_HexToRGBA(withoutHash, nsHexColorType::NoAlpha, &color)) { return NS_ERROR_FAILURE; } if (mCallback) { // It means Open has already been called: this is not allowed NS_WARNING("mCallback is already set. Open called twice?"); return NS_ERROR_FAILURE; } mCallback = aColorPickerShownCallback; nsXPIDLCString title; title.Adopt(ToNewUTF8String(mTitle)); GtkWindow *parent_window = GTK_WINDOW(mParentWidget->GetNativeData(NS_NATIVE_SHELLWIDGET)); #if defined(ACTIVATE_GTK3_COLOR_PICKER) && GTK_CHECK_VERSION(3,4,0) GtkWidget* color_chooser = gtk_color_chooser_dialog_new(title, parent_window); if (parent_window) { gtk_window_set_destroy_with_parent(GTK_WINDOW(color_chooser), TRUE); } gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(color_chooser), FALSE); GdkRGBA color_rgba = convertToRgbaColor(color); gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(color_chooser), &color_rgba); g_signal_connect(GTK_COLOR_CHOOSER(color_chooser), "color-activated", G_CALLBACK(OnColorChanged), this); #else GtkWidget *color_chooser = gtk_color_selection_dialog_new(title); if (parent_window) { GtkWindow *window = GTK_WINDOW(color_chooser); gtk_window_set_transient_for(window, parent_window); gtk_window_set_destroy_with_parent(window, TRUE); } GdkColor color_gdk = convertToGdkColor(color); gtk_color_selection_set_current_color(WidgetGetColorSelection(color_chooser), &color_gdk); g_signal_connect(WidgetGetColorSelection(color_chooser), "color-changed", G_CALLBACK(OnColorChanged), this); #endif NS_ADDREF_THIS(); g_signal_connect(color_chooser, "response", G_CALLBACK(OnResponse), this); g_signal_connect(color_chooser, "destroy", G_CALLBACK(OnDestroy), this); gtk_widget_show(color_chooser); return NS_OK; }