/*
* Copyright (C) 2001 Havoc Pennington
* Copyright (C) 2016 Alberts Muktupāvels
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <glib/gi18n-lib.h>
#include "meta-color.h"
#include "meta-color-private.h"
#include "meta-color-spec-private.h"
#include "meta-theme.h"
enum _MetaColorSpecType
{
META_COLOR_SPEC_BASIC,
META_COLOR_SPEC_GTK,
META_COLOR_SPEC_GTK_CUSTOM,
META_COLOR_SPEC_BLEND,
META_COLOR_SPEC_SHADE
};
enum _MetaGtkColorComponent
{
META_GTK_COLOR_FG,
META_GTK_COLOR_BG,
META_GTK_COLOR_LIGHT,
META_GTK_COLOR_DARK,
META_GTK_COLOR_MID,
META_GTK_COLOR_TEXT,
META_GTK_COLOR_BASE,
META_GTK_COLOR_TEXT_AA,
META_GTK_COLOR_LAST
};
struct _MetaColorSpec
{
MetaColorSpecType type;
union
{
struct {
GdkRGBA color;
} basic;
struct {
MetaGtkColorComponent component;
GtkStateFlags state;
} gtk;
struct {
gchar *color_name;
MetaColorSpec *fallback;
} gtkcustom;
struct {
MetaColorSpec *foreground;
MetaColorSpec *background;
gdouble alpha;
GdkRGBA color;
} blend;
struct {
MetaColorSpec *base;
gdouble factor;
GdkRGBA color;
} shade;
} data;
};
static void
set_color_from_style (GdkRGBA *color,
GtkStyleContext *context,
GtkStateFlags state,
MetaGtkColorComponent component)
{
GdkRGBA other;
gtk_style_context_set_state (context, state);
switch (component)
{
case META_GTK_COLOR_BG:
case META_GTK_COLOR_BASE:
meta_color_get_background_color (context, state, color);
break;
case META_GTK_COLOR_FG:
case META_GTK_COLOR_TEXT:
gtk_style_context_get_color (context, state, color);
break;
case META_GTK_COLOR_TEXT_AA:
gtk_style_context_get_color (context, state, color);
set_color_from_style (&other, context, state, META_GTK_COLOR_BASE);
color->red = (color->red + other.red) / 2;
color->green = (color->green + other.green) / 2;
color->blue = (color->blue + other.blue) / 2;
break;
case META_GTK_COLOR_MID:
meta_color_get_light_color (context, state, color);
meta_color_get_dark_color (context, state, &other);
color->red = (color->red + other.red) / 2;
color->green = (color->green + other.green) / 2;
color->blue = (color->blue + other.blue) / 2;
break;
case META_GTK_COLOR_LIGHT:
meta_color_get_light_color (context, state, color);
break;
case META_GTK_COLOR_DARK:
meta_color_get_dark_color (context, state, color);
break;
case META_GTK_COLOR_LAST:
default:
g_assert_not_reached ();
break;
}
}
static void
color_composite (const GdkRGBA *bg,
const GdkRGBA *fg,
gdouble alpha,
GdkRGBA *color)
{
*color = *bg;
color->red = color->red + (fg->red - color->red) * alpha;
color->green = color->green + (fg->green - color->green) * alpha;
color->blue = color->blue + (fg->blue - color->blue) * alpha;
color->alpha = color->alpha + (fg->alpha - color->alpha) * alpha;
}
static void
set_custom_color_from_style (GdkRGBA *color,
GtkStyleContext *context,
const gchar *color_name,
MetaColorSpec *fallback)
{
if (!gtk_style_context_lookup_color (context, color_name, color))
meta_color_spec_render (fallback, context, color);
}
static MetaGtkColorComponent
meta_color_component_from_string (const gchar *str)
{
if (strcmp ("fg", str) == 0)
return META_GTK_COLOR_FG;
else if (strcmp ("bg", str) == 0)
return META_GTK_COLOR_BG;
else if (strcmp ("light", str) == 0)
return META_GTK_COLOR_LIGHT;
else if (strcmp ("dark", str) == 0)
return META_GTK_COLOR_DARK;
else if (strcmp ("mid", str) == 0)
return META_GTK_COLOR_MID;
else if (strcmp ("text", str) == 0)
return META_GTK_COLOR_TEXT;
else if (strcmp ("base", str) == 0)
return META_GTK_COLOR_BASE;
else if (strcmp ("text_aa", str) == 0)
return META_GTK_COLOR_TEXT_AA;
else
return META_GTK_COLOR_LAST;
}
MetaColorSpec *
meta_color_spec_new (MetaColorSpecType type)
{
MetaColorSpec *spec;
MetaColorSpec dummy;
gint size;
size = G_STRUCT_OFFSET (MetaColorSpec, data);
switch (type)
{
case META_COLOR_SPEC_BASIC:
size += sizeof (dummy.data.basic);
break;
case META_COLOR_SPEC_GTK:
size += sizeof (dummy.data.gtk);
break;
case META_COLOR_SPEC_GTK_CUSTOM:
size += sizeof (dummy.data.gtkcustom);
break;
case META_COLOR_SPEC_BLEND:
size += sizeof (dummy.data.blend);
break;
case META_COLOR_SPEC_SHADE:
size += sizeof (dummy.data.shade);
break;
default:
break;
}
spec = g_malloc0 (size);
spec->type = type;
return spec;
}
MetaColorSpec *
meta_color_spec_new_from_string (const gchar *str,
GError **error)
{
MetaColorSpec *spec;
spec = NULL;
if (strncmp (str, "gtk:custom", 10) == 0)
{
const gchar *color_name_start;
const gchar *fallback_str_start;
const gchar *end;
gchar *fallback_str;
MetaColorSpec *fallback;
gchar *color_name;
if (str[10] != '(')
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("GTK custom color specification must have color name and fallback in parentheses, e.g. gtk:custom(foo,bar); could not parse '%s'"),
str);
return NULL;
}
color_name_start = str + 11;
fallback_str_start = color_name_start;
while (*fallback_str_start && *fallback_str_start != ',')
{
if (!(g_ascii_isalnum (*fallback_str_start)
|| *fallback_str_start == '-' || *fallback_str_start == '_'))
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Invalid character '%c' in color_name parameter of gtk:custom, only A-Za-z0-9-_ are valid"),
*fallback_str_start);
return NULL;
}
fallback_str_start++;
}
fallback_str_start++;
end = strrchr (str, ')');
if (color_name_start == NULL || fallback_str_start == NULL || end == NULL)
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Gtk:custom format is 'gtk:custom(color_name,fallback)', '%s' does not fit the format"),
str);
return NULL;
}
fallback_str = g_strndup (fallback_str_start, end - fallback_str_start);
fallback = meta_color_spec_new_from_string (fallback_str, error);
g_free (fallback_str);
if (fallback == NULL)
return NULL;
color_name = g_strndup (color_name_start, fallback_str_start - color_name_start - 1);
spec = meta_color_spec_new (META_COLOR_SPEC_GTK_CUSTOM);
spec->data.gtkcustom.color_name = color_name;
spec->data.gtkcustom.fallback = fallback;
}
else if (strncmp (str, "gtk:", 4) == 0)
{
const gchar *bracket;
const gchar *end_bracket;
gchar *tmp;
GtkStateFlags state;
MetaGtkColorComponent component;
bracket = str;
while (*bracket && *bracket != '[')
++bracket;
if (*bracket == '\0')
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("GTK color specification must have the state in brackets, e.g. gtk:fg[NORMAL] where NORMAL is the state; could not parse '%s'"),
str);
return NULL;
}
end_bracket = bracket;
++end_bracket;
while (*end_bracket && *end_bracket != ']')
++end_bracket;
if (*end_bracket == '\0')
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("GTK color specification must have a close bracket after the state, e.g. gtk:fg[NORMAL] where NORMAL is the state; could not parse '%s'"),
str);
return NULL;
}
tmp = g_strndup (bracket + 1, end_bracket - bracket - 1);
if (!meta_gtk_state_from_string (tmp, &state))
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Did not understand state '%s' in color specification"),
tmp);
g_free (tmp);
return NULL;
}
g_free (tmp);
tmp = g_strndup (str + 4, bracket - str - 4);
component = meta_color_component_from_string (tmp);
if (component == META_GTK_COLOR_LAST)
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Did not understand color component '%s' in color specification"),
tmp);
g_free (tmp);
return NULL;
}
g_free (tmp);
spec = meta_color_spec_new (META_COLOR_SPEC_GTK);
spec->data.gtk.state = state;
spec->data.gtk.component = component;
g_assert (spec->data.gtk.component < META_GTK_COLOR_LAST);
}
else if (strncmp (str, "blend/", 6) == 0)
{
gchar **split;
gdouble alpha;
gchar *end;
MetaColorSpec *fg;
MetaColorSpec *bg;
split = g_strsplit (str, "/", 4);
if (split[0] == NULL || split[1] == NULL ||
split[2] == NULL || split[3] == NULL)
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Blend format is 'blend/bg_color/fg_color/alpha', '%s' does not fit the format"),
str);
g_strfreev (split);
return NULL;
}
alpha = g_ascii_strtod (split[3], &end);
if (end == split[3])
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Could not parse alpha value '%s' in blended color"),
split[3]);
g_strfreev (split);
return NULL;
}
if (alpha < (0.0 - 1e6) || alpha > (1.0 + 1e6))
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Alpha value '%s' in blended color is not between 0.0 and 1.0"),
split[3]);
g_strfreev (split);
return NULL;
}
fg = NULL;
bg = NULL;
bg = meta_color_spec_new_from_string (split[1], error);
if (bg == NULL)
{
g_strfreev (split);
return NULL;
}
fg = meta_color_spec_new_from_string (split[2], error);
if (fg == NULL)
{
meta_color_spec_free (bg);
g_strfreev (split);
return NULL;
}
g_strfreev (split);
spec = meta_color_spec_new (META_COLOR_SPEC_BLEND);
spec->data.blend.alpha = alpha;
spec->data.blend.background = bg;
spec->data.blend.foreground = fg;
}
else if (strncmp (str, "shade/", 6) == 0)
{
gchar **split;
gdouble factor;
gchar *end;
MetaColorSpec *base;
split = g_strsplit (str, "/", 3);
if (split[0] == NULL || split[1] == NULL || split[2] == NULL)
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Shade format is 'shade/base_color/factor', '%s' does not fit the format"),
str);
g_strfreev (split);
return NULL;
}
factor = g_ascii_strtod (split[2], &end);
if (end == split[2])
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Could not parse shade factor '%s' in shaded color"),
split[2]);
g_strfreev (split);
return NULL;
}
if (factor < (0.0 - 1e6))
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Shade factor '%s' in shaded color is negative"),
split[2]);
g_strfreev (split);
return NULL;
}
base = meta_color_spec_new_from_string (split[1], error);
if (base == NULL)
{
g_strfreev (split);
return NULL;
}
g_strfreev (split);
spec = meta_color_spec_new (META_COLOR_SPEC_SHADE);
spec->data.shade.factor = factor;
spec->data.shade.base = base;
}
else
{
spec = meta_color_spec_new (META_COLOR_SPEC_BASIC);
if (!gdk_rgba_parse (&spec->data.basic.color, str))
{
g_set_error (error, META_THEME_ERROR, META_THEME_ERROR_FAILED,
_("Could not parse color '%s'"), str);
meta_color_spec_free (spec);
return NULL;
}
}
g_assert (spec);
return spec;
}
MetaColorSpec *
meta_color_spec_new_gtk (MetaGtkColorComponent component,
GtkStateFlags state)
{
MetaColorSpec *spec;
spec = meta_color_spec_new (META_COLOR_SPEC_GTK);
spec->data.gtk.component = component;
spec->data.gtk.state = state;
return spec;
}
void
meta_color_spec_free (MetaColorSpec *spec)
{
g_return_if_fail (spec != NULL);
switch (spec->type)
{
case META_COLOR_SPEC_BASIC:
break;
case META_COLOR_SPEC_GTK:
break;
case META_COLOR_SPEC_GTK_CUSTOM:
if (spec->data.gtkcustom.color_name)
g_free (spec->data.gtkcustom.color_name);
if (spec->data.gtkcustom.fallback)
meta_color_spec_free (spec->data.gtkcustom.fallback);
break;
case META_COLOR_SPEC_BLEND:
if (spec->data.blend.foreground)
meta_color_spec_free (spec->data.blend.foreground);
if (spec->data.blend.background)
meta_color_spec_free (spec->data.blend.background);
break;
case META_COLOR_SPEC_SHADE:
if (spec->data.shade.base)
meta_color_spec_free (spec->data.shade.base);
break;
default:
break;
}
g_free (spec);
}
void
meta_color_spec_render (MetaColorSpec *spec,
GtkStyleContext *context,
GdkRGBA *color)
{
g_return_if_fail (spec != NULL);
g_return_if_fail (GTK_IS_STYLE_CONTEXT (context));
switch (spec->type)
{
case META_COLOR_SPEC_BASIC:
*color = spec->data.basic.color;
break;
case META_COLOR_SPEC_GTK:
set_color_from_style (color, context, spec->data.gtk.state,
spec->data.gtk.component);
break;
case META_COLOR_SPEC_GTK_CUSTOM:
set_custom_color_from_style (color, context,
spec->data.gtkcustom.color_name,
spec->data.gtkcustom.fallback);
break;
case META_COLOR_SPEC_BLEND:
{
GdkRGBA bg;
GdkRGBA fg;
meta_color_spec_render (spec->data.blend.background, context, &bg);
meta_color_spec_render (spec->data.blend.foreground, context, &fg);
color_composite (&bg, &fg, spec->data.blend.alpha,
&spec->data.blend.color);
*color = spec->data.blend.color;
}
break;
case META_COLOR_SPEC_SHADE:
{
meta_color_spec_render (spec->data.shade.base, context,
&spec->data.shade.color);
meta_color_shade (&spec->data.shade.color, spec->data.shade.factor,
&spec->data.shade.color);
*color = spec->data.shade.color;
}
break;
default:
break;
}
}
/**
* meta_gtk_state_from_string:
* @str: state string
* @state: (out): location to store #GtkStateFlags
*
* Convert string to #GtkStateFlags
*
* Returns: %TRUE if state string was valid, %FALSE otherwise
*/
gboolean
meta_gtk_state_from_string (const gchar *str,
GtkStateFlags *state)
{
if (g_ascii_strcasecmp ("normal", str) == 0)
*state = GTK_STATE_FLAG_NORMAL;
else if (g_ascii_strcasecmp ("prelight", str) == 0)
*state = GTK_STATE_FLAG_PRELIGHT;
else if (g_ascii_strcasecmp ("active", str) == 0)
*state = GTK_STATE_FLAG_ACTIVE;
else if (g_ascii_strcasecmp ("selected", str) == 0)
*state = GTK_STATE_FLAG_SELECTED;
else if (g_ascii_strcasecmp ("insensitive", str) == 0)
*state = GTK_STATE_FLAG_INSENSITIVE;
else if (g_ascii_strcasecmp ("inconsistent", str) == 0)
*state = GTK_STATE_FLAG_INCONSISTENT;
else if (g_ascii_strcasecmp ("focused", str) == 0)
*state = GTK_STATE_FLAG_FOCUSED;
else if (g_ascii_strcasecmp ("backdrop", str) == 0)
*state = GTK_STATE_FLAG_BACKDROP;
else
return FALSE;
return TRUE;
}