/* 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 : ImgHistory.c */
/* */
/* Purpose: Remembering image sizes, in case the */
/* HTML doesn't specify it. */
/* */
/* Author : A.D.Hodgkinson */
/* */
/* History: 22-Nov-97: Created. */
/***************************************************/
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "kernel.h"
#include "swis.h"
#include "flex.h"
#include "wimp.h"
#include "wimplib.h"
#include "event.h"
#include "toolbox.h"
#include "svcprint.h"
#include "Global.h"
#include "Utils.h"
#include "ChoiceDefs.h"
#include "Images.h"
#include "Save.h" /* For Save_ScrapFile definition */
#include "URLutils.h" /* For FileMethod definition */
#include "ImgHistory.h"
/* Image history structure. It's so small that these */
/* are kept in an array (one malloc block). */
typedef struct imghistory_entry
{
char * url;
unsigned int hash;
int os_x;
int os_y;
unsigned int last_accessed;
}
imghistory_entry;
/* Static variables */
static imghistory_entry * imghistory_base = NULL;
int imghistory_entries = 0;
/* Local statics */
static int imghistory_find_entry (const char ** url_base, int url_offset);
static void imghistory_remove_entry (int entry);
static int imghistory_count (void);
/*************************************************/
/* imghistory_find_entry() */
/* */
/* Searches for a given image in the image */
/* history, and returns an array index for that */
/* image if it is present, else -1. */
/* */
/* If the parameters seem odd, it may help to */
/* realise that this allows a flex block to hold */
/* the URL without any worries about flex */
/* shifting. */
/* */
/* Parameters: Pointer to a pointer to a block */
/* containing the image's full URL; */
/* */
/* Offset into the block at which */
/* the image lies. */
/* */
/* Returns: Index in the image history array */
/* of the entry representing the */
/* image if found, else -1. */
/*************************************************/
static int imghistory_find_entry(const char ** url_base, int url_offset)
{
int entry;
unsigned int hash;
if (!imghistory_entries || !url_base) return -1;
hash = utils_return_hash(*url_base + url_offset);
/* Go through the array */
for (entry = 0; entry < imghistory_entries; entry++)
{
if (imghistory_base[entry].hash == hash)
{
/* Use strcmp. We're going to be very strict in this; strcmp is not */
/* a technically valid way to compare URLs, but it's fast and you */
/* don't need much storage space for the URLs themselves. The image */
/* history is not sufficiently important to warrant anything more */
/* robust than this. */
if (!strcmp(imghistory_base[entry].url, *url_base + url_offset)) return entry;
}
}
/* Nothing found */
return -1;
}
/*************************************************/
/* imghistory_record() */
/* */
/* Records a given image in the image history. */
/* If an entry is already present for the image, */
/* it just updates the entry's last_accessed */
/* field and ensures the size is set to the */
/* given values. */
/* */
/* Parameters: Pointer to a pointer to a block */
/* containing the image's full URL; */
/* */
/* Offset into the block at which */
/* the image lies; */
/* */
/* x size of the image, in OS units; */
/* */
/* y size of the image, in OS units. */
/*************************************************/
_kernel_oserror * imghistory_record(const char ** url_base, int url_offset, int os_x, int os_y)
{
imghistory_entry * new_base;
char * new_url;
int entry;
if (!url_base) return NULL;
/* Don't store scrap file transfer images */
if (!strncmp(*url_base + url_offset, FileMethod, sizeof(FileMethod) - 1))
{
char test_url[Limits_URL];
/* Build the URL we'd be on for a scrap file fetch */
StrNCpy0(test_url, Save_ScrapFile);
urlutils_pathname_to_url(test_url, sizeof(test_url));
/* If it's the same as the URL we've been given, don't store */
/* this image in the image history. */
if (!strcmp(*url_base + url_offset, test_url)) return NULL;
}
/* Try to find the item */
entry = imghistory_find_entry(url_base, url_offset);
/* Found it */
if (entry >= 0)
{
imghistory_base[entry].last_accessed = time(NULL);
/* Ensure the recorded size matches that given! */
imghistory_base[entry].os_x = os_x;
imghistory_base[entry].os_y = os_y;
/* That's all we need to do in this case */
return NULL;
}
/* Oh well, it wasn't there. So have to make a new entry */
new_base = realloc(imghistory_base, sizeof(imghistory_entry) * (imghistory_entries + 1));
/* Claim failed, so exit with error */
if (!new_base) return make_no_memory_error(28);
/* OK, managed that; set imghistory_base to whatever was returned */
/* by realloc but don't increment the items counter yet */
imghistory_base = new_base;
/* Try to allocate space for the URL too */
new_url = malloc(strlen(*url_base + url_offset) + 1);
/* If this claim fails, don't bother shrinking the array back; */
/* we haven't increased the item count, so things will take */
/* care of themselves on the next addition (assuming that the */
/* lack of memory doesn't prove catastrophic elsewhere!). */
if (!new_url) return make_no_memory_error(28);
/* If we reach here, both claims were successful */
imghistory_base[imghistory_entries].url = new_url;
imghistory_base[imghistory_entries].os_x = os_x;
imghistory_base[imghistory_entries].os_y = os_y;
imghistory_base[imghistory_entries].last_accessed = time(NULL);
strcpy(new_url, *url_base + url_offset);
imghistory_base[imghistory_entries].hash = utils_return_hash(new_url);
imghistory_entries ++;
/* Call expiry functions */
if (choices.image_expiry_age) imghistory_expire(time(NULL) - choices.image_expiry_age);
if (choices.image_max_size) imghistory_limit(choices.image_max_size);
#ifdef SINGLE_USER
/* Finished - exit by saving, if required */
if (choices.save_image_history == Choices_SaveImageHistory_Always)
{
return imghistory_save(lookup_choice("ImageHistorySave:Browse:User.Images",0,0));
}
#endif
return NULL;
}
/*************************************************/
/* imghistory_return_size() */
/* */
/* Returns the size of an image based on the */
/* given URL. If the image has no entry in the */
/* image history, -1 is returned for the x and */
/* y sizes. */
/* */
/* Parameters: Pointer to a pointer to a block */
/* containing the image's full URL; */
/* */
/* Offset into the block at which */
/* the image lies; */
/* */
/* Pointer to an int, in which the x */
/* size of the image is returned in */
/* OS units, or -1 if the image has */
/* no entry in the image history; */
/* */
/* Similarly, pointer to an int for */
/* the y size. */
/* */
/* Assumes: The int pointers may be NULL (but */
/* this would of course be pretty */
/* pointless!). */
/*************************************************/
void imghistory_return_size(const char ** url_base, int url_offset, int * os_x, int * os_y)
{
int entry;
if (os_x) *os_x = -1;
if (os_y) *os_y = -1;
if (!url_base) return;
/* Try and find the entry for this image */
entry = imghistory_find_entry(url_base, url_offset);
/* Not found */
if (entry < 0) return;
/* Found, so return the sizes and exit */
if (os_x) *os_x = imghistory_base[entry].os_x;
if (os_y) *os_y = imghistory_base[entry].os_y;
return;
}
/*************************************************/
/* imghistory_remove_entry() */
/* */
/* Removes an entry from the image history */
/* array by copying the last item over it and */
/* shrinking the array size. */
/* */
/* Parameters: Entry number. */
/*************************************************/
static void imghistory_remove_entry(int entry)
{
if (entry < 0 || entry >= imghistory_entries) return;
/* If this is the last item, only need to shrink */
/* the array and decrement the item counter. Else, */
/* copy the top item over the one being removed */
/* and then shrink the array. */
if (entry < imghistory_entries - 1)
{
memcpy(&imghistory_base[entry],
&imghistory_base[imghistory_entries - 1],
sizeof(imghistory_entry));
}
imghistory_entries --;
/* Shouldn't fail, but if it does... Well, we ditch the history. */
imghistory_base = realloc(imghistory_base,
imghistory_entries * sizeof(imghistory_entry));
/* Finished */
return;
}
/*************************************************/
/* imghistory_expire() */
/* */
/* Remove all entiries for images which have */
/* last been seen before a given time (i.e. are */
/* greater than a certain age). */
/* */
/* Parameters: Time (in time() function format) */
/* which an image must not have been */
/* visited on or since for expiry to */
/* take place - so to expire 1 day */
/* old images, say, you'd pass */
/* time() - 60*60*24. */
/*************************************************/
void imghistory_expire(unsigned int time)
{
int entry = 0;
/* Go through removing items. The removal routine copies the last */
/* array item over the one being removed, so we only imcrement */
/* the entry number if nothing has been removed. */
while (entry < imghistory_entries)
{
if (imghistory_base[entry].last_accessed <= time) imghistory_remove_entry(entry);
else entry++;
}
return;
}
/*************************************************/
/* imghistory_count() */
/* */
/* Count the total space used by the image */
/* history. */
/* */
/* Returns: Space occupied by the image */
/* history array and strings */
/* attached to this, including their */
/* terminators, in bytes. */
/*************************************************/
static int imghistory_count(void)
{
int count = 0;
int entry;
for (entry = 0; entry < imghistory_entries; entry ++)
{
count += sizeof(imghistory_entry);
count += imghistory_base[entry].url ? strlen(imghistory_base[entry].url) + 1 : 0;
}
return count;
}
/*************************************************/
/* imghistory_limit() */
/* */
/* Limit the space occupied by the image history */
/* to a given amount. */
/* */
/* Parameters: Maximum size the history may be, */
/* in bytes. */
/*************************************************/
void imghistory_limit(unsigned int size)
{
int entry;
int oldest;
int found;
/* Keep removing items as long as the actual size is */
/* greater than the maximum size specified. */
while (imghistory_count() > size)
{
/* Find the oldest entry */
oldest = 0;
found = 0;
for (entry = 0; entry < imghistory_entries; entry++)
{
if (
imghistory_base[entry].last_accessed < oldest ||
!oldest
)
oldest = imghistory_base[entry].last_accessed, found = entry;
}
/* Remove the oldest entry, if found */
if (oldest) imghistory_remove_entry(found);
}
/* Finished */
return;
}
/*************************************************/
/* imghistory_load() */
/* */
/* Loads the global history from the given path. */
/* Will raise errors (usually, due to RISC OS */
/* C's file I/O, the wrong ones...) if there is */
/* a failure during loading, but not if the file */
/* refuses to open or the number of items cannot */
/* be read from it (i.e. a missing or zero */
/* length History file). */
/* */
/* Parameters: Pointer to the full pathname for */
/* the history file. */
/*************************************************/
_kernel_oserror * imghistory_load(const char * pathname)
{
FILE * file;
char * url = NULL;
static char * local_path = NULL;
int result;
int last_accessed, os_x, os_y, url_len;
int items, item;
int cc, ch;
if (!pathname || !*pathname) return NULL;
local_path = malloc(strlen(pathname) + 1);
if (!local_path) return NULL;
strcpy(local_path, pathname);
file = fopen(local_path, "rb");
if (!file)
{
free(local_path);
return NULL; /* Fail silently - there may be no History file; this is OK */
}
/* Read how many items there are - again file silently, the */
/* file may just be zero bytes long. */
result = fscanf(file, "%d\n", &items);
if (result == EOF)
{
fclose(file);
free(local_path);
return NULL;
}
/* Allocate space for the array */
imghistory_base = malloc(sizeof(imghistory_entry) * items);
if (!imghistory_base)
{
fclose(file);
free(local_path);
return make_no_memory_error(29);
}
imghistory_entries = 0; /* We'll increment this as each gets loaded successfully */
/* Now load each entry's details */
_swix(Hourglass_On, 0);
for (item = 0; item < items; item++)
{
_swix(Hourglass_Percentage,
_IN(0),
(100 * item) / items);
/* Read the last accessed time and required string lengths */
result = fscanf(file, "%d,%d,%d,%d\n", &last_accessed, &os_x, &os_y, &url_len);
if (result == EOF) goto imghistory_load_exit;
/* Allocate buffers for the strings */
url = malloc(url_len + 1);
if (!url)
{
imghistory_entries = item; /* E.g. if item 0 fails to load, we say there are zero entries */
fclose(file);
_swix(Hourglass_Off,0);
free(local_path);
return make_no_memory_error(29);
}
/* Read the URL */
for (cc = 0; cc < url_len; cc++)
{
int ch = fgetc(file);
if (result == ch) goto imghistory_load_exit;
url[cc] = (char) ch;
}
url[url_len] = 0;
/* Skip the '\n' */
ch = fgetc(file);
if (result == ch) goto imghistory_load_exit;
/* Now make the entry */
imghistory_base[item].url = url;
imghistory_base[item].hash = utils_return_hash(url);
url = NULL; /* Make sure we don't go and free it or something! */
imghistory_base[item].os_x = os_x;
imghistory_base[item].os_y = os_y;
imghistory_base[item].last_accessed = last_accessed;
/* Successful addition */
imghistory_entries ++;
/* (Closure of 'for' loop) */
}
fclose(file);
_swix(Hourglass_Off,0);
free(local_path);
if (choices.image_expiry_age) imghistory_expire(time(NULL) - choices.image_expiry_age);
if (choices.image_max_size) imghistory_limit(choices.image_max_size);
return NULL;
/* Error condition exit */
imghistory_load_exit:
fclose(file);
_swix(Hourglass_Off,0);
free(url);
free(local_path);
RetLastE;
}
/*************************************************/
/* imghistory_save() */
/* */
/* Saves the global history to the given path. */
/* */
/* Parameters: Pointer to the full pathname for */
/* the history file. */
/*************************************************/
_kernel_oserror * imghistory_save(const char * pathname)
{
static char * local_path = NULL;
FILE * file;
int entry;
int wrote;
if (!pathname || !*pathname) return NULL;
/* Canonicalise the path */
RetError(utils_canonicalise_path(pathname, &local_path));
/* Ensure it is present */
{
_kernel_oserror * e = utils_build_tree(local_path);
if (e)
{
free(local_path);
return e;
}
}
/* Create the file */
file = fopen(local_path, "wb");
if (!file)
{
free(local_path);
RetLastE;
}
/* Write the number of items */
wrote = fprintf(file, "%d\n", imghistory_entries);
if (wrote <= 0)
{
fclose(file);
free(local_path);
RetLastE;
}
/* Write the item contents */
if (imghistory_entries)
{
for (entry = 0; entry < imghistory_entries; entry++)
{
wrote = fprintf(file,
"%d,%d,%d,%d\n%s\n",
imghistory_base[entry].last_accessed,
imghistory_base[entry].os_x,
imghistory_base[entry].os_y,
imghistory_base[entry].url ? strlen(imghistory_base[entry].url) : 0,
imghistory_base[entry].url ? imghistory_base[entry].url : "");
if (wrote <= 0)
{
fclose(file);
free(local_path);
RetLastE;
}
}
}
/* Close the file and exit */
fclose(file);
free(local_path);
return NULL;
}
/*************************************************/
/* imghistory_empty() */
/* */
/* Find out whether or not the image history has */
/* any entries in it. */
/* */
/* Returns: 1 if there are no entries (the */
/* image history is empty), else 0. */
/*************************************************/
int imghistory_empty(void)
{
return !imghistory_entries;
}