You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
525 lines
14 KiB
525 lines
14 KiB
/*
|
|
* Copyright 2013 Ole Loots <ole@monochrom.net>
|
|
*
|
|
* This file is part of NetSurf, http://www.netsurf-browser.org/
|
|
*
|
|
* NetSurf is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; version 2 of the License.
|
|
*
|
|
* NetSurf is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Module Description:
|
|
*
|
|
* AES Object tree tools.
|
|
*
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include "gemtk.h"
|
|
|
|
char *gemtk_obj_get_text(OBJECT * tree, short idx)
|
|
{
|
|
static char p[]="";
|
|
|
|
switch (tree[idx].ob_type & 0x00FF) {
|
|
case G_BUTTON:
|
|
case G_STRING:
|
|
case G_TITLE:
|
|
return( tree[idx].ob_spec.free_string);
|
|
case G_TEXT:
|
|
case G_BOXTEXT:
|
|
case G_FTEXT:
|
|
case G_FBOXTEXT:
|
|
return (tree[idx].ob_spec.tedinfo->te_ptext);
|
|
case G_ICON:
|
|
case G_CICON:
|
|
return (tree[idx].ob_spec.iconblk->ib_ptext);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return (p);
|
|
}
|
|
|
|
/*
|
|
static void set_text(OBJECT *obj, short idx, char * text, int len)
|
|
{
|
|
char spare[255];
|
|
|
|
if( len > 254 )
|
|
len = 254;
|
|
if( text != NULL ) {
|
|
strncpy(spare, text, 254);
|
|
} else {
|
|
strcpy(spare, "");
|
|
}
|
|
|
|
set_string(obj, idx, spare);
|
|
}
|
|
*/
|
|
|
|
char gemtk_obj_set_str_safe(OBJECT * tree, short idx, const char *txt)
|
|
{
|
|
char spare[204];
|
|
short type = 0;
|
|
short maxlen = 0;
|
|
|
|
|
|
type = (tree[idx].ob_type & 0xFF);
|
|
if (type == G_FTEXT || type == G_FBOXTEXT) {
|
|
TEDINFO *ted = ((TEDINFO *)get_obspec(tree, idx));
|
|
maxlen = ted->te_tmplen+1;
|
|
if (maxlen > 200) {
|
|
maxlen = 200;
|
|
} else if (maxlen < 0) {
|
|
maxlen = 0;
|
|
}
|
|
} else {
|
|
assert((type == G_FTEXT) || (type == G_FBOXTEXT));
|
|
}
|
|
|
|
snprintf(spare, maxlen, "%s", txt);
|
|
set_string(tree, idx, spare);
|
|
|
|
return(0);
|
|
}
|
|
|
|
OBJECT *gemtk_obj_get_tree(int idx)
|
|
{
|
|
|
|
OBJECT *tree;
|
|
|
|
rsrc_gaddr(R_TREE, idx, &tree);
|
|
|
|
return tree;
|
|
}
|
|
|
|
bool gemtk_obj_is_inside(OBJECT * tree, short obj, GRECT *area)
|
|
{
|
|
GRECT obj_screen;
|
|
bool ret = false;
|
|
|
|
objc_offset(tree, obj, &obj_screen.g_x, &obj_screen.g_y);
|
|
obj_screen.g_w = tree[obj].ob_width;
|
|
obj_screen.g_h = tree[obj].ob_height;
|
|
|
|
ret = RC_WITHIN(&obj_screen, area);
|
|
|
|
return(ret);
|
|
}
|
|
|
|
GRECT * gemtk_obj_screen_rect(OBJECT * tree, short obj)
|
|
{
|
|
static GRECT obj_screen;
|
|
|
|
get_objframe(tree, obj, &obj_screen);
|
|
|
|
return(&obj_screen);
|
|
}
|
|
|
|
|
|
void gemtk_obj_mouse_sprite(OBJECT *tree, int index)
|
|
{
|
|
MFORM mform;
|
|
int dum;
|
|
|
|
if ((tree[index].ob_type & 0xFF) != G_ICON)
|
|
return;
|
|
|
|
dum = tree[index].ob_spec.iconblk->ib_char;
|
|
mform . mf_nplanes = 1;
|
|
mform . mf_fg = (dum>>8)&0x0F;
|
|
mform . mf_bg = dum>>12;
|
|
mform . mf_xhot = 0; /* to prevent the mform to "jump" on the */
|
|
mform . mf_yhot = 0; /* screen (zebulon rules!) */
|
|
|
|
for( dum = 0; dum<16; dum ++) {
|
|
mform . mf_mask[dum] = tree[index].ob_spec.iconblk->ib_pmask[dum];
|
|
mform . mf_data[dum] = tree[index].ob_spec.iconblk->ib_pdata[dum];
|
|
}
|
|
graf_mouse(USER_DEF, &mform);
|
|
}
|
|
|
|
|
|
/*
|
|
* gemtk_obj_tree_copy
|
|
*
|
|
* Copy a complete object-tree including all substructures (optional).
|
|
*
|
|
* CAUTION: The object-tree *must* have the LASTOB-flag (0x20) set in
|
|
* it's physically last member.
|
|
*
|
|
* BUG: Up to now tree_copy won't copy the color-icon-structure,
|
|
* because I'm too lazy ;) Maybe I'll do that one day. If you need it
|
|
* urgently, contact me and force me to work... Btw, this doesn't mean
|
|
* that G_CICONs won't be copied at all, but the copied tree will
|
|
* share the CICONBLKs with the original.
|
|
*
|
|
* Input:
|
|
* tree: Pointer to tree which should be copied
|
|
* what: Specifies what substructures should be copied, too (see the
|
|
* C_xxx-definitions in tree-copy.h for details)
|
|
*
|
|
* Output:
|
|
* NULL: Tree couldn't be copied (due to lack of memory)
|
|
* otherwise: Pointer to copied tree, use free to dealloc it's memory
|
|
*/
|
|
OBJECT *gemtk_obj_tree_copy(OBJECT *tree)
|
|
{
|
|
int16_t i, objects;
|
|
size_t to_malloc, size;
|
|
OBJECT *new_tree;
|
|
char *area;
|
|
|
|
/* Calculate the number of bytes we need for the new tree */
|
|
to_malloc = (size_t) 0;
|
|
for (i = 0;;) {
|
|
|
|
/* Size of the OBJECT-structure itself */
|
|
to_malloc += sizeof(OBJECT);
|
|
|
|
switch (tree[i].ob_type & 0xff) {
|
|
case G_TEXT:
|
|
case G_BOXTEXT:
|
|
case G_FTEXT:
|
|
case G_FBOXTEXT:
|
|
/* Size of a TEDINFO-structure */
|
|
to_malloc += sizeof(TEDINFO);
|
|
|
|
/* Sizes of the strings in the TEDINFO-structure */
|
|
to_malloc += (size_t)tree[i].ob_spec.tedinfo->te_txtlen;
|
|
to_malloc += (size_t)tree[i].ob_spec.tedinfo->te_txtlen;
|
|
to_malloc += (size_t)tree[i].ob_spec.tedinfo->te_tmplen;
|
|
break;
|
|
|
|
case G_IMAGE:
|
|
|
|
/* Size of the BITBLK-structure */
|
|
to_malloc += sizeof(BITBLK);
|
|
|
|
/* Size of the image-data in the BITBLK-structure */
|
|
to_malloc += (size_t)((int32_t)tree[i].ob_spec.bitblk->bi_wb *
|
|
(int32_t)tree[i].ob_spec.bitblk->bi_hl);
|
|
|
|
break;
|
|
|
|
case G_USERDEF:
|
|
/* Size of the USERBLK-structure */
|
|
to_malloc += sizeof(USERBLK);
|
|
break;
|
|
|
|
case G_BUTTON:
|
|
case G_STRING:
|
|
case G_TITLE:
|
|
/* Size of the string (with one null character at the end) */
|
|
to_malloc += strlen(tree[i].ob_spec.free_string) + 1L;
|
|
break;
|
|
|
|
case G_ICON:
|
|
/* Size of the ICONBLK-structure */
|
|
to_malloc += sizeof(BITBLK);
|
|
|
|
/* Sizes of icon-data, icon-mask and icon-text */
|
|
to_malloc += (size_t)((int32_t)tree[i].ob_spec.iconblk->ib_wicon *
|
|
(int32_t)tree[i].ob_spec.iconblk->ib_hicon /
|
|
4L + 1L +
|
|
(int32_t)strlen(tree[i].ob_spec.iconblk->ib_ptext));
|
|
|
|
break;
|
|
}
|
|
|
|
/* If the size is odd, make it even */
|
|
if ((long)to_malloc & 1)
|
|
to_malloc++;
|
|
|
|
/* Exit if we've reached the last object in the tree */
|
|
if (tree[i].ob_flags & OF_LASTOB)
|
|
break;
|
|
|
|
i++;
|
|
}
|
|
|
|
objects = i + 1;
|
|
|
|
/* If there's not enough memory left for the new tree, return NULL */
|
|
if ((new_tree = (OBJECT *)calloc(1, to_malloc)) == NULL) {
|
|
return(NULL);
|
|
}
|
|
|
|
/*
|
|
* area contains a pointer to the area where we copy the structures to
|
|
*/
|
|
area = (char *)((int32_t)new_tree+(int32_t)objects*(int32_t)sizeof(OBJECT));
|
|
|
|
for (i = 0; i < objects; i++) {
|
|
|
|
/* Copy the contents of the OBJECT-structure */
|
|
new_tree[i] = tree[i];
|
|
|
|
/* This was added to assure true copies of the object type */
|
|
new_tree[i].ob_type = tree[i].ob_type;
|
|
|
|
switch (tree[i].ob_type & 0xff) {
|
|
case G_TEXT:
|
|
case G_BOXTEXT:
|
|
case G_FTEXT:
|
|
case G_FBOXTEXT:
|
|
|
|
/* Copy the contents of the TEDINFO-structure */
|
|
*(TEDINFO *)area = *tree[i].ob_spec.tedinfo;
|
|
new_tree[i].ob_spec.tedinfo = (TEDINFO *)area;
|
|
area += sizeof(TEDINFO);
|
|
|
|
/* Copy the strings in the TEDINFO-structure */
|
|
strncpy(area, tree[i].ob_spec.tedinfo->te_ptext,
|
|
tree[i].ob_spec.tedinfo->te_txtlen);
|
|
new_tree[i].ob_spec.tedinfo->te_ptext = area;
|
|
area += tree[i].ob_spec.tedinfo->te_txtlen;
|
|
strncpy(area, tree[i].ob_spec.tedinfo->te_ptmplt,
|
|
tree[i].ob_spec.tedinfo->te_tmplen);
|
|
new_tree[i].ob_spec.tedinfo->te_ptmplt = area;
|
|
area += tree[i].ob_spec.tedinfo->te_tmplen;
|
|
strncpy(area, tree[i].ob_spec.tedinfo->te_pvalid,
|
|
tree[i].ob_spec.tedinfo->te_txtlen);
|
|
new_tree[i].ob_spec.tedinfo->te_pvalid = area;
|
|
area += tree[i].ob_spec.tedinfo->te_txtlen;
|
|
|
|
break;
|
|
|
|
case G_IMAGE:
|
|
|
|
/* Copy the contents of the BITBLK-structure */
|
|
*(BITBLK *)area = *tree[i].ob_spec.bitblk;
|
|
new_tree[i].ob_spec.bitblk = (BITBLK *)area;
|
|
area += sizeof(BITBLK);
|
|
|
|
/* Copy the image-data */
|
|
size = (size_t)((int32_t)tree[i].ob_spec.bitblk->bi_wb *
|
|
(int32_t)tree[i].ob_spec.bitblk->bi_hl);
|
|
memcpy(area, tree[i].ob_spec.bitblk->bi_pdata, size);
|
|
new_tree[i].ob_spec.bitblk->bi_pdata = (int16_t *)area;
|
|
area += size;
|
|
|
|
break;
|
|
|
|
case G_USERDEF:
|
|
|
|
/* Copy the contents of the USERBLK-structure */
|
|
*(USERBLK *)area = *tree[i].ob_spec.userblk;
|
|
new_tree[i].ob_spec.userblk = (USERBLK *)area;
|
|
area += sizeof(USERBLK);
|
|
|
|
break;
|
|
|
|
case G_BUTTON:
|
|
case G_STRING:
|
|
case G_TITLE:
|
|
|
|
/* Copy the string */
|
|
size = strlen(tree[i].ob_spec.free_string) + 1L;
|
|
strcpy(area, tree[i].ob_spec.free_string);
|
|
new_tree[i].ob_spec.free_string = area;
|
|
area += size;
|
|
|
|
break;
|
|
|
|
case G_ICON:
|
|
|
|
/* Copy the contents of the ICONBLK-structure */
|
|
*(ICONBLK *)area = *tree[i].ob_spec.iconblk;
|
|
new_tree[i].ob_spec.iconblk = (ICONBLK *)area;
|
|
area += sizeof(ICONBLK);
|
|
|
|
size = (size_t)((int32_t)tree[i].ob_spec.iconblk->ib_wicon *
|
|
(int32_t)tree[i].ob_spec.iconblk->ib_hicon /
|
|
8L);
|
|
/* Copy the mask-data */
|
|
memcpy(area, tree[i].ob_spec.iconblk->ib_pmask, size);
|
|
new_tree[i].ob_spec.iconblk->ib_pmask = (int16_t *)area;
|
|
area += size;
|
|
|
|
/* Copy the icon-data */
|
|
memcpy(area, tree[i].ob_spec.iconblk->ib_pdata, size);
|
|
new_tree[i].ob_spec.iconblk->ib_pdata = (int16_t *)area;
|
|
area += size;
|
|
size = strlen(tree[i].ob_spec.iconblk->ib_ptext) + 1L;
|
|
|
|
/* Copy the icon-string */
|
|
strcpy(area, tree[i].ob_spec.iconblk->ib_ptext);
|
|
new_tree[i].ob_spec.iconblk->ib_ptext = area;
|
|
area += size;
|
|
|
|
break;
|
|
}
|
|
|
|
/* Assure that area contains an even address */
|
|
if ((int32_t)area & 1)
|
|
area++;
|
|
}
|
|
|
|
return(new_tree);
|
|
}
|
|
|
|
/***
|
|
* Create a simple OBJECT tree from a list of strings, to be used with menu_popup
|
|
* OBJECT ownership is passed to caller.
|
|
* Call gemtk_obj_destroy_popup_tree once the popup isn't needed anymore.
|
|
*
|
|
* \param items A list of string to be used as items
|
|
* \param nitems The number of items in the list
|
|
* \param selected The text of the selected item
|
|
* \param horizontal Set to true to render the tree horizontally
|
|
* \param max_width -1: autodetect width
|
|
* \param max_heigth -1: autodetect height (set to postive value when using a vertical scrolling popup)
|
|
* \return a pointer to the new OBJECT tree
|
|
*/
|
|
OBJECT * gemtk_obj_create_popup_tree(const char **items, int nitems,
|
|
char * selected, bool horizontal,
|
|
int max_width, int max_height)
|
|
{
|
|
OBJECT * popup = NULL;
|
|
int box_width = 0;
|
|
int box_height = 0;
|
|
int char_width = 10;
|
|
int char_height = 16;
|
|
int item_height; // height of each item
|
|
|
|
assert(items != NULL);
|
|
|
|
item_height = char_height;
|
|
|
|
/* Allocate room for n items and the root G_BOX: */
|
|
popup = calloc(nitems+1, sizeof(OBJECT));
|
|
assert(popup != null);
|
|
|
|
for (int i=0; i<nitems; i++) {
|
|
|
|
int len = strlen(items[i]);
|
|
|
|
if (horizontal && (max_width<1)) {
|
|
box_width += (len * char_width)+4;
|
|
}
|
|
else if (!horizontal){
|
|
/* Detect max width, used for vertical rendering: */
|
|
if(len*char_width > box_width){
|
|
box_width = (len+2) * char_width;
|
|
}
|
|
//if (max_height < 1) {
|
|
box_height += item_height;
|
|
//}
|
|
}
|
|
}
|
|
|
|
if (max_width>0){
|
|
box_width = max_width;
|
|
}
|
|
|
|
if (horizontal) {
|
|
box_height = item_height;
|
|
}
|
|
else if(max_height > 0){
|
|
// TODO: validate max_height, shrink values larger than screen height
|
|
//box_height = max_height;
|
|
}
|
|
|
|
/*
|
|
printf("popup height: %d, popup width: %d\n", box_height, box_width);
|
|
*/
|
|
|
|
popup[0].ob_next = -1; /**< object's next sibling */
|
|
popup[0].ob_head = 1; /**< head of object's children */
|
|
popup[0].ob_tail = nitems; /**< tail of object's children */
|
|
popup[0].ob_type = G_BOX; /**< type of object */
|
|
popup[0].ob_flags = OF_FL3DBAK; /**< flags */
|
|
popup[0].ob_state = OS_NORMAL; /**< state */
|
|
popup[0].ob_spec.index = (long) 16650496L; /**< object-specific data */
|
|
popup[0].ob_x = 0; /**< upper left corner of object */
|
|
popup[0].ob_y = 0; /**< upper left corner of object */
|
|
popup[0].ob_width = box_width; /**< width of obj */
|
|
popup[0].ob_height = box_height;
|
|
|
|
|
|
|
|
/* Add items to popup: */
|
|
int xpos = 0, ypos = 0;
|
|
|
|
for (int i=0; i<nitems; i++) {
|
|
|
|
int state = OS_NORMAL;
|
|
int flags = OF_NONE;
|
|
int item_width;
|
|
char * string = calloc(1, strlen(items[i])+3);
|
|
|
|
snprintf(string, strlen(items[i])+3, " %s", items[i]);
|
|
|
|
if (selected != NULL) {
|
|
if (strcmp(selected, items[i]) == 0) {
|
|
state |= OS_CHECKED;
|
|
}
|
|
}
|
|
|
|
if (i == nitems-1) {
|
|
flags |= OF_LASTOB;
|
|
}
|
|
|
|
item_width = (horizontal) ? ((int)strlen(items[i])*char_width)+2 : box_width;
|
|
/*
|
|
printf("addin popup item \"%s\" (w: %d, h: %d, flags: %x) at %d/%d\n", items[i],
|
|
item_width, item_height, flags,
|
|
xpos, ypos);
|
|
*/
|
|
|
|
popup[i+1].ob_next = ((flags&OF_LASTOB) != 0) ? 0 : i+2; /**< object's next sibling */
|
|
popup[i+1].ob_head = -1; /**< head of object's children */
|
|
popup[i+1].ob_tail = -1; /**< tail of object's children */
|
|
popup[i+1].ob_type = G_STRING; /**< type of object */
|
|
popup[i+1].ob_flags = flags; /**< flags */
|
|
popup[i+1].ob_state = state; /**< state */
|
|
popup[i+1].ob_spec.free_string = string; /**< object-specific data */
|
|
popup[i+1].ob_x = xpos; /**< upper left corner of object */
|
|
popup[i+1].ob_y = ypos; /**< upper left corner of object */
|
|
popup[i+1].ob_width = item_width; /**< width of obj */
|
|
popup[i+1].ob_height = item_height;
|
|
|
|
if (horizontal) {
|
|
xpos += item_width;
|
|
}
|
|
else {
|
|
ypos += item_height;
|
|
}
|
|
|
|
}
|
|
|
|
return(popup);
|
|
}
|
|
|
|
/***
|
|
* Free memory of an OBJECT tree created with gemtk_obj_create_popup_tree.
|
|
*
|
|
* \param popup The tree to destroy
|
|
*/
|
|
void gemtk_obj_destroy_popup_tree(OBJECT * popup)
|
|
{
|
|
int i=0;
|
|
|
|
while (1) {
|
|
if (popup[i].ob_type == G_STRING) {
|
|
free(popup[i+1].ob_spec.free_string);
|
|
}
|
|
if((popup[i].ob_flags & OF_LASTOB) != OF_LASTOB){
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
free(popup);
|
|
}
|