void gui_paste_from_clipboard(struct gui_window *g, int x, int y)
{
/* This and the other clipboard code is heavily based on the RKRM examples */
struct ContextNode *cn;
ULONG rlen=0,error;
struct CSet cset;
LONG codeset = 0;
char *clip;
STRPTR readbuf = AllocVec(1024,MEMF_PRIVATE | MEMF_CLEAR);
cset.CodeSet = 0;
if(OpenIFF(iffh,IFFF_READ)) return;
if(StopChunk(iffh,ID_FTXT,ID_CHRS)) return;
if(StopChunk(iffh,ID_FTXT,ID_CSET)) return;
while(1)
{
error = ParseIFF(iffh,IFFPARSE_SCAN);
if(error == IFFERR_EOC) continue;
else if(error) break;
cn = CurrentChunk(iffh);
if((cn)&&(cn->cn_Type == ID_FTXT)&&(cn->cn_ID == ID_CSET))
{
rlen = ReadChunkBytes(iffh,&cset,32);
if(cset.CodeSet == 1) codeset = 106;
else codeset = cset.CodeSet;
}
if((cn)&&(cn->cn_Type == ID_FTXT)&&(cn->cn_ID == ID_CHRS))
{
while((rlen = ReadChunkBytes(iffh,readbuf,1024)) > 0)
{
if(codeset == 0)
{
utf8_from_local_encoding(readbuf,rlen,&clip);
}
else
{
utf8_from_enc(readbuf,
(const char *)ObtainCharsetInfo(DFCS_NUMBER,
codeset, DFCS_MIMENAME),
rlen, &clip);
}
browser_window_paste_text(g->shared->bw,clip,rlen,true);
}
if(rlen < 0) error = rlen;
}
}
CloseIFF(iffh);
}
nserror utf8_from_local_encoding(const char *string, size_t len, char **result)
{
const char *encname = "ISO-8859-1";
#ifdef __amigaos4__
LONG charset;
charset = GetDiskFontCtrl(DFCTRL_CHARSET);
encname = (const char *) ObtainCharsetInfo(DFCS_NUMBER, charset, DFCS_MIMENAME);
#endif
return utf8_from_enc(string,encname,len,result,NULL);
}
nserror nsgtk_viewsource(GtkWindow *parent, struct browser_window *bw)
{
nserror ret;
struct hlcache_handle *hlcontent;
const char *source_data;
unsigned long source_size;
char *ndata = NULL;
size_t ndata_len;
char *filename;
char *title;
hlcontent = browser_window_get_content(bw);
if (hlcontent == NULL) {
return NSERROR_BAD_PARAMETER;
}
if (content_get_type(hlcontent) != CONTENT_HTML) {
return NSERROR_BAD_CONTENT;
}
source_data = content_get_source_data(hlcontent, &source_size);
ret = nsurl_nice(browser_window_get_url(bw), &filename, false);
if (ret != NSERROR_OK) {
filename = strdup(messages_get("SaveSource"));
if (filename == NULL) {
return NSERROR_NOMEM;
}
}
title = malloc(strlen(nsurl_access(browser_window_get_url(bw))) + SLEN("Source of - NetSurf") + 1);
if (title == NULL) {
free(filename);
return NSERROR_NOMEM;
}
sprintf(title, "Source of %s - NetSurf", nsurl_access(browser_window_get_url(bw)));
ret = utf8_from_enc(source_data,
content_get_encoding(hlcontent, CONTENT_ENCODING_NORMAL),
source_size,
&ndata,
&ndata_len);
if (ret == NSERROR_OK) {
ret = nsgtk_viewdata(title, filename, ndata, ndata_len);
}
free(filename);
free(title);
return ret;
}
nserror utf8_from_local_encoding(const char *string, size_t len, char **result)
{
return utf8_from_enc(string, "ATARIST", len, result, NULL);
}
/**
* Convert a string encoded in the system local encoding to UTF-8
*
* \param string The string to convert
* \param len The length (in bytes) of the string, or 0
* \param result Pointer to location in which to store result
* \return An nserror code
*/
nserror utf8_from_local_encoding(const char *string, size_t len, char **result)
{
os_error *error;
int alphabet, i, num_specials = 0, result_alloc;
#define SPECIAL_CHUNK_SIZE 255
size_t off, prev_off, cur_off;
char *temp;
const char *enc;
nserror err;
assert(string && result);
/* get length, if necessary */
if (len == 0)
len = strlen(string);
/* read system alphabet */
error = xosbyte1(osbyte_ALPHABET_NUMBER, 127, 0, &alphabet);
if (error)
alphabet = territory_ALPHABET_LATIN1;
/* UTF-8 -> simply copy string */
if (alphabet == 111 /* UTF-8 */) {
temp = strndup(string, len);
if (!temp)
return NSERROR_NOMEM;
*result = temp;
return NSERROR_OK;
}
/* get encoding name */
enc = (alphabet <= CONT_ENC_END ? localencodings[alphabet - 100]
: (alphabet == 120 ?
localencodings[CONT_ENC_END - 100 + 1]
: localencodings[0]));
/* create output buffer (oversized) */
result_alloc = (len * 4) + (3 * SPECIAL_CHUNK_SIZE) + 1;
*(result) = malloc(result_alloc);
if (!(*result))
return NSERROR_NOMEM;
*(*result) = '\0';
prev_off = 0;
cur_off = 0;
/* Iterate over string, converting input between unconvertable
* characters and inserting appropriate output for characters
* that iconv can't handle. */
for (off = 0; off < len; off++) {
if (string[off] < 0x80 || string[off] > 0x9f)
continue;
for (i = 0; i != NOF_ELEMENTS(special_chars); i++) {
if (string[off] != special_chars[i].local)
continue;
/* 0 length has a special meaning to utf8_from_enc */
if (off - prev_off > 0) {
err = utf8_from_enc(string + prev_off, enc,
off - prev_off, &temp, NULL);
if (err != NSERROR_OK) {
assert(err != NSERROR_BAD_ENCODING);
LOG("utf8_from_enc failed");
free(*result);
return NSERROR_NOMEM;
}
strcat((*result) + cur_off, temp);
cur_off += strlen(temp);
free(temp);
}
strcat((*result) + cur_off, special_chars[i].utf);
cur_off += special_chars[i].len;
prev_off = off + 1;
num_specials++;
if (num_specials % SPECIAL_CHUNK_SIZE ==
SPECIAL_CHUNK_SIZE - 1) {
char *temp = realloc((*result),
result_alloc +
(3 * SPECIAL_CHUNK_SIZE));
if (!temp) {
free(*result);
return NSERROR_NOMEM;
}
*result = temp;
result_alloc += (3 * SPECIAL_CHUNK_SIZE);
}
}
}
/* handle last chunk
* NB. 0 length has a special meaning to utf8_from_enc */
if (prev_off < len) {
err = utf8_from_enc(string + prev_off, enc, len - prev_off,
&temp, NULL);
if (err != NSERROR_OK) {
assert(err != NSERROR_BAD_ENCODING);
LOG("utf8_from_enc failed");
free(*result);
return NSERROR_NOMEM;
}
strcat((*result) + cur_off, temp);
cur_off += strlen(temp);
free(temp);
}
/* and copy into more reasonably-sized buffer */
temp = realloc((*result), cur_off + 1);
if (!temp) {
LOG("realloc failed");
free(*result);
return NSERROR_NOMEM;
}
*result = temp;
return NSERROR_OK;
}
char *ami_clipboard_cat_collection(struct CollectionItem *ci, LONG codeset, size_t *text_length)
{
struct CollectionItem *ci_new = NULL, *ci_next, *ci_curr = ci;
size_t len = 0;
char *text = NULL, *p;
/* Scan the collected chunks to find out the total size.
* If they are not in UTF-8, convert the chunks first and create a new CollectionItem list.
*/
do {
switch(codeset) {
case 106:
len += ci_curr->ci_Size;
break;
case 0:
if(ci_new) {
ci_next->ci_Next = AllocVecTags(sizeof(struct CollectionItem), AVT_ClearWithValue, 0, TAG_DONE);
ci_next = ci_next->ci_Next;
} else {
ci_new = AllocVecTags(sizeof(struct CollectionItem), AVT_ClearWithValue, 0, TAG_DONE);
ci_next = ci_new;
}
utf8_from_local_encoding(ci_curr->ci_Data, ci_curr->ci_Size, (char **)&ci_next->ci_Data);
ci_next->ci_Size = strlen(ci_next->ci_Data);
len += ci_next->ci_Size;
break;
default:
if(ci_new) {
ci_next->ci_Next = AllocVecTags(sizeof(struct CollectionItem), AVT_ClearWithValue, 0, TAG_DONE);
ci_next = ci_next->ci_Next;
} else {
ci_new = AllocVecTags(sizeof(struct CollectionItem), AVT_ClearWithValue, 0, TAG_DONE);
ci_next = ci_new;
}
utf8_from_enc(ci_curr->ci_Data,
(const char *)ObtainCharsetInfo(DFCS_NUMBER,
codeset, DFCS_MIMENAME),
ci_curr->ci_Size, (char **)&ci_next->ci_Data, NULL);
ci_next->ci_Size = strlen(ci_next->ci_Data);
len += ci_next->ci_Size;
break;
}
} while (ci_curr = ci_curr->ci_Next);
text = malloc(len);
if(text == NULL) return NULL;
/* p points to the end of the buffer. This is because the chunks are
* in the list in reverse order. */
p = text + len;
if(ci_new) {
ci_curr = ci_new;
} else {
ci_curr = ci;
}
do {
p -= ci_curr->ci_Size;
memcpy(p, ci_curr->ci_Data, ci_curr->ci_Size);
ci_next = ci_curr->ci_Next;
if(ci_new) {
free(ci_curr->ci_Data);
FreeVec(ci_curr);
}
} while (ci_curr = ci_next);
*text_length = len;
return text;
}
