You've already forked ukui-menus
mirror of
https://github.com/ukui/ukui-menus.git
synced 2026-03-09 09:22:26 -07:00
437 lines
10 KiB
C
437 lines
10 KiB
C
/* 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., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#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 = 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 */
|