netsurf/desktop/tree.c

1327 lines
36 KiB
C
Raw Normal View History

/*
* Copyright 2004 Richard Wilson <not_ginger_matt@users.sourceforge.net>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
* NetSurf is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* NetSurf is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/** \file
* Generic tree handling (implementation).
*/
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "content/urldb.h"
#include "desktop/tree.h"
#include "desktop/options.h"
#include "utils/log.h"
#include "utils/messages.h"
#include "utils/utils.h"
static void tree_draw_node(struct tree *tree, struct node *node, int clip_x,
int clip_y, int clip_width, int clip_height);
static struct node_element *tree_create_node_element(struct node *parent,
node_element_data data);
static void tree_delete_node_internal(struct tree *tree, struct node *node, bool siblings);
static int tree_get_node_width(struct node *node);
static int tree_get_node_height(struct node *node);
static void tree_handle_selection_area_node(struct tree *tree,
struct node *node, int x, int y, int width, int height,
bool invert);
static void tree_selected_to_processing(struct node *node);
void tree_clear_processing(struct node *node);
struct node *tree_move_processing_node(struct node *node, struct node *link,
bool before, bool first);
struct node *tree_create_leaf_node_shared(struct node *parent, const char *title);
static int tree_initialising = 0;
/**
* Initialises a user-created tree
*
* \param tree the tree to initialise
*/
void tree_initialise(struct tree *tree) {
assert(tree);
tree_set_node_expanded(tree, tree->root, true);
tree_initialise_nodes(tree, tree->root);
tree_recalculate_node_positions(tree, tree->root);
tree_set_node_expanded(tree, tree->root, false);
tree->root->expanded = true;
tree_recalculate_node_positions(tree, tree->root);
tree_recalculate_size(tree);
}
/**
* Initialises a user-created node structure
*
* \param root the root node to update from
*/
void tree_initialise_nodes(struct tree *tree, struct node *root) {
struct node *node;
assert(root);
tree_initialising++;
for (node = root; node; node = node->next) {
tree_recalculate_node(tree, node, true);
if (node->child) {
tree_initialise_nodes(tree, node->child);
}
}
tree_initialising--;
if (tree_initialising == 0)
tree_recalculate_node_positions(tree, root);
}
/**
* Recalculate the node data and redraw the relevant section of the tree.
*
* \param tree the tree to redraw
* \param node the node to update
* \param recalculate_sizes whether the elements have changed
* \param expansion the request is the result of a node expansion
*/
void tree_handle_node_changed(struct tree *tree, struct node *node,
bool recalculate_sizes, bool expansion) {
int width, height;
assert(node);
if ((expansion) && (node->expanded) && (node->child)) {
tree_set_node_expanded(tree, node->child, false);
tree_set_node_selected(tree, node->child, false);
}
width = node->box.width;
height = node->box.height;
if ((recalculate_sizes) || (expansion))
tree_recalculate_node(tree, node, true);
if ((node->box.height != height) || (expansion)) {
tree_recalculate_node_positions(tree, tree->root);
tree_redraw_area(tree, 0, node->box.y, 16384, 16384);
} else {
width = (width > node->box.width) ? width : node->box.width;
tree_redraw_area(tree, node->box.x, node->box.y, width, node->box.height);
}
if ((recalculate_sizes) || (expansion))
tree_recalculate_size(tree);
}
/**
* Recalculate the node element and redraw the relevant section of the tree.
* The tree size is not updated.
*
* \param tree the tree to redraw
* \param element the node element to update
*/
void tree_handle_node_element_changed(struct tree *tree, struct node_element *element) {
int width, height;
assert(element);
width = element->box.width;
height = element->box.height;
tree_recalculate_node_element(element);
if (element->box.height != height) {
tree_recalculate_node(tree, element->parent, false);
tree_redraw_area(tree, 0, element->box.y, 16384, 16384);
} else {
if (element->box.width != width)
tree_recalculate_node(tree, element->parent, false);
width = (width > element->box.width) ? width :
element->box.width;
tree_redraw_area(tree, element->box.x, element->box.y, width, element->box.height);
}
}
/**
* Recalculates the size of a node.
*
* \param node the node to update
* \param recalculate_sizes whether the node elements have changed
*/
void tree_recalculate_node(struct tree *tree, struct node *node, bool recalculate_sizes) {
struct node_element *element;
int width, height;
assert(node);
width = node->box.width;
height = node->box.height;
node->box.width = 0;
node->box.height = 0;
if (node->expanded) {
for (element = &node->data; element; element = element->next) {
if (recalculate_sizes)
tree_recalculate_node_element(element);
node->box.width = (node->box.width >
element->box.x + element->box.width - node->box.x) ?
node->box.width :
element->box.width + element->box.x - node->box.x;
node->box.height += element->box.height;
}
} else {
if (recalculate_sizes)
for (element = &node->data; element; element = element->next)
tree_recalculate_node_element(element);
else
tree_recalculate_node_element(&node->data);
node->box.width = node->data.box.width;
node->box.height = node->data.box.height;
}
if (height != node->box.height) {
for (; node->parent; node = node->parent);
if (tree_initialising == 0)
tree_recalculate_node_positions(tree, node);
}
}
/**
* Recalculates the position of a node, its siblings and children.
*
* \param root the root node to update from
*/
void tree_recalculate_node_positions(struct tree *tree, struct node *root) {
struct node *parent;
struct node *node;
struct node *child;
struct node_element *element;
int y;
for (node = root; node; node = node->next) {
if (node->previous) {
node->box.x = node->previous->box.x;
node->box.y = node->previous->box.y +
tree_get_node_height(node->previous);
} else if ((parent = node->parent)) {
node->box.x = parent->box.x + NODE_INSTEP;
node->box.y = parent->box.y +
parent->box.height;
for (child = parent->child; child != node;
child = child->next)
node->box.y += child->box.height;
} else {
node->box.x = tree->no_furniture ? -NODE_INSTEP + 4 : 0;
node->box.y = -40;
}
if (node->expanded) {
if (node->folder) {
node->data.box.x = node->box.x;
node->data.box.y = node->box.y;
tree_recalculate_node_positions(tree, node->child);
} else {
y = node->box.y;
for (element = &node->data; element;
element = element->next) {
if (element->type == NODE_ELEMENT_TEXT_PLUS_SPRITE) {
element->box.x = node->box.x;
} else {
element->box.x = node->box.x + NODE_INSTEP;
}
element->box.y = y;
y += element->box.height;
}
}
} else {
node->data.box.x = node->box.x;
node->data.box.y = node->box.y;
}
}
}
/**
* Calculates the width of a node including any children
*
* \param node the node to calculate the height of
* \return the total width of the node and children
*/
int tree_get_node_width(struct node *node) {
int width = 0;
int child_width;
assert(node);
for (; node; node = node->next) {
if (width < (node->box.x + node->box.width))
width = node->box.x + node->box.width;
if ((node->child) && (node->expanded)) {
child_width = tree_get_node_width(node->child);
if (width < child_width)
width = child_width;
}
}
return width;
}
/**
* Calculates the height of a node including any children
*
* \param node the node to calculate the height of
* \return the total height of the node and children
*/
int tree_get_node_height(struct node *node) {
int y1;
assert(node);
if ((node->child) && (node->expanded)) {
y1 = node->box.y;
if (y1 < 0)
y1 = 0;
node = node->child;
while ((node->next) || ((node->child) && (node->expanded))) {
for (; node->next; node = node->next);
if ((node->child) && (node->expanded))
node = node->child;
}
return node->box.y + node->box.height - y1;
} else {
return node->box.height;
}
}
/**
* Updates all siblinds and descendants of a node to an expansion state.
* No update is performed for the tree changes.
*
* \param node the node to set all siblings and descendants of
* \param expanded the expansion state to set
*/
void tree_set_node_expanded(struct tree *tree, struct node *node, bool expanded) {
for (; node; node = node->next) {
if (node->expanded != expanded) {
node->expanded = expanded;
tree_recalculate_node(tree, node, false);
}
if ((node->child) && (node->expanded))
tree_set_node_expanded(tree, node->child, expanded);
}
}
/**
* Updates all siblinds and descendants of a node to an expansion state.
*
* \param tree the tree to update
* \param node the node to set all siblings and descendants of
* \param expanded the expansion state to set
* \param folder whether to update folders
* \param leaf whether to update leaves
* \return whether any changes were made
*/
bool tree_handle_expansion(struct tree *tree, struct node *node, bool expanded, bool folder,
bool leaf) {
struct node *entry = node;
bool redraw = false;
for (; node; node = node->next) {
if ((node->expanded != expanded) && (node != tree->root) &&
((folder && (node->folder)) || (leaf && (!node->folder)))) {
node->expanded = expanded;
if (node->child)
tree_set_node_expanded(tree, node->child, false);
if ((node->data.next) && (node->data.next->box.height == 0))
tree_recalculate_node(tree, node, true);
else
tree_recalculate_node(tree, node, false);
redraw = true;
}
if ((node->child) && (node->expanded))
redraw |= tree_handle_expansion(tree, node->child, expanded, folder, leaf);
}
if ((entry == tree->root) && (redraw)) {
tree_recalculate_node_positions(tree, tree->root);
tree_redraw_area(tree, 0, 0, 16384, 16384);
tree_recalculate_size(tree);
}
return redraw;
}
/**
* Updates all siblinds and descendants of a node to an selected state.
* The required areas of the tree are redrawn.
*
* \param tree the tree to update nodes for
* \param node the node to set all siblings and descendants of
* \param selected the selection state to set
*/
void tree_set_node_selected(struct tree *tree, struct node *node, bool selected) {
for (; node; node = node->next) {
if ((node->selected != selected) && (node != tree->root)) {
node->selected = selected;
tree_redraw_area(tree, node->box.x, node->box.y, node->box.width,
node->data.box.height);
}
if ((node->child) && (node->expanded))
tree_set_node_selected(tree, node->child, selected);
}
}
/**
* Finds a node at a specific location.
*
* \param root the root node to check from
* \param x the x co-ordinate
* \param y the y co-ordinate
* \param furniture whether the returned area was in an elements furniture
* \return the node at the specified position, or NULL for none
*/
struct node *tree_get_node_at(struct node *root, int x, int y, bool *furniture) {
struct node_element *result;
if ((result = tree_get_node_element_at(root, x, y, furniture)))
return result->parent;
return NULL;
}
/**
* Finds a node element at a specific location.
*
* \param node the root node to check from
* \param x the x co-ordinate
* \param y the y co-ordinate
* \param furniture whether the returned area was in an elements furniture
* \return the node at the specified position, or NULL for none
*/
struct node_element *tree_get_node_element_at(struct node *node, int x, int y,
bool *furniture) {
struct node_element *element;
*furniture = false;
for (; node; node = node->next) {
if (node->box.y > y) return NULL;
if ((node->box.x - NODE_INSTEP < x) && (node->box.y < y) &&
(node->box.x + node->box.width >= x) &&
(node->box.y + node->box.height >= y)) {
if (node->expanded) {
for (element = &node->data; element;
element = element->next) {
if ((element->box.x < x) && (element->box.y < y) &&
(element->box.x + element->box.width >= x) &&
(element->box.y + element->box.height >= y))
return element;
}
} else if ((node->data.box.x < x) &&
(node->data.box.y < y) &&
(node->data.box.x + node->data.box.width >= x) &&
(node->data.box.y + node->data.box.height >= y))
return &node->data;
if (((node->child) || (node->data.next)) &&
(node->data.box.x - NODE_INSTEP + 8 < x) &&
(node->data.box.y + 8 < y) &&
(node->data.box.x > x) &&
(node->data.box.y + 32 > y)) {
*furniture = true;
return &node->data;
}
}
if ((node->child) && (node->expanded) &&
((element = tree_get_node_element_at(node->child, x, y,
furniture))))
return element;
}
return NULL;
}
/**
* Finds a node element from a node with a specific user_type
*
* \param node the node to examine
* \param user_type the user_type to check for
* \return the corresponding element
*/
struct node_element *tree_find_element(struct node *node, node_element_data data) {
struct node_element *element;
for (element = &node->data; element; element = element->next)
if (element->data == data) return element;
return NULL;
}
/**
* Moves nodes within a tree.
*
* \param tree the tree to process
* \param link the node to link before/as a child (folders) or before/after (link)
* \param before whether to link siblings before or after the supplied node
*/
void tree_move_selected_nodes(struct tree *tree, struct node *destination, bool before) {
struct node *link;
struct node *test;
bool error;
tree_clear_processing(tree->root);
tree_selected_to_processing(tree->root);
/* the destination node cannot be a child of any node with the processing flag set */
error = destination->processing;
for (test = destination; test; test = test->parent)
error |= test->processing;
if (error) {
tree_clear_processing(tree->root);
return;
}
if ((destination->folder) && (!destination->expanded) && (!before)) {
destination->expanded = true;
tree_handle_node_changed(tree, destination, false, true);
}
link = tree_move_processing_node(tree->root, destination, before, true);
while (link)
link = tree_move_processing_node(tree->root, link, false, false);
tree_clear_processing(tree->root);
tree_recalculate_node_positions(tree, tree->root);
tree_redraw_area(tree, 0, 0, 16384, 16384);
}
/**
* Sets the processing flag to the selection state.
*
* \param node the node to process siblings and children of
*/
void tree_selected_to_processing(struct node *node) {
for (; node; node = node->next) {
node->processing = node->selected;
if ((node->child) && (node->expanded))
tree_selected_to_processing(node->child);
}
}
/**
* Clears the processing flag.
*
* \param node the node to process siblings and children of
*/
void tree_clear_processing(struct node *node) {
for (; node; node = node->next) {
node->processing = false;
if (node->child)
tree_clear_processing(node->child);
}
}
/**
* Moves the first node in a tree with the processing flag set.
*
* \param tree the node to move siblings/children of
* \param link the node to link before/as a child (folders) or before/after (link)
* \param before whether to link siblings before or after the supplied node
* \param first whether to always link after the supplied node (ie not inside of folders)
* \return the node moved
*/
struct node *tree_move_processing_node(struct node *node, struct node *link, bool before,
bool first) {
struct node *result;
bool folder = link->folder;
for (; node; node = node->next) {
if (node->processing) {
node->processing = false;
tree_delink_node(node);
if (!first)
link->folder = false;
tree_link_node(link, node, before);
if (!first)
link->folder = folder;
return node;
}
if (node->child) {
result = tree_move_processing_node(node->child, link, before, first);
if (result)
return result;
}
}
return NULL;
}
/**
* Checks whether a node, its siblings or any children are selected.
*
* \param node the root node to check from
*/
bool tree_has_selection(struct node *node) {
for (; node; node = node->next) {
if (node->selected)
return true;
if ((node->child) && (node->expanded) &&
(tree_has_selection(node->child)))
return true;
}
return false;
}
/**
* Updates the selected state for a region of nodes.
*
* \param tree the tree to update
* \param x the minimum x of the selection rectangle
* \param y the minimum y of the selection rectangle
* \param width the width of the selection rectangle
* \param height the height of the selection rectangle
* \param invert whether to invert the selected state
*/
void tree_handle_selection_area(struct tree *tree, int x, int y, int width, int height,
bool invert) {
assert(tree);
assert(tree->root);
if (!tree->root->child) return;
if (width < 0) {
x += width;
width =- width;
}
if (height < 0) {
y += height;
height =- height;
}
tree_handle_selection_area_node(tree, tree->root->child, x, y, width, height, invert);
}
/**
* Updates the selected state for a region of nodes.
*
* \param tree the tree to update
* \param node the node to update children and siblings of
* \param x the minimum x of the selection rectangle
* \param y the minimum y of the selection rectangle
* \param width the width of the selection rectangle
* \param height the height of the selection rectangle
* \param invert whether to invert the selected state
*/
void tree_handle_selection_area_node(struct tree *tree, struct node *node, int x, int y,
int width, int height, bool invert) {
struct node_element *element;
struct node *update;
int x_max, y_max;
assert(tree);
assert(node);
x_max = x + width;
y_max = y + height;
for (; node; node = node->next) {
if (node->box.y > y_max) return;
if ((node->box.x < x_max) && (node->box.y < y_max) &&
(node->box.x + node->box.width + NODE_INSTEP >= x) &&
(node->box.y + node->box.height >= y)) {
update = NULL;
if (node->expanded) {
for (element = &node->data; element;
element = element->next) {
if ((element->box.x < x_max) && (element->box.y < y_max) &&
(element->box.x + element->box.width >= x) &&
(element->box.y + element->box.height >= y)) {
update = element->parent;
break;
}
}
} else if ((node->data.box.x < x_max) &&
(node->data.box.y < y_max) &&
(node->data.box.x + node->data.box.width >= x) &&
(node->data.box.y + node->data.box.height >= y))
update = node->data.parent;
if ((update) && (node != tree->root)) {
if (invert) {
node->selected = !node->selected;
tree_handle_node_element_changed(tree, &node->data);
} else if (!node->selected) {
node->selected = true;
tree_handle_node_element_changed(tree, &node->data);
}
}
}
if ((node->child) && (node->expanded))
tree_handle_selection_area_node(tree, node->child, x, y, width, height,
invert);
}
}
/**
* Redraws a tree.
*
* \param tree the tree to draw
* \param clip_x the minimum x of the clipping rectangle
* \param clip_y the minimum y of the clipping rectangle
* \param clip_width the width of the clipping rectangle
* \param clip_height the height of the clipping rectangle
*/
void tree_draw(struct tree *tree, int clip_x, int clip_y, int clip_width,
int clip_height) {
assert(tree);
assert(tree->root);
if (!tree->root->child) return;
tree_initialise_redraw(tree);
tree_draw_node(tree, tree->root->child, clip_x,
clip_y, clip_width, clip_height);
}
/**
* Redraws a node.
*
* \param tree the tree to draw
* \param node the node to draw children and siblings of
* \param clip_x the minimum x of the clipping rectangle
* \param clip_y the minimum y of the clipping rectangle
* \param clip_width the width of the clipping rectangle
* \param clip_height the height of the clipping rectangle
*/
void tree_draw_node(struct tree *tree, struct node *node, int clip_x, int clip_y,
int clip_width, int clip_height) {
struct node_element *element;
int x_max, y_max;
assert(tree);
assert(node);
x_max = clip_x + clip_width + NODE_INSTEP;
y_max = clip_y + clip_height;
if ((node->parent->next) && (node->parent->next->box.y < clip_y))
return;
for (; node; node = node->next) {
if (node->box.y > y_max) return;
if ((node->next) && (!tree->no_furniture))
tree_draw_line(node->box.x - (NODE_INSTEP / 2),
node->box.y + (40 / 2), 0,
node->next->box.y - node->box.y);
if ((node->box.x < x_max) && (node->box.y < y_max) &&
(node->box.x + node->box.width + NODE_INSTEP >= clip_x) &&
(node->box.y + node->box.height >= clip_y)) {
if (!tree->no_furniture) {
if ((node->expanded) && (node->child))
tree_draw_line(node->box.x + (NODE_INSTEP / 2),
node->data.box.y + node->data.box.height, 0,
(40 / 2));
if ((node->parent) && (node->parent != tree->root) &&
(node->parent->child == node))
tree_draw_line(node->parent->box.x + (NODE_INSTEP / 2),
node->parent->data.box.y +
node->parent->data.box.height, 0,
(40 / 2));
tree_draw_line(node->box.x - (NODE_INSTEP / 2),
node->data.box.y +
node->data.box.height - (40 / 2),
(NODE_INSTEP / 2) - 4, 0);
tree_draw_node_expansion(tree, node);
}
if (node->expanded)
for (element = &node->data; element;
element = element->next)
tree_draw_node_element(tree, element);
else
tree_draw_node_element(tree, &node->data);
}
if ((node->child) && (node->expanded))
tree_draw_node(tree, node->child, clip_x, clip_y, clip_width,
clip_height);
}
}
/**
* Gets link characteristics to insert a node at a specified position.
*
* \param tree the tree to find link information for
* \param x the x co-ordinate
* \param y the y co-ordinate
* \param before set to whether the node should be linked before on exit
* \return the node to link with
*/
struct node *tree_get_link_details(struct tree *tree, int x, int y, bool *before) {
struct node *node = NULL;
bool furniture;
assert(tree);
assert(tree->root);
*before = false;
if (tree->root->child)
node = tree_get_node_at(tree->root->child, x, y, &furniture);
if ((!node) || (furniture))
return tree->root;
if (y < (node->box.y + (node->box.height / 2))) {
*before = true;
} else if ((node->folder) && (node->expanded) && (node->child)) {
node = node->child;
*before = true;
}
return node;
}
/**
* Links a node into the tree.
*
* \param link the node to link before/as a child (folders) or before/after (link)
* \param node the node to link
* \param before whether to link siblings before or after the supplied node
*/
void tree_link_node(struct node *link, struct node *node, bool before) {
assert(link);
assert(node);
if ((!link->folder) || (before)) {
node->parent = link->parent;
if (before) {
node->next = link;
node->previous = link->previous;
if (link->previous) link->previous->next = node;
link->previous = node;
if ((link->parent) && (link->parent->child == link))
link->parent->child = node;
} else {
node->previous = link;
node->next = link->next;
if (link->next) link->next->previous = node;
link->next = node;
}
} else {
if (!link->child) {
link->child = link->last_child = node;
node->previous = NULL;
} else {
link->last_child->next = node;
node->previous = link->last_child;
link->last_child = node;
}
node->parent = link;
node->next = NULL;
}
node->deleted = false;
}
/**
* Delinks a node from the tree.
*
* \param node the node to delink
*/
void tree_delink_node(struct node *node) {
assert(node);
if (node->parent) {
if (node->parent->child == node)
node->parent->child = node->next;
if (node->parent->last_child == node)
node->parent->last_child = node->previous;
if (node->parent->child == NULL) {
/* don't contract top-level node */
if (node->parent->parent)
node->parent->expanded = false;
}
node->parent = NULL;
}
if (node->previous)
node->previous->next = node->next;
if (node->next)
node->next->previous = node->previous;
node->previous = NULL;
node->next = NULL;
}
/**
* Deletes all selected node from the tree.
*
* \param tree the tree to delete from
* \param node the node to delete
*/
void tree_delete_selected_nodes(struct tree *tree, struct node *node) {
struct node *next;
while (node) {
next = node->next;
if ((node->selected) && (node != tree->root))
tree_delete_node(tree, node, false);
else if (node->child)
tree_delete_selected_nodes(tree, node->child);
node = next;
}
}
/**
* Deletes a node from the tree.
*
* \param tree the tree to delete from
* \param node the node to delete
* \param siblings whether to delete all siblings
*/
void tree_delete_node(struct tree *tree, struct node *node, bool siblings) {
tree_delete_node_internal(tree, node, siblings);
if (tree->root)
tree_recalculate_node_positions(tree, tree->root);
tree_redraw_area(tree, 0, 0, 16384, 16384); /* \todo correct area */
tree_recalculate_size(tree);
}
/**
* Deletes a node from the tree.
*
* \param tree the tree to delete from
* \param node the node to delete
* \param siblings whether to delete all siblings
*/
void tree_delete_node_internal(struct tree *tree, struct node *node, bool siblings) {
struct node *next, *child;
struct node_element *e, *f, *domain, *path;
char *domain_t, *path_t, *name_t;
char *space;
assert(node);
if (tree->temp_selection == node)
tree->temp_selection = NULL;
if (tree->root == node)
tree->root = NULL;
next = node->next;
tree_delink_node(node);
child = node->child;
node->child = NULL;
if (child)
tree_delete_node_internal(tree, child, true);
if (!node->retain_in_memory) {
node->retain_in_memory = true;
for (e = &node->data; e; e = f) {
if (e->text) {
/* we don't free non-editable titles or URLs */
if ((node->editable) || (node->folder))
free(e->text);
else {
/* only reset non-deleted items */
if (!node->deleted) {
if (e->data == TREE_ELEMENT_URL) {
/* reset URL characteristics */
urldb_reset_url_visit_data(e->text);
} else if (e->data == TREE_ELEMENT_NAME) {
/* get the rest of the cookie data */
domain = tree_find_element(node,
TREE_ELEMENT_DOMAIN);
path = tree_find_element(node,
TREE_ELEMENT_PATH);
if (domain && path) {
domain_t = domain->text +
strlen(messages_get(
"TreeDomain")) - 4;
space = strchr(domain_t, ' ');
if (space)
*space = '\0';
path_t = path->text +
strlen(messages_get(
"TreePath")) - 4;
space = strchr(path_t, ' ');
if (space)
*space = '\0';
name_t = e->text;
urldb_delete_cookie(
domain_t,
path_t,
e->text);
}
}
}
if (e->data != TREE_ELEMENT_TITLE &&
e->data != TREE_ELEMENT_URL) {
free(e->text);
e->text = NULL;
}
}
}
if (e->sprite) {
/* TODO the type of this field is platform dependent */
free(e->sprite); /* \todo platform specific bits */
e->sprite = NULL;
}
f = e->next;
if (e != &node->data)
free(e);
}
free(node);
} else {
node->deleted = true;
}
if (siblings && next)
tree_delete_node_internal(tree, next, true);
}
/**
* Creates a folder node with the specified title, and links it into the tree.
*
* \param parent the parent node, or NULL not to link
* \param title the node title (copied)
* \return the newly created node.
*/
struct node *tree_create_folder_node(struct node *parent, const char *title) {
struct node *node;
assert(title);
node = calloc(sizeof(struct node), 1);
if (!node) return NULL;
node->editable = true;
node->folder = true;
node->data.parent = node;
node->data.type = NODE_ELEMENT_TEXT;
node->data.text = squash_whitespace(title);
node->data.data = TREE_ELEMENT_TITLE;
tree_set_node_sprite_folder(node);
if (parent)
tree_link_node(parent, node, false);
return node;
}
/**
* Creates a leaf node with the specified title, and links it into the tree.
*
* \param parent the parent node, or NULL not to link
* \param title the node title (copied)
* \return the newly created node.
*/
struct node *tree_create_leaf_node(struct node *parent, const char *title) {
struct node *node;
assert(title);
node = calloc(sizeof(struct node), 1);
if (!node) return NULL;
node->folder = false;
node->data.parent = node;
node->data.type = NODE_ELEMENT_TEXT;
node->data.text = strdup(squash_whitespace(title));
node->data.data = TREE_ELEMENT_TITLE;
node->editable = true;
if (parent)
tree_link_node(parent, node, false);
return node;
}
/**
* Creates a leaf node with the specified title, and links it into the tree.
*
* \param parent the parent node, or NULL not to link
* \param title the node title
* \return the newly created node.
*/
struct node *tree_create_leaf_node_shared(struct node *parent, const char *title) {
struct node *node;
assert(title);
node = calloc(sizeof(struct node), 1);
if (!node) return NULL;
node->folder = false;
node->data.parent = node;
node->data.type = NODE_ELEMENT_TEXT;
node->data.text = title;
node->data.data = TREE_ELEMENT_TITLE;
node->editable = false;
if (parent)
tree_link_node(parent, node, false);
return node;
}
/**
* Creates a tree entry for a URL, and links it into the tree
*
*
* \param parent the node to link to
* \param url the URL (copied)
* \param data the URL data to use
* \param title the custom title to use
* \return the node created, or NULL for failure
*/
struct node *tree_create_URL_node(struct node *parent,
const char *url, const struct url_data *data,
const char *title) {
struct node *node;
struct node_element *element;
assert(data);
node = tree_create_leaf_node(parent, title ? title : url);
if (!node)
return NULL;
element = tree_create_node_element(node, TREE_ELEMENT_THUMBNAIL);
if (element)
element->type = NODE_ELEMENT_THUMBNAIL;
tree_create_node_element(node, TREE_ELEMENT_VISITS);
tree_create_node_element(node, TREE_ELEMENT_LAST_VISIT);
element = tree_create_node_element(node, TREE_ELEMENT_URL);
if (element)
element->text = strdup(url);
tree_update_URL_node(node, url, NULL);
return node;
}
/**
* Creates a tree entry for a URL, and links it into the tree.
*
* All information is used directly from the url_data, and as such cannot be
* edited and should never be freed.
*
* \param parent the node to link to
* \param url the URL
* \param data the URL data to use
* \return the node created, or NULL for failure
*/
struct node *tree_create_URL_node_shared(struct node *parent,
const char *url, const struct url_data *data) {
struct node *node;
struct node_element *element;
char *title;
assert(url && data);
if (data->title)
title = data->title;
else
title = url;
node = tree_create_leaf_node_shared(parent, title);
if (!node)
return NULL;
element = tree_create_node_element(node, TREE_ELEMENT_THUMBNAIL);
if (element)
element->type = NODE_ELEMENT_THUMBNAIL;
tree_create_node_element(node, TREE_ELEMENT_VISITS);
tree_create_node_element(node, TREE_ELEMENT_LAST_VISIT);
element = tree_create_node_element(node, TREE_ELEMENT_URL);
if (element)
element->text = url;
tree_update_URL_node(node, url, data);
return node;
}
/**
* Creates a tree entry for a cookie, and links it into the tree.
*
* All information is copied from the cookie_data, and as such can
* be edited and should be freed.
*
* \param parent the node to link to
* \param url the URL
* \param data the cookie data to use
* \return the node created, or NULL for failure
*/
struct node *tree_create_cookie_node(struct node *parent,
const struct cookie_data *data) {
struct node *node;
struct node_element *element;
char buffer[256];
char buffer2[16];
node = tree_create_leaf_node(parent, data->name);
if (!node)
return NULL;
node->data.data = TREE_ELEMENT_NAME;
node->editable = false;
element = tree_create_node_element(node, TREE_ELEMENT_PERSISTENT);
if (element) {
snprintf(buffer, 256, messages_get("TreePersistent"),
data->no_destroy ? messages_get("Yes") : messages_get("No"));
element->text = strdup(buffer);
}
element = tree_create_node_element(node, TREE_ELEMENT_VERSION);
if (element) {
snprintf(buffer2, 16, "TreeVersion%i", data->version);
snprintf(buffer, 256, messages_get("TreeVersion"), messages_get(buffer2));
element->text = strdup(buffer);
}
element = tree_create_node_element(node, TREE_ELEMENT_SECURE);
if (element) {
snprintf(buffer, 256, messages_get("TreeSecure"),
data->secure ? messages_get("Yes") : messages_get("No"));
element->text = strdup(buffer);
}
element = tree_create_node_element(node, TREE_ELEMENT_LAST_USED);
if (element) {
snprintf(buffer, 256, messages_get("TreeLastUsed"),
(data->last_used > 0) ?
ctime(&data->last_used) : messages_get("TreeUnknown"));
if (data->last_used > 0)
buffer[strlen(buffer) - 1] = '\0';
element->text = strdup(buffer);
}
element = tree_create_node_element(node, TREE_ELEMENT_EXPIRES);
if (element) {
snprintf(buffer, 256, messages_get("TreeExpires"),
(data->expires > 0)
? (data->expires == 1)
? messages_get("TreeSession")
: ctime(&data->expires)
: messages_get("TreeUnknown"));
if (data->expires > 0 && data->expires != 1)
buffer[strlen(buffer) - 1] = '\0';
element->text = strdup(buffer);
}
element = tree_create_node_element(node, TREE_ELEMENT_PATH);
if (element) {
snprintf(buffer, 256, messages_get("TreePath"), data->path,
data->path_from_set ? messages_get("TreeHeaders") : "");
element->text = strdup(buffer);
}
element = tree_create_node_element(node, TREE_ELEMENT_DOMAIN);
if (element) {
snprintf(buffer, 256, messages_get("TreeDomain"), data->domain,
data->domain_from_set ? messages_get("TreeHeaders") : "");
element->text = strdup(buffer);
}
if ((data->comment) && (strcmp(data->comment, ""))) {
element = tree_create_node_element(node, TREE_ELEMENT_COMMENT);
if (element) {
snprintf(buffer, 256, messages_get("TreeComment"), data->comment);
element->text = strdup(buffer);
}
}
element = tree_create_node_element(node, TREE_ELEMENT_VALUE);
if (element) {
snprintf(buffer, 256, messages_get("TreeValue"),
data->value ? data->value : messages_get("TreeUnused"));
element->text = strdup(buffer);
}
tree_set_node_sprite(node, "small_xxx", "small_xxx");
return node;
}
/**
* Creates an empty text node element and links it to a node.
*
* \param parent the parent node
* \param user_type the required user_type
* \return the newly created element.
*/
struct node_element *tree_create_node_element(struct node *parent, node_element_data data) {
struct node_element *element;
element = calloc(sizeof(struct node_element), 1);
if (!element) return NULL;
element->parent = parent;
element->data = data;
element->type = NODE_ELEMENT_TEXT;
element->next = parent->data.next;
parent->data.next = element;
return element;
}
/**
* Recalculates the size of a tree.
*
* \param tree the tree to recalculate
*/
void tree_recalculate_size(struct tree *tree) {
int width, height;
assert(tree);
if (!tree->handle)
return;
width = tree->width;
height = tree->height;
if (tree->root) {
tree->width = tree_get_node_width(tree->root);
tree->height = tree_get_node_height(tree->root);
} else {
tree->width = 0;
tree->height = 0;
}
if ((width != tree->width) || (height != tree->height))
tree_resized(tree);
}
/**
* Returns the selected node, or NULL if multiple nodes are selected.
*
* \param node the node to search sibling and children
* \return the selected node, or NULL if multiple nodes are selected
*/
struct node *tree_get_selected_node(struct node *node) {
struct node *result = NULL;
struct node *temp;
for (; node; node = node->next) {
if (node->selected) {
if (result)
return NULL;
result = node;
}
if ((node->child) && (node->expanded)) {
temp = tree_get_selected_node(node->child);
if (temp) {
if (result)
return NULL;
else
result = temp;
}
}
}
return result;
}