void
configure(void)
{
ENTER;
DBG("dialog %p\n", dialog);
if (!dialog)
dialog = mk_dialog();
gtk_widget_show(dialog);
update_opt_menu(edge_opt, p->edge - 1);
update_opt_menu(allign_opt, p->allign - 1);
//gtk_adjustment_set_value(margin_adj, p->margin);
//gtk_adjustment_value_changed(margin_adj);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(margin_spinb), p->margin);
update_opt_menu(width_opt, p->widthtype - 1);
gtk_adjustment_set_value(width_adj, p->width);
update_opt_menu(height_opt, HEIGHT_PIXEL - 1);
gtk_adjustment_set_value(height_adj, p->height);
update_toggle_button(tr_checkb, p->transparent);
gtk_color_button_set_color(GTK_COLOR_BUTTON(tr_colorb), &p->gtintcolor);
gtk_color_button_set_alpha (GTK_COLOR_BUTTON(tr_colorb), 256*p->alpha);
gtk_widget_show(dialog);
update_toggle_button(prop_dt_checkb, p->setdocktype);
update_toggle_button(prop_st_checkb, p->setstrut);
RET();
}
static void
change_color_check (GtkToggleButton *button, XpadPreferences *pref)
{
g_signal_handler_block (xpad_settings (), pref->priv->notify_back_handler);
g_signal_handler_block (xpad_settings (), pref->priv->notify_text_handler);
if (!gtk_toggle_button_get_active (button))
{
xpad_settings_set_text_color (xpad_settings (), NULL);
xpad_settings_set_back_color (xpad_settings (), NULL);
}
else
{
GdkColor color;
gtk_color_button_get_color (GTK_COLOR_BUTTON (pref->priv->textbutton), &color);
xpad_settings_set_text_color (xpad_settings (), &color);
gtk_color_button_get_color (GTK_COLOR_BUTTON (pref->priv->backbutton), &color);
xpad_settings_set_back_color (xpad_settings (), &color);
}
gtk_widget_set_sensitive (pref->priv->colorbox, gtk_toggle_button_get_active (button));
g_signal_handler_unblock (xpad_settings (), pref->priv->notify_back_handler);
g_signal_handler_unblock (xpad_settings (), pref->priv->notify_text_handler);
}
void
global_config_save(FILE *fp)
{
GdkColor c;
fprintf(fp, "# fbpanel <profile> config file\n");
fprintf(fp, "# see http://fbpanel.sf.net/docs.html for complete configuration guide\n");
fprintf(fp, "\n\n");
fprintf(fp, "Global {\n");
fprintf(fp, " edge = %s\n",
num2str(edge_pair, gtk_combo_box_get_active(GTK_COMBO_BOX(edge_opt)) + 1, "none"));
fprintf(fp, " allign = %s\n",
num2str(allign_pair, gtk_combo_box_get_active(GTK_COMBO_BOX(allign_opt)) + 1, "none"));
fprintf(fp, " margin = %d\n", (int) margin_adj->value);
fprintf(fp, " widthtype = %s\n",
num2str(width_pair, gtk_combo_box_get_active(GTK_COMBO_BOX(width_opt)) + 1, "none"));
fprintf(fp, " width = %d\n", (int) width_adj->value);
fprintf(fp, " height = %d\n", (int) height_adj->value);
fprintf(fp, " transparent = %s\n",
num2str(bool_pair, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tr_checkb)), "false"));
gtk_color_button_get_color(GTK_COLOR_BUTTON(tr_colorb), &c);
fprintf(fp, " tintcolor = #%06x\n", gcolor2rgb24(&c));
fprintf(fp, " alpha = %d\n", gtk_color_button_get_alpha(GTK_COLOR_BUTTON(tr_colorb)) * 0xff / 0xffff);
fprintf(fp, " setdocktype = %s\n",
num2str(bool_pair, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(prop_dt_checkb)), "true"));
fprintf(fp, " setpartialstrut = %s\n",
num2str(bool_pair, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(prop_st_checkb)), "true"));
fprintf(fp, "}\n\n");
}
PRIVATE void propgen(Component *c, Generator *g) {
Data *data = g->data;
GtkWidget *dialog, *vbox2, *color1; //, *color2; //*type;
dialog = gtk_dialog_new_with_buttons( "GL Cube Properties", gui_get_mesh_window(), GTK_DIALOG_DESTROY_WITH_PARENT,
"Oki", GTK_RESPONSE_OK, "Not Now", GTK_RESPONSE_CANCEL, NULL );
vbox2 = gtk_vbox_new( FALSE, 10 );
color1 = g_object_new( GTK_TYPE_COLOR_BUTTON, "color", &(data->cube_color), "title", "cube_color", "use-alpha", TRUE, "alpha", data->cube_alpha, NULL );
gtk_container_add( GTK_CONTAINER( vbox2 ), color1 );
gtk_container_add( GTK_CONTAINER( GTK_DIALOG( dialog )->vbox ), vbox2 );
gtk_widget_show_all( dialog );
gint response = gtk_dialog_run( GTK_DIALOG(dialog) );
if( response != GTK_RESPONSE_CANCEL ) {
gtk_color_button_get_color( GTK_COLOR_BUTTON(color1), &(data->cube_color) );
data->cube_alpha = gtk_color_button_get_alpha( GTK_COLOR_BUTTON(color1) );
}
gtk_widget_destroy( dialog );
}
EXPORT gboolean init_text_attributes(GladeXML *xml)
{
extern GdkColor white;
extern GdkColor black;
GtkWidget *notebook = NULL;
GtkWidget *child = NULL;
notebook = glade_xml_get_widget(xml,"value_notebook");
child = glade_xml_get_widget(xml,"value_text_table");
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),child,TRUE,TRUE,GTK_PACK_START);
child = glade_xml_get_widget(xml,"value_font_table");
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),child,TRUE,TRUE,GTK_PACK_START);
child = glade_xml_get_widget(xml,"value_location_table");
gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(notebook),child,TRUE,TRUE,GTK_PACK_START);
OBJ_SET((glade_xml_get_widget(xml,"precision_spin")),"handler",GINT_TO_POINTER(PRECISION));
OBJ_SET((glade_xml_get_widget(xml,"value_xpos_spin")),"handler",GINT_TO_POINTER(VALUE_XPOS));
OBJ_SET((glade_xml_get_widget(xml,"value_ypos_spin")),"handler",GINT_TO_POINTER(VALUE_YPOS));
OBJ_SET((glade_xml_get_widget(xml,"value_grab_button")),"x_spin",glade_xml_get_widget(xml,"value_xpos_spin"));
OBJ_SET((glade_xml_get_widget(xml,"value_grab_button")),"y_spin",glade_xml_get_widget(xml,"value_ypos_spin"));
OBJ_SET((glade_xml_get_widget(xml,"value_font_scale_spin")),"handler",GINT_TO_POINTER(VALUE_FONTSCALE));
OBJ_SET((glade_xml_get_widget(xml,"value_color_day_button")),"handler",GINT_TO_POINTER(GAUGE_COL_VALUE_FONT_DAY));
OBJ_SET((glade_xml_get_widget(xml,"value_color_nite_button")),"handler",GINT_TO_POINTER(GAUGE_COL_VALUE_FONT_NITE));
OBJ_SET((glade_xml_get_widget(xml,"show_value_check")),"handler",GINT_TO_POINTER(SHOW_VALUE));
gtk_color_button_set_color(GTK_COLOR_BUTTON(glade_xml_get_widget(xml,"value_color_day_button")),&white);
gtk_color_button_set_color(GTK_COLOR_BUTTON(glade_xml_get_widget(xml,"value_color_nite_button")),&black);
update_text_controls();
update_onscreen_tblocks();
return TRUE;
}
gboolean abrir_preferencias(respuesta_t * respuesta) {
dialogo_preferencias_filtro_t * dialogo = dialogo_preferencias_filtro_crear();
if(!dialogo) {
return FALSE;
}
if(respuesta) {
gtk_color_button_set_color (GTK_COLOR_BUTTON(dialogo->bot_color_ordenes), &respuesta->orden.color);
gtk_color_button_set_color (GTK_COLOR_BUTTON(dialogo->bot_color_argumentos), &respuesta->argumento.color);
gtk_range_set_value(GTK_RANGE(dialogo->sld_tolerancia_ordenes), respuesta->orden.tolerancia);
gtk_range_set_value(GTK_RANGE(dialogo->sld_tolerancia_argumentos), respuesta->argumento.tolerancia);
}
gboolean devolver;
if (gtk_dialog_run(GTK_DIALOG(dialogo->dlg_preferencias_filtro)) == GTK_RESPONSE_OK) {
gtk_color_button_get_color(GTK_COLOR_BUTTON(dialogo->bot_color_ordenes), &respuesta->orden.color);
gtk_color_button_get_color(GTK_COLOR_BUTTON(dialogo->bot_color_argumentos), &respuesta->argumento.color);
respuesta->orden.tolerancia = gtk_range_get_value(GTK_RANGE(dialogo->sld_tolerancia_ordenes));
respuesta->argumento.tolerancia = gtk_range_get_value(GTK_RANGE(dialogo->sld_tolerancia_argumentos));
devolver = TRUE;
}
else {
devolver = FALSE;
}
dialogo_preferencias_filtro_cerrar(dialogo);
return devolver;
}
static void
wp_color_changed (AppearanceData *data,
gboolean update)
{
MateWPItem *item;
item = get_selected_item (data, NULL);
if (item == NULL)
return;
gtk_color_button_get_color (GTK_COLOR_BUTTON (data->wp_pcpicker), item->pcolor);
gtk_color_button_get_color (GTK_COLOR_BUTTON (data->wp_scpicker), item->scolor);
if (update)
{
gchar *pcolor, *scolor;
pcolor = gdk_color_to_string (item->pcolor);
scolor = gdk_color_to_string (item->scolor);
g_settings_set_string (data->wp_settings, WP_PCOLOR_KEY, pcolor);
g_settings_set_string (data->wp_settings, WP_SCOLOR_KEY, scolor);
g_free (pcolor);
g_free (scolor);
}
wp_shade_type_changed (NULL, data);
}
static void
wp_props_wp_selected (GtkTreeSelection *selection,
AppearanceData *data)
{
MateWPItem *item;
item = get_selected_item (data, NULL);
if (item != NULL)
{
wp_set_sensitivities (data);
if (strcmp (item->filename, "(none)") != 0)
wp_option_menu_set (data, item->options, FALSE);
wp_option_menu_set (data, item->shade_type, TRUE);
gtk_color_button_set_color (GTK_COLOR_BUTTON (data->wp_pcpicker),
item->pcolor);
gtk_color_button_set_color (GTK_COLOR_BUTTON (data->wp_scpicker),
item->scolor);
if (data->wp_update_settings)
wp_props_wp_set (data, item);
}
else
{
gtk_widget_set_sensitive (data->wp_rem_button, FALSE);
}
}
static void
UpdateColourPreview(void)
{
TextureInfo *tempTexture;
double ambient[4], diffuse[4], specular[4];
if (!bUpdate)
return;
if (useOpacity)
opacityValue = (float) gtk_adjustment_get_value(padjOpacity) / 100.0f;
gtk_color_button_get_array(GTK_COLOR_BUTTON(pcpAmbient), ambient);
gtk_color_button_get_array(GTK_COLOR_BUTTON(pcpDiffuse), diffuse);
gtk_color_button_get_array(GTK_COLOR_BUTTON(pcpSpecular), specular);
tempTexture = col3d.textureInfo; /* Remeber texture, as setupmat resets it */
SetupMat(&col3d, (float) ambient[0], (float) ambient[1], (float) ambient[2],
(float) diffuse[0], (float) diffuse[1], (float) diffuse[2],
(float) specular[0], (float) specular[1], (float) specular[2],
(int) gtk_adjustment_get_value(padjShine), opacityValue);
col3d.textureInfo = tempTexture;
gtk_widget_queue_draw(pwPreview);
}
static void
profile_palette_notify_colorpickers_cb (TerminalProfile *profile,
GParamSpec *pspec,
GtkWidget *editor)
{
GtkWidget *w;
GdkColor colors[TERMINAL_PALETTE_SIZE];
guint n_colors, i;
n_colors = G_N_ELEMENTS (colors);
terminal_profile_get_palette (profile, colors, &n_colors);
n_colors = MIN (n_colors, TERMINAL_PALETTE_SIZE);
for (i = 0; i < n_colors; i++)
{
char name[32];
GdkColor old_color;
g_snprintf (name, sizeof (name), "palette-colorpicker-%d", i + 1);
w = profile_editor_get_widget (editor, name);
gtk_color_button_get_color (GTK_COLOR_BUTTON (w), &old_color);
if (!gdk_color_equal (&old_color, &colors[i]))
{
g_signal_handlers_block_by_func (w, G_CALLBACK (palette_color_notify_cb), profile);
gtk_color_button_set_color (GTK_COLOR_BUTTON (w), &colors[i]);
g_signal_handlers_unblock_by_func (w, G_CALLBACK (palette_color_notify_cb), profile);
}
}
}
/* Preferences Callback : Change color. */
void
preferences_color_cb (GtkWidget *button, gpointer data)
{
GdkColor color, font_color;
char *color_str, *font_color_str;
gtk_color_button_get_color (
GTK_COLOR_BUTTON (stickynotes->w_prefs_color), &color);
gtk_color_button_get_color (
GTK_COLOR_BUTTON (stickynotes->w_prefs_font_color),
&font_color);
color_str = g_strdup_printf ("#%.2x%.2x%.2x",
color.red / 256,
color.green / 256,
color.blue / 256);
font_color_str = g_strdup_printf ("#%.2x%.2x%.2x",
font_color.red / 256,
font_color.green / 256,
font_color.blue / 256);
g_settings_set_string (stickynotes->settings, "default-color", color_str);
g_settings_set_string (stickynotes->settings, "default-font-color", font_color_str);
g_free (color_str);
g_free (font_color_str);
}
void colour_changed(GtkWidget *w, gpointer data)
{
rgba_t *col = (rgba_t*)data;
GdkColor gdk_col;
gtk_color_button_get_color(GTK_COLOR_BUTTON(w), &gdk_col);
int alpha = (gtk_color_button_get_alpha(GTK_COLOR_BUTTON(w)) / 255);
if (alpha > 255)
alpha = 255;
int red = (gdk_col.red / 255);
if (red > 255)
red = 255;
int green = (gdk_col.green / 255);
if (green > 255)
green = 255;
int blue = (gdk_col.blue / 255);
if (blue > 255)
blue = 255;
//col->set((BYTE)red, (BYTE)green, (BYTE)blue, (BYTE)alpha);
col->r = (BYTE)red;
col->g = (BYTE)green;
col->b = (BYTE)blue;
col->a = (BYTE)alpha;
force_map_redraw(true, true);
}
/* Properties Dialog Callback : Color */
void
properties_color_cb (GtkWidget *button, StickyNote *note)
{
char *color_str = NULL;
char *font_color_str = NULL;
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(note->w_def_color)))
{
GdkColor color;
GdkColor font_color;
gtk_color_button_get_color (
GTK_COLOR_BUTTON (note->w_color),
&color);
gtk_color_button_get_color (
GTK_COLOR_BUTTON (note->w_font_color),
&font_color);
color_str = g_strdup_printf ("#%.2x%.2x%.2x",
color.red / 256,
color.green / 256,
color.blue / 256);
font_color_str = g_strdup_printf ("#%.2x%.2x%.2x",
font_color.red / 256,
font_color.green / 256,
font_color.blue / 256);
}
stickynote_set_color (note, color_str, font_color_str, TRUE);
g_free (color_str);
g_free (font_color_str);
}
EXPORT gboolean create_text_block_event(GtkWidget * widget, gpointer data)
{
GtkWidget *dialog = NULL;
MtxTextBlock *tblock = NULL;
GladeXML *xml = NULL;
gchar * filename = NULL;
gint result = 0;
if (!GTK_IS_WIDGET(gauge))
return FALSE;
filename = get_file(g_build_filename(GAUGEDESIGNER_GLADE_DIR,"gaugedesigner.glade",NULL),NULL);
if (filename)
{
xml = glade_xml_new(filename, "tblock_dialog", NULL);
g_free(filename);
}
else
{
printf("Can't locate primary glade file!!!!\n");
exit(-1);
}
glade_xml_signal_autoconnect(xml);
dialog = glade_xml_get_widget(xml,"tblock_dialog");
gtk_color_button_set_color(GTK_COLOR_BUTTON(glade_xml_get_widget(xml,"tblock_day_colorbutton")),&white);
gtk_color_button_set_color(GTK_COLOR_BUTTON(glade_xml_get_widget(xml,"tblock_nite_colorbutton")),&black);
if (!GTK_IS_WIDGET(dialog))
{
return FALSE;
}
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result)
{
case GTK_RESPONSE_APPLY:
tblock = g_new0(MtxTextBlock, 1);
tblock->font_scale = gtk_spin_button_get_value(GTK_SPIN_BUTTON(glade_xml_get_widget(xml,"tblock_font_scale_spin")));
tblock->x_pos = gtk_spin_button_get_value(GTK_SPIN_BUTTON(glade_xml_get_widget(xml,"tblock_xpos_spin")));
tblock->y_pos = gtk_spin_button_get_value(GTK_SPIN_BUTTON(glade_xml_get_widget(xml,"tblock_ypos_spin")));
tblock->text = gtk_editable_get_chars(GTK_EDITABLE(glade_xml_get_widget(xml,"tblock_text_entry")),0,-1);
gtk_color_button_get_color(GTK_COLOR_BUTTON(glade_xml_get_widget(xml,"tblock_day_colorbutton")),&tblock->color[MTX_DAY]);
gtk_color_button_get_color(GTK_COLOR_BUTTON(glade_xml_get_widget(xml,"tblock_nite_colorbutton")),&tblock->color[MTX_NITE]);
tblock->font = (gchar *)gtk_font_button_get_font_name (GTK_FONT_BUTTON(glade_xml_get_widget(xml,"tblock_fontbutton")));
tblock->font = g_strchomp(g_strdelimit(tblock->font,"0123456789",' '));
changed = TRUE;
mtx_gauge_face_set_text_block_struct(MTX_GAUGE_FACE(gauge),tblock);
g_free(tblock->text);
g_free(tblock);
update_onscreen_tblocks();
break;
default:
break;
}
if (GTK_IS_WIDGET(dialog))
gtk_widget_destroy(dialog);
return (FALSE);
}
/* Preferences Callback : Change color. */
void
preferences_color_cb (GtkWidget *button, gpointer data)
{
GdkColor color, font_color;
char *color_str, *font_color_str;
gtk_color_button_get_color (
GTK_COLOR_BUTTON (stickynotes->w_prefs_color), &color);
gtk_color_button_get_color (
GTK_COLOR_BUTTON (stickynotes->w_prefs_font_color),
&font_color);
color_str = g_strdup_printf ("#%.2x%.2x%.2x",
color.red / 256,
color.green / 256,
color.blue / 256);
font_color_str = g_strdup_printf ("#%.2x%.2x%.2x",
font_color.red / 256,
font_color.green / 256,
font_color.blue / 256);
gconf_client_set_string (stickynotes->gconf,
GCONF_PATH "/defaults/color", color_str, NULL);
gconf_client_set_string (stickynotes->gconf,
GCONF_PATH "/defaults/font_color", font_color_str,
NULL);
g_free (color_str);
g_free (font_color_str);
}
static void
swap_colors_clicked (GtkButton *button,
CcBackgroundPanel *panel)
{
CcBackgroundPanelPrivate *priv = panel->priv;
GdkColor pcolor, scolor;
char *new_pcolor, *new_scolor;
gtk_color_button_get_color (GTK_COLOR_BUTTON (WID ("style-pcolor")), &pcolor);
gtk_color_button_get_color (GTK_COLOR_BUTTON (WID ("style-scolor")), &scolor);
gtk_color_button_set_color (GTK_COLOR_BUTTON (WID ("style-scolor")), &pcolor);
gtk_color_button_set_color (GTK_COLOR_BUTTON (WID ("style-pcolor")), &scolor);
new_pcolor = gdk_color_to_string (&scolor);
new_scolor = gdk_color_to_string (&pcolor);
g_object_set (priv->current_background,
"primary-color", new_pcolor,
"secondary-color", new_scolor,
NULL);
g_settings_set_string (priv->settings, WP_PCOLOR_KEY, new_pcolor);
g_settings_set_string (priv->settings, WP_SCOLOR_KEY, new_scolor);
g_free (new_pcolor);
g_free (new_scolor);
g_settings_apply (priv->settings);
update_preview (priv, NULL);
}
void wxColourButton::UpdateColour()
{
#ifdef __WXGTK3__
gtk_color_button_set_rgba(GTK_COLOR_BUTTON(m_widget), m_colour);
#else
gtk_color_button_set_color(GTK_COLOR_BUTTON(m_widget), m_colour.GetColor());
#endif
}
void settings(){
GtkWidget *window_settings;
GtkWidget *box_buttons;
GtkWidget *box_cbuttons1;
GtkWidget *box_cbuttons2;
GtkWidget * label_bg;
GtkWidget * label_fg;
GtkWidget* button_save;
GtkWidget* button_close;
window_settings = gtk_window_new(GTK_WINDOW_TOPLEVEL);
box_main = gtk_vbox_new(FALSE, 0);
box_buttons = gtk_hbox_new(FALSE, 0);
box_cbuttons1 = gtk_hbox_new(FALSE, 0);
box_cbuttons2 = gtk_hbox_new(FALSE, 0);
label_bg = gtk_label_new("Background : ");
gtk_box_pack_start (GTK_BOX(box_cbuttons1), label_bg, TRUE, FALSE, 5);
button_bcolor = gtk_color_button_new();
gtk_box_pack_start (GTK_BOX(box_cbuttons1), button_bcolor, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX(box_main), box_cbuttons1, TRUE, FALSE, 5);
label_fg = gtk_label_new("Foreground : ");
gtk_box_pack_start (GTK_BOX(box_cbuttons2), label_fg, TRUE, FALSE, 5);
button_fcolor = gtk_color_button_new();
gtk_box_pack_start (GTK_BOX(box_cbuttons2), button_fcolor, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX(box_main), box_cbuttons2, TRUE, FALSE, 5);
button_save = gtk_button_new_with_label("Save");
button_close = gtk_button_new_with_label("Close");
gtk_signal_connect (GTK_OBJECT (button_save), "clicked",
GTK_SIGNAL_FUNC (save), NULL);
gtk_box_pack_start (GTK_BOX (box_buttons), button_save, TRUE, FALSE, 5);
gtk_signal_connect (GTK_OBJECT (button_close), "clicked",
GTK_SIGNAL_FUNC (remove_vte), NULL);
gtk_box_pack_start (GTK_BOX (box_buttons), button_close, TRUE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (box_main), box_buttons, TRUE, FALSE, 5);
gtk_container_add (GTK_CONTAINER (window_settings), box_main);
gtk_widget_show (label_fg);
gtk_widget_show (label_bg);
gtk_widget_show (box_cbuttons1);
gtk_widget_show (box_cbuttons2);
gtk_widget_show (button_bcolor);
gtk_widget_show (button_fcolor);
gtk_widget_show (button_save);
gtk_widget_show (button_close);
gtk_widget_show (box_buttons);
gtk_widget_show (box_main);
gtk_widget_show (window_settings);
gtk_color_button_set_color(GTK_COLOR_BUTTON(button_bcolor), &bcolor);
gtk_color_button_set_color(GTK_COLOR_BUTTON(button_fcolor), &fcolor);
}
void reset_general_controls()
{
GtkWidget * widget = NULL;
if ((!toplevel) || (!gauge))
return;
hold_handlers = TRUE;
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"cw_button"));
gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(widget),TRUE);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"ccw_button"));
gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(widget),TRUE);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"antialiased_check"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),TRUE);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"tattletale_check"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),TRUE);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"tattletale_alpha_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_width_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_tail_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"start_angle_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"sweep_angle_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"lbound_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"ubound_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),0);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"background_color_button"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget),&black);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"needle_color_button"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget),&white);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_begin_color_button"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget),&white);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"gradient_end_color_button"));
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget),&black);
hold_handlers = FALSE;
}
static void widget_colorbutton_input_by_file(variable *var, char *filename)
{
FILE *infile;
GdkColor color;
list_t *values = NULL;
gchar line[512];
gint count;
guint alpha;
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Entering.\n", __func__);
#endif
if (infile = fopen(filename, "r")) {
/* Just one line */
if (fgets(line, 512, infile)) {
/* Enforce end of string in case of max chars read */
line[512 - 1] = 0;
/* Remove the trailing [CR]LFs */
for (count = strlen(line) - 1; count >= 0; count--)
if (line[count] == 13 || line[count] == 10) line[count] = 0;
values = linecutter(g_strdup(line), '|');
if (values->n_lines > 0) {
/* Parse the RGB value to create the necessary GdkColor.
* This function doesn't like trailing whitespace so it
* needs to be stripped first with g_strstrip() */
if (gdk_color_parse(g_strstrip(values->line[0]), &color)) {
#ifdef DEBUG_CONTENT
fprintf(stderr, "%s:() valid colour found\n", __func__);
#endif
gtk_color_button_set_color(GTK_COLOR_BUTTON(var->Widget), &color);
}
}
if (values->n_lines > 1) {
/* Read alpha as an unsigned decimal integer */
if (sscanf(values->line[1], "%u", &alpha) == 1) {
#ifdef DEBUG_CONTENT
fprintf(stderr, "%s:() valid alpha=%u found\n", __func__, alpha);
#endif
/* This requires use-alpha="true" */
gtk_color_button_set_alpha(GTK_COLOR_BUTTON(var->Widget), alpha);
}
}
/* Free linecutter memory */
if (values) list_t_free(values);
}
/* Close the file */
fclose(infile);
} else {
fprintf(stderr, "%s(): Couldn't open '%s' for reading.\n", __func__,
filename);
}
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
}
void update_text_controls()
{
gfloat tmp1 = 0.0;
gfloat tmp2 = 0.0;
gchar *tmpbuf0 = NULL;
gchar *tmpbuf = NULL;
GtkWidget * widget = NULL;
MtxGaugeFace *g = NULL;
GdkColor color;
if (GTK_IS_WIDGET(gauge))
g = MTX_GAUGE_FACE(gauge);
else
return;
if (!toplevel)
return;
hold_handlers = TRUE;
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"precision_spin"));
mtx_gauge_face_get_attribute(g, PRECISION, &tmp1);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),(gint)tmp1);
mtx_gauge_face_get_attribute(g, VALUE_FONTSCALE, &tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_font_scale_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
mtx_gauge_face_get_attribute(g, VALUE_XPOS, &tmp1);
mtx_gauge_face_get_attribute(g, VALUE_YPOS, &tmp2);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_xpos_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_ypos_spin"));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget),tmp2);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_font_button"));
tmpbuf0 = mtx_gauge_face_get_value_font(g);
tmpbuf = g_strdup_printf("%s 13",tmpbuf0);
gtk_font_button_set_font_name(GTK_FONT_BUTTON(widget),tmpbuf);
g_free(tmpbuf0);
g_free(tmpbuf);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"show_value_check"));
mtx_gauge_face_get_attribute(g, SHOW_VALUE, &tmp1);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),(gint)tmp1);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_color_day_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_VALUE_FONT_DAY, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = GTK_WIDGET (gtk_builder_get_object(toplevel,"value_color_nite_button"));
(void)mtx_gauge_face_get_color(g,GAUGE_COL_VALUE_FONT_NITE, &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
hold_handlers = FALSE;
}
void widget_colorbutton_save(variable *var)
{
FILE *outfile;
GdkColor color;
GList *element;
gchar *act;
gchar *filename = NULL;
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Entering.\n", __func__);
#endif
/* We'll use the output file filename if available */
act = attributeset_get_first(&element, var->Attributes, ATTR_OUTPUT);
while (act) {
if (strncasecmp(act, "file:", 5) == 0 && strlen(act) > 5) {
filename = act + 5;
break;
}
act = attributeset_get_next(&element, var->Attributes, ATTR_OUTPUT);
}
/* If we have a valid filename then open it and dump the
* widget's data to it */
if (filename) {
if ((outfile = fopen(filename, "w"))) {
gtk_color_button_get_color(GTK_COLOR_BUTTON(var->Widget), &color);
if (gtk_color_button_get_use_alpha(GTK_COLOR_BUTTON(var->Widget))) {
fprintf(outfile, "#%02x%02x%02x|%u",
(color.red + 257 / 2) / 257,
(color.green + 257 / 2) / 257,
(color.blue + 257 / 2) / 257,
gtk_color_button_get_alpha(GTK_COLOR_BUTTON(var->Widget)));
} else {
fprintf(outfile, "#%02x%02x%02x",
(color.red + 257 / 2) / 257,
(color.green + 257 / 2) / 257,
(color.blue + 257 / 2) / 257);
}
/* Close the file */
fclose(outfile);
} else {
fprintf(stderr, "%s(): Couldn't open '%s' for writing.\n",
__func__, filename);
}
} else {
fprintf(stderr, "%s(): No <output file> directive found.\n", __func__);
}
#ifdef DEBUG_TRANSITS
fprintf(stderr, "%s(): Exiting.\n", __func__);
#endif
}
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
}
/*********************************************************
* Edit color
*********************************************************/
static void
gconf_edit_color_cb(GtkColorButton *w, xconf *xc)
{
GdkColor c;
xconf *xc_alpha;
gtk_color_button_get_color(GTK_COLOR_BUTTON(w), &c);
xconf_set_value(xc, gdk_color_to_RRGGBB(&c));
if ((xc_alpha = g_object_get_data(G_OBJECT(w), "alpha")))
{
guint16 a = gtk_color_button_get_alpha(GTK_COLOR_BUTTON(w));
a >>= 8;
xconf_set_int(xc_alpha, (int) a);
}
void edit_preferences( GtkWindow* parent )
{
GtkWidget *auto_save_btn, *ask_before_save_btn, *set_default_btn,
*rotate_exif_only_btn, *slide_delay_spinner, *ask_before_del_btn, *bg_btn, *bg_full_btn;
GtkBuilder* builder = gtk_builder_new();
GtkDialog* dlg;
gtk_builder_add_from_file(builder, PACKAGE_DATA_DIR "/gpicview/ui/pref-dlg.ui", NULL);
dlg = (GtkDialog*)gtk_builder_get_object(builder, "dlg");
gtk_window_set_transient_for((GtkWindow*)dlg, parent);
ask_before_save_btn = (GtkWidget*)gtk_builder_get_object(builder, "ask_before_save");
gtk_toggle_button_set_active( (GtkToggleButton*)ask_before_save_btn, pref.ask_before_save );
ask_before_del_btn = (GtkWidget*)gtk_builder_get_object(builder, "ask_before_delete");
gtk_toggle_button_set_active( (GtkToggleButton*)ask_before_del_btn, pref.ask_before_delete );
auto_save_btn = (GtkWidget*)gtk_builder_get_object(builder, "auto_save_rotated");
gtk_toggle_button_set_active( (GtkToggleButton*)auto_save_btn, pref.auto_save_rotated );
rotate_exif_only_btn = (GtkWidget*)gtk_builder_get_object(builder, "rotate_exif_only");
gtk_toggle_button_set_active( (GtkToggleButton*)rotate_exif_only_btn, pref.rotate_exif_only );
slide_delay_spinner = (GtkWidget*)gtk_builder_get_object(builder, "slide_delay");
gtk_spin_button_set_value( (GtkSpinButton*)slide_delay_spinner, pref.slide_delay) ;
set_default_btn = (GtkWidget*)gtk_builder_get_object(builder, "make_default");
g_signal_connect( set_default_btn, "clicked", G_CALLBACK(on_set_default), parent );
bg_btn = (GtkWidget*)gtk_builder_get_object(builder, "bg");
gtk_color_button_set_color(GTK_COLOR_BUTTON(bg_btn), &pref.bg);
g_signal_connect( bg_btn, "color-set", G_CALLBACK(on_set_bg), parent );
bg_full_btn = (GtkWidget*)gtk_builder_get_object(builder, "bg_full");
gtk_color_button_set_color(GTK_COLOR_BUTTON(bg_full_btn), &pref.bg_full);
g_signal_connect( bg_full_btn, "color-set", G_CALLBACK(on_set_bg_full), parent );
g_object_unref( builder );
gtk_dialog_run( dlg );
pref.ask_before_save = gtk_toggle_button_get_active( (GtkToggleButton*)ask_before_save_btn );
pref.ask_before_delete = gtk_toggle_button_get_active( (GtkToggleButton*)ask_before_del_btn );
pref.auto_save_rotated = gtk_toggle_button_get_active( (GtkToggleButton*)auto_save_btn );
pref.rotate_exif_only = gtk_toggle_button_get_active( (GtkToggleButton*)rotate_exif_only_btn );
pref.slide_delay = gtk_spin_button_get_value_as_int( (GtkSpinButton*)slide_delay_spinner );
gtk_widget_destroy( (GtkWidget*)dlg );
}
void save(){
gtk_color_button_get_color(GTK_COLOR_BUTTON(button_bcolor), &bcolor);
gtk_color_button_get_color(GTK_COLOR_BUTTON(button_fcolor), &fcolor);
struct v *p = st;
int i;
for(i = 0; i < c; i++){
set_data(p);
p = p -> next;
}
gtk_color_button_set_color(GTK_COLOR_BUTTON(button_bcolor), &bcolor);
gtk_color_button_set_color(GTK_COLOR_BUTTON(button_fcolor), &fcolor);
write_config();
}
gboolean alter_w_range_data(GtkWidget *widget, gpointer data)
{
gint index = (GINT)OBJ_GET((widget),"index");
gfloat value = 0.0;
GdkColor color;
WrField field = (WrField)(GINT)data;
if (!GTK_IS_WIDGET(gauge))
return FALSE;
switch (field)
{
case WR_LOWPOINT:
case WR_HIGHPOINT:
case WR_INSET:
case WR_LWIDTH:
value = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget));
mtx_gauge_face_alter_warning_range(MTX_GAUGE_FACE(gauge),index,field,(void *)&value);
break;
case WR_COLOR_DAY:
case WR_COLOR_NITE:
gtk_color_button_get_color(GTK_COLOR_BUTTON(widget),&color);
mtx_gauge_face_alter_warning_range(MTX_GAUGE_FACE(gauge),index,field,(void *)&color);
break;
default:
break;
}
return TRUE;
}
static void
panel_properties_dialog_setup_color_button (PanelPropertiesDialog *dialog,
GladeXML *gui)
{
PanelColor color;
dialog->color_button = glade_xml_get_widget (gui, "color_button");
g_return_if_fail (dialog->color_button != NULL);
dialog->color_label = glade_xml_get_widget (gui, "color_label");
g_return_if_fail (dialog->color_label != NULL);
panel_profile_get_background_color (dialog->toplevel, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (dialog->color_button),
&(color.gdk));
g_signal_connect_swapped (dialog->color_button, "color_set",
G_CALLBACK (panel_properties_dialog_color_changed),
dialog);
if ( ! panel_profile_is_writable_background_color (dialog->toplevel)) {
gtk_widget_set_sensitive (dialog->color_button, FALSE);
gtk_widget_set_sensitive (dialog->color_label, FALSE);
gtk_widget_show (dialog->writability_warn_background);
}
}
/**
* called when a color is chosen in the GtkColorButton,
* update the color selected
*
* \param color_button
* \param combobox
*
* \return FALSE
* */
static gboolean preferences_view_color_changed ( GtkWidget *color_button,
GtkWidget *combobox )
{
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combobox), &iter))
{
GtkTreeModel *model;
GdkColor *color;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combobox));
gtk_tree_model_get ( GTK_TREE_MODEL (model),
&iter,
1, &color,
-1 );
if (color)
{
gtk_color_button_get_color ( GTK_COLOR_BUTTON (color_button),
color );
/* update the colors in the transactions list */
transaction_list_redraw ();
/* update scheduled list */
gsb_scheduler_list_fill_list (gsb_scheduler_list_get_tree_view ());
gsb_scheduler_list_set_background_color (gsb_scheduler_list_get_tree_view ());
gsb_scheduler_list_select (-1);
}
}
return FALSE;
}
/* 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
}
