EAPI Eina_Stringshare *
eolian_expression_value_to_literal(const Eolian_Value *val)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(val, NULL);
switch (val->type)
{
case EOLIAN_EXPR_BOOL:
return eina_stringshare_add(val->value.b ? "EINA_TRUE"
: "EINA_FALSE");
case EOLIAN_EXPR_NULL:
return eina_stringshare_add("NULL");
case EOLIAN_EXPR_CHAR:
{
char c = val->value.c;
Eina_Strbuf *buf = eina_strbuf_new();
const char *ret;
eina_strbuf_append_char(buf, '\'');
_append_char_escaped(buf, c);
eina_strbuf_append_char(buf, '\'');
ret = eina_stringshare_add(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return ret;
}
case EOLIAN_EXPR_STRING:
{
const char *ret;
char *c = (char*)val->value.s;
Eina_Strbuf *buf = eina_strbuf_new();
eina_strbuf_append_char(buf, '\"');
while (*c) _append_char_escaped(buf, *(c++));
eina_strbuf_append_char(buf, '\"');
ret = eina_stringshare_add(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return ret;
}
case EOLIAN_EXPR_INT:
case EOLIAN_EXPR_UINT:
case EOLIAN_EXPR_LONG:
case EOLIAN_EXPR_ULONG:
case EOLIAN_EXPR_LLONG:
case EOLIAN_EXPR_ULLONG:
case EOLIAN_EXPR_FLOAT:
case EOLIAN_EXPR_DOUBLE:
{
const char *ret;
Eina_Strbuf *buf = eina_strbuf_new();
_number_to_str(val, buf);
ret = eina_stringshare_add(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return ret;
}
default:
return NULL;
}
}
Eina_Strbuf *
eo_gen_docs_event_gen(const Eolian_State *state, const Eolian_Event *ev,
const char *group)
{
if (!ev) return NULL;
const Eolian_Documentation *doc = eolian_event_documentation_get(ev);
char buf[1024];
const Eolian_Type *rt = eolian_event_type_get(ev);
const char *p = NULL;
if (rt)
{
p = buf;
Eina_Stringshare *rts = eolian_type_c_type_get(rt, EOLIAN_C_TYPE_DEFAULT);
snprintf(buf, sizeof(buf), "@return %s", rts);
eina_stringshare_del(rts);
}
if (!doc)
{
Eina_Strbuf *bufs = eina_strbuf_new();
eina_strbuf_append(bufs, "/**\n * No description\n");
if (p)
{
eina_strbuf_append(bufs, " * ");
eina_strbuf_append(bufs, p);
eina_strbuf_append_char(bufs, '\n');
}
eina_strbuf_append(bufs, " */");
return bufs;
}
return _gen_doc_buf(state, doc, group, p, 0);
}
EAPI Eina_Stringshare *
eolian_function_full_c_name_get(const Eolian_Function *foo_id,
Eolian_Function_Type ftype)
{
char tbuf[512];
tbuf[0] = '\0';
const char *prefix = (ftype != EOLIAN_FUNCTION_POINTER) ? _get_eo_prefix(foo_id, tbuf): tbuf;
if (!prefix)
return NULL;
const char *funcn = eolian_function_name_get(foo_id);
Eina_Strbuf *buf = eina_strbuf_new();
Eina_Stringshare *ret;
char *abbr = _get_abbreviated_name(prefix, funcn);
eina_strbuf_append(buf, abbr);
free(abbr);
if ((ftype == EOLIAN_PROP_GET) || (ftype == EOLIAN_PROPERTY))
eina_strbuf_append(buf, "_get");
else if (ftype == EOLIAN_PROP_SET)
eina_strbuf_append(buf, "_set");
ret = eina_stringshare_add(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return ret;
}
static void
_gen_doc_brief(const Eolian_State *state, const char *summary, const char *since,
const char *group, const char *el, int indent, Eina_Strbuf *buf)
{
int curl = 4 + indent;
Eina_Strbuf *wbuf = eina_strbuf_new();
if (indent)
eina_strbuf_append(buf, "/**< ");
else
eina_strbuf_append(buf, "/** ");
curl = _append_section(state, summary, indent, curl, buf, wbuf);
eina_strbuf_free(wbuf);
curl = _append_extra(el, indent, curl, EINA_FALSE, buf);
curl = _append_since(since, indent, curl, buf);
char *sgrp = _sanitize_group(group);
if (((curl + 3) > DOC_LIMIT(indent)) || sgrp)
{
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
if (sgrp) eina_strbuf_append(buf, " *");
}
if (sgrp)
{
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
}
_append_group(buf, sgrp, indent);
eina_strbuf_append(buf, " */");
}
static void
_gen_doc_full(const Eolian_State *state, const char *summary,
const char *description, const char *since,
const char *group, const char *el, int indent, Eina_Strbuf *buf)
{
int curl = 0;
Eina_Strbuf *wbuf = eina_strbuf_new();
if (indent)
eina_strbuf_append(buf, "/**<\n");
else
eina_strbuf_append(buf, "/**\n");
curl += _indent_line(buf, indent);
eina_strbuf_append(buf, " * @brief ");
curl += sizeof(" * @brief ") - 1;
_append_section(state, summary, indent, curl, buf, wbuf);
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * ");
_append_section(state, description, indent, curl + 3, buf, wbuf);
curl = _append_extra(el, indent, curl, EINA_TRUE, buf);
curl = _append_since(since, indent, curl, buf);
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
char *sgrp = _sanitize_group(group);
if (sgrp)
{
eina_strbuf_append(buf, " *\n");
_indent_line(buf, indent);
}
_append_group(buf, sgrp, indent);
eina_strbuf_append(buf, " */");
eina_strbuf_free(wbuf);
}
static void
_gen_doc_brief(const char *summary, const char *since, const char *group,
int indent, Eina_Strbuf *buf, Eina_Bool use_legacy)
{
int curl = 4 + indent;
Eina_Strbuf *wbuf = eina_strbuf_new();
eina_strbuf_append(buf, "/** ");
curl = _append_section(summary, indent, curl, buf, wbuf, use_legacy);
eina_strbuf_free(wbuf);
curl = _append_since(since, indent, curl, buf);
char *sgrp = _sanitize_group(group);
if (((curl + 3) > DOC_LIMIT(indent)) || sgrp)
{
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
if (sgrp) eina_strbuf_append(buf, " *");
}
if (sgrp)
{
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
}
_append_group(buf, sgrp, indent);
eina_strbuf_append(buf, " */");
}
static void
_gen_doc_full(const char *summary, const char *description, const char *since,
const char *group, int indent, Eina_Strbuf *buf, Eina_Bool use_legacy)
{
int curl = 0;
Eina_Strbuf *wbuf = eina_strbuf_new();
eina_strbuf_append(buf, "/**\n");
curl += _indent_line(buf, indent);
eina_strbuf_append(buf, " * @brief ");
curl += sizeof(" * @brief ") - 1;
_append_section(summary, indent, curl, buf, wbuf, use_legacy);
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * ");
_append_section(description, indent, curl + 3, buf, wbuf, use_legacy);
curl = _append_since(since, indent, curl, buf);
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
char *sgrp = _sanitize_group(group);
if (sgrp)
{
eina_strbuf_append(buf, " *\n");
_indent_line(buf, indent);
}
_append_group(buf, sgrp, indent);
eina_strbuf_append(buf, " */");
eina_strbuf_free(wbuf);
}
int main(int argc, char **argv)
{
Eina_Strbuf *buf;
eina_init();
buf = eina_strbuf_new();
eina_strbuf_append_length(buf, "buffe", 5);
eina_strbuf_append_char(buf, 'r');
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_insert_escaped(buf, "my ", 0);
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_reset(buf);
eina_strbuf_append_escaped(buf, "my buffer");
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_reset(buf);
eina_strbuf_append_printf(buf, "%s%c", "buffe", 'r');
eina_strbuf_insert_printf(buf, " %s: %d", 6, "length", eina_strbuf_length_get(buf));
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_remove(buf, 0, 7);
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_replace_all(buf, "length", "size");
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
eina_shutdown();
return 0;
}
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;
}
Eina_Bool
alert_command_run(void *data)
{
Module_Alert_Command *mac = data;
#define _EV(_a, _b, _c, _d) _a = ecore_event_handler_add(ECORE_EXE_EVENT_##_b, _c, _d)
_EV(mac->ev.data, DATA, _alert_command_data, mac);
EINA_SAFETY_ON_NULL_RETURN_VAL(mac->ev.data, EINA_TRUE);
_EV(mac->ev.del, DEL, _alert_command_del, mac);
EINA_SAFETY_ON_NULL_GOTO(mac->ev.del, del_data);
_EV(mac->ev.error, ERROR, _alert_command_error, mac);
EINA_SAFETY_ON_NULL_GOTO(mac->ev.error, del_del);
#undef _EV
mac->buf = eina_strbuf_new();
EINA_SAFETY_ON_NULL_GOTO(mac->buf, del_error);
mac->exe = ecore_exe_pipe_run(mac->command->command, ECORE_EXE_PIPE_READ, mac);
EINA_SAFETY_ON_NULL_GOTO(mac->exe, free_buf);
ecore_exe_data_set(mac->exe, mac);
return EINA_TRUE;
free_buf:
eina_strbuf_free(mac->buf);
del_error:
ecore_event_handler_del(mac->ev.error);
del_del:
ecore_event_handler_del(mac->ev.del);
del_data:
ecore_event_handler_del(mac->ev.data);
return EINA_TRUE;
}
static Eina_Error
ret_cb(Azy_Client *cli, Azy_Content *content, Eina_Binbuf *data)
{
Eina_Strbuf *buf;
if (azy_content_error_is_set(content))
printf("Error encountered: %s\n", azy_content_error_message_get(content));
else
{
const Eina_List *cookies;
printf("Success!\n");
buf = eina_strbuf_new();
cookies = azy_net_cookie_set_list_get(azy_content_net_get(content));
if (cookies)
azy_net_cookie_set_list_generate(buf, cookies);
cookies = azy_net_cookie_send_list_get(azy_content_net_get(content));
if (cookies)
azy_net_cookie_send_list_generate(buf, cookies);
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
}
if (!azy_client_current(cli)) azy_client_close(cli);
return AZY_ERROR_NONE;
}
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;
}
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 = strdup(eina_strbuf_string_get(buffer));
eina_strbuf_reset(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 = strdup(eina_strbuf_string_get(buffer));
end:
free(str_cpy);
eina_strbuf_free(buffer);
return ret;
}
Eina_Strbuf *
url_normalize_str(const char *str)
{
Eina_Strbuf *buf;
buf = eina_strbuf_new();
eina_strbuf_append(buf, str);
eina_strbuf_replace_all(buf, " ", "%20");
return buf;
}
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);
}
static Eina_Bool
em_file_open(void *video,
const char *file)
{
Emotion_Gstreamer_Video *ev = video;
Eina_Strbuf *sbuf = NULL;
const char *uri;
if (!file) return EINA_FALSE;
if (strstr(file, "://") == NULL)
{
sbuf = eina_strbuf_new();
eina_strbuf_append(sbuf, "file://");
if (strncmp(file, "./", 2) == 0)
file += 2;
if (strstr(file, ":/") != NULL)
{ /* We absolutely need file:///C:/ under Windows, so adding it here */
eina_strbuf_append(sbuf, "/");
}
else if (*file != '/')
{
char tmp[PATH_MAX];
if (getcwd(tmp, PATH_MAX))
{
eina_strbuf_append(sbuf, tmp);
eina_strbuf_append(sbuf, "/");
}
}
eina_strbuf_append(sbuf, file);
}
ev->play_started = 0;
ev->pipeline_parsed = 0;
uri = sbuf ? eina_strbuf_string_get(sbuf) : file;
DBG("setting file to '%s'", uri);
ev->pipeline = gstreamer_video_sink_new(ev, ev->obj, uri);
if (sbuf) eina_strbuf_free(sbuf);
if (!ev->pipeline)
return EINA_FALSE;
ev->eos_bus = gst_pipeline_get_bus(GST_PIPELINE(ev->pipeline));
if (!ev->eos_bus)
{
ERR("could not get the bus");
return EINA_FALSE;
}
gst_bus_set_sync_handler(ev->eos_bus, _eos_sync_fct, ev);
ev->position = 0.0;
return 1;
}
/**
* @brief Helper func for generating content string name for given day number
* @param day_num number of day in week
*
* @returns an Eina_Strbuf* object filled with content day-name
*/
static Eina_Strbuf *
_eail_dayselector_gen_day_str(int day_num)
{
Eina_Strbuf *str_buf = NULL;
str_buf = eina_strbuf_new();
eina_strbuf_append_printf(str_buf, EAIL_CONTENT_PART_FORMAT, day_num);
return str_buf;
}
/* Gadcon Functions */
static E_Gadcon_Client *
_gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style)
{
Evas_Object *o;
E_Gadcon_Client *gcc;
Forecasts *w;
Instance *inst;
inst = E_NEW(Instance, 1);
inst->ci = _forecasts_config_item_get(id);
inst->area = eina_stringshare_add(inst->ci->code);
inst->buffer = eina_strbuf_new();
w = _forecasts_new(gc->evas);
w->inst = inst;
inst->forecasts = w;
o = w->forecasts_obj;
gcc = e_gadcon_client_new(gc, name, id, style, o);
gcc->data = inst;
inst->gcc = gcc;
inst->popup = NULL;
inst->forecasts_obj = o;
evas_object_event_callback_add(inst->forecasts_obj, EVAS_CALLBACK_MOUSE_DOWN,
_cb_mouse_down, inst);
evas_object_event_callback_add(inst->forecasts_obj, EVAS_CALLBACK_MOUSE_IN,
_cb_mouse_in, inst);
evas_object_event_callback_add(inst->forecasts_obj, EVAS_CALLBACK_MOUSE_OUT,
_cb_mouse_out, inst);
if (!inst->add_handler)
inst->add_handler =
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD,
_forecasts_server_add, inst);
if (!inst->del_handler)
inst->del_handler =
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DEL,
_forecasts_server_del, inst);
if (!inst->data_handler)
inst->data_handler =
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
_forecasts_server_data, inst);
evas_object_event_callback_add(w->forecasts_obj, EVAS_CALLBACK_MOUSE_DOWN,
_forecasts_cb_mouse_down, inst);
forecasts_config->instances =
eina_list_append(forecasts_config->instances, inst);
_forecasts_cb_check(inst);
inst->check_timer =
ecore_timer_add(inst->ci->poll_time, _forecasts_cb_check, inst);
return gcc;
}
EAPI Eina_Stringshare *
eolian_typedecl_c_type_get(const Eolian_Typedecl *tp)
{
Eina_Stringshare *ret;
Eina_Strbuf *buf;
EINA_SAFETY_ON_NULL_RETURN_VAL(tp, NULL);
buf = eina_strbuf_new();
database_typedecl_to_str(tp, buf);
ret = eina_stringshare_add(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return ret;
}
static void
on_error(void *user_data, Evas_Object *webview, void *event_info)
{
Eina_Strbuf* buffer;
const Ewk_Web_Error *error = (const Ewk_Web_Error *)event_info;
buffer = eina_strbuf_new();
eina_strbuf_append_printf(buffer, "<html><body><div style=\"color:#ff0000\">ERROR!</div><br><div>Code: %d<br>Description: %s<br>URL: %s</div></body</html>",
ewk_web_error_code_get(error), ewk_web_error_description_get(error), ewk_web_error_url_get(error));
ewk_view_html_string_load(webview, eina_strbuf_string_get(buffer), 0, ewk_web_error_url_get(error));
eina_strbuf_free(buffer);
}
EAPI Eina_Stringshare *
eolian_expression_serialize(const Eolian_Expression *expr)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(expr, NULL);
Eina_Strbuf *buf = eina_strbuf_new();
if (!_expr_serialize(expr, buf, EINA_TRUE))
{
eina_strbuf_free(buf);
return NULL;
}
const char *ret = eina_stringshare_add(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return ret;
}
/* expand fname to full path name (so that PATH is ignored) plus turn
* stuff into a command, and also verify whether the path exists */
static char *
get_cmdline_from_argv(const char *fname, const char **argv)
{
Eina_Strbuf *buf;
char *ret;
char pbuf[PATH_MAX];
const char *arg = NULL;
FILE *testf = fopen(fname, "rb");
if (!testf)
return NULL;
fclose(testf);
/* for windows, we have realpath in evil, no need for GetFullPathName */
if (!realpath(fname, pbuf))
return NULL;
buf = eina_strbuf_new();
eina_strbuf_append_char(buf, '"');
eina_strbuf_append(buf, pbuf);
eina_strbuf_append_char(buf, '"');
while ((arg = *(argv++)))
{
char c;
eina_strbuf_append_char(buf, ' ');
eina_strbuf_append_char(buf, '"');
while ((c = *(arg++)))
{
#ifndef _WIN32
if (c == '"' || c == '$') eina_strbuf_append_char(buf, '\\');
eina_strbuf_append_char(buf, c);
#else
if (c == '"') eina_strbuf_append_char(buf, '\\');
else if (c == '%') eina_strbuf_append_char(buf, '"');
eina_strbuf_append_char(buf, c);
if (c == '%') eina_strbuf_append_char(buf, '"');
#endif
}
eina_strbuf_append_char(buf, '"');
}
ret = strdup(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
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;
}
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 = strdup(eina_strbuf_string_get(buffer));
eina_strbuf_free(buffer);
return ret;
}
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 Eina_Strbuf *
_gen_doc_buf(const Eolian_State *state, const Eolian_Documentation *doc,
const char *group, const char *el, int indent)
{
if (!doc) return NULL;
const char *sum = eolian_documentation_summary_get(doc);
const char *desc = eolian_documentation_description_get(doc);
const char *since = eolian_documentation_since_get(doc);
Eina_Strbuf *buf = eina_strbuf_new();
if (!desc)
_gen_doc_brief(state, sum, since, group, el, indent, buf);
else
_gen_doc_full(state, sum, desc, since, group, el, indent, buf);
return buf;
}
Eina_Strbuf *
docs_generate_full(const Eolian_Documentation *doc, const char *group,
int indent, Eina_Bool use_legacy)
{
if (!doc) return NULL;
const char *sum = eolian_documentation_summary_get(doc);
const char *desc = eolian_documentation_description_get(doc);
const char *since = eolian_documentation_since_get(doc);
Eina_Strbuf *buf = eina_strbuf_new();
if (!desc)
_gen_doc_brief(sum, since, group, indent, buf, use_legacy);
else
_gen_doc_full(sum, desc, since, group, indent, buf, use_legacy);
return buf;
}
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 void
ede_game_debug_panel_update(double now)
{
Eina_Strbuf *t;
char *ts;
static int last_second = 0;
static int fps_counter = 0;
static int FPS = 0;
if (!_debug_panel_enable) return;
// calc FPS
fps_counter++;
if ((int)now > last_second)
{
//~ D("last second %d %d", last_second, fps_counter);
last_second = now;
FPS = fps_counter;
fps_counter = 0;
}
t = eina_strbuf_new();
// game info
eina_strbuf_append(t, "<h3>game:</h3><br>");
ts = ede_game_time_get(now);
eina_strbuf_append_printf(t, "FPS %d time %s<br>", FPS, ts);
EDE_FREE(ts);
eina_strbuf_append_printf(t, "lives %d<br>bucks %d<br>",
_player_lives, _player_bucks);
eina_strbuf_append(t, "<br>");
// info from other components
ede_enemy_debug_info_fill(t);
ede_tower_debug_info_fill(t);
ede_bullet_debug_info_fill(t);
ede_level_debug_info_fill(t);
ede_gui_debug_text_set(eina_strbuf_string_get(t));
eina_strbuf_free(t);
}
static void
title_set(Ecore_Evas *ee, const char *title, int progress)
{
Eina_Strbuf* buffer;
if (!title || !*title) {
ecore_evas_title_set(ee, APP_NAME);
return;
}
buffer = eina_strbuf_new();
if (progress < 100)
eina_strbuf_append_printf(buffer, "%s (%d%%) - %s", title, progress, APP_NAME);
else
eina_strbuf_append_printf(buffer, "%s - %s", title, APP_NAME);
ecore_evas_title_set(ee, eina_strbuf_string_get(buffer));
eina_strbuf_free(buffer);
}
