/* Copyright 1997 Acorn Computers Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************/
/* File : Hotlist.c */
/* */
/* Purpose: Managing a hotlist in the browser. */
/* */
/* Author : D.T.A.Brown */
/* */
/* History: 06-Aug-97: Created. */
/* 22-Aug-97: (ADH/DTAB) Integrated into */
/* main browser code. */
/***************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "swis.h"
#include "toolbox.h"
#include "wimp.h"
#include "wimplib.h"
#include "menu.h"
#include "event.h"
#include "gadgets.h"
#include "svcprint.h"
#include "Global.h"
#include "FromROSLib.h"
#include "Utils.h"
#include "ChoiceDefs.h"
#include "FetchPage.h"
#include "Filetypes.h"
#include "Menus.h"
#include "Mouse.h"
#include "Multiuser.h"
#include "Protocols.h"
#include "Save.h"
#include "Toolbars.h"
#include "URLUtils.h"
#include "Windows.h"
#include "Hotlist.h"
/* Internationalisation support */
#ifdef UNIFONT
#define CHARSET_SPECIFIER "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\n"
#else
#define CHARSET_SPECIFIER "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=ISO-8859-1\">\n"
#endif
/* Local definitions */
#define HotlistWrite(fn) {written = (fn); if (written < 0) goto hotlist_save_error;}
/* Local statics */
static int autoopen_oldtime; /* Base time for autoopen directory */
static hotlist_item * hotlist_root = NULL; /* Pointer to the hotlist root directory item */
static int hotlist_windowid = NULL_ObjectId; /* Object ID of the hotlist window */
static hotlist_item * hotlist_newitem; /* When ever a new item is created this points to it */
static int menu_itemno = 0; /* Item over which menu was pressed */
static int menu_select = 0; /* 1 if an item had to be selected when the menu was opened */
static unsigned int last_selected_item = 0xffffffff; /* The last item which was selected */
static unsigned int highlighted_itemno; /* During dragging, the number of a directory item using the '...+' sprite */
static hotlist_item * hotlist_current_highlighted = NULL; /* To save scanning lists, pointer to the highlighted item */
static int hl_show_urls; /* 0 when url descriptions to be shown, 1 to show urls */
static unsigned int hotlist_bbar_size = 0; /* Height in OS units of the button bar */
static unsigned int alter_new; /* Remembers if the edit dialogue is Alter or New; see */
/* HOTLIST_MENUSECTION_NEW and HOTLIST_MENUSECTION_ALTER */
/* Local structures */
typedef struct hl_dragging_details
{
char drag_type; /* One of HOTIST_NOT_DRAGGING, HOTLIST_BOX_DRAG, HOTLIST_SOLID_DRAG_OBJECT, */
/* HOTLIST_SOLID_DRAG_SPRITE, or HOTLIST_BOX_DRAG_SELECTION - See Hotlist.h */
unsigned int using_adjust :1;
}
hl_dragging_details;
static hl_dragging_details hotlist_dragging;
/* Event handler prototypes */
// Write these out in full, to clearly state exactly what parameters are needed?
// Or is this in fact more robust, as the compiler will fault mismatched functions
// in this source as opposed to wherever a registration of the handler occurs?
static _kernel_oserror * hotlist_selection_box_start(void);
static WimpEventHandler hotlist_redraw_handler;
static WimpEventHandler hotlist_mouse_click_handler;
static WimpEventHandler hotlist_drag_completed_handler;
static WimpEventHandler hotlist_null_handler;
static WimpEventHandler hotlist_null_drag_select_handler;
static ToolboxEventHandler hotlist_menuopen_handler;
static ToolboxEventHandler hotlist_menuclose_handler;
static ToolboxEventHandler hotlist_select_all_handler;
static ToolboxEventHandler hotlist_clear_selection_handler;
static ToolboxEventHandler hotlist_menu_openall_handler;
static ToolboxEventHandler hotlist_menu_closeall_handler;
static ToolboxEventHandler hotlist_menu_delete_handler;
static ToolboxEventHandler hotlist_save_to_server_handler;
static ToolboxEventHandler hotlist_show_editurl_handler;
static ToolboxEventHandler hotlist_show_rendirectory_handler;
static ToolboxEventHandler hotlist_show_newurl_handler;
static ToolboxEventHandler hotlist_show_newdirectory_handler;
static ToolboxEventHandler hotlist_newedit_url_handler;
static ToolboxEventHandler hotlist_newren_directory_handler;
static ToolboxEventHandler hotlist_reset_url_handler;
static ToolboxEventHandler hotlist_reset_directory_handler;
static ToolboxEventHandler hotlist_show_descriptions_handler;
static ToolboxEventHandler hotlist_show_urls_handler;
static ToolboxEventHandler hotlist_drag_stop_handler;
static ToolboxEventHandler hotlist_close_handler;
/* Debug functions */
#ifdef TRACE
static void hotlist_display_item(hotlist_item * item);
static void hotlist_display_tree(hotlist_item * list, int indent);
#endif
/* List enquiry and manupulation */
static _kernel_oserror * hotlist_link (hotlist_item * item, hotlist_item * target, unsigned int position);
static void hotlist_unlink (hotlist_item * item);
static _kernel_oserror * hotlist_new_directory (hotlist_item * parent, char * directory_name, unsigned int position, hotlist_item ** new);
static _kernel_oserror * hotlist_new_url (hotlist_item * parent, unsigned int position, char * url_desc, char * url);
static void hotlist_delete_item (hotlist_item * item);
static _kernel_oserror * hotlist_move_item (hotlist_item * source, hotlist_item * target, unsigned int position);
static _kernel_oserror * hotlist_copy_item (hotlist_item * source, hotlist_item * target, unsigned int position, hotlist_item ** new_item);
/* Item enquiry and manipulation */
static _kernel_oserror * hotlist_get_entry_sizes (unsigned int * item_height, unsigned int * item_dir_width, unsigned int * item_url_width);
static int hotlist_set_flags (hotlist_item * list, hotlist_type type, unsigned int flags);
static int hotlist_clear_flags (hotlist_item * list, hotlist_type type, unsigned int flags);
/* Finding items */
static hotlist_item * hotlist_find_item (hotlist_item * list, unsigned int item_no);
static hotlist_item * hotlist_find_item_r (hotlist_item * list, unsigned int item_no, int * curr_item);
static int hotlist_find_no_from_item (hotlist_item * item);
static int hotlist_find_no_from_item_r (hotlist_item * list, hotlist_item * item, int * curr_item);
static hotlist_item * hotlist_find_selected_item_r (hotlist_item * list);
/* Counting items */
static void hotlist_count_selected_items_r (hotlist_item * list, int * count);
static unsigned int hotlist_count_displayed_items (hotlist_item * list);
static void hotlist_count_displayed_items_r (hotlist_item * list, int * count);
// Categorisation work in progress...
static _kernel_oserror * hotlist_draw (hotlist_item * list, unsigned int first_item, unsigned int last_item);
static _kernel_oserror * hotlist_draw_r (hotlist_item *list, unsigned int first_item, unsigned int last_item, int * curr_item, unsigned int indent, unsigned int item_height, unsigned int item_dir_width, unsigned int item_url_width);
static unsigned int hotlist_contents_selected (hotlist_item * item);
static unsigned int hotlist_no_contents_selected (hotlist_item * item);
static unsigned int hotlist_get_max_width (hotlist_item * list);
static _kernel_oserror * hotlist_get_max_width_r (hotlist_item *list, unsigned int indent, int * max_width, unsigned int item_height, unsigned int item_dir_width, unsigned int item_url_width);
static _kernel_oserror * hotlist_redraw_now (void);
static _kernel_oserror * hotlist_redraw_now_r (hotlist_item * list, int * curr_item);
static _kernel_oserror * hotlist_get_shape (int * xmin, int * xmax, hotlist_item * item);
static _kernel_oserror * hotlist_directory_open_close (hotlist_item * item, unsigned int itemno);
static _kernel_oserror * hotlist_redraw_items (unsigned int firstitem, unsigned int lastitem);
static _kernel_oserror * hotlist_launch_url (hotlist_item * item);
static _kernel_oserror * hotlist_process_click_on_item (unsigned int itemno, hotlist_item * item, int buttons, int x, int y);
static _kernel_oserror * hotlist_process_click (int x, int y, int buttons);
static int hotlist_preopen (void);
static _kernel_oserror * hotlist_set_menu_details (ObjectId menuid);
static _kernel_oserror * hotlist_save_entries (FILE * fileptr, hotlist_item * list, int type, int save_read_only);
static void hotlist_lower_tags (char * string);
static void hotlist_drag_renderer (hotlist_item * item, unsigned int item_height, unsigned int item_dir_width, unsigned int item_url_width);
static _kernel_oserror * hotlist_start_drag (void);
static _kernel_oserror * hotlist_start_drag_backend (void);
static _kernel_oserror * hotlist_modified (unsigned int type);
static void hotlist_convert_drag_selection (hotlist_item * item);
static _kernel_oserror * hotlist_autoscroll (int window);
static _kernel_oserror * hotlist_load_directory (FILE * fileptr, hotlist_item * target);
static int hotlist_get_selected_shape (BBox * box);
static _kernel_oserror * hotlist_get_selected_shape_r (hotlist_item * list, BBox * box, unsigned int * itemno, int * found, unsigned int item_height);
static _kernel_oserror * hotlist_select_box (unsigned int first_item, unsigned int last_item, int minx, int maxx);
static _kernel_oserror * hotlist_select_box_r (unsigned int first_item, unsigned int last_item, hotlist_item *item, unsigned int *itemno, int minx, int maxx);
static void hotlist_find_match_r (char * buffer, int buffer_size, hotlist_item * item, hotlist_item ** lowest_item, int * lowest_offset, int * lowest_diff);
/* Save Protocol */
static _kernel_oserror * hotlist_initiate_uri_save (hotlist_item *sourceitem);
static _kernel_oserror * hotlist_initiate_html_save (char *filename);
#ifdef TRACE
/*************************************************/
/* hotlist_display_item() */
/* */
/* This function display the data held by a */
/* single hotlist_item */
/* */
/* Parameters: Pointer to a hotlist_item */
/*************************************************/
static void hotlist_display_item(hotlist_item * item)
{
Printf("\nhotlist_display_item for %p\n",item);
Printf("--------------------\n");
Printf("type = %d\n", item->type);
Printf("name = %s\n", item->name);
Printf("flags = %d\n", item->flags);
Printf("parent = %p\n", item->parent);
Printf("previous = %p\n", item->previous);
Printf("next = %p\n", item->next);
Printf("data.generic_data = %p ", item->data.generic_data);
switch(item->type)
{
case hl_url:
{
Printf("URL(%s)\n", item->data.url);
}
break;
case hl_directory:
{
Printf("sub directory pointer\n");
}
break;
default:
{
Printf("\n");
}
break;
}
}
/*************************************************/
/* hotlist_display_tree() */
/* */
/* Recursivly display the hotlist tree starting */
/* from the passed item */
/* */
/* Parameters: Pointer to a hotlist_item */
/* value to start indent at */
/* recommended 0 */
/*************************************************/
static void hotlist_display_tree(hotlist_item * list, int indent)
{
int count;
Printf("\nhotlist_display_tree for %p, indent %d\n", list, indent);
Printf("--------------------\n\n");
while (list)
{
for (count = 0; count < indent; count++) Printf("| ");
switch (list->type)
{
case hl_url:
{
Printf("%s:URL(%s)\n", list->name, list->data.url);
}
break;
case hl_directory:
{
Printf("%s:DIRECTORY", list->name);
}
if (list->flags & HOTLIST_D_IS_OPEN)
{
Printf(" (Open)\n");
hotlist_display_tree(list->data.directory_content, indent + 1);
}
else
{
Printf(" (Closed)\n");
hotlist_display_tree(list->data.directory_content, indent + 1);
}
break;
default:
{
Printf("%s:UNRECOGNISED TYPE\n", list->name);
}
break;
}
list = list->next;
}
}
#endif
// /*************************************************/
// /* hotlist_is_inside() */
// /* */
// /* Checks if one hotlist_item is held inside */
// /* the directory structure of another */
// /* hotlist_item */
// /* */
// /* Parameters: Pointer to the hotlist_item that */
// /* may be inside the parent; */
// /* */
// /* Pointer to the parent */
// /* hotlist_item. */
// /* */
// /* Returns: 1 if item is inside, else 0. */
// /*************************************************/
//
// static int hotlist_is_inside(hotlist_item * inside, hotlist_item * outside)
// {
// while (inside)
// {
// if (inside == outside) return 1;
// inside = inside->parent;
// }
//
// return 0;
// }
/*************************************************/
/* hotlist_link() */
/* */
/* This function links the passed item to the */
/* passed target. */
/* */
/* It can link the item in four different ways; */
/* before or after the target, or if the target */
/* is a directory, at the beginning or end of */
/* that directory's contents. */
/* */
/* Parameters: Pointer to the hotlist_item */
/* struct to link in; */
/* */
/* Pointer to the hotlist_item */
/* struct to link to; */
/* */
/* Position to link to - */
/* HOTLIST_POSITION_BEGINNING */
/* HOTLIST_POSITION_END */
/* HOTLIST_POSITION_BEFORE or */
/* HOTLIST_POSITION_AFTER. */
/* */
/* Assumes: The item and target pointers are */
/* not NULL and are valid; */
/* */
/* That if adding to the beginning */
/* or end, the target is a directory */
/* (in both cases, an error will be */
/* raised in TRACE builds if the */
/* assumptions are violated). */
/*************************************************/
static _kernel_oserror * hotlist_link(hotlist_item * item, hotlist_item * target, unsigned int position)
{
#ifdef TRACE
/* Test certain basic assumptions are not violated */
if (!item || !target)
{
erb.errnum = Utils_Error_Custom_Normal;
strcpy(erb.errmess, "NULL hotlist item or target pointer in hotlist_link");
show_error_ret(&erb);
return NULL;
}
if (
(
position == HOTLIST_POSITION_BEGINNING ||
position == HOTLIST_POSITION_END
)
&& target->type != hl_directory
)
{
erb.errnum = Utils_Error_Custom_Normal;
strcpy(erb.errmess, "Cannot insert at item at the beginning or end when the target is not a directory, in hotlist_link");
show_error_ret(&erb);
return NULL;
}
#endif
switch (position)
{
case HOTLIST_POSITION_BEFORE:
{
/* Simple insertion above the target item */
item->next = target;
item->previous = target->previous;
item->parent = target->parent;
target->previous = item;
if (item->previous) item->previous->next = item;
if (item->parent && item->parent->data.directory_content == target) item->parent->data.directory_content = item;
}
break;
default: /* We'll allow a default to adding after the target item */
case HOTLIST_POSITION_AFTER:
{
/* Again, a simple insertion after the target item */
item->previous = target;
item->next = target->next;
item->parent = target->parent;
target->next = item;
if (item->next) item->next->previous = item;
}
break;
case HOTLIST_POSITION_BEGINNING:
{
/* A bit harder - insert at the top of a directory. */
/* First a quick sanity check - TRACE builds will */
/* already have faulted this, but For non-TRACE */
/* builds, at least this will stop things dying. */
if (target->type != hl_directory) return NULL;
/* This item is going to be at the beginning of a */
/* directory, so there is never a previous item. */
item->previous = NULL;
/* The next item is the one that used to be at the top */
/* of the directory, and the parent for this item will */
/* obviously be the target. */
item->next = target->data.directory_content;
item->parent = target;
/* If we have a next item, make sure its previous field */
/* now points to the new item at the top. */
if (item->next) item->next->previous = item;
/* The target should point to the new top item, too. */
target->data.directory_content = item;
}
break;
case HOTLIST_POSITION_END:
{
hotlist_item * last;
/* Similarly, add to the end of the directory */
if (target->type != hl_directory) return NULL;
/* As before the parent must be the target item */
item->parent = target;
/* Now look from the start of the directory downwards for */
/* the last item currently present. */
last = target->data.directory_content;
while(last && last->next) last = last->next;
/* The new item must point to that one as in its previous field, */
/* and has no next item to point to. */
item->previous = last;
item->next = NULL;
if (last)
{
/* If there were any items in the directory, make sure that the */
/* last one points to the new bottom entry. */
last->next = item;
}
else
{
/* Otherwise, the parent directory should point to this item */
target->data.directory_content = item;
}
}
break;
}
/* Finished... */
return NULL;
}
/*************************************************/
/* hotlist_unlink() */
/* */
/* This function unlinks the passed item from */
/* the items linked in before and after it. */
/* */
/* Parameters: Pointer to the hotlist_item */
/* struct to remove. */
/*************************************************/
static void hotlist_unlink(hotlist_item *item)
{
if (item->parent && item->parent->data.directory_content == item) item->parent->data.directory_content = item->next;
if (item->previous) item->previous->next = item->next;
if (item->next) item->next->previous = item->previous;
/* Not strictly needed, but added to ensure robustness */
item->next = NULL;
item->previous = NULL;
item->parent = NULL;
}
/*************************************************/
/* hotlist_new_directory() */
/* */
/* This function creates a new directory */
/* at the beginning of the given parent. */
/* */
/* Parameters: Pointer to a hotlist_item of type */
/* directory that represents the */
/* parent item for this new entry; */
/* */
/* Name of new directory to create; */
/* */
/* Position to create the new item */
/* relative to the parent (as for */
/* hotlist_link); */
/* */
/* Pointer to a pointer to a */
/* hotlist_item struct, which will */
/* be filled in with the address of */
/* the new item (unless there is an */
/* error returned). */
/* */
/* Assumes: That the pointer to a pointer to */
/* a hotlist_item struct is not NULL */
/* (it would make little sense to */
/* allow this...). */
/*************************************************/
static _kernel_oserror * hotlist_new_directory(hotlist_item * parent, char * directory_name, unsigned int position, hotlist_item ** new)
{
char * perm_dirname;
hotlist_item * item;
_kernel_oserror * e;
int is_untitled = 0;
if (!directory_name) is_untitled = 1;
else
{
while (*directory_name && *directory_name <= ' ') directory_name ++;
if (!*directory_name) is_untitled = 1;
else
{
int len = strlen(directory_name);
while (len && directory_name[len - 1] <= ' ') len--;
if (!len) is_untitled = 1;
else directory_name[len] = '\0';
}
}
if (is_untitled) directory_name = lookup_token("HotlistUntitled:(Untitled)",0,0);
/* Allocate space for the item and its name */
item = malloc(sizeof(hotlist_item));
if (!item) return make_no_memory_error(4);
perm_dirname = malloc(strlen(directory_name) + 1);
if (!perm_dirname)
{
free(item);
return make_no_memory_error(5);
}
/* Copy the name into the new buffer */
strcpy(perm_dirname, directory_name);
/* Initialise the new hotlist item */
item->type = hl_directory;
item->flags = DIRECTORY_FLAGS;
item->name = perm_dirname;
item->data.directory_content = NULL;
if (parent)
{
/* If we have been given a parent item, link this new */
/* directory to it. */
e = hotlist_link(item, parent, position);
/* If there's an error, free the item structure and name, */
/* and return that error. */
if (e)
{
free(item);
free(perm_dirname);
return e;
}
}
else
{
/* If there's no parent item, fill the various pointers */
/* to other things in the list with NULL. */
item->next = NULL;
item->previous = NULL;
item->parent = NULL;
}
/* Record the new item in the hotlist_newitem static */
hotlist_newitem = item;
/* Return the address of the new item and exit */
*new = item;
return NULL;
}
/*************************************************/
/* hotlist_new_url() */
/* */
/* This function creates a new url */
/* at the end of the passed directory */
/* */
/* Parameters: Pointer to a hotlist_item struct */
/* representing a directory to add */
/* the URL to; */
/* */
/* Position within that directory */
/* to link to (number of items from */
/* the start); */
/* */
/* Description of the URL (e.g. from */
/* the page title); */
/* */
/* Pointer to the URL itself. */
/*************************************************/
static _kernel_oserror * hotlist_new_url(hotlist_item * parent, unsigned int position, char * url_desc, char * url)
{
char * perm_url_desc;
char * perm_url;
hotlist_item * item;
_kernel_oserror * e;
/* Do we have a URL string? */
if (!url) return NULL;
while (*url && *url <= ' ') url++;
if (!*url) return NULL;
/* Do we have a useful title string? */
if (!url_desc) url_desc = url;
else
{
while (*url_desc && *url_desc <= ' ') url_desc ++;
if (!*url_desc) url_desc = url;
else
{
int len = strlen(url_desc) - 1;
while (len && url_desc[len] <= ' ') len--;
if (!len) url_desc = url;
else url_desc[len + 1] = '\0';
}
}
/* Allocate a new hotlist_item structure */
if ((item = malloc(sizeof(hotlist_item))) == NULL)
{
#ifdef TRACE
if (tl & (1<<25)) Printf("hotlist_new_url: Could not allocate room for new URL item\n");
#endif
goto hotlist_new_url_no_memory; /* See bottom of function */
}
/* Allocate space for the description string */
perm_url_desc = malloc(strlen(url_desc) + 1);
if (perm_url_desc == NULL) goto hotlist_new_url_no_memory; /* See bottom of function */
/* Allocate space for the URL */
perm_url = malloc(strlen(url) + 1);
if (perm_url == NULL)
{
free(perm_url_desc);
goto hotlist_new_url_no_memory; /* See bottom of function */
}
/* Copy the given description and URL to the allocated space */
strcpy(perm_url_desc, url_desc);
strcpy(perm_url, url);
/* Fill in miscellaneous parts of the hotlist_item structure */
item->type = hl_url;
item->flags = URL_FLAGS;
item->name = perm_url_desc;
item->data.url = perm_url;
/* Link the item to the rest of the hotlist */
e = hotlist_link(item, parent, position);
if (e)
{
free(item);
free(perm_url_desc);
free(perm_url);
return e;
}
/* Remember which item was added in the hotlist_newitem static */
/* and exit with no error. */
hotlist_newitem = item;
return NULL;
/* Code for a common error case */
hotlist_new_url_no_memory:
erb.errnum = Utils_Error_Custom_Normal;
StrNCpy0(erb.errmess,
lookup_token("NoMemURL:There is not enough free memory to add another URL to the hotlist.",
0,
0));
return &erb;
}
/*************************************************/
/* hotlist_delete_item() */
/* */
/* This function deletes an item from the */
/* hotlist structure; it will recursively delete */
/* directories. */
/* */
/* Parameters: Pointer to the hotlist_item */
/* struct to delete. */
/*************************************************/
static void hotlist_delete_item(hotlist_item * item)
{
if (item)
{
switch (item->type)
{
/* For a URL item, unlink it from the list */
/* and free associated memory. */
case hl_url:
{
hotlist_unlink(item);
free(item->name);
free(item->data.url);
free(item);
}
break;
case hl_directory:
{
/* Recursively delete all items in the directory */
while (item->data.directory_content)
{
hotlist_delete_item(item->data.directory_content);
}
/* Now unlink the item */
hotlist_unlink(item);
/* Free associated memory */
free(item);
free(item->name);
}
break;
default:
{
#ifdef TRACE
/* A 'should never happen' case! */
erb.errnum = Utils_Error_Custom_Message;
strcpy(erb.errmess, "Unrecognised item type in hotlist_delete_item - possibly memory corruption?");
show_error_ret(&erb);
#endif
}
break;
}
}
}
/*************************************************/
/* hotlist_move_item() */
/* */
/* This function takes an item and moves its */
/* position within the directory tree. */
/* */
/* Parameters: Pointer to the hotlist_item */
/* struct to move; */
/* */
/* Pointer to the hotlist_item */
/* structure to move to; */
/* */
/* Position relative to that struct */
/* for the item to go to, as for */
/* hotlist_link. */
/* */
/* Assumes: It is assumed that if the object */
/* is a directory it is not being */
/* moved into it self or one of its */
/* children. If this is not the case */
/* then both it and its children */
/* will become unlinked from the */
/* hotlist structure (nasty...!). */
/*************************************************/
static _kernel_oserror * hotlist_move_item(hotlist_item * source, hotlist_item * target, unsigned int position)
{
hotlist_item * newdir, * tempptr;
/* If the item is read only, don't move it; copy instead. */
if (source->flags & HOTLIST_G_IS_READ_ONLY)
{
return hotlist_copy_item(source, target, position, NULL);
}
/* Otherwise, moving it is OK */
if (!(source->type == hl_directory && !hotlist_contents_selected(source->data.directory_content)))
{
/* Unlink item from directory structure */
hotlist_unlink(source);
/* Link into new position in directory structure */
return hotlist_link(source, target, position);
}
else
{
/* Special case - moving a directory whose contents are only partially selected. */
/* We can't move a directory whose contents are only partially to be moved, */
/* there would be nowhere to leave the items which were not moved with it. */
/* So, create a new directory based on the old */
RetError(hotlist_new_directory(target, source->name, position, &newdir));
/* Move the contents recursively into the new directory */
source = source->data.directory_content;
while (source)
{
tempptr = source->next;
if (source->flags & HOTLIST_G_IS_SELECTED)
{
hotlist_move_item(source, newdir, HOTLIST_POSITION_END);
source->flags &= ~HOTLIST_G_IS_SELECTED;
}
source = tempptr;
}
}
return NULL;
}
/*************************************************/
/* hotlist_copy_item() */
/* */
/* This function copies an item, and in the case */
/* of it being a directory, its children, to the */
/* specified place. */
/* */
/* Parameters: Pointer to the hotlist_item */
/* struct to copy; */
/* */
/* Pointer to the hotlist_item */
/* struct to copy to; */
/* */
/* Position relative to that item to */
/* copy to, as for hotlist_link; */
/* */
/* Pointer to a pointer to a */
/* hotlist_item struct, in which the */
/* address of the new item is */
/* returned. */
/* */
/* Assumes: It is assumed that if the object */
/* is a directory it is not being */
/* copied into it self or one of its */
/* children - if it is the function */
/* will keep recursing and */
/* eventually run out of stack; */
/* */
/* The pointer to the pointer to the */
/* hotlist_item struct may be NULL. */
/*************************************************/
static _kernel_oserror * hotlist_copy_item(hotlist_item * source, hotlist_item * target,
unsigned int position, hotlist_item ** new_item)
{
hotlist_item * newdir;
newdir = NULL;
switch(source->type)
{
/* For a URL, create a new item based on the source one */
case hl_url:
{
RetError(hotlist_new_url(target, position, source->name, source->data.url));
}
break;
/* For a directory, first create a new item based on the source one */
case hl_directory:
{
hotlist_item * content;
RetError(hotlist_new_directory(target, source->name, position, &newdir));
/* Now copy the contents recursively */
content = source->data.directory_content;
while (content)
{
if (content->flags & HOTLIST_G_IS_SELECTED)
{
RetError(hotlist_copy_item(content, newdir, HOTLIST_POSITION_END, NULL));
}
content = content->next;
}
}
break;
}
/* Fill in the new_item return value */
if (new_item)
{
if (newdir) *new_item = newdir;
else *new_item = hotlist_newitem;
}
return NULL;
}
/*************************************************/
/* hotlist_get_entry_sizes() */
/* */
/* This function reads the size of the sprites */
/* to be used by the hotlist and from them */
/* determines the size of the hotlist entries. */
/* */
/* Parameters: Pointer to an int, in which the */
/* height of an item is placed in */
/* OS units; */
/* */
/* Pointer to an int, in which the */
/* minimum width of a directory item */
/* is returned, in OS units; */
/* */
/* Pointer to an int, in which the */
/* minimum width of a URL item is */
/* returned, in OS units. */
/* */
/* Assumes: Any of the pointers may be NULL. */
/*************************************************/
static _kernel_oserror * hotlist_get_entry_sizes(unsigned int * item_height, unsigned int * item_dir_width, unsigned int * item_url_width)
{
int width, height;
/* Get the open directory sprite size */
RetError(read_sprite_size(OPEN_DIRECTORY_SPRITE, &width, &height));
/* Use this for the minimum width of a directory entry */
/* and the height of an item. */
if (item_dir_width) *item_dir_width = width;
if (item_height) *item_height = height;
/* Now read the closed sprite; if the size is greater */
/* than the width or height found above, use the new */
/* sizes instead. */
RetError(read_sprite_size(CLOSED_DIRECTORY_SPRITE, &width, &height));
if (item_height && height > *item_height) *item_height = height;
if (item_dir_width && width > *item_dir_width) *item_dir_width = width;
/* Similarly for the insert item sprite. */
RetError(read_sprite_size(INSERT_DIRECTORY_SPRITE, &width, &height));
if (item_height && height > *item_height) *item_height = height;
if (item_dir_width && width > *item_dir_width) *item_dir_width = width;
/* Find the URL sprite size, and if required increase the */
/* minimum entry height again based on this. */
RetError(read_sprite_size(URL_SPRITE, &width, &height));
if (item_height && height > *item_height) *item_height= height;
/* Set the URL width to the value found above and add 8 to */
/* all of them for aesthetics. */
if (item_url_width) *item_url_width = width + 8;
if (item_dir_width) *item_dir_width += 8;
if (item_height) *item_height += 8;
return NULL;
}
/*************************************************/
/* hotlist_set_flags() */
/* */
/* This function will recursively set flags for */
/* either a specified type of hotlist_item or */
/* all hotlist_items, to the given value. All */
/* items which are changed will have their */
/* HOTLIST_G_REDRAW_NOW bit set. */
/* */
/* Parameters: Pointer to a hotlist_item struct */
/* to start on; */
/* */
/* Type of hotlist_item to set flags */
/* for, or hl_ALL for all types; */
/* */
/* Flags to set. */
/* */
/* Returns: 1 if any flags were set, else 0. */
/*************************************************/
static int hotlist_set_flags(hotlist_item * list, hotlist_type type, unsigned int flags)
{
int changed = 0;
while (list)
{
/* Alter all items, or those of the correct type */
if (type == hl_ALL || type == list->type)
{
if (list->flags | flags != list->flags)
{
list->flags |= HOTLIST_G_REDRAW_NOW;
changed = 1;
}
list->flags |= flags;
}
/* Recursive call for directories */
if (list->type == hl_directory)
{
if (hotlist_set_flags(list->data.directory_content, type, flags)) changed = 1;
}
list = list->next;
}
return changed;
}
/*************************************************/
/* hotlist_clear_flags() */
/* */
/* This function will recursively clear flags */
/* for either a specified type of hotlist_item */
/* or all hotlist_items. All items changed will */
/* have their HOTLIST_G_REDRAW_NOW bit set, */
/* unless, of course, the routine is called to */
/* clear that bit. */
/* */
/* Parameters: Pointer to a hotlist_item struct */
/* to start on; */
/* */
/* Type of hotlist_item to set flags */
/* for, or hl_ALL for all types; */
/* */
/* Flags clear word (any bits set in */
/* this word are cleared in the item */
/* flags). */
/* */
/* Returns: 1 if flags were cleared, else 0. */
/*************************************************/
static int hotlist_clear_flags(hotlist_item * list, hotlist_type type, unsigned int flags)
{
int changed = 0;
while (list)
{
/* Only alter the requested item types */
if (type == hl_ALL || type == list->type)
{
if ((list->flags & ~flags) != list->flags)
{
list->flags |= HOTLIST_G_REDRAW_NOW;
changed = 1;
}
list->flags &= ~flags;
}
/* Recursive call for directories */
if (list->type == hl_directory)
{
if (hotlist_clear_flags(list->data.directory_content, type, flags)) changed = 1;
}
list = list->next;
}
return changed;
}
/*************************************************/
/* hotlist_find_item() */
/* */
/* This function will recursivly scan through */
/* a hotlist structure and return a pointer to */
/* the n'th item. It will only recurse through */
/* open directories. */
/* */
/* Parameters: Pointer to a hotlist_item at the */
/* top of the directory to scan; */
/* */
/* The nth item to return within it. */
/* */
/* Returns: Pointer to the requested item or */
/* NULL if it does not exist. */
/*************************************************/
static hotlist_item * hotlist_find_item(hotlist_item * list, unsigned int item_no)
{
int curr_item = 0;
return hotlist_find_item_r(list, item_no, &curr_item);
}
/*************************************************/
/* hotlist_find_item_r() */
/* */
/* Recursive back-end to hotlist_find_item. */
/* */
/* Parameters: Pointer to a hotlist_item at the */
/* top of the directory to scan; */
/* */
/* The nth item to return within it; */
/* */
/* Pointer to an int, in which the */
/* number of the current item is */
/* accumulated (initialised to an */
/* appropriate value, usually 0). */
/* */
/* Returns: As hotlist_find_item. */
/* */
/* Assumes: The pointer to the int may *not* */
/* be NULL. */
/*************************************************/
static hotlist_item * hotlist_find_item_r(hotlist_item * list, unsigned int item_no, int * curr_item)
{
hotlist_item * temp;
while (list)
{
if (*curr_item == item_no) return list; /* Found the list item */
/* Increment the item counter */
*curr_item += 1;
/* Recursively scan open directories */
if (list->type == hl_directory && list->flags & HOTLIST_D_IS_OPEN)
{
temp = hotlist_find_item_r(list->data.directory_content, item_no, curr_item);
if (temp) return temp;
}
/* Move to the next list item */
list = list->next;
}
return NULL; /* List does not extend far enough */
}
/*************************************************/
/* hotlist_find_no_from_item() */
/* */
/* This function will recursivly scan through */
/* a hotlist structure and return the position */
/* of the specified item. It will only recurse */
/* through open directories. */
/* */
/* Parameters: Pointer to a hotlist_item to */
/* start at; */
/* */
/* Pointer to the item whos position */
/* is to be returned. */
/* */
/* Returns: The item position or -1 if it is */
/* not found. */
/*************************************************/
static int hotlist_find_no_from_item(hotlist_item * item)
{
int curr_item = 0;
return hotlist_find_no_from_item_r(hotlist_root->data.directory_content, item, &curr_item);
}
/*************************************************/
/* hotlist_find_no_from_item_r() */
/* */
/* Recursive back-end to */
/* hotlist_find_no_from_item. */
/* */
/* Parameters: Pointer to a hotlist_item to */
/* start at; */
/* */
/* Pointer to the item whos position */
/* is to be returned; */
/* */
/* Pointer to an int, in which the */
/* number of the current item is */
/* accumulated (initialised to an */
/* appropriate value, usually 0). */
/* */
/* Returns: As hotlist_find_no_from_item. */
/* */
/* Assumes: The pointer to the int may *not* */
/* be NULL. */
/*************************************************/
static int hotlist_find_no_from_item_r(hotlist_item * list, hotlist_item * item, int * curr_item)
{
/* Start the search at the given item */
while (list)
{
if (item == list) return *curr_item; /* Found the list item */
*curr_item += 1;
/* Recursively scan open directories */
if (list->type == hl_directory && list->flags & HOTLIST_D_IS_OPEN)
{
int found;
found = hotlist_find_no_from_item_r(list->data.directory_content, item, curr_item);
if (found >= 0) return found;
}
/* Move to the next item */
list = list->next;
}
/* Didn't find it */
return -1;
}
/*************************************************/
/* hotlist_find_selected_item() */
/* */
/* This function returns a pointer to the first */
/* selected item found. */
/* */
/* Returns: Pointer to a hotlist_item struct */
/* which was the first selected item */
/* found in a search starting */
/* from the root, or NULL if there */
/* is nothing selected. */
/*************************************************/
hotlist_item * hotlist_find_selected_item(void)
{
return hotlist_find_selected_item_r(hotlist_root);
}
/*************************************************/
/* hotlist_find_selected_item_r() */
/* */
/* Recursive back-end to */
/* hotlist_find_selected_item. */
/* */
/* Parameters: Pointer to a hotlist_item */
/* struct to start at. */
/* */
/* Returns: As hotlist_find_selected_item. */
/*************************************************/
static hotlist_item * hotlist_find_selected_item_r(hotlist_item * list)
{
while (list)
{
if (list->flags & HOTLIST_G_IS_SELECTED) return list; /* Found it */
/* Recursively scan all directories */
if (list->type == hl_directory)
{
hotlist_item * found;
found = hotlist_find_selected_item_r(list->data.directory_content);
if (found) return found;
}
/* Move to the next item */
list = list->next;
}
/* Didn't find it */
return NULL;
}
/*************************************************/
/* hotlist_count_selected_items() */
/* */
/* Count the number of items that are currently */
/* selected in the hotlist window. */
/* */
/* If you want to know if all items are selected */
/* use hotlist_contents_selected. If you want to */
/* know if no items are selected, it is faster */
/* to use hotlist_no_contents_selected than */
/* compare the return value of this function */
/* against zero (this function *must* scan all */
/* hotlist items, whereas the other can exit as */
/* soon as a selected item is found). */
/* */
/* Returns: The number of selected items. */
/*************************************************/
unsigned int hotlist_count_selected_items(void)
{
int count = 0;
hotlist_count_selected_items_r(hotlist_root->data.directory_content, &count);
return count;
}
/*************************************************/
/* hotlist_count_selected_items_r() */
/* */
/* Recursive back-end to */
/* hotlist_count_selected_items. */
/* */
/* Parameters: Pointer to a hotlist_item struct */
/* representing the first item in a */
/* directory to count; */
/* */
/* Pointer to an int, in which the */
/* total is accumulated. */
/* */
/* Assumes: The pointer to the int may *not* */
/* be NULL. */
/*************************************************/
static void hotlist_count_selected_items_r(hotlist_item * list, int * count)
{
while (list)
{
if (list->flags & HOTLIST_G_IS_SELECTED)
{
*count += 1;
}
else
{
/* Only recurse through directories which are not selected */
if (list->type == hl_directory)
{
hotlist_count_selected_items_r(list->data.directory_content, count);
}
}
list = list->next;
}
}
/*************************************************/
/* hotlist_count_displayed_items() */
/* */
/* This routine counts the number of items */
/* displayed in the hotlist window. */
/* */
/* Parameters: Pointer to a hotlist_item struct */
/* to start at. */
/* */
/* Returns: The number of displayed items. */
/*************************************************/
static unsigned int hotlist_count_displayed_items(hotlist_item * list)
{
int count = 0;
hotlist_count_displayed_items_r(list, &count);
return count;
}
/*************************************************/
/* hotlist_count_displayed_items_r() */
/* */
/* Recursive back-end to */
/* hotlist_count_displayed_items. */
/* */
/* Parameters: Pointer to a hotlist_item struct */
/* to start at; */
/* */
/* Pointer to an int, in which the */
/* total is accumulated. */
/* */
/* Assumes: The pointer to the int may *not* */
/* be NULL. */
/*************************************************/
static void hotlist_count_displayed_items_r(hotlist_item *list, int * count)
{
while (list)
{
/* Recursive scan for open directories */
if (list->type == hl_directory && list->flags & HOTLIST_D_IS_OPEN)
{
hotlist_count_displayed_items_r(list->data.directory_content, count);
}
list = list->next;
*count += 1;
}
}
/*************************************************/
/* hotlist_draw() */
/* */
/* Redraws a specified region of the hotlist. */
/* Assumes graphics rectangles are set up */
/* appropriately (e.g. the function is called */
/* during a Wimp redraw session). */
/* */
/* Parameters: Pointer to a hotlist_item giving */
/* the list that we're to draw; */
/* */
/* First item number to draw (count */
/* the visible items from the top of */
/* the window downwards starting at */
/* an item number of zero); */
/* */
/* Last item number to draw. */
/*************************************************/
static _kernel_oserror * hotlist_draw(hotlist_item * list, unsigned int first_item, unsigned int last_item)
{
int curr_item = 0;
unsigned int item_height, item_dir_width, item_url_width;
RetError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
return hotlist_draw_r(list,
first_item,
last_item,
&curr_item,
0,
item_height,
item_dir_width,
item_url_width);
}
/*************************************************/
/* hotlist_draw_r() */
/* */
/* Recursive back-end to hotlist_draw. */
/* */
/* Parameters: Pointer to a hotlist_item giving */
/* the list that we're to draw; */
/* */
/* First item number to draw (count */
/* the visible items from the top of */
/* the window downwards starting at */
/* an item number of zero); */
/* */
/* Last item number to draw; */
/* */
/* Pointer to an int, which is used */
/* to accumulate the current item */
/* number - the contents should be */
/* initialised to an appropriate */
/* value for the first three */
/* parameters (usually, zero); */
/* */
/* Level of indentation (OS units); */
/* */
/* Height of an item (OS units); */
/* */
/* Width of a directory item (OS */
/* units); */
/* */
/* Width of a URL item (OS units). */
/* */
/* Assumes: The pointer to the int may *not* */
/* be NULL. */
/*************************************************/
static _kernel_oserror * hotlist_draw_r(hotlist_item *list, unsigned int first_item, unsigned int last_item,
int * curr_item, unsigned int indent, unsigned int item_height,
unsigned int item_dir_width, unsigned int item_url_width)
{
WimpIconBlock icon;
unsigned int temp_width;
int text_width;
while (list)
{
/* Break out if done all items to be displayed */
if (*curr_item > last_item) return NULL;
/* Don't draw until we reach the required first item */
if (*curr_item >= first_item)
{
/* Construct an icon block for Wimp_PlotIcon. First, icon flags. */
icon.flags = HOTLIST_SPRITE_ICON_FLAGS;
if (((list->flags & HOTLIST_G_IS_SELECTED) ? 1 : 0) ^
((list->flags & HOTLIST_G_DRAG_SELECTED) ? 1 : 0)
) icon.flags |= WimpIcon_Selected;
/* Point to the main sprite pool */
icon.data.is.sprite_area = (void*) sprite_block;
/* Set type-dependent characteristics */
switch(list->type)
{
case hl_url:
{
/* A URL item; set the sprite name and item width accordingly */
icon.data.is.sprite = !(list->flags & HOTLIST_G_IS_READ_ONLY) ? URL_SPRITE : RESOURCES_URL_SPRITE;
icon.data.is.sprite_name_length = strlen(URL_SPRITE);
temp_width = item_url_width;
}
break;
case hl_directory:
{
/* Directories are a bit more complex, as they can be open, */
/* closed, or showing a '+' if a dragged item is hovering */
/* over it and would drop 'into' the directory if released. */
temp_width = item_dir_width; /* Width is based on the widest sprite of the three */
if (list->flags & HOTLIST_D_IS_HIGHLIGHTED)
{
/* The item is either selected (something is 'hovering' over it)... */
icon.data.is.sprite = INSERT_DIRECTORY_SPRITE;
icon.data.is.sprite_name_length = strlen(INSERT_DIRECTORY_SPRITE);
}
else
{
/* ...or unselected. In that case it is either open or closed. */
if (list->flags & HOTLIST_D_IS_OPEN)
{
icon.data.is.sprite = !(list->flags & HOTLIST_G_IS_READ_ONLY) ? OPEN_DIRECTORY_SPRITE : OPEN_RESOURCES_DIRECTORY_SPRITE;
}
else
{
icon.data.is.sprite = !(list->flags & HOTLIST_G_IS_READ_ONLY) ? CLOSED_DIRECTORY_SPRITE : CLOSED_RESOURCES_DIRECTORY_SPRITE;
}
icon.data.is.sprite_name_length = strlen(icon.data.is.sprite);
}
}
break;
default:
{
temp_width = 0; /* Should never happen... */
}
break;
}
/* Set the item bounding box appropriately */
icon.bbox.xmin = indent;
icon.bbox.xmax = indent + temp_width;
icon.bbox.ymin = -item_height * (*curr_item) - item_height;
icon.bbox.ymax = -item_height * (*curr_item);
/* Plot the item */
RetError(wimp_plot_icon(&icon));
/* We now need to plot the item text. First, get the width, */
/* taking the opportunity to point the icon that we'll plot */
/* to the appropriate text, too. */
if (list->type == hl_url && hl_show_urls)
{
/* If this is a URL item and we are to show URLs, then find */
/* the width of the URL rather than the description. */
RetError(utils_text_width(list->data.url, &text_width, 0));
/* Point to the URL text */
icon.data.it.buffer = list->data.url;
icon.data.it.buffer_size = strlen(list->data.url);
icon.data.it.validation = NULL;
}
else
{
/* Otherwise (any other item, or a URL item when we're showing */
/* descriptions) just find the name's width. */
RetError(utils_text_width(list->name, &text_width, 0));
/* Point to the description */
icon.data.it.buffer = list->name;
icon.data.it.buffer_size = strlen(list->name);
icon.data.it.validation = NULL;
}
/* Set the bounding box for the text. The hard coded */
/* constants are nothing critical - just aesthetics. */
icon.bbox.xmin = indent + temp_width + 2;
icon.bbox.xmax = indent + temp_width + 2 + text_width + 12;
icon.bbox.ymin = -item_height * (*curr_item) - item_height + 2;
icon.bbox.ymax = -item_height * (*curr_item) - 2;
/* Set the flags accordingly if the text is selected or unselected */
if (((list->flags & HOTLIST_G_IS_SELECTED) ? 1 : 0) ^
((list->flags & HOTLIST_G_DRAG_SELECTED) ? 1 : 0)) icon.flags = HOTLIST_TEXT_ICON_FLAGS_SELECTED;
else icon.flags = HOTLIST_TEXT_ICON_FLAGS_UNSELECTED;
/* Finally, plot the item. */
RetError(wimp_plot_icon(&icon));
}
/* Increment the item number */
*curr_item += 1;
/* Recursive redraw for directories */
if (list->type == hl_directory && list->flags & HOTLIST_D_IS_OPEN)
{
RetError(hotlist_draw_r(list->data.directory_content,
first_item,
last_item,
curr_item,
indent + item_dir_width,
item_height,
item_dir_width,
item_url_width));
}
/* Move on down the list */
list = list->next;
}
return NULL;
}
/*************************************************/
/* hotlist_get_max_width_r */
/* */
/* Recursive back-end to hotlist_get_max_width. */
/* */
/* Parameters: Pointer to a hotlist_item struct */
/* to start at; */
/* */
/* An indent in OS units, as for */
/* redrawing the hotlist; */
/* */
/* Pointer to an int, in which the */
/* width of the widest item so far */
/* is accumulated; */
/* */
/* Height of a hotlist item in OS */
/* units; */
/* */
/* Width of a hotlist directory */
/* sprite in OS units; */
/* */
/* Width of a hotlist URL sprite in */
/* OS units. */
/* */
/* Assumes: The pointer to the int may *not* */
/* be NULL. */
/*************************************************/
static _kernel_oserror * hotlist_get_max_width_r(hotlist_item *list, unsigned int indent, int * max_width,
unsigned int item_height, unsigned int item_dir_width, unsigned int item_url_width)
{
_kernel_oserror * e;
unsigned int item_width;
int text_width;
while (list)
{
/* Get width of the icon */
switch (list->type)
{
case hl_directory: item_width = item_dir_width; break;
case hl_url: item_width = item_url_width; break;
default: item_width = 0; break;
}
/* Work out width of the text */
if (list->type == hl_url && hl_show_urls) e = utils_text_width(list->data.url, &text_width, 0);
else e = utils_text_width(list->name, &text_width, 0);
if (e) return e;
/* Account for the indent and spacers (aesthetics) */
item_width += indent + 2 + text_width + 12;
/* If this is wider than so far recorded, store the new value */
if (item_width > *max_width) *max_width = item_width;
/* Recursive call for open directories */
if (list->type == hl_directory && list->flags & HOTLIST_D_IS_OPEN)
{
RetError(hotlist_get_max_width_r(list->data.directory_content,
indent + item_dir_width,
max_width,
item_height,
item_dir_width,
item_url_width));
}
/* Move on down the list */
list = list->next;
}
return NULL;
}
/*************************************************/
/* hotlist_get_max_width() */
/* */
/* This function returns the maximum width of */
/* of the displayed hotlist entries. */
/* */
/* Parameters: Pointer to a hotlist_item struct */
/* to start at. This is assumed to */
/* be at zero indent from the left */
/* hand side. */
/* */
/* Returns: Of all visible entries, the width */
/* of the widest, in OS units. */
/*************************************************/
static unsigned int hotlist_get_max_width(hotlist_item * list)
{
unsigned int item_height, item_dir_width, item_url_width;
int widest = 0;
/* Find basic item size information */
if (hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width)) return 0;
/* Scan the directory and all open directories with in it for */
/* the widest item */
if (hotlist_get_max_width_r(list,
0,
&widest,
item_height,
item_dir_width,
item_url_width)) return 0;
/* Return the result */
return widest;
}
/*************************************************/
/* hotlist_redraw_now() */
/* */
/* This function redraws all visible items with */
/* the HOTLIST_G_REDRAW_NOW bit set. */
/*************************************************/
static _kernel_oserror * hotlist_redraw_now(void)
{
int curr_item = 0;
return hotlist_redraw_now_r(hotlist_root->data.directory_content, &curr_item);
}
/*************************************************/
/* hotlist_redraw_now_r() */
/* */
/* Recursive back-end to hotlist_redraw_now. */
/* */
/* Parameters: Pointer to a hotlist_item struct */
/* to start on; */
/* */
/* Pointer to an int, in which the */
/* current item number being redrawn */
/* is accumulated. */
/* */
/* Assumes: The pointer to the int may *not* */
/* be NULL. */
/*************************************************/
static _kernel_oserror * hotlist_redraw_now_r(hotlist_item * list, int * curr_item)
{
while (list)
{
if (list->flags & HOTLIST_G_REDRAW_NOW)
{
/* Redraw just the one item */
RetError(hotlist_redraw_items(*curr_item, *curr_item));
/* Clear the flag */
list->flags &= ~HOTLIST_G_REDRAW_NOW;
}
*curr_item += 1;
if (list->type == hl_directory && list->flags & HOTLIST_D_IS_OPEN)
{
/* Recursive call for open directories */
RetError(hotlist_redraw_now_r(list->data.directory_content, curr_item));
}
list = list->next;
}
return NULL;
}
/*************************************************/
/* hotlist_add() */
/* */
/* Add a new URL to the hotlist. */
/* */
/* Parameters: Description of the URL (e.g. from */
/* the page title); */
/* */
/* Pointer to the URL itself; */
/* */
/* 0 to add to the top, 1 to add to */
/* the bottom. */
/*************************************************/
_kernel_oserror * hotlist_add(char * description, char * url, int at_bottom)
{
_kernel_oserror * e = NULL;
int position;
hotlist_item * target;
int type;
target = hotlist_find_selected_item();
if (!target)
{
position = at_bottom ? HOTLIST_POSITION_END : HOTLIST_POSITION_BEGINNING;
target = hotlist_root;
type = 1;
/* If adding to the beginning of the hotlist, skip any */
/* read-only items at the top first. */
if (position == HOTLIST_POSITION_BEGINNING)
{
hotlist_item * check = target->data.directory_content;
/* Look for something not read-only */
while (check && check->next)
{
if (check->next->flags & HOTLIST_G_IS_READ_ONLY) check = check->next;
else break;
}
if (check && (check->flags & HOTLIST_G_IS_READ_ONLY))
{
position = HOTLIST_POSITION_AFTER;
target = check;
}
}
}
else
{
if (target->type == hl_directory)
{
position = HOTLIST_POSITION_BEGINNING;
}
else
{
position = HOTLIST_POSITION_AFTER;
}
type = 2;
}
/* Add the item and ensure the window extent etc. is correct */
e = hotlist_new_url(target,
position,
description,
url);
if (!e) hotlist_preopen();
/* Optimise the redraw to do as little as possible depending */
/* upon where in the list the item was added. */
switch (position)
{
default:
case HOTLIST_POSITION_END:
{
hotlist_redraw_now();
}
break;
case HOTLIST_POSITION_BEGINNING:
{
if (type == 1)
{
hotlist_redraw_items(0,
hotlist_count_displayed_items(hotlist_root->data.directory_content));
}
else
{
if (target->flags & HOTLIST_D_IS_OPEN)
{
hotlist_redraw_items(hotlist_find_no_from_item(target),
hotlist_count_displayed_items(hotlist_root->data.directory_content));
}
}
}
break;
case HOTLIST_POSITION_BEFORE:
case HOTLIST_POSITION_AFTER:
{
hotlist_redraw_items(hotlist_find_no_from_item(hotlist_newitem),
hotlist_count_displayed_items(hotlist_root->data.directory_content));
}
}
if (!e) return hotlist_modified(HL_MODIFIED_ADD);
return e;
}
/*************************************************/
/* hotlist_get_shape() */
/* */
/* This function calculates the xmin and xmax */
/* of the passed hotlist_item. */
/* */
/* Parameters: Pointer to an int, in which the */
/* xmin offset (in OS units) from */
/* the left hand edge is returned; */
/* */
/* Similarly, a pointer to an int to */
/* take the xmax offset; */
/* */
/* Pointer to the hotlist_item to */
/* examine. */
/* */
/* Assumes: Any pointer may be NULL. */
/*************************************************/
static _kernel_oserror * hotlist_get_shape(int * xmin, int * xmax, hotlist_item * item)
{
hotlist_item * tempitem;
unsigned int item_height, item_dir_width, item_url_width;
int icon_width;
int text_width;
int count = 0;
if (xmin) *xmin = 0;
if (xmax) *xmax = 0;
if (!item) return NULL;
/* Find entry sizes */
RetError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
/* Count how many parent items we have. This allows */
/* the left hand indent to be calculated. */
tempitem = item;
while (tempitem)
{
tempitem = tempitem->parent;
count++;
}
count -= 2;
/* Find the text width */
if (item->type == hl_url && hl_show_urls) utils_text_width(item->data.url, &text_width, 0);
else utils_text_width(item->name, &text_width, 0);
/* Add in the sprite width */
switch (item->type)
{
case hl_directory: icon_width = item_dir_width;
break;
case hl_url: icon_width = item_url_width;
break;
default: icon_width = 0;
break;
}
/* Add up the total and exit */
if (xmin) *xmin = count * item_dir_width;
if (xmax) *xmax = count * item_dir_width + icon_width + 2 + text_width + 12;
return NULL;
}
/*************************************************/
/* hotlist_directory_open_close() */
/* */
/* This function opens or closes a directory, */
/* dealing with all required redrawing. */
/* */
/* Parameters: Pointer to the hotlist_item */
/* struct representing the directory */
/* to open or close; */
/* */
/* Number of that item (counting the */
/* visible hotlist items from the */
/* top of the window downwards, */
/* starting at zero). */
/*************************************************/
static _kernel_oserror * hotlist_directory_open_close(hotlist_item * item, unsigned int itemno)
{
unsigned int item_height, item_dir_width, item_url_width;
int top, window_handle;
BBox bbox;
RetError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
/* Swap the flag saying whether the directory is open or not */
item->flags ^= HOTLIST_D_IS_OPEN;
/* Clear all selected items within the directory */
hotlist_clear_flags(item->data.directory_content, hl_ALL, HOTLIST_G_IS_SELECTED | HOTLIST_G_REDRAW_NOW);
/* Do the appropriate redrawing */
hotlist_preopen();
RetError(window_get_wimp_handle(0, hotlist_windowid, &window_handle));
RetError(window_get_extent(0, hotlist_windowid, &bbox));
top = -itemno * item_height;
if (item->data.directory_content)
{
RetError(wimp_force_redraw(window_handle,
bbox.xmin,
bbox.ymin,
bbox.xmax,
top));
}
else
{
RetError(wimp_force_redraw(window_handle,
bbox.xmin,
top-item_height,
bbox.xmax,
top));
}
return NULL;
}
/*************************************************/
/* hotlist_redraw_items() */
/* */
/* This function forces the redraw of a set of */
/* items. */
/* */
/* Parameters: Item number of the first item to */
/* redraw (counting the visible */
/* items from the top of the window */
/* downwards, starting at zero) - */
/* this is inclusive; */
/* */
/* Item number of the last item to */
/* redraw (also inclusive). */
/*************************************************/
static _kernel_oserror * hotlist_redraw_items(unsigned int firstitem, unsigned int lastitem)
{
unsigned int item_height, item_dir_width, item_url_width;
BBox bbox;
int window_handle;
/* Get the entry sizes */
RetError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
/* Find the window extent */
RetError(window_get_wimp_handle(0, hotlist_windowid, &window_handle));
RetError(window_get_extent(0, hotlist_windowid, &bbox));
/* Force a redraw for the whole extent width, over a vertical */
/* span determined by the given item numbers. */
return wimp_force_redraw(window_handle,
bbox.xmin,
- (lastitem + 1) * item_height,
bbox.xmax,
- firstitem * item_height);
}
/*************************************************/
/* hotlist_clear_selection() */
/* */
/* This function unselects all items, redrawing */
/* as required. */
/*************************************************/
_kernel_oserror * hotlist_clear_selection(void)
{
if (
hotlist_clear_flags(hotlist_root->data.directory_content,
hl_ALL,
HOTLIST_G_IS_SELECTED)
)
return hotlist_redraw_now();
return NULL;
}
/*************************************************/
/* hotlist_launch_url() */
/* */
/* This function launches the url in the passed */
/* item. */
/* */
/* Parameters: Pointer to a hotlist_item struct */
/* holding the URL to launch. */
/*************************************************/
static _kernel_oserror * hotlist_launch_url(hotlist_item * item)
{
#ifdef TRACE
if (tl & (1u<<25)) hotlist_display_item(item);
#endif
return windows_create_browser(item->data.url, NULL, NULL, NULL, Windows_CreateBrowser_Normal);
}
/*************************************************/
/* hotlist_process_click_on_item() */
/* */
/* Deal with clicks on hotlist items. */
/* */
/* Parameters: Item number that was clicked upon */
/* (counting visible items from the */
/* top of the window downwards, */
/* starting with item number 0); */
/* */
/* Pointer to a hotlist_item struct */
/* representing the item clicked on; */
/* */
/* State of the mouse buttons, as */
/* Wimp_GetPointerInfo would return */
/* for clicks on a window of button */
/* type 10 (Double/Click/Drag); */
/* */
/* Screen x coordinate of the click; */
/* */
/* Screen y coordinate of the click. */
/*************************************************/
static _kernel_oserror * hotlist_process_click_on_item(unsigned int itemno, hotlist_item * item, int buttons, int x, int y)
{
_kernel_oserror * e = NULL;
switch (buttons)
{
/* The window button type is Double/Click/Drag, so */
/* this represents a double click with Select. */
case Wimp_MouseButtonSelect:
{
/* Open or close directories, open URLs in a new window */
if (last_selected_item == itemno)
{
switch(item->type)
{
case hl_directory: e = hotlist_directory_open_close(item, itemno);
break;
case hl_url: e = hotlist_launch_url(item);
break;
}
if (e) show_error_ret(e);
/* Deselect the item that was double-clicked upon */
item->flags &= ~HOTLIST_G_IS_SELECTED;
e = hotlist_redraw_items(itemno, itemno);
}
}
break;
/* Double-click with Adjust */
case Wimp_MouseButtonAdjust:
{
/* Open or close directories, but for URLs, open them in */
/* a new window and close the hotlist. */
if (last_selected_item == itemno)
{
switch(item->type)
{
case hl_directory: e = hotlist_directory_open_close(item, itemno);
break;
case hl_url:
{
e = hotlist_launch_url(item);
if (!e) toolbox_hide_object(0, hotlist_windowid);
}
break;
}
if (e) show_error_ret(e);
/* Deselect the item that was double-clicked upon */
item->flags &= ~HOTLIST_G_IS_SELECTED;
e = hotlist_redraw_items(itemno, itemno);
}
}
break;
/* Drag with Select */
case 64:
{
e = hotlist_start_drag();
}
break;
/* Drag with Adjust */
case 16:
{
/* If the item clicked upon wasn't selected, select it */
if (!(item->flags & HOTLIST_G_IS_SELECTED))
{
item->flags |= HOTLIST_G_IS_SELECTED;
last_selected_item = itemno;
}
/* Start the drag and redraw the item clicked upon */
e = hotlist_start_drag();
if (!e) e = hotlist_redraw_items(itemno, itemno);
}
break;
/* Click with Select */
case 1024:
{
if (!(item->flags & HOTLIST_G_IS_SELECTED)) /* (Do nothing when selected) */
{
/* Clear the selected flags of everything else */
e = hotlist_clear_selection();
/* Select this item and if a directory, all items within it */
item->flags |= HOTLIST_G_IS_SELECTED | HOTLIST_G_REDRAW_NOW;
if (item->type == hl_directory) hotlist_set_flags(item->data.directory_content,
hl_ALL,
HOTLIST_G_IS_SELECTED);
/* Redraw to reflect the selection */
if (!e) e = hotlist_redraw_now();
}
last_selected_item = itemno;
}
break;
/* Click with Adjust */
case 256:
{
/* Swap the selected state of the item */
item->flags ^= HOTLIST_G_IS_SELECTED;
item->flags |= HOTLIST_G_REDRAW_NOW;
last_selected_item = itemno;
/* If a directory, select or deselect the contents */
if (item->type == hl_directory)
{
if (item->flags & HOTLIST_G_IS_SELECTED)
{
hotlist_set_flags(item->data.directory_content, hl_ALL, HOTLIST_G_IS_SELECTED);
}
else
{
hotlist_clear_flags(item->data.directory_content, hl_ALL, HOTLIST_G_IS_SELECTED);
}
}
/* Redraw to reflect the selection */
e = hotlist_redraw_now();
}
break;
}
/* Return any errors that may have been generated */
return e;
}
/*************************************************/
/* hotlist_process_click() */
/* */
/* This function deals with mouse clicks on the */
/* hotlist window. */
/* */
/* Parameters: X position of click, in window */
/* coords; */
/* */
/* Y position of click, in window */
/* coords; */
/* */
/* Button state (as returned by */
/* Wimp_GetPointerInfo). */
/*************************************************/
static _kernel_oserror * hotlist_process_click(int x, int y, int buttons)
{
_kernel_oserror * e = NULL;
hotlist_item * item;
unsigned int item_height, item_dir_width, item_url_width;
unsigned int itemno;
int xmin, xmax;
/* Get information on what was clicked upon */
RetError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
itemno = -y / item_height;
item = hotlist_find_item(hotlist_root->data.directory_content, itemno);
if (item) RetError(hotlist_get_shape(&xmin, &xmax, item));
if (item && x >= xmin && x <= xmax)
{
/* If we have a specific item, process the click on it */
return hotlist_process_click_on_item(itemno, item, buttons, x, y);
}
else
{
/* Otherwise, actions depend on the button type */
switch(buttons)
{
/* Drag with Select */
case 64:
{
RetError(hotlist_clear_selection());
e = hotlist_selection_box_start();
}
break;
/* Drag with Adjust */
case 16:
{
e = hotlist_selection_box_start();
}
break;
/* Click with Select */
case 1024:
{
e = hotlist_clear_selection();
last_selected_item = 0xffffffff;
}
break;
/* Click with Adjust */
case 256:
{
last_selected_item = 0xffffffff;
}
break;
}
}
return e;
}
/*************************************************/
/* hotlist_preopen() */
/* */
/* This function should be called before opening */
/* the hotlist window. If the window is already */
/* showing, then the extent may be altered but */
/* it will never shrink the visible area of the */
/* window. If the window is currently closed, it */
/* will set the extent to the minimum possible */
/* value, which may well drag the visible area */
/* down too. */
/* */
/* Returns: 1 if window was already open, */
/* or 0 if it was closed. */
/*************************************************/
static int hotlist_preopen(void)
{
_kernel_oserror * e;
WimpGetWindowStateBlock state;
BBox bbox;
ObjectId parent_id;
ComponentId parent_component;
unsigned int item_height, item_dir_width, item_url_width;
unsigned int number, maxlen;
unsigned int objectstate;
int height, width;
#define HotlistPreopen_ShowError(e) {if(e){show_error_ret(e);return 0;}}
/* Is the window open or closed? */
e = toolbox_get_object_state(0, hotlist_windowid, &objectstate);
HotlistPreopen_ShowError(e);
/* Get entry sizes */
e = hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width);
HotlistPreopen_ShowError(e);
/* General information */
number = hotlist_count_displayed_items(hotlist_root->data.directory_content);
maxlen = hotlist_get_max_width(hotlist_root->data.directory_content) + 4;
/* Find out window details */
e = window_get_wimp_handle(0, hotlist_windowid, &state.window_handle);
HotlistPreopen_ShowError(e);
e = wimp_get_window_state(&state);
HotlistPreopen_ShowError(e);
/* Sanity check... */
if (number < HOTLIST_WINDOW_MIN_HEIGHT) number = HOTLIST_WINDOW_MIN_HEIGHT;
if (maxlen < HOTLIST_WINDOW_MIN_WIDTH) maxlen = HOTLIST_WINDOW_MIN_WIDTH;
/* If the window is open, get its extent */
if (objectstate & Toolbox_GetObjectState_Showing)
{
e = window_get_extent(0, hotlist_windowid, &bbox);
HotlistPreopen_ShowError(e);
}
/* Work out the y extent and x extent required for showing */
/* as much of the visible items in the hotlist as possible */
bbox.ymin = -number * item_height;
bbox.xmax = maxlen;
/* If the window was already open, don't let the visible */
/* area change - otherwise go for a best fit to the */
/* items, as worked out above. */
if (objectstate & Toolbox_GetObjectState_Showing)
{
width = state.visible_area.xmax - state.visible_area.xmin;
height = state.visible_area.ymax - state.visible_area.ymin + hotlist_bbar_size;
if (bbox.ymin > -height) bbox.ymin = -height;
if (bbox.xmax < width) bbox.xmax = width;
}
/* Account for a button bar, if one were present. */
bbox.ymax = hotlist_bbar_size;
bbox.xmin = 0;
/* Set the extent */
e = window_set_extent(0, hotlist_windowid, &bbox);
HotlistPreopen_ShowError(e);
/* (Re)open the window */
if (objectstate & Toolbox_GetObjectState_Showing)
{
e = window_get_wimp_handle(0, hotlist_windowid, &state.window_handle);
if (!e) e = wimp_get_window_state(&state);
if (!e) e = toolbox_get_parent(0, hotlist_windowid, &parent_id, &parent_component);
if (!e) e = toolbox_show_object(0, hotlist_windowid, Toolbox_ShowObject_FullSpec, &(state.visible_area), parent_id, parent_component);
HotlistPreopen_ShowError(e);
}
return !!(objectstate & Toolbox_GetObjectState_Showing);
}
/*************************************************/
/* hotlist_redraw_handler() */
/* */
/* This handles redraw events from the Wimp, for */
/* the hotlist window. */
/* */
/* Parameters are as standard for a Wimp event */
/* handler. */
/*************************************************/
static int hotlist_redraw_handler(int event_code, WimpPollBlock * event, IdBlock * id_block, void * handle)
{
_kernel_oserror * e = NULL;
WimpRedrawWindowBlock block;
unsigned int item_height, item_dir_width, item_url_width;
unsigned int first_item, last_item;
int more;
/* Get entry sizes */
ChkError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
block.window_handle = event->redraw_window_request.window_handle;
/* Start the redraw loop */
wimp_redraw_window(&block, &more);
while (more && !e)
{
/* Work out which bits to redraw... */
first_item = -(block.redraw_area.ymax - (block.visible_area.ymax - block.yscroll)) / item_height;
last_item = (-(block.redraw_area.ymin - (block.visible_area.ymax - block.yscroll)) / item_height) + 1;
/* ...and redraw them */
e = hotlist_draw(hotlist_root->data.directory_content,
first_item,
last_item);
/* Get the next redraw rectangle */
if (!e) e = wimp_get_rectangle(&block, &more);
}
return 1;
}
/*************************************************/
/* hotlist_mouse_click_handler() */
/* */
/* Event handler to deal with mouse clicks in */
/* the hotlist window; converts coordinates from */
/* screen to window, and runs the result through */
/* hotlist_process_click. */
/* */
/* Parameters are as standard for a Wimp event */
/* handler. */
/*************************************************/
static int hotlist_mouse_click_handler(int event_code, WimpPollBlock * event, IdBlock * id_block, void * handle)
{
WimpGetWindowStateBlock state;
state.window_handle = event->mouse_click.window_handle;
wimp_get_window_state(&state);
wimp_set_caret_position(state.window_handle, -1, 0, 0, -1, -1);
ChkError(hotlist_process_click(event->mouse_click.mouse_x + (state.xscroll - state.visible_area.xmin),
event->mouse_click.mouse_y + (state.yscroll - state.visible_area.ymax),
event->mouse_click.buttons));
return 1;
}
/*************************************************/
/* hotlist_menuclose_handler() */
/* */
/* Called when menus close. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_menuclose_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
ObjectId submenu_id;
/* Deselect any items selected by the menu */
if (menu_select)
{
hotlist_clear_selection();
menu_select = 0;
}
/* Get rid of any submenus */
ChkError(menu_get_sub_menu_show(0, id_block->self_id, HOTLIST_URL_MENUITEM, &submenu_id));
if (submenu_id) ChkError(toolbox_delete_object(0, submenu_id));
ChkError(menu_set_sub_menu_show(0, id_block->self_id, HOTLIST_URL_MENUITEM, 0));
return 1;
}
/*************************************************/
/* hotlist_set_menu_details() */
/* */
/* When a menu is to be opened or the hotlist */
/* state changes in a way that can affect open */
/* menus, this can be used to update the menu */
/* contents. */
/* */
/* Parameters: Object ID of the hotlist root */
/* menu. */
/*************************************************/
static _kernel_oserror * hotlist_set_menu_details(ObjectId menuid)
{
hotlist_item * item;
char entrytext[Limits_Hotlist_ItemName];
ObjectId submenu_id;
switch (hotlist_count_selected_items())
{
/* No selected items - set the URL/Directory name string to */
/* "URL ''" and grey it out, along with the Clear Selection */
/* entry. */
case 0:
{
RetError(menu_set_entry_text(0, menuid, HOTLIST_URL_MENUITEM, "URL ''"));
RetError(menu_set_fade(0, menuid, HOTLIST_URL_MENUITEM, 1));
RetError(menu_set_fade(0, menuid, HOTLIST_CLEARSELECTION_MENUITEM, 1));
}
break;
/* Only 1 item selected */
case 1:
{
int name_len;
item = hotlist_find_selected_item();
switch(item->type)
{
/* One directory selected - set the URL/Directory name */
/* string to a relevant value, and create and attach */
/* the relevant submenu. */
case hl_directory:
{
StrNCpy0(entrytext, "Dir. '");
RetError(toolbox_create_object(0, "HLDirmenu", &submenu_id));
RetError(menu_set_sub_menu_show(0, menuid, HOTLIST_URL_MENUITEM, submenu_id));
/* If the item is read-only, grey out the 'delete' entry */
if (item->flags & HOTLIST_G_IS_READ_ONLY) menu_set_fade(0, submenu_id, HOTLIST_DELETE_SUBMENUITEM, 1);
else menu_set_fade(0, submenu_id, HOTLIST_DELETE_SUBMENUITEM, 0);
}
break;
/* Similarly, deal with a single URL being selected */
case hl_url:
{
StrNCpy0(entrytext, "URL '");
RetError(toolbox_create_object(0, "HLURLmenu", &submenu_id));
RetError(menu_set_sub_menu_show(0, menuid, HOTLIST_URL_MENUITEM, submenu_id));
if (item->flags & HOTLIST_G_IS_READ_ONLY) menu_set_fade(0, submenu_id, HOTLIST_DELETE_SUBMENUITEM, 1);
else menu_set_fade(0, submenu_id, HOTLIST_DELETE_SUBMENUITEM, 0);
}
break;
}
name_len = strlen(item->name);
/* Add the item name in. If the whole item will not fit, put as much as */
/* will do, followed by '...'. */
if (name_len < sizeof(entrytext) - strlen(entrytext) - 1) strcat(entrytext, item->name); /* ('<' accounts for terminator, -1 accounts for closing "'") */
else if (sizeof(entrytext) - strlen(entrytext) > 5)
{
strncat(entrytext, item->name, sizeof(entrytext) - strlen(entrytext) - 5); /* (-5 accounts for closing "'", "..." and terminator) */
strcat(entrytext, "...");
}
if (strlen(entrytext) < sizeof(entrytext) - 1) strcat(entrytext, "'");
/* Set the text, unfade the item, and unfade the Clear Selection item */
RetError(menu_set_entry_text(0, menuid, HOTLIST_URL_MENUITEM, entrytext));
RetError(menu_set_fade(0, menuid, HOTLIST_URL_MENUITEM, 0));
RetError(menu_set_fade(0, menuid, HOTLIST_CLEARSELECTION_MENUITEM, 0));
}
break;
/* Many items selected */
default:
{
/* Set the URL/Directory name string, ungrey that item and Clear Selection, */
/* and create and attach an appropriate submenu. */
RetError(menu_set_entry_text(0, menuid, HOTLIST_URL_MENUITEM, "Selection"));
RetError(menu_set_fade(0, menuid, HOTLIST_URL_MENUITEM, 0));
RetError(menu_set_fade(0, menuid, HOTLIST_CLEARSELECTION_MENUITEM, 0));
RetError(toolbox_create_object(0, "HLSlctmenu", &submenu_id));
RetError(menu_set_sub_menu_show(0, menuid, HOTLIST_URL_MENUITEM, submenu_id));
}
break;
}
/* If *everything* is selected, want to grey out Select All; */
/* else ungrey it. */
if (hotlist_contents_selected(hotlist_root)) RetError(menu_set_fade(0, menuid, HOTLIST_SELECTALL_MENUITEM, 1))
else RetError(menu_set_fade(0, menuid, HOTLIST_SELECTALL_MENUITEM, 0))
/* Set the ticks on 'Show Descriptions' or 'Show URLs' in the */
/* Display submenu. */
RetError(menu_get_sub_menu_show(0, menuid, HOTLIST_DISPLAY_MENUITEM, &submenu_id));
if (hl_show_urls)
{
RetError(menu_set_tick(0, submenu_id, HOTLIST_MENU_SHOWDESCRIPTIONS, 0));
RetError(menu_set_tick(0, submenu_id, HOTLIST_MENU_SHOWURLS, 1));
}
else
{
RetError(menu_set_tick(0, submenu_id, HOTLIST_MENU_SHOWDESCRIPTIONS, 1));
RetError(menu_set_tick(0, submenu_id, HOTLIST_MENU_SHOWURLS, 0));
}
/* Finished */
return NULL;
}
/*************************************************/
/* hotlist_menuopen_handler() */
/* */
/* Handles events raised when menus are about to */
/* be shown. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_menuopen_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
WimpGetWindowStateBlock state;
WimpGetPointerInfoBlock pointerblock;
hotlist_item * item;
unsigned int item_height, item_dir_width, item_url_width;
int xmin, xmax, window_handle;
ObjectId sub_menu;
/* Get entry sizes. */
ChkError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
if (event_code == EHotlistToBeShown)
{
/* Work out which item the pointer was over. */
ChkError(window_get_wimp_handle(0, hotlist_windowid, &window_handle));
state.window_handle = window_handle;
ChkError(wimp_get_window_state(&state));
ChkError(wimp_get_pointer_info(&pointerblock));
pointerblock.x = pointerblock.x + (state.xscroll - state.visible_area.xmin);
pointerblock.y = pointerblock.y + (state.yscroll - state.visible_area.ymax);
menu_itemno = -pointerblock.y / item_height;
}
ChkError(menu_get_sub_menu_show(0, id_block->self_id, HOTLIST_DISPLAY_MENUITEM, &sub_menu));
/* If there are no selected items, select the one the menu */
/* was opened over. */
if (hotlist_count_selected_items() == 0)
{
item = hotlist_find_item(hotlist_root->data.directory_content, menu_itemno);
if (item) ChkError(hotlist_get_shape(&xmin, &xmax, item));
if (item && pointerblock.x >= xmin && pointerblock.x <= xmax)
{
item->flags |= HOTLIST_G_IS_SELECTED | HOTLIST_G_REDRAW_NOW;
if (item->type == hl_directory) hotlist_set_flags(item->data.directory_content, hl_ALL, HOTLIST_G_IS_SELECTED);
menu_select = 1;
ChkError(hotlist_redraw_now());
}
}
/* Update the menus */
ChkError(hotlist_set_menu_details(id_block->self_id));
return 0;
}
/*************************************************/
/* hotlist_save_entries() */
/* */
/* This function recurses through the hotlist */
/* directory structure saving all directories */
/* and entries as it goes. */
/* */
/* Parameters: Pointer to a FILE struct for the */
/* file to write to; */
/* */
/* Pointer to a hotlist_item struct */
/* representing the first item in */
/* the directory to save (which may */
/* itself be a directory); */
/* */
/* 0 - save all of hotlist, */
/* 1 - only save selection portions, */
/* but in both cases obey the next */
/* parameter; */
/* */
/* 0 - don't save read-only items, */
/* 1 - allow saving of read-only */
/* items. */
/* */
/* Assumes: The FILE pointer must not be NULL */
/* however the hotlist_item pointer */
/* can be (e.g. an empty directory). */
/*************************************************/
static _kernel_oserror * hotlist_save_entries(FILE * fileptr, hotlist_item * list, int type, int save_read_only)
{
int written;
/* Follow the directory list */
while (list)
{
/* Don't save read-only entries unless told to */
if (save_read_only || !(list->flags & HOTLIST_G_IS_READ_ONLY))
{
switch (list->type)
{
/* Write a link for URLs */
case hl_url:
{
if (type == 0 || (type == 1 && list->flags & HOTLIST_G_IS_SELECTED))
{
HotlistWrite(fprintf(fileptr, "<li><a href=\"%s\">%s</a>\n", list->data.url, list->name));
}
}
break;
/* Write a heading for directories */
case hl_directory:
{
if (type == 0 || !hotlist_no_contents_selected(list->data.directory_content))
{
if (type == 0 || (type == 1 && list->flags & HOTLIST_G_IS_SELECTED))
{
HotlistWrite(fprintf(fileptr, "<h4>%s</h4>\n", list->name));
if (list->flags & HOTLIST_D_IS_OPEN)
{
HotlistWrite(fprintf(fileptr, "<ul><!--open-->\n"));
}
else
{
HotlistWrite(fprintf(fileptr, "<ul>\n"));
}
}
/* Recursive call for the directory contents First, */
/* write the entry header. */
/* Do the contents */
RetError(hotlist_save_entries(fileptr, list->data.directory_content, type, save_read_only));
if (type == 0 || (type == 1 && list->flags & HOTLIST_G_IS_SELECTED))
{
HotlistWrite(fprintf(fileptr, "</ul>\n"));
}
}
}
break;
}
}
/* Continue down the list */
list = list->next;
}
return NULL;
/* Error condition exit */
hotlist_save_error:
RetLastE;
}
/*************************************************/
/* hotlist_save_hotlist() */
/* */
/* This function saves the hotlist as an HTML */
/* file. */
/* */
/* Parameters: Pointer to the filename to save */
/* to (null terminated); */
/* */
/* Pointer to a buffer containing */
/* any extra information to put in */
/* the top of the file (intended for */
/* multiuser builds); */
/* */
/* 0 to save all of hotlist, 1 to */
/* save only the selected portions. */
/*************************************************/
_kernel_oserror * hotlist_save_hotlist(char * filename, char * extradata, int type)
{
_kernel_oserror * e;
FILE * fileptr;
static char * local_path = NULL;
int written;
if (!filename || !*filename) return NULL;
/* Canonicalise the path */
RetError(utils_canonicalise_path(filename, &local_path));
/* Ensure it is present */
e = utils_build_tree(local_path);
if (e)
{
free(local_path);
return e;
}
/* Could take a while... */
_swix(Hourglass_On, 0);
/* Open the file for writng */
fileptr = fopen(local_path, "wb");
/* Complain if it fails */
if (fileptr == NULL)
{
free(local_path);
RetLastE;
}
/* Write the extra data */
if (extradata) HotlistWrite(fprintf(fileptr, "%s", extradata));
/* Write the file header */
HotlistWrite(fprintf(fileptr, "<html>\n"
"<head>\n"
CHARSET_SPECIFIER
"<title>"));
HotlistWrite(fprintf(fileptr, "%s", lookup_token("HotlistHTMLTitle:Hotlist",0,0)));
HotlistWrite(fprintf(fileptr, "</title>\n"
"</head>\n"
"<body>\n"
"<ul>\n"));
/* Fill in the body */
e = hotlist_save_entries(fileptr,
hotlist_root->data.directory_content,
type,
type == 1 ? 1 : 0); /* If saving part of the hotlist, allow saving of read-only components */
if (e)
{
_swix(Hourglass_Off, 0);
fclose(fileptr);
free(local_path);
return e;
}
/* Write the footer and close the file */
HotlistWrite(fprintf(fileptr, "</ul>\n"));
HotlistWrite(fprintf(fileptr, "</body>\n"));
HotlistWrite(fprintf(fileptr, "</html>\n"));
fclose(fileptr);
_swix(Hourglass_Off, 0);
/* Set the filetype to HTML (0xfaf) */
e = _swix(OS_File,
_INR(0,2),
18,
local_path,
FileType_HTML);
free(local_path);
return e;
/* Error condition exit */
hotlist_save_error:
if (fileptr)
{
fclose(fileptr);
_swix(Hourglass_Off, 0);
}
free(local_path);
RetLastE;
}
/*************************************************/
/* hotlist_save() */
/* */
/* Veneer onto hotlist_save_hotlist - saves all */
/* of the hotlist, created to preserve API. */
/* */
/* Parameters: Pointer to the filename to save */
/* to (null terminated). */
/*************************************************/
_kernel_oserror * hotlist_save(char * filename)
{
return hotlist_save_hotlist(filename, NULL, 0); /* Save entire hotlist */
}
/*************************************************/
/* hotlist_lower_tags() */
/* */
/* This function processes the passed string */
/* turning all characters within a tag to lower */
/* case. It will detect characters within quotes */
/* and leave their case the same; this will */
/* preserve the case of URLs. */
/* */
/* Obviously, this assumes that the HTML file */
/* being fed in is not broken; tags and quoted */
/* text must always be correctly closed, and */
/* in both cases must not span multiple lines. */
/* */
/* Parameters: Pointer to the string to process. */
/*************************************************/
static void hotlist_lower_tags(char *string)
{
int intag = 0, inquotes = 0;
while (*string)
{
if (intag)
{
if (inquotes)
{
if (*string == '"') inquotes = 0;
}
else
{
if (*string == '"') inquotes = 1;
if (*string == '>') intag --;
*string = tolower(*string);
}
}
else
{
if (*string == '<') intag++;
}
string++;
}
}
/*************************************************/
/* hotlist_load_directory() */
/* */
/* This function loads the directory contents of */
/* a hotlist HTML file previously saved by */
/* hotlist_save or a compatible source. For */
/* example, at the time of creation this can */
/* correctly load and understand hotlist files */
/* from at least one other popular browser. */
/* */
/* Parameters: Pointer to a FILE struct through */
/* which data will be read; */
/* */
/* Pointer to a hotlist_item; new */
/* data structures generated from */
/* the file contents are added to */
/* the linked list that this struct */
/* lies in. */
/*************************************************/
static _kernel_oserror * hotlist_load_directory(FILE * fileptr, hotlist_item * target)
{
_kernel_oserror * e = NULL;
static char * next_directory_name = NULL;
static char * string_buffer = NULL;
static char * str_ptr;
char * url;
hotlist_item * new_dir;
unsigned int unfollowed_uls = 0;
long int file_position;
int character, count;
int target_type;
/* Go through the file in chunks */
target_type = 0; /* At end of directory */
while (!feof(fileptr)) /* In theory the code below means you'll never get this; but just to be safe... */
{
file_position = ftell(fileptr);
/* Scan ahead to find the end of line - marked by any */
/* control character, in this case; need to include */
/* as many consecutive control chars as are present */
/* in the file, in the count. */
do
{
/* First, get to either a control char or EOF */
character = fgetc(fileptr);
}
while (character > 31 && character != EOF);
while (character < 32 && character != EOF)
{
/* If we're not on EOF, continue until we're no longer */
/* on a control char or hit EOF. */
character = fgetc(fileptr);
}
/* Work out how many bytes we've read */
count = (int) (ftell(fileptr) - file_position);
/* If count is zero, we're at the end of the file */
if (!count) break;
/* If we're not on EOF and don't have a control char, then */
/* we overshot by one; so we would want to subtract one */
/* from count. However, to ensure string manipulation */
/* works OK, we'll need one char to null terminate the */
/* string. So in that case, we need to *add* one to count */
/* if the above condition isn't true. */
if (!(character > 31 && character != EOF)) count ++;
/* Right, after all that messing around rewind to the stored */
/* file position and allocate a buffer for this string. */
if (fseek(fileptr, file_position, SEEK_SET))
{
erb = *_kernel_last_oserror();
e = &erb;
goto hotlist_load_directory_exit; /* (See near end of function) */
}
/* Note that string_buffer is a static, as this way only one */
/* of these buffers ever exists, even for recursive calls. */
if (string_buffer) free(string_buffer);
string_buffer = malloc(count);
/* Complain if the allocation fails */
if (!string_buffer)
{
erb = *_kernel_last_oserror();
e = &erb;
goto hotlist_load_directory_exit; /* (See near end of function) */
}
/* Read the data and force a terminator at the end of the buffer, */
/* just to be safe. */
if (fread(string_buffer, sizeof(char), count - 1, fileptr) != count - 1)
{
erb = *_kernel_last_oserror();
e = &erb;
goto hotlist_load_directory_exit; /* (See near end of function) */
}
string_buffer[count - 1] = 0;
/* Convert tags to lower case */
hotlist_lower_tags(string_buffer);
/* Treat any opening '<h...>' tag (header) as the title to a directory */
str_ptr = strstr(string_buffer, "<h");
if (
str_ptr &&
str_ptr[2] >= '1' &&
str_ptr[2] <= '6' &&
str_ptr[3] == '>'
)
{
/* Read the directory name (up to the closing '</h...>') */
str_ptr = strtok(str_ptr + 4, "<");
/* Allocate space for it */
if (next_directory_name) free(next_directory_name);
next_directory_name = malloc(strlen(str_ptr) + 1);
/* Complain if the allocation fails */
if (!next_directory_name)
{
e = make_no_memory_error(3);
goto hotlist_load_directory_exit; /* (See near end of function) */
}
/* Otherwise, copy the name in */
strcpy(next_directory_name, str_ptr);
}
/* Treat any '<a href=...>' attribute contents (link) as a URL for the hotlist */
else if ((str_ptr = strstr(string_buffer, "<a href=\"")) != NULL) /* Using '!= NULL' stops a compiler warning... */
{
/* First extract the URL */
str_ptr += 9; /* Derived from strlen("<a href=\"") */
str_ptr = strtok(str_ptr, "\"");
/* Because we're about to use strtok() to extract the title, it'll */
/* put a convenient terminator into the string_buffer block at the */
/* end of the URL. So all we need to do is record the current */
/* pointer in the block, str_ptr, for use when we finally add the */
/* item to the hotlist. */
url = str_ptr;
/* Extract the title - between the closing '>' of the '<a href=...' */
/* and the opening '<' of the '</a>'. */
str_ptr = strtok(NULL, "><");
/* Get ready to add this item, provided that the URL string has */
/* ':/' in - i.e. looks fully specified */
if (strstr(url, ":/"))
{
if (target_type == 0)
{
e = hotlist_new_url(target, HOTLIST_POSITION_END, str_ptr, url);
target_type = 1;
}
else
{
e = hotlist_new_url(target, HOTLIST_POSITION_AFTER, str_ptr, url);
}
if (e) goto hotlist_load_directory_exit; /* (See near end of function) */
target = hotlist_newitem;
}
}
/* Treat any '<ul>' tags as the start of a new directory. The name comes */
/* from a preceeding '<h...>' tag (see above). */
else if ((str_ptr = strstr(string_buffer, "<ul>")) != NULL) /* New directory */
{
if (!next_directory_name)
{
/* If we don't have a directory name for this one, apparently, flag it */
/* by incrementing the unmatched '<ul>' counter. */
unfollowed_uls ++;
}
else
{
/* Otherwise, add the directory */
if (target_type == 0)
{
e = hotlist_new_directory(target, next_directory_name, HOTLIST_POSITION_END, &new_dir);
target_type = 1;
}
else
{
e = hotlist_new_directory(target, next_directory_name, HOTLIST_POSITION_AFTER, &new_dir);
}
if (e) goto hotlist_load_directory_exit;
target = hotlist_newitem;
if (strstr(string_buffer, "<!--open-->") != NULL)
{
new_dir->flags |= HOTLIST_D_IS_OPEN;
}
free(next_directory_name);
next_directory_name = NULL;
/* If the directory was added, recursively load the contents */
if (new_dir)
{
/* Note this will invalidate string_buffer. The contents must */
/* not be used after the call! */
e = hotlist_load_directory(fileptr, new_dir);
if (e) goto hotlist_load_directory_exit; /* (See near end of function) */
}
else
{
/* If the directory was not added, flag it */
unfollowed_uls ++;
}
}
}
/* Treat any '</ul>' tags as the end of a directory. */
else if ((str_ptr = strstr(string_buffer, "</ul>")) != NULL) /* Close directory */
{
/* If we have unfollowed '<ul>' tags, decrement the counter; */
/* otherwise, exit quietly. */
if (unfollowed_uls) unfollowed_uls--;
else goto hotlist_load_directory_exit; /* (See near end of function) */
}
}
/* This section is not necessarily an error exit condition, so */
/* the code falls through to it in normal running. If 'e' is */
/* NULL there's still no error returned in the end. Note */
/* though how the various buffers are freed, and thus */
/* invalidated, at this point; so during recursive routines, */
/* they must not be accessed after the recursive call has */
/* been made (unless, of course, they are reallocated). */
hotlist_load_directory_exit:
/* Free up the temporary buffers */
if (string_buffer)
{
free(string_buffer);
string_buffer = NULL;
}
if (next_directory_name)
{
free(next_directory_name);
next_directory_name = NULL;
}
// We could at this point give a warning if unfollowed_uls is non-zero.
return e;
}
/*************************************************/
/* hotlist_discard() */
/* */
/* Empties the hotlist. The hotlist window is */
/* not updated (expected usage is to close the */
/* window shotly before or after discarding the */
/* contents). */
/*************************************************/
void hotlist_discard(void)
{
while (hotlist_root->data.directory_content)
{
hotlist_delete_item(hotlist_root->data.directory_content);
}
}
/*************************************************/
/* hotlist_load() */
/* */
/* This function loads an HTML file previously */
/* saved by hotlist_save as the new hotlist. */
/* */
/* Parameters: Pointer to the filename to load */
/* (null terminated). */
/*************************************************/
_kernel_oserror * hotlist_load(char * filename)
{
_kernel_oserror * e;
static char * local_path = NULL;
FILE * fileptr;
if (!filename || !*filename) return NULL;
local_path = malloc(strlen(filename) + 1);
if (!local_path) return NULL;
strcpy(local_path, filename);
/* First delete all the existing hotlist items */
hotlist_discard();
/* Open the file */
fileptr = fopen(local_path, "r");
if (fileptr == NULL)
{
free(local_path);
erb.errnum = Utils_Error_Custom_Normal;
StrNCpy0(erb.errmess,
lookup_token("HlCantLoad:Hotlist file could not be loaded",
0,
0));
return &erb;
}
/* Load it (any errors are returned right at the end) */
e = hotlist_load_directory(fileptr, hotlist_root);
fclose(fileptr);
/* Clear all of the various flags for redraw, */
/* selection etc. now that we have a new */
/* hotlist. */
hotlist_clear_flags(hotlist_root, hl_ALL, HOTLIST_G_REDRAW_NOW);
#ifdef TRACE
/* Show the tree now the file is loaded */
if (tl & (1u<<25)) hotlist_display_tree(hotlist_root, 0);
#endif
/* Finished; redraw issues are left to the caller */
if (!e) e = hotlist_modified(HL_MODIFIED_LOAD);
free(local_path);
return e;
}
/*************************************************/
/* hotlist_initialise() */
/* */
/* This function initialises the hotlist library */
/* routines, and must be called before any other */
/* hotlist functions. */
/*************************************************/
_kernel_oserror * hotlist_initialise(void)
{
ObjectId toolbar;
ObjectId menu_id;
BBox bbox;
unsigned int item_height, item_dir_width, item_url_width;
char root[] = "Root";
/* Set some initial flags */
hotlist_dragging.drag_type = HOTLIST_NOT_DRAGGING;
hotlist_dragging.using_adjust = 0;
/* Create root directory item */
RetError(hotlist_new_directory(NULL, root, 0, &hotlist_root));
/* Create the hotlist window */
RetError(toolbox_create_object(0, "HotlistWind", &hotlist_windowid));
/* Is there a toolbar? */
RetError(window_get_tool_bars(InternalTopLeft,
hotlist_windowid,
NULL,
&toolbar,
NULL,
NULL));
/* If so, read the size */
if (toolbar != 0)
{
RetError(window_get_extent(0, toolbar, &bbox));
hotlist_bbar_size = bbox.ymax - bbox.ymin;
}
else hotlist_bbar_size = 0;
/* Read sprite sizes to see if the sprites actually exist */
RetError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
/* Register event handlers for redraw, clicks and drags in the */
/* main hotlist window. */
RetError(event_register_wimp_handler(hotlist_windowid,
Wimp_ERedrawWindow,
hotlist_redraw_handler,
NULL));
RetError(event_register_wimp_handler(hotlist_windowid,
Wimp_EMouseClick,
hotlist_mouse_click_handler,
NULL));
RetError(event_register_wimp_handler(-1,
Wimp_EUserDrag,
hotlist_drag_completed_handler,
NULL));
/* Menu handlers */
RetError(window_get_menu(0, hotlist_windowid, &menu_id));
RetError(event_register_toolbox_handler(menu_id,
EHotlistToBeShown,
hotlist_menuopen_handler,
NULL));
RetError(event_register_toolbox_handler(menu_id,
EHotlistHidden,
hotlist_menuclose_handler,
NULL));
/* Main menu items */
RetError(event_register_toolbox_handler(-1,
EHotlistSelectAll,
hotlist_select_all_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistClearSelect,
hotlist_clear_selection_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistOpenAll,
hotlist_menu_openall_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistCloseAll,
hotlist_menu_closeall_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistDelete,
hotlist_menu_delete_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistSaveToServer,
hotlist_save_to_server_handler, /* a.k.a. Save As Default */
NULL));
/* Submenu warning events */
RetError(event_register_toolbox_handler(-1,
EHotlistShowEditURL,
hotlist_show_editurl_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistShowRenameDirectory,
hotlist_show_rendirectory_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistShowNewURL,
hotlist_show_newurl_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistShowNewDirectory,
hotlist_show_newdirectory_handler,
NULL));
/* Hotlist related dialogue events */
RetError(event_register_toolbox_handler(-1,
EHotlistClose,
hotlist_close_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistNewEditURLOK,
hotlist_newedit_url_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistNewEditURLCancel,
hotlist_reset_url_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistNewRenameDirectoryOK,
hotlist_newren_directory_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistNewRenameDirectoryCancel,
hotlist_reset_directory_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistShowDescriptions,
hotlist_show_descriptions_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistShowURLs,
hotlist_show_urls_handler,
NULL));
RetError(event_register_toolbox_handler(-1,
EHotlistCancelDrag,
hotlist_drag_stop_handler,
NULL));
return NULL;
}
/*************************************************/
/* hotlist_open() */
/* */
/* Opens the hotlist window. If already open, */
/* all this does is bring it to the front - it */
/* doesn't move it. The display type is changed, */
/* if required, in any case. */
/* */
/* Parameters: Show type (as for a call to */
/* Toolbox_ShowObject); */
/* */
/* Show block (as for a call to */
/* Toolbox_ShowObject); */
/* */
/* 0 to open showing descriptions, */
/* or 1 to open showing URLs. */
/*************************************************/
_kernel_oserror * hotlist_open(int show_type, void * type, int show_urls)
{
int open, old_show_urls;
_kernel_oserror * e;
old_show_urls = hl_show_urls;
/* Sets show descriptions / show URLs */
hl_show_urls = show_urls;
/* Set the size of the window etc. */
open = hotlist_preopen();
/* Show the hotlist. We have to do this twice; if we try to centre */
/* it just the once, then that call seems to read the visible area */
/* as it was *before* hotlist_preopen changed the extent. */
/* */
/* This Is Bad. In any case, for opening centred, we want to open */
/* full size, if not already open. */
if (open)
{
/* Open window once to let the wimp/toolbox see what shape it really is, */
/* but don't fiddle with the visible area as the window was already open. */
e = toolbox_show_object(0,
hotlist_windowid,
Toolbox_ShowObject_Default,
0,
0,
-1);
}
else
{
BBox extent;
WindowShowObjectBlock show;
RetError(window_get_extent(0, hotlist_windowid, &extent));
show.visible_area = extent;
show.behind = -3;
e = toolbox_show_object(0,
hotlist_windowid,
Toolbox_ShowObject_FullSpec,
&show,
0,
-1);
/* Open it once again in the place the window is really wanted */
e = toolbox_show_object(0,
hotlist_windowid,
show_type,
type,
0,
-1);
}
/* Redraw the window if the display type has changed */
if (!e && open && hl_show_urls != old_show_urls)
{
hotlist_redraw_items(0, hotlist_count_displayed_items(hotlist_root->data.directory_content));
}
return e;
}
/*************************************************/
/* hotlist_close() */
/* */
/* Closes the hotlist window. */
/*************************************************/
_kernel_oserror * hotlist_close(void)
{
if (hotlist_windowid) return toolbox_hide_object(0, hotlist_windowid);
else return NULL;
}
/*************************************************/
/* hotlist_close_handler() */
/* */
/* Closes the hotlist window. . */
/*************************************************/
static int hotlist_close_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
ChkError(hotlist_close());
return 1;
}
/*************************************************/
/* hotlist_select_all_handler() */
/* */
/* This function handles the 'select all' menu */
/* item. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_select_all_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
ObjectId main_menu;
menu_select = 0;
/* Select everything */
hotlist_set_flags(hotlist_root, hl_ALL, HOTLIST_G_IS_SELECTED);
hotlist_root->flags &= ~HOTLIST_G_IS_SELECTED;
hotlist_redraw_now();
/* Get the main menu ID */
ChkError(window_get_menu(0, hotlist_windowid, &main_menu));
/* Update the main menu contents to reflect the new state */
hotlist_set_menu_details(main_menu);
return 1;
}
/*************************************************/
/* hotlist_clear_selection_handler() */
/* */
/* This function handles the clear selection */
/* menu item */
/*************************************************/
static int hotlist_clear_selection_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
ObjectId main_menu;
menu_select = 0;
/* Get the main menu ID */
ChkError(window_get_menu(0, hotlist_windowid, &main_menu));
/* Clear the selection */
hotlist_clear_selection();
/* Update the main menu */
hotlist_set_menu_details(main_menu);
return 1;
}
/*************************************************/
/* hotlist_menu_openall_handler() */
/* */
/* Deal with the Open All menu item. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_menu_openall_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
if (hotlist_root->data.directory_content)
{
menu_itemno = 0;
/* Set all Open flags, clear all Redraw Now flags, and force a redraw of everything */
hotlist_set_flags (hotlist_root->data.directory_content, hl_directory, HOTLIST_D_IS_OPEN);
hotlist_clear_flags(hotlist_root->data.directory_content, hl_directory, HOTLIST_G_REDRAW_NOW);
ChkError(hotlist_redraw_items(0, hotlist_count_displayed_items(hotlist_root->data.directory_content)));
hotlist_preopen();
}
return 1;
}
/*************************************************/
/* hotlist_menu_closeall_handler() */
/* */
/* Deal with the Close All menu item. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_menu_closeall_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
unsigned int noitems;
ObjectId main_menu;
if (hotlist_root->data.directory_content)
{
menu_itemno = 0;
/* Clear all Open and Redraw Now flags, and deselect all items */
noitems = hotlist_count_displayed_items(hotlist_root->data.directory_content);
hotlist_clear_flags(hotlist_root->data.directory_content,
hl_directory,
HOTLIST_D_IS_OPEN | HOTLIST_G_REDRAW_NOW);
ChkError(hotlist_clear_selection());
ChkError(hotlist_redraw_items(0, noitems));
/* Get the main menu ID */
ChkError(window_get_menu(0, hotlist_windowid, &main_menu));
/* Update the menus to reflect there's nothing selected */
ChkError(hotlist_set_menu_details(main_menu));
hotlist_preopen();
}
return 1;
}
/*************************************************/
/* hotlist_menu_delete_handler() */
/* */
/* Deal with the Delete menu item. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_menu_delete_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
hotlist_item * item;
unsigned int noitems;
ObjectId hotlist_window;
int deleted = 0;
if (!id_block->ancestor_id) hotlist_window = id_block->self_id;
else hotlist_window = id_block->ancestor_id;
/* If there are no selected items, can't do anything */
noitems = hotlist_count_displayed_items(hotlist_root->data.directory_content);
if (!hotlist_count_selected_items()) return 0;
/* Delete all selected items */
while ((item = hotlist_find_selected_item()) != NULL)
{
if (item->flags & HOTLIST_G_IS_READ_ONLY)
{
/* Just clear selection on read only items */
item->flags &= ~HOTLIST_G_IS_SELECTED;
}
else
{
/* Delete read/write items */
deleted ++;
hotlist_delete_item(item);
}
}
/* Redraw */
hotlist_redraw_items(0, noitems);
/* We may have no more work to do if all of the selected items */
/* were read-only; otherwise, 'deleted' will be non-zero. */
if (deleted)
{
/* Update the window extent */
hotlist_preopen();
/* The hotlist has been modified... */
hotlist_modified(HL_MODIFIED_DELETE);
}
/* Finished */
return 1;
}
/*************************************************/
/* hotlist_save_to_server_handler() */
/* */
/* Deal with the 'Save to server' menu item */
/* (also known as 'Save as default'). */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_save_to_server_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
#ifdef SINGLE_USER
show_error_ret(hotlist_save(lookup_choice("HotlistSave:Browse:User.Hotlist",0,0)));
#else
show_error_ret(multiuser_save_hotlist());
#endif
return 1;
}
/*************************************************/
/* hotlist_show_newurl_handler() */
/* */
/* This function fills in the edit / create URL */
/* dialogue to be a New URL object. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_show_newurl_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
ObjectId dboxid;
#ifdef TRACE
if (tl & (1u<<25)) Printf("hotlist_show_newurl_handler: Called\n");
#endif
ChkError(menu_get_sub_menu_show(0, id_block->self_id, id_block->self_component, &dboxid));
alter_new = HOTLIST_MENUSECTION_NEW;
/* Set the title, clear the description writable and URL writable, */
/* and set the default action button text. 'Cancel' stays as */
/* 'Cancel'. */
ChkError(window_set_title(0, dboxid, lookup_token("HotlistCreateURLTitle:Create new URL",0,0)));
ChkError(writablefield_set_value(0, dboxid, HOTLIST_NEWURL_NAME, ""));
ChkError(writablefield_set_value(0, dboxid, HOTLIST_NEWURL_URL, ""));
ChkError(actionbutton_set_text (0, dboxid, HOTLIST_NEWURL_NEW, lookup_token("HotlistCreateURLAction:Create",0,0)));
return 1;
}
/*************************************************/
/* hotlist_show_editurl_handler() */
/* */
/* This function fills in the edit / create URL */
/* dialogue to be an Edit URL object. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_show_editurl_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
hotlist_item * item;
ObjectId dboxid;
#ifdef TRACE
if (tl & (1u<<25)) Printf("hotlist_show_editurl_handler: Called\n");
#endif
/* Must have a selected item... */
item = hotlist_find_selected_item();
if (!item) return 0;
ChkError(menu_get_sub_menu_show(0, id_block->self_id, id_block->self_component, &dboxid));
alter_new = HOTLIST_MENUSECTION_ALTER;
/* Set the title, description writable, URL writable, and */
/* default action button text. 'Cancel' stays as 'Cancel'. */
ChkError(window_set_title(0, dboxid, lookup_token("HotlistEditURLTitle:Edit URL",0,0)));
ChkError(writablefield_set_value(0, dboxid, HOTLIST_NEWURL_NAME, item->name));
ChkError(writablefield_set_value(0, dboxid, HOTLIST_NEWURL_URL, item->data.url));
ChkError(actionbutton_set_text (0, dboxid, HOTLIST_NEWURL_NEW, lookup_token("HotlistEditURLAction:Alter",0,0)));
/* If the item's flags show it is read-only, it can't be altered */
if (item->flags & HOTLIST_G_IS_READ_ONLY) set_gadget_state(dboxid, HOTLIST_NEWURL_NEW, 1);
else set_gadget_state(dboxid, HOTLIST_NEWURL_NEW, 0);
return 1;
}
/*************************************************/
/* hotlist_show_newdirectory_handler() */
/* */
/* This function fills in the edit / create */
/* directory dialogue to be a New Directory */
/* object. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_show_newdirectory_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
ObjectId dboxid;
#ifdef TRACE
if (tl & (1u<<25)) Printf("hotlist_show_newdirectory_handler: Called\n");
#endif
ChkError(menu_get_sub_menu_show(0, id_block->self_id, id_block->self_component, &dboxid));
alter_new = HOTLIST_MENUSECTION_NEW;
/* Set the title, clear the writable contents, and set */
/* the default action button text. 'Cancel' stays as */
/* 'Cancel'. */
ChkError(window_set_title(0, dboxid, lookup_token("HotlistCreateDirTitle:Create new directory",0,0)));
ChkError(writablefield_set_value(0, dboxid, HOTLIST_NEWDIRECTORY_NAME, ""));
ChkError(actionbutton_set_text (0, dboxid, HOTLIST_NEWDIRECTORY_NEW, lookup_token("HotlistCreateDirAction:Create",0,0)));
return 1;
}
/*************************************************/
/* hotlist_show_rendirectory_handler() */
/* */
/* This function fills in the edit / create */
/* directory dialogue to be a Rename Directory */
/* object. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_show_rendirectory_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
hotlist_item * item;
ObjectId dboxid;
#ifdef TRACE
if (tl & (1u<<25)) Printf("hotlist_show_rendirectory_handler: Called\n");
#endif
/* Must have a selected item... */
item = hotlist_find_selected_item();
if (!item) return 0;
ChkError(menu_get_sub_menu_show(0, id_block->self_id, id_block->self_component, &dboxid));
alter_new = HOTLIST_MENUSECTION_ALTER;
/* Set the title, writable contents, and default action */
/* button text. 'Cancel' stays as 'Cancel'. */
ChkError(window_set_title(0, dboxid, lookup_token("HotlistRenameDirTitle:Rename directory",0,0)));
ChkError(writablefield_set_value(0, dboxid, HOTLIST_NEWDIRECTORY_NAME, item->name));
ChkError(actionbutton_set_text (0, dboxid, HOTLIST_NEWDIRECTORY_NEW, lookup_token("HotlistRenameDirAction:Rename",0,0)));
/* If the item's flags show it is read-only, it can't be renamed */
if (item->flags & HOTLIST_G_IS_READ_ONLY) set_gadget_state(dboxid, HOTLIST_NEWDIRECTORY_NEW, 1);
else set_gadget_state(dboxid, HOTLIST_NEWDIRECTORY_NEW, 0);
return 1;
}
/*************************************************/
/* hotlist_newedit_url_handler() */
/* */
/* This function either alters the name and URL */
/* fields of a selected URL, or creates a new */
/* URL item in the directory that the pointer */
/* was over when the main menu was opened. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_newedit_url_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
_kernel_oserror * e = NULL;
hotlist_item * item;
hotlist_item * tempitem;
char * tempdesc;
char * tempurl;
int size;
/* Is there a selected item? */
item = hotlist_find_selected_item();
/* Get the length of the description (name) text */
ChkError(writablefield_get_value(0,
id_block->self_id,
HOTLIST_NEWURL_NAME,
NULL,
0,
&size));
/* Try to allocate space for it */
tempdesc = malloc(size + 1); /* '+1' to be safe (above call *should* return 'size of buffer required'...) */
if (!tempdesc)
{
show_error_cont(make_no_memory_error(15));
return 1;
}
/* Get the value, making absolutely sure it's terminated */
ChkError(writablefield_get_value(0,
id_block->self_id,
HOTLIST_NEWURL_NAME,
tempdesc,
size,
NULL));
tempdesc[size] = 0;
/* Do the same for the URL */
ChkError(writablefield_get_value(0,
id_block->self_id,
HOTLIST_NEWURL_URL,
NULL,
0,
&size));
tempurl = malloc(size + 1);
if (!tempurl)
{
free(tempdesc);
show_error_cont(make_no_memory_error(15));
return 1;
}
ChkError(writablefield_get_value(0,
id_block->self_id,
HOTLIST_NEWURL_URL,
tempurl,
size,
NULL));
tempurl[size] = 0;
/* 'alter_new' is set by the menu handling functions to */
/* reflect whether we should create or alter items. */
switch (alter_new)
{
case HOTLIST_MENUSECTION_NEW:
{
/* Create a new item. First, find the one the menu was */
/* opened over. */
tempitem = hotlist_find_item(hotlist_root->data.directory_content, menu_itemno);
/* If we can't, add to the start of the root directory */
if (!tempitem)
{
menu_itemno = 0;
e = hotlist_new_url(hotlist_root,
HOTLIST_POSITION_BEGINNING,
tempdesc,
tempurl);
}
/* Otherwise add it after the item, unless the parent is read-only */
else
{
if (tempitem->parent && (tempitem->parent->flags & HOTLIST_G_IS_READ_ONLY))
{
erb.errnum = Utils_Error_Custom_Message;
StrNCpy0(erb.errmess,
lookup_token("HLNewRO:You can't create an item here (the directory is read-only).",
0,0));
e = &erb;
}
else
{
e = hotlist_new_url(tempitem,
HOTLIST_POSITION_AFTER,
tempdesc,
tempurl);
}
}
if (!e)
{
/* Ensure the window extent is up to date */
hotlist_preopen();
/* Deal with redraw issues */
e = hotlist_redraw_items(menu_itemno,
hotlist_count_displayed_items(hotlist_root->data.directory_content));
hotlist_clear_flags(hotlist_root, hl_ALL, HOTLIST_G_REDRAW_NOW);
/* Call the 'hotlist has changed' function */
hotlist_modified(HL_MODIFIED_ADD);
}
/* Free temporary data and report any errors */
free(tempdesc);
free(tempurl);
ChkError(e);
}
break;
case HOTLIST_MENUSECTION_ALTER:
{
/* Alter an existing item. If it is read-only, complain; */
/* otherwise, free its URL and description text. */
if (item->flags & HOTLIST_G_IS_READ_ONLY)
{
erb.errnum = Utils_Error_Custom_Message;
StrNCpy0(erb.errmess,
lookup_token("NLAlterRO:You can't alter this item (it is read-only).",
0,0));
e = &erb;
free(tempdesc);
free(tempurl);
}
else
{
free(item->name);
free(item->data.url);
/* Point to the new URL and description */
item->name = tempdesc;
item->data.url = tempurl;
/* Deal with redraw issues */
item->flags |= HOTLIST_G_REDRAW_NOW;
hotlist_preopen();
e = hotlist_redraw_now();
/* Call the 'hotlist has changed' function */
hotlist_modified(HL_MODIFIED_ALTER);
}
/* Report any errors */
ChkError(e);
}
break;
}
return 1;
}
/*************************************************/
/* hotlist_newren_directory_handler() */
/* */
/* As hotlist_newedit_url_handler, but for */
/* directory items. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_newren_directory_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
_kernel_oserror * e = NULL;
hotlist_item * item;
hotlist_item * tempitem;
char * tempname;
int size;
/* This bit is similar to the start of hotlist_newedit_url_handler */
item = hotlist_find_selected_item();
ChkError(writablefield_get_value(0,
id_block->self_id,
HOTLIST_NEWDIRECTORY_NAME,
NULL,
0,
&size));
tempname = malloc(size + 1);
if (!tempname)
{
show_error_cont(make_no_memory_error(16));
return 1;
}
ChkError(writablefield_get_value(0,
id_block->self_id,
HOTLIST_NEWDIRECTORY_NAME,
tempname,
size,
NULL));
switch (alter_new)
{
case HOTLIST_MENUSECTION_NEW:
{
tempitem = hotlist_find_item(hotlist_root->data.directory_content, menu_itemno);
/* If we can't find the item the pointer was near, at at the */
/* start of the root; else add near the item. */
if (!tempitem)
{
menu_itemno = 0;
e = hotlist_new_directory(hotlist_root,
tempname,
HOTLIST_POSITION_END,
&tempitem);
}
else
{
/* The parent may be read-only */
if (tempitem->parent && (tempitem->parent->flags & HOTLIST_G_IS_READ_ONLY))
{
erb.errnum = Utils_Error_Custom_Message;
StrNCpy0(erb.errmess,
lookup_token("HLNewRO:You can't create an item here (the directory is read-only).",
0,0));
e = &erb;
}
else
{
e = hotlist_new_directory(tempitem,
tempname,
HOTLIST_POSITION_AFTER,
&tempitem);
}
}
if (!e)
{
hotlist_preopen();
e = hotlist_redraw_items(menu_itemno,
hotlist_count_displayed_items(hotlist_root->data.directory_content));
hotlist_clear_flags(hotlist_root, hl_ALL, HOTLIST_G_REDRAW_NOW);
hotlist_modified(HL_MODIFIED_ADD);
}
/* Free the temporary block and report any errors */
free(tempname);
ChkError(e);
}
break;
case HOTLIST_MENUSECTION_ALTER:
{
/* Alter an existing directory. If it is read-only, complain. */
if (item->flags & HOTLIST_G_IS_READ_ONLY)
{
erb.errnum = Utils_Error_Custom_Message;
StrNCpy0(erb.errmess,
lookup_token("NLAlterRO:You can't alter this item (it is read-only).",
0,0));
e = &erb;
free(tempname);
}
else
{
/* Free the item's existing name, link to the new */
/* name, and do the relevant redraws / hotlist */
/* modified calls. */
free(item->name);
item->name = tempname;
item->flags |= HOTLIST_G_REDRAW_NOW;
hotlist_preopen();
e = hotlist_redraw_now();
hotlist_modified(HL_MODIFIED_ALTER);
}
/* Report any errors */
ChkError(e);
}
break;
}
return 1;
}
/*************************************************/
/* hotlist_reset_url_handler() */
/* */
/* This function is called when Cancel is */
/* clicked on in the New (aka Edit) URL�dialogue */
/* box. It resets the contents to their previous */
/* state. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_reset_url_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
/* Action depends on whether we were altering, or creating an item */
switch (alter_new)
{
case HOTLIST_MENUSECTION_NEW:
{
ChkError(writablefield_set_value(0, id_block->self_id, HOTLIST_NEWURL_NAME, ""));
ChkError(writablefield_set_value(0, id_block->self_id, HOTLIST_NEWURL_URL, ""));
}
break;
case HOTLIST_MENUSECTION_ALTER:
{
hotlist_item * item = hotlist_find_selected_item();
if (item)
{
ChkError(writablefield_set_value(0, id_block->self_id, HOTLIST_NEWURL_NAME, item->name));
ChkError(writablefield_set_value(0, id_block->self_id, HOTLIST_NEWURL_URL, item->data.url));
}
}
break;
}
return 1;
}
/*************************************************/
/* hotlist_reset_directory_handler() */
/* */
/* Similar to hotlist_reset_url_handler, but for */
/* resetting the New (aka Rename) Directory */
/* dialogue. */
/* */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_reset_directory_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
switch (alter_new)
{
case HOTLIST_MENUSECTION_NEW:
{
ChkError(writablefield_set_value(0,
id_block->self_id,
HOTLIST_NEWDIRECTORY_NAME,
""));
}
break;
case HOTLIST_MENUSECTION_ALTER:
{
hotlist_item * item = hotlist_find_selected_item();
if (item) ChkError(writablefield_set_value(0,
id_block->self_id,
HOTLIST_NEWDIRECTORY_NAME,
item->name));
}
break;
}
return 1;
}
/*************************************************/
/* hotlist_drag_renderer() */
/* */
/* Renders a single hotlist item at 0,0 for use */
/* with DragAnObject. */
/* */
/* Parameters: Pointer to the item to render; */
/* */
/* Height of a hotlist item in OS */
/* units; */
/* */
/* Width of a hotlist directory */
/* sprite in OS units; */
/* */
/* Width of a hotlist URL sprite in */
/* OS units. */
/*************************************************/
static void hotlist_drag_renderer(hotlist_item * item, unsigned int item_height,
unsigned int item_dir_width, unsigned int item_url_width)
{
/* DON'T put Printf's in here... Doesn't work, at least, */
/* not with PipeFS output methods. */
WimpIconBlock hotlist_iconblock;
int temp_width;
int text_width;
/* Create an icon block for the sprite component */
hotlist_iconblock.flags = HOTLIST_SPRITE_ICON_FLAGS;
hotlist_iconblock.data.is.sprite_area = (void *) sprite_block;
/* Set appropriate sprite and width of sprite */
switch(item->type)
{
case hl_url:
{
hotlist_iconblock.data.is.sprite = !(item->flags & HOTLIST_G_IS_READ_ONLY) ? URL_SPRITE : RESOURCES_URL_SPRITE;
hotlist_iconblock.data.is.sprite_name_length = strlen(hotlist_iconblock.data.is.sprite);
temp_width = item_url_width;
}
break;
case hl_directory:
{
hotlist_iconblock.data.is.sprite = !(item->flags & HOTLIST_G_IS_READ_ONLY) ? CLOSED_DIRECTORY_SPRITE : CLOSED_RESOURCES_DIRECTORY_SPRITE;
hotlist_iconblock.data.is.sprite_name_length = strlen(hotlist_iconblock.data.is.sprite);
temp_width = item_dir_width;
}
break;
default:
{
temp_width = 0;
}
break;
}
/* Set the bounding box */
hotlist_iconblock.bbox.xmin = 2;
hotlist_iconblock.bbox.xmax = 2 + temp_width;
hotlist_iconblock.bbox.ymax = 2 + item_height;
hotlist_iconblock.bbox.ymin = 2;
/* Plot the item */
if (wimp_plot_icon(&hotlist_iconblock)) return; /* Bail out on error! */
/* Create an icon block for the text component */
if (item->type == hl_url && hl_show_urls) utils_text_width(item->data.url, &text_width, 0);
else utils_text_width(item->name, &text_width, 0);
hotlist_iconblock.flags = HOTLIST_TEXT_ICON_FLAGS_DRAG;
/* Set the bounding box */
hotlist_iconblock.bbox.xmin = temp_width + 4;
hotlist_iconblock.bbox.xmax = temp_width + text_width + 16;
hotlist_iconblock.bbox.ymax = item_height;
hotlist_iconblock.bbox.ymin = 4;
/* Set the text according to the item type */
if (item->type == hl_url && hl_show_urls)
{
hotlist_iconblock.data.it.buffer = item->data.url;
hotlist_iconblock.data.it.buffer_size = strlen(item->data.url);
hotlist_iconblock.data.it.validation = NULL;
}
else
{
hotlist_iconblock.data.it.buffer = item->name;
hotlist_iconblock.data.it.buffer_size = strlen(item->name);
hotlist_iconblock.data.it.validation = NULL;
}
/* Plot the icon */
wimp_plot_icon(&hotlist_iconblock);
/* Finished */
return;
}
/*************************************************/
/* hotlist_start_drag() */
/* */
/* Start a new drag operation inside the hotlist */
/* window. */
/*************************************************/
static _kernel_oserror * hotlist_start_drag(void)
{
/* Do the hard work elsewhere... */
RetError(hotlist_start_drag_backend());
/* Reset autoscroll */
RetError(hotlist_autoscroll(0));
/* Register NULL handler */
register_null_claimant(Wimp_ENull, hotlist_null_handler, NULL);
/* Finished */
return NULL;
}
/*************************************************/
/* hotlist_start_drag_backend() */
/* */
/* This function is called by hotlist_start_drag */
/* to do most of the work for starting a drag */
/* operation from within the hotlist window. A */
/* drag box is created, bounding all selected */
/* items. */
/*************************************************/
static _kernel_oserror * hotlist_start_drag_backend(void)
{
WimpGetWindowStateBlock state;
WimpGetPointerInfoBlock pointerblock;
WimpDragBox box;
hotlist_item * item;
unsigned int item_height, item_dir_width, item_url_width;
BBox bbox;
int xorigin, yorigin;
int screenwidth, screenheight;
/* Read the pointer position and get the hotlist item sizes */
RetError(wimp_get_pointer_info(&pointerblock));
RetError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
/* Record whether ot not Adjust (and only Adjust) was used */
hotlist_dragging.using_adjust = (pointerblock.button_state == Wimp_MouseButtonAdjust);
/* Get the shape of the selected items */
hotlist_get_selected_shape(&bbox);
/* Now get information on the hotlist window itself, */
/* and the current screen shape. */
RetError(window_get_wimp_handle(0, hotlist_windowid, &state.window_handle));
RetError(wimp_get_window_state(&state));
xorigin = state.xscroll - state.visible_area.xmin;
yorigin = state.yscroll - state.visible_area.ymax;
/* Screen size, pixels */
screenwidth = bbc_modevar(-1, BBC_XWindLimit);
screenheight = bbc_modevar(-1, BBC_YWindLimit);
/* Convert to OS units */
screenwidth = (screenwidth + 1) << (bbc_modevar(-1, BBC_XEigFactor));
screenheight = (screenheight + 1) << (bbc_modevar(-1, BBC_YEigFactor));
/* Read CMOS - solid drags, or a dashed outline? */
if (_kernel_osbyte(161, 28, 0) & (1 << (8 + 1)))
{
_kernel_swi_regs regs;
int redraw_params[4];
/* Solid drags */
item = hotlist_find_selected_item();
/* A single item, or several? */
if (
(hotlist_count_selected_items() == 1 && item->type == hl_url) ||
(
hotlist_count_selected_items() == 1 &&
item->type == hl_directory &&
(
!(item->flags & HOTLIST_D_IS_OPEN) ||
hotlist_no_contents_selected(item->data.directory_content) ||
item->data.directory_content == NULL
)
)
)
{
/* A single item. Set up the box shape */
box.dragging_box.xmin = bbox.xmin - xorigin;
box.dragging_box.ymin = bbox.ymin - yorigin;
box.dragging_box.xmax = bbox.xmax - xorigin;
box.dragging_box.ymax = bbox.ymax - yorigin;
/* Store details of the redraw */
redraw_params[0] = (int) hotlist_find_selected_item();
redraw_params[1] = (int) item_height;
redraw_params[2] = (int) item_dir_width;
redraw_params[3] = (int) item_url_width;
/* Fill in the register block */
regs.r[0] = (2<<0) | (2<<2) | (1<<6) | (1<<7) | (1<<16);
regs.r[1] = (int) hotlist_drag_renderer;
regs.r[2] = (int) redraw_params;
regs.r[3] = (int) &(box.dragging_box);
/* Start the drag - use DragAnObject, as then we can show */
/* the item's text, as seen in the hotlist window, during */
/* the drag. */
RetError(_kernel_swi(DragAnObject_Start, ®s, ®s));
/* Finished; flag that we're solid-dragging an object and exit */
hotlist_dragging.drag_type = HOTLIST_SOLID_DRAG_OBJECT;
return NULL;
}
else
{
int width, height;
/* Several items. */
RetError(read_sprite_size(SELECTION_SPRITE, &width, &height));
/* Set the box shape, based around the mouse pointer coordinates */
box.dragging_box.xmin = pointerblock.x - (width / 2 + 10); /* '+ 10' = aesthetics */
box.dragging_box.ymin = pointerblock.y - (height / 2 + 10);
box.dragging_box.xmax = pointerblock.x + (width / 2 + 10);
box.dragging_box.ymax = pointerblock.y + (height / 2 + 10);
/* Fill in the register block */
regs.r[0] = (1<<0) | (1<<2) | (1<<6) | (1<<7);
regs.r[1] = (int) sprite_block;
regs.r[2] = (int) "package";
regs.r[3] = (int) &(box.dragging_box);
/* Start the drag - use DragASprite as there's no text to */
/* show with the 'package' icon. */
RetError(_kernel_swi(DragASprite_Start, ®s, ®s));
/* Finished; flag that we're solid-dragging an object and exit */
hotlist_dragging.drag_type = HOTLIST_SOLID_DRAG_SPRITE;
return NULL;
}
}
/* CMOS said - use a dashed outline drag. */
box.drag_type = Wimp_DragBox_DragFixedDash;
/* Set the box shape */
box.dragging_box.xmin = bbox.xmin - xorigin;
box.dragging_box.xmax = bbox.xmax - xorigin;
box.dragging_box.ymin = bbox.ymin - yorigin;
box.dragging_box.ymax = bbox.ymax - yorigin;
/* Constrain the drag to the screen size */
box.parent_box.xmin = box.dragging_box.xmin - pointerblock.x;
box.parent_box.xmax = box.dragging_box.xmax - pointerblock.x + screenwidth;
box.parent_box.ymin = box.dragging_box.ymin - pointerblock.y;
box.parent_box.ymax = box.dragging_box.ymax - pointerblock.y + screenheight;
/* Start the drag */
RetError(wimp_drag_box(&box));
/* Finished; flag that we're dragging an object with a dashed outline and exit */
hotlist_dragging.drag_type = HOTLIST_BOX_DRAG;
return NULL;
}
/*************************************************/
/* hotlist_drag_stop_handler() */
/* */
/* Terminates any hotlist drag in progress. */
/*************************************************/
static int hotlist_drag_stop_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
_kernel_oserror * e;
int dragging = hotlist_dragging.drag_type;
#ifdef TRACE
if (tl & (1u<<25)) Printf("hotlist_drag_stop_handler: Called\n");
#endif
/* If we're not dragging in the hotlist, something weird is */
/* going on! So definitely, ignore the event... */
if (hotlist_dragging.drag_type == HOTLIST_NOT_DRAGGING) return 0;
/* Make sure we clear the dragging flag as soon as possible. */
/* If it gets left switched on, then drags in other parts of */
/* the browser could get misinterpreted by the hotlist code. */
dragging = hotlist_dragging.drag_type;
hotlist_dragging.drag_type = HOTLIST_NOT_DRAGGING;
if (hotlist_current_highlighted)
{
hotlist_current_highlighted->flags &= ~HOTLIST_D_IS_HIGHLIGHTED;
ChkError(hotlist_redraw_items(highlighted_itemno, highlighted_itemno));
hotlist_current_highlighted = NULL;
}
/* Deal with each dragging type */
switch (dragging)
{
/* Complain if we don't understand it */
default:
{
hotlist_dragging.drag_type = HOTLIST_NOT_DRAGGING;
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Value %d of hotlist_dragging.drag_type not understood in hotlist_drag_stop_handler",
hotlist_dragging.drag_type);
show_error_ret(&erb);
#endif
return 0;
}
break;
case HOTLIST_SOLID_DRAG_OBJECT:
{
/* Stop drag an object */
e = _swix(DragAnObject_Stop, 0);
deregister_null_claimant(Wimp_ENull, hotlist_null_handler, NULL);
ChkError(e);
}
break;
case HOTLIST_SOLID_DRAG_SPRITE:
{
/* Stop drag a sprite */
e = _swix(DragASprite_Stop, 0);
deregister_null_claimant(Wimp_ENull, hotlist_null_handler, NULL);
ChkError(e);
}
break;
case HOTLIST_BOX_DRAG_SELECTION:
{
/* Stop drag box */
e = wimp_drag_box(NULL);
deregister_null_claimant(Wimp_ENull, hotlist_null_drag_select_handler, NULL);
/* Deselect anything that is currently selected */
hotlist_clear_flags(hotlist_root->data.directory_content, hl_ALL, HOTLIST_G_DRAG_SELECTED);
ChkError(hotlist_redraw_now());
ChkError(e);
}
break;
case HOTLIST_BOX_DRAG:
{
e = wimp_drag_box(NULL);
deregister_null_claimant(Wimp_ENull, hotlist_null_handler, NULL);
ChkError(e);
}
break;
}
return 1;
}
/*************************************************/
/* hotlist_drag_completed_handler() */
/* */
/* This function is called when a user_drag */
/* completes. If the drag is one started by the */
/* hotlist section it is processed. Dropping the */
/* drag in the hotlist window will move or copy */
/* the items being dragged; dropping in any */
/* other window will try to save the relevant */
/* datatype (URI or HTML) to that window. */
/*************************************************/
static int hotlist_drag_completed_handler(int event_code, WimpPollBlock * event, IdBlock * id_block, void * handle)
{
WimpGetWindowStateBlock state;
WimpGetPointerInfoBlock pointerblock;
hotlist_item * targetitem;
hotlist_item * sourceitem;
int window_handle;
unsigned int item_height, item_dir_width, item_url_width;
unsigned int top, bottom;
int xmin, xmax;
int winx, winy;
int position;
int dragging;
int shift = 0;
#ifdef TRACE
if (tl & (1u<<25)) Printf("hotlist_drag_completed_handler: Called\n");
#endif
/* If we're not dragging in the hotlist, the Wimp returned */
/* this because someone else completed a drag (e.g. a save */
/* dialogue). In that case, ignore the event. */
if (hotlist_dragging.drag_type == HOTLIST_NOT_DRAGGING) return 0;
/* Make sure we clear the dragging flag as soon as possible. */
/* If it gets left switched on, then drags in other parts of */
/* the browser could get misinterpreted by the hotlist code. */
dragging = hotlist_dragging.drag_type;
hotlist_dragging.drag_type = HOTLIST_NOT_DRAGGING;
/* Check if SHIFT is pressed */
_swix(OS_Byte,
_INR(0,1) | _OUT(1),
121,
128,
&shift);
/* Reset autoscrolling (To restore pointer if necessary) */
show_error_ret(hotlist_autoscroll(0));
/* Deal with each dragging type */
switch (dragging)
{
/* Complain if we don't understand it */
default:
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Value %d of hotlist_dragging.drag_type not understood in hotlist_drag_completed_handler",
hotlist_dragging.drag_type);
show_error_ret(&erb);
#endif
return 0;
}
break;
/* For e.g. dragging a single URL or directory item */
case HOTLIST_SOLID_DRAG_OBJECT:
{
_swix(DragAnObject_Stop, 0);
}
break;
/* For e.g. dragging a selection under the 'package' icon */
case HOTLIST_SOLID_DRAG_SPRITE:
{
_swix(DragASprite_Stop, 0);
}
break;
/* For e.g. dragging a single URL or selection without solid drags emables */
case HOTLIST_BOX_DRAG:
{
/* No special action required in this case */
}
break;
/* When dragging out a box to dynamically select hotlist items */
case HOTLIST_BOX_DRAG_SELECTION:
{
deregister_null_claimant(Wimp_ENull, hotlist_null_drag_select_handler, NULL);
hotlist_convert_drag_selection(hotlist_root->data.directory_content);
return 0;
}
break;
}
/* If there is a currently highlighted directory (i.e. something */
/* was to be dropped into it) unhighlight that item. */
if (hotlist_current_highlighted)
{
hotlist_current_highlighted->flags &= ~HOTLIST_D_IS_HIGHLIGHTED;
hotlist_redraw_items(highlighted_itemno, highlighted_itemno);
hotlist_current_highlighted = NULL;
}
/* Remove the drag null handler */
deregister_null_claimant(Wimp_ENull, hotlist_null_handler, NULL);
/* Remember the first selected item in the hotlist */
sourceitem = hotlist_find_selected_item();
/* Get information on the pointer */
wimp_get_pointer_info(&pointerblock);
/* Was the drag ended over the hotlist window? */
ChkError(window_get_wimp_handle(0,
hotlist_windowid,
&window_handle));
if (window_handle == pointerblock.window_handle)
{
/* Yes, the drag ended over the hotlist window. */
if (pointerblock.icon_handle != -1) return 0; /* (Only understand drops on workspace) */
/* Find item sizes, the window x and y coordinate of the */
/* drop point, and from this, the targetted hotlist item. */
ChkError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
state.window_handle = pointerblock.window_handle;
ChkError(wimp_get_window_state(&state));
winx = pointerblock.x + (state.xscroll - state.visible_area.xmin);
winy = pointerblock.y + (state.yscroll - state.visible_area.ymax);
top = (-winy) / item_height;
targetitem = hotlist_find_item(hotlist_root->data.directory_content, top);
/* Decide where to put the items */
if (targetitem)
{
/* If we've dropped on a selected or read-only item, do nothing */
if (targetitem->flags & (HOTLIST_G_IS_SELECTED | HOTLIST_G_IS_READ_ONLY)) return 0;
/* Otherwise, find the x coordinate span of the target item... */
hotlist_get_shape(&xmin, &xmax, targetitem);
if (targetitem->type == hl_directory && winx >= xmin && winx <= xmin + item_dir_width)
{
/* ...and if the drop point was within the x span of the */
/* directory icon part of a directory, place in that */
/* directory (directories will only show the '+' icon, */
/* i.e. highlighted, when the pointer hovers over the */
/* sprite component). */
position = HOTLIST_POSITION_BEGINNING;
}
else
{
if ((-winy % item_height) > item_height / 2)
{
/* If we're over half way past the item, place after it, unless */
/* it is an open directory. Again, the null handler dealing */
/* with highlighting directory sprites reflects this situation */
/* correctly. */
if (
targetitem->type == hl_directory &&
targetitem->flags & HOTLIST_D_IS_OPEN
)
{
position = HOTLIST_POSITION_BEGINNING;
}
else
{
position = HOTLIST_POSITION_AFTER;
}
}
else
{
/* Otherwise, place before */
position = HOTLIST_POSITION_BEFORE;
}
}
}
else
{
/* If there is no target item, add to the end of the hotlist root */
targetitem = hotlist_root;
position = HOTLIST_POSITION_END;
}
/* Find the selected item. If its number is less than the one */
/* we estimated from the drop y coordinate, use that instead. */
{
int selected;
selected = hotlist_find_no_from_item(hotlist_find_selected_item());
if (selected < top) top = selected;
}
/* Count how many items are displayed to get the last hotlist item */
bottom = hotlist_count_displayed_items(hotlist_root->data.directory_content);
if (!shift)
{
/* If shift isn't pressed, move selected items */
do
{
/* Ensure the source item is deselected */
sourceitem->flags &= ~HOTLIST_G_IS_SELECTED;
/* Move it */
ChkError(hotlist_move_item(sourceitem,
targetitem,
position));
/* If this is a directory, deselect its contents */
if (sourceitem->type == hl_directory)
{
hotlist_clear_flags(sourceitem->data.directory_content,
hl_ALL,
HOTLIST_G_IS_SELECTED);
}
targetitem = sourceitem;
sourceitem = hotlist_find_selected_item();
/* Loop round moving all following items for as long as */
/* anything is still selected - making sure we copy */
/* them all after what we just added. */
position = HOTLIST_POSITION_AFTER;
}
while (sourceitem);
ChkError(hotlist_modified(HL_MODIFIED_MOVE));
}
else
{
/* Shift is pressed, so copy the items. The code is very */
/* similar in structure to the move stuff above. */
do
{
sourceitem->flags &= ~HOTLIST_G_IS_SELECTED;
ChkError(hotlist_copy_item(sourceitem,
targetitem,
position,
&targetitem));
if (sourceitem->type == hl_directory)
{
hotlist_clear_flags(sourceitem->data.directory_content,
hl_ALL,
HOTLIST_G_IS_SELECTED);
}
sourceitem = hotlist_find_selected_item();
position = HOTLIST_POSITION_AFTER;
}
while (sourceitem);
ChkError(hotlist_modified(HL_MODIFIED_COPY));
}
/* The displayed item count may have changed, so take the greatest */
/* value of this as the bottom item to redraw between. */
{
int new_bottom = hotlist_count_displayed_items(hotlist_root->data.directory_content);
if (new_bottom > bottom) bottom = new_bottom;
}
/* Ensure the window extent etc. is up to date */
hotlist_preopen();
/* Redraw the relevant regions of the window */
ChkError(hotlist_redraw_items(top, bottom));
}
else
{
/* No - the drag did not end over the hotlist window */
if (
sourceitem &&
hotlist_count_selected_items() == 1 &&
sourceitem->type == hl_url
)
{
/* There is a single selected item which is a URL. So, save */
/* it as a URI file. */
hotlist_initiate_uri_save(sourceitem);
}
else
{
/* Can't save URI file when saving more than one URL, */
/* so save an HTML file instead. */
hotlist_initiate_html_save(lookup_token("HotlistLeafname:Hotlist",0,0));
}
}
/* If we were using Adjust, close the window */
if (hotlist_dragging.using_adjust)
{
hotlist_dragging.using_adjust = 0;
ChkError(toolbox_hide_object(0, hotlist_windowid));
}
/* Finished */
return 1;
}
/*************************************************/
/* hotlist_autoscroll() */
/* */
/* Auto-scrolls a window. */
/* */
/* Parameters: Object ID of the window to scroll */
/* or 0 to reset autoscrolling. */
/*************************************************/
static _kernel_oserror * hotlist_autoscroll(int window)
{
WimpGetWindowStateBlock state;
ObjectId over_window;
ObjectId parent;
ComponentId component;
BBox extent;
int scroll_changed;
int x, y, position;
int autoscroll_newtime;
static unsigned int scrolling, autoscroll_oldtime;
static unsigned int mouse_shape = Mouse_Shape_Normal;
/* Reset autoscroll handling if requested */
if (!window)
{
#ifdef TRACE
if (tl & (1<<25)) Printf("hotlist_autoscroll: Resetting\n");
#endif
scrolling = 0;
mouse_set_pointer_shape(Mouse_Shape_Normal);
mouse_shape = Mouse_Shape_Normal;
return _swix(OS_ReadMonotonicTime,
_OUT(0),
&autoscroll_oldtime);
}
/* What window is the pointer over? */
RetError(window_get_pointer_info(0, &x, &y, NULL, &over_window, NULL));
/* Get information on the window given to the function */
RetError(window_get_wimp_handle(0, window, &state.window_handle));
RetError(wimp_get_window_state(&state));
RetError(window_get_extent(0, window, &extent));
/* Find location of pointer relative to the given window */
if (
x < state.visible_area.xmin ||
x > state.visible_area.xmax ||
y < state.visible_area.ymin ||
y > state.visible_area.ymax
)
{
/* Outside the visible area */
position = 0;
}
else if (
x > state.visible_area.xmin + choices.auto_scroll_margin &&
x < state.visible_area.xmax - choices.auto_scroll_margin &&
y > state.visible_area.ymin + choices.auto_scroll_margin &&
y < state.visible_area.ymax - choices.auto_scroll_margin
)
{
/* Pointer is inside the non-scrolling region of the given window */
position = 1;
}
else
{
/* Pointer is inside the scrolling region of the given window */
position = 2;
}
/* Work out what scroll settings to give, flagging if there is */
/* a change in 'scroll_changed'. */
scroll_changed = 0;
if (position == 0 || position == 2)
{
/* Check position relative to the top/bottom of the window */
if (y > state.visible_area.ymax - choices.auto_scroll_margin)
{
/* At or over the top of the window */
if (state.yscroll < extent.ymax)
{
scroll_changed = 1;
state.yscroll += (y - (state.visible_area.ymax - choices.auto_scroll_margin));
}
}
else
{
if (y < state.visible_area.ymin + choices.auto_scroll_margin)
{
/* At or under the bottom of the window */
if (state.yscroll > extent.ymin + (state.visible_area.ymax - state.visible_area.ymin))
{
scroll_changed = 1;
state.yscroll -= ((state.visible_area.ymin + choices.auto_scroll_margin) - y);
}
}
}
/* Check the position relative to the left/right of the window, too */
if (x > state.visible_area.xmax - choices.auto_scroll_margin)
{
/* At or to the right of the right hand edge of the window */
if (state.xscroll < extent.xmax - (state.visible_area.xmax - state.visible_area.xmin))
{
scroll_changed = 1;
state.xscroll += (x - (state.visible_area.xmax - choices.auto_scroll_margin));
}
}
else
{
if (x < state.visible_area.xmin + choices.auto_scroll_margin)
{
/* At or to the left of the left hand edge of the window */
if (state.xscroll > extent.xmin)
{
scroll_changed = 1;
state.xscroll -= ((state.visible_area.xmin + choices.auto_scroll_margin) - x);
}
}
}
}
/* Deal with flags and the mouse pointer */
switch (position)
{
/* If we're outside the visible area of the window, and not scrolling, */
/* set the pointer back to a normal shape (else leave it alone). */
case 0:
{
if (!scrolling)
{
RetError(_swix(OS_ReadMonotonicTime,
_OUT(0),
&autoscroll_oldtime));
if (mouse_shape != Mouse_Shape_Normal)
{
mouse_set_pointer_shape(Mouse_Shape_Normal);
mouse_shape = Mouse_Shape_Normal;
}
}
}
break;
/* If we're in the non-scrolling region, unset the 'scrolling' flag */
/* and set the mouse pointer back to a normal shape. */
case 1:
{
scrolling = 0;
RetError(_swix(OS_ReadMonotonicTime,
_OUT(0),
&autoscroll_oldtime));
if (mouse_shape != Mouse_Shape_Normal)
{
mouse_set_pointer_shape(Mouse_Shape_Normal);
mouse_shape = Mouse_Shape_Normal;
}
}
break;
/* If inside the scrolling region, wait a while on the 'ToScroll' */
/* pointer, then start scrolling. */
case 2:
{
if (!scrolling && scroll_changed)
{
RetError(_swix(OS_ReadMonotonicTime,
_OUT(0),
&autoscroll_newtime));
/* If we exceed the autoscroll delay, set the scrolling flag */
if (autoscroll_newtime - autoscroll_oldtime > choices.auto_scroll_delay)
{
scrolling = 1;
}
/* Otherwise, set the 'ToScroll' pointer */
else
{
if (mouse_shape != Mouse_Shape_ToScroll)
{
mouse_shape = Mouse_Shape_ToScroll;
mouse_set_pointer_shape(Mouse_Shape_ToScroll);
}
}
}
/* If the scroll position hasn't changed, update oldtime */
if (!scroll_changed)
{
RetError(_swix(OS_ReadMonotonicTime,
_OUT(0),
&autoscroll_oldtime));
}
}
break;
}
/* Closing actions to take if scrolling is in progress. */
if (scrolling)
{
if (scroll_changed)
{
/* If the scroll position has changed, update the window */
RetError(toolbox_get_parent(0,
window,
&parent,
&component));
RetError(toolbox_show_object(0,
window,
Toolbox_ShowObject_FullSpec,
&state.visible_area,
parent,
component));
/* Ensure the pointer shape is correct */
if (mouse_shape != Mouse_Shape_Scrolling)
{
mouse_shape = Mouse_Shape_Scrolling;
mouse_set_pointer_shape(Mouse_Shape_Scrolling);
}
}
else
{
/* If the scroll position has not changed, set the pointer */
/* shape to normal, and unset the scrolling flag - we've */
/* scrolled to the limit of the window extent. */
if (mouse_shape != Mouse_Shape_Normal)
{
mouse_shape = Mouse_Shape_Normal;
mouse_set_pointer_shape(Mouse_Shape_Normal);
scrolling = 0;
}
}
}
/* Finished */
return NULL;
}
/*************************************************/
/* hotlist_null_handler() */
/* */
/* Called every null event while a drag is in */
/* operation. */
/* */
/* Parameters are as standard for a Wimp event */
/* handler. */
/*************************************************/
static int hotlist_null_handler(int event_code, WimpPollBlock * event, IdBlock * id_block, void * handle)
{
WimpGetWindowStateBlock state;
hotlist_item * item;
ObjectId window;
unsigned int item_height, item_dir_width, item_url_width;
unsigned int itemno;
int x, y, buttons;
int xmin, xmax;
int remove_highlight = 0;
/* Get information on the pointer position */
ChkError(window_get_pointer_info(0, &x, &y, &buttons, &window, NULL));
/* Deal with autoscroll */
ChkError(hotlist_autoscroll(hotlist_windowid));
if (window == hotlist_windowid)
{
/* The pointer is over the hotlist window */
ChkError(window_get_wimp_handle(0, window, &state.window_handle));
/* Display arrow pointing into directory to say that dropping */
/* here will put in directory rather than next to it. First, */
/* get the window state. */
ChkError(wimp_get_window_state(&state));
/* Work out the item that the pointer is over */
ChkError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
x += (state.xscroll - state.visible_area.xmin);
y += (state.yscroll - state.visible_area.ymax);
itemno = -y / item_height;
item = hotlist_find_item(hotlist_root->data.directory_content, itemno);
/* Is this a directory item which is already not selected? (The */
/* selected check is so that we don't end up highlighting the */
/* item we're dragging if this item is a directory). */
if (item && item->type == hl_directory && !(item->flags & HOTLIST_G_IS_SELECTED))
{
ChkError(hotlist_get_shape(&xmin, &xmax, item));
/* If we're over the directory sprite, or half way under the item height when */
/* the directory is open. */
if (
(
x >= xmin &&
x <= xmin + item_dir_width
)
||
(
((-y % item_height) > item_height / 2) &&
item->flags & HOTLIST_D_IS_OPEN
)
)
{
/* ...and the currently highlighted item isn't the one we're over, and */
/* it isn't read only... */
if (
hotlist_current_highlighted != item &&
!(item->flags & HOTLIST_G_IS_READ_ONLY)
)
{
/* ...then first, clear any highlighted item */
if (hotlist_current_highlighted)
{
hotlist_current_highlighted->flags &= ~HOTLIST_D_IS_HIGHLIGHTED;
ChkError(hotlist_redraw_items(highlighted_itemno, highlighted_itemno));
}
/* Now highlight the item we're over */
item->flags |= HOTLIST_D_IS_HIGHLIGHTED;
hotlist_current_highlighted = item;
highlighted_itemno = itemno;
ChkError(hotlist_redraw_items(highlighted_itemno, highlighted_itemno));
/* Reset the auto-open timer */
ChkError(_swix(OS_ReadMonotonicTime,
_OUT(0),
&autoopen_oldtime));
}
else if (hotlist_current_highlighted == item)
{
int new_time;
/* If we've stayed over the same highlighted item, */
/* keep a count of for how long, and if required, */
/* automatically open the directory. */
ChkError(_swix(OS_ReadMonotonicTime,
_OUT(0),
&new_time));
if (
choices.auto_open_delay &&
!(item->flags & HOTLIST_D_IS_OPEN) &&
new_time - autoopen_oldtime > choices.auto_open_delay
)
{
/* Auto-open the directory */
item->flags |= HOTLIST_D_IS_OPEN;
hotlist_preopen();
ChkError(hotlist_redraw_items(highlighted_itemno,
hotlist_count_displayed_items(hotlist_root->data.directory_content)));
}
}
}
else
{
/* If we're not over a directory sprite, clear any existing */
/* highlight. */
remove_highlight = 1;
}
}
/* If we're not over a directory at all, never mind it's directory */
/* sprite component, again, clear any existing highlight. */
else remove_highlight = 1;
}
/* The following executes if the pointer is not over the hotlist window */
else
{
/* Again, clear any highlighted directory sprite. */
remove_highlight = 1;
}
/* If we're not over a directory sprite, clear any existing */
/* highlight. */
if (remove_highlight && hotlist_current_highlighted)
{
hotlist_current_highlighted->flags &= ~HOTLIST_D_IS_HIGHLIGHTED;
ChkError(hotlist_redraw_items(highlighted_itemno, highlighted_itemno));
hotlist_current_highlighted = NULL;
}
/* Finished */
return 0;
}
//
// Simple non-scrolling selection box, to be improved later...
// Workarea relative corner of selection box may not be needed.
//
static int selection_x, selection_y;
/*************************************************/
/* hotlist_start_drag() */
/* */
/* This function is called to start a selection */
/* box operation in the hotlist window. */
/*************************************************/
static _kernel_oserror * hotlist_selection_box_start(void)
{
WimpGetPointerInfoBlock pointerblock;
WimpGetWindowStateBlock state;
WimpDragBox box;
/* Get the pointer position and info on the hotlist window */
RetError(wimp_get_pointer_info(&pointerblock));
RetError(window_get_wimp_handle(0, hotlist_windowid, &state.window_handle));
RetError(wimp_get_window_state(&state));
/* Remember the pointer position in window coordinates */
selection_x = pointerblock.x + (state.xscroll - state.visible_area.xmin);
selection_y = pointerblock.y + (state.yscroll - state.visible_area.ymax);
/* Set up the drag box structure */
box.drag_type = Wimp_DragBox_DragRubberDash;
box.dragging_box.xmin = pointerblock.x;
box.dragging_box.xmax = pointerblock.x;
box.dragging_box.ymin = pointerblock.y;
box.dragging_box.ymax = pointerblock.y;
box.parent_box.xmin = state.visible_area.xmin;
box.parent_box.xmax = state.visible_area.xmax;
box.parent_box.ymin = state.visible_area.ymin;
box.parent_box.ymax = state.visible_area.ymax;
/* Start the drag */
RetError(wimp_drag_box(&box));
/* Set global variable saying we are currently dragging */
/* so we know whether to process a user_drag_box event */
hotlist_dragging.drag_type = HOTLIST_BOX_DRAG_SELECTION;
/* Install the null handler */
register_null_claimant(Wimp_ENull, hotlist_null_drag_select_handler, NULL);
return NULL;
}
/*************************************************/
/* hotlist_null_drag_select_handler() */
/* */
/* This function is called as a null handler; */
/* it is responsible for selecting and */
/* deselecting items within and outside the */
/* rubber drag box started by */
/* hotlist_selection_box_start. */
/* */
/* Parameters are as standard for a Wimp event */
/* handler. */
/*************************************************/
static int hotlist_null_drag_select_handler(int event_code, WimpPollBlock * event, IdBlock * id_block, void * handle)
{
WimpGetPointerInfoBlock pointerblock;
WimpGetWindowStateBlock state;
unsigned int item_height, item_dir_width, item_url_width;
unsigned int item_min, item_max;
int workx, worky;
int minx, maxx;
/* Find the pointer position and get information on the hotlist window */
ChkError(wimp_get_pointer_info(&pointerblock));
ChkError(window_get_wimp_handle(0, hotlist_windowid, &state.window_handle));
ChkError(wimp_get_window_state(&state));
ChkError(hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width));
/* Get the mouse position in window coordinates */
workx = pointerblock.x + (state.xscroll - state.visible_area.xmin);
worky = pointerblock.y + (state.yscroll - state.visible_area.ymax);
/* Work out the items spanned by the drag box */
item_min = -worky / item_height;
if (-selection_y / item_height < item_min) item_min = -selection_y / item_height;
item_max = (-worky / item_height);
if ((-selection_y / item_height) > item_max) item_max = (-selection_y / item_height);
if (selection_x < workx)
{
minx = selection_x;
maxx = workx;
}
else
{
minx = workx;
maxx = selection_x;
}
/* Select them */
ChkError(hotlist_select_box(item_min, item_max, minx, maxx));
return 0;
}
/*************************************************/
/* hotlist_select_box() */
/* */
/* Sets the HOTLIST_G_DRAG_SELECTED flag for all */
/* visible items in the range first_item to */
/* last_item where their horizontal visible area */
/* intersects with the a line draw from minx to */
/* maxx. Clears the HOTLIST_G_DRAG_SELECTED */
/* flag for all other items. */
/* */
/* Parameters: Number of the first visible item; */
/* */
/* Number of the last visible item; */
/* */
/* minx (window coords); */
/* */
/* maxx (window coords). */
/*************************************************/
_kernel_oserror * hotlist_select_box(unsigned int first_item, unsigned int last_item, int minx, int maxx)
{
unsigned int itemno = 0;
return hotlist_select_box_r(first_item,
last_item,
hotlist_root->data.directory_content,
&itemno,
minx,
maxx);
}
/*************************************************/
/* hotlist_select_box_r() */
/* */
/* Recursive backend to hotlist_select_box. */
/* */
/* Parameters: Number of the first visible item; */
/* */
/* Number of the last visible item; */
/* */
/* First item in the directory to */
/* scan; */
/* */
/* Pointer to an int, in which the */
/* current item number is kept (for */
/* internal use only); */
/* */
/* minx (window coords); */
/* */
/* maxx (window coords). */
/*************************************************/
_kernel_oserror * hotlist_select_box_r(unsigned int first_item, unsigned int last_item, hotlist_item * item,
unsigned int * itemno, int minx, int maxx)
{
_kernel_oserror * e;
int itemxmin, itemxmax;
while (item)
{
if (*itemno >= first_item && *itemno <= last_item)
{
/* As long as we're within the item number specified, deal with items */
RetError(hotlist_get_shape(&itemxmin, &itemxmax, item));
/* Select items within the horizontal range */
if (!(maxx < itemxmin || minx > itemxmax))
{
if (!(item->flags & HOTLIST_G_DRAG_SELECTED))
{
item->flags |= HOTLIST_G_DRAG_SELECTED;
e = hotlist_redraw_items(*itemno, *itemno);
/* If directory is closed, select everything in it (if it is open, */
/* we should only select items the drag box covers). */
if (item->type == hl_directory && !(item->flags & HOTLIST_D_IS_OPEN))
{
hotlist_set_flags (item->data.directory_content, hl_ALL, HOTLIST_G_DRAG_SELECTED);
hotlist_clear_flags(item->data.directory_content, hl_ALL, HOTLIST_G_REDRAW_NOW);
}
if (e) return e;
}
}
/* Deselect items outside of the horizontal range */
else
{
if (item->flags & HOTLIST_G_DRAG_SELECTED)
{
item->flags &= ~HOTLIST_G_DRAG_SELECTED;
e = hotlist_redraw_items(*itemno, *itemno);
/* If directory is closed unselect everything in it */
if (item->type == hl_directory && !(item->flags & HOTLIST_D_IS_OPEN))
{
hotlist_clear_flags(item->data.directory_content,
hl_ALL,
HOTLIST_G_DRAG_SELECTED | HOTLIST_G_REDRAW_NOW);
}
if (e) return e;
}
}
}
else
{
/* If we're not within the item numbers specified, then deselect things */
if (item->flags & HOTLIST_G_DRAG_SELECTED)
{
item->flags &= ~HOTLIST_G_DRAG_SELECTED;
e = hotlist_redraw_items(*itemno, *itemno);
/* If directory is closed unselect everything in it */
if (item->type == hl_directory && !(item->flags & HOTLIST_D_IS_OPEN))
{
hotlist_clear_flags(item->data.directory_content,
hl_ALL,
HOTLIST_G_DRAG_SELECTED | HOTLIST_G_REDRAW_NOW);
}
if (e) return e;
}
}
/* Increment the item number character */
*itemno += 1;
/* Recurse for any open directory items */
if (item->type == hl_directory && item->flags & HOTLIST_D_IS_OPEN)
{
RetError(hotlist_select_box_r(first_item,
last_item,
item->data.directory_content,
itemno,
minx,
maxx));
}
/* Get the next item */
item = item->next;
}
/* Finished */
return NULL;
}
/*************************************************/
/* hotlist_contents_selected() */
/* */
/* Checks if all items and subdirectories are */
/* selected. */
/* */
/* Parameters: Pointer to the first hotlist_item */
/* to check. */
/* */
/* Returns: 1 if all items are selected, else */
/* 0 (there are unselected items). */
/*************************************************/
static unsigned int hotlist_contents_selected(hotlist_item * item)
{
while (item)
{
/* Keep trying to find an unselected item and */
/* immediately return 0 if found. */
if (!item->flags & HOTLIST_G_IS_SELECTED) return 0;
if (item->type == hl_directory)
{
if (!hotlist_contents_selected(item->data.directory_content)) return 0;
}
item = item->next;
}
return 1;
}
/*************************************************/
/* hotlist_no_contents_selected() */
/* */
/* Checks if all items and subdirectories are */
/* unselected. */
/* */
/* Parameters: Pointer to the first hotlist_item */
/* to check. */
/* */
/* Returns: 1 if all items are unselected, */
/* or 0 (there are selected items). */
/*************************************************/
static unsigned int hotlist_no_contents_selected(hotlist_item * item)
{
while (item)
{
/* Keep trying to find a selected item and */
/* immediately return 0 if found. */
if (item->flags & HOTLIST_G_IS_SELECTED) return 0;
if (item->type == hl_directory)
{
if (!hotlist_no_contents_selected(item->data.directory_content)) return 0;
}
item = item->next;
}
return 1;
}
/*************************************************/
/* hotlist_show_descriptions_handler() */
/* */
/* Selects Show Descriptions and redraws the */
/* hotlist window and relevant menus to reflect */
/* this. Parameters are as standard for a */
/* Toolbox event handler. */
/*************************************************/
static int hotlist_show_descriptions_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
ObjectId main_menu;
hl_show_urls = 0;
/* Update the menus */
ChkError(window_get_menu(0, hotlist_windowid, &main_menu));
hotlist_set_menu_details(main_menu);
/* Ensure the window is up to date */
hotlist_preopen();
/* Redraw as required */
ChkError(hotlist_redraw_items(0,
hotlist_count_displayed_items(hotlist_root->data.directory_content)));
return 1;
}
/*************************************************/
/* hotlist_show_urls_handler() */
/* */
/* Selects Show URLs and redraws the hotlist */
/* window and relevant menus to reflect this. */
/* Parameters are as standard for a Toolbox */
/* event handler. */
/*************************************************/
static int hotlist_show_urls_handler(int event_code, ToolboxEvent * event, IdBlock * id_block, void * handle)
{
ObjectId main_menu;
hl_show_urls = 1;
/* Update the menus */
ChkError(window_get_menu(0, hotlist_windowid, &main_menu));
hotlist_set_menu_details(main_menu);
/* Ensure the window is up to date */
hotlist_preopen();
/* Redraw as required */
ChkError(hotlist_redraw_items(0,
hotlist_count_displayed_items(hotlist_root->data.directory_content)));
return 1;
}
/*************************************************/
/* hotlist_convert_drag_selection() */
/* */
/* Recurses through the hotlist_item structure */
/* altering all 'HOTLIST_G_DRAG_SELECTED' items */
/* to have 'HOTLIST_G_IS_SELECTED' set or unset */
/* as is appropriate. */
/* */
/* dragselected and selected = unselected */
/* dragselected = selected */
/* selected = selected */
/* neither = unselected */
/* */
/* Parameters: Pointer to a hotlist_item to */
/* start on. */
/*************************************************/
static void hotlist_convert_drag_selection(hotlist_item *item)
{
while (item)
{
if (item->flags & HOTLIST_G_DRAG_SELECTED)
{
item->flags &= ~HOTLIST_G_DRAG_SELECTED;
if (item->flags & HOTLIST_G_IS_SELECTED) item->flags &= ~HOTLIST_G_IS_SELECTED;
else item->flags |= HOTLIST_G_IS_SELECTED;
}
/* Recursive call for directories */
if (item->type == hl_directory)
{
hotlist_convert_drag_selection(item->data.directory_content);
}
item = item->next;
}
}
/*************************************************/
/* hotlist_modified() */
/* */
/* Called whenever the hotlist is modified. */
/* */
/* Parameters: The operaton that modified the */
/* hotlist, as a number; see the */
/* HL_MODIFIED_... definitions in */
/* Hotlist.h. */
/*************************************************/
static _kernel_oserror * hotlist_modified(unsigned int type)
{
#ifdef TRACE
if (tl & (1u<<25)) Printf("hotlist_modified: Called\n");
#endif
if (choices.save_hotlist == Choices_SaveHotlist_Always)
{
/* If we've loaded a resources file, there's no point */
/* saving the hotlist because the read-only parts will */
/* not get saved anyway. */
if (type != HL_MODIFIED_LOADED_RESOURCES)
{
#ifdef SINGLE_USER
return hotlist_save(lookup_choice("HotlistSave:Browse:User.Hotlist",0,0));
#else
multiuser_save_hotlist();
return NULL;
#endif
}
}
return NULL;
}
/*************************************************/
/* hotlist_initiate_uri_save() */
/* */
/* Starts file transfer of a URI file to another */
/* application. */
/* */
/* Parameters: Pointer to the hotlist item to */
/* save as a URI file. */
/*************************************************/
static _kernel_oserror * hotlist_initiate_uri_save(hotlist_item * item)
{
WimpGetPointerInfoBlock block;
WimpMessage message;
int ctrl;
/* Is Control being pressed? */
_swix(OS_Byte,
_INR(0,1) | _OUT(1),
121,
129,
&ctrl);
/* Find out where the pointer is */
RetError(wimp_get_pointer_info(&block));
/* Get the leafname. Use a message block for the buffer because */
/* there's no point generating anything longer than can actually */
/* be sent out in a message. */
urlutils_leafname_from_url(item->data.url,
message.data.data_save.leaf_name,
sizeof(message.data.data_save.leaf_name));
/* Send Message_DataSave to start file transfer - a URI file, */
/* or if Control is held down, a URL file. */
return protocols_atats_send_data_save(NULL,
item,
message.data.data_save.leaf_name,
save_uri_size(item->data.url, item->name, 0),
ctrl ? FileType_URL : FileType_URI,
protocols_saving_hotlist_entry,
&block);
}
/*************************************************/
/* hotlist_initiate_html_save() */
/* */
/* Starts file transfer of a selection in the */
/* hotlist as an HTML file. */
/* */
/* Parameters: Pointer to a null-terminated */
/* leafname to save as. */
/*************************************************/
static _kernel_oserror * hotlist_initiate_html_save(char * filename)
{
WimpGetPointerInfoBlock block;
WimpMessage message;
RetError(wimp_get_pointer_info(&block));
/* Ensure the leafname isn't too long for a message */
StrNCpy0(message.data.data_save.leaf_name, filename);
/* Send Message_DataSave to start file transfer */
return protocols_atats_send_data_save(NULL,
NULL,
message.data.data_save.leaf_name,
-1,
FileType_HTML,
protocols_saving_hotlist_selection,
&block);
}
/*************************************************/
/* hotlist_return_window_id() */
/* */
/* Returns: The toolbox object ID of the */
/* hotlist window. */
/*************************************************/
ObjectId hotlist_return_window_id(void)
{
return hotlist_windowid;
}
/*************************************************/
/* hotlist_add_position() */
/* */
/* Add a new URL to the hotlist at a specified */
/* position.� */
/* */
/* Parameters: Screen relative x position; */
/* */
/* Screen relative y position; */
/* */
/* Description of the URL (e.g. from */
/* the page title); */
/* */
/* Pointer to the URL itself. */
/*************************************************/
_kernel_oserror * hotlist_add_position(int x, int y, char * description, char * url)
{
WimpGetWindowStateBlock state;
hotlist_item * targetitem;
unsigned int item_height, item_dir_width, item_url_width;
int winx, winy;
int top, position;
/* Calculate window relative coordinates */
RetError(window_get_wimp_handle(0,
hotlist_windowid,
&state.window_handle));
RetError(wimp_get_window_state(&state));
winx = coords_x_toworkarea(x, (WimpRedrawWindowBlock *) &state);
winy = coords_y_toworkarea(y, (WimpRedrawWindowBlock *) &state);
/* Calculate which item add is over */
hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width);
top = (-winy) / item_height;
targetitem = hotlist_find_item(hotlist_root->data.directory_content, top);
/* Decide where to put the new item */
if (targetitem)
{
if ((-winy % item_height) > item_height / 2)
{
/* Put item after the target if we're over */
/* half way past its height */
position = HOTLIST_POSITION_AFTER;
}
else
{
/* Otherwise, put item before the target */
position = HOTLIST_POSITION_BEFORE;
}
}
else
{
/* Put item at end of root directory */
position = HOTLIST_POSITION_END;
targetitem = hotlist_root;
}
/* Create new item in appropriate place */
RetError(hotlist_new_url(targetitem,
position,
description,
url));
hotlist_preopen();
/* Optimise the redraw to do as little as possible depending */
/* upon where in the list the item was added. */
switch (position)
{
case HOTLIST_POSITION_END:
{
RetError(hotlist_redraw_now());
}
break;
default:
{
hotlist_clear_flags(hotlist_root, hl_ALL, HOTLIST_G_REDRAW_NOW);
RetError(hotlist_redraw_items(top - 1,
hotlist_count_displayed_items(hotlist_root->data.directory_content)));
}
break;
}
/* Exit by calling the routine that we must call every */
/* time the hotlist changes (so that it can, for */
/* example, be saved - should the Choices require it. */
return hotlist_modified(HL_MODIFIED_ADD);
}
/*************************************************/
/* hotlist_add_html_file() */
/* */
/* Read in an HTML file, adding items starting */
/* at the specified position. */
/* */
/* Parameters: Screen relative x position; */
/* */
/* Screen relative y position; */
/* */
/* Pathname of the HTML file. */
/*************************************************/
_kernel_oserror * hotlist_add_html_file(int x, int y, char * path)
{
_kernel_oserror * e;
hotlist_item * targetitem;
hotlist_item * newitem;
FILE * fileptr;
WimpGetWindowStateBlock state;
unsigned int item_height, item_dir_width, item_url_width;
int winx, winy;
int top, position;
char * dirname;
/* Calculate window relative coordinates */
RetError(window_get_wimp_handle(0,
hotlist_windowid,
&state.window_handle));
RetError(wimp_get_window_state(&state));
winx = coords_x_toworkarea(x, (WimpRedrawWindowBlock *) &state);
winy = coords_y_toworkarea(y, (WimpRedrawWindowBlock *) &state);
/* Calculate which item add is over */
hotlist_get_entry_sizes(&item_height, &item_dir_width, &item_url_width);
top = (-winy) / item_height;
targetitem = hotlist_find_item(hotlist_root->data.directory_content, top);
/* Decide where to put the new item */
if (targetitem)
{
if ((-winy % item_height) > item_height / 2)
{
/* Put item after the target if we're over */
/* half way past its height */
position = HOTLIST_POSITION_AFTER;
}
else
{
/* Otherwise, put item before the target */
position = HOTLIST_POSITION_BEFORE;
}
}
else
{
/* Put item at end of root directory */
position = HOTLIST_POSITION_END;
targetitem = hotlist_root;
}
dirname = strrchr(path, '.');
if (dirname) dirname ++;
if (!dirname || !*dirname) dirname = lookup_token("HotlistUntitled:(Untitled)",0,0);
RetError(hotlist_new_directory(targetitem, dirname, position, &newitem));
/* Open the file */
fileptr = fopen(path, "r");
if (fileptr == NULL)
{
erb.errnum = Utils_Error_Custom_Normal;
StrNCpy0(erb.errmess,
lookup_token("HlCantLoad:Hotlist file could not be loaded",
0,
0));
return &erb;
}
/* Load it, adding to the new directory */
e = hotlist_load_directory(fileptr, newitem);
fclose(fileptr);
if (e) return e;
/* Handle redraw */
hotlist_preopen();
hotlist_set_flags(hotlist_root, hl_ALL, HOTLIST_G_REDRAW_NOW);
RetError(hotlist_redraw_now());
/* Exit through the 'has modified' routine */
return hotlist_modified(HL_MODIFIED_ADD);
}
/*************************************************/
/* hotlist_load_resources() */
/* */
/* Read in a read-only 'Resources' hotlist, at */
/* the top of the hotlist window. This will not */
/* be saved when the rest of the hotlist is. */
/* */
/* Errors are raised if there is not enough */
/* memory etc., but not if the file doesn't */
/* exist. */
/* */
/* Parameters: Pathname of the HTML file. */
/*************************************************/
_kernel_oserror * hotlist_load_resources(char * path)
{
_kernel_oserror * e;
hotlist_item * newitem;
FILE * fileptr;
RetError(hotlist_new_directory(hotlist_root,
lookup_token("HotlistResDir:Resources",0,0),
HOTLIST_POSITION_BEGINNING,
&newitem));
/* Open the file */
fileptr = fopen(path, "r");
/* Fail silently if there's an error opening it */
if (fileptr == NULL) return NULL;
/* Load it, adding to the new directory */
e = hotlist_load_directory(fileptr, newitem);
fclose(fileptr);
if (e) return e;
/* Set all contained items as read-only, and mark the top-level */
/* Resources directory as both read-only and, if the Choices */
/* say so, open. */
newitem->flags |= (HOTLIST_G_IS_READ_ONLY);
hotlist_set_flags(newitem->data.directory_content,
hl_ALL,
HOTLIST_G_IS_READ_ONLY);
if (!strcmp(lookup_choice("OpenResources:no",0,0), "yes"))
{
newitem->flags |= (HOTLIST_D_IS_OPEN);
}
/* Handle redraw */
hotlist_preopen();
hotlist_set_flags(hotlist_root, hl_ALL, HOTLIST_G_REDRAW_NOW);
RetError(hotlist_redraw_now());
/* Exit through the 'has modified' routine */
return hotlist_modified(HL_MODIFIED_LOADED_RESOURCES);
}
/*************************************************/
/* hotlist_get_selected_shape() */
/* */
/* This routine gets the coordinates required to */
/* bound every selected item in the hotlist */
/* window (window relative coordinated) */
/* */
/* Parameters: Pointer to window relative */
/* bounding box. */
/* */
/* Returns: 1 if there were selected item(s), */
/* 0 if there weren't. */
/*************************************************/
static int hotlist_get_selected_shape(BBox * box)
{
_kernel_oserror * e;
unsigned int itemno, item_height;
int found;
found = 0;
itemno = 0;
/* Get item sizes */
e = hotlist_get_entry_sizes(&item_height, NULL, NULL);
if (e)
{
show_error_ret(e);
return 0;
}
/* Enter the recursive routine */
e = hotlist_get_selected_shape_r(hotlist_root->data.directory_content,
box,
&itemno,
&found,
item_height);
if (e)
{
show_error_ret(e);
return 0;
}
return found;
}
/*************************************************/
/* hotlist_get_selected_shape_r() */
/* */
/* Recursive back-end to */
/* hotlist_get_selected_shape(). */
/* */
/* Parameters: Pointer to a hotlist_item; */
/* */
/* Pointer to window relative */
/* bounding box; */
/* */
/* Pointer to the current item */
/* number (for internal use); */
/* */
/* Pointer to found flag; */
/* */
/* The height of a single entry in */
/* OS units. */
/*************************************************/
static _kernel_oserror * hotlist_get_selected_shape_r(hotlist_item * list, BBox * box, unsigned int * itemno, int * found, unsigned int item_height)
{
int newxmin, newxmax;
while (list)
{
if (list->flags & HOTLIST_G_IS_SELECTED)
{
RetError(hotlist_get_shape(&newxmin, &newxmax, list));
/* If we've already found an open item, then only extend the */
/* bounding box in appropriate directions. */
if (*found)
{
if (newxmin < box->xmin) box->xmin = newxmin;
if (newxmax > box->xmax) box->xmax = newxmax;
box->ymin = -((*itemno) + 1) * item_height;
}
else
{
/* This section run for first selected item found only; */
/* set the selected shape box to match the item's */
/* bounding box. */
box->xmin = newxmin;
box->xmax = newxmax;
box->ymax = -(*itemno) * item_height;
box->ymin = -((*itemno) + 1) * item_height;
/* Flag that we've found a selected item */
*found = 1;
}
}
*itemno += 1;
/* Recursively scan all open directories */
if (list->type == hl_directory && (list->flags & HOTLIST_D_IS_OPEN))
{
RetError(hotlist_get_selected_shape_r(list->data.directory_content,
box,
itemno,
found,
item_height));
}
/* Follow the list */
list = list->next;
}
/* Finished */
return NULL;
}
/*************************************************/
/* hotlist_find_match() */
/* */
/* Takes a string from the given buffer and sees */
/* if there's something in the Hotlist that */
/* matches it in some way. */
/* */
/* If it finds something, it writes it back to */
/* the buffer and returns 1. */
/* */
/* Parameters: Pointer to the buffer holding the */
/* string to try and match; */
/* */
/* Size of the buffer in bytes. */
/* */
/* Returns: 1 if the buffer is updated with a */
/* match string, else 0 (buffer */
/* contents will be unaltered). */
/*************************************************/
int hotlist_find_match(char * buffer, int buffer_size)
{
hotlist_item * lowest_item = NULL;
int lowest_offset = -1;
int lowest_diff = 0;
if (!buffer || !*buffer) return 0;
hotlist_find_match_r(buffer,
buffer_size,
hotlist_root,
&lowest_item,
&lowest_offset,
&lowest_diff);
if (lowest_item && lowest_offset >= 0)
{
strncpy(buffer, lowest_item->data.url, buffer_size);
buffer[buffer_size - 1] = 0;
return 1;
}
return 0;
}
/*************************************************/
/* hotlist_find_match_r() */
/* */
/* Recursive back-end to hotlist_find_match. */
/* */
/* Parameters: Pointer to the buffer holding the */
/* string to try and match; */
/* */
/* Size of the buffer in bytes; */
/* */
/* Pointer to a hotlist_item at the */
/* top of the directory to scan; */
/* */
/* Pointer to a hotlist_item * in */
/* which the best match hotlist_item */
/* is written, if any; */
/* */
/* Pointer to an int, in which the */
/* lowest offset into a string so */
/* far is written; */
/* */
/* Pointer to an int, in which the */
/* lowest difference in lengths */
/* between the buffer and match */
/* string is written. */
/*************************************************/
static void hotlist_find_match_r(char * buffer, int buffer_size, hotlist_item * item,
hotlist_item ** lowest_item, int * lowest_offset,
int * lowest_diff)
{
while (item)
{
if (item->type == hl_directory)
{
hotlist_find_match_r(buffer,
buffer_size,
item->data.directory_content,
lowest_item,
lowest_offset,
lowest_diff);
}
else
{
int this_offset = 0;
int got_one = 0;
const char * found;
if (item->data.url)
{
found = strstr(item->data.url, buffer);
if (found)
{
this_offset = found - item->data.url;
got_one = 1;
}
}
if (!got_one && item->name)
{
found = strstr(item->name, buffer);
if (found)
{
this_offset = found - item->name;
got_one = 1;
}
}
if (got_one)
{
if (*lowest_offset < 0 || this_offset <= *lowest_offset)
{
int this_diff = strlen(item->data.url) - strlen(buffer);
*lowest_offset = this_offset;
if (this_offset < *lowest_offset) *lowest_diff = 0;
if (!*lowest_diff || (this_diff && this_diff < *lowest_diff))
{
*lowest_diff = this_diff;
*lowest_item = item;
}
}
}
}
item = item->next;
}
return;
}
/*************************************************/
/* hotlist_empty() */
/* */
/* See if the hotlist is empty or not. */
/* */
/* Returns: 1 if the hotlist is empty else 0. */
/*************************************************/
int hotlist_empty(void)
{
if (
!hotlist_root ||
!hotlist_root->data.directory_content
)
return 1;
return 0;
}