mirrors/netsurf
1
0
Fork 0
mirror of https://github.com/netsurf-browser/netsurf synced 2024-12-26 05:57:00 +03:00
Code Issues Packages Projects Releases Wiki Activity
010039686d
netsurf/riscos/hotlist.c
Richard Wilson 2601897638 [project @ 2004-11-03 17:57:39 by rjw] 
Hotlist entries are correctly redrawn when renamed

svn path=/import/netsurf/; revision=1340
2004-11-03 17:57:39 +00:00

2609 lines
67 KiB
C
Raw Blame History

/*
* This file is part of NetSurf, http://netsurf.sourceforge.net/
* Licensed under the GNU General Public License,
* http://www.opensource.org/licenses/gpl-license
* Copyright 2004 Richard Wilson <not_ginger_matt@users.sourceforge.net>
*/
/** \file
* Hotlist (implementation).
*/
#include <string.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
#include <swis.h>
#include "libxml/HTMLparser.h"
#include "libxml/HTMLtree.h"
#include "oslib/colourtrans.h"
#include "oslib/dragasprite.h"
#include "oslib/osfile.h"
#include "oslib/wimp.h"
#include "oslib/wimpspriteop.h"
#include "netsurf/content/content.h"
#include "netsurf/riscos/gui.h"
#include "netsurf/riscos/theme.h"
#include "netsurf/riscos/tinct.h"
#include "netsurf/riscos/wimp.h"
#include "netsurf/utils/log.h"
#include "netsurf/utils/messages.h"
#include "netsurf/utils/utils.h"
#include "netsurf/utils/url.h"
#define HOTLIST_EXPAND 0
#define HOTLIST_COLLAPSE 1
#define HOTLIST_ENTRY 2
#define HOTLIST_LINE 3
#define HOTLIST_TLINE 4
#define HOTLIST_BLINE 5
#define HOTLIST_TEXT_BUFFER 256
#define HOTLIST_LEAF_INSET 32
#define HOTLIST_ICON_WIDTH 36
#define HOTLIST_LINE_HEIGHT 44
#define HOTLIST_TEXT_PADDING 16
struct hotlist_entry {
/** The next hotlist entry at this level, or NULL for no more
*/
struct hotlist_entry *next_entry;
/** The child hotlist entry (NULL for no children).
The children value must be set for this value to take effect.
*/
struct hotlist_entry *child_entry;
/** The hotlist entry that has this entry as its next entry
*/
struct hotlist_entry *previous_entry;
/** The hotlist entry that this is a child of
*/
struct hotlist_entry *parent_entry;
/** The number of children (-1 for non-folders, >=0 for folders)
*/
int children;
/** The title of the hotlist entry/folder, UTF-8.
*/
char *title;
/** The URL of the hotlist entry (NULL for folders)
*/
char *url;
/** Whether this entry is expanded
*/
bool expanded;
/** Whether this entry is selected
*/
bool selected;
/** The content filetype (not for folders)
*/
int filetype;
/** The number of visits
*/
int visits;
/** Add/last visit dates
*/
time_t add_date;
time_t last_date;
/** Position on last reformat (relative to window origin)
*/
int x0;
int y0;
int width;
int height;
/** Cached values
*/
int collapsed_width;
int expanded_width;
/** The width of the various lines sub-text
*/
int widths[4];
/** Whether the item is awaiting processing
*/
bool process;
};
/* A basic window for the toolbar and status
*/
static wimp_window hotlist_window_definition = {
{0, 0, 600, 800},
0,
0,
wimp_TOP,
wimp_WINDOW_NEW_FORMAT | wimp_WINDOW_MOVEABLE | wimp_WINDOW_BACK_ICON |
wimp_WINDOW_CLOSE_ICON | wimp_WINDOW_TITLE_ICON |
wimp_WINDOW_TOGGLE_ICON | wimp_WINDOW_SIZE_ICON |
wimp_WINDOW_VSCROLL,
wimp_COLOUR_BLACK,
wimp_COLOUR_LIGHT_GREY,
wimp_COLOUR_LIGHT_GREY,
wimp_COLOUR_WHITE,
wimp_COLOUR_DARK_GREY,
wimp_COLOUR_MID_LIGHT_GREY,
wimp_COLOUR_CREAM,
0,
{0, -800, 16384, 0},
wimp_ICON_TEXT | wimp_ICON_INDIRECTED | wimp_ICON_HCENTRED |
wimp_ICON_VCENTRED,
wimp_BUTTON_DOUBLE_CLICK_DRAG << wimp_ICON_BUTTON_TYPE_SHIFT,
wimpspriteop_AREA,
1,
256,
{""},
0
};
/* An icon to plot text with
*/
static wimp_icon text_icon;
static wimp_icon sprite_icon;
/* Temporary workspace for plotting
*/
static char drag_name[12];
static char icon_name[12];
static char extended_text[HOTLIST_TEXT_BUFFER];
/* Whether a reformat is pending
*/
static bool reformat_pending = false;
static int max_width = 0;
static int max_height = 0;
/* The hotlist window, toolbar and plot origins
*/
wimp_w hotlist_window;
struct toolbar *hotlist_toolbar = NULL;
static int origin_x, origin_y;
/* The current redraw rectangle
*/
static int clip_x0, clip_y0, clip_x1, clip_y1;
/* The root entry
*/
static struct hotlist_entry root;
/* The sprite header addresses for Tinct
*/
static char *sprite[6];
/* The drag buttons
*/
bool dragging;
wimp_mouse_state drag_buttons;
/* Whether the current selection was from a menu click
*/
bool menu_selection = false;
bool menu_open = false;
/* Whether the editing facilities are for add so that we know how
to reset the dialog boxes on a adjust-cancel and the action to
perform on ok.
*/
bool dialog_folder_add = false;
bool dialog_entry_add = false;
bool hotlist_insert = false;
static bool ro_gui_hotlist_initialise_sprite(const char *name, int number);
static bool ro_gui_hotlist_load(void);
static void ro_gui_hotlist_load_file(const char *filename);
static void ro_gui_hotlist_load_directory(xmlNode *ul,
struct hotlist_entry *directory);
static void ro_gui_hotlist_load_entry(xmlNode *li,
struct hotlist_entry *directory);
xmlNode *ro_gui_hotlist_find_element(xmlNode *node, const char *name);
bool ro_gui_hotlist_save_directory(struct hotlist_entry *directory,
xmlNode *node);
bool ro_gui_hotlist_save_entry(struct hotlist_entry *entry,
xmlNode *node);
bool ro_gui_hotlist_save_entry_comment(xmlNode *node,
const char *name, int value);
static void ro_gui_hotlist_link_entry(struct hotlist_entry *link, struct hotlist_entry *entry, bool before);
static void ro_gui_hotlist_delink_entry(struct hotlist_entry *entry);
static void ro_gui_hotlist_delete_entry(struct hotlist_entry *entry, bool siblings);
static void ro_gui_hotlist_visited_update(struct content *content, struct hotlist_entry *entry);
static int ro_gui_hotlist_redraw_tree(struct hotlist_entry *entry, int level, int x0, int y0);
static int ro_gui_hotlist_redraw_item(struct hotlist_entry *entry, int level, int x0, int y0);
static struct hotlist_entry *ro_gui_hotlist_create_entry(const char *title, const char *url,
int filetype, struct hotlist_entry *folder);
static void ro_gui_hotlist_update_entry_size(struct hotlist_entry *entry);
static struct hotlist_entry *ro_gui_hotlist_find_entry(int x, int y, struct hotlist_entry *entry);
static int ro_gui_hotlist_selection_state(struct hotlist_entry *entry, bool selected, bool redraw);
static void ro_gui_hotlist_selection_drag(struct hotlist_entry *entry,
int x0, int y0, int x1, int y1,
bool toggle, bool redraw);
static int ro_gui_hotlist_selection_count(struct hotlist_entry *entry, bool folders);
static void ro_gui_hotlist_update_expansion(struct hotlist_entry *entry, bool only_selected,
bool folders, bool links, bool expand, bool contract);
static void ro_gui_hotlist_launch_selection(struct hotlist_entry *entry);
static void ro_gui_hotlist_invalidate_statistics(struct hotlist_entry *entry);
static struct hotlist_entry *ro_gui_hotlist_first_selection(struct hotlist_entry *entry);
static void ro_gui_hotlist_selection_to_process(struct hotlist_entry *entry);
static bool ro_gui_hotlist_move_processing(struct hotlist_entry *entry, struct hotlist_entry *destination, bool before);
#define hotlist_ensure_sprite(buffer, fallback) if (xwimpspriteop_read_sprite_info(buffer, 0, 0, 0, 0)) sprintf(buffer, fallback)
#define hotlist_redraw_entry(entry, full) xwimp_force_redraw(hotlist_window, full ? 0 : entry->x0, \
full ? -16384 : entry->y0, full ? 16384 : entry->x0 + entry->expanded_width, entry->y0 + entry->height);
#define hotlist_redraw_entry_title(entry) xwimp_force_redraw(hotlist_window, entry->x0, \
entry->y0 + entry->height - HOTLIST_LINE_HEIGHT, entry->x0 + entry->width, entry->y0 + entry->height);
void ro_gui_hotlist_init(void) {
const char *title;
os_box extent = {0, 0, 0, 0};
os_error *error;
/* Set the initial root options
*/
root.next_entry = NULL;
root.child_entry = NULL;
root.children = 0;
root.expanded = true;
/* Load the hotlist
*/
if (!ro_gui_hotlist_load()) return;
/* Get our sprite ids for faster plotting.
*/
if (ro_gui_hotlist_initialise_sprite("expand", HOTLIST_EXPAND) ||
ro_gui_hotlist_initialise_sprite("collapse", HOTLIST_COLLAPSE) ||
ro_gui_hotlist_initialise_sprite("entry", HOTLIST_ENTRY) ||
ro_gui_hotlist_initialise_sprite("line", HOTLIST_LINE) ||
ro_gui_hotlist_initialise_sprite("halflinet", HOTLIST_TLINE) ||
ro_gui_hotlist_initialise_sprite("halflineb", HOTLIST_BLINE)) {
return;
}
/* Update our text icon
*/
text_icon.data.indirected_text.validation = (char *) -1;
text_icon.data.indirected_text.size = 256;
sprite_icon.flags = wimp_ICON_SPRITE | wimp_ICON_INDIRECTED |
wimp_ICON_HCENTRED | wimp_ICON_VCENTRED |
(wimp_COLOUR_BLACK << wimp_ICON_FG_COLOUR_SHIFT) |
(wimp_COLOUR_VERY_LIGHT_GREY << wimp_ICON_BG_COLOUR_SHIFT);
sprite_icon.data.indirected_sprite.area = wimpspriteop_AREA;
sprite_icon.data.indirected_text.size = 12;
/* Create our window
*/
title = messages_get("Hotlist");
hotlist_window_definition.title_data.indirected_text.text = title;
hotlist_window_definition.title_data.indirected_text.validation =
(char *) -1;
hotlist_window_definition.title_data.indirected_text.size = strlen(title);
error = xwimp_create_window(&hotlist_window_definition, &hotlist_window);
if (error) {
LOG(("xwimp_create_window: 0x%x: %s",
error->errnum, error->errmess));
die(error->errmess);
}
/* Create our toolbar
*/
hotlist_toolbar = ro_gui_theme_create_toolbar(NULL, THEME_HOTLIST_TOOLBAR);
ro_gui_theme_attach_toolbar(hotlist_toolbar, hotlist_window);
/* Update the extent
*/
if (hotlist_toolbar) {
extent.x1 = 16384;
extent.y1 = hotlist_toolbar->height;
extent.y0 = -16384;
error = xwimp_set_extent(hotlist_window, &extent);
if (error) {
LOG(("xwimp_set_extent: 0x%x: %s",
error->errnum, error->errmess));
die(error->errmess);
}
reformat_pending = true;
}
}
/**
* Initialise a hotlist sprite for use with Tinct
*
* \param name the name of the sprite
* \param number the sprite cache number
* \return whether an error occurred
*/
bool ro_gui_hotlist_initialise_sprite(const char *name, int number) {
os_error *error;
sprintf(icon_name, "tr_%s", name);
error = xosspriteop_select_sprite(osspriteop_USER_AREA, gui_sprites,
(osspriteop_id)icon_name,
(osspriteop_header **)&sprite[number]);
if (error) {
warn_user("MiscError", error->errmess);
LOG(("Failed to load hotlist sprite 'tr_%s'", name));
return true;
}
return false;
}
/**
* Shows the hotlist window.
*/
void ro_gui_hotlist_show(void) {
os_error *error;
int screen_width, screen_height;
wimp_window_state state;
int dimension;
int scroll_width;
/* We may have failed to initialise
*/
if (!hotlist_window) return;
/* Get the window state
*/
state.w = hotlist_window;
error = xwimp_get_window_state(&state);
if (error) {
warn_user("WimpError", error->errmess);
return;
}
/* If we're open we jump to the top of the stack, if not then we
open in the centre of the screen.
*/
if (!(state.flags & wimp_WINDOW_OPEN)) {
/* Clear the selection/expansion states
*/
ro_gui_hotlist_update_expansion(root.child_entry, false, true, true, false, true);
ro_gui_hotlist_selection_state(root.child_entry, false, false);
/* Get the current screen size
*/
ro_gui_screen_size(&screen_width, &screen_height);
/* Move to the centre
*/
dimension = state.visible.x1 - state.visible.x0;
scroll_width = ro_get_vscroll_width(hotlist_window);
state.visible.x0 = (screen_width - (dimension + scroll_width)) / 2;
state.visible.x1 = state.visible.x0 + dimension;
dimension = state.visible.y1 - state.visible.y0;
state.visible.y0 = (screen_height - dimension) / 2;
state.visible.y1 = state.visible.y0 + dimension;
state.xscroll = 0;
state.yscroll = 0;
if (hotlist_toolbar) state.yscroll = hotlist_toolbar->height;
}
/* Open the window at the top of the stack
*/
ro_gui_menu_prepare_hotlist();
state.next = wimp_TOP;
error = xwimp_open_window((wimp_open*)&state);
if (error) {
warn_user("WimpError", error->errmess);
return;
}
/* Set the caret position
*/
xwimp_set_caret_position(state.w, -1, -100,
-100, 32, -1);
}
bool ro_gui_hotlist_load(void) {
fileswitch_object_type obj_type = 0;
struct hotlist_entry *netsurf;
struct hotlist_entry *entry;
/* Check if we have an initial hotlist. OS_File does funny things relating to errors,
so we use the object type to determine success
*/
xosfile_read_stamped_no_path("Choices:WWW.NetSurf.Hotlist", &obj_type,
(bits)0, (bits)0, (int *)0, (fileswitch_attr)0, (bits)0);
if (obj_type == fileswitch_IS_FILE) {
ro_gui_hotlist_load_file("Choices:WWW.NetSurf.Hotlist");
return true;
} else {
/* Create a folder
*/
netsurf = ro_gui_hotlist_create_entry("NetSurf", NULL, 0, &root);
if (!netsurf)
return false;
/* Add some content
*/
entry = ro_gui_hotlist_create_entry("NetSurf homepage",
"http://netsurf.sourceforge.net/",
0xfaf, netsurf);
if (!entry)
return false;
entry->add_date = (time_t) -1;
entry = ro_gui_hotlist_create_entry("NetSurf test builds",
"http://netsurf.strcprstskrzkrk.co.uk/",
0xfaf, netsurf);
if (!entry)
return false;
entry->add_date = (time_t) -1;
/* We succeeded
*/
return true;
}
}
/**
* Load the hotlist from file.
*
* \param filename name of file to read
*/
void ro_gui_hotlist_load_file(const char *filename)
{
xmlDoc *doc;
xmlNode *html, *body, *ul;
doc = htmlParseFile(filename, "iso-8859-1");
if (!doc) {
warn_user("HotlistLoadError", messages_get("ParsingFail"));
return;
}
html = ro_gui_hotlist_find_element((xmlNode *) doc, "html");
body = ro_gui_hotlist_find_element(html, "body");
ul = ro_gui_hotlist_find_element(body, "ul");
if (!ul) {
xmlFreeDoc(doc);
warn_user("HotlistLoadError",
"(<html>...<body>...<ul> not found.)");
return;
}
ro_gui_hotlist_load_directory(ul, &root);
xmlFreeDoc(doc);
}
/**
* Parse a directory represented as a ul.
*
* \param ul xmlNode for parsed ul
* \param directory directory to add this directory to
*/
void ro_gui_hotlist_load_directory(xmlNode *ul,
struct hotlist_entry *directory)
{
char *title;
struct hotlist_entry *dir;
xmlNode *n;
for (n = ul->children; n; n = n->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 (n->type != XML_ELEMENT_NODE)
continue;
if (strcmp(n->name, "li") == 0) {
/* entry */
ro_gui_hotlist_load_entry(n, directory);
} else if (strcmp(n->name, "h4") == 0) {
/* directory */
title = (char *) xmlNodeGetContent(n);
if (!title) {
warn_user("HotlistLoadError", "(Empty <h4> "
"or memory exhausted.)");
return;
}
for (n = n->next;
n && n->type != XML_ELEMENT_NODE;
n = n->next)
;
if (!n || strcmp(n->name, "ul") != 0) {
/* next element isn't expected ul */
free(title);
warn_user("HotlistLoadError", "(Expected "
"<ul> not present.)");
return;
}
dir = ro_gui_hotlist_create_entry(title, NULL, 0,
directory);
if (!dir)
return;
ro_gui_hotlist_load_directory(n, dir);
}
}
}
/**
* Parse an entry represented as a li.
*
* \param li xmlNode for parsed li
* \param directory directory to add this entry to
*/
void ro_gui_hotlist_load_entry(xmlNode *li,
struct hotlist_entry *directory)
{
char *url = 0;
char *title = 0;
int filetype = 0xfaf;
int add_date = -1;
int last_date = -1;
int visits = 0;
char *comment;
struct hotlist_entry *entry;
xmlNode *n;
for (n = li->children; n; n = n->next) {
/* The li must contain an "a" element, and may contain
* some additional data as comments. */
if (n->type == XML_ELEMENT_NODE &&
strcmp(n->name, "a") == 0) {
url = (char *) xmlGetProp(n, (const xmlChar *) "href");
title = (char *) xmlNodeGetContent(n);
} else if (n->type == XML_COMMENT_NODE) {
comment = (char *) xmlNodeGetContent(n);
if (!comment)
continue;
if (strncmp("Type:", comment, 5) == 0)
filetype = atoi(comment + 5);
else if (strncmp("Added:", comment, 6) == 0)
add_date = atoi(comment + 6);
else if (strncmp("LastVisit:", comment, 10) == 0)
last_date = atoi(comment + 10);
else if (strncmp("Visits:", comment, 7) == 0)
visits = atoi(comment + 7);
}
}
if (!url || !title) {
warn_user("HotlistLoadError", "(Missing <a> in <li> or "
"memory exhausted.)");
return;
}
entry = ro_gui_hotlist_create_entry(title, url, filetype, directory);
if (!entry)
return;
entry->add_date = add_date;
entry->last_date = last_date;
entry->visits = visits;
}
/**
* Search the children of an xmlNode for an element.
*
* \param node xmlNode to search children of, or 0
* \param name name of element to find
* \return first child of node which is an element and matches name, or
* 0 if not found or parameter node is 0
*/
xmlNode *ro_gui_hotlist_find_element(xmlNode *node, const char *name)
{
xmlNode *n;
if (!node)
return 0;
for (n = node->children;
n && !(n->type == XML_ELEMENT_NODE &&
strcmp(n->name, name) == 0);
n = n->next)
;
return n;
}
/**
* Perform a save to the default file
*/
void ro_gui_hotlist_save(void) {
/* Don't save if we didn't load
*/
if (!hotlist_window) return;
/* Ensure we have a directory to save to later.
*/
xosfile_create_dir("<Choices$Write>.WWW", 0);
xosfile_create_dir("<Choices$Write>.WWW.NetSurf", 0);
/* Save to our file
*/
ro_gui_hotlist_save_as("<Choices$Write>.WWW.NetSurf.Hotlist");
}
/**
* Perform a save to a specified file
*
* /param filename the file to save to
*/
void ro_gui_hotlist_save_as(const char *filename)
{
int res;
xmlDoc *doc;
xmlNode *html, *head, *title, *body;
/* Unfortunately the Browse Hotlist format is invalid HTML,
* so this is a lie. */
doc = htmlNewDoc("http://www.w3.org/TR/html4/strict.dtd",
"-//W3C//DTD HTML 4.01//EN");
if (!doc) {
warn_user("NoMemory", 0);
return;
}
html = xmlNewNode(NULL, "html");
if (!html) {
warn_user("NoMemory", 0);
xmlFreeDoc(doc);
return;
}
xmlDocSetRootElement(doc, html);
head = xmlNewChild(html, NULL, "head", NULL);
if (!head) {
warn_user("NoMemory", 0);
xmlFreeDoc(doc);
return;
}
title = xmlNewTextChild(head, NULL, "title", "NetSurf Hotlist");
if (!title) {
warn_user("NoMemory", 0);
xmlFreeDoc(doc);
return;
}
body = xmlNewChild(html, NULL, "body", NULL);
if (!body) {
warn_user("NoMemory", 0);
xmlFreeDoc(doc);
return;
}
if (!ro_gui_hotlist_save_directory(&root, body)) {
warn_user("NoMemory", 0);
xmlFreeDoc(doc);
return;
}
doc->charset = XML_CHAR_ENCODING_UTF8;
res = htmlSaveFileEnc(filename, doc, "iso-8859-1");
if (res == -1) {
warn_user("HotlistSaveError", 0);
xmlFreeDoc(doc);
return;
}
xmlFreeDoc(doc);
xosfile_set_type(filename, 0xfaf);
}
/**
* Add a directory to the HTML tree for saving.
*
* \param directory hotlist directory to add
* \param node node to add ul to
* \return true on success, false on memory exhaustion
*/
bool ro_gui_hotlist_save_directory(struct hotlist_entry *directory,
xmlNode *node)
{
struct hotlist_entry *child;
xmlNode *ul, *h4;
ul = xmlNewChild(node, NULL, "ul", NULL);
if (!ul)
return false;
for (child = directory->child_entry; child; child = child->next_entry) {
if (child->url) {
/* entry */
if (!ro_gui_hotlist_save_entry(child, ul))
return false;
} else {
/* directory */
/* invalid HTML */
h4 = xmlNewTextChild(ul, NULL, "h4", child->title);
if (!h4)
return false;
if (!ro_gui_hotlist_save_directory(child, ul))
return false;
}
}
return true;
}
/**
* Add an entry to the HTML tree for saving.
*
* \param entry hotlist entry to add
* \param node node to add li to
* \return true on success, false on memory exhaustion
*/
bool ro_gui_hotlist_save_entry(struct hotlist_entry *entry,
xmlNode *node)
{
xmlNode *li, *a;
xmlAttr *href;
li = xmlNewChild(node, NULL, "li", NULL);
if (!li)
return false;
a = xmlNewTextChild(li, NULL, "a", entry->title);
if (!a)
return false;
href = xmlNewProp(a, "href", entry->url);
if (!href)
return false;
if (entry->filetype != 0xfaf)
if (!ro_gui_hotlist_save_entry_comment(li,
"Type", entry->filetype))
return false;
if (entry->add_date != -1)
if (!ro_gui_hotlist_save_entry_comment(li,
"Added", entry->add_date))
return false;
if (entry->last_date != -1)
if (!ro_gui_hotlist_save_entry_comment(li,
"LastVisit", entry->last_date))
return false;
if (entry->visits != 0)
if (!ro_gui_hotlist_save_entry_comment(li,
"Visits", entry->visits))
return false;
return true;
}
/**
* Add a special comment node to the HTML tree for saving.
*
* \param node node to add comment to
* \param name name of special comment
* \param value value of special comment
* \return true on success, false on memory exhaustion
*/
bool ro_gui_hotlist_save_entry_comment(xmlNode *node,
const char *name, int value)
{
char s[40];
xmlNode *comment;
snprintf(s, sizeof s, "%s:%i", name, value);
s[sizeof s - 1] = 0;
comment = xmlNewComment(s);
if (!comment)
return false;
if (!xmlAddChild(node, comment)) {
xmlFreeNode(comment);
return false;
}
return true;
}
/**
* Adds a hotlist entry to the root of the tree.
*
* \param title the entry title
* \param content the content to add
*/
void ro_gui_hotlist_add(char *title, struct content *content) {
ro_gui_hotlist_create_entry(title, content->url, ro_content_filetype(content), &root);
}
/**
* Informs the hotlist that some content has been visited
*
* \param content the content visited
*/
void hotlist_visited(struct content *content) {
if ((!content) || (!content->url)) return;
ro_gui_hotlist_visited_update(content, root.child_entry);
}
/**
* Informs the hotlist that some content has been visited (internal)
*
* \param content the content visited
* \param entry the entry to check siblings and children of
*/
void ro_gui_hotlist_visited_update(struct content *content, struct hotlist_entry *entry) {
char *url;
bool full = false;
/* Update the hotlist
*/
url = content->url;
while (entry) {
if ((entry->url) && (strcmp(url, entry->url) == 0)) {
/* Check if we're going to need a full redraw downwards
*/
full = ((entry->visits == 0) || (entry->last_date == -1));
/* Update our values
*/
if (entry->children == -1) entry->filetype = ro_content_filetype(content);
entry->visits++;
entry->last_date = time(NULL);
ro_gui_hotlist_update_entry_size(entry);
/* Redraw the least we can get away with
*/
if (entry->expanded) hotlist_redraw_entry(entry, full);
}
if (entry->child_entry) ro_gui_hotlist_visited_update(content, entry->child_entry);
entry = entry->next_entry;
}
}
/**
* Adds a hotlist entry to a folder of the tree.
*
* \param title the entry title (copied)
* \param url the entry url (NULL to create a folder) (copied)
* \param filetype filetype of entry
* \param folder the folder to add the entry into
* \return the new entry, or NULL on error and error reported
*/
struct hotlist_entry *ro_gui_hotlist_create_entry(const char *title,
const char *url, int filetype,
struct hotlist_entry *folder) {
struct hotlist_entry *entry;
url_func_result res;
/* Check we have a title or a URL
*/
if (!title && !url) return NULL;
/* Allocate some memory
*/
entry = (struct hotlist_entry *)calloc(1, sizeof(struct hotlist_entry));
if (!entry) {
warn_user("NoMemory", 0);
return NULL;
}
/* Normalise the URL and add the title if we have one, or
use the URL instead
*/
entry->url = 0;
if ((url) && ((res = url_normalize(url, &entry->url)) != URL_FUNC_OK)) {
/** \todo use correct error message */
warn_user("NoMemory", 0);
free(entry->url);
free(entry);
return NULL;
}
if (title) {
entry->title = strdup(title);
if (!entry->title) {
warn_user("NoMemory", 0);
free(entry->url);
free(entry);
return NULL;
}
entry->title = strip(entry->title);
} else {
entry->title = strdup(entry->url);
if (!entry->title) {
warn_user("NoMemory", 0);
free(entry->url);
free(entry);
return NULL;
}
}
/* Set the other values
*/
entry->children = (url == NULL) ? 0 : -1;
entry->filetype = filetype;
entry->visits = 0;
entry->add_date = time(NULL);
entry->last_date = (time_t)-1;
ro_gui_hotlist_update_entry_size(entry);
/* Link into the tree
*/
ro_gui_hotlist_link_entry(folder, entry, false);
return entry;
}
/**
* Links a hotlist entry into the tree.
*
* \param link the entry to link as a child (folders) or before/after (link)
* \param entry the entry to link
* \param before whether to link siblings before or after the supplied link
*/
void ro_gui_hotlist_link_entry(struct hotlist_entry *link, struct hotlist_entry *entry, bool before) {
struct hotlist_entry *link_entry;
if ((!link || !entry) || (link == entry)) return;
/* Check if the parent is a folder or an entry
*/
if (link->children == -1) {
entry->parent_entry = link->parent_entry;
entry->parent_entry->children++;
if (before) {
entry->next_entry = link;
entry->previous_entry = link->previous_entry;
if (link->previous_entry) link->previous_entry->next_entry = entry;
link->previous_entry = entry;
if (link->parent_entry) {
if (link->parent_entry->child_entry == link) {
link->parent_entry->child_entry = entry;
}
}
} else {
entry->previous_entry = link;
entry->next_entry = link->next_entry;
if (link->next_entry) link->next_entry->previous_entry = entry;
link->next_entry = entry;
}
} else {
link_entry = link->child_entry;
/* Link into the tree as a child at the end
*/
if (!link_entry) {
link->child_entry = entry;
entry->previous_entry = NULL;
} else {
while (link_entry->next_entry) link_entry = link_entry->next_entry;
link_entry->next_entry = entry;
entry->previous_entry = link_entry;
}
/* Update the links
*/
entry->parent_entry = link;
entry->next_entry = NULL;
/* Increment the number of children
*/
link->children += 1;
}
/* Force a redraw
*/
reformat_pending = true;
xwimp_force_redraw(hotlist_window, 0, -16384, 16384, 0);
}
/**
* De-links a hotlist entry from the tree.
*
* \param entry the entry to de-link
*/
void ro_gui_hotlist_delink_entry(struct hotlist_entry *entry) {
if (!entry) return;
/* Sort out if the entry was the initial child reference
*/
if (entry->parent_entry) {
entry->parent_entry->children -= 1;
if (entry->parent_entry->children == 0) entry->parent_entry->expanded = false;
if (entry->parent_entry->child_entry == entry) {
entry->parent_entry->child_entry = entry->next_entry;
}
entry->parent_entry = NULL;
}
/* Remove the entry from siblings
*/
if (entry->previous_entry) {
entry->previous_entry->next_entry = entry->next_entry;
}
if (entry->next_entry) {
entry->next_entry->previous_entry = entry->previous_entry;
}
entry->previous_entry = NULL;
entry->next_entry = NULL;
/* Force a redraw
*/
reformat_pending = true;
xwimp_force_redraw(hotlist_window, 0, -16384, 16384, 0);
}
/**
* Delete an entry and all children
* This function also performs any necessary delinking
*
* \param entry the entry to delete
* \param siblings delete all following siblings
*/
void ro_gui_hotlist_delete_entry(struct hotlist_entry *entry, bool siblings) {
struct hotlist_entry *next_entry = NULL;
while (entry) {
/* Recurse to children first
*/
if (entry->child_entry) ro_gui_hotlist_delete_entry(entry->child_entry, true);
/* Free our memory
*/
free(entry->url);
free(entry->title);
/* Get the next entry before we de-link and delete
*/
if (siblings) next_entry = entry->next_entry;
/* Delink and delete our entry and move on
*/
ro_gui_hotlist_delink_entry(entry);
free(entry);
entry = next_entry;
}
}
/**
* Updates and entrys size
*/
void ro_gui_hotlist_update_entry_size(struct hotlist_entry *entry) {
int width;
int max_width;
int line_number = 0;
/* Get the width of the title
*/
xwimptextop_string_width(entry->title,
strlen(entry->title) > 256 ? 256 : strlen(entry->title),
&width);
entry->collapsed_width = width;
max_width = width;
/* Get the width of the URL
*/
if (entry->url) {
snprintf(extended_text, HOTLIST_TEXT_BUFFER,
messages_get("HotlistURL"), entry->url);
if (strlen(extended_text) >= 255) {
extended_text[252] = '.';
extended_text[253] = '.';
extended_text[254] = '.';
extended_text[255] = '\0';
}
xwimptextop_string_width(extended_text,
strlen(extended_text) > 256 ? 256 : strlen(extended_text),
&width);
if (width > max_width) max_width = width;
entry->widths[line_number++] = width;
}
/* Get the width of the add date
*/
if (entry->add_date != -1) {
snprintf(extended_text, HOTLIST_TEXT_BUFFER,
messages_get("HotlistAdded"), ctime(&entry->add_date));
xwimptextop_string_width(extended_text,
strlen(extended_text) > 256 ? 256 : strlen(extended_text),
&width);
if (width > max_width) max_width = width;
entry->widths[line_number++] = width;
}
/* Get the width of the last visit
*/
if (entry->last_date != -1) {
snprintf(extended_text, HOTLIST_TEXT_BUFFER,
messages_get("HotlistLast"), ctime(&entry->last_date));
xwimptextop_string_width(extended_text,
strlen(extended_text) > 256 ? 256 : strlen(extended_text),
&width);
if (width > max_width) max_width = width;
entry->widths[line_number++] = width;
}
/* Get the width of the visit count
*/
if (entry->visits > 0) {
snprintf(extended_text, HOTLIST_TEXT_BUFFER,
messages_get("HotlistVisits"), entry->visits);
xwimptextop_string_width(extended_text,
strlen(extended_text) > 256 ? 256 : strlen(extended_text),
&width);
if (width > max_width) max_width = width;
entry->widths[line_number++] = width;
}
/* Increase the text width by the borders
*/
entry->expanded_width = max_width + HOTLIST_LEAF_INSET + HOTLIST_ICON_WIDTH + HOTLIST_TEXT_PADDING;
entry->collapsed_width += HOTLIST_LEAF_INSET + HOTLIST_ICON_WIDTH + HOTLIST_TEXT_PADDING;
reformat_pending = true;
}
/**
* Redraws a section of the hotlist window
*
* \param redraw the area to redraw
*/
void ro_gui_hotlist_redraw(wimp_draw *redraw) {
wimp_window_state state;
osbool more;
os_box extent = {0, 0, 0, 0};;
/* Reset our min/max sizes
*/
max_width = 0;
max_height = 0;
/* Redraw each rectangle
*/
more = wimp_redraw_window(redraw);
while (more) {
clip_x0 = redraw->clip.x0;
clip_y0 = redraw->clip.y0;
clip_x1 = redraw->clip.x1;
clip_y1 = redraw->clip.y1;
origin_x = redraw->box.x0 - redraw->xscroll;
origin_y = redraw->box.y1 - redraw->yscroll;
ro_gui_hotlist_redraw_tree(root.child_entry, 0,
origin_x + 8, origin_y - 4);
more = wimp_get_rectangle(redraw);
}
/* Check if we should reformat
*/
if (reformat_pending) {
max_width += 8;
max_height -= 4;
if (max_width < 600) max_width = 600;
if (max_height > -800) max_height = -800;
extent.x1 = max_width;
extent.y0 = max_height;
if (hotlist_toolbar) {
extent.y1 += hotlist_toolbar->height;
}
xwimp_set_extent(hotlist_window, &extent);
state.w = hotlist_window;
wimp_get_window_state(&state);
wimp_open_window((wimp_open *) &state);
reformat_pending = false;
}
}
/**
* Redraws a section of the hotlist window (non-WIMP interface)
*
* \param entry the entry to draw descendants and siblings of
* \param level the tree level of the entry
* \param x0 the x co-ordinate to plot from
* \param y0 the y co-ordinate to plot from
* \returns the height of the tree
*/
int ro_gui_hotlist_redraw_tree(struct hotlist_entry *entry, int level, int x0, int y0) {
bool first = true;
int cumulative = 0;
int height = 0;
int box_y0;
if (!entry) return 0;
/* Repeatedly draw our entries
*/
while (entry) {
/* Redraw the item
*/
height = ro_gui_hotlist_redraw_item(entry, level, x0 + HOTLIST_LEAF_INSET, y0);
box_y0 = y0;
cumulative += height;
/* Update the entry position
*/
if (entry->children == -1) {
entry->height = height;
} else {
entry->height = HOTLIST_LINE_HEIGHT;
}
entry->x0 = x0 - origin_x;
entry->y0 = y0 - origin_y - entry->height;
if (entry->expanded) {
entry->width = entry->expanded_width;
} else {
entry->width = entry->collapsed_width;
}
/* Get the maximum extents
*/
if ((x0 + entry->width) > (max_width + origin_x))
max_width = x0 + entry->width - origin_x;
if ((y0 - height) < (max_height + origin_y))
max_height = y0 - height - origin_y;
/* Draw the vertical links
*/
if (entry->next_entry) {
/* Draw a half-line for the first entry in the top tree
*/
if (first && (level == 0)) {
_swix(Tinct_Plot, _IN(2) | _IN(3) | _IN(4) | _IN(7),
sprite[HOTLIST_BLINE], x0 + 8, y0 - HOTLIST_LINE_HEIGHT,
tinct_BILINEAR_FILTER);
y0 -= HOTLIST_LINE_HEIGHT;
height -= HOTLIST_LINE_HEIGHT;
}
/* Draw the rest of the lines
*/
while (height > 0) {
_swix(Tinct_Plot, _IN(2) | _IN(3) | _IN(4) | _IN(7),
sprite[HOTLIST_LINE], x0 + 8, y0 - HOTLIST_LINE_HEIGHT,
tinct_BILINEAR_FILTER);
y0 -= HOTLIST_LINE_HEIGHT;
height -= HOTLIST_LINE_HEIGHT;
}
} else {
/* Draw a half-line for the last entry
*/
if (!first || (level != 0)) {
_swix(Tinct_Plot, _IN(2) | _IN(3) | _IN(4) | _IN(7),
sprite[HOTLIST_TLINE], x0 + 8, y0 - 22,
tinct_BILINEAR_FILTER);
height -= HOTLIST_LINE_HEIGHT;
y0 -= HOTLIST_LINE_HEIGHT;
}
}
/* Draw the expansion type
*/
if (entry->children == 0) {
_swix(Tinct_Plot, _IN(2) | _IN(3) | _IN(4) | _IN(7),
sprite[HOTLIST_ENTRY], x0, box_y0 - 23,
tinct_BILINEAR_FILTER);
} else {
if (entry->expanded) {
_swix(Tinct_Plot, _IN(2) | _IN(3) | _IN(4) | _IN(7),
sprite[HOTLIST_COLLAPSE], x0, box_y0 - 31,
tinct_BILINEAR_FILTER);
} else {
_swix(Tinct_Plot, _IN(2) | _IN(3) | _IN(4) | _IN(7),
sprite[HOTLIST_EXPAND], x0, box_y0 - 31,
tinct_BILINEAR_FILTER);
}
}
/* Move to the next entry
*/
entry = entry->next_entry;
first = false;
}
/* Return our height
*/
return cumulative;
}
/**
* Redraws an entry in the tree and any children
*
* \param entry the entry to redraw
* \param level the level of the entry
* \param x0 the x co-ordinate to plot at
* \param y0 the y co-ordinate to plot at
* \return the height of the entry
*/
int ro_gui_hotlist_redraw_item(struct hotlist_entry *entry, int level, int x0, int y0) {
int height = HOTLIST_LINE_HEIGHT;
int line_y0;
int line_height;
/* Set the correct height
*/
if ((entry->children == -1) && (entry->expanded)) {
if (entry->url) height += HOTLIST_LINE_HEIGHT;
if (entry->visits > 0) height += HOTLIST_LINE_HEIGHT;
if (entry->add_date != -1) height += HOTLIST_LINE_HEIGHT;
if (entry->last_date != -1) height += HOTLIST_LINE_HEIGHT;
}
/* Check whether we need to redraw
*/
if ((x0 < clip_x1) && (y0 > clip_y0) && ((x0 + entry->width) > clip_x0) &&
((y0 - height) < clip_y1)) {
/* Update the selection state
*/
text_icon.flags = wimp_ICON_TEXT | (wimp_COLOUR_BLACK << wimp_ICON_FG_COLOUR_SHIFT) |
(wimp_COLOUR_VERY_LIGHT_GREY << wimp_ICON_BG_COLOUR_SHIFT) |
wimp_ICON_INDIRECTED | wimp_ICON_VCENTRED;
if (entry->selected) {
sprite_icon.flags |= wimp_ICON_SELECTED;
text_icon.flags |= wimp_ICON_SELECTED;
text_icon.flags |= wimp_ICON_FILLED;
}
/* Draw our icon type
*/
sprite_icon.extent.x0 = x0 - origin_x;
sprite_icon.extent.x1 = x0 - origin_x + HOTLIST_ICON_WIDTH;
sprite_icon.extent.y0 = y0 - origin_y - HOTLIST_LINE_HEIGHT;
sprite_icon.extent.y1 = y0 - origin_y;
sprite_icon.data.indirected_sprite.id = (osspriteop_id)icon_name;
if (entry->children != -1) {
if ((entry->expanded) && (entry->children > 0)) {
sprintf(icon_name, "small_diro");
hotlist_ensure_sprite(icon_name, "small_dir");
} else {
sprintf(icon_name, "small_dir");
}
} else {
/* Get the icon sprite
*/
sprintf(icon_name, "small_%x", entry->filetype);
hotlist_ensure_sprite(icon_name, "small_xxx");
}
xwimp_plot_icon(&sprite_icon);
/* Draw our textual information
*/
text_icon.data.indirected_text.text = entry->title;
text_icon.extent.x0 = x0 - origin_x + HOTLIST_ICON_WIDTH;
text_icon.extent.x1 = x0 - origin_x + entry->collapsed_width - HOTLIST_LEAF_INSET;
text_icon.extent.y0 = y0 - origin_y - HOTLIST_LINE_HEIGHT + 2;
text_icon.extent.y1 = y0 - origin_y - 2;
xwimp_plot_icon(&text_icon);
/* Clear the selection state
*/
if (entry->selected) {
sprite_icon.flags &= ~wimp_ICON_SELECTED;
}
/* Draw our further information if expanded
*/
if ((entry->children == -1) && (entry->expanded) && (height > HOTLIST_LINE_HEIGHT)) {
text_icon.flags = wimp_ICON_TEXT | (wimp_COLOUR_DARK_GREY << wimp_ICON_FG_COLOUR_SHIFT) |
wimp_ICON_INDIRECTED | wimp_ICON_VCENTRED;
text_icon.extent.y0 = y0 - origin_y - HOTLIST_LINE_HEIGHT;
text_icon.extent.y1 = y0 - origin_y;
/* Draw the lines
*/
y0 -= HOTLIST_LINE_HEIGHT;
line_y0 = y0;
line_height = height - HOTLIST_LINE_HEIGHT;
while (line_height > 0) {
if (line_height == HOTLIST_LINE_HEIGHT) {
_swix(Tinct_Plot, _IN(2) | _IN(3) | _IN(4) | _IN(7),
sprite[HOTLIST_TLINE], x0 + 16, line_y0 - 22,
tinct_BILINEAR_FILTER);
} else {
_swix(Tinct_Plot, _IN(2) | _IN(3) | _IN(4) | _IN(7),
sprite[HOTLIST_LINE], x0 + 16, line_y0 - HOTLIST_LINE_HEIGHT,
tinct_BILINEAR_FILTER);
}
_swix(Tinct_Plot, _IN(2) | _IN(3) | _IN(4) | _IN(7),
sprite[HOTLIST_ENTRY], x0 + 8, line_y0 - 23,
tinct_BILINEAR_FILTER);
line_height -= HOTLIST_LINE_HEIGHT;
line_y0 -= HOTLIST_LINE_HEIGHT;
}
/* Set the right extent of the icon to be big enough for anything
*/
text_icon.extent.x1 = x0 - origin_x + 4096;
/* Plot the URL text
*/
text_icon.data.indirected_text.text = extended_text;
if (entry->url) {
snprintf(extended_text, HOTLIST_TEXT_BUFFER,
messages_get("HotlistURL"), entry->url);
if (strlen(extended_text) >= 255) {
extended_text[252] = '.';
extended_text[253] = '.';
extended_text[254] = '.';
extended_text[255] = '\0';
}
text_icon.extent.y0 -= HOTLIST_LINE_HEIGHT;
text_icon.extent.y1 -= HOTLIST_LINE_HEIGHT;
xwimp_plot_icon(&text_icon);
}
/* Plot the date added text
*/
if (entry->add_date != -1) {
snprintf(extended_text, HOTLIST_TEXT_BUFFER,
messages_get("HotlistAdded"), ctime(&entry->add_date));
text_icon.extent.y0 -= HOTLIST_LINE_HEIGHT;
text_icon.extent.y1 -= HOTLIST_LINE_HEIGHT;
xwimp_plot_icon(&text_icon);
}
/* Plot the last visited text
*/
if (entry->last_date != -1) {
snprintf(extended_text, HOTLIST_TEXT_BUFFER,
messages_get("HotlistLast"), ctime(&entry->last_date));
text_icon.extent.y0 -= HOTLIST_LINE_HEIGHT;
text_icon.extent.y1 -= HOTLIST_LINE_HEIGHT;
xwimp_plot_icon(&text_icon);
}
/* Plot the visit count text
*/
if (entry->visits > 0) {
snprintf(extended_text, HOTLIST_TEXT_BUFFER,
messages_get("HotlistVisits"), entry->visits);
text_icon.extent.y0 -= HOTLIST_LINE_HEIGHT;
text_icon.extent.y1 -= HOTLIST_LINE_HEIGHT;
xwimp_plot_icon(&text_icon);
}
}
}
/* Draw any children
*/
if ((entry->child_entry) && (entry->expanded)) {
height += ro_gui_hotlist_redraw_tree(entry->child_entry, level + 1,
x0 + 8, y0 - HOTLIST_LINE_HEIGHT);
}
return height;
}
/**
* Respond to a mouse click
*
* /param pointer the pointer state
*/
void ro_gui_hotlist_click(wimp_pointer *pointer) {
wimp_caret caret;
wimp_drag drag;
struct hotlist_entry *entry;
wimp_window_state state;
wimp_mouse_state buttons;
int x, y;
int x_offset;
int y_offset;
bool no_entry = false;
os_error *error;
os_box box = { pointer->pos.x - 34, pointer->pos.y - 34,
pointer->pos.x + 34, pointer->pos.y + 34 };
int selection;
/* Get the button state
*/
buttons = pointer->buttons;
/* Get the window state. Quite why the Wimp can't give relative
positions is beyond me.
*/
state.w = hotlist_window;
wimp_get_window_state(&state);
/* Translate by the origin/scroll values
*/
x = (pointer->pos.x - (state.visible.x0 - state.xscroll));
y = (pointer->pos.y - (state.visible.y1 - state.yscroll));
/* We want the caret on a click
*/
error = xwimp_get_caret_position(&caret);
if (error) {
LOG(("xwimp_get_caret_position: 0x%x: %s", error->errnum,
error->errmess));
}
if (((pointer->buttons == (wimp_CLICK_SELECT << 8)) ||
(pointer->buttons == (wimp_CLICK_ADJUST << 8))) &&
(caret.w != state.w)) {
error = xwimp_set_caret_position(state.w, -1, -100,
-100, 32, -1);
if (error) {
LOG(("xwimp_set_caret_position: 0x%x: %s",
error->errnum, error->errmess));
}
}
/* Find our entry
*/
entry = ro_gui_hotlist_find_entry(x, y, root.child_entry);
if (entry) {
/* Check if we clicked on the expanding bit
*/
x_offset = x - entry->x0;
y_offset = y - (entry->y0 + entry->height);
if (((x_offset < HOTLIST_LEAF_INSET) && (y_offset > -HOTLIST_LINE_HEIGHT) &&
((buttons == wimp_CLICK_SELECT << 8) || (buttons == wimp_CLICK_ADJUST << 8) ||
(buttons == wimp_DOUBLE_SELECT) || (buttons == wimp_DOUBLE_ADJUST))) ||
((entry->children != -1) &&
((buttons == wimp_DOUBLE_SELECT) || (buttons == wimp_DOUBLE_ADJUST)))) {
if (entry->children != 0) {
ro_gui_hotlist_update_expansion(entry->child_entry, false, true, true, false, true);
ro_gui_hotlist_selection_state(entry->child_entry,
false, false);
entry->expanded = !entry->expanded;
if (x_offset >= HOTLIST_LEAF_INSET) entry->selected = false;
reformat_pending = true;
hotlist_redraw_entry(entry, true);
ro_gui_menu_prepare_hotlist();
}
} else if (x_offset >= HOTLIST_LEAF_INSET) {
/* We treat a menu click as a Select click if we have no selections
*/
if (buttons == wimp_CLICK_MENU) {
if (ro_gui_hotlist_selection_count(root.child_entry, true) == 0) {
menu_selection = true;
buttons = (wimp_CLICK_SELECT << 8);
}
}
/* Check for selection
*/
if (buttons == (wimp_CLICK_SELECT << 8)) {
if (!entry->selected) {
ro_gui_hotlist_selection_state(root.child_entry,
false, true);
entry->selected = true;
hotlist_redraw_entry_title(entry);
ro_gui_menu_prepare_hotlist();
}
} else if (buttons == (wimp_CLICK_ADJUST << 8)) {
entry->selected = !entry->selected;
hotlist_redraw_entry_title(entry);
ro_gui_menu_prepare_hotlist();
}
/* Check if we should open the URL
*/
if (((buttons == wimp_DOUBLE_SELECT) || (buttons == wimp_DOUBLE_ADJUST)) &&
(entry->children == -1)) {
browser_window_create(entry->url, NULL, 0);
if (buttons == wimp_DOUBLE_SELECT) {
ro_gui_hotlist_selection_state(root.child_entry,
false, true);
ro_gui_menu_prepare_hotlist();
} else {
entry->selected = false;
ro_gui_dialog_close_persistant(hotlist_window);
xwimp_close_window(hotlist_window);
}
}
/* Check if we should start a drag
*/
if ((buttons == (wimp_CLICK_SELECT <<4)) || (buttons == (wimp_CLICK_ADJUST << 4))) {
selection = ro_gui_hotlist_get_selected(true);
if (selection > 0) {
gui_current_drag_type = GUI_DRAG_HOTLIST_MOVE;
if (selection > 1) {
sprintf(drag_name, "package");
} else {
if (entry->children != -1) {
if ((entry->expanded) && (entry->children > 0)) {
sprintf(drag_name, "directoryo");
hotlist_ensure_sprite(drag_name, "directory");
} else {
sprintf(drag_name, "directory");
}
} else {
sprintf(drag_name, "file_%x", entry->filetype);
hotlist_ensure_sprite(drag_name, "file_xxx");
}
}
error = xdragasprite_start(dragasprite_HPOS_CENTRE |
dragasprite_VPOS_CENTRE |
dragasprite_BOUND_POINTER |
dragasprite_DROP_SHADOW,
(osspriteop_area *) 1, drag_name, &box, 0);
dragging = true;
}
}
} else {
if (!((x_offset < HOTLIST_LEAF_INSET) && (y_offset > -HOTLIST_LINE_HEIGHT))) {
no_entry = true;
}
}
} else {
no_entry = true;
}
/* Get the original button state back
*/
buttons = pointer->buttons;
/* Create a menu if we should
*/
if (buttons == wimp_CLICK_MENU) {
ro_gui_create_menu(hotlist_menu, pointer->pos.x,
pointer->pos.y, NULL);
menu_open = true;
return;
}
/* Handle a click without an entry
*/
if (no_entry) {
/* Deselect everything if we click nowhere
*/
if (buttons == (wimp_CLICK_SELECT << 8)) {
ro_gui_hotlist_selection_state(root.child_entry,
false, true);
ro_gui_menu_prepare_hotlist();
}
/* Handle the start of a drag
*/
if (buttons == (wimp_CLICK_SELECT << 4) ||
buttons == (wimp_CLICK_ADJUST << 4)) {
/* Clear the current selection
*/
if (buttons == (wimp_CLICK_SELECT << 4)) {
ro_gui_hotlist_selection_state(root.child_entry,
false, true);
ro_gui_menu_prepare_hotlist();
}
/* Start a drag box
*/
drag_buttons = buttons;
gui_current_drag_type = GUI_DRAG_HOTLIST_SELECT;
drag.w = hotlist_window;
drag.type = wimp_DRAG_USER_RUBBER;
drag.initial.x0 = pointer->pos.x;
drag.initial.x1 = pointer->pos.x;
drag.initial.y0 = pointer->pos.y;
drag.initial.y1 = pointer->pos.y;
drag.bbox.x0 = state.visible.x0;
drag.bbox.x1 = state.visible.x1;
drag.bbox.y0 = state.visible.y0;
drag.bbox.y1 = state.visible.y1;
if (hotlist_toolbar) drag.bbox.y1 -= hotlist_toolbar->height;
xwimp_drag_box(&drag);
dragging = true;
}
}
}
/**
* Find an entry at a particular position
*
* \param x the x co-ordinate
* \param y the y co-ordinate
* \param entry the entry to check down from (root->child_entry for the entire tree)
* /return the entry occupying the positon
*/
struct hotlist_entry *ro_gui_hotlist_find_entry(int x, int y, struct hotlist_entry *entry) {
struct hotlist_entry *find_entry;
int inset_x = 0;
int inset_y = 0;
/* Check we have an entry (only applies if we have an empty hotlist)
*/
if (!entry) return NULL;
/* Get the first child entry
*/
while (entry) {
/* Check if this entry could possibly match
*/
if ((x > entry->x0) && (y > entry->y0) && (x < (entry->x0 + entry->width)) &&
(y < (entry->y0 + entry->height))) {
/* The top line extends all the way left
*/
if (y - (entry->y0 + entry->height) > -HOTLIST_LINE_HEIGHT) {
if (x < (entry->x0 + entry->collapsed_width)) return entry;
return NULL;
}
/* No other entry can occupy the left edge
*/
inset_x = x - entry->x0 - HOTLIST_LEAF_INSET - HOTLIST_ICON_WIDTH;
if (inset_x < 0) return NULL;
/* Check the right edge against our various widths
*/
inset_y = -((y - entry->y0 - entry->height) / HOTLIST_LINE_HEIGHT);
if (inset_x < (entry->widths[inset_y - 1] + HOTLIST_TEXT_PADDING)) return entry;
return NULL;
}
/* Continue onwards
*/
if ((entry->child_entry) && (entry->expanded)) {
find_entry = ro_gui_hotlist_find_entry(x, y, entry->child_entry);
if (find_entry) return find_entry;
}
entry = entry->next_entry;
}
return NULL;
}
/**
* Updated the selection state of the tree
*
* \param entry the entry to update all siblings and descendants of
* \param selected the selection state to set
* \param redraw update the icons in the Wimp
* \return the number of entries that have changed
*/
int ro_gui_hotlist_selection_state(struct hotlist_entry *entry, bool selected, bool redraw) {
int changes = 0;
/* Check we have an entry (only applies if we have an empty hotlist)
*/
if (!entry) return 0;
/* Get the first child entry
*/
while (entry) {
/* Check this entry
*/
if (entry->selected != selected) {
/* Update the selection state
*/
entry->selected = selected;
changes++;
/* Redraw the entrys first line
*/
if (redraw) hotlist_redraw_entry_title(entry);
}
/* Continue onwards
*/
if ((entry->child_entry) && ((!selected) || (entry->expanded))) {
changes += ro_gui_hotlist_selection_state(entry->child_entry,
selected, redraw & (entry->expanded));
}
entry = entry->next_entry;
}
return changes;
}
/**
* Returns the first selected item
*
* \param entry the search siblings and children of
* \return the first selected item
*/
struct hotlist_entry *ro_gui_hotlist_first_selection(struct hotlist_entry *entry) {
struct hotlist_entry *test_entry;
/* Check we have an entry (only applies if we have an empty hotlist)
*/
if (!entry) return NULL;
/* Work through our entries
*/
while (entry) {
if (entry->selected) return entry;
if (entry->child_entry) {
test_entry = ro_gui_hotlist_first_selection(entry->child_entry);
if (test_entry) return test_entry;
}
entry = entry->next_entry;
}
return NULL;
}
/**
* Return the current number of selected items (internal interface)
*
* \param entry the entry to count siblings and children of
*/
int ro_gui_hotlist_selection_count(struct hotlist_entry *entry, bool folders) {
int count = 0;
if (!entry) return 0;
while (entry) {
if ((entry->selected) && (folders || (entry->children == -1))) count++;
if (entry->child_entry) count += ro_gui_hotlist_selection_count(entry->child_entry, folders);
entry = entry->next_entry;
}
return count;
}
/**
* Launch the current selection (internal interface)
*
* \param entry the entry to launch siblings and children of
*/
void ro_gui_hotlist_launch_selection(struct hotlist_entry *entry) {
if (!entry) return;
while (entry) {
if ((entry->selected) && (entry->url)) browser_window_create(entry->url, NULL, 0);
if (entry->child_entry) ro_gui_hotlist_launch_selection(entry->child_entry);
entry = entry->next_entry;
}
}
/**
* Invalidate the statistics for any selected items (internal interface)
*
* \param entry the entry to update siblings and children of
*/
void ro_gui_hotlist_invalidate_statistics(struct hotlist_entry *entry) {
if (!entry) return;
while (entry) {
if ((entry->selected) && (entry->children == -1)) {
entry->visits = 0;
entry->last_date = (time_t)-1;
if (entry->expanded) hotlist_redraw_entry(entry, true);
}
if (entry->child_entry) ro_gui_hotlist_invalidate_statistics(entry->child_entry);
entry = entry->next_entry;
}
}
/**
* Set the process flag for the current selection (internal interface)
*
* \param entry the entry to modify siblings and children of
*/
void ro_gui_hotlist_selection_to_process(struct hotlist_entry *entry) {
if (!entry) return;
while (entry) {
entry->process = entry->selected;
if (entry->child_entry) ro_gui_hotlist_selection_to_process(entry->child_entry);
entry = entry->next_entry;
}
}
/**
* Toggles the expanded state for selected icons
* If neither expand not contract are set then the entries are toggled
*
* \param entry the entry to update all siblings and descendants of
* \param only_selected whether to only update selected icons
* \param folders whether to update folders
* \param links whether to update links
* \param expand force all entries to be expanded (dominant)
* \param contract force all entries to be contracted (recessive)
*/
void ro_gui_hotlist_update_expansion(struct hotlist_entry *entry, bool only_selected,
bool folders, bool links, bool expand, bool contract) {
bool current;
/* Set a reformat to be pending
*/
reformat_pending = true;
/* Check we have an entry (only applies if we have an empty hotlist)
*/
if (!entry) return;
/* Get the first child entry
*/
while (entry) {
/* Check this entry
*/
if ((entry->selected) || (!only_selected)) {
current = entry->expanded;
/* Only update what we should
*/
if (((links) && (entry->children == -1)) || ((folders) && (entry->children > 0))) {
/* Update the expansion state
*/
if (expand) {
entry->expanded = true;
} else if (contract) {
entry->expanded = false;
} else {
entry->expanded = !entry->expanded;
}
}
/* If we have contracted then we de-select and collapse any children
*/
if (entry->child_entry && !entry->expanded) {
ro_gui_hotlist_update_expansion(entry->child_entry, false, true, true, false, true);
ro_gui_hotlist_selection_state(entry->child_entry, false, false);
}
/* Redraw the entrys first line
*/
if (current != entry->expanded) hotlist_redraw_entry(entry, true);
}
/* Continue onwards (child entries cannot be selected if the parent is
not expanded)
*/
if (entry->child_entry && entry->expanded) {
ro_gui_hotlist_update_expansion(entry->child_entry,
only_selected, folders, links, expand, contract);
}
entry = entry->next_entry;
}
}
/**
* Updated the selection state of the tree
*
* \param entry the entry to update all siblings and descendants of
* \param x0 the left edge of the box
* \param y0 the top edge of the box
* \param x1 the right edge of the box
* \param y1 the bottom edge of the box
* \param toggle toggle the selection state, otherwise set
* \param redraw update the icons in the Wimp
*/
void ro_gui_hotlist_selection_drag(struct hotlist_entry *entry,
int x0, int y0, int x1, int y1,
bool toggle, bool redraw) {
bool do_update;
int line;
int test_y;
/* Check we have an entry (only applies if we have an empty hotlist)
*/
if (!entry) return;
/* Get the first child entry
*/
while (entry) {
/* Check if this entry could possibly match
*/
if ((x1 > (entry->x0 + HOTLIST_LEAF_INSET)) && (y0 > entry->y0) &&
(x0 < (entry->x0 + entry->width)) &&
(y1 < (entry->y0 + entry->height))) {
do_update = false;
/* Check the exact area of the title line
*/
if ((x1 > (entry->x0 + HOTLIST_LEAF_INSET)) &&
(y0 > entry->y0 + entry->height - HOTLIST_LINE_HEIGHT) &&
(x0 < (entry->x0 + entry->collapsed_width)) &&
(y1 < (entry->y0 + entry->height))) {
do_update = true;
}
/* Check the other lines
*/
line = 1;
test_y = entry->y0 + entry->height - HOTLIST_LINE_HEIGHT;
while (((line * HOTLIST_LINE_HEIGHT) < entry->height) && (!do_update)) {
/* Check this line
*/
if ((x1 > (entry->x0 + HOTLIST_LEAF_INSET + HOTLIST_ICON_WIDTH)) &&
(y1 < test_y) && (y0 > test_y - HOTLIST_LINE_HEIGHT) &&
(x0 < (entry->x0 + entry->widths[line - 1] +
HOTLIST_LEAF_INSET + HOTLIST_ICON_WIDTH +
HOTLIST_TEXT_PADDING))) {
do_update = true;
}
/* Move to the next line
*/
line++;
test_y -= HOTLIST_LINE_HEIGHT;
}
/* Redraw the entrys first line
*/
if (do_update) {
if (toggle) {
entry->selected = !entry->selected;
} else {
entry->selected = true;
}
if (redraw) hotlist_redraw_entry_title(entry);
}
}
/* Continue onwards
*/
if ((entry->child_entry) && (entry->expanded)) {
ro_gui_hotlist_selection_drag(entry->child_entry,
x0, y0, x1, y1, toggle, redraw);
}
entry = entry->next_entry;
do_update = false;
}
}
/**
* The end of a selection drag has been reached
*
* \param drag the final drag co-ordinates
*/
void ro_gui_hotlist_selection_drag_end(wimp_dragged *drag) {
wimp_window_state state;
int x0, y0, x1, y1;
int toolbar_height = 0;
/* Reset our dragging state
*/
dragging = false;
/* Get the toolbar height
*/
if (hotlist_toolbar) toolbar_height = hotlist_toolbar->height * 2;
/* Get the window state to make everything relative
*/
state.w = hotlist_window;
wimp_get_window_state(&state);
/* Create the relative positions
*/
x0 = drag->final.x0 - state.visible.x0 - state.xscroll;
x1 = drag->final.x1 - state.visible.x0 - state.xscroll;
y0 = drag->final.y0 - state.visible.y1 - state.yscroll + toolbar_height;
y1 = drag->final.y1 - state.visible.y1 - state.yscroll + toolbar_height;
/* Make sure x0 < x1 and y0 > y1
*/
if (x0 > x1) {
x0 ^= x1;
x1 ^= x0;
x0 ^= x1;
}
if (y0 < y1) {
y0 ^= y1;
y1 ^= y0;
y0 ^= y1;
}
/* Update the selection state
*/
if (drag_buttons == (wimp_CLICK_SELECT << 4)) {
ro_gui_hotlist_selection_drag(root.child_entry, x0, y0, x1, y1, false, true);
} else {
ro_gui_hotlist_selection_drag(root.child_entry, x0, y0, x1, y1, true, true);
}
ro_gui_menu_prepare_hotlist();
}
/**
* The end of a item moving drag has been reached
*
* \param drag the final drag co-ordinates
*/
void ro_gui_hotlist_move_drag_end(wimp_dragged *drag) {
wimp_pointer pointer;
int toolbar_height = 0;
wimp_window_state state;
struct hotlist_entry *test_entry;
struct hotlist_entry *entry;
int x, y, x0, y0, x1, y1;
bool before = false;
/* Reset our dragging state
*/
dragging = false;
/* Check we dropped to our window
*/
xwimp_get_pointer_info(&pointer);
if (pointer.w != hotlist_window) return;
/* Get the toolbar height
*/
if (hotlist_toolbar) toolbar_height = hotlist_toolbar->height * 2;
/* Set the process flag for all selected items
*/
ro_gui_hotlist_selection_to_process(root.child_entry);
/* Get the window state to make everything relative
*/
state.w = hotlist_window;
wimp_get_window_state(&state);
/* Create the relative positions
*/
x0 = drag->final.x0 - state.visible.x0 - state.xscroll;
x1 = drag->final.x1 - state.visible.x0 - state.xscroll;
y0 = drag->final.y0 - state.visible.y1 - state.yscroll + toolbar_height;
y1 = drag->final.y1 - state.visible.y1 - state.yscroll + toolbar_height;
x = (x0 + x1) / 2;
y = (y0 + y1) / 2;
/* Find our entry
*/
entry = ro_gui_hotlist_find_entry(x, y, root.child_entry);
if (!entry) entry = &root;
/* No parent of the destination can be processed
*/
test_entry = entry;
while (test_entry != NULL) {
if (test_entry->process) return;
test_entry = test_entry->parent_entry;
}
/* Check for before/after
*/
before = ((y - (entry->y0 + entry->height)) > (-HOTLIST_LINE_HEIGHT / 2));
/* Start our recursive moving
*/
while (ro_gui_hotlist_move_processing(root.child_entry, entry, before));
}
bool ro_gui_hotlist_move_processing(struct hotlist_entry *entry, struct hotlist_entry *destination, bool before) {
bool result = false;
if (!entry) return false;
while (entry) {
if (entry->process) {
entry->process = false;
ro_gui_hotlist_delink_entry(entry);
ro_gui_hotlist_link_entry(destination, entry, before);
result = true;
}
if (entry->child_entry) {
result |= ro_gui_hotlist_move_processing(entry->child_entry, destination, before);
}
entry = entry->next_entry;
}
return result;
}
/**
* Handle a menu being closed
*/
void ro_gui_hotlist_menu_closed(void) {
menu_open = false;
if (menu_selection) {
ro_gui_hotlist_selection_state(root.child_entry, false, true);
menu_selection = false;
}
}
/**
* Handle a keypress
*
* \param key the key pressed
* \return whether the key was processed
*/
bool ro_gui_hotlist_keypress(int key) {
wimp_window_state state;
int y;
/* Handle basic keys
*/
switch (key) {
case 1: /* CTRL+A */
ro_gui_hotlist_selection_state(root.child_entry, true, true);
if (menu_open) ro_gui_create_menu(hotlist_menu, 0, 0, NULL);
return true;
case 26: /* CTRL+Z */
ro_gui_hotlist_selection_state(root.child_entry, false, true);
if (menu_open) ro_gui_create_menu(hotlist_menu, 0, 0, NULL);
return true;
case 32: /* SPACE */
ro_gui_hotlist_update_expansion(root.child_entry, true, true, true, false, false);
if (menu_open) ro_gui_create_menu(hotlist_menu, 0, 0, NULL);
return true;
case wimp_KEY_RETURN:
ro_gui_hotlist_launch_selection(root.child_entry);
return true;
case wimp_KEY_F3:
ro_gui_hotlist_save();
return true;
case wimp_KEY_UP:
case wimp_KEY_DOWN:
case wimp_KEY_PAGE_UP:
case wimp_KEY_PAGE_DOWN:
case wimp_KEY_CONTROL | wimp_KEY_UP:
case wimp_KEY_CONTROL | wimp_KEY_DOWN:
break;
default:
return false;
}
/* Handle keypress scrolling
*/
state.w = hotlist_window;
wimp_get_window_state(&state);
y = state.visible.y1 - state.visible.y0 - 32;
switch (key) {
case wimp_KEY_UP:
state.yscroll += 32;
break;
case wimp_KEY_DOWN:
state.yscroll -= 32;
break;
case wimp_KEY_PAGE_UP:
state.yscroll += y;
break;
case wimp_KEY_PAGE_DOWN:
state.yscroll -= y;
break;
case wimp_KEY_CONTROL | wimp_KEY_UP:
state.yscroll = 1000;
break;
case wimp_KEY_CONTROL | wimp_KEY_DOWN:
state.yscroll = -0x10000000;
break;
}
xwimp_open_window((wimp_open *) &state);
return true;
}
void ro_gui_hotlist_toolbar_click(wimp_pointer* pointer) {
int selection;
/* Store the toolbar
*/
current_toolbar = hotlist_toolbar;
/* Handle Menu clicks
*/
if (pointer->buttons == wimp_CLICK_MENU) {
ro_gui_create_menu(toolbar_menu, pointer->pos.x,
pointer->pos.y, NULL);
return;
}
/* Handle the buttons appropriately
*/
switch (pointer->i) {
case ICON_TOOLBAR_CREATE:
hotlist_insert = false;
if (pointer->buttons == wimp_CLICK_SELECT) {
ro_gui_hotlist_prepare_folder_dialog(false);
ro_gui_dialog_open_persistant(hotlist_window, dialog_folder, true);
} else {
ro_gui_hotlist_prepare_entry_dialog(false);
ro_gui_dialog_open_persistant(hotlist_window, dialog_entry, true);
}
break;
case ICON_TOOLBAR_OPEN:
selection = ro_gui_hotlist_get_selected(true);
ro_gui_hotlist_update_expansion(root.child_entry, (selection != 0), true, false,
(pointer->buttons == wimp_CLICK_SELECT),
(pointer->buttons == wimp_CLICK_ADJUST));
break;
case ICON_TOOLBAR_EXPAND:
selection = ro_gui_hotlist_get_selected(true);
ro_gui_hotlist_update_expansion(root.child_entry, (selection != 0), false, true,
(pointer->buttons == wimp_CLICK_SELECT),
(pointer->buttons == wimp_CLICK_ADJUST));
break;
case ICON_TOOLBAR_DELETE:
ro_gui_hotlist_delete_selected();
break;
case ICON_TOOLBAR_LAUNCH:
ro_gui_hotlist_keypress(wimp_KEY_RETURN);
break;
}
}
void ro_gui_hotlist_prepare_folder_dialog(bool selected) {
struct hotlist_entry *entry = NULL;
if (selected) entry = ro_gui_hotlist_first_selection(root.child_entry);
/* Update the title
*/
dialog_folder_add = selected;
if (selected) {
ro_gui_set_window_title(dialog_folder, messages_get("EditFolder"));
} else {
ro_gui_set_window_title(dialog_folder, messages_get("NewFolder"));
}
/* Update the icons
*/
if (entry == NULL) {
ro_gui_set_icon_string(dialog_folder, 1, messages_get("Folder"));
} else {
ro_gui_set_icon_string(dialog_folder, 1, entry->title);
}
}
void ro_gui_hotlist_prepare_entry_dialog(bool selected) {
struct hotlist_entry *entry = NULL;
if (selected) entry = ro_gui_hotlist_first_selection(root.child_entry);
/* Update the title
*/
dialog_entry_add = selected;
if (selected) {
ro_gui_set_window_title(dialog_entry, messages_get("EditLink"));
} else {
ro_gui_set_window_title(dialog_entry, messages_get("NewLink"));
}
/* Update the icons
*/
if (entry == NULL) {
ro_gui_set_icon_string(dialog_entry, 1, messages_get("Link"));
ro_gui_set_icon_string(dialog_entry, 3, "");
} else {
ro_gui_set_icon_string(dialog_entry, 1, entry->title);
ro_gui_set_icon_string(dialog_entry, 3, entry->url);
}
}
/**
* Set all items to either selected or deselected
*
* \param selected the state to set all items to
*/
void ro_gui_hotlist_set_selected(bool selected) {
ro_gui_hotlist_selection_state(root.child_entry, selected, true);
menu_selection = false;
}
/**
* Reset the statistics for selected entries
*/
void ro_gui_hotlist_reset_statistics(void) {
ro_gui_hotlist_invalidate_statistics(root.child_entry);
}
/**
* Return the current number of selected items
*
* \param folders include folders in the selection count
* \return the number of selected items
*/
int ro_gui_hotlist_get_selected(bool folders) {
return ro_gui_hotlist_selection_count(root.child_entry, folders);
}
/**
* Set all items to either selected or deselected
*
* \param expand whether to expand (collapse otherwise)
* \param folders whether to update folders
* \param links whether to update links
*/
void ro_gui_hotlist_set_expanded(bool expand, bool folders, bool links) {
ro_gui_hotlist_update_expansion(root.child_entry, false, folders, links, expand, !expand);
}
/**
* Deletes any selected items
*
* \param selected the state to set all items to
*/
void ro_gui_hotlist_delete_selected(void) {
struct hotlist_entry *entry;
while ((entry = ro_gui_hotlist_first_selection(root.child_entry)) != NULL) {
ro_gui_hotlist_delete_entry(entry, false);
}
}
void ro_gui_hotlist_dialog_click(wimp_pointer *pointer) {
struct hotlist_entry *entry = NULL;
char *title = NULL;
char *url = NULL;
char *old_value;
int icon = pointer->i;
int close_icon, ok_icon;
bool folder;
bool add;
url_func_result res;
/* Get our data
*/
if (pointer->w == dialog_entry) {
title = strip(ro_gui_get_icon_string(pointer->w, 1));
url = strip(ro_gui_get_icon_string(pointer->w, 3));
close_icon = 4;
ok_icon = 5;
folder = false;
add = !dialog_entry_add;
} else {
title = strip(ro_gui_get_icon_string(pointer->w, 1));
close_icon = 2;
ok_icon = 3;
folder = true;
add = !dialog_folder_add;
}
/* Check for cancelling
*/
if (icon == close_icon) {
if (pointer->buttons == wimp_CLICK_SELECT) {
ro_gui_dialog_close(pointer->w);
xwimp_create_menu((wimp_menu *)-1, 0, 0);
return;
}
if (folder) {
ro_gui_hotlist_prepare_folder_dialog(dialog_folder_add);
} else {
ro_gui_hotlist_prepare_entry_dialog(dialog_entry_add);
}
return;
}
/* Check for ok
*/
if (icon != ok_icon) return;
/* Check we have valid values
*/
if ((title != NULL) && (strlen(title) == 0)) {
warn_user("NoNameError", 0);
return;
}
if ((url != NULL) && (strlen(url) == 0)) {
warn_user("NoURLError", 0);
return;
}
/* Update/insert our data
*/
if (add) {
/* todo: insert at the selection place if hotlist_insert is set */
ro_gui_hotlist_create_entry(title, url, folder ? 0 : 0xfaf, &root);
} else {
entry = ro_gui_hotlist_first_selection(root.child_entry);
if (entry == NULL) return;
if (url) {
old_value = entry->url;
res = url_normalize(url, &entry->url);
if (res != URL_FUNC_OK) {
/** \todo use correct error message */
warn_user("NoMemory", 0);
entry->url = old_value;
return;
}
if (old_value) free(old_value);
}
if (title) {
old_value = entry->title;
entry->title = strdup(title);
if (!entry->title) {
warn_user("NoMemory", 0);
entry->title = old_value;
return;
}
free(old_value);
}
hotlist_redraw_entry(entry, false); /* first for contracting size */
ro_gui_hotlist_update_entry_size(entry);
hotlist_redraw_entry(entry, false); /* then for expanding size */
}
/* Close if we should
*/
if (pointer->buttons == wimp_CLICK_SELECT) {
xwimp_create_menu((wimp_menu *)-1, 0, 0);
ro_gui_dialog_close(pointer->w);
return;
}
/* Update our display
*/
if (folder) {
ro_gui_hotlist_prepare_folder_dialog(dialog_folder_add);
} else {
ro_gui_hotlist_prepare_entry_dialog(dialog_entry_add);
}
}
int ro_gui_hotlist_help(int x, int y) {
struct hotlist_entry *entry;
wimp_window_state state;
int toolbar_height = 0;
int x_offset, y_offset;
/* Return the dragging codes
*/
if (dragging) {
if (gui_current_drag_type == GUI_DRAG_HOTLIST_SELECT) return 6;
if (gui_current_drag_type == GUI_DRAG_HOTLIST_MOVE) return 7;
return -1;
}
/* Get the toolbar height
*/
if (hotlist_toolbar) toolbar_height = hotlist_toolbar->height * 2;
/* Get the window state to make everything relative
*/
state.w = hotlist_window;
wimp_get_window_state(&state);
/* Create the relative positions
*/
x = x - state.visible.x0 - state.xscroll;
y = y - state.visible.y1 - state.yscroll + toolbar_height;
/* Get the current entry
*/
entry = ro_gui_hotlist_find_entry(x, y, root.child_entry);
if (entry == NULL) return -1;
/* Return the relevant code
*/
x_offset = x - entry->x0;
y_offset = y - (entry->y0 + entry->height);
if ((x_offset < HOTLIST_LEAF_INSET) && (y_offset > -HOTLIST_LINE_HEIGHT)) {
if (entry->children == 0) return -1;
return (((entry->children == -1) ? 2 : 0) + ((entry->expanded) ? 1 : 0));
}
return ((entry->children == -1) ? 5 : 4);
}
Reference in New Issue View Git Blame Copy Permalink