//______________________________________________________________________
guint RCStyle::parse(
GtkRcStyle* rc_style,
GtkSettings* settings,
GScanner* scanner )
{
static GQuark scope_id = 0;
guint old_scope;
guint token;
if( !scope_id )
{ scope_id = g_quark_from_string( "oxygen_engine" ); }
old_scope = g_scanner_set_scope( scanner, scope_id );
token = g_scanner_peek_next_token( scanner );
while( token != G_TOKEN_RIGHT_CURLY )
{
token = g_scanner_peek_next_token( scanner );
if( token != G_TOKEN_NONE ) return token;
}
g_scanner_get_next_token( scanner );
g_scanner_set_scope( scanner, old_scope );
return G_TOKEN_NONE;
}
static guint
mist_rc_style_parse (GtkRcStyle *rc_style,
GtkSettings *settings,
GScanner *scanner)
{
static GQuark scope_id = 0;
guint old_scope;
guint token;
/* Set up a new scope in this scanner. */
if (!scope_id)
scope_id = g_quark_from_string("theme_engine");
/* If we bail out due to errors, we *don't* reset the scope, so the
* error messaging code can make sense of our tokens.
*/
old_scope = g_scanner_set_scope(scanner, scope_id);
/* We're ready to go, now parse the top level */
token = g_scanner_peek_next_token(scanner);
while (token != G_TOKEN_RIGHT_CURLY) {
switch (token) {
default :
token = G_TOKEN_RIGHT_CURLY;
}
token = g_scanner_peek_next_token (scanner);
if (token != G_TOKEN_NONE) {
return token;
}
}
g_scanner_get_next_token(scanner);
g_scanner_set_scope(scanner, old_scope);
return G_TOKEN_NONE;
}
guint
theme_parse_rc_style (GScanner *scanner, GtkRcStyle *rc_style)
{
ThemeRcData *theme_data;
guint scope_id;
guint old_scope;
guint token;
if (!scope_id)
scope_id = g_quark_from_string("theme_engine");
old_scope = g_scanner_set_scope (scanner, scope_id);
#if 0
if (!g_scanner_lookup_symbol(scanner, theme_symbols[0].name)) {
g_scanner_freeze_symbol_table(scanner);
for (i = 0; i < n_theme_symbols; i++)
{
g_scanner_scope_add_symbol(scanner, scope_id,
theme_symbols[i].name,
GINT_TO_POINTER(theme_symbols[i].token));
}
g_scanner_thaw_symbol_table(scanner);
}
#endif
token = g_scanner_peek_next_token (scanner);
while (token != G_TOKEN_RIGHT_CURLY) {
token = g_scanner_peek_next_token (scanner);
}
g_scanner_get_next_token (scanner);
g_scanner_set_scope (scanner, old_scope);
theme_data = g_new0 (ThemeRcData, 1);
rc_style->engine_data = theme_data;
return G_TOKEN_NONE;
}
/**
* gimp_scanner_parse_matrix2:
* @scanner: A #GScanner created by gimp_scanner_new_file() or
* gimp_scanner_new_string()
* @dest: Pointer to a matrix to store the result
*
* Return value: %TRUE on success
*
* Since: 2.4
**/
gboolean
gimp_scanner_parse_matrix2 (GScanner *scanner,
GimpMatrix2 *dest)
{
guint scope_id;
guint old_scope_id;
GTokenType token;
GimpMatrix2 matrix;
scope_id = g_quark_from_static_string ("gimp_scanner_parse_matrix");
old_scope_id = g_scanner_set_scope (scanner, scope_id);
if (! g_scanner_scope_lookup_symbol (scanner, scope_id, "matrix"))
g_scanner_scope_add_symbol (scanner, scope_id,
"matrix", GINT_TO_POINTER (0));
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
{
token = G_TOKEN_FLOAT;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[0][0]))
goto finish;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[0][1]))
goto finish;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[1][0]))
goto finish;
if (! gimp_scanner_parse_float (scanner, &matrix.coeff[1][1]))
goto finish;
token = G_TOKEN_RIGHT_PAREN;
}
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_NONE; /* indicates success */
goto finish;
default: /* do nothing */
break;
}
}
finish:
if (token != G_TOKEN_NONE)
{
g_scanner_get_next_token (scanner);
g_scanner_unexp_token (scanner, token, NULL, NULL, NULL,
_("fatal parse error"), TRUE);
}
else
{
*dest = matrix;
}
g_scanner_set_scope (scanner, old_scope_id);
return (token == G_TOKEN_NONE);
}
/**
* gimp_scanner_parse_color:
* @scanner: A #GScanner created by gimp_scanner_new_file() or
* gimp_scanner_new_string()
* @dest: Pointer to a color to store the result
*
* Return value: %TRUE on success
*
* Since: 2.4
**/
gboolean
gimp_scanner_parse_color (GScanner *scanner,
GimpRGB *dest)
{
guint scope_id;
guint old_scope_id;
GTokenType token;
GimpRGB color = { 0.0, 0.0, 0.0, 1.0 };
scope_id = g_quark_from_static_string ("gimp_scanner_parse_color");
old_scope_id = g_scanner_set_scope (scanner, scope_id);
if (! g_scanner_scope_lookup_symbol (scanner, scope_id, "color-rgb"))
{
g_scanner_scope_add_symbol (scanner, scope_id,
"color-rgb", GINT_TO_POINTER (COLOR_RGB));
g_scanner_scope_add_symbol (scanner, scope_id,
"color-rgba", GINT_TO_POINTER (COLOR_RGBA));
g_scanner_scope_add_symbol (scanner, scope_id,
"color-hsv", GINT_TO_POINTER (COLOR_HSV));
g_scanner_scope_add_symbol (scanner, scope_id,
"color-hsva", GINT_TO_POINTER (COLOR_HSVA));
}
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
{
gdouble col[4] = { 0.0, 0.0, 0.0, 1.0 };
gint n_channels = 4;
gboolean is_hsv = FALSE;
gint i;
switch (GPOINTER_TO_INT (scanner->value.v_symbol))
{
case COLOR_RGB:
n_channels = 3;
/* fallthrough */
case COLOR_RGBA:
break;
case COLOR_HSV:
n_channels = 3;
/* fallthrough */
case COLOR_HSVA:
is_hsv = TRUE;
break;
}
token = G_TOKEN_FLOAT;
for (i = 0; i < n_channels; i++)
{
gboolean negate = FALSE;
if (g_scanner_peek_next_token (scanner) == '-')
{
negate = TRUE;
g_scanner_get_next_token (scanner);
}
if (! gimp_scanner_parse_float (scanner, &col[i]))
goto finish;
if (negate)
col[i] = - col[i];
}
if (is_hsv)
{
GimpHSV hsv;
gimp_hsva_set (&hsv, col[0], col[1], col[2], col[3]);
gimp_hsv_clamp (&hsv);
gimp_hsv_to_rgb (&hsv, &color);
}
else
{
gimp_rgba_set (&color, col[0], col[1], col[2], col[3]);
gimp_rgb_clamp (&color);
}
token = G_TOKEN_RIGHT_PAREN;
}
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_NONE; /* indicates success */
goto finish;
default: /* do nothing */
break;
}
}
finish:
if (token != G_TOKEN_NONE)
{
g_scanner_get_next_token (scanner);
g_scanner_unexp_token (scanner, token, NULL, NULL, NULL,
_("fatal parse error"), TRUE);
}
else
{
*dest = color;
}
g_scanner_set_scope (scanner, old_scope_id);
return (token == G_TOKEN_NONE);
}
/**
* gimp_config_deserialize_property:
* @config: a #GimpConfig.
* @scanner: a #GScanner.
* @nest_level: the nest level
*
* This function deserializes a single property of @config. You
* shouldn't need to call this function directly. If possible, use
* gimp_config_deserialize_properties() instead.
*
* Return value: %G_TOKEN_RIGHT_PAREN on success, otherwise the
* expected #GTokenType or %G_TOKEN_NONE if the expected token was
* found but couldn't be parsed.
*
* Since: GIMP 2.4
**/
GTokenType
gimp_config_deserialize_property (GimpConfig *config,
GScanner *scanner,
gint nest_level)
{
GimpConfigInterface *config_iface = NULL;
GimpConfigInterface *parent_iface = NULL;
GParamSpec *prop_spec;
GTokenType token = G_TOKEN_RIGHT_PAREN;
GValue value = { 0, };
guint old_scope_id;
old_scope_id = g_scanner_set_scope (scanner, 0);
prop_spec = G_PARAM_SPEC (scanner->value.v_symbol);
g_value_init (&value, prop_spec->value_type);
if (G_TYPE_IS_OBJECT (prop_spec->owner_type))
{
GTypeClass *owner_class = g_type_class_peek (prop_spec->owner_type);
config_iface = g_type_interface_peek (owner_class, GIMP_TYPE_CONFIG);
/* We must call deserialize_property() *only* if the *exact* class
* which implements it is param_spec->owner_type's class.
*
* Therefore, we ask param_spec->owner_type's immediate parent class
* for it's GimpConfigInterface and check if we get a different
* pointer.
*
* (if the pointers are the same, param_spec->owner_type's
* GimpConfigInterface is inherited from one of it's parent classes
* and thus not able to handle param_spec->owner_type's properties).
*/
if (config_iface)
{
GTypeClass *owner_parent_class;
owner_parent_class = g_type_class_peek_parent (owner_class);
parent_iface = g_type_interface_peek (owner_parent_class,
GIMP_TYPE_CONFIG);
}
}
if (config_iface &&
config_iface != parent_iface && /* see comment above */
config_iface->deserialize_property &&
config_iface->deserialize_property (config,
prop_spec->param_id,
&value,
prop_spec,
scanner,
&token))
{
/* nop */
}
else
{
if (G_VALUE_HOLDS_OBJECT (&value))
token = gimp_config_deserialize_object (&value,
config, prop_spec,
scanner, nest_level);
else
token = gimp_config_deserialize_value (&value,
config, prop_spec, scanner);
}
if (token == G_TOKEN_RIGHT_PAREN &&
g_scanner_peek_next_token (scanner) == token)
{
if (! (G_VALUE_HOLDS_OBJECT (&value) &&
(prop_spec->flags & GIMP_CONFIG_PARAM_AGGREGATE)))
g_object_set_property (G_OBJECT (config), prop_spec->name, &value);
}
#ifdef CONFIG_DEBUG
else
{
g_warning ("%s: couldn't deserialize property %s::%s of type %s",
G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (config)),
prop_spec->name,
g_type_name (prop_spec->value_type));
}
#endif
g_value_unset (&value);
g_scanner_set_scope (scanner, old_scope_id);
return token;
}
static gboolean
gimp_session_info_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
GimpSessionInfo *info = GIMP_SESSION_INFO (config);
GTokenType token;
guint scope_id;
guint old_scope_id;
scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (config));
old_scope_id = g_scanner_set_scope (scanner, scope_id);
g_scanner_scope_add_symbol (scanner, scope_id, "factory-entry",
GINT_TO_POINTER (SESSION_INFO_FACTORY_ENTRY));
g_scanner_scope_add_symbol (scanner, scope_id, "position",
GINT_TO_POINTER (SESSION_INFO_POSITION));
g_scanner_scope_add_symbol (scanner, scope_id, "size",
GINT_TO_POINTER (SESSION_INFO_SIZE));
g_scanner_scope_add_symbol (scanner, scope_id, "monitor",
GINT_TO_POINTER (SESSION_INFO_MONITOR));
g_scanner_scope_add_symbol (scanner, scope_id, "open-on-exit",
GINT_TO_POINTER (SESSION_INFO_OPEN));
g_scanner_scope_add_symbol (scanner, scope_id, "aux-info",
GINT_TO_POINTER (SESSION_INFO_AUX));
g_scanner_scope_add_symbol (scanner, scope_id, "gimp-dock",
GINT_TO_POINTER (SESSION_INFO_GIMP_DOCK));
g_scanner_scope_add_symbol (scanner, scope_id, "gimp-toolbox",
GINT_TO_POINTER (SESSION_INFO_GIMP_TOOLBOX));
/* For sessionrc files from version <= GIMP 2.6 */
g_scanner_scope_add_symbol (scanner, scope_id, "dock",
GINT_TO_POINTER (SESSION_INFO_DOCK));
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
gint dummy;
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
switch (GPOINTER_TO_INT (scanner->value.v_symbol))
{
case SESSION_INFO_FACTORY_ENTRY:
{
gchar *identifier = NULL;
GimpDialogFactoryEntry *entry = NULL;
token = G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &identifier))
goto error;
entry = gimp_dialog_factory_find_entry (gimp_dialog_factory_get_singleton (),
identifier);
if (! entry)
goto error;
gimp_session_info_set_factory_entry (info, entry);
g_free (identifier);
}
break;
case SESSION_INFO_POSITION:
token = G_TOKEN_INT;
if (! gimp_session_info_parse_offset (scanner,
&info->p->x,
&info->p->right_align))
goto error;
if (! gimp_session_info_parse_offset (scanner,
&info->p->y,
&info->p->bottom_align))
goto error;
break;
case SESSION_INFO_SIZE:
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &info->p->width))
goto error;
if (! gimp_scanner_parse_int (scanner, &info->p->height))
goto error;
break;
case SESSION_INFO_MONITOR:
token = G_TOKEN_INT;
if (gimp_scanner_parse_int (scanner, &dummy))
{
info->p->monitor =
gdk_display_get_monitor (gdk_display_get_default (), dummy);
}
else
goto error;
break;
case SESSION_INFO_OPEN:
info->p->open = TRUE;
/* the screen number is optional, and obsolete */
if (g_scanner_peek_next_token (scanner) == G_TOKEN_RIGHT_PAREN)
break;
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &dummy))
goto error;
break;
case SESSION_INFO_AUX:
token = gimp_session_info_aux_deserialize (scanner,
&info->p->aux_info);
if (token != G_TOKEN_LEFT_PAREN)
goto error;
break;
case SESSION_INFO_GIMP_TOOLBOX:
case SESSION_INFO_GIMP_DOCK:
case SESSION_INFO_DOCK:
{
GimpSessionInfoDock *dock_info = NULL;
const gchar *dock_type = NULL;
/* Handle old sessionrc:s from versions <= GIMP 2.6 */
if (GPOINTER_TO_INT (scanner->value.v_symbol) == SESSION_INFO_DOCK &&
info->p->factory_entry &&
info->p->factory_entry->identifier &&
strcmp ("gimp-toolbox-window",
info->p->factory_entry->identifier) == 0)
{
dock_type = "gimp-toolbox";
}
else
{
dock_type = ((GPOINTER_TO_INT (scanner->value.v_symbol) ==
SESSION_INFO_GIMP_TOOLBOX) ?
"gimp-toolbox" :
"gimp-dock");
}
g_scanner_set_scope (scanner, scope_id + 1);
token = gimp_session_info_dock_deserialize (scanner, scope_id + 1,
&dock_info,
dock_type);
if (token == G_TOKEN_LEFT_PAREN)
{
g_scanner_set_scope (scanner, scope_id);
info->p->docks = g_list_append (info->p->docks, dock_info);
}
else
goto error;
}
break;
default:
break;
}
token = G_TOKEN_RIGHT_PAREN;
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default:
break;
}
}
error:
/* If we don't have docks, assume it is a toolbox dock window from a
* sessionrc file from GIMP <= 2.6 and add a toolbox dock manually
*/
if (! info->p->docks &&
info->p->factory_entry &&
strcmp ("gimp-toolbox-window",
info->p->factory_entry->identifier) == 0)
{
info->p->docks =
g_list_append (info->p->docks,
gimp_session_info_dock_new ("gimp-toolbox"));
}
g_scanner_scope_remove_symbol (scanner, scope_id, "factory-entry");
g_scanner_scope_remove_symbol (scanner, scope_id, "position");
g_scanner_scope_remove_symbol (scanner, scope_id, "size");
g_scanner_scope_remove_symbol (scanner, scope_id, "open-on-exit");
g_scanner_scope_remove_symbol (scanner, scope_id, "aux-info");
g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-dock");
g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-toolbox");
g_scanner_scope_remove_symbol (scanner, scope_id, "dock");
g_scanner_set_scope (scanner, old_scope_id);
return gimp_config_deserialize_return (scanner, token, nest_level);
}
GSList *
plug_in_rc_parse (Gimp *gimp,
GFile *file,
GError **error)
{
GScanner *scanner;
GEnumClass *enum_class;
GSList *plug_in_defs = NULL;
gint protocol_version = GIMP_PROTOCOL_VERSION;
gint file_version = PLUG_IN_RC_FILE_VERSION;
GTokenType token;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
scanner = gimp_scanner_new_gfile (file, error);
if (! scanner)
return NULL;
enum_class = g_type_class_ref (GIMP_TYPE_ICON_TYPE);
g_scanner_scope_add_symbol (scanner, 0,
"protocol-version",
GINT_TO_POINTER (PROTOCOL_VERSION));
g_scanner_scope_add_symbol (scanner, 0,
"file-version",
GINT_TO_POINTER (FILE_VERSION));
g_scanner_scope_add_symbol (scanner, 0,
"plug-in-def", GINT_TO_POINTER (PLUG_IN_DEF));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"proc-def", GINT_TO_POINTER (PROC_DEF));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"locale-def", GINT_TO_POINTER (LOCALE_DEF));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"help-def", GINT_TO_POINTER (HELP_DEF));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"has-init", GINT_TO_POINTER (HAS_INIT));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"proc-arg", GINT_TO_POINTER (PROC_ARG));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"menu-path", GINT_TO_POINTER (MENU_PATH));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"icon", GINT_TO_POINTER (ICON));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"load-proc", GINT_TO_POINTER (LOAD_PROC));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"save-proc", GINT_TO_POINTER (SAVE_PROC));
g_scanner_scope_add_symbol (scanner, LOAD_PROC,
"extension", GINT_TO_POINTER (EXTENSION));
g_scanner_scope_add_symbol (scanner, LOAD_PROC,
"prefix", GINT_TO_POINTER (PREFIX));
g_scanner_scope_add_symbol (scanner, LOAD_PROC,
"magic", GINT_TO_POINTER (MAGIC));
g_scanner_scope_add_symbol (scanner, LOAD_PROC,
"mime-type", GINT_TO_POINTER (MIME_TYPE));
g_scanner_scope_add_symbol (scanner, LOAD_PROC,
"handles-uri", GINT_TO_POINTER (HANDLES_URI));
g_scanner_scope_add_symbol (scanner, LOAD_PROC,
"thumb-loader", GINT_TO_POINTER (THUMB_LOADER));
g_scanner_scope_add_symbol (scanner, SAVE_PROC,
"extension", GINT_TO_POINTER (EXTENSION));
g_scanner_scope_add_symbol (scanner, SAVE_PROC,
"prefix", GINT_TO_POINTER (PREFIX));
g_scanner_scope_add_symbol (scanner, SAVE_PROC,
"mime-type", GINT_TO_POINTER (MIME_TYPE));
g_scanner_scope_add_symbol (scanner, SAVE_PROC,
"handles-uri", GINT_TO_POINTER (HANDLES_URI));
token = G_TOKEN_LEFT_PAREN;
while (protocol_version == GIMP_PROTOCOL_VERSION &&
file_version == PLUG_IN_RC_FILE_VERSION &&
g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
switch (GPOINTER_TO_INT (scanner->value.v_symbol))
{
case PROTOCOL_VERSION:
token = G_TOKEN_INT;
if (gimp_scanner_parse_int (scanner, &protocol_version))
token = G_TOKEN_RIGHT_PAREN;
break;
case FILE_VERSION:
token = G_TOKEN_INT;
if (gimp_scanner_parse_int (scanner, &file_version))
token = G_TOKEN_RIGHT_PAREN;
break;
case PLUG_IN_DEF:
g_scanner_set_scope (scanner, PLUG_IN_DEF);
token = plug_in_def_deserialize (gimp, scanner, &plug_in_defs);
g_scanner_set_scope (scanner, 0);
break;
default:
break;
}
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default: /* do nothing */
break;
}
}
if (protocol_version != GIMP_PROTOCOL_VERSION ||
file_version != PLUG_IN_RC_FILE_VERSION ||
token != G_TOKEN_LEFT_PAREN)
{
if (protocol_version != GIMP_PROTOCOL_VERSION)
{
g_set_error (error,
GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_VERSION,
_("Skipping '%s': wrong GIMP protocol version."),
gimp_file_get_utf8_name (file));
}
else if (file_version != PLUG_IN_RC_FILE_VERSION)
{
g_set_error (error,
GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_VERSION,
_("Skipping '%s': wrong pluginrc file format version."),
gimp_file_get_utf8_name (file));
}
else
{
g_scanner_get_next_token (scanner);
g_scanner_unexp_token (scanner, token, NULL, NULL, NULL,
_("fatal parse error"), TRUE);
}
g_slist_free_full (plug_in_defs, (GDestroyNotify) g_object_unref);
plug_in_defs = NULL;
}
g_type_class_unref (enum_class);
gimp_scanner_destroy (scanner);
return g_slist_reverse (plug_in_defs);
}
static guint
dawati_rc_style_parse (GtkRcStyle *rc_style,
GtkSettings *settings,
GScanner *scanner)
{
GTokenType token;
static GQuark scope_id;
guint old_scope;
int i;
DawatiRcStyle *mb_style = DAWATI_RC_STYLE (rc_style);
if (!scope_id)
scope_id = g_quark_from_string ("dawati-gtk-engine");
/* set the new scope and store the old scope id */
old_scope = g_scanner_set_scope (scanner, scope_id);
/* register the symbols if we haven't already done so */
if (!g_scanner_lookup_symbol (scanner, dawati_rc_symbols[0].name))
{
for (i = 0; dawati_rc_symbols[i].name; i++)
{
g_scanner_scope_add_symbol (scanner,
scope_id,
dawati_rc_symbols[i].name,
GINT_TO_POINTER (dawati_rc_symbols[i].
token));
}
}
token = g_scanner_peek_next_token (scanner);
while (token != G_TOKEN_RIGHT_CURLY)
{
switch (token)
{
case TOKEN_BORDER_COLOR:
token = dawati_parse_border_color (scanner, mb_style);
break;
case TOKEN_RADIUS:
g_scanner_get_next_token (scanner);
token = dawati_get_token (scanner, G_TOKEN_EQUAL_SIGN);
if (token != G_TOKEN_NONE)
break;
token = dawati_get_token (scanner, G_TOKEN_INT);
if (token != G_TOKEN_NONE)
break;
mb_style->radius = scanner->value.v_int;
break;
case TOKEN_SHADOW:
g_scanner_get_next_token (scanner);
token = dawati_get_token (scanner, G_TOKEN_EQUAL_SIGN);
if (token != G_TOKEN_NONE)
break;
token = dawati_get_token (scanner, G_TOKEN_FLOAT);
if (token != G_TOKEN_NONE)
break;
mb_style->shadow = scanner->value.v_float;
mb_style->shadow_set = TRUE;
break;
default:
g_scanner_get_next_token (scanner);
token = G_TOKEN_RIGHT_CURLY;
break;
}
if (token != G_TOKEN_NONE)
{
return token;
}
token = g_scanner_peek_next_token (scanner);
}
g_scanner_get_next_token (scanner);
g_scanner_set_scope (scanner, old_scope);
return G_TOKEN_NONE;
}
static guint
dwerg_rc_style_parse(GtkRcStyle *rc_style,
GtkSettings *settings,
GScanner* scanner)
{
static GQuark scope_id = 0;
DwergRcStyle *theme_data = DWERG_RC_STYLE(rc_style);
theme_data->shadow_color_from = malloc(sizeof(GdkColor));
theme_data->shadow_color_to = malloc(sizeof(GdkColor));
guint old_scope;
guint token;
guint i;
/* setup scope, safe old_scope for crash, define tokens */
if (!scope_id)
scope_id = g_quark_from_string("dwerg_theme_engine");
old_scope = g_scanner_set_scope(scanner, scope_id);
if (!g_scanner_lookup_symbol(scanner, theme_symbols[0].name))
{
g_scanner_freeze_symbol_table(scanner);
for (i = 0; i < G_N_ELEMENTS(theme_symbols); i++)
g_scanner_scope_add_symbol(scanner, scope_id,
theme_symbols[i].name,
GINT_TO_POINTER(theme_symbols[i].token));
g_scanner_thaw_symbol_table(scanner);
}
token = g_scanner_peek_next_token(scanner);
while (token != G_TOKEN_RIGHT_CURLY)
{
switch(token)
{
case TOKEN_SHADOW_COLOR_FROM:
g_print("vla\n");
token = g_scanner_get_next_token(scanner);
if (token != TOKEN_SHADOW_COLOR_FROM)
return token;
token = g_scanner_get_next_token(scanner);
if (token != G_TOKEN_EQUAL_SIGN)
return token;
token = gtk_rc_parse_color(scanner,
theme_data->shadow_color_from);
g_print("ja lekker\n");
break;
case TOKEN_SHADOW_COLOR_TO:
token = g_scanner_get_next_token(scanner);
if (token != TOKEN_SHADOW_COLOR_TO)
return token;
token = g_scanner_get_next_token(scanner);
if (token != G_TOKEN_EQUAL_SIGN)
return token;
token = gtk_rc_parse_color(scanner,
theme_data->shadow_color_to);
break;
default:
g_scanner_get_next_token(scanner);
token = G_TOKEN_RIGHT_CURLY;
break;
}
if (token != G_TOKEN_NONE) {
g_free(theme_data);
return token;
}
token = g_scanner_peek_next_token(scanner);
}
/* on no error reset the scope */
g_scanner_get_next_token(scanner);
g_scanner_set_scope(scanner, old_scope);
return G_TOKEN_NONE;
}
static guint
clearlooks_rc_style_parse (GtkRcStyle *rc_style,
GtkSettings *settings,
GScanner *scanner)
{
static GQuark scope_id = 0;
ClearlooksRcStyle *clearlooks_style = CLEARLOOKS_RC_STYLE (rc_style);
guint old_scope;
guint token;
/* Set up a new scope in this scanner. */
if (!scope_id)
scope_id = g_quark_from_string("clearlooks_theme_engine");
/* If we bail out due to errors, we *don't* reset the scope, so the
* error messaging code can make sense of our tokens.
*/
old_scope = g_scanner_set_scope(scanner, scope_id);
/* Now check if we already added our symbols to this scope
* (in some previous call to clearlooks_rc_style_parse for the
* same scanner.
*/
if (!g_scanner_lookup_symbol(scanner, clearlooks_rc_symbols)) {
gchar *current_symbol = clearlooks_rc_symbols;
gint i = G_TOKEN_LAST + 1;
/* Add our symbols */
while ((current_symbol[0] != '\0') && (i < TOKEN_LAST)) {
g_scanner_scope_add_symbol(scanner, scope_id, current_symbol, GINT_TO_POINTER (i));
current_symbol += strlen(current_symbol) + 1;
i++;
}
g_assert (i == TOKEN_LAST && current_symbol[0] == '\0');
}
/* We're ready to go, now parse the top level */
token = g_scanner_peek_next_token(scanner);
while (token != G_TOKEN_RIGHT_CURLY)
{
switch (token)
{
case TOKEN_FOCUSCOLOR:
token = clearlooks_gtk2_rc_parse_color (settings, scanner, rc_style, &clearlooks_style->focus_color);
clearlooks_style->flags |= CL_FLAG_FOCUS_COLOR;
break;
case TOKEN_SCROLLBARCOLOR:
token = clearlooks_gtk2_rc_parse_color (settings, scanner, rc_style, &clearlooks_style->scrollbar_color);
clearlooks_style->flags |= CL_FLAG_SCROLLBAR_COLOR;
break;
case TOKEN_COLORIZESCROLLBAR:
token = clearlooks_gtk2_rc_parse_boolean (settings, scanner, &clearlooks_style->colorize_scrollbar);
clearlooks_style->flags |= CL_FLAG_COLORIZE_SCROLLBAR;
break;
case TOKEN_CONTRAST:
token = clearlooks_gtk2_rc_parse_double (settings, scanner, &clearlooks_style->contrast);
clearlooks_style->flags |= CL_FLAG_CONTRAST;
break;
case TOKEN_RELIEFSTYLE:
token = clearlooks_gtk2_rc_parse_int (settings, scanner, &clearlooks_style->reliefstyle);
clearlooks_style->flags |= CL_FLAG_RELIEFSTYLE;
break;
case TOKEN_MENUBARSTYLE:
token = clearlooks_gtk2_rc_parse_int (settings, scanner, &clearlooks_style->menubarstyle);
clearlooks_style->flags |= CL_FLAG_MENUBARSTYLE;
break;
case TOKEN_TOOLBARSTYLE:
token = clearlooks_gtk2_rc_parse_int (settings, scanner, &clearlooks_style->toolbarstyle);
clearlooks_style->flags |= CL_FLAG_TOOLBARSTYLE;
break;
case TOKEN_ANIMATION:
token = clearlooks_gtk2_rc_parse_boolean (settings, scanner, &clearlooks_style->animation);
clearlooks_style->flags |= CL_FLAG_ANIMATION;
break;
case TOKEN_STYLE:
token = clearlooks_gtk2_rc_parse_style (settings, scanner, &clearlooks_style->style);
clearlooks_style->flags |= CL_FLAG_STYLE;
break;
case TOKEN_RADIUS:
token = clearlooks_gtk2_rc_parse_double (settings, scanner, &clearlooks_style->radius);
clearlooks_style->flags |= CL_FLAG_RADIUS;
break;
case TOKEN_HINT:
token = ge_rc_parse_hint (scanner, &clearlooks_style->hint);
clearlooks_style->flags |= CL_FLAG_HINT;
break;
case TOKEN_DISABLE_FOCUS:
token = clearlooks_gtk2_rc_parse_boolean (settings, scanner, &clearlooks_style->disable_focus);
clearlooks_style->flags |= CL_FLAG_DISABLE_FOCUS;
break;
/* stuff to ignore */
case TOKEN_SUNKENMENU:
token = clearlooks_gtk2_rc_parse_dummy (settings, scanner, "sunkenmenu");
break;
case TOKEN_PROGRESSBARSTYLE:
token = clearlooks_gtk2_rc_parse_dummy (settings, scanner, "progressbarstyle");
break;
case TOKEN_MENUITEMSTYLE:
token = clearlooks_gtk2_rc_parse_dummy (settings, scanner, "menuitemstyle");
break;
case TOKEN_LISTVIEWITEMSTYLE:
token = clearlooks_gtk2_rc_parse_dummy (settings, scanner, "listviewitemstyle");
break;
default:
g_scanner_get_next_token(scanner);
token = G_TOKEN_RIGHT_CURLY;
break;
}
if (token != G_TOKEN_NONE)
return token;
token = g_scanner_peek_next_token(scanner);
}
g_scanner_get_next_token(scanner);
g_scanner_set_scope(scanner, old_scope);
return G_TOKEN_NONE;
}
void
session_init (Gimp *gimp)
{
gchar *filename;
GScanner *scanner;
GTokenType token;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
filename = session_filename (gimp);
scanner = gimp_scanner_new_file (filename, &error);
if (! scanner && error->code == GIMP_CONFIG_ERROR_OPEN_ENOENT)
{
g_clear_error (&error);
g_free (filename);
filename = g_build_filename (gimp_sysconf_directory (),
"sessionrc", NULL);
scanner = gimp_scanner_new_file (filename, NULL);
}
if (! scanner)
{
g_clear_error (&error);
g_free (filename);
return;
}
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename));
g_scanner_scope_add_symbol (scanner, 0, "session-info",
GINT_TO_POINTER (SESSION_INFO));
g_scanner_scope_add_symbol (scanner, 0, "last-tip-shown",
GINT_TO_POINTER (LAST_TIP_SHOWN));
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
if (scanner->value.v_symbol == GINT_TO_POINTER (SESSION_INFO))
{
g_scanner_set_scope (scanner, SESSION_INFO);
token = gimp_session_info_deserialize (scanner, SESSION_INFO);
if (token == G_TOKEN_RIGHT_PAREN)
g_scanner_set_scope (scanner, 0);
else
break;
}
else if (scanner->value.v_symbol == GINT_TO_POINTER (LAST_TIP_SHOWN))
{
GimpGuiConfig *config = GIMP_GUI_CONFIG (gimp->config);
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &config->last_tip))
break;
}
token = G_TOKEN_RIGHT_PAREN;
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default: /* do nothing */
break;
}
}
if (token != G_TOKEN_LEFT_PAREN)
{
g_scanner_get_next_token (scanner);
g_scanner_unexp_token (scanner, token, NULL, NULL, NULL,
_("fatal parse error"), TRUE);
}
if (error)
{
gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR, "%s", error->message);
g_clear_error (&error);
gimp_config_file_backup_on_error (filename, "sessionrc", NULL);
}
gimp_scanner_destroy (scanner);
g_free (filename);
}
static gchar* parse_name (GScanner *scanner)
{
GTokenType token;
guint buttons = 0;
guint modifier = 0;
guint len = 0;
gchar *name;
token = g_scanner_cur_token(scanner);
if (token != G_TOKEN_STRING)
{
g_scanner_unexp_token (scanner, G_TOKEN_STRING, NULL,
NULL, NULL, "aborting", TRUE);
exit (1);
}
len = strlen (scanner->value.v_string);
name = g_strndup (scanner->value.v_string, len + 3);
token = g_scanner_get_next_token (scanner);
/*
* Are there any options to limit the scope of the definition?
*/
if (token == G_TOKEN_LEFT_BRACE)
{
g_scanner_set_scope (scanner, 1);
scanner->config->int_2_float = 0;
modifier = buttons = 0;
while ((token = g_scanner_get_next_token (scanner))
!= G_TOKEN_RIGHT_BRACE)
{
if (token == G_TOKEN_SYMBOL)
{
if ((intptr_t) scanner->value.v_symbol < 11)
buttons |= 1 << ((intptr_t) scanner->value.v_symbol - 1);
else
modifier |= 1 << ((intptr_t) scanner->value.v_symbol - 11);
}
else if (token == G_TOKEN_INT)
{
if (scanner->value.v_int <= 5 && scanner->value.v_int > 0)
buttons |= 1 << (scanner->value.v_int - 1);
else
g_printerr ("Only Buttons 1-5 are supported!\n");
}
else
{
g_printerr ("skipped token\n");
}
}
g_scanner_set_scope (scanner, 0);
scanner->config->int_2_float = 1;
token = g_scanner_get_next_token (scanner);
}
name [len] = 124;
name [len+1] = buttons + 64;
name [len+2] = modifier + 48;
name [len+3] = 0;
return name;
}
void parse_config (GromitData *data)
{
GromitPaintContext *context=NULL;
GromitPaintContext *context_template=NULL;
GScanner *scanner;
GTokenType token;
gchar *filename;
int file;
gchar *name, *copy;
GromitPaintType type;
GdkRGBA *fg_color=NULL;
guint width, arrowsize, minwidth;
filename = g_strjoin (G_DIR_SEPARATOR_S,
g_get_user_config_dir(), "gromit-mpx.cfg", NULL);
file = open (filename, O_RDONLY);
if (file < 0)
{
g_printerr ("Could not open %s: %s\n", filename, g_strerror (errno));
/* try global config file */
g_free (filename);
filename = g_strdup ("/etc/gromit-mpx/gromit-mpx.cfg");
file = open (filename, O_RDONLY);
if (file < 0)
{
g_printerr ("Could not open %s: %s\n", filename, g_strerror (errno));
g_free (filename);
return;
}
}
scanner = g_scanner_new (NULL);
scanner->input_name = filename;
scanner->config->case_sensitive = 0;
scanner->config->scan_octal = 0;
scanner->config->identifier_2_string = 0;
scanner->config->char_2_token = 1;
scanner->config->numbers_2_int = 1;
scanner->config->int_2_float = 1;
g_scanner_scope_add_symbol (scanner, 0, "PEN", (gpointer) GROMIT_PEN);
g_scanner_scope_add_symbol (scanner, 0, "ERASER", (gpointer) GROMIT_ERASER);
g_scanner_scope_add_symbol (scanner, 0, "RECOLOR",(gpointer) GROMIT_RECOLOR);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON1", (gpointer) 1);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON2", (gpointer) 2);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON3", (gpointer) 3);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON4", (gpointer) 4);
g_scanner_scope_add_symbol (scanner, 1, "BUTTON5", (gpointer) 5);
g_scanner_scope_add_symbol (scanner, 1, "SHIFT", (gpointer) 11);
g_scanner_scope_add_symbol (scanner, 1, "CONTROL", (gpointer) 12);
g_scanner_scope_add_symbol (scanner, 1, "META", (gpointer) 13);
g_scanner_scope_add_symbol (scanner, 1, "ALT", (gpointer) 13);
g_scanner_scope_add_symbol (scanner, 2, "size", (gpointer) 1);
g_scanner_scope_add_symbol (scanner, 2, "color", (gpointer) 2);
g_scanner_scope_add_symbol (scanner, 2, "arrowsize", (gpointer) 3);
g_scanner_scope_add_symbol (scanner, 2, "minsize", (gpointer) 4);
g_scanner_set_scope (scanner, 0);
scanner->config->scope_0_fallback = 0;
g_scanner_input_file (scanner, file);
token = g_scanner_get_next_token (scanner);
while (token != G_TOKEN_EOF)
{
/*
* New tool definition
*/
if (token == G_TOKEN_STRING)
{
name = parse_name (scanner);
token = g_scanner_cur_token(scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_scanner_unexp_token (scanner, G_TOKEN_EQUAL_SIGN, NULL,
NULL, NULL, "aborting", TRUE);
exit (1);
}
token = g_scanner_get_next_token (scanner);
/* defaults */
type = GROMIT_PEN;
width = 7;
arrowsize = 0;
minwidth = 1;
fg_color = data->red;
if (token == G_TOKEN_SYMBOL)
{
type = (GromitPaintType) scanner->value.v_symbol;
token = g_scanner_get_next_token (scanner);
}
else if (token == G_TOKEN_STRING)
{
copy = parse_name (scanner);
token = g_scanner_cur_token(scanner);
context_template = g_hash_table_lookup (data->tool_config, copy);
if (context_template)
{
type = context_template->type;
width = context_template->width;
arrowsize = context_template->arrowsize;
minwidth = context_template->minwidth;
fg_color = context_template->paint_color;
}
else
{
g_printerr ("WARNING: Unable to copy \"%s\": "
"not yet defined!\n", copy);
}
}
else
{
g_printerr ("Expected Tool-definition "
"or name of template tool\n");
exit (1);
}
/* Are there any tool-options?
*/
if (token == G_TOKEN_LEFT_PAREN)
{
GdkRGBA *color = NULL;
g_scanner_set_scope (scanner, 2);
scanner->config->int_2_float = 1;
token = g_scanner_get_next_token (scanner);
while (token != G_TOKEN_RIGHT_PAREN)
{
if (token == G_TOKEN_SYMBOL)
{
if ((intptr_t) scanner->value.v_symbol == 1)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_FLOAT)
{
g_printerr ("Missing Size (float)... aborting\n");
exit (1);
}
width = (guint) (scanner->value.v_float + 0.5);
}
else if ((intptr_t) scanner->value.v_symbol == 2)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_STRING)
{
g_printerr ("Missing Color (string)... "
"aborting\n");
exit (1);
}
color = g_malloc (sizeof (GdkRGBA));
if (gdk_rgba_parse (color, scanner->value.v_string))
{
fg_color = color;
}
else
{
g_printerr ("Unable to parse color. "
"Keeping default.\n");
g_free (color);
}
color = NULL;
}
else if ((intptr_t) scanner->value.v_symbol == 3)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_FLOAT)
{
g_printerr ("Missing Arrowsize (float)... "
"aborting\n");
exit (1);
}
arrowsize = scanner->value.v_float;
}
else if ((intptr_t) scanner->value.v_symbol == 4)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_EQUAL_SIGN)
{
g_printerr ("Missing \"=\"... aborting\n");
exit (1);
}
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_FLOAT)
{
g_printerr ("Missing Minsize (float)... "
"aborting\n");
exit (1);
}
minwidth = scanner->value.v_float;
}
else
{
g_printerr ("Unknown tool type?????\n");
}
}
else
{
g_printerr ("skipped token!!!\n");
}
token = g_scanner_get_next_token (scanner);
}
g_scanner_set_scope (scanner, 0);
token = g_scanner_get_next_token (scanner);
}
/*
* Finally we expect a semicolon
*/
if (token != ';')
{
g_printerr ("Expected \";\"\n");
exit (1);
}
context = paint_context_new (data, type, fg_color, width, arrowsize, minwidth);
g_hash_table_insert (data->tool_config, name, context);
}
else
{
g_printerr ("Expected name of Tool to define\n");
exit(1);
}
token = g_scanner_get_next_token (scanner);
}
g_scanner_destroy (scanner);
close (file);
g_free (filename);
}
static guint
rsvg_rc_style_parse (GtkRcStyle *rc_style,
GtkSettings *settings,
GScanner *scanner)
{
static GQuark scope_id = 0;
RsvgRcStyle *rsvg_style = RSVG_RC_STYLE (rc_style);
guint old_scope;
guint token;
guint i;
ThemeImage *img;
/* Set up a new scope in this scanner. */
if (!scope_id)
scope_id = g_quark_from_string("rsvg_theme_engine");
/* If we bail out due to errors, we *don't* reset the scope, so the
* error messaging code can make sense of our tokens.
*/
old_scope = g_scanner_set_scope(scanner, scope_id);
/* Now check if we already added our symbols to this scope
* (in some previous call to theme_parse_rc_style for the
* same scanner.
*/
if (!g_scanner_lookup_symbol(scanner, theme_symbols[0].name))
{
for (i = 0; i < G_N_ELEMENTS (theme_symbols); i++)
g_scanner_scope_add_symbol(scanner, scope_id,
theme_symbols[i].name,
GINT_TO_POINTER(theme_symbols[i].token));
}
/* We're ready to go, now parse the top level */
token = g_scanner_peek_next_token(scanner);
while (token != G_TOKEN_RIGHT_CURLY)
{
switch (token)
{
case TOKEN_IMAGE:
img = NULL;
token = theme_parse_image(settings, scanner, rsvg_style, &img);
break;
default:
g_scanner_get_next_token(scanner);
token = G_TOKEN_RIGHT_CURLY;
break;
}
if (token != G_TOKEN_NONE)
return token;
else
rsvg_style->img_list = g_list_append(rsvg_style->img_list, img);
token = g_scanner_peek_next_token(scanner);
}
g_scanner_get_next_token(scanner);
g_scanner_set_scope(scanner, old_scope);
return G_TOKEN_NONE;
}
GTokenType
gimp_session_info_dock_deserialize (GScanner *scanner,
gint scope,
GimpSessionInfoDock **dock_info,
const gchar *dock_type)
{
GTokenType token;
g_return_val_if_fail (scanner != NULL, G_TOKEN_LEFT_PAREN);
g_return_val_if_fail (dock_info != NULL, G_TOKEN_LEFT_PAREN);
g_scanner_scope_add_symbol (scanner, scope, "side",
GINT_TO_POINTER (SESSION_INFO_SIDE));
g_scanner_scope_add_symbol (scanner, scope, "position",
GINT_TO_POINTER (SESSION_INFO_POSITION));
g_scanner_scope_add_symbol (scanner, scope, "book",
GINT_TO_POINTER (SESSION_INFO_BOOK));
*dock_info = gimp_session_info_dock_new (dock_type);
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
switch (GPOINTER_TO_INT (scanner->value.v_symbol))
{
GimpSessionInfoBook *book;
case SESSION_INFO_SIDE:
token = G_TOKEN_IDENTIFIER;
if (g_scanner_peek_next_token (scanner) != token)
break;
g_scanner_get_next_token (scanner);
if (strcmp ("left", scanner->value.v_identifier) == 0)
(*dock_info)->side = GIMP_ALIGN_LEFT;
else
(*dock_info)->side = GIMP_ALIGN_RIGHT;
break;
case SESSION_INFO_POSITION:
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &((*dock_info)->position)))
(*dock_info)->position = 0;
break;
case SESSION_INFO_BOOK:
g_scanner_set_scope (scanner, scope + 1);
token = gimp_session_info_book_deserialize (scanner, scope + 1,
&book);
if (token == G_TOKEN_LEFT_PAREN)
{
(*dock_info)->books = g_list_append ((*dock_info)->books, book);
g_scanner_set_scope (scanner, scope);
}
else
return token;
break;
default:
return token;
}
token = G_TOKEN_RIGHT_PAREN;
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default:
break;
}
}
g_scanner_scope_remove_symbol (scanner, scope, "book");
g_scanner_scope_remove_symbol (scanner, scope, "position");
g_scanner_scope_remove_symbol (scanner, scope, "side");
return token;
}
static GTokenType
plug_in_file_proc_deserialize (GScanner *scanner,
GimpPlugInProcedure *proc)
{
GTokenType token;
gint symbol;
gchar *value;
if (! gimp_scanner_parse_token (scanner, G_TOKEN_LEFT_PAREN))
return G_TOKEN_LEFT_PAREN;
if (! gimp_scanner_parse_token (scanner, G_TOKEN_SYMBOL))
return G_TOKEN_SYMBOL;
symbol = GPOINTER_TO_INT (scanner->value.v_symbol);
if (symbol != LOAD_PROC && symbol != SAVE_PROC)
return G_TOKEN_SYMBOL;
proc->file_proc = TRUE;
g_scanner_set_scope (scanner, symbol);
while (g_scanner_peek_next_token (scanner) == G_TOKEN_LEFT_PAREN)
{
token = g_scanner_get_next_token (scanner);
if (token != G_TOKEN_LEFT_PAREN)
return token;
if (! gimp_scanner_parse_token (scanner, G_TOKEN_SYMBOL))
return G_TOKEN_SYMBOL;
symbol = GPOINTER_TO_INT (scanner->value.v_symbol);
if (symbol == MAGIC)
{
if (! gimp_scanner_parse_string_no_validate (scanner, &value))
return G_TOKEN_STRING;
}
else if (symbol != HANDLES_URI)
{
if (! gimp_scanner_parse_string (scanner, &value))
return G_TOKEN_STRING;
}
switch (symbol)
{
case EXTENSION:
g_free (proc->extensions);
proc->extensions = value;
break;
case PREFIX:
g_free (proc->prefixes);
proc->prefixes = value;
break;
case MAGIC:
g_free (proc->magics);
proc->magics = value;
break;
case MIME_TYPE:
gimp_plug_in_procedure_set_mime_type (proc, value);
g_free (value);
break;
case HANDLES_URI:
gimp_plug_in_procedure_set_handles_uri (proc);
break;
case THUMB_LOADER:
gimp_plug_in_procedure_set_thumb_loader (proc, value);
g_free (value);
break;
default:
return G_TOKEN_SYMBOL;
}
if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN))
return G_TOKEN_RIGHT_PAREN;
}
if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN))
return G_TOKEN_RIGHT_PAREN;
g_scanner_set_scope (scanner, PLUG_IN_DEF);
return G_TOKEN_LEFT_PAREN;
}
static guint
mgicchikn_rc_style_parse (GtkRcStyle * rc_style,
GtkSettings * settings,
GScanner * scanner)
{
MgicChiknRcStyle *style;
static GQuark scope = 0;
GQuark old_scope;
guint token;
gint i;
g_return_val_if_fail (rc_style != NULL, G_TOKEN_NONE);
g_return_val_if_fail (MGICCHIKN_IS_RC_STYLE (rc_style), G_TOKEN_NONE);
style = MGICCHIKN_RC_STYLE (rc_style);
if (!scope)
scope = g_quark_from_string ("theme_engine");
old_scope = g_scanner_set_scope (scanner, scope);
/* If we don't have the symbol table inside scanner, put it in there */
if (!g_scanner_lookup_symbol (scanner, symbols[0].name))
{
for (i = 0; i < G_N_ELEMENTS (symbols); i++)
{
g_scanner_scope_add_symbol (scanner, scope,
symbols[i].name,
GUINT_TO_POINTER (symbols[i].token));
}
}
token = g_scanner_peek_next_token (scanner);
while (token != G_TOKEN_RIGHT_CURLY)
{
switch (token)
{
case MGICCHIKN_TOKEN_STOCK_IMAGE_TRANSPARENCY:
token = mgicchikn_rc_parse_stock_image_transparency (style, scanner);
break;
case MGICCHIKN_TOKEN_STOCK_IMAGE_SATURATION:
token = mgicchikn_rc_parse_stock_image_saturation (style, scanner);
break;
case MGICCHIKN_TOKEN_STOCK_IMAGE_BRIGHTNESS:
token = mgicchikn_rc_parse_stock_image_brightness (style, scanner);
break;
case MGICCHIKN_TOKEN_SHADOW:
token = mgicchikn_rc_parse_shadow (style, scanner);
break;
case MGICCHIKN_TOKEN_SHADOW_WIDTH:
token = mgicchikn_rc_parse_shadow_width (style, scanner);
break;
case MGICCHIKN_TOKEN_GRIPPY_STYLE:
token = mgicchikn_rc_parse_grippy_style (style, scanner);
break;
case MGICCHIKN_TOKEN_FONT_SHADOW:
token = mgicchikn_rc_parse_font_shadow (style, scanner);
break;
case MGICCHIKN_TOKEN_FONT_UNDERLINE:
token = mgicchikn_rc_parse_font_underline (style, scanner);
break;
case MGICCHIKN_TOKEN_CHECK_IMAGE:
token = mgicchikn_rc_parse_check_image (style, settings, scanner);
break;
case MGICCHIKN_TOKEN_RADIO_IMAGE:
token = mgicchikn_rc_parse_radio_image (style, settings, scanner);
break;
default:
break;
}
if (token != G_TOKEN_NONE)
return token;
token = g_scanner_peek_next_token (scanner);
}
g_scanner_get_next_token (scanner);
g_scanner_set_scope (scanner, old_scope);
return G_TOKEN_NONE;
}
GTokenType
gimp_session_info_book_deserialize (GScanner *scanner,
gint scope,
GimpSessionInfoBook **book)
{
GimpSessionInfoBook *info;
GTokenType token;
g_return_val_if_fail (scanner != NULL, G_TOKEN_LEFT_PAREN);
g_return_val_if_fail (book != NULL, G_TOKEN_LEFT_PAREN);
g_scanner_scope_add_symbol (scanner, scope, "position",
GINT_TO_POINTER (SESSION_INFO_BOOK_POSITION));
g_scanner_scope_add_symbol (scanner, scope, "current-page",
GINT_TO_POINTER (SESSION_INFO_BOOK_CURRENT_PAGE));
g_scanner_scope_add_symbol (scanner, scope, "dockable",
GINT_TO_POINTER (SESSION_INFO_BOOK_DOCKABLE));
info = gimp_session_info_book_new ();
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
switch (GPOINTER_TO_INT (scanner->value.v_symbol))
{
GimpSessionInfoDockable *dockable;
case SESSION_INFO_BOOK_POSITION:
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &info->position))
goto error;
break;
case SESSION_INFO_BOOK_CURRENT_PAGE:
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &info->current_page))
goto error;
break;
case SESSION_INFO_BOOK_DOCKABLE:
g_scanner_set_scope (scanner, scope + 1);
token = gimp_session_info_dockable_deserialize (scanner,
scope + 1,
&dockable);
if (token == G_TOKEN_LEFT_PAREN)
{
info->dockables = g_list_append (info->dockables, dockable);
g_scanner_set_scope (scanner, scope);
}
else
goto error;
break;
default:
goto error;
}
token = G_TOKEN_RIGHT_PAREN;
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default:
break;
}
}
*book = info;
g_scanner_scope_remove_symbol (scanner, scope, "position");
g_scanner_scope_remove_symbol (scanner, scope, "current-page");
g_scanner_scope_remove_symbol (scanner, scope, "dockable");
return token;
error:
*book = NULL;
gimp_session_info_book_free (info);
return token;
}
/**
* gimp_config_deserialize_properties:
* @config: a #GimpConfig.
* @scanner: a #GScanner.
* @nest_level: the nest level
*
* This function uses the @scanner to configure the properties of @config.
*
* Return value: %TRUE on success, %FALSE otherwise.
*
* Since: GIMP 2.4
**/
gboolean
gimp_config_deserialize_properties (GimpConfig *config,
GScanner *scanner,
gint nest_level)
{
GObjectClass *klass;
GParamSpec **property_specs;
guint n_property_specs;
guint i;
guint scope_id;
guint old_scope_id;
GTokenType token;
GTokenType next;
g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE);
klass = G_OBJECT_GET_CLASS (config);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
if (! property_specs)
return TRUE;
scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (config));
old_scope_id = g_scanner_set_scope (scanner, scope_id);
for (i = 0; i < n_property_specs; i++)
{
GParamSpec *prop_spec = property_specs[i];
if (prop_spec->flags & GIMP_CONFIG_PARAM_SERIALIZE)
{
g_scanner_scope_add_symbol (scanner, scope_id,
prop_spec->name, prop_spec);
}
}
g_free (property_specs);
g_object_freeze_notify (G_OBJECT (config));
token = G_TOKEN_LEFT_PAREN;
while (TRUE)
{
next = g_scanner_peek_next_token (scanner);
if (G_UNLIKELY (next != token &&
! (token == G_TOKEN_SYMBOL &&
next == G_TOKEN_IDENTIFIER)))
{
break;
}
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_IDENTIFIER:
token = gimp_config_skip_unknown_property (scanner);
break;
case G_TOKEN_SYMBOL:
token = gimp_config_deserialize_property (config,
scanner, nest_level);
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default: /* do nothing */
break;
}
}
g_scanner_set_scope (scanner, old_scope_id);
g_object_thaw_notify (G_OBJECT (config));
if (token == G_TOKEN_NONE)
return FALSE;
return gimp_config_deserialize_return (scanner, token, nest_level);
}
void
gimp_unitrc_load (Gimp *gimp)
{
GFile *file;
GScanner *scanner;
GTokenType token;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
file = gimp_directory_file ("unitrc", NULL);
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file));
scanner = gimp_scanner_new_gfile (file, &error);
if (! scanner && error->code == GIMP_CONFIG_ERROR_OPEN_ENOENT)
{
g_clear_error (&error);
g_object_unref (file);
file = gimp_sysconf_directory_file ("unitrc", NULL);
scanner = gimp_scanner_new_gfile (file, NULL);
}
if (! scanner)
{
g_clear_error (&error);
g_object_unref (file);
return;
}
g_scanner_scope_add_symbol (scanner, 0,
"unit-info", GINT_TO_POINTER (UNIT_INFO));
g_scanner_scope_add_symbol (scanner, UNIT_INFO,
"factor", GINT_TO_POINTER (UNIT_FACTOR));
g_scanner_scope_add_symbol (scanner, UNIT_INFO,
"digits", GINT_TO_POINTER (UNIT_DIGITS));
g_scanner_scope_add_symbol (scanner, UNIT_INFO,
"symbol", GINT_TO_POINTER (UNIT_SYMBOL));
g_scanner_scope_add_symbol (scanner, UNIT_INFO,
"abbreviation", GINT_TO_POINTER (UNIT_ABBREV));
g_scanner_scope_add_symbol (scanner, UNIT_INFO,
"singular", GINT_TO_POINTER (UNIT_SINGULAR));
g_scanner_scope_add_symbol (scanner, UNIT_INFO,
"plural", GINT_TO_POINTER (UNIT_PLURAL));
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
if (scanner->value.v_symbol == GINT_TO_POINTER (UNIT_INFO))
{
g_scanner_set_scope (scanner, UNIT_INFO);
token = gimp_unitrc_unit_info_deserialize (scanner, gimp);
if (token == G_TOKEN_RIGHT_PAREN)
g_scanner_set_scope (scanner, 0);
}
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default: /* do nothing */
break;
}
}
if (token != G_TOKEN_LEFT_PAREN)
{
g_scanner_get_next_token (scanner);
g_scanner_unexp_token (scanner, token, NULL, NULL, NULL,
_("fatal parse error"), TRUE);
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message);
g_clear_error (&error);
gimp_config_file_backup_on_error (file, "unitrc", NULL);
}
gimp_scanner_destroy (scanner);
g_object_unref (file);
}
static guint
thinice_rc_style_parse (GtkRcStyle *rc_style,
GtkSettings *settings,
GScanner *scanner)
{
static GQuark scope_id = 0;
ThiniceRcStyle *theme_data = THINICE_RC_STYLE (rc_style);
guint old_scope;
guint token;
guint i;
/* Set up a new scope in this scanner. */
/*
g_print("theme_parse_rc_style(\"%s\")\n", rc_style->name);
*/
if (!scope_id)
scope_id = g_quark_from_string("theme_engine");
/* If we bail out due to errors, we *don't* reset the scope, so the
* error messaging code can make sense of our tokens.
*/
old_scope = g_scanner_set_scope(scanner, scope_id);
/* Now check if we already added our symbols to this scope
* (in some previous call to theme_parse_rc_style for the
* same scanner.
*/
if (!g_scanner_lookup_symbol(scanner, theme_symbols[0].name))
{
g_scanner_freeze_symbol_table(scanner);
for (i = 0; i < n_theme_symbols; i++)
{
g_scanner_scope_add_symbol(scanner, scope_id,
theme_symbols[i].name,
GINT_TO_POINTER(theme_symbols[i].token));
}
g_scanner_thaw_symbol_table(scanner);
}
/* We're ready to go, now parse the top level */
/* theme_data = g_new0(ThiniceRcStyle, 1); */
theme_data->scrollbar_type = DEFAULT_SCROLLSHAPE;
theme_data->scrollbar_marks = DEFAULT_SCROLLBARMARKS;
theme_data->scroll_button_marks = DEFAULT_SCROLLBUTTONMARKS;
theme_data->handlebox_marks = DEFAULT_HANDLEBOXMARKS;
theme_data->mark_type1 = DEFAULT_MARKTYPE1;
theme_data->mark_type2 = DEFAULT_MARKTYPE2;
token = g_scanner_peek_next_token(scanner);
while (token != G_TOKEN_RIGHT_CURLY)
{
switch (token)
{
case TOKEN_RECTSCROLLBAR:
token = theme_parse_boolean(scanner, TOKEN_RECTSCROLLBAR, &i);
if (token != G_TOKEN_NONE)
break;
if (i == FALSE)
theme_data->scrollbar_type = SCROLL_SHAPED;
else
theme_data->scrollbar_type = SCROLL_RECT;
break;
case TOKEN_SCROLLBUTTONMARKS:
token = theme_parse_boolean(scanner, TOKEN_SCROLLBUTTONMARKS, &i);
if (token != G_TOKEN_NONE)
break;
if (i == TRUE)
theme_data->mark_type2 = MARKS_SLASH;
else
theme_data->mark_type2 = MARKS_NOTHING;
/*
if (i == TRUE)
theme_data->scroll_button_marks = MARKS_ON;
else
theme_data->scroll_button_marks = MARKS_OFF;
*/
break;
case TOKEN_SCROLLBARMARKS:
token = theme_parse_boolean(scanner, TOKEN_SCROLLBARMARKS, &i);
if (token != G_TOKEN_NONE)
break;
if (i == TRUE)
theme_data->mark_type1 = MARKS_SLASH;
else
theme_data->mark_type1 = MARKS_NOTHING;
/*
if (i == TRUE)
theme_data->scrollbar_marks = MARKS_ON;
else
theme_data->scrollbar_marks = MARKS_OFF;
*/
break;
case TOKEN_HANDLEBOXMARKS:
token = theme_parse_boolean(scanner, TOKEN_HANDLEBOXMARKS, &i);
if (token != G_TOKEN_NONE)
break;
if (i == TRUE)
theme_data->handlebox_marks = MARKS_ON;
else
theme_data->handlebox_marks = MARKS_OFF;
break;
case TOKEN_MARKTYPE1:
token = theme_parse_marktype(scanner, TOKEN_MARKTYPE1, &i);
if (token != G_TOKEN_NONE)
break;
theme_data->mark_type1 = i;
break;
case TOKEN_MARKTYPE2:
token = theme_parse_marktype(scanner, TOKEN_MARKTYPE2, &i);
if (token != G_TOKEN_NONE)
break;
theme_data->mark_type2 = i;
break;
case TOKEN_PANEDDOTS:
token = theme_parse_paned(scanner, TOKEN_PANEDDOTS, &i);
if (token != G_TOKEN_NONE)
break;
theme_data->paned_dots = i;
break;
default:
g_scanner_get_next_token(scanner);
token = G_TOKEN_RIGHT_CURLY;
break;
}
if (token != G_TOKEN_NONE)
{
g_free(theme_data);
return token;
}
token = g_scanner_peek_next_token(scanner);
}
g_scanner_get_next_token(scanner);
g_scanner_set_scope(scanner, old_scope);
return G_TOKEN_NONE;
}
