2013-08-15 22:19:24 +04:00
|
|
|
/*
|
|
|
|
* Copyright 2012 John-Mark Bell <jmb@netsurf-browser.org>
|
|
|
|
* Copyright 2013 Michael Drake <tlsa@netsurf-browser.org>
|
|
|
|
*
|
|
|
|
* 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/>.
|
|
|
|
*/
|
|
|
|
|
2015-01-23 15:14:37 +03:00
|
|
|
#include <errno.h>
|
2013-08-15 22:19:24 +04:00
|
|
|
#include <assert.h>
|
|
|
|
#include <stdlib.h>
|
2014-07-17 03:18:44 +04:00
|
|
|
#include <string.h>
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
#include <dom/dom.h>
|
|
|
|
#include <dom/bindings/hubbub/parser.h>
|
|
|
|
|
|
|
|
#include "utils/corestrings.h"
|
|
|
|
#include "utils/messages.h"
|
|
|
|
#include "utils/utils.h"
|
2013-08-22 19:06:06 +04:00
|
|
|
#include "utils/utf8.h"
|
2013-08-15 22:19:24 +04:00
|
|
|
#include "utils/libdom.h"
|
|
|
|
#include "utils/log.h"
|
2016-04-26 14:50:16 +03:00
|
|
|
#include "content/urldb.h"
|
|
|
|
|
|
|
|
#include "desktop/gui_misc.h"
|
|
|
|
#include "desktop/gui_internal.h"
|
|
|
|
#include "desktop/hotlist.h"
|
|
|
|
#include "desktop/treeview.h"
|
|
|
|
#include "desktop/browser.h"
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
#define N_DAYS 28
|
|
|
|
#define N_SEC_PER_DAY (60 * 60 * 24)
|
|
|
|
|
|
|
|
enum hotlist_fields {
|
|
|
|
HL_TITLE,
|
|
|
|
HL_URL,
|
|
|
|
HL_LAST_VISIT,
|
|
|
|
HL_VISITS,
|
|
|
|
HL_FOLDER,
|
|
|
|
HL_N_FIELDS
|
|
|
|
};
|
|
|
|
|
|
|
|
struct hotlist_folder {
|
|
|
|
treeview_node *folder;
|
|
|
|
struct treeview_field_data data;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct hotlist_ctx {
|
|
|
|
treeview *tree;
|
|
|
|
struct treeview_field_desc fields[HL_N_FIELDS];
|
|
|
|
bool built;
|
2013-08-27 14:40:12 +04:00
|
|
|
struct hotlist_folder *default_folder;
|
2013-08-15 22:19:24 +04:00
|
|
|
};
|
|
|
|
struct hotlist_ctx hl_ctx;
|
|
|
|
|
|
|
|
struct hotlist_entry {
|
|
|
|
nsurl *url;
|
|
|
|
treeview_node *entry;
|
|
|
|
|
|
|
|
struct treeview_field_data data[HL_N_FIELDS - 1];
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a hotlist entry's data from the url_data.
|
|
|
|
*
|
2014-11-08 14:38:20 +03:00
|
|
|
* \param e hotlist entry to set up.
|
|
|
|
* \param data Data associated with entry's URL.
|
|
|
|
* \return NSERROR_OK on success, appropriate error otherwise.
|
2013-08-15 22:19:24 +04:00
|
|
|
*/
|
2013-09-05 15:54:15 +04:00
|
|
|
static nserror hotlist_create_treeview_field_visits_data(
|
|
|
|
struct hotlist_entry *e, const struct url_data *data)
|
2013-08-15 22:19:24 +04:00
|
|
|
{
|
|
|
|
char buffer[16];
|
|
|
|
const char *last_visited;
|
|
|
|
char *last_visited2;
|
|
|
|
int len;
|
|
|
|
|
2013-09-05 15:54:15 +04:00
|
|
|
/* Last visited */
|
2013-10-23 16:20:43 +04:00
|
|
|
if (data->visits != 0) {
|
|
|
|
last_visited = ctime(&data->last_visit);
|
|
|
|
last_visited2 = strdup(last_visited);
|
|
|
|
len = 24;
|
|
|
|
} else {
|
|
|
|
last_visited2 = strdup("-");
|
|
|
|
len = 1;
|
|
|
|
}
|
2013-09-05 15:54:15 +04:00
|
|
|
if (last_visited2 == NULL) {
|
|
|
|
return NSERROR_NOMEM;
|
2013-10-23 16:20:43 +04:00
|
|
|
|
|
|
|
} else if (len == 24) {
|
2013-08-15 22:19:24 +04:00
|
|
|
assert(last_visited2[24] == '\n');
|
|
|
|
last_visited2[24] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
e->data[HL_LAST_VISIT].field = hl_ctx.fields[HL_LAST_VISIT].field;
|
|
|
|
e->data[HL_LAST_VISIT].value = last_visited2;
|
2013-10-23 16:20:43 +04:00
|
|
|
e->data[HL_LAST_VISIT].value_len = len;
|
2013-08-15 22:19:24 +04:00
|
|
|
|
2013-09-05 15:54:15 +04:00
|
|
|
/* Visits */
|
2013-08-15 22:19:24 +04:00
|
|
|
len = snprintf(buffer, 16, "%u", data->visits);
|
|
|
|
if (len == 16) {
|
|
|
|
len--;
|
|
|
|
buffer[len] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
e->data[HL_VISITS].field = hl_ctx.fields[HL_VISITS].field;
|
|
|
|
e->data[HL_VISITS].value = strdup(buffer);
|
2013-09-05 15:54:15 +04:00
|
|
|
if (e->data[HL_VISITS].value == NULL) {
|
|
|
|
free((void*)e->data[HL_LAST_VISIT].value);
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
2013-08-15 22:19:24 +04:00
|
|
|
e->data[HL_VISITS].value_len = len;
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
2013-09-05 15:54:15 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a hotlist entry's data from the url_data.
|
|
|
|
*
|
2014-11-08 14:38:20 +03:00
|
|
|
* \param e hotlist entry to set up
|
|
|
|
* \param title Title for entry, or NULL if using title from data
|
|
|
|
* \param data Data associated with entry's URL
|
2013-09-05 15:54:15 +04:00
|
|
|
* \return NSERROR_OK on success, appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_create_treeview_field_data(
|
|
|
|
struct hotlist_entry *e, const char *title,
|
|
|
|
const struct url_data *data)
|
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
|
|
|
|
/* "URL" field */
|
|
|
|
e->data[HL_URL].field = hl_ctx.fields[HL_URL].field;
|
|
|
|
e->data[HL_URL].value = nsurl_access(e->url);
|
|
|
|
e->data[HL_URL].value_len = nsurl_length(e->url);
|
|
|
|
|
|
|
|
/* "Title" field */
|
|
|
|
if (title == NULL) {
|
|
|
|
/* Title not provided; use one from URL data */
|
|
|
|
title = (data->title != NULL) ?
|
|
|
|
data->title : nsurl_access(e->url);
|
|
|
|
}
|
|
|
|
|
|
|
|
e->data[HL_TITLE].field = hl_ctx.fields[HL_TITLE].field;
|
|
|
|
e->data[HL_TITLE].value = strdup(title);
|
|
|
|
if (e->data[HL_TITLE].value == NULL) {
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
|
|
|
e->data[HL_TITLE].value_len = (e->data[HL_TITLE].value != NULL) ?
|
|
|
|
strlen(title) : 0;
|
|
|
|
|
|
|
|
/* "Last visited" and "Visits" fields */
|
|
|
|
err = hotlist_create_treeview_field_visits_data(e, data);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
free((void*)e->data[HL_TITLE].value);
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
/**
|
|
|
|
* Add a hotlist entry to the treeview
|
|
|
|
*
|
|
|
|
* \param e Entry to add to treeview
|
|
|
|
* \param relation Existing node to insert as relation of, or NULL
|
|
|
|
* \param rel Folder's relationship to relation
|
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*
|
|
|
|
* It is assumed that the entry is unique (for its URL) in the global
|
|
|
|
* hotlist table
|
|
|
|
*/
|
|
|
|
static nserror hotlist_entry_insert(struct hotlist_entry *e,
|
|
|
|
treeview_node *relation, enum treeview_relationship rel)
|
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
|
|
|
|
err = treeview_create_node_entry(hl_ctx.tree, &(e->entry),
|
|
|
|
relation, rel, e->data, e, hl_ctx.built ?
|
2013-08-30 15:51:40 +04:00
|
|
|
TREE_OPTION_NONE : TREE_OPTION_SUPPRESS_RESIZE |
|
|
|
|
TREE_OPTION_SUPPRESS_REDRAW);
|
2013-08-15 22:19:24 +04:00
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-15 23:57:09 +04:00
|
|
|
/**
|
|
|
|
* Delete a hotlist entry
|
|
|
|
*
|
|
|
|
* This does not delete the treeview node, rather it should only be called from
|
|
|
|
* the treeview node delete event message.
|
|
|
|
*
|
|
|
|
* \param e Entry to delete
|
|
|
|
*/
|
|
|
|
static void hotlist_delete_entry_internal(struct hotlist_entry *e)
|
|
|
|
{
|
|
|
|
assert(e != NULL);
|
|
|
|
assert(e->entry == NULL);
|
|
|
|
|
|
|
|
/* Destroy fields */
|
|
|
|
free((void *)e->data[HL_TITLE].value); /* Eww */
|
|
|
|
free((void *)e->data[HL_LAST_VISIT].value); /* Eww */
|
|
|
|
free((void *)e->data[HL_VISITS].value); /* Eww */
|
|
|
|
nsurl_unref(e->url);
|
|
|
|
|
|
|
|
/* Destroy entry */
|
|
|
|
free(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
/**
|
2013-08-27 23:56:43 +04:00
|
|
|
* Create hotlist entry data for URL.
|
2013-08-15 22:19:24 +04:00
|
|
|
*
|
|
|
|
* \param url URL for entry to add to hotlist.
|
|
|
|
* \param title Title for entry, or NULL if using title from data
|
2013-08-15 23:57:09 +04:00
|
|
|
* \param data URL data for the entry, or NULL
|
2013-08-27 23:56:43 +04:00
|
|
|
* \param entry Updated to new hotlist entry data
|
2013-08-15 22:19:24 +04:00
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
2013-08-27 23:56:43 +04:00
|
|
|
static nserror hotlist_create_entry(nsurl *url, const char *title,
|
|
|
|
const struct url_data *data, struct hotlist_entry **entry)
|
2013-08-15 22:19:24 +04:00
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
struct hotlist_entry *e;
|
|
|
|
|
2013-08-27 23:56:43 +04:00
|
|
|
assert(url != NULL);
|
|
|
|
|
|
|
|
*entry = NULL;
|
|
|
|
|
2013-08-15 23:57:09 +04:00
|
|
|
if (data == NULL) {
|
|
|
|
/* Get the URL data */
|
|
|
|
data = urldb_get_url_data(url);
|
|
|
|
if (data == NULL) {
|
|
|
|
/* No entry in database, so add one */
|
|
|
|
urldb_add_url(url);
|
|
|
|
/* now attempt to get url data */
|
|
|
|
data = urldb_get_url_data(url);
|
|
|
|
}
|
|
|
|
if (data == NULL) {
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
/* Create new local hotlist entry */
|
|
|
|
e = malloc(sizeof(struct hotlist_entry));
|
|
|
|
if (e == NULL) {
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
e->url = nsurl_ref(url);
|
|
|
|
e->entry = NULL;
|
|
|
|
|
|
|
|
err = hotlist_create_treeview_field_data(e, title, data);
|
|
|
|
if (err != NSERROR_OK) {
|
2013-08-15 23:57:09 +04:00
|
|
|
nsurl_unref(e->url);
|
|
|
|
free(e);
|
2013-08-15 22:19:24 +04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-27 23:56:43 +04:00
|
|
|
*entry = e;
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Add an entry to the hotlist (creates the entry).
|
|
|
|
*
|
|
|
|
* \param url URL for entry to add to hotlist.
|
|
|
|
* \param title Title for entry, or NULL if using title from data
|
|
|
|
* \param data URL data for the entry, or NULL
|
|
|
|
* \param relation Existing node to insert as relation of, or NULL
|
|
|
|
* \param rel Entry's relationship to relation
|
|
|
|
* \param entry Updated to new treeview entry node
|
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_add_entry_internal(nsurl *url, const char *title,
|
|
|
|
const struct url_data *data, treeview_node *relation,
|
|
|
|
enum treeview_relationship rel, treeview_node **entry)
|
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
struct hotlist_entry *e;
|
|
|
|
|
|
|
|
err = hotlist_create_entry(url, title, data, &e);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
err = hotlist_entry_insert(e, relation, rel);
|
|
|
|
if (err != NSERROR_OK) {
|
2013-08-15 23:57:09 +04:00
|
|
|
hotlist_delete_entry_internal(e);
|
2013-08-15 22:19:24 +04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-15 23:57:09 +04:00
|
|
|
/* Make this URL persistent */
|
|
|
|
urldb_set_url_persistence(url, true);
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
*entry = e->entry;
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-16 01:27:28 +04:00
|
|
|
/**
|
|
|
|
* Add folder to the hotlist (creates the folder).
|
|
|
|
*
|
2013-08-27 14:57:31 +04:00
|
|
|
* \param title Title for folder, or NULL if using title from data
|
2013-08-16 01:27:28 +04:00
|
|
|
* \param relation Existing node to insert as relation of, or NULL
|
2013-08-27 14:57:31 +04:00
|
|
|
* \param rel Folder's relationship to relation
|
2013-08-27 14:40:12 +04:00
|
|
|
* \param folder Updated to new hotlist folder data
|
2014-11-18 20:16:26 +03:00
|
|
|
* \param default_folder Add to the default folder.
|
2013-08-16 01:27:28 +04:00
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_add_folder_internal(
|
|
|
|
const char *title, treeview_node *relation,
|
2013-11-08 22:53:34 +04:00
|
|
|
enum treeview_relationship rel, struct hotlist_folder **folder,
|
|
|
|
bool default_folder)
|
2013-08-16 01:27:28 +04:00
|
|
|
{
|
2013-08-20 22:45:52 +04:00
|
|
|
struct hotlist_folder *f;
|
2013-11-08 22:53:34 +04:00
|
|
|
treeview_node_options_flags flags = TREE_OPTION_NONE;
|
2013-08-20 22:45:52 +04:00
|
|
|
treeview_node *n;
|
2013-08-16 01:27:28 +04:00
|
|
|
nserror err;
|
|
|
|
|
|
|
|
if (title == NULL) {
|
2013-11-17 20:36:51 +04:00
|
|
|
title = messages_get("NewFolderName");
|
2013-08-16 01:27:28 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Create the title field */
|
2013-08-20 22:45:52 +04:00
|
|
|
f = malloc(sizeof(struct hotlist_folder));
|
|
|
|
if (f == NULL) {
|
2013-08-16 01:27:28 +04:00
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
2013-08-20 22:45:52 +04:00
|
|
|
f->data.field = hl_ctx.fields[HL_FOLDER].field;
|
2013-09-05 15:54:15 +04:00
|
|
|
f->data.value = strdup(title);
|
|
|
|
if (f->data.value == NULL) {
|
|
|
|
free(f);
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
2013-08-20 22:45:52 +04:00
|
|
|
f->data.value_len = strlen(title);
|
2013-08-16 01:27:28 +04:00
|
|
|
|
2013-11-11 18:32:07 +04:00
|
|
|
if (!hl_ctx.built)
|
2013-11-08 22:53:34 +04:00
|
|
|
flags |= TREE_OPTION_SUPPRESS_RESIZE |
|
|
|
|
TREE_OPTION_SUPPRESS_REDRAW;
|
|
|
|
if (default_folder)
|
|
|
|
flags |= TREE_OPTION_SPECIAL_DIR;
|
|
|
|
|
2013-08-16 01:27:28 +04:00
|
|
|
err = treeview_create_node_folder(hl_ctx.tree,
|
2013-11-08 22:53:34 +04:00
|
|
|
&n, relation, rel, &f->data, f, flags);
|
2013-08-16 01:27:28 +04:00
|
|
|
if (err != NSERROR_OK) {
|
2013-09-05 15:54:15 +04:00
|
|
|
free((void*)f->data.value); /* Eww */
|
2013-08-20 22:45:52 +04:00
|
|
|
free(f);
|
2013-08-16 01:27:28 +04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-20 22:45:52 +04:00
|
|
|
f->folder = n;
|
2013-08-27 14:40:12 +04:00
|
|
|
*folder = f;
|
2013-08-16 01:27:28 +04:00
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
static nserror hotlist_tree_node_folder_cb(
|
|
|
|
struct treeview_node_msg msg, void *data)
|
|
|
|
{
|
2013-08-20 22:45:52 +04:00
|
|
|
struct hotlist_folder *f = data;
|
|
|
|
const char *old_text;
|
|
|
|
bool match;
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
switch (msg.msg) {
|
|
|
|
case TREE_MSG_NODE_DELETE:
|
2013-08-27 16:31:40 +04:00
|
|
|
if (f == hl_ctx.default_folder)
|
|
|
|
hl_ctx.default_folder = NULL;
|
2013-08-20 22:45:52 +04:00
|
|
|
free((void*)f->data.value); /* Eww */
|
2013-08-15 22:19:24 +04:00
|
|
|
free(f);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TREE_MSG_NODE_EDIT:
|
2013-08-20 22:45:52 +04:00
|
|
|
if (lwc_string_isequal(hl_ctx.fields[HL_FOLDER].field,
|
|
|
|
msg.data.node_edit.field, &match) ==
|
|
|
|
lwc_error_ok && match == true &&
|
|
|
|
msg.data.node_edit.text != NULL &&
|
|
|
|
msg.data.node_edit.text[0] != '\0') {
|
|
|
|
/* Requst to change the folder title text */
|
|
|
|
old_text = f->data.value;
|
|
|
|
f->data.value = strdup(msg.data.node_edit.text);
|
|
|
|
|
|
|
|
if (f->data.value == NULL) {
|
|
|
|
f->data.value = old_text;
|
|
|
|
} else {
|
|
|
|
f->data.value_len = strlen(f->data.value);
|
|
|
|
treeview_update_node_folder(hl_ctx.tree,
|
|
|
|
f->folder, &f->data, f);
|
|
|
|
free((void *)old_text);
|
|
|
|
}
|
|
|
|
}
|
2013-08-15 22:19:24 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TREE_MSG_NODE_LAUNCH:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
2014-10-31 02:27:41 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* callback for hotlist treeview entry manipulation.
|
|
|
|
*/
|
|
|
|
static nserror
|
|
|
|
hotlist_tree_node_entry_cb(struct treeview_node_msg msg, void *data)
|
2013-08-15 22:19:24 +04:00
|
|
|
{
|
|
|
|
struct hotlist_entry *e = data;
|
2013-08-20 23:03:46 +04:00
|
|
|
const char *old_text;
|
|
|
|
nsurl *old_url;
|
|
|
|
nsurl *url;
|
2014-10-31 02:27:41 +03:00
|
|
|
nserror err = NSERROR_OK;
|
2013-08-20 23:03:46 +04:00
|
|
|
bool match;
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
switch (msg.msg) {
|
|
|
|
case TREE_MSG_NODE_DELETE:
|
|
|
|
e->entry = NULL;
|
|
|
|
hotlist_delete_entry_internal(e);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TREE_MSG_NODE_EDIT:
|
2013-08-20 23:03:46 +04:00
|
|
|
if (lwc_string_isequal(hl_ctx.fields[HL_TITLE].field,
|
|
|
|
msg.data.node_edit.field, &match) ==
|
|
|
|
lwc_error_ok && match == true &&
|
|
|
|
msg.data.node_edit.text != NULL &&
|
|
|
|
msg.data.node_edit.text[0] != '\0') {
|
|
|
|
/* Requst to change the entry title text */
|
|
|
|
old_text = e->data[HL_TITLE].value;
|
|
|
|
e->data[HL_TITLE].value =
|
|
|
|
strdup(msg.data.node_edit.text);
|
|
|
|
|
|
|
|
if (e->data[HL_TITLE].value == NULL) {
|
|
|
|
e->data[HL_TITLE].value = old_text;
|
|
|
|
} else {
|
|
|
|
e->data[HL_TITLE].value_len =
|
|
|
|
strlen(e->data[HL_TITLE].value);
|
|
|
|
treeview_update_node_entry(hl_ctx.tree,
|
|
|
|
e->entry, e->data, e);
|
|
|
|
free((void *)old_text);
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (lwc_string_isequal(hl_ctx.fields[HL_URL].field,
|
|
|
|
msg.data.node_edit.field, &match) ==
|
|
|
|
lwc_error_ok && match == true &&
|
|
|
|
msg.data.node_edit.text != NULL &&
|
|
|
|
msg.data.node_edit.text[0] != '\0') {
|
|
|
|
/* Requst to change the entry URL text */
|
|
|
|
err = nsurl_create(msg.data.node_edit.text, &url);
|
2014-10-31 02:27:41 +03:00
|
|
|
if (err == NSERROR_OK) {
|
|
|
|
old_url = e->url;
|
2013-08-20 23:03:46 +04:00
|
|
|
|
2014-10-31 02:27:41 +03:00
|
|
|
e->url = url;
|
|
|
|
e->data[HL_URL].value = nsurl_access(url);
|
|
|
|
e->data[HL_URL].value_len = nsurl_length(e->url);
|
2013-08-20 23:03:46 +04:00
|
|
|
|
2014-10-31 02:27:41 +03:00
|
|
|
treeview_update_node_entry(hl_ctx.tree,
|
|
|
|
e->entry, e->data, e);
|
|
|
|
nsurl_unref(old_url);
|
|
|
|
}
|
2013-08-20 23:03:46 +04:00
|
|
|
}
|
2013-08-15 22:19:24 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TREE_MSG_NODE_LAUNCH:
|
|
|
|
{
|
2014-02-10 18:08:45 +04:00
|
|
|
struct browser_window *existing = NULL;
|
2014-10-31 02:27:41 +03:00
|
|
|
enum browser_window_create_flags flags = BW_CREATE_HISTORY;
|
2013-08-15 22:19:24 +04:00
|
|
|
|
2014-02-10 18:08:45 +04:00
|
|
|
/* TODO: Set existing to window that new tab appears in */
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
if (msg.data.node_launch.mouse &
|
|
|
|
(BROWSER_MOUSE_MOD_1 | BROWSER_MOUSE_MOD_2) ||
|
2014-02-10 18:08:45 +04:00
|
|
|
existing == NULL) {
|
2013-08-15 22:19:24 +04:00
|
|
|
/* Shift or Ctrl launch, open in new window rather
|
|
|
|
* than tab. */
|
2014-02-10 18:08:45 +04:00
|
|
|
/* TODO: flags ^= BW_CREATE_TAB; */
|
2013-08-15 22:19:24 +04:00
|
|
|
}
|
|
|
|
|
2014-10-31 02:27:41 +03:00
|
|
|
err = browser_window_create(flags, e->url, NULL,
|
2014-02-10 18:08:45 +04:00
|
|
|
existing, NULL);
|
2013-08-15 22:19:24 +04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2014-10-31 02:27:41 +03:00
|
|
|
return err;
|
2013-08-15 22:19:24 +04:00
|
|
|
}
|
2014-10-31 02:27:41 +03:00
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
struct treeview_callback_table hl_tree_cb_t = {
|
|
|
|
.folder = hotlist_tree_node_folder_cb,
|
|
|
|
.entry = hotlist_tree_node_entry_cb
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
treeview *tree;
|
|
|
|
treeview_node *rel;
|
|
|
|
enum treeview_relationship relshp;
|
|
|
|
bool last_was_h4;
|
|
|
|
dom_string *title;
|
|
|
|
} hotlist_load_ctx;
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Parse an entry represented as a li.
|
|
|
|
*
|
2014-10-31 02:27:41 +03:00
|
|
|
* \param li DOM node for parsed li
|
|
|
|
* \param ctx Our hotlist loading context.
|
2013-08-15 22:19:24 +04:00
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_load_entry(dom_node *li, hotlist_load_ctx *ctx)
|
|
|
|
{
|
|
|
|
dom_node *a;
|
2013-08-15 23:57:09 +04:00
|
|
|
dom_string *title1, *url1;
|
2013-09-05 15:54:15 +04:00
|
|
|
const char *title;
|
2013-08-15 22:19:24 +04:00
|
|
|
nsurl *url;
|
|
|
|
dom_exception derror;
|
|
|
|
nserror err;
|
|
|
|
|
|
|
|
/* The li must contain an "a" element */
|
|
|
|
a = libdom_find_first_element(li, corestring_lwc_a);
|
|
|
|
if (a == NULL) {
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("Missing <a> in <li>");
|
2014-10-31 02:27:41 +03:00
|
|
|
return NSERROR_INVALID;
|
2013-08-15 22:19:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
derror = dom_node_get_text_content(a, &title1);
|
|
|
|
if (derror != DOM_NO_ERR) {
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("No title");
|
2013-08-15 22:19:24 +04:00
|
|
|
dom_node_unref(a);
|
2014-10-31 02:27:41 +03:00
|
|
|
return NSERROR_INVALID;
|
2013-08-15 22:19:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
derror = dom_element_get_attribute(a, corestring_dom_href, &url1);
|
|
|
|
if (derror != DOM_NO_ERR || url1 == NULL) {
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("No URL");
|
2013-08-15 22:19:24 +04:00
|
|
|
dom_string_unref(title1);
|
|
|
|
dom_node_unref(a);
|
2014-10-31 02:27:41 +03:00
|
|
|
return NSERROR_INVALID;
|
2013-08-15 22:19:24 +04:00
|
|
|
}
|
|
|
|
dom_node_unref(a);
|
|
|
|
|
|
|
|
if (title1 != NULL) {
|
2013-09-05 15:54:15 +04:00
|
|
|
title = dom_string_data(title1);
|
2013-08-15 22:19:24 +04:00
|
|
|
} else {
|
2013-11-11 18:32:07 +04:00
|
|
|
title = messages_get("NoTitle");
|
2013-08-15 22:19:24 +04:00
|
|
|
}
|
|
|
|
|
2013-08-15 22:55:12 +04:00
|
|
|
/* Need to get URL as a nsurl object */
|
2013-08-15 22:19:24 +04:00
|
|
|
err = nsurl_create(dom_string_data(url1), &url);
|
|
|
|
dom_string_unref(url1);
|
|
|
|
|
|
|
|
if (err != NSERROR_OK) {
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("Failed normalising '%s'", dom_string_data(url1));
|
2013-08-15 22:19:24 +04:00
|
|
|
|
2014-10-31 02:27:41 +03:00
|
|
|
if (title1 != NULL) {
|
2013-09-08 22:28:57 +04:00
|
|
|
dom_string_unref(title1);
|
2014-10-31 02:27:41 +03:00
|
|
|
}
|
2013-09-08 22:28:57 +04:00
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add the entry */
|
2013-08-15 23:57:09 +04:00
|
|
|
err = hotlist_add_entry_internal(url, title, NULL, ctx->rel,
|
2013-08-15 22:19:24 +04:00
|
|
|
ctx->relshp, &ctx->rel);
|
|
|
|
nsurl_unref(url);
|
2014-10-31 02:27:41 +03:00
|
|
|
if (title1 != NULL) {
|
2013-09-08 22:28:57 +04:00
|
|
|
dom_string_unref(title1);
|
2014-10-31 02:27:41 +03:00
|
|
|
}
|
2013-08-15 22:19:24 +04:00
|
|
|
ctx->relshp = TREE_REL_NEXT_SIBLING;
|
|
|
|
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Callback for libdom_iterate_child_elements, which dispite the namespace is
|
|
|
|
* a NetSurf function.
|
|
|
|
*
|
|
|
|
* \param node Node that is a child of the directory UL node
|
|
|
|
* \param ctx Our hotlist loading context.
|
|
|
|
*/
|
|
|
|
static nserror hotlist_load_directory_cb(dom_node *node, void *ctx);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Parse a directory represented as a ul.
|
|
|
|
*
|
2014-11-08 14:38:20 +03:00
|
|
|
* \param ul DOM node for parsed ul.
|
|
|
|
* \param ctx The hotlist context.
|
2013-08-15 22:19:24 +04:00
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_load_directory(dom_node *ul, hotlist_load_ctx *ctx)
|
|
|
|
{
|
|
|
|
assert(ul != NULL);
|
|
|
|
assert(ctx != NULL);
|
|
|
|
|
|
|
|
return libdom_iterate_child_elements(ul,
|
|
|
|
hotlist_load_directory_cb, ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Documented above, in forward declaration */
|
|
|
|
nserror hotlist_load_directory_cb(dom_node *node, void *ctx)
|
|
|
|
{
|
|
|
|
/* TODO: return appropriate errors */
|
|
|
|
hotlist_load_ctx *current_ctx = ctx;
|
|
|
|
dom_string *name;
|
|
|
|
dom_exception error;
|
|
|
|
nserror err;
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
|
|
|
|
error = dom_node_get_node_name(node, &name);
|
|
|
|
if (error != DOM_NO_ERR || name == NULL)
|
2014-10-31 02:27:41 +03:00
|
|
|
return NSERROR_DOM;
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
if (dom_string_caseless_lwc_isequal(name, corestring_lwc_li)) {
|
|
|
|
/* Entry handling */
|
|
|
|
hotlist_load_entry(node, current_ctx);
|
|
|
|
current_ctx->last_was_h4 = false;
|
|
|
|
|
|
|
|
} else if (dom_string_caseless_lwc_isequal(name, corestring_lwc_h4)) {
|
|
|
|
/* Directory handling, part 1: Get title from H4 */
|
|
|
|
dom_string *title;
|
|
|
|
|
|
|
|
error = dom_node_get_text_content(node, &title);
|
|
|
|
if (error != DOM_NO_ERR || title == NULL) {
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("Empty <h4> or memory exhausted.");
|
2013-08-15 22:19:24 +04:00
|
|
|
dom_string_unref(name);
|
2014-10-31 02:27:41 +03:00
|
|
|
return NSERROR_DOM;
|
2013-08-15 22:19:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (current_ctx->title != NULL)
|
|
|
|
dom_string_unref(current_ctx->title);
|
|
|
|
current_ctx->title = title;
|
|
|
|
current_ctx->last_was_h4 = true;
|
|
|
|
|
|
|
|
} else if (current_ctx->last_was_h4 &&
|
|
|
|
dom_string_caseless_lwc_isequal(name,
|
|
|
|
corestring_lwc_ul)) {
|
|
|
|
/* Directory handling, part 2: Make node, and handle children */
|
2013-09-05 15:54:15 +04:00
|
|
|
const char *title;
|
2013-08-27 14:40:12 +04:00
|
|
|
dom_string *id;
|
|
|
|
struct hotlist_folder *f;
|
2013-08-15 22:19:24 +04:00
|
|
|
hotlist_load_ctx new_ctx;
|
|
|
|
treeview_node *rel;
|
2013-11-08 22:53:34 +04:00
|
|
|
bool default_folder = false;
|
2013-08-16 01:46:54 +04:00
|
|
|
|
2013-08-27 14:40:12 +04:00
|
|
|
/* Check if folder should be default folder */
|
|
|
|
error = dom_element_get_attribute(node, corestring_dom_id, &id);
|
|
|
|
if (error != DOM_NO_ERR) {
|
|
|
|
dom_string_unref(name);
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
|
|
|
if (id != NULL) {
|
|
|
|
if (dom_string_lwc_isequal(id, corestring_lwc_default))
|
2013-11-08 22:53:34 +04:00
|
|
|
default_folder = true;
|
2013-08-27 14:40:12 +04:00
|
|
|
|
|
|
|
dom_string_unref(id);
|
|
|
|
}
|
|
|
|
|
2013-11-08 22:53:34 +04:00
|
|
|
title = dom_string_data(current_ctx->title);
|
|
|
|
|
|
|
|
/* Add folder node */
|
|
|
|
err = hotlist_add_folder_internal(title, current_ctx->rel,
|
|
|
|
current_ctx->relshp, &f, default_folder);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
dom_string_unref(name);
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (default_folder)
|
|
|
|
hl_ctx.default_folder = f;
|
|
|
|
|
2013-08-27 14:40:12 +04:00
|
|
|
rel = f->folder;
|
2013-08-15 22:19:24 +04:00
|
|
|
current_ctx->rel = rel;
|
|
|
|
current_ctx->relshp = TREE_REL_NEXT_SIBLING;
|
|
|
|
|
|
|
|
new_ctx.tree = current_ctx->tree;
|
|
|
|
new_ctx.rel = rel;
|
|
|
|
new_ctx.relshp = TREE_REL_FIRST_CHILD;
|
|
|
|
new_ctx.last_was_h4 = false;
|
|
|
|
new_ctx.title = NULL;
|
|
|
|
|
|
|
|
/* And load its contents */
|
|
|
|
err = hotlist_load_directory(node, &new_ctx);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
dom_string_unref(name);
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (new_ctx.title != NULL) {
|
|
|
|
dom_string_unref(new_ctx.title);
|
|
|
|
new_ctx.title = NULL;
|
|
|
|
}
|
|
|
|
current_ctx->last_was_h4 = false;
|
|
|
|
} else {
|
|
|
|
current_ctx->last_was_h4 = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
dom_string_unref(name);
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-02 15:43:46 +03:00
|
|
|
/*
|
|
|
|
* Get path for writing hotlist to
|
|
|
|
*
|
|
|
|
* \param path The final path of the hotlist
|
|
|
|
* \param loaded Updated to the path to write the holist to
|
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_get_temp_path(const char *path, char **temp_path)
|
|
|
|
{
|
2015-01-02 16:37:39 +03:00
|
|
|
const char *extension = "-bk";
|
2015-01-02 15:43:46 +03:00
|
|
|
char *joined;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
len = strlen(path) + strlen(extension);
|
|
|
|
|
|
|
|
joined = malloc(len + 1);
|
|
|
|
if (joined == NULL) {
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (snprintf(joined, len + 1, "%s%s", path, extension) != len) {
|
|
|
|
free(joined);
|
|
|
|
return NSERROR_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
|
|
|
*temp_path = joined;
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
/*
|
|
|
|
* Load the hotlist data from file
|
|
|
|
*
|
|
|
|
* \param path The path to load the hotlist file from, or NULL
|
|
|
|
* \param loaded Updated to true iff hotlist file loaded, else set false
|
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_load(const char *path, bool *loaded)
|
|
|
|
{
|
|
|
|
dom_document *document;
|
|
|
|
dom_node *html, *body, *ul;
|
|
|
|
hotlist_load_ctx ctx;
|
2015-01-02 15:43:46 +03:00
|
|
|
char *temp_path;
|
2013-08-15 22:19:24 +04:00
|
|
|
nserror err;
|
|
|
|
|
|
|
|
*loaded = false;
|
|
|
|
|
|
|
|
/* Handle no path */
|
|
|
|
if (path == NULL) {
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("No hotlist file path provided.");
|
2013-08-15 22:19:24 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
2015-01-02 15:43:46 +03:00
|
|
|
/* Get temp hotlist write path */
|
|
|
|
err = hotlist_get_temp_path(path, &temp_path);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
/* Load hotlist file */
|
|
|
|
err = libdom_parse_file(path, "iso-8859-1", &document);
|
|
|
|
if (err != NSERROR_OK) {
|
2015-01-02 15:43:46 +03:00
|
|
|
err = libdom_parse_file(temp_path, "iso-8859-1", &document);
|
|
|
|
if (err != NSERROR_OK) {
|
2015-01-02 18:24:40 +03:00
|
|
|
free(temp_path);
|
2015-01-02 15:43:46 +03:00
|
|
|
return err;
|
|
|
|
}
|
2013-08-15 22:19:24 +04:00
|
|
|
}
|
2015-01-02 18:24:40 +03:00
|
|
|
free(temp_path);
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
/* Find HTML element */
|
|
|
|
html = libdom_find_first_element((dom_node *) document,
|
|
|
|
corestring_lwc_html);
|
|
|
|
if (html == NULL) {
|
|
|
|
dom_node_unref(document);
|
2016-04-26 14:50:16 +03:00
|
|
|
guit->misc->warning("TreeLoadError", "(<html> not found)");
|
2013-08-15 22:19:24 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find BODY element */
|
|
|
|
body = libdom_find_first_element(html, corestring_lwc_body);
|
|
|
|
if (body == NULL) {
|
|
|
|
dom_node_unref(html);
|
|
|
|
dom_node_unref(document);
|
2016-04-26 14:50:16 +03:00
|
|
|
guit->misc->warning("TreeLoadError", "(<html>...<body> not found)");
|
2013-08-15 22:19:24 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find UL element */
|
|
|
|
ul = libdom_find_first_element(body, corestring_lwc_ul);
|
|
|
|
if (ul == NULL) {
|
|
|
|
dom_node_unref(body);
|
|
|
|
dom_node_unref(html);
|
|
|
|
dom_node_unref(document);
|
2016-04-26 14:50:16 +03:00
|
|
|
guit->misc->warning("TreeLoadError",
|
2013-08-15 22:19:24 +04:00
|
|
|
"(<html>...<body>...<ul> not found.)");
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set up the hotlist loading context */
|
|
|
|
ctx.tree = hl_ctx.tree;
|
|
|
|
ctx.rel = NULL;
|
|
|
|
ctx.relshp = TREE_REL_FIRST_CHILD;
|
|
|
|
ctx.last_was_h4 = false;
|
|
|
|
ctx.title = NULL;
|
|
|
|
|
|
|
|
err = hotlist_load_directory(ul, &ctx);
|
|
|
|
|
|
|
|
if (ctx.title != NULL) {
|
|
|
|
dom_string_unref(ctx.title);
|
|
|
|
ctx.title = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dom_node_unref(ul);
|
|
|
|
dom_node_unref(body);
|
|
|
|
dom_node_unref(html);
|
|
|
|
dom_node_unref(document);
|
|
|
|
|
2013-08-15 22:51:42 +04:00
|
|
|
if (err != NSERROR_OK) {
|
2016-04-26 14:50:16 +03:00
|
|
|
guit->misc->warning("TreeLoadError", "(Failed building tree.)");
|
2013-08-15 22:51:42 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
2013-08-16 01:46:54 +04:00
|
|
|
*loaded = true;
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Generate default hotlist
|
|
|
|
*
|
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_generate(void)
|
|
|
|
{
|
2013-08-16 01:27:28 +04:00
|
|
|
int i;
|
2013-08-27 14:40:12 +04:00
|
|
|
struct hotlist_folder *f;
|
2013-08-16 01:27:28 +04:00
|
|
|
treeview_node *e;
|
2013-09-05 15:54:15 +04:00
|
|
|
const char *title;
|
2013-08-16 01:27:28 +04:00
|
|
|
nserror err;
|
|
|
|
nsurl *url;
|
|
|
|
static const struct {
|
|
|
|
const char *url;
|
|
|
|
const char *msg_key;
|
|
|
|
} default_entries[] = {
|
|
|
|
{ "http://www.netsurf-browser.org/",
|
|
|
|
"HotlistHomepage" },
|
|
|
|
{ "http://www.netsurf-browser.org/downloads/",
|
|
|
|
"HotlistDownloads" },
|
|
|
|
{ "http://www.netsurf-browser.org/documentation",
|
|
|
|
"HotlistDocumentation" },
|
|
|
|
{ "http://www.netsurf-browser.org/contact",
|
|
|
|
"HotlistContact" }
|
|
|
|
};
|
|
|
|
const int n_entries = sizeof(default_entries) /
|
|
|
|
sizeof(default_entries[0]);
|
|
|
|
|
|
|
|
/* First make "NetSurf" folder for defualt entries */
|
2013-09-05 15:54:15 +04:00
|
|
|
title = "NetSurf";
|
2013-08-16 01:27:28 +04:00
|
|
|
err = hotlist_add_folder_internal(title, NULL,
|
2013-11-08 22:53:34 +04:00
|
|
|
TREE_REL_FIRST_CHILD, &f, false);
|
2013-08-16 01:27:28 +04:00
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* And add entries as children of folder node */
|
|
|
|
for (i = n_entries - 1; i >= 0; i--) {
|
|
|
|
/* Get URL as nsurl object */
|
|
|
|
err = nsurl_create(default_entries[i].url, &url);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
|
|
|
|
2013-09-05 15:54:15 +04:00
|
|
|
title = messages_get(default_entries[i].msg_key);
|
2013-08-16 01:27:28 +04:00
|
|
|
|
|
|
|
/* Build the node */
|
|
|
|
err = hotlist_add_entry_internal(url, title,
|
2013-08-27 14:40:12 +04:00
|
|
|
NULL, f->folder, TREE_REL_FIRST_CHILD, &e);
|
2013-08-16 01:27:28 +04:00
|
|
|
nsurl_unref(url);
|
|
|
|
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-02 15:43:46 +03:00
|
|
|
/* Save the hotlist to to a file at the given path
|
|
|
|
*
|
|
|
|
* \param path Path to save hostlist file to.
|
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_save(const char *path)
|
|
|
|
{
|
|
|
|
nserror res = NSERROR_OK;
|
|
|
|
char *temp_path;
|
|
|
|
|
|
|
|
/* Get path to export to */
|
|
|
|
res = hotlist_get_temp_path(path, &temp_path);
|
|
|
|
if (res != NSERROR_OK) {
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Export to temp path */
|
|
|
|
res = hotlist_export(temp_path, NULL);
|
|
|
|
if (res != NSERROR_OK) {
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2015-02-03 13:15:37 +03:00
|
|
|
/* Remove old hotlist to handle non-POSIX rename() implementations. */
|
|
|
|
(void)remove(path);
|
|
|
|
|
2015-01-23 17:11:43 +03:00
|
|
|
/* Replace any old hotlist file with the one we just saved */
|
2015-01-02 18:32:47 +03:00
|
|
|
if (rename(temp_path, path) != 0) {
|
|
|
|
res = NSERROR_SAVE_FAILED;
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("Error renaming hotlist: %s.", strerror(errno));
|
2015-01-02 18:32:47 +03:00
|
|
|
goto cleanup;
|
|
|
|
}
|
2015-01-02 15:43:46 +03:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
free(temp_path);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-28 14:05:21 +04:00
|
|
|
struct treeview_export_walk_ctx {
|
2013-08-22 19:06:06 +04:00
|
|
|
FILE *fp;
|
|
|
|
};
|
2015-01-02 15:43:46 +03:00
|
|
|
|
2013-08-22 19:06:06 +04:00
|
|
|
/** Callback for treeview_walk node entering */
|
|
|
|
static nserror hotlist_export_enter_cb(void *ctx, void *node_data,
|
|
|
|
enum treeview_node_type type, bool *abort)
|
|
|
|
{
|
2013-08-28 14:05:21 +04:00
|
|
|
struct treeview_export_walk_ctx *tw = ctx;
|
2014-01-29 01:40:13 +04:00
|
|
|
nserror ret;
|
2013-08-22 19:06:06 +04:00
|
|
|
|
|
|
|
if (type == TREE_NODE_ENTRY) {
|
|
|
|
struct hotlist_entry *e = node_data;
|
|
|
|
char *t_text;
|
|
|
|
char *u_text;
|
|
|
|
|
|
|
|
ret = utf8_to_html(e->data[HL_TITLE].value, "iso-8859-1",
|
|
|
|
e->data[HL_TITLE].value_len, &t_text);
|
2014-01-29 01:40:13 +04:00
|
|
|
if (ret != NSERROR_OK)
|
2013-08-22 19:06:06 +04:00
|
|
|
return NSERROR_SAVE_FAILED;
|
|
|
|
|
|
|
|
ret = utf8_to_html(e->data[HL_URL].value, "iso-8859-1",
|
|
|
|
e->data[HL_URL].value_len, &u_text);
|
2014-01-29 01:40:13 +04:00
|
|
|
if (ret != NSERROR_OK) {
|
2013-08-22 19:06:06 +04:00
|
|
|
free(t_text);
|
|
|
|
return NSERROR_SAVE_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(tw->fp, "<li><a href=\"%s\">%s</a></li>\n",
|
|
|
|
u_text, t_text);
|
|
|
|
|
|
|
|
free(t_text);
|
|
|
|
free(u_text);
|
|
|
|
|
|
|
|
} else if (type == TREE_NODE_FOLDER) {
|
|
|
|
struct hotlist_folder *f = node_data;
|
|
|
|
char *f_text;
|
|
|
|
|
|
|
|
ret = utf8_to_html(f->data.value, "iso-8859-1",
|
|
|
|
f->data.value_len, &f_text);
|
2014-01-29 01:40:13 +04:00
|
|
|
if (ret != NSERROR_OK)
|
2013-08-22 19:06:06 +04:00
|
|
|
return NSERROR_SAVE_FAILED;
|
|
|
|
|
2013-08-27 14:40:12 +04:00
|
|
|
if (f == hl_ctx.default_folder) {
|
|
|
|
fprintf(tw->fp, "<h4>%s</h4>\n<ul id=\"default\">\n",
|
|
|
|
f_text);
|
|
|
|
} else {
|
|
|
|
fprintf(tw->fp, "<h4>%s</h4>\n<ul>\n", f_text);
|
|
|
|
}
|
2013-08-22 19:06:06 +04:00
|
|
|
|
|
|
|
free(f_text);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
/** Callback for treeview_walk node leaving */
|
|
|
|
static nserror hotlist_export_leave_cb(void *ctx, void *node_data,
|
|
|
|
enum treeview_node_type type, bool *abort)
|
|
|
|
{
|
2013-08-28 14:05:21 +04:00
|
|
|
struct treeview_export_walk_ctx *tw = ctx;
|
2013-08-22 19:06:06 +04:00
|
|
|
|
|
|
|
if (type == TREE_NODE_FOLDER) {
|
|
|
|
fputs("</ul>\n", tw->fp);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
2013-08-28 13:59:56 +04:00
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
nserror hotlist_export(const char *path, const char *title)
|
2013-08-15 22:19:24 +04:00
|
|
|
{
|
2013-08-28 14:05:21 +04:00
|
|
|
struct treeview_export_walk_ctx tw;
|
2013-08-22 19:06:06 +04:00
|
|
|
nserror err;
|
|
|
|
FILE *fp;
|
|
|
|
|
|
|
|
fp = fopen(path, "w");
|
|
|
|
if (fp == NULL)
|
|
|
|
return NSERROR_SAVE_FAILED;
|
|
|
|
|
2013-08-28 14:14:33 +04:00
|
|
|
if (title == NULL)
|
|
|
|
title = "NetSurf hotlist";
|
|
|
|
|
2013-08-22 19:06:06 +04:00
|
|
|
/* The Acorn Browse Hotlist format, which we mimic[*], is invalid HTML
|
|
|
|
* claming to be valid.
|
|
|
|
* [*] Why? */
|
|
|
|
fputs("<!DOCTYPE html "
|
|
|
|
"PUBLIC \"//W3C/DTD HTML 4.01//EN\" "
|
|
|
|
"\"http://www.w3.org/TR/html4/strict.dtd\">\n", fp);
|
|
|
|
fputs("<html>\n<head>\n", fp);
|
|
|
|
fputs("<meta http-equiv=\"Content-Type\" "
|
|
|
|
"content=\"text/html; charset=iso-8859-1\">\n", fp);
|
|
|
|
fprintf(fp, "<title>%s</title>\n", title);
|
|
|
|
fputs("</head>\n<body>\n<ul>\n", fp);
|
|
|
|
|
|
|
|
tw.fp = fp;
|
|
|
|
err = treeview_walk(hl_ctx.tree, NULL,
|
|
|
|
hotlist_export_enter_cb,
|
|
|
|
hotlist_export_leave_cb,
|
|
|
|
&tw, TREE_NODE_ENTRY | TREE_NODE_FOLDER);
|
|
|
|
if (err != NSERROR_OK)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
fputs("</ul>\n</body>\n</html>\n", fp);
|
|
|
|
|
|
|
|
fclose(fp);
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-03 22:43:59 +04:00
|
|
|
struct hotlist_iterate_ctx {
|
|
|
|
hotlist_folder_enter_cb enter_cb;
|
|
|
|
hotlist_address_cb address_cb;
|
|
|
|
hotlist_folder_leave_cb leave_cb;
|
|
|
|
void *ctx;
|
|
|
|
};
|
|
|
|
/** Callback for hotlist_iterate node entering */
|
|
|
|
static nserror hotlist_iterate_enter_cb(void *ctx, void *node_data,
|
|
|
|
enum treeview_node_type type, bool *abort)
|
|
|
|
{
|
|
|
|
struct hotlist_iterate_ctx *data = ctx;
|
|
|
|
|
|
|
|
if (type == TREE_NODE_ENTRY && data->address_cb != NULL) {
|
|
|
|
struct hotlist_entry *e = node_data;
|
|
|
|
data->address_cb(data->ctx, e->url,
|
|
|
|
e->data[HL_TITLE].value);
|
|
|
|
|
|
|
|
} else if (type == TREE_NODE_FOLDER && data->enter_cb != NULL) {
|
|
|
|
struct hotlist_folder *f = node_data;
|
|
|
|
data->enter_cb(data->ctx, f->data.value);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
/** Callback for hotlist_iterate node leaving */
|
|
|
|
static nserror hotlist_iterate_leave_cb(void *ctx, void *node_data,
|
|
|
|
enum treeview_node_type type, bool *abort)
|
|
|
|
{
|
|
|
|
struct hotlist_iterate_ctx *data = ctx;
|
|
|
|
|
|
|
|
if (type == TREE_NODE_FOLDER && data->leave_cb != NULL) {
|
|
|
|
data->leave_cb(data->ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
nserror hotlist_iterate(void *ctx,
|
|
|
|
hotlist_folder_enter_cb enter_cb,
|
|
|
|
hotlist_address_cb address_cb,
|
|
|
|
hotlist_folder_leave_cb leave_cb)
|
|
|
|
{
|
|
|
|
struct hotlist_iterate_ctx data;
|
|
|
|
nserror err;
|
|
|
|
|
|
|
|
data.enter_cb = enter_cb;
|
|
|
|
data.address_cb = address_cb;
|
|
|
|
data.leave_cb = leave_cb;
|
|
|
|
data.ctx = ctx;
|
|
|
|
|
|
|
|
err = treeview_walk(hl_ctx.tree, NULL,
|
|
|
|
hotlist_iterate_enter_cb,
|
|
|
|
hotlist_iterate_leave_cb,
|
|
|
|
&data, TREE_NODE_ENTRY | TREE_NODE_FOLDER);
|
|
|
|
if (err != NSERROR_OK)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
/**
|
|
|
|
* Initialise the treeview entry feilds
|
|
|
|
*
|
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_initialise_entry_fields(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
const char *label;
|
|
|
|
|
|
|
|
for (i = 0; i < HL_N_FIELDS; i++)
|
|
|
|
hl_ctx.fields[i].field = NULL;
|
|
|
|
|
2013-08-18 20:16:47 +04:00
|
|
|
hl_ctx.fields[HL_TITLE].flags = TREE_FLAG_DEFAULT |
|
|
|
|
TREE_FLAG_ALLOW_EDIT;
|
2013-08-15 22:19:24 +04:00
|
|
|
label = "TreeviewLabelTitle";
|
|
|
|
label = messages_get(label);
|
|
|
|
if (lwc_intern_string(label, strlen(label),
|
|
|
|
&hl_ctx.fields[HL_TITLE].field) !=
|
|
|
|
lwc_error_ok) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2015-01-03 03:17:11 +03:00
|
|
|
hl_ctx.fields[HL_URL].flags = TREE_FLAG_ALLOW_EDIT |
|
|
|
|
TREE_FLAG_COPY_TEXT;
|
2013-08-15 22:19:24 +04:00
|
|
|
label = "TreeviewLabelURL";
|
|
|
|
label = messages_get(label);
|
|
|
|
if (lwc_intern_string(label, strlen(label),
|
|
|
|
&hl_ctx.fields[HL_URL].field) !=
|
|
|
|
lwc_error_ok) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
hl_ctx.fields[HL_LAST_VISIT].flags = TREE_FLAG_SHOW_NAME;
|
|
|
|
label = "TreeviewLabelLastVisit";
|
|
|
|
label = messages_get(label);
|
|
|
|
if (lwc_intern_string(label, strlen(label),
|
|
|
|
&hl_ctx.fields[HL_LAST_VISIT].field) !=
|
|
|
|
lwc_error_ok) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
hl_ctx.fields[HL_VISITS].flags = TREE_FLAG_SHOW_NAME;
|
|
|
|
label = "TreeviewLabelVisits";
|
|
|
|
label = messages_get(label);
|
|
|
|
if (lwc_intern_string(label, strlen(label),
|
|
|
|
&hl_ctx.fields[HL_VISITS].field) !=
|
|
|
|
lwc_error_ok) {
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2013-08-18 20:16:47 +04:00
|
|
|
hl_ctx.fields[HL_FOLDER].flags = TREE_FLAG_DEFAULT |
|
|
|
|
TREE_FLAG_ALLOW_EDIT;
|
2013-08-15 22:19:24 +04:00
|
|
|
label = "TreeviewLabelFolder";
|
|
|
|
label = messages_get(label);
|
|
|
|
if (lwc_intern_string(label, strlen(label),
|
|
|
|
&hl_ctx.fields[HL_FOLDER].field) !=
|
|
|
|
lwc_error_ok) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
|
|
|
error:
|
|
|
|
for (i = 0; i < HL_N_FIELDS; i++)
|
|
|
|
if (hl_ctx.fields[i].field != NULL)
|
|
|
|
lwc_string_unref(hl_ctx.fields[i].field);
|
|
|
|
|
|
|
|
return NSERROR_UNKNOWN;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Populate the hotlist from file, or generate default hotlist if no file
|
|
|
|
*
|
|
|
|
* \param path The path to load the hotlist file from, or NULL
|
|
|
|
* \return NSERROR_OK on success, or appropriate error otherwise
|
|
|
|
*/
|
|
|
|
static nserror hotlist_populate(const char *path)
|
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
bool loaded;
|
|
|
|
|
|
|
|
/* Load hotlist file */
|
|
|
|
err = hotlist_load(path, &loaded);
|
|
|
|
|
2013-09-05 14:53:19 +04:00
|
|
|
if (loaded && err == NSERROR_OK)
|
|
|
|
return err;
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
/* Couldn't load hotlist, generate a default one */
|
|
|
|
err = hotlist_generate();
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
nserror hotlist_init(struct core_window_callback_table *cw_t,
|
|
|
|
void *core_window_handle, const char *path)
|
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("Loading hotlist");
|
2013-08-15 22:19:24 +04:00
|
|
|
|
2013-08-27 14:40:12 +04:00
|
|
|
hl_ctx.tree = NULL;
|
|
|
|
hl_ctx.built = false;
|
|
|
|
hl_ctx.default_folder = NULL;
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
/* Init. hotlist treeview entry fields */
|
|
|
|
err = hotlist_initialise_entry_fields();
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
hl_ctx.tree = NULL;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create the hotlist treeview */
|
|
|
|
err = treeview_create(&hl_ctx.tree, &hl_tree_cb_t,
|
|
|
|
HL_N_FIELDS, hl_ctx.fields,
|
|
|
|
cw_t, core_window_handle,
|
2013-08-16 23:01:58 +04:00
|
|
|
TREEVIEW_NO_FLAGS);
|
2013-08-15 22:19:24 +04:00
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
hl_ctx.tree = NULL;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Populate the hotlist */
|
|
|
|
err = hotlist_populate(path);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Hotlist tree is built
|
|
|
|
* We suppress the treeview height callback on entry insertion before
|
|
|
|
* the treeview is built. */
|
|
|
|
hl_ctx.built = true;
|
|
|
|
|
2013-09-03 17:38:01 +04:00
|
|
|
/* Inform client of window height */
|
|
|
|
treeview_get_height(hl_ctx.tree);
|
|
|
|
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("Loaded hotlist");
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
nserror hotlist_fini(const char *path)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
nserror err;
|
|
|
|
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("Finalising hotlist");
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
/* Save the hotlist */
|
2015-01-02 15:43:46 +03:00
|
|
|
err = hotlist_save(path);
|
2013-08-15 22:19:24 +04:00
|
|
|
if (err != NSERROR_OK) {
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("Problem saving the hotlist.");
|
2013-08-15 22:19:24 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Destroy the hotlist treeview */
|
|
|
|
err = treeview_destroy(hl_ctx.tree);
|
2013-08-16 00:13:40 +04:00
|
|
|
hl_ctx.built = false;
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
/* Free hotlist treeview entry fields */
|
|
|
|
for (i = 0; i < HL_N_FIELDS; i++)
|
|
|
|
if (hl_ctx.fields[i].field != NULL)
|
|
|
|
lwc_string_unref(hl_ctx.fields[i].field);
|
|
|
|
|
2015-05-28 18:08:46 +03:00
|
|
|
LOG("Finalised hotlist");
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
2013-08-23 21:26:18 +04:00
|
|
|
nserror hotlist_add_url(nsurl *url)
|
2013-08-15 22:19:24 +04:00
|
|
|
{
|
2013-08-16 00:10:36 +04:00
|
|
|
treeview_node *entry;
|
|
|
|
nserror err;
|
2013-08-15 22:19:24 +04:00
|
|
|
|
|
|
|
/* If we don't have a hotlist at the moment, just return OK */
|
|
|
|
if (hl_ctx.tree == NULL)
|
|
|
|
return NSERROR_OK;
|
|
|
|
|
2013-08-27 14:57:31 +04:00
|
|
|
/* Make the default folder, if we don't have one */
|
|
|
|
if (hl_ctx.default_folder == NULL) {
|
2013-08-27 15:44:01 +04:00
|
|
|
const char *temp = messages_get("HotlistDefaultFolderName");
|
2013-08-27 14:57:31 +04:00
|
|
|
struct hotlist_folder *f;
|
2013-09-05 15:54:15 +04:00
|
|
|
err = hotlist_add_folder_internal(temp, NULL,
|
2013-11-08 22:53:34 +04:00
|
|
|
TREE_REL_FIRST_CHILD, &f, true);
|
2013-08-27 14:57:31 +04:00
|
|
|
if (err != NSERROR_OK)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (f == NULL)
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
|
|
|
|
hl_ctx.default_folder = f;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add new entry to default folder */
|
|
|
|
err = hotlist_add_entry_internal(url, NULL, NULL,
|
|
|
|
hl_ctx.default_folder->folder,
|
2013-08-16 00:10:36 +04:00
|
|
|
TREE_REL_FIRST_CHILD, &entry);
|
2013-09-05 14:55:49 +04:00
|
|
|
if (err != NSERROR_OK)
|
|
|
|
return err;
|
2013-08-15 22:19:24 +04:00
|
|
|
|
2013-08-27 14:57:31 +04:00
|
|
|
/* Ensure default folder is expanded */
|
|
|
|
err = treeview_node_expand(hl_ctx.tree, hl_ctx.default_folder->folder);
|
2013-09-05 14:55:49 +04:00
|
|
|
if (err != NSERROR_OK)
|
|
|
|
return err;
|
2013-08-27 14:57:31 +04:00
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-23 20:30:31 +04:00
|
|
|
struct treeview_has_url_walk_ctx {
|
|
|
|
nsurl *url;
|
|
|
|
bool found;
|
|
|
|
};
|
|
|
|
/** Callback for treeview_walk */
|
|
|
|
static nserror hotlist_has_url_walk_cb(void *ctx, void *node_data,
|
|
|
|
enum treeview_node_type type, bool *abort)
|
|
|
|
{
|
|
|
|
struct treeview_has_url_walk_ctx *tw = ctx;
|
|
|
|
|
|
|
|
if (type == TREE_NODE_ENTRY) {
|
|
|
|
struct hotlist_entry *e = node_data;
|
|
|
|
|
|
|
|
if (nsurl_compare(e->url, tw->url, NSURL_COMPLETE) == true) {
|
|
|
|
/* Found what we're looking for */
|
|
|
|
tw->found = true;
|
|
|
|
*abort = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
bool hotlist_has_url(nsurl *url)
|
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
struct treeview_has_url_walk_ctx tw = {
|
|
|
|
.url = url,
|
|
|
|
.found = false
|
|
|
|
};
|
|
|
|
|
|
|
|
if (hl_ctx.built == false)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
err = treeview_walk(hl_ctx.tree, NULL, hotlist_has_url_walk_cb, NULL,
|
|
|
|
&tw, TREE_NODE_ENTRY);
|
|
|
|
if (err != NSERROR_OK)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return tw.found;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-23 21:26:18 +04:00
|
|
|
struct treeview_remove_url_walk_ctx {
|
|
|
|
nsurl *url;
|
|
|
|
};
|
|
|
|
/** Callback for treeview_walk */
|
|
|
|
static nserror hotlist_remove_url_walk_cb(void *ctx, void *node_data,
|
|
|
|
enum treeview_node_type type, bool *abort)
|
|
|
|
{
|
|
|
|
struct treeview_remove_url_walk_ctx *tw = ctx;
|
|
|
|
|
|
|
|
if (type == TREE_NODE_ENTRY) {
|
|
|
|
struct hotlist_entry *e = node_data;
|
|
|
|
|
|
|
|
if (nsurl_compare(e->url, tw->url, NSURL_COMPLETE) == true) {
|
|
|
|
/* Found what we're looking for: delete it */
|
2013-08-30 15:51:40 +04:00
|
|
|
treeview_delete_node(hl_ctx.tree, e->entry,
|
|
|
|
TREE_OPTION_NONE);
|
2013-08-23 21:26:18 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
void hotlist_remove_url(nsurl *url)
|
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
struct treeview_remove_url_walk_ctx tw = {
|
|
|
|
.url = url
|
|
|
|
};
|
|
|
|
|
|
|
|
if (hl_ctx.built == false)
|
|
|
|
return;
|
|
|
|
|
|
|
|
err = treeview_walk(hl_ctx.tree, NULL, NULL, hotlist_remove_url_walk_cb,
|
|
|
|
&tw, TREE_NODE_ENTRY);
|
|
|
|
if (err != NSERROR_OK)
|
|
|
|
return;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-23 22:49:06 +04:00
|
|
|
struct treeview_update_url_walk_ctx {
|
|
|
|
nsurl *url;
|
|
|
|
const struct url_data *data;
|
|
|
|
};
|
|
|
|
/** Callback for treeview_walk */
|
|
|
|
static nserror hotlist_update_url_walk_cb(void *ctx, void *node_data,
|
|
|
|
enum treeview_node_type type, bool *abort)
|
|
|
|
{
|
|
|
|
struct treeview_update_url_walk_ctx *tw = ctx;
|
|
|
|
struct hotlist_entry *e = node_data;
|
|
|
|
nserror err;
|
|
|
|
|
|
|
|
if (type != TREE_NODE_ENTRY) {
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nsurl_compare(e->url, tw->url, NSURL_COMPLETE) == true) {
|
|
|
|
/* Found match: Update the entry data */
|
|
|
|
free((void *)e->data[HL_LAST_VISIT].value); /* Eww */
|
|
|
|
free((void *)e->data[HL_VISITS].value); /* Eww */
|
|
|
|
|
|
|
|
if (tw->data == NULL) {
|
|
|
|
/* Get the URL data */
|
|
|
|
tw->data = urldb_get_url_data(tw->url);
|
|
|
|
if (tw->data == NULL) {
|
|
|
|
/* No entry in database, so add one */
|
|
|
|
urldb_add_url(tw->url);
|
|
|
|
/* now attempt to get url data */
|
|
|
|
tw->data = urldb_get_url_data(tw->url);
|
|
|
|
}
|
|
|
|
if (tw->data == NULL) {
|
|
|
|
return NSERROR_NOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-05 15:54:15 +04:00
|
|
|
err = hotlist_create_treeview_field_visits_data(e, tw->data);
|
2013-08-23 22:49:06 +04:00
|
|
|
if (err != NSERROR_OK)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = treeview_update_node_entry(hl_ctx.tree,
|
|
|
|
e->entry, e->data, e);
|
|
|
|
if (err != NSERROR_OK)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
void hotlist_update_url(nsurl *url)
|
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
struct treeview_update_url_walk_ctx tw = {
|
|
|
|
.url = url,
|
|
|
|
.data = NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
if (hl_ctx.built == false)
|
|
|
|
return;
|
|
|
|
|
|
|
|
err = treeview_walk(hl_ctx.tree, NULL, hotlist_update_url_walk_cb, NULL,
|
|
|
|
&tw, TREE_NODE_ENTRY);
|
|
|
|
if (err != NSERROR_OK)
|
|
|
|
return;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-27 23:56:43 +04:00
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
nserror hotlist_add_entry(nsurl *url, const char *title, bool at_y, int y)
|
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
treeview_node *entry;
|
|
|
|
treeview_node *relation;
|
|
|
|
enum treeview_relationship rel;
|
|
|
|
|
|
|
|
if (url == NULL) {
|
|
|
|
err = nsurl_create("http://netsurf-browser.org/", &url);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
assert(url != NULL);
|
|
|
|
} else {
|
|
|
|
nsurl_ref(url);
|
|
|
|
}
|
|
|
|
|
|
|
|
err = treeview_get_relation(hl_ctx.tree, &relation, &rel, at_y, y);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
nsurl_unref(url);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-29 16:08:04 +04:00
|
|
|
err = hotlist_add_entry_internal(url, title, NULL,
|
2013-08-27 23:56:43 +04:00
|
|
|
relation, rel, &entry);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
nsurl_unref(url);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-08-28 00:01:35 +04:00
|
|
|
nsurl_unref(url);
|
|
|
|
|
2013-08-27 23:56:43 +04:00
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
nserror hotlist_add_folder(const char *title, bool at_y, int y)
|
|
|
|
{
|
|
|
|
nserror err;
|
|
|
|
struct hotlist_folder *f;
|
|
|
|
treeview_node *relation;
|
|
|
|
enum treeview_relationship rel;
|
|
|
|
|
|
|
|
err = treeview_get_relation(hl_ctx.tree, &relation, &rel, at_y, y);
|
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-11-08 22:53:34 +04:00
|
|
|
err = hotlist_add_folder_internal(title, relation, rel, &f, false);
|
2013-08-27 23:56:43 +04:00
|
|
|
if (err != NSERROR_OK) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NSERROR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-15 22:19:24 +04:00
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
void hotlist_redraw(int x, int y, struct rect *clip,
|
|
|
|
const struct redraw_context *ctx)
|
|
|
|
{
|
|
|
|
treeview_redraw(hl_ctx.tree, x, y, clip, ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
void hotlist_mouse_action(browser_mouse_state mouse, int x, int y)
|
|
|
|
{
|
|
|
|
treeview_mouse_action(hl_ctx.tree, mouse, x, y);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
void hotlist_keypress(uint32_t key)
|
|
|
|
{
|
|
|
|
treeview_keypress(hl_ctx.tree, key);
|
|
|
|
}
|
|
|
|
|
2013-08-28 17:13:02 +04:00
|
|
|
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
bool hotlist_has_selection(void)
|
|
|
|
{
|
|
|
|
return treeview_has_selection(hl_ctx.tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-13 17:24:25 +04:00
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
bool hotlist_get_selection(nsurl **url, const char **title)
|
|
|
|
{
|
|
|
|
struct hotlist_entry *e;
|
2014-05-24 18:09:20 +04:00
|
|
|
enum treeview_node_type type;
|
2013-09-13 17:24:25 +04:00
|
|
|
void *v;
|
|
|
|
|
2014-05-24 18:09:20 +04:00
|
|
|
type = treeview_get_selection(hl_ctx.tree, &v);
|
|
|
|
if (type != TREE_NODE_ENTRY || v == NULL) {
|
2013-09-13 17:24:25 +04:00
|
|
|
*url = NULL;
|
|
|
|
*title = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
e = (struct hotlist_entry *)v;
|
|
|
|
|
|
|
|
*url = e->url;
|
|
|
|
*title = e->data[HL_TITLE].value;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-08-28 17:13:02 +04:00
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
void hotlist_edit_selection(void)
|
|
|
|
{
|
|
|
|
treeview_edit_selection(hl_ctx.tree);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-03 14:28:02 +04:00
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
nserror hotlist_expand(bool only_folders)
|
|
|
|
{
|
|
|
|
return treeview_expand(hl_ctx.tree, only_folders);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Exported interface, documented in hotlist.h */
|
|
|
|
nserror hotlist_contract(bool all)
|
|
|
|
{
|
|
|
|
return treeview_contract(hl_ctx.tree, all);
|
|
|
|
}
|
|
|
|
|