void unistrcpy(unichar *to, const unichar *from)
{
int len = unistrlen(from);
int i;
for (i = 0; i < len; ++i) to[i] = from[i];
unistrlen(to) = len;
}
unichar *unistrcat(const unichar *str1, const unichar *str2)
{
int len = unistrlen(str1) + unistrlen(str2);
unichar *r = mm_alloc((len + 1) * sizeof(unichar) + sizeof(int));
unichar *rr = (unichar *)((int)r + sizeof(int));
*((int *)r) = len;
memcpy(rr, str1, unistrlen(str1) * sizeof(unichar));
memcpy(rr + unistrlen(str1), str2, unistrlen(str2) * sizeof(unichar));
return rr;
}
int unistrcmp(const unichar *str1, const unichar *str2)
{
int len1 = unistrlen(str1);
int len2 = unistrlen(str2);
int i, r;
if (len1 != len2) return len1 - len2;
for (i = 0; i < len1; ++i) {
if ((r = str1[i] - str2[i])) return r;
}
return 0;
}
/**************************************************************************
Convert Unistring ( Uint16[] ) to UniChar structure.
Memmory alocation -> after all use need call del_chain(...) !
**************************************************************************/
static struct UniChar *text2chain(const Uint16 * pInText)
{
int i, len;
struct UniChar *pOutChain = NULL;
struct UniChar *chr_tmp = NULL;
len = unistrlen(pInText);
if (len == 0) {
return pOutChain;
}
pOutChain = fc_calloc(1, sizeof(struct UniChar));
pOutChain->chr[0] = pInText[0];
pOutChain->chr[1] = 0;
chr_tmp = pOutChain;
for (i = 1; i < len; i++) {
chr_tmp->next = fc_calloc(1, sizeof(struct UniChar));
chr_tmp->next->chr[0] = pInText[i];
chr_tmp->next->chr[1] = 0;
chr_tmp->next->prev = chr_tmp;
chr_tmp = chr_tmp->next;
}
return pOutChain;
}
void _uniprint(unichar *s)
{
int len = unistrlen(s);
int i;
for (i = 0; i < len; ++i) printf("%c", s[i]);
printf("\n");
}
int unistrchr(const unichar *str, int c)
{
int len = unistrlen(str);
int i;
for (i = 0; i < len; ++i) {
if (str[i] == c) return 1;
}
return 0;
}
int unistrpos(unichar *str, int start, unichar *s2)
{
unichar *s1 = str;
int l1 = unistrlen(s1);
int l2 = unistrlen(s2);
s1 += start;
l1 -= start;
while (l1 >= l2) {
if (memcmp(s1, s2, l2 * sizeof(unichar)) == 0) {
return s1 - str;
}
s1++;
l1--;
}
return -1;
}
static char *dup_u2c(int cp, const WCHAR *uc)
{
int len;
char *cptr;
const union cptable *cpdef = find_codepage(cp);
if(cpdef)
len = wine_cp_wcstombs(cpdef, 0, uc, unistrlen(uc)+1, NULL, 0, NULL, NULL);
else
len = wine_utf8_wcstombs(0, uc, unistrlen(uc)+1, NULL, 0);
cptr = xmalloc(len);
if (cpdef)
len = wine_cp_wcstombs(cpdef, 0, uc, unistrlen(uc)+1, cptr, len, NULL, NULL);
else
len = wine_utf8_wcstombs(0, uc, unistrlen(uc)+1, cptr, len);
if (len < 0)
internal_error(__FILE__, __LINE__, "Buffer overflow? code %d\n", len);
return cptr;
}
const char *tochars(const unichar *str)
{
static char buf[65536];
int i;
int len = unistrlen(str);
for (i = 0; i < len && i < 65530; ++i) buf[i] = (char)str[i];
buf[i] = 0;
return buf;
}
unichar *unistrdup(const unichar *str)
{
int len = unistrlen(str);
unichar *r = mm_alloc((len + 1) * sizeof(unichar) + sizeof(int));
unichar *rr = (unichar *)((int)r + sizeof(int));
*((int *)r) = len;
memcpy(rr, str, (len) * sizeof(unichar));
return rr;
}
unichar *unisubstrdup(const unichar *a, int start, int len)
{
if (len == 0) return unistrdup_str("");
int lenofa = unistrlen(a);
while (start < 0) start += lenofa;
if (start >= lenofa) return unistrdup_str("");
int maxcpy = lenofa - start;
if (len > 0) {
maxcpy = maxcpy < len ? maxcpy : len;
}
unichar *r = mm_alloc((maxcpy + 1) * sizeof(unichar) + sizeof(int));
unichar *rr = (unichar *)((int)r + sizeof(int));
*((int *)r) = maxcpy;
memcpy(rr, a + start, maxcpy * sizeof(unichar));
return rr;
}
/* charCodeAt */
static int strpto_charCodeAt(PSTATE *ps, Value *args, Value *_this, Value *ret, int asc)
{
if (asc) die("Execute String.prototype.charCodeAt as constructor\n");
Value target = { 0 };
value_copy(target, *_this);
value_tostring(&target);
int slen = unistrlen(target.d.str);
int pos = 0;
Value *vpos;
if ((vpos = value_object_lookup_array(args, 0, NULL))) {
value_toint32(vpos);
pos = (int)vpos->d.num;
}
if (pos < 0 || pos >= slen) {
value_make_number(*ret, ieee_makenan());
} else {
value_make_number(*ret, target.d.str[pos]);
}
value_erase(target);
return 0;
}
/**************************************************************************
Convert string from display encoding (16 bit unicode) to
local encoding (8 bit char) and resut put in 'pToString'.
if 'pToString' == NULL then resulting string will be allocate automaticaly.
'length' give real sizeof 'pToString' array.
Function return (char *) pointer to (new) pToString.
**************************************************************************/
char *convertcopy_to_chars(char *pToString, size_t length,
const Uint16 * pFromUniString)
{
/* Start Parametrs */
const char *pFromcode = get_display_encoding();
const char *pTocode = get_internal_encoding();
const char *pStart = (char *) pFromUniString;
size_t ulength = (unistrlen(pFromUniString) + 1) * 2;
/* ===== */
char *pResult;
iconv_t cd;
/* ===== */
if (!pStart) {
return pToString;
}
cd = iconv_open(pTocode, pFromcode);
if (cd == (iconv_t) (-1)) {
if (errno != EINVAL) {
return pToString;
}
}
if (pToString) {
pResult = pToString;
} else {
length = ulength * 2; /* UTF-8: up to 4 bytes per char */
pResult = fc_calloc(1, length);
}
iconv(cd, NULL, NULL, NULL, NULL); /* return to the initial state */
/* Do the conversion for real. */
{
const char *pInptr = pStart;
size_t Insize = ulength;
char *pOutptr = pResult;
size_t Outsize = length;
while (Insize > 0 && Outsize > 0) {
size_t Res =
iconv(cd, (ICONV_CONST char **) &pInptr, &Insize, &pOutptr, &Outsize);
if (Res == (size_t) (-1)) {
log_error("iconv() error: %s", fc_strerror(fc_get_errno()));
if (errno == EINVAL) {
break;
} else {
int saved_errno = errno;
iconv_close(cd);
errno = saved_errno;
if(!pToString) {
FC_FREE(pResult);
}
return pToString;
}
}
}
{
size_t Res = iconv(cd, NULL, NULL, &pOutptr, &Outsize);
if (Res == (size_t) (-1)) {
int saved_errno = errno;
iconv_close(cd);
errno = saved_errno;
if(!pToString) {
FC_FREE(pResult);
}
return pToString;
}
}
}
iconv_close(cd);
return pResult;
}
static char *make_string(WCHAR *uc, int len, int codepage)
{
char *str = xmalloc(7*len + 1);
char *cptr = str;
int i;
int b;
if(!codepage)
{
*cptr++ = ' ';
*cptr++ = 'L';
*cptr++ = '"';
for(i = b = 0; i < len; i++, uc++)
{
switch(*uc)
{
case '\a': *cptr++ = '\\'; *cptr++ = 'a'; b += 2; break;
case '\b': *cptr++ = '\\'; *cptr++ = 'b'; b += 2; break;
case '\f': *cptr++ = '\\'; *cptr++ = 'f'; b += 2; break;
case '\n': *cptr++ = '\\'; *cptr++ = 'n'; b += 2; break;
case '\r': *cptr++ = '\\'; *cptr++ = 'r'; b += 2; break;
case '\t': *cptr++ = '\\'; *cptr++ = 't'; b += 2; break;
case '\v': *cptr++ = '\\'; *cptr++ = 'v'; b += 2; break;
case '\\': *cptr++ = '\\'; *cptr++ = '\\'; b += 2; break;
case '"': *cptr++ = '\\'; *cptr++ = '"'; b += 2; break;
default:
if (*uc < 0x100 && isprint(*uc))
{
*cptr++ = *uc;
b++;
}
else
{
int n = sprintf(cptr, "\\x%04x", *uc & 0xffff);
cptr += n;
b += n;
}
break;
}
if(i < len-1 && b >= 72)
{
*cptr++ = '"';
*cptr++ = ',';
*cptr++ = '\n';
*cptr++ = ' ';
*cptr++ = 'L';
*cptr++ = '"';
b = 0;
}
}
if (unicodeout)
len = (len + 1) & ~1;
else
len = (len + 3) & ~3;
for(; i < len; i++)
{
*cptr++ = '\\';
*cptr++ = 'x';
*cptr++ = '0';
*cptr++ = '0';
*cptr++ = '0';
*cptr++ = '0';
}
*cptr++ = '"';
*cptr = '\0';
}
else
{
char *tmp, *cc;
int mlen;
const union cptable *cpdef = find_codepage(codepage);
if (cpdef)
mlen = wine_cp_wcstombs(cpdef, 0, uc, unistrlen(uc)+1, NULL, 0, NULL, NULL);
else
mlen = wine_utf8_wcstombs(0, uc, unistrlen(uc)+1, NULL, 0);
cc = tmp = xmalloc(mlen);
if (cpdef) {
if((i = wine_cp_wcstombs(cpdef, 0, uc, unistrlen(uc)+1, tmp, mlen, NULL, NULL)) < 0)
internal_error(__FILE__, __LINE__, "Buffer overflow? code %d\n", i);
} else {
if((i = wine_utf8_wcstombs(0, uc, unistrlen(uc)+1, tmp, mlen)) < 0)
internal_error(__FILE__, __LINE__, "Buffer overflow? code %d\n", i);
}
*cptr++ = ' ';
*cptr++ = '"';
for(i = b = 0; i < len; i++, cc++)
{
switch(*cc)
{
case '\a': *cptr++ = '\\'; *cptr++ = 'a'; b += 2; break;
case '\b': *cptr++ = '\\'; *cptr++ = 'b'; b += 2; break;
case '\f': *cptr++ = '\\'; *cptr++ = 'f'; b += 2; break;
case '\n': *cptr++ = '\\'; *cptr++ = 'n'; b += 2; break;
case '\r': *cptr++ = '\\'; *cptr++ = 'r'; b += 2; break;
case '\t': *cptr++ = '\\'; *cptr++ = 't'; b += 2; break;
case '\v': *cptr++ = '\\'; *cptr++ = 'v'; b += 2; break;
case '\\': *cptr++ = '\\'; *cptr++ = '\\'; b += 2; break;
case '"': *cptr++ = '\\'; *cptr++ = '"'; b += 2; break;
default:
if(isprint(*cc))
{
*cptr++ = *cc;
b++;
}
else
{
int n = sprintf(cptr, "\\x%02x", *cc & 0xff);
cptr += n;
b += n;
}
break;
}
if(i < len-1 && b >= 72)
{
*cptr++ = '"';
*cptr++ = ',';
*cptr++ = '\n';
*cptr++ = ' ';
*cptr++ = '"';
b = 0;
}
}
len = (len + 3) & ~3;
for(; i < len; i++)
{
*cptr++ = '\\';
*cptr++ = 'x';
*cptr++ = '0';
*cptr++ = '0';
}
*cptr++ = '"';
*cptr = '\0';
free(tmp);
}
return str;
}
/**************************************************************************
Create Edit Field surface ( with Text) and blit them to Main.screen,
on position 'pEdit_Widget->size.x , pEdit_Widget->size.y'
Graphic is taken from 'pEdit_Widget->theme'
Text is taken from 'pEdit_Widget->sting16'
if flag 'FW_DRAW_THEME_TRANSPARENT' is set theme will be blit
transparent ( Alpha = 128 )
function return Hight of created surfaces or (-1) if theme surface can't
be created.
**************************************************************************/
static int redraw_edit(struct widget *pEdit_Widget)
{
int ret;
if (get_wstate(pEdit_Widget) == FC_WS_PRESSED) {
return redraw_edit_chain((struct EDIT *)pEdit_Widget->data.ptr);
} else {
int iRet = 0;
SDL_Rect rDest = {pEdit_Widget->size.x, pEdit_Widget->size.y, 0, 0};
SDL_Surface *pEdit = NULL;
SDL_Surface *pText;
ret = (*baseclass_redraw)(pEdit_Widget);
if (ret != 0) {
return ret;
}
if (pEdit_Widget->string16->text &&
get_wflags(pEdit_Widget) & WF_PASSWD_EDIT) {
Uint16 *backup = pEdit_Widget->string16->text;
size_t len = unistrlen(backup) + 1;
char *cBuf = fc_calloc(1, len);
memset(cBuf, '*', len - 1);
cBuf[len - 1] = '\0';
pEdit_Widget->string16->text = convert_to_utf16(cBuf);
pText = create_text_surf_from_str16(pEdit_Widget->string16);
FC_FREE(pEdit_Widget->string16->text);
FC_FREE(cBuf);
pEdit_Widget->string16->text = backup;
} else {
pText = create_text_surf_from_str16(pEdit_Widget->string16);
}
pEdit = create_bcgnd_surf(pEdit_Widget->theme, get_wstate(pEdit_Widget),
pEdit_Widget->size.w, pEdit_Widget->size.h);
if (!pEdit) {
return -1;
}
/* blit theme */
alphablit(pEdit, NULL, pEdit_Widget->dst->surface, &rDest);
/* set position and blit text */
if (pText) {
rDest.y += (pEdit->h - pText->h) / 2;
/* blit centred text to botton */
if (pEdit_Widget->string16->style & SF_CENTER) {
rDest.x += (pEdit->w - pText->w) / 2;
} else {
if (pEdit_Widget->string16->style & SF_CENTER_RIGHT) {
rDest.x += pEdit->w - pText->w - adj_size(5);
} else {
rDest.x += adj_size(5); /* cennter left */
}
}
alphablit(pText, NULL, pEdit_Widget->dst->surface, &rDest);
}
/* pText */
iRet = pEdit->h;
/* Free memory */
FREESURFACE(pText);
FREESURFACE(pEdit);
return iRet;
}
return 0;
}
