mirror of
https://github.com/netsurf-browser/netsurf
synced 2024-12-22 20:16:54 +03:00
Remove completely dead file.
NetSurf's list handling has been redundant and unused for years.
This commit is contained in:
Michael Drake
parent
0cdc102946
commit
c7ba173a64
@ -1,10 +1,9 @@
|
||||
# Render sources
|
||||
|
||||
S_RENDER := box.c box_construct.c box_normalise.c box_textarea.c \
|
||||
font.c form.c imagemap.c layout.c list.c search.c table.c \
|
||||
textplain.c \
|
||||
font.c form.c imagemap.c layout.c search.c table.c textplain.c \
|
||||
html.c html_css.c html_css_fetcher.c html_script.c \
|
||||
html_interaction.c html_redraw.c html_forms.c html_object.c
|
||||
|
||||
|
||||
S_RENDER := $(addprefix render/,$(S_RENDER))
|
||||
S_RENDER := $(addprefix render/,$(S_RENDER))
|
||||
|
||||
483
render/list.c
483
render/list.c
@ -1,483 +0,0 @@
|
||||
/*
|
||||
* Copyright 2005 Richard Wilson <info@tinct.net>
|
||||
*
|
||||
* This file is part of NetSurf, http://www.netsurf-browser.org/
|
||||
*
|
||||
* NetSurf is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; version 2 of the License.
|
||||
*
|
||||
* NetSurf is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* HTML lists (implementation).
|
||||
*/
|
||||
#include <assert.h>
|
||||
#include <ctype.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <strings.h>
|
||||
#include "css/css.h"
|
||||
#include "render/list.h"
|
||||
#include "utils/log.h"
|
||||
|
||||
|
||||
struct list_counter {
|
||||
char *name; /** Counter name */
|
||||
struct list_counter_state *first; /** First counter state */
|
||||
struct list_counter_state *state; /** Current counter state */
|
||||
struct list_counter *next; /** Next counter */
|
||||
};
|
||||
|
||||
struct list_counter_state {
|
||||
int count; /** Current count */
|
||||
struct list_counter_state *parent; /** Parent counter, or NULL */
|
||||
struct list_counter_state *next; /** Next counter, or NULL */
|
||||
};
|
||||
|
||||
static struct list_counter *list_counter_pool = NULL;
|
||||
static char list_counter_workspace[16];
|
||||
|
||||
static const char *list_counter_roman[] = { "I", "IV", "V", "IX",
|
||||
"X", "XL", "L", "XC",
|
||||
"C", "CD", "D", "CM",
|
||||
"M"};
|
||||
static const int list_counter_decimal[] = { 1, 4, 5, 9,
|
||||
10, 40, 50, 90,
|
||||
100, 400, 500, 900,
|
||||
1000};
|
||||
#define ROMAN_DECIMAL_CONVERSIONS (sizeof(list_counter_decimal) \
|
||||
/ sizeof(list_counter_decimal[0]))
|
||||
|
||||
|
||||
static struct list_counter *render_list_find_counter(const char *name);
|
||||
static char *render_list_encode_counter(struct list_counter_state *state,
|
||||
enum css_list_style_type_e style);
|
||||
static char *render_list_encode_roman(int value);
|
||||
|
||||
/*
|
||||
static void render_list_counter_output(char *name);
|
||||
*/
|
||||
|
||||
/**
|
||||
* Finds a counter from the current pool, or adds a new one.
|
||||
*
|
||||
* \param name the name of the counter to find
|
||||
* \return the counter, or NULL if it couldn't be found/created.
|
||||
*/
|
||||
static struct list_counter *render_list_find_counter(const char *name) {
|
||||
struct list_counter *counter;
|
||||
|
||||
assert(name);
|
||||
/* find a current counter */
|
||||
for (counter = list_counter_pool; counter; counter = counter->next)
|
||||
if (!strcasecmp(name, counter->name))
|
||||
return counter;
|
||||
|
||||
/* create a new counter */
|
||||
counter = calloc(1, sizeof(struct list_counter));
|
||||
if (!counter) {
|
||||
LOG(("No memory for calloc()"));
|
||||
return NULL;
|
||||
}
|
||||
counter->name = malloc(strlen(name) + 1);
|
||||
if (!counter->name) {
|
||||
LOG(("No memory for malloc()"));
|
||||
free(counter);
|
||||
return NULL;
|
||||
}
|
||||
strcpy(counter->name, name);
|
||||
counter->next = list_counter_pool;
|
||||
list_counter_pool = counter;
|
||||
return counter;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Removes all counters from the current pool.
|
||||
*/
|
||||
void render_list_destroy_counters(void) {
|
||||
struct list_counter *counter = list_counter_pool;
|
||||
struct list_counter *next_counter;
|
||||
struct list_counter_state *state;
|
||||
struct list_counter_state *next_state;
|
||||
|
||||
while (counter) {
|
||||
next_counter = counter->next;
|
||||
free(counter->name);
|
||||
state = counter->first;
|
||||
free(counter);
|
||||
counter = next_counter;
|
||||
while (state) {
|
||||
next_state = state->next;
|
||||
free(state);
|
||||
state = next_state;
|
||||
}
|
||||
}
|
||||
list_counter_pool = NULL;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Resets a counter in accordance with counter-reset (CSS 2.1/12.4).
|
||||
*
|
||||
* \param name the name of the counter to reset
|
||||
* \param value the value to reset the counter to
|
||||
* \return true on success, false on failure.
|
||||
*/
|
||||
bool render_list_counter_reset(const char *name, int value) {
|
||||
struct list_counter *counter;
|
||||
struct list_counter_state *state;
|
||||
struct list_counter_state *link;
|
||||
|
||||
assert(name);
|
||||
counter = render_list_find_counter(name);
|
||||
if (!counter)
|
||||
return false;
|
||||
state = calloc(1, sizeof(struct list_counter_state));
|
||||
if (!state) {
|
||||
LOG(("No memory for calloc()"));
|
||||
return false;
|
||||
}
|
||||
state->count = value;
|
||||
state->parent = counter->state;
|
||||
counter->state = state;
|
||||
if (!counter->first) {
|
||||
counter->first = state;
|
||||
} else {
|
||||
for (link = counter->first; link->next; link = link->next);
|
||||
link->next = state;
|
||||
}
|
||||
/* render_list_counter_output(name);
|
||||
*/ return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Increments a counter in accordance with counter-increment (CSS 2.1/12.4).
|
||||
*
|
||||
* \param name the name of the counter to reset
|
||||
* \param value the value to increment the counter by
|
||||
* \return true on success, false on failure.
|
||||
*/
|
||||
bool render_list_counter_increment(const char *name, int value) {
|
||||
struct list_counter *counter;
|
||||
|
||||
assert(name);
|
||||
counter = render_list_find_counter(name);
|
||||
if (!counter)
|
||||
return false;
|
||||
/* if no counter-reset used, it is assumed the counter has been reset
|
||||
* to 0 by the root element. */
|
||||
if (!counter->state) {
|
||||
if (counter->first) {
|
||||
counter->state = counter->first;
|
||||
counter->state->count = 0;
|
||||
} else {
|
||||
render_list_counter_reset(name, 0);
|
||||
}
|
||||
}
|
||||
if (counter->state)
|
||||
counter->state->count += value;
|
||||
/* render_list_counter_output(name);
|
||||
*/ return counter->state != NULL;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Ends the scope of a counter.
|
||||
*
|
||||
* \param name the name of the counter to end the scope for
|
||||
* \return true on success, false on failure.
|
||||
*/
|
||||
bool render_list_counter_end_scope(const char *name) {
|
||||
struct list_counter *counter;
|
||||
|
||||
assert(name);
|
||||
counter = render_list_find_counter(name);
|
||||
if ((!counter) || (!counter->state))
|
||||
return false;
|
||||
counter->state = counter->state->parent;
|
||||
/* render_list_counter_output(name);
|
||||
*/ return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns a textual representation of a counter for counter() or counters()
|
||||
* (CSS 2.1/12.2).
|
||||
*
|
||||
* \param css_counter the counter to convert
|
||||
* \return a textual representation of the counter, or NULL on failure
|
||||
*/
|
||||
char *render_list_counter(const css_computed_content_item *css_counter) {
|
||||
struct list_counter *counter;
|
||||
struct list_counter_state *state;
|
||||
char *compound = NULL;
|
||||
char *merge, *extend;
|
||||
lwc_string *name = NULL, *sep = NULL;
|
||||
uint8_t style;
|
||||
|
||||
assert(css_counter);
|
||||
|
||||
if (css_counter->type == CSS_COMPUTED_CONTENT_COUNTER) {
|
||||
name = css_counter->data.counter.name;
|
||||
style = css_counter->data.counter.style;
|
||||
} else {
|
||||
assert(css_counter->type == CSS_COMPUTED_CONTENT_COUNTERS);
|
||||
|
||||
name = css_counter->data.counters.name;
|
||||
sep = css_counter->data.counters.sep;
|
||||
style = css_counter->data.counters.style;
|
||||
}
|
||||
|
||||
counter = render_list_find_counter(lwc_string_data(name));
|
||||
if (!counter) {
|
||||
LOG(("Failed to find/create counter for conversion"));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* handle counter() first */
|
||||
if (sep == NULL)
|
||||
return render_list_encode_counter(counter->state, style);
|
||||
|
||||
/* loop through all states for counters() */
|
||||
for (state = counter->first; state; state = state->next) {
|
||||
merge = render_list_encode_counter(state, style);
|
||||
if (!merge) {
|
||||
free(compound);
|
||||
return NULL;
|
||||
}
|
||||
if (!compound) {
|
||||
compound = merge;
|
||||
} else {
|
||||
extend = realloc(compound, strlen(compound) +
|
||||
strlen(merge) + 1);
|
||||
if (!extend) {
|
||||
LOG(("No memory for realloc()"));
|
||||
free(compound);
|
||||
free(merge);
|
||||
return NULL;
|
||||
}
|
||||
compound = extend;
|
||||
strcat(compound, merge);
|
||||
}
|
||||
if (state->next) {
|
||||
merge = realloc(compound, strlen(compound) +
|
||||
lwc_string_length(sep) + 1);
|
||||
if (!merge) {
|
||||
LOG(("No memory for realloc()"));
|
||||
free(compound);
|
||||
return NULL;
|
||||
}
|
||||
compound = merge;
|
||||
strcat(compound, lwc_string_data(sep));
|
||||
}
|
||||
}
|
||||
return compound;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns a textual representation of a counter state in a specified style.
|
||||
*
|
||||
* \param state the counter state to represent
|
||||
* \param style the counter style to use
|
||||
* \return a textual representation of the counter state, or NULL on failure
|
||||
*/
|
||||
static char *render_list_encode_counter(struct list_counter_state *state,
|
||||
enum css_list_style_type_e style) {
|
||||
char *result = NULL;
|
||||
int i;
|
||||
|
||||
/* no counter state means that the counter is currently out of scope */
|
||||
if (!state) {
|
||||
result = malloc(1);
|
||||
if (!result)
|
||||
return NULL;
|
||||
result[0] = '\0';
|
||||
return result;
|
||||
}
|
||||
|
||||
/* perform the relevant encoding to upper case where applicable */
|
||||
switch (style) {
|
||||
case CSS_LIST_STYLE_TYPE_LOWER_ALPHA:
|
||||
case CSS_LIST_STYLE_TYPE_UPPER_ALPHA:
|
||||
if (state->count <= 0)
|
||||
result = calloc(1, 1);
|
||||
else
|
||||
result = malloc(2);
|
||||
if (!result)
|
||||
return NULL;
|
||||
if (state->count > 0) {
|
||||
result[0] = 'A' + (state->count - 1) % 26;
|
||||
result[1] = '\0';
|
||||
}
|
||||
break;
|
||||
case CSS_LIST_STYLE_TYPE_DISC:
|
||||
case CSS_LIST_STYLE_TYPE_CIRCLE:
|
||||
case CSS_LIST_STYLE_TYPE_SQUARE:
|
||||
result = malloc(2);
|
||||
if (!result)
|
||||
return NULL;
|
||||
result[0] = '?';
|
||||
result[1] = '\0';
|
||||
break;
|
||||
case CSS_LIST_STYLE_TYPE_LOWER_ROMAN:
|
||||
case CSS_LIST_STYLE_TYPE_UPPER_ROMAN:
|
||||
result = render_list_encode_roman(state->count);
|
||||
if (!result)
|
||||
return NULL;
|
||||
break;
|
||||
case CSS_LIST_STYLE_TYPE_DECIMAL:
|
||||
snprintf(list_counter_workspace,
|
||||
sizeof list_counter_workspace,
|
||||
"%i", state->count);
|
||||
result = malloc(strlen(list_counter_workspace) + 1);
|
||||
if (!result)
|
||||
return NULL;
|
||||
strcpy(result, list_counter_workspace);
|
||||
break;
|
||||
case CSS_LIST_STYLE_TYPE_NONE:
|
||||
result = malloc(1);
|
||||
if (!result)
|
||||
return NULL;
|
||||
result[0] = '\0';
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
/* perform case conversion */
|
||||
if ((style == CSS_LIST_STYLE_TYPE_LOWER_ALPHA) ||
|
||||
(style == CSS_LIST_STYLE_TYPE_LOWER_ROMAN))
|
||||
for (i = 0; result[i]; i++)
|
||||
result[i] = tolower(result[i]);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Encodes a value in roman numerals.
|
||||
* For values that cannot be represented (ie <=0) an empty string is returned.
|
||||
*
|
||||
* \param value the value to represent
|
||||
* \return a string containing the representation, or NULL on failure
|
||||
*/
|
||||
static char *render_list_encode_roman(int value) {
|
||||
int i, overflow, p = 0;
|
||||
char temp[10];
|
||||
char *result;
|
||||
|
||||
/* zero and below is returned as an empty string and not erred as
|
||||
* if it is counters() will fail to complete other scopes. */
|
||||
if (value <= 0) {
|
||||
result = malloc(1);
|
||||
if (!result)
|
||||
return NULL;
|
||||
result[0] = '\0';
|
||||
return result;
|
||||
}
|
||||
|
||||
/* we only calculate 1->999 and then add a M for each thousand */
|
||||
overflow = value / 1000;
|
||||
value = value % 1000;
|
||||
|
||||
/* work backwards through the array */
|
||||
for (i = ROMAN_DECIMAL_CONVERSIONS - 1; i >= 0; i--) {
|
||||
while (value >= list_counter_decimal[0]) {
|
||||
if (value - list_counter_decimal[i] <
|
||||
list_counter_decimal[0] - 1)
|
||||
break;
|
||||
value -= list_counter_decimal[i];
|
||||
temp[p++] = list_counter_roman[i][0];
|
||||
if (i & 0x1)
|
||||
temp[p++] = list_counter_roman[i][1];
|
||||
}
|
||||
}
|
||||
temp[p] = '\0';
|
||||
|
||||
/* create a copy for the caller including thousands */
|
||||
result = malloc(p + overflow + 1);
|
||||
if (!result)
|
||||
return NULL;
|
||||
for (i = 0; i < overflow; i++)
|
||||
result[i] = 'M';
|
||||
strcpy(&result[overflow], temp);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void render_list_test(void) {
|
||||
/* example given in CSS2.1/12.4.1 */
|
||||
/* render_list_counter_reset("item", 0);
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_reset("item", 0);
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_reset("item", 0);
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_end_scope("item");
|
||||
render_list_counter_reset("item", 0);
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_end_scope("item");
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_end_scope("item");
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_end_scope("item");
|
||||
render_list_counter_reset("item", 0);
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_increment("item", 1);
|
||||
render_list_counter_end_scope("item");
|
||||
*/
|
||||
}
|
||||
/*
|
||||
static void render_list_counter_output(char *name) {
|
||||
struct list_counter *counter;
|
||||
char *result;
|
||||
struct css_counter css_counter;
|
||||
|
||||
assert(name);
|
||||
counter = render_list_find_counter(name);
|
||||
if (!counter) {
|
||||
fprintf(stderr, "Unable to create counter '%s'\n", name);
|
||||
return;
|
||||
}
|
||||
|
||||
css_counter.name = name;
|
||||
css_counter.style = CSS_LIST_STYLE_TYPE_LOWER_ALPHA;
|
||||
css_counter.separator = NULL;
|
||||
result = render_list_counter(&css_counter);
|
||||
if (!result) {
|
||||
fprintf(stderr, "Failed to output counter('%s')\n", name);
|
||||
} else {
|
||||
fprintf(stderr, "counter('%s') is '%s'\n", name, result);
|
||||
free(result);
|
||||
}
|
||||
css_counter.separator = ".";
|
||||
result = render_list_counter(&css_counter);
|
||||
if (!result) {
|
||||
fprintf(stderr, "Failed to output counters('%s', '.')\n", name);
|
||||
} else {
|
||||
fprintf(stderr, "counters('%s', '.') is '%s'\n", name, result);
|
||||
free(result);
|
||||
}
|
||||
}
|
||||
*/
|
||||
@ -1,38 +0,0 @@
|
||||
/*
|
||||
* Copyright 2005 Richard Wilson <info@tinct.net>
|
||||
*
|
||||
* This file is part of NetSurf, http://www.netsurf-browser.org/
|
||||
*
|
||||
* NetSurf is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; version 2 of the License.
|
||||
*
|
||||
* NetSurf is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* HTML lists (interface).
|
||||
*/
|
||||
|
||||
#ifndef _NETSURF_RENDER_LIST_H_
|
||||
#define _NETSURF_RENDER_LIST_H_
|
||||
|
||||
#include <stdbool.h>
|
||||
|
||||
#include "css/css.h"
|
||||
|
||||
void render_list_destroy_counters(void);
|
||||
bool render_list_counter_reset(const char *name, int value);
|
||||
bool render_list_counter_increment(const char *name, int value);
|
||||
bool render_list_counter_end_scope(const char *name);
|
||||
char *render_list_counter(const css_computed_content_item *css_counter);
|
||||
|
||||
void render_list_test(void);
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue
Block a user