/**
*
* @param widget
* @param msg
*/
void cwt_msgbox_set_msg(CWT_WIDGET_PTR widget, const CWT_CHAR* msg)
{
if( msg ) {
CWT_WIDGET_PTR label;
const CWT_CHAR *ptr = msg;
StringBufferPtr sb;
sb = strbuf_new_defaults();
while( *ptr ) {
if( *ptr == '\n' ) {
label = cwt_new_widget(0, CWT_WT_LABEL, widget);
cwt_label_set_text(label, strbuf_cstr(sb));
strbuf_clear(sb);
} else {
strbuf_append_char(sb, *ptr);
}
ptr++;
}
if( strbuf_size(sb) > 0 ) {
label = cwt_new_widget(0, CWT_WT_LABEL, widget);
cwt_label_set_text(label, strbuf_cstr(sb));
}
strbuf_delete(sb);
widget->need_layout = TRUE;
}
}
static std::string s_getPackageName(const std::vector<FlaDefinition>& definitions, float scale)
{
strbuf_init_stack(result, 64);
CLOVER_SCOPE_EXIT
{
strbuf_finish(result);
};
for (auto& def : definitions)
{
auto md5 = def.getDataMd5();
strbuf_push_lstring(result, md5.c_str(), md5.size());
strbuf_push_char(result, '_');
strbuf_push_uint32(result, def.getId());
strbuf_push_char(result, '_');
}
strbuf_push_uint32(result, static_cast<uint32_t>(scale * FlaSDK::getTextureContentScaleFactor() * 100));
md5_state_t state;
md5_init(&state);
md5_append(&state, (md5_byte_t*)strbuf_cstr(result), (int)strbuf_length(result));
md5_byte_t buf[16];
md5_finish(&state, buf);
return libra::str_md5HexString(buf);
}
char* read_file(char *path)
{
HEX_ASSERT(path);
Strbuf strbuf = strbuf_create();
HEX_ASSERT(strbuf);
char c;
while( (c = fgetc(_f) ) != EOF ) {
if(c == '\n') continue;
char s[2];
memset(s, 0, sizeof(s));
snprintf(s, sizeof(s), "%c", c);
strbuf_append(strbuf, s);
}
char *str = strdup(strbuf_cstr(strbuf));
HEX_ASSERT(str);
strbuf_free(&strbuf);
return str;
}
/*
* mingled name = 'name' + '_' + type + '_' + 'indent_level'
* */
char* vtable_mingle_name(VtableEntry entry)
{
HEX_ASSERT(entry);
HEX_ASSERT(entry->name);
Strbuf strbuf = strbuf_create();
HEX_ASSERT(strbuf);
char type_str[2];
char indent_level_str[5];
snprintf(type_str, sizeof(type_str), "%u", (unsigned int)entry->type);
snprintf(indent_level_str, sizeof(indent_level_str), "%u", entry->indent_level);
strbuf_append(strbuf, (const char*)entry->name);
strbuf_append(strbuf, "_");
strbuf_append(strbuf, (const char*)type_str);
strbuf_append(strbuf, "_");
strbuf_append(strbuf, (const char*)indent_level_str);
char *mingled_name = strbuf_cstr(strbuf);
HEX_ASSERT(mingled_name);
HEX_FREE(strbuf);
return mingled_name;
}
void _cwt_render_input(CWT_WIDGET_PTR widget)
{
CWT_INPUT_PTR input = CWT_CAST(widget, CWT_INPUT_PTR);
CWT_VIEWPORT vp;
CWT_STYLE_PTR style;
CWT_RECT text_rect;
const CWT_CHAR* text = strbuf_cstr(input->strbuf);
_cwt_get_viewport(&vp);
JQ_ASSERT(widget);
/*_cwt_text_rect(0, 0, vp.width, vp.height, _CWT_WIDGET_STYLE(widget), text + input->start_pos, &text_rect);*/
text_rect.left = 0;
text_rect.top = 0;
text_rect.width = vp.width;
text_rect.height = vp.height;
style = _CWT_WIDGET_STYLE(widget);
_cwt_outtext_box(text + input->start_pos, &text_rect, &style->font, style->align, style->color, CWT_Transparent);
if( cwt_widget_is_focused(widget) ) {
int cursor_left = 0;
CWT_CHAR *left_text;
left_text = strbuf_substr(input->strbuf, input->start_pos, input->pos);
if( left_text ) {
_cwt_text_size_wh(&style->font, left_text, &cursor_left, NULL);
JQ_FREE(left_text);
}
_cwt_input_render_cursor(cursor_left, text_rect.top, text_rect.height);
}
}
static std::string s_key(lua_Debug* debug)
{
strbuf_init_stack(buf, 128);
strbuf_push_string(buf, debug->source);
strbuf_push_uint32(buf, debug->linedefined);
auto result = strbuf_cstr(buf);
strbuf_finish(buf);
return result;
}
static std::string sizeToString(const rbp::RectSize& size)
{
strbuf_init_stack(result, 32);
CLOVER_SCOPE_EXIT
{
strbuf_finish(result);
};
strbuf_push_pair(result, size.width, size.height);
return strbuf_cstr(result);
}
char *
htmlent_decode(const char *html)
{
bool in_ent = false;
struct strbuf *buf = strbuf_init();
struct strbuf *ent = strbuf_init();
char *res;
const char *dec;
while (*html) {
char c = *html++;
if (in_ent) {
strbuf_addc(ent, c);
if (c == ';') {
char *ent_cstr = strbuf_cstr(ent);
strbuf_clear(ent);
in_ent = false;
dec = htmlent_table_lookup_dec(ent_cstr);
amz_free(ent_cstr);
if (dec != NULL)
strbuf_add(buf, dec);
}
continue;
} else if (c == '&') {
in_ent = true;
strbuf_addc(ent, c);
continue;
}
strbuf_addc(buf, c);
}
res = strbuf_cstr(buf);
strbuf_free(buf);
strbuf_free(ent);
return res;
}
static std::string rectToString(const rbp::Rect& rt)
{
strbuf_init_stack(result, 32);
CLOVER_SCOPE_EXIT
{
strbuf_finish(result);
};
strbuf_push_char(result, '{');
strbuf_push_pair(result, rt.x, rt.y);
strbuf_push_char(result, ',');
strbuf_push_pair(result, rt.width, rt.height);
strbuf_push_char(result, '}');
return strbuf_cstr(result);
}
static std::string s_getImageName(const std::string& name, int index)
{
strbuf_init_stack(imageName, 64);
CLOVER_SCOPE_EXIT
{
strbuf_finish(imageName);
};
strbuf_push_lstring(imageName, name.c_str(), name.size());
libra_path_remove_ext(imageName);
strbuf_push_char(imageName, '_');
strbuf_push_uint32(imageName, index);
strbuf_push_string(imageName, ".png");
return strbuf_cstr(imageName);
}
std::string TextureFrames::transToLuaConfig(const std::string& name, int index)
{
strbuf_init_stack(result, 64);
CLOVER_SCOPE_EXIT
{
strbuf_finish(result);
};
auto imageName = s_getImageName(name, index);
s_transToLuaMetadata(result, _size, imageName);
for (auto& frame : _frames)
{
s_transToLuaFrame(result, frame);
}
auto cstr = strbuf_cstr(result);
return std::string(cstr, cstr + strbuf_length(result));
}
char* ftable_mingle_name(FtableEntry entry)
{
HEX_ASSERT(entry);
HEX_ASSERT(entry->name);
Strbuf strbuf = strbuf_create();
HEX_ASSERT(strbuf);
strbuf_append(strbuf, (const char*)entry->name);
ParameterList paramlist = (ParameterList)entry->paramlist;
while(paramlist) {
Parameter param = paramlist->parameter;
HEX_ASSERT(param);
HEX_ASSERT(param->parameter_name);
strbuf_append(strbuf, "_");
strbuf_append(strbuf, (const char*)param->parameter_name);
strbuf_append(strbuf, "-");
if(param->type_specifier) {
char buf[10];
snprintf(buf, sizeof(buf), "%d", param->type_specifier);
strbuf_append(strbuf, buf);
} else {
strbuf_append(strbuf, (const char*)param->custom_type);
}
paramlist = paramlist->next;
}
char *mingled_name = strdup(strbuf_cstr(strbuf));
HEX_ASSERT(mingled_name);
HEX_FREE(strbuf);
return mingled_name;
}
const CWT_CHAR* cwt_input_text(CWT_WIDGET_PTR widget)
{
CWT_INPUT_PTR input = (CWT_INPUT_PTR)widget;
JQ_ASSERT(widget);
return strbuf_cstr(input->strbuf);
}
void _cwt_size_min_input(CWT_WIDGET_PTR widget, CWT_SIZE *sz)
{
CWT_INPUT_PTR input = CWT_CAST(widget, CWT_INPUT_PTR);
JQ_ASSERT(widget);
_cwt_text_size(&_CWT_WIDGET_STYLE(widget)->font, strbuf_cstr(input->strbuf), sz);
}
