static void
profile_colors_notify_scheme_combo_cb (TerminalProfile *profile,
GParamSpec *pspec,
GtkComboBox *combo)
{
const GdkColor *fg, *bg;
guint i;
fg = terminal_profile_get_property_boxed (profile, TERMINAL_PROFILE_FOREGROUND_COLOR);
bg = terminal_profile_get_property_boxed (profile, TERMINAL_PROFILE_BACKGROUND_COLOR);
if (fg && bg)
{
for (i = 0; i < G_N_ELEMENTS (color_schemes); ++i)
{
if (gdk_color_equal (fg, &color_schemes[i].foreground) &&
gdk_color_equal (bg, &color_schemes[i].background))
break;
}
}
else
{
i = G_N_ELEMENTS (color_schemes);
}
/* If we didn't find a match, then we get the last combo box item which is "custom" */
g_signal_handlers_block_by_func (combo, G_CALLBACK (color_scheme_combo_changed_cb), profile);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), i);
g_signal_handlers_unblock_by_func (combo, G_CALLBACK (color_scheme_combo_changed_cb), profile);
}
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);
}
}
}
gboolean
terminal_profile_modify_palette_entry (TerminalProfile *profile,
guint i,
const GdkColor *color)
{
TerminalProfilePrivate *priv = profile->priv;
GValueArray *array;
GValue *value;
GdkColor *old_color;
array = g_value_get_boxed (g_value_array_get_nth (priv->properties, PROP_PALETTE));
if (!array ||
i >= array->n_values)
return FALSE;
value = g_value_array_get_nth (array, i);
old_color = g_value_get_boxed (value);
if (!old_color ||
!gdk_color_equal (old_color, color))
{
g_value_set_boxed (value, color);
g_object_notify (G_OBJECT (profile), TERMINAL_PROFILE_PALETTE);
}
return TRUE;
}
void
vkb_button_set_bg(GtkWidget *widget, GtkStateType state, const GdkColor *color)
{
GtkVkbButton *button;
GdkColormap *colormap;
g_return_if_fail(GTK_IS_VKB_BUTTON(widget));
g_return_if_fail(state >= GTK_STATE_NORMAL && state <= GTK_STATE_INSENSITIVE);
button = GTK_VKB_BUTTON(widget);
colormap = gtk_widget_get_colormap(GTK_WIDGET(button));
if (button->bgcolor[state].pixel != 0) {
if (gdk_color_equal(&button->bgcolor[state], color))
goto done;
gdk_colormap_free_colors(colormap, &button->bgcolor[state], 1);
}
button->bgcolor[state] = *color;
button->bgcolor[state].pixel = 0;
gdk_colormap_alloc_color(colormap, &button->bgcolor[state], FALSE, TRUE);
done:
return;
}
static int
gtk_color_instance_equal (struct Lisp_Color_Instance *c1,
struct Lisp_Color_Instance *c2,
int depth)
{
return (gdk_color_equal (COLOR_INSTANCE_GTK_COLOR (c1),
COLOR_INSTANCE_GTK_COLOR (c2)));
}
static int
values_equal (GParamSpec *pspec,
const GValue *va,
const GValue *vb)
{
/* g_param_values_cmp isn't good enough for some types, since e.g.
* it compares colours and font descriptions by pointer value, not
* with the correct compare functions. Providing extra
* PangoParamSpecFontDescription and GdkParamSpecColor wouldn't
* have fixed this either, since it's unclear how to _order_ them.
* Luckily we only need to check them for equality here.
*/
if (g_param_values_cmp (pspec, va, vb) == 0)
return TRUE;
if (G_PARAM_SPEC_VALUE_TYPE (pspec) == GDK_TYPE_COLOR)
return gdk_color_equal (g_value_get_boxed (va), g_value_get_boxed (vb));
if (G_PARAM_SPEC_VALUE_TYPE (pspec) == PANGO_TYPE_FONT_DESCRIPTION)
return pango_font_description_equal (g_value_get_boxed (va), g_value_get_boxed (vb));
if (G_IS_PARAM_SPEC_VALUE_ARRAY (pspec) &&
G_PARAM_SPEC_VALUE_TYPE (G_PARAM_SPEC_VALUE_ARRAY (pspec)->element_spec) == GDK_TYPE_COLOR)
{
GValueArray *ara, *arb;
guint i;
ara = g_value_get_boxed (va);
arb = g_value_get_boxed (vb);
if (!ara || !arb || ara->n_values != arb->n_values)
return FALSE;
for (i = 0; i < ara->n_values; ++i)
if (!gdk_color_equal (g_value_get_boxed (g_value_array_get_nth (ara, i)),
g_value_get_boxed (g_value_array_get_nth (arb, i))))
return FALSE;
return TRUE;
}
return FALSE;
}
gboolean
html_color_equal (HTMLColor *color1, HTMLColor *color2)
{
if (color1 == color2)
return TRUE;
if (!color1 || !color2)
return FALSE;
return gdk_color_equal (&color1->color, &color2->color);
}
static gint
filter_color_eq (EFilterElement *element_a,
EFilterElement *element_b)
{
EFilterColor *color_a = E_FILTER_COLOR (element_a);
EFilterColor *color_b = E_FILTER_COLOR (element_b);
return E_FILTER_ELEMENT_CLASS (e_filter_color_parent_class)->
eq (element_a, element_b) &&
gdk_color_equal (&color_a->color, &color_b->color);
}
static gboolean
palette_cmp (const GdkColor *ca,
const GdkColor *cb)
{
guint i;
for (i = 0; i < TERMINAL_PALETTE_SIZE; ++i)
if (!gdk_color_equal (&ca[i], &cb[i]))
return FALSE;
return TRUE;
}
void
na_tray_manager_set_colors (NaTrayManager *manager,
GdkColor *fg,
GdkColor *error,
GdkColor *warning,
GdkColor *success)
{
g_return_if_fail (NA_IS_TRAY_MANAGER (manager));
if (!gdk_color_equal (&manager->fg, fg) ||
!gdk_color_equal (&manager->error, error) ||
!gdk_color_equal (&manager->warning, warning) ||
!gdk_color_equal (&manager->success, success))
{
manager->fg = *fg;
manager->error = *error;
manager->warning = *warning;
manager->success = *success;
na_tray_manager_set_colors_property (manager);
}
}
void matenu_menu_bar_set_background (MatenuMenuBar* self, MatenuBackground* value) {
MatenuBackgroundType old_type;
GdkColor old_color;
GdkPixmap* _tmp0_;
g_return_if_fail (self != NULL);
old_type = self->priv->_background->type;
old_color = self->priv->_background->color;
self->priv->_background->type = value->type;
self->priv->_background->pixmap = (_tmp0_ = _g_object_ref0 (value->pixmap), _g_object_unref0 (self->priv->_background->pixmap), _tmp0_);
self->priv->_background->color = value->color;
self->priv->_background->offset_x = value->offset_x;
self->priv->_background->offset_y = value->offset_y;
switch (self->priv->_background->type) {
case MATENU_BACKGROUND_TYPE_NONE:
{
if (old_type != self->priv->_background->type) {
GtkRcStyle* rc_style;
gtk_widget_set_style ((GtkWidget*) self, NULL);
rc_style = gtk_rc_style_new ();
gtk_widget_modify_style ((GtkWidget*) self, rc_style);
_g_object_unref0 (rc_style);
}
break;
}
case MATENU_BACKGROUND_TYPE_COLOR:
{
gboolean _tmp1_ = FALSE;
if (old_type != self->priv->_background->type) {
_tmp1_ = TRUE;
} else {
gboolean _tmp2_ = FALSE;
if (old_type == self->priv->_background->type) {
_tmp2_ = !gdk_color_equal (&old_color, &self->priv->_background->color);
} else {
_tmp2_ = FALSE;
}
_tmp1_ = _tmp2_;
}
if (_tmp1_) {
gtk_widget_modify_bg ((GtkWidget*) self, GTK_STATE_NORMAL, &self->priv->_background->color);
}
break;
}
case MATENU_BACKGROUND_TYPE_PIXMAP:
{
matenu_menu_bar_reset_bg_pixmap (self);
break;
}
}
g_object_notify ((GObject *) self, "background");
}
gboolean msgwin_goto_compiler_file_line(gboolean focus_editor)
{
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
gchar *string;
GdkColor *color;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(msgwindow.tree_compiler));
if (gtk_tree_selection_get_selected(selection, &model, &iter))
{
/* if the item is not coloured red, it's not an error line */
gtk_tree_model_get(model, &iter, COMPILER_COL_COLOR, &color, -1);
if (color == NULL || ! gdk_color_equal(color, &color_error))
{
if (color != NULL)
gdk_color_free(color);
return FALSE;
}
gdk_color_free(color);
gtk_tree_model_get(model, &iter, COMPILER_COL_STRING, &string, -1);
if (string != NULL)
{
gint line;
gchar *filename, *dir;
GtkTreePath *path;
gboolean ret;
path = gtk_tree_model_get_path(model, &iter);
find_prev_build_dir(path, model, &dir);
gtk_tree_path_free(path);
msgwin_parse_compiler_error_line(string, dir, &filename, &line);
g_free(string);
g_free(dir);
ret = goto_compiler_file_line(filename, line, focus_editor);
g_free(filename);
return ret;
}
}
return FALSE;
}
void
gtk_color_combo_find_color(GtkColorCombo *color_combo,
GdkColor *color, gint *row, gint *col)
{
GdkColor combo_color;
gchar *name;
gint i, j;
gdouble dist = 114000.0;
gdouble d, dr, dg, db;
*row = -1;
*col = -1;
for(i = 0; i < color_combo->nrows; i++){
for(j = 0; j < color_combo->ncols; j++){
name = gtk_color_combo_get_color_at(color_combo, i, j);
gdk_color_parse(name, &combo_color);
if(gdk_color_equal(color, &combo_color)){
*row = i;
*col = j;
return;
}
dr = fabs(color->red - combo_color.red);
dg = fabs(color->green - combo_color.green);
db = fabs(color->blue - combo_color.blue);
d = dr + dg + db;
/*
printf("%d %d %d // %d %d %d\n",color->red,color->green,color->blue,combo_color.red,combo_color.green,combo_color.blue);
printf("%f\n",d);
*/
if(d < dist){
dist = d;
*row = i;
*col = j;
}
}
}
}
void
prefs_set_color_gdk (Prefs *p, Color which, GdkColor *color)
{
gboolean changed = FALSE;
if (p->color[which]) {
changed = !gdk_color_equal (color, p->color[which]);
gdk_color_free (p->color[which]);
}
p->color[which] = gdk_color_copy (color);
if (changed) {
gchar *spec;
spec = prefs_colors_to_csvstr (p);
gconf_client_set_string (p->gconf_client, PREF_CARD_COLORS, spec, NULL);
g_free (spec);
}
}
static int restore_values (void)
{
int ret = 0;
if (desktop_font != orig_desktop_font)
{
desktop_font = orig_desktop_font;
ret = 1;
}
if (desktop_picture != orig_desktop_picture)
{
desktop_picture = orig_desktop_picture;
ret = 1;
}
if (desktop_mode != orig_desktop_mode)
{
desktop_mode = orig_desktop_mode;
ret = 1;
}
if (icon_size != orig_icon_size)
{
icon_size = orig_icon_size;
ret = 1;
}
if (!gdk_color_equal (&theme_colour, &orig_theme_colour))
{
theme_colour = orig_theme_colour;
ret = 1;
}
if (!gdk_color_equal (&themetext_colour, &orig_themetext_colour))
{
themetext_colour = orig_themetext_colour;
ret = 1;
}
if (!gdk_color_equal (&desktop_colour, &orig_desktop_colour))
{
desktop_colour = orig_desktop_colour;
ret = 1;
}
if (!gdk_color_equal (&desktoptext_colour, &orig_desktoptext_colour))
{
desktoptext_colour = orig_desktoptext_colour;
ret = 1;
}
if (!gdk_color_equal (&bar_colour, &orig_bar_colour))
{
bar_colour = orig_bar_colour;
ret = 1;
}
if (!gdk_color_equal (&bartext_colour, &orig_bartext_colour))
{
bartext_colour = orig_bartext_colour;
ret = 1;
}
if (barpos != orig_barpos)
{
barpos = orig_barpos;
ret = 1;
}
if (strcmp ("PiX", orig_lxsession_theme))
{
set_lxsession_theme (orig_lxsession_theme);
ret = 1;
}
if (strcmp ("PiX", orig_openbox_theme))
{
set_openbox_theme (orig_openbox_theme);
ret = 1;
}
if (show_docs != orig_show_docs)
{
show_docs = orig_show_docs;
ret = 1;
}
if (show_trash != orig_show_trash)
{
show_trash = orig_show_trash;
ret = 1;
}
if (show_mnts != orig_show_mnts)
{
show_mnts = orig_show_mnts;
ret = 1;
}
return ret;
}
static void header_label_style_set(GtkWidget *widget)
{
GtkStyle *style = gtk_widget_get_style(widget);
if (! gdk_color_equal(&style->fg[GTK_STATE_NORMAL], &style->fg[GTK_STATE_SELECTED]))
gtk_widget_modify_fg(widget, GTK_STATE_NORMAL, &style->fg[GTK_STATE_SELECTED]);
}
static void
gtk_text_render_state_update (GtkTextRenderState *state,
GtkTextAppearance *new_appearance)
{
GdkScreen *screen = gtk_widget_get_screen (state->widget);
if (!state->last_appearance ||
!gdk_color_equal (&new_appearance->fg_color, &state->last_appearance->fg_color))
gtk_text_render_state_set_color (state, state->fg_gc, &new_appearance->fg_color);
if (!state->last_appearance ||
new_appearance->fg_stipple != state->last_appearance->fg_stipple)
{
if (new_appearance->fg_stipple)
{
if (screen == gdk_drawable_get_screen (new_appearance->fg_stipple))
{
gdk_gc_set_fill (state->fg_gc, GDK_STIPPLED);
gdk_gc_set_stipple (state->fg_gc, new_appearance->fg_stipple);
}
else
g_warning ("gtk_text_render_state_update:\n"
"The foreground stipple bitmap has been created on the wrong screen.\n"
"Ignoring the stipple bitmap information.");
}
else
{
gdk_gc_set_fill (state->fg_gc, GDK_SOLID);
}
}
if (new_appearance->draw_bg)
{
if (!state->last_bg_appearance ||
!gdk_color_equal (&new_appearance->bg_color, &state->last_bg_appearance->bg_color))
gtk_text_render_state_set_color (state, state->bg_gc, &new_appearance->bg_color);
if (!state->last_bg_appearance ||
new_appearance->bg_stipple != state->last_bg_appearance->bg_stipple)
{
if (new_appearance->bg_stipple)
{
if (screen == gdk_drawable_get_screen (new_appearance->bg_stipple))
{
gdk_gc_set_fill (state->bg_gc, GDK_STIPPLED);
gdk_gc_set_stipple (state->bg_gc, new_appearance->bg_stipple);
}
else
g_warning ("gtk_text_render_state_update:\n"
"The background stipple bitmap has been created on the wrong screen.\n"
"Ignoring the stipple bitmap information.");
}
else
{
gdk_gc_set_fill (state->bg_gc, GDK_SOLID);
}
}
state->last_bg_appearance = new_appearance;
}
state->last_appearance = new_appearance;
}
