/**
* Create and initialise a node
*/
void ro_gui_global_history_initialise_node(const char *title,
time_t base, int days_back)
{
struct tm *full_time;
char buffer[64];
struct node *node;
base += days_back * 60 * 60 * 24;
if (!title) {
full_time = localtime(&base);
strftime((char *)&buffer, (size_t)64, "%A", full_time);
node = tree_create_folder_node(NULL, buffer);
} else
node = tree_create_folder_node(NULL, title);
if (!node)
return;
node->retain_in_memory = true;
node->deleted = true;
node->editable = false;
global_history_base_node[global_history_base_node_count] = node;
global_history_base_node_time[global_history_base_node_count] = base;
global_history_base_node_count++;
}
/**
* Add a folder node.
*
* \param selected create the folder in the currently-selected node
*/
void hotlist_add_folder(bool selected)
{
struct node *node, *parent = NULL;
struct node_element *element;
char *title = strdup("Untitled");
if (title == NULL) {
LOG(("malloc failed"));
warn_user("NoMemory", 0);
return;
}
creating_node = true;
if (selected == true) {
parent = tree_get_selected_node(tree_get_root(hotlist_tree));
if (parent && (tree_node_is_folder(parent) == false)) {
parent = tree_node_get_parent(parent);
}
}
if (parent == NULL) {
parent = tree_get_default_folder_node(hotlist_tree);
}
node = tree_create_folder_node(hotlist_tree, parent, title,
true, false, false);
if (node == NULL) {
free(title);
return;
}
tree_set_node_user_callback(node, hotlist_node_callback, NULL);
tree_set_node_icon(hotlist_tree, node, folder_icon);
element = tree_node_find_element(node, TREE_ELEMENT_TITLE, NULL);
tree_start_edit(hotlist_tree, element);
}
/**
* Parse a directory represented as a ul.
*
* \param ul xmlNode for parsed ul
* \param directory directory to add this directory to
*/
static void tree_url_load_directory(xmlNode *ul, struct tree *tree,
struct node *directory, tree_node_user_callback callback,
void *callback_data)
{
char *title;
struct node *dir;
xmlNode *xmlnode;
xmlChar *id;
assert(ul != NULL);
assert(directory != NULL);
for (xmlnode = ul->children; xmlnode; xmlnode = xmlnode->next) {
/* The ul may contain entries as a li, or directories as
* an h4 followed by a ul. Non-element nodes may be present
* (eg. text, comments), and are ignored. */
if (xmlnode->type != XML_ELEMENT_NODE)
continue;
if (strcmp((const char *)xmlnode->name, "li") == 0) {
/* entry */
tree_url_load_entry(xmlnode, tree, directory, callback,
callback_data);
} else if (strcmp((const char *)xmlnode->name, "h4") == 0) {
/* directory */
bool dir_is_default = false;
title = (char *) xmlNodeGetContent(xmlnode );
if (!title) {
warn_user("TreeLoadError", "(Empty <h4> "
"or memory exhausted.)");
return;
}
for (xmlnode = xmlnode->next;
xmlnode && xmlnode->type != XML_ELEMENT_NODE;
xmlnode = xmlnode->next)
;
if ((xmlnode == NULL) ||
strcmp((const char *)xmlnode->name, "ul") != 0) {
/* next element isn't expected ul */
free(title);
warn_user("TreeLoadError", "(Expected "
"<ul> not present.)");
return;
} else {
id = xmlGetProp(xmlnode,
(const xmlChar *) "id");
if (id != NULL) {
if(strcmp((const char *)id, "default") == 0)
dir_is_default = true;
xmlFree(id);
}
}
dir = tree_create_folder_node(tree, directory, title,
true, false, false);
if (dir == NULL) {
free(title);
return;
}
if(dir_is_default == true) {
tree_set_default_folder_node(tree, dir);
}
if (callback != NULL)
tree_set_node_user_callback(dir, callback,
callback_data);
if (folder_icon != NULL)
tree_set_node_icon(tree, dir, folder_icon);
tree_url_load_directory(xmlnode, tree, dir, callback,
callback_data);
}
}
}
void gui_cert_verify(struct browser_window *bw, hlcache_handle *c,
const struct ssl_cert_info *certs, unsigned long num)
{
const struct ssl_cert_info *from;
struct session_cert *to;
struct session_data *data;
struct tree *tree;
struct node *node;
long i;
STRPTR yesorno,reqcontents;
int res = 0;
struct treeview_window *twin;
assert(bw && c && certs);
/* copy the certificate information */
data = calloc(1, sizeof(struct session_data));
if (!data) {
warn_user("NoMemory", 0);
return;
}
data->url = strdup(content_get_url(c));
if (!data->url) {
free(data);
warn_user("NoMemory", 0);
return;
}
data->bw = bw;
data->num = num;
data->certs = calloc(num, sizeof(struct session_cert));
if (!data->certs) {
free(data->url);
free(data);
warn_user("NoMemory", 0);
return;
}
for (i = 0; i < (long)num; i++) {
to = &data->certs[i];
from = &certs[i];
to->subject_t = strdup(from->subject);
to->issuer_t = strdup(from->issuer);
if ((!to->subject_t) || (!to->issuer_t)) {
for (; i >= 0; i--) {
to = &data->certs[i];
free(to->subject_t);
free(to->issuer_t);
}
free(data->certs);
free(data->url);
free(data);
warn_user("NoMemory", 0);
return;
}
snprintf(to->version, sizeof data->certs->version, "%ld",
from->version);
snprintf(to->valid_from, sizeof data->certs->valid_from, "%s",
from->not_before);
snprintf(to->type, sizeof data->certs->type, "%d",
from->cert_type);
snprintf(to->valid_to, sizeof data->certs->valid_to, "%s",
from->not_after);
snprintf(to->serial, sizeof data->certs->serial, "%ld",
from->serial);
}
tree = calloc(sizeof(struct tree), 1);
if (!tree) {
//ro_gui_cert_close(ssl_w);
warn_user("NoMemory", 0);
return;
}
tree->root = tree_create_folder_node(NULL, "Root");
if (!tree->root) {
// ro_gui_cert_close(ssl_w);
warn_user("NoMemory", 0);
free(tree);
tree = NULL;
return;
}
tree->root->expanded = true;
tree->handle = 0;
tree->movable = false;
tree->no_drag = true;
tree->no_vscroll = true;
tree->no_furniture = true;
tree->single_selection = true;
data->tree = tree;
/* put the SSL names in the tree */
for (i = 0; i < (long)num; i++) {
node = tree_create_leaf_node(tree->root, certs[i].subject);
if (node) {
node->data.data = TREE_ELEMENT_SSL;
tree_set_node_sprite(node, "small_xxx", "small_xxx");
}
}
tree_initialise(tree);
ami_open_tree(tree,AMI_TREE_SSLCERT);
twin = (struct treeview_window *)data->tree->handle;
if(yesorno = ASPrintf("%s|%s",messages_get("Accept"),messages_get("Reject")))
{
if(reqcontents = ASPrintf("%s\n\n%s: %s\n%s: %s\n%s: %s\n%s: %s\n%s: %s",
messages_get("SSLError"),
messages_get("Subject"),
to->subject_t,
messages_get("Issuer"),
to->issuer_t,
messages_get("Version"),
to->version,
messages_get("ValidFrom"),
to->valid_from,
messages_get("ValidTo"),
to->valid_to))
{
res = TimedDosRequesterTags(TDR_ImageType,TDRIMAGE_QUESTION,
TDR_Window,twin->win,
TDR_TitleString,messages_get("NetSurf"),
TDR_GadgetString,yesorno,
TDR_FormatString,reqcontents,
TAG_DONE);
FreeVec(reqcontents);
}
FreeVec(yesorno);
}
if(res == 1)
{
ami_gui_cert_apply(data);
}
ami_gui_cert_close(data);
}
/**
* Initialise global history tree
*/
void ro_gui_global_history_initialise(void)
{
char s[MAXIMUM_URL_LENGTH];
FILE *fp;
/* create our window */
global_history_window = ro_gui_dialog_create("tree");
ro_gui_set_window_title(global_history_window,
messages_get("GlobalHistory"));
ro_gui_wimp_event_register_redraw_window(global_history_window,
ro_gui_tree_redraw);
ro_gui_wimp_event_register_open_window(global_history_window,
ro_gui_tree_open);
ro_gui_wimp_event_register_mouse_click(global_history_window,
ro_gui_global_history_click);
/* Create an empty tree */
global_history_tree = calloc(sizeof(struct tree), 1);
if (!global_history_tree) {
warn_user("NoMemory", 0);
return;
}
global_history_tree->root = tree_create_folder_node(NULL, "Root");
if (!global_history_tree->root) {
warn_user("NoMemory", 0);
free(global_history_tree);
global_history_tree = NULL;
return;
}
global_history_tree->root->expanded = true;
ro_gui_global_history_initialise_nodes();
global_history_tree->handle = (int)global_history_window;
global_history_tree->movable = false;
ro_gui_wimp_event_set_user_data(global_history_window,
global_history_tree);
ro_gui_wimp_event_register_keypress(global_history_window,
ro_gui_tree_keypress);
/* Create our toolbar */
global_history_tree->toolbar = ro_gui_theme_create_toolbar(NULL,
THEME_HISTORY_TOOLBAR);
if (global_history_tree->toolbar)
ro_gui_theme_attach_toolbar(global_history_tree->toolbar,
global_history_window);
/* load recent URLs */
fp = fopen(option_recent_path, "r");
if (!fp)
LOG(("Failed to open file '%s' for reading",
option_recent_path));
else {
while (fgets(s, MAXIMUM_URL_LENGTH, fp)) {
if (s[strlen(s) - 1] == '\n')
s[strlen(s) - 1] = '\0';
global_history_add_recent(s);
}
fclose(fp);
}
global_history_init = true;
urldb_iterate_entries(global_history_add_internal);
global_history_init = false;
tree_initialise(global_history_tree);
}
BOOL ami_tree_event(struct treeview_window *twin)
{
/* return TRUE if window destroyed */
ULONG class,result,relevent = 0;
ULONG column;
uint16 code;
struct MenuItem *item;
struct node *treenode;
struct Node *lbnode;
struct node_element *element;
char *text;
// ULONG editcols[] = {TREE_ELEMENT_TITLE,TREE_ELEMENT_URL};
static WORD gen=0;
while((result = RA_HandleInput(twin->objects[OID_MAIN],&code)) != WMHI_LASTMSG)
{
switch(result & WMHI_CLASSMASK) // class
{
case WMHI_GADGETUP:
switch(result & WMHI_GADGETMASK)
{
case GID_TREEBROWSER:
GetAttrs(twin->gadgets[GID_TREEBROWSER],
LISTBROWSER_RelEvent,&relevent,
TAG_DONE);
switch(relevent)
{
case LBRE_DOUBLECLICK:
GetAttr(LISTBROWSER_SelectedNode,twin->gadgets[GID_TREEBROWSER],(ULONG *)&lbnode);
GetListBrowserNodeAttrs(lbnode,
LBNA_UserData,(ULONG *)&treenode,
TAG_DONE);
ami_tree_launch_node(twin->tree,treenode);
break;
case LBRE_EDIT:
GetAttrs(twin->gadgets[GID_TREEBROWSER],
LISTBROWSER_SelectedNode,(ULONG *)&lbnode,
// LISTBROWSER_RelColumn,(ULONG *)&column,
TAG_DONE);
GetListBrowserNodeAttrs(lbnode,
LBNA_UserData,(ULONG *)&treenode,
TAG_DONE);
element = tree_find_element(treenode,TREE_ELEMENT_TITLE);
GetListBrowserNodeAttrs(lbnode,
LBNA_Column,column,
LBNCA_Text,(ULONG *)&text,
TAG_DONE);
element->text = (char *)strdup(text);
tree_handle_node_element_changed(twin->tree, element);
break;
case LBRE_HIDECHILDREN:
GetAttr(LISTBROWSER_SelectedNode,twin->gadgets[GID_TREEBROWSER],(ULONG *)&lbnode);
GetListBrowserNodeAttrs(lbnode,
LBNA_UserData,(ULONG *)&treenode,
TAG_DONE);
tree_set_node_expanded(twin->tree, treenode, false);
break;
case LBRE_SHOWCHILDREN:
GetAttr(LISTBROWSER_SelectedNode,twin->gadgets[GID_TREEBROWSER],(ULONG *)&lbnode);
GetListBrowserNodeAttrs(lbnode,
LBNA_UserData,(ULONG *)&treenode,
TAG_DONE);
tree_set_node_expanded(twin->tree, treenode, true);
break;
}
break;
case GID_OPEN:
GetAttr(LISTBROWSER_SelectedNode,twin->gadgets[GID_TREEBROWSER],(ULONG *)&lbnode);
GetListBrowserNodeAttrs(lbnode,
LBNA_UserData,(ULONG *)&treenode,
TAG_DONE);
ami_tree_launch_node(twin->tree,treenode);
break;
case GID_NEWF:
GetAttr(LISTBROWSER_SelectedNode,twin->gadgets[GID_TREEBROWSER],(ULONG *)&lbnode);
if(lbnode)
{
GetListBrowserNodeAttrs(lbnode,
LBNA_UserData,(ULONG *)&treenode,
TAG_DONE);
}
else
{
treenode = twin->tree->root;
}
tree_create_folder_node(treenode,(char *)messages_get("TreeNewFolder"));
ami_recreate_listbrowser(twin);
break;
case GID_NEWB:
ami_new_bookmark(twin);
break;
case GID_UP:
ami_move_node(twin,AMI_MOVE_UP);
break;
case GID_DOWN:
ami_move_node(twin,AMI_MOVE_DOWN);
break;
case GID_LEFT:
ami_move_node(twin,AMI_MOVE_OUT);
break;
case GID_DEL:
GetAttr(LISTBROWSER_SelectedNode,twin->gadgets[GID_TREEBROWSER],(ULONG *)&lbnode);
GetListBrowserNodeAttrs(lbnode,
LBNA_UserData,(ULONG *)&treenode,
TAG_DONE);
tree_delete_node(twin->tree, treenode, false);
/* We are recreating the list from scratch as there is no obvious easy way
to delete children from a listbrowser list */
ami_recreate_listbrowser(twin);
break;
}
break;
/* no menus yet, copied in as will probably need it later
case WMHI_MENUPICK:
item = ItemAddress(gwin->win->MenuStrip,code);
while (code != MENUNULL)
{
ami_menupick(code,gwin);
if(win_destroyed) break;
code = item->NextSelect;
}
break;
*/
case WMHI_CLOSEWINDOW:
ami_tree_close(twin);
return TRUE;
break;
}
}
return FALSE;
}
/* exported interface documented in hotlist.h */
bool hotlist_initialise(struct tree *tree, const char *hotlist_path, const char* folder_icon_name)
{
struct node *node;
const struct url_data *url_data;
char *name;
int hlst_loop;
/* Either load or create a hotlist */
creating_node = false;
folder_icon = tree_load_icon(folder_icon_name);
tree_url_node_init(folder_icon_name);
if (tree == NULL)
return false;
hotlist_tree = tree;
hotlist_tree_root = tree_get_root(hotlist_tree);
if (tree_urlfile_load(hotlist_path,
hotlist_tree,
hotlist_node_callback,
NULL)) {
return true;
}
/* failed to load hotlist file, use default list */
name = strdup("NetSurf");
if (name == NULL) {
LOG(("malloc failed"));
warn_user("NoMemory", 0);
return false;
}
node = tree_create_folder_node(hotlist_tree, hotlist_tree_root,
name, true, false, false);
if (node == NULL) {
free(name);
return false;
}
tree_set_node_user_callback(node, hotlist_node_callback, NULL);
tree_set_node_icon(hotlist_tree, node, folder_icon);
for (hlst_loop = 0; hlst_loop != HOTLIST_ENTRIES_COUNT; hlst_loop++) {
url_data = urldb_get_url_data(hotlist_default_entries[hlst_loop].url);
if (url_data == NULL) {
urldb_add_url(hotlist_default_entries[hlst_loop].url);
urldb_set_url_persistence(
hotlist_default_entries[hlst_loop].url,
true);
url_data = urldb_get_url_data(
hotlist_default_entries[hlst_loop].url);
}
if (url_data != NULL) {
tree_create_URL_node(hotlist_tree, node,
hotlist_default_entries[hlst_loop].url,
messages_get(hotlist_default_entries[hlst_loop].msg_key),
hotlist_node_callback, NULL);
tree_update_URL_node(hotlist_tree, node,
hotlist_default_entries[hlst_loop].url,
url_data);
}
}
return true;
}
