char *
dbus_name_to_c(const char *dbus)
{
char *str_cpy = strdup(dbus), *pch, *ret;
Eina_Strbuf *buffer = eina_strbuf_new();
unsigned i;
pch = strtok(str_cpy, "/.");
if (!pch)
{
ret = strdup("root");
goto end;
}
eina_strbuf_append(buffer, pch);
while ((pch = strtok(NULL, "/.")))
eina_strbuf_append_printf(buffer, "_%s",pch);
ret = eina_strbuf_string_steal(buffer);
for (i = 0; ret[i]; i++)
{
if (i > 0 && ret[i-1] != '_' && ret[i] > '@' && ret[i] < '[')//upper case
eina_strbuf_append_printf(buffer, "_%c", tolower(ret[i]));
else
eina_strbuf_append_char(buffer, tolower(ret[i]));
}
free(ret);
ret = eina_strbuf_string_steal(buffer);
end:
free(str_cpy);
eina_strbuf_free(buffer);
return ret;
}
char *
url_from_user_input(const char *arg)
{
/* If it is already a URL, return the argument as is. */
if (has_scheme(arg) || !strcasecmp(arg, "about:blank"))
return strdup(arg);
Eina_Strbuf *buf = eina_strbuf_manage_new(eina_file_path_sanitize(arg));
/* Check if the path exists. */
if (ecore_file_exists(eina_strbuf_string_get(buf))) {
/* File exists, convert local path to a URL. */
eina_strbuf_prepend(buf, "file://");
} else {
/* The path does not exist, convert it to a URL by
prepending http:// scheme:
www.google.com -> http://www.google.com */
eina_strbuf_string_free(buf);
eina_strbuf_append_printf(buf, "http://%s", arg);
}
char *url = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
return url;
}
static char *
_get_abbreviated_name(const char *prefix, const char *fname)
{
Eina_Strbuf *buf = eina_strbuf_new();
const char *last_p = strrchr(prefix, '_');
last_p = (last_p) ? (last_p + 1) : prefix;
const char *tmp = strstr(fname, last_p);
int len = strlen(last_p);
if ((tmp) &&
((tmp == fname) || (*(tmp - 1) == '_')) &&
((*(tmp + len) == '\0') || (*(tmp + len) == '_')))
{
int plen = strlen(prefix);
len += (tmp - fname);
if ((plen >= len) && !strncmp(prefix + plen - len, fname, len))
{
eina_strbuf_append_n(buf, prefix, plen - len);
}
}
if (eina_strbuf_length_get(buf) == 0)
eina_strbuf_append_printf(buf, "%s_", prefix);
eina_strbuf_append(buf, fname);
char *ret = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
return ret;
}
static char *
evas_gl_common_shader_glsl_get(unsigned int flags, const char *base)
{
Eina_Strbuf *s = eina_strbuf_new();
unsigned int k;
char *str;
/* This is an env var to use for debugging purposes only */
static const char *evas_gl_shader_glsl_version = NULL;
if (!evas_gl_shader_glsl_version)
{
evas_gl_shader_glsl_version = getenv("EVAS_GL_SHADER_GLSL_VERSION");
if (!evas_gl_shader_glsl_version) evas_gl_shader_glsl_version = "";
else WRN("Using GLSL version tag: '%s'", evas_gl_shader_glsl_version);
}
if (*evas_gl_shader_glsl_version)
eina_strbuf_append_printf(s, "#version %s\n", evas_gl_shader_glsl_version);
for (k = 0; k < SHADER_FLAG_COUNT; k++)
{
if (flags & (1 << k))
eina_strbuf_append_printf(s, "#define SHD_%s\n", _shader_flags[k]);
}
eina_strbuf_append(s, base);
str = eina_strbuf_string_steal(s);
eina_strbuf_free(s);
return str;
}
static void indicator_battery_text_set(void *data, int value)
{
Eina_Strbuf *temp_buf = NULL;
Eina_Strbuf *percent_buf = NULL;
char *temp_str = NULL;
retif(data == NULL, , "Invalid parameter!");
battery.type = INDICATOR_TXT_WITH_IMG_ICON;
temp_buf = eina_strbuf_new();
percent_buf = eina_strbuf_new();
/* Set Label for percentage value */
eina_strbuf_append_printf(temp_buf, "%d", value);
temp_str = eina_strbuf_string_steal(temp_buf);
eina_strbuf_append_printf(percent_buf, "%s",
indicator_util_icon_label_set
(temp_str, NULL, NULL,
BATTERY_VALUE_FONT_SIZE,
data));
free(temp_str);
/* Set Label for pecentage symbol */
eina_strbuf_append_printf(temp_buf, "%%");
temp_str = eina_strbuf_string_steal(temp_buf);
eina_strbuf_append_printf(percent_buf, "%s",
indicator_util_icon_label_set
(temp_str, NULL,
BATTERY_PERCENT_FONT_STYLE,
BATTERY_PERCENT_FONT_SIZE,
data));
free(temp_str);
if (battery.txt_obj.data != NULL)
free(battery.txt_obj.data);
battery.txt_obj.data = eina_strbuf_string_steal(percent_buf);
if (temp_buf != NULL)
eina_strbuf_free(temp_buf);
if (percent_buf != NULL)
eina_strbuf_free(percent_buf);
}
char *
string_build(const char *fmt, ...)
{
va_list ap;
Eina_Strbuf *buffer = eina_strbuf_new();
char *ret;
va_start(ap, fmt);
eina_strbuf_prepend_vprintf(buffer, fmt, ap);
va_end(ap);
ret = eina_strbuf_string_steal(buffer);
eina_strbuf_free(buffer);
return ret;
}
EOLIAN static char*
_efl_text_markup_util_text_to_markup(const char *text)
{
Eina_Strbuf *sbuf;
char *str = NULL;
if (!text) return NULL;
sbuf = eina_strbuf_new();
_markup_get_text_utf8_append(sbuf, text);
str = eina_strbuf_string_steal(sbuf);
eina_strbuf_free(sbuf);
return str;
}
EAPI char *
eina_simple_xml_node_dump(Eina_Simple_XML_Node *node, const char *indent)
{
Eina_Strbuf *buf;
char *ret;
if (!node) return NULL;
buf = eina_strbuf_new();
if (!buf) return NULL;
_eina_simple_xml_node_dump(buf, node, indent, 0);
ret = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
return ret;
}
static char *
_module_patterns_str_new(void)
{
Eina_Strbuf *buf;
char * const *itr;
char *ret;
if (!module_patterns) return strdup("*");
buf = eina_strbuf_new();
for (itr = module_patterns; *itr != NULL; itr++)
{
eina_strbuf_append(buf, *itr);
if (itr[1]) eina_strbuf_append(buf, ", ");
}
ret = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
return ret;
}
EAPI Eina_Stringshare *
eolian_typedecl_enum_field_c_name_get(const Eolian_Enum_Type_Field *fl)
{
Eina_Stringshare *ret;
Eina_Strbuf *buf;
char *bufp, *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(fl, NULL);
buf = eina_strbuf_new();
if (fl->base_enum->legacy)
eina_strbuf_append(buf, fl->base_enum->legacy);
else
eina_strbuf_append(buf, fl->base_enum->base.name);
eina_strbuf_append_char(buf, '_');
eina_strbuf_append(buf, fl->base.name);
bufp = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
eina_str_toupper(&bufp);
while ((p = strchr(bufp, '.'))) *p = '_';
ret = eina_stringshare_add(bufp);
free(bufp);
return ret;
}
char *
_dbus_package_to_path(const char *pkg)
{
Eina_Strbuf *buffer;
char *ret;
buffer = eina_strbuf_new();
eina_strbuf_append_char(buffer, '/');
for (; *pkg != '\0'; pkg++)
{
if (*pkg == '.')
eina_strbuf_append_char(buffer, '/');
else if(isalnum(*pkg))
eina_strbuf_append_char(buffer, *pkg);
else
eina_strbuf_append_printf(buffer, "_%02x", *pkg);
}
ret = eina_strbuf_string_steal(buffer);
eina_strbuf_free(buffer);
return ret;
}
char *
replace_string(const char *string, const char *substr, const char *replacement)
{
char *str_cpy = strdup(string);
char *pch;
char *ret;
Eina_Strbuf *buffer = eina_strbuf_new();
pch = strtok(str_cpy, substr);
if (!pch)
{
eina_strbuf_free(buffer);
return str_cpy;
}
eina_strbuf_append(buffer, pch);
while ((pch = strtok(NULL, substr)))
eina_strbuf_append_printf(buffer, "%s%s", replacement, pch);
ret = eina_strbuf_string_steal(buffer);
free(str_cpy);
eina_strbuf_free(buffer);
return ret;
}
Eina_Bool
file_read(const char *file_name, char **buffer)
{
FILE *xml_handler;
int data; /* fgetc needs int to detect EOF correctly */
Eina_Strbuf *buf;
xml_handler = fopen(file_name, "rt");
if (!xml_handler)
{
printf("Error to read file: %s\n", file_name);
return EINA_FALSE;
}
buf = eina_strbuf_new();
while ((data = fgetc(xml_handler)) != EOF)
eina_strbuf_append_char(buf, (char)data);
fclose(xml_handler);
*buffer = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
return EINA_TRUE;
}
}
eina_strbuf_append_printf(result, "*** timer: %f ***\n", tm->in);
if (tm->frozen)
eina_strbuf_append(result, "FROZEN\n");
if (tm->delete_me)
eina_strbuf_append(result, "DELETED\n");
for (j = 0; j < tm->timer_bt_num; j++)
eina_strbuf_append_printf(result, "%s\n", strings[j]);
free(strings);
}
eina_strbuf_append_printf(result, "\n***\nThere is %i living timer.\nWe did lost track of %i timers.\n", living_timer, unknow_timer);
out = eina_strbuf_string_steal(result);
eina_strbuf_free(result);
_ecore_unlock();
return out;
#else
return NULL;
#endif
}
/**
* @}
*/
Ecore_Timer *
_ecore_timer_loop_add(double in,
static char *
_text_util_markup_to_text(const char *text)
{
Eina_Strbuf *sbuf;
char *s, *p, *ret;
char *tag_start, *tag_end, *esc_start, *esc_end;
if (!text) return NULL;
tag_start = tag_end = esc_start = esc_end = NULL;
sbuf = eina_strbuf_new();
p = (char *)text;
s = p;
/* This loop goes through all of the mark up text until it finds format
* tags, escape sequences or the terminating NULL. When it finds either
* of those, it appends the text found up until that point to the textblock
* proccesses whatever found. It repeats itself until the termainating
* NULL is reached. */
for (;;)
{
/* If we got to the end of string or just finished/started tag
* or escape sequence handling. */
if ((*p == 0) ||
(tag_end) || (esc_end) ||
(tag_start) || (esc_start))
{
if (tag_end)
{
/* If we reached to a tag ending, analyze the tag */
char *ttag;
size_t ttag_len;
tag_start++; /* Skip the < */
tag_end--; /* Skip the > */
if ((tag_end > tag_start) && (*(tag_end - 1) == '/'))
{
tag_end --; /* Skip the terminating '/' */
while (*(tag_end - 1) == ' ')
tag_end--; /* skip trailing ' ' */
}
ttag_len = tag_end - tag_start;
ttag = malloc(ttag_len + 1);
if (ttag)
{
memcpy(ttag, tag_start, ttag_len);
ttag[ttag_len] = 0;
if (_IS_PARAGRAPH_SEPARATOR_SIMPLE(ttag))
eina_strbuf_append(sbuf, _PARAGRAPH_SEPARATOR_UTF8);
else if (_IS_LINE_SEPARATOR(ttag))
eina_strbuf_append(sbuf, _NEWLINE_UTF8);
else if (_IS_TAB(ttag))
eina_strbuf_append(sbuf, _TAB_UTF8);
else if (!strncmp(ttag, "item", 4))
eina_strbuf_append(sbuf, _REPLACEMENT_CHAR_UTF8);
free(ttag);
}
tag_start = tag_end = NULL;
}
else if (esc_end)
{
const char *escape;
escape = _escaped_char_get(esc_start, esc_end + 1);
if (escape) eina_strbuf_append(sbuf, escape);
esc_start = esc_end = NULL;
}
else if (*p == 0)
{
if (s)
{
eina_strbuf_append_length(sbuf, s, p - s);
s = NULL;
}
else
{
ERR("There is a invalid markup tag at positoin '%u'. Please check the text.", (unsigned int) (p - text));
}
}
if (*p == 0)
break;
}
if (*p == '<')
{
if (!esc_start)
{
/* Append the text prior to this to the textblock and
* mark the start of the tag */
tag_start = p;
tag_end = NULL;
if (s)
{
eina_strbuf_append_length(sbuf, s, p - s);
s = NULL;
}
else
{
ERR("There is a invalid markup tag at positoin '%u'. Please check the text.", (unsigned int) (p - text));
}
}
}
else if (*p == '>')
{
if (tag_start)
{
tag_end = p + 1;
s = p + 1;
}
}
else if (*p == '&')
{
if (!tag_start)
{
/* Append the text prior to this to the textblock and mark
* the start of the escape sequence */
esc_start = p;
esc_end = NULL;
if (s)
{
eina_strbuf_append_length(sbuf, s, p - s);
s = NULL;
}
else
{
ERR("There is a invalid markup tag at positoin '%u'. Please check the text.", (unsigned int) (p - text));
}
}
}
else if (*p == ';')
{
if (esc_start)
{
esc_end = p;
s = p + 1;
}
}
p++;
}
ret = eina_strbuf_string_steal(sbuf);
eina_strbuf_free(sbuf);
return ret;
}
char *
_nedje_text_escape(const char *text)
{
Eina_Strbuf *txt;
char *ret;
const char *text_end;
size_t text_len;
Eina_Array *arr;
const char *cur_tag = NULL;
if (!text) return NULL;
txt = eina_strbuf_new();
text_len = strlen(text);
arr = eina_array_new(3);
text_end = text + text_len;
while (text < text_end)
{
int advance;
if ((text[0] == '<') && text[1])
{
const char *tag, *popped;
Eina_Bool closing = EINA_FALSE;
if (text[1] == '/') //closing tag
{
closing = EINA_TRUE;
tag = _get_tag(text + 2);
}
else
tag = _get_tag(text + 1);
if (closing)
{
if (cur_tag && (tag != cur_tag))
{
/* tag mismatch: autoclose all failure tags
* not technically required by the spec,
* but it makes me feel better about myself
*/
do
{
popped = eina_array_pop(arr);
if (eina_array_count(arr))
cur_tag = eina_array_data_get(arr, eina_array_count(arr) - 1);
else
cur_tag = NULL;
eina_strbuf_append_printf(txt, "</%c>", popped[1]);
} while (cur_tag && (popped != tag));
advance = 4;
}
else if (cur_tag)
{
/* tag match: just pop */
popped = eina_array_pop(arr);
if (eina_array_count(arr))
cur_tag = eina_array_data_get(arr, eina_array_count(arr) - 1);
else
cur_tag = NULL;
eina_strbuf_append_printf(txt, "</%c>", popped[1]);
advance = 4;
}
else
{
/* no current tag: escape */
advance = _text_escape(txt, text);
}
}
else
{
if (tag)
{
cur_tag = tag;
eina_array_push(arr, tag);
eina_strbuf_append_printf(txt, "<%c>", tag[1]);
advance = 3;
}
else
advance = _text_escape(txt, text);
}
}
else if (text[0] == '&')
{
const char *s;
s = strchr(text, ';');
if (s)
s = evas_textblock_escape_string_range_get(text, s + 1);
if (s)
{
eina_strbuf_append_char(txt, text[0]);
advance = 1;
}
else
advance = _text_escape(txt, text);
}
else
advance = _text_escape(txt, text);
text += advance;
}
eina_array_free(arr);
ret = eina_strbuf_string_steal(txt);
eina_strbuf_free(txt);
return ret;
}
}
else elm_layout_text_set(ELM_WIDGET_DATA(sd)->obj, "month_text", "");
}
static char *
_access_info_cb(void *data __UNUSED__,
Evas_Object *obj,
Elm_Widget_Item *item __UNUSED__)
{
char *ret;
Eina_Strbuf *buf;
buf = eina_strbuf_new();
eina_strbuf_append_printf(buf, "day %s", elm_widget_access_info_get(obj));
ret = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
return ret;
}
static void
_access_calendar_item_register(Evas_Object *obj)
{
int maxdays, day, i;
char day_s[3], pname[14];
Evas_Object *ao;
ELM_CALENDAR_DATA_GET(obj, sd);
day = 0;
maxdays = _maxdays_get(&sd->shown_time);
