/* Random utility functions for menu code */
/*
* Copyright (C) 2003 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "menu-util.h"
#include <stdio.h>
#include <stdarg.h>
#ifdef G_ENABLE_DEBUG
static gboolean verbose = FALSE;
static gboolean initted = FALSE;
static inline gboolean
menu_verbose_enabled (void)
{
if (!initted)
{
verbose = g_getenv ("MENU_VERBOSE") != NULL;
initted = TRUE;
}
return verbose;
}
static int
utf8_fputs (const char *str,
FILE *f)
{
char *l;
int ret;
l = g_locale_from_utf8 (str, -1, NULL, NULL, NULL);
if (l == NULL)
ret = fputs (str, f); /* just print it anyway, better than nothing */
else
ret = fputs (l, f);
g_free (l);
return ret;
}
void
menu_verbose (const char *format,
...)
{
va_list args;
char *str;
if (!menu_verbose_enabled ())
return;
va_start (args, format);
str = g_strdup_vprintf (format, args);
va_end (args);
utf8_fputs (str, stderr);
fflush (stderr);
g_free (str);
}
static void append_to_string (MenuLayoutNode *node,
gboolean onelevel,
int depth,
GString *str);
static void
append_spaces (GString *str,
int depth)
{
while (depth > 0)
{
g_string_append_c (str, ' ');
--depth;
}
}
static void
append_children (MenuLayoutNode *node,
int depth,
GString *str)
{
MenuLayoutNode *iter;
iter = menu_layout_node_get_children (node);
while (iter != NULL)
{
append_to_string (iter, FALSE, depth, str);
iter = menu_layout_node_get_next (iter);
}
}
static void
append_simple_with_attr (MenuLayoutNode *node,
int depth,
const char *node_name,
const char *attr_name,
const char *attr_value,
GString *str)
{
const char *content;
append_spaces (str, depth);
if ((content = menu_layout_node_get_content (node)))
{
char *escaped;
escaped = g_markup_escape_text (content, -1);
if (attr_name && attr_value)
{
char *attr_escaped;
attr_escaped = g_markup_escape_text (attr_value, -1);
g_string_append_printf (str, "<%s %s=\"%s\">%s</%s>\n",
node_name, attr_name,
attr_escaped, escaped, node_name);
g_free (attr_escaped);
}
else
{
g_string_append_printf (str, "<%s>%s</%s>\n",
node_name, escaped, node_name);
}
g_free (escaped);
}
else
{
if (attr_name && attr_value)
{
char *attr_escaped;
attr_escaped = g_markup_escape_text (attr_value, -1);
g_string_append_printf (str, "<%s %s=\"%s\"/>\n",
node_name, attr_name,
attr_escaped);
g_free (attr_escaped);
}
else
{
g_string_append_printf (str, "<%s/>\n", node_name);
}
}
}
static void
append_layout (MenuLayoutNode *node,
int depth,
const char *node_name,
MenuLayoutValues *layout_values,
GString *str)
{
const char *content;
append_spaces (str, depth);
if ((content = menu_layout_node_get_content (node)))
{
char *escaped;
escaped = g_markup_escape_text (content, -1);
g_string_append_printf (str,
"<%s show_empty=\"%s\" inline=\"%s\" inline_header=\"%s\""
" inline_alias=\"%s\" inline_limit=\"%d\">%s</%s>\n",
node_name,
layout_values->show_empty ? "true" : "false",
layout_values->inline_menus ? "true" : "false",
layout_values->inline_header ? "true" : "false",
layout_values->inline_alias ? "true" : "false",
layout_values->inline_limit,
escaped,
node_name);
g_free (escaped);
}
else
{
g_string_append_printf (str,
"<%s show_empty=\"%s\" inline=\"%s\" inline_header=\"%s\""
" inline_alias=\"%s\" inline_limit=\"%d\"/>\n",
node_name,
layout_values->show_empty ? "true" : "false",
layout_values->inline_menus ? "true" : "false",
layout_values->inline_header ? "true" : "false",
layout_values->inline_alias ? "true" : "false",
layout_values->inline_limit);
}
}
static void
append_merge (MenuLayoutNode *node,
int depth,
const char *node_name,
MenuLayoutMergeType merge_type,
GString *str)
{
const char *merge_type_str;
merge_type_str = NULL;
switch (merge_type)
{
case MENU_LAYOUT_MERGE_NONE:
merge_type_str = "none";
break;
case MENU_LAYOUT_MERGE_MENUS:
merge_type_str = "menus";
break;
case MENU_LAYOUT_MERGE_FILES:
merge_type_str = "files";
break;
case MENU_LAYOUT_MERGE_ALL:
merge_type_str = "all";
break;
default:
g_assert_not_reached ();
break;
}
append_simple_with_attr (node, depth, node_name, "type", merge_type_str, str);
}
static void
append_simple (MenuLayoutNode *node,
int depth,
const char *node_name,
GString *str)
{
append_simple_with_attr (node, depth, node_name, NULL, NULL, str);
}
static void
append_start (MenuLayoutNode *node,
int depth,
const char *node_name,
GString *str)
{
append_spaces (str, depth);
g_string_append_printf (str, "<%s>\n", node_name);
}
static void
append_end (MenuLayoutNode *node,
int depth,
const char *node_name,
GString *str)
{
append_spaces (str, depth);
g_string_append_printf (str, "</%s>\n", node_name);
}
static void
append_container (MenuLayoutNode *node,
gboolean onelevel,
int depth,
const char *node_name,
GString *str)
{
append_start (node, depth, node_name, str);
if (!onelevel)
{
append_children (node, depth + 2, str);
append_end (node, depth, node_name, str);
}
}
static void
append_to_string (MenuLayoutNode *node,
gboolean onelevel,
int depth,
GString *str)
{
MenuLayoutValues layout_values;
switch (menu_layout_node_get_type (node))
{
case MENU_LAYOUT_NODE_ROOT:
if (!onelevel)
append_children (node, depth - 1, str); /* -1 to ignore depth of root */
else
append_start (node, depth - 1, "Root", str);
break;
case MENU_LAYOUT_NODE_PASSTHROUGH:
g_string_append (str,
menu_layout_node_get_content (node));
g_string_append_c (str, '\n');
break;
case MENU_LAYOUT_NODE_MENU:
append_container (node, onelevel, depth, "Menu", str);
break;
case MENU_LAYOUT_NODE_APP_DIR:
append_simple (node, depth, "AppDir", str);
break;
case MENU_LAYOUT_NODE_DEFAULT_APP_DIRS:
append_simple (node, depth, "DefaultAppDirs", str);
break;
case MENU_LAYOUT_NODE_DIRECTORY_DIR:
append_simple (node, depth, "DirectoryDir", str);
break;
case MENU_LAYOUT_NODE_DEFAULT_DIRECTORY_DIRS:
append_simple (node, depth, "DefaultDirectoryDirs", str);
break;
case MENU_LAYOUT_NODE_DEFAULT_MERGE_DIRS:
append_simple (node, depth, "DefaultMergeDirs", str);
break;
case MENU_LAYOUT_NODE_NAME:
append_simple (node, depth, "Name", str);
break;
case MENU_LAYOUT_NODE_DIRECTORY:
append_simple (node, depth, "Directory", str);
break;
case MENU_LAYOUT_NODE_ONLY_UNALLOCATED:
append_simple (node, depth, "OnlyUnallocated", str);
break;
case MENU_LAYOUT_NODE_NOT_ONLY_UNALLOCATED:
append_simple (node, depth, "NotOnlyUnallocated", str);
break;
case MENU_LAYOUT_NODE_INCLUDE:
append_container (node, onelevel, depth, "Include", str);
break;
case MENU_LAYOUT_NODE_EXCLUDE:
append_container (node, onelevel, depth, "Exclude", str);
break;
case MENU_LAYOUT_NODE_FILENAME:
append_simple (node, depth, "Filename", str);
break;
case MENU_LAYOUT_NODE_CATEGORY:
append_simple (node, depth, "Category", str);
break;
case MENU_LAYOUT_NODE_ALL:
append_simple (node, depth, "All", str);
break;
case MENU_LAYOUT_NODE_AND:
append_container (node, onelevel, depth, "And", str);
break;
case MENU_LAYOUT_NODE_OR:
append_container (node, onelevel, depth, "Or", str);
break;
case MENU_LAYOUT_NODE_NOT:
append_container (node, onelevel, depth, "Not", str);
break;
case MENU_LAYOUT_NODE_MERGE_FILE:
{
MenuMergeFileType type;
type = menu_layout_node_merge_file_get_type (node);
append_simple_with_attr (node, depth, "MergeFile",
"type", type == MENU_MERGE_FILE_TYPE_PARENT ? "parent" : "path",
str);
break;
}
case MENU_LAYOUT_NODE_MERGE_DIR:
append_simple (node, depth, "MergeDir", str);
break;
case MENU_LAYOUT_NODE_LEGACY_DIR:
append_simple_with_attr (node, depth, "LegacyDir",
"prefix", menu_layout_node_legacy_dir_get_prefix (node),
str);
break;
case MENU_LAYOUT_NODE_KDE_LEGACY_DIRS:
append_simple (node, depth, "KDELegacyDirs", str);
break;
case MENU_LAYOUT_NODE_MOVE:
append_container (node, onelevel, depth, "Move", str);
break;
case MENU_LAYOUT_NODE_OLD:
append_simple (node, depth, "Old", str);
break;
case MENU_LAYOUT_NODE_NEW:
append_simple (node, depth, "New", str);
break;
case MENU_LAYOUT_NODE_DELETED:
append_simple (node, depth, "Deleted", str);
break;
case MENU_LAYOUT_NODE_NOT_DELETED:
append_simple (node, depth, "NotDeleted", str);
break;
case MENU_LAYOUT_NODE_LAYOUT:
append_container (node, onelevel, depth, "Layout", str);
break;
case MENU_LAYOUT_NODE_DEFAULT_LAYOUT:
menu_layout_node_default_layout_get_values (node, &layout_values);
append_layout (node, depth, "DefaultLayout", &layout_values, str);
break;
case MENU_LAYOUT_NODE_MENUNAME:
menu_layout_node_menuname_get_values (node, &layout_values);
append_layout (node, depth, "MenuName", &layout_values, str);
break;
case MENU_LAYOUT_NODE_SEPARATOR:
append_simple (node, depth, "Name", str);
break;
case MENU_LAYOUT_NODE_MERGE:
append_merge (node,
depth,
"Merge",
menu_layout_node_merge_get_type (node),
str);
break;
default:
g_assert_not_reached ();
break;
}
}
void
menu_debug_print_layout (MenuLayoutNode *node,
gboolean onelevel)
{
if (menu_verbose_enabled ())
{
GString *str;
str = g_string_new (NULL);
append_to_string (node, onelevel, 0, str);
utf8_fputs (str->str, stderr);
fflush (stderr);
g_string_free (str, TRUE);
}
}
#endif /* G_ENABLE_DEBUG */