1
0
mirror of https://github.com/rkd77/elinks.git synced 2024-12-04 14:46:47 -05:00
elinks/src/document/css/stylesheet.c
2005-10-21 09:14:07 +02:00

285 lines
6.1 KiB
C

/* CSS stylesheet handling */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <string.h>
#include "elinks.h"
#include "document/css/property.h"
#include "document/css/stylesheet.h"
#include "util/error.h"
#include "util/lists.h"
#include "util/memory.h"
#include "util/string.h"
/* You can find some mysterious functions commented out here. I planned to use
* them for various smart things (well they all report to
* merge_css_stylesheets()), but it turns out it makes no sense to merge
* stylesheets now (and maybe it won't in the future neither...). But maybe you
* will find them useful at some time, so... Dunno. --pasky */
struct css_selector *
find_css_selector(struct list_head *sels, enum css_selector_type type,
enum css_selector_relation rel,
unsigned char *name, int namelen)
{
struct css_selector *selector;
assert(sels && name);
foreach (selector, *sels) {
if (type != selector->type || rel != selector->relation)
continue;
if (strlcasecmp(name, namelen, selector->name, -1))
continue;
return selector;
}
return NULL;
}
struct css_selector *
init_css_selector(struct list_head *sels, enum css_selector_type type,
unsigned char *name, int namelen)
{
struct css_selector *selector;
selector = mem_calloc(1, sizeof(*selector));
if (!selector) return NULL;
selector->relation = CSR_ROOT; /* Default */
init_list(selector->leaves);
selector->type = type;
init_list(selector->properties);
if (name) {
if (namelen < 0)
namelen = strlen(name);
selector->name = memacpy(name, namelen);
if (!selector->name) {
mem_free(selector);
return NULL;
}
set_mem_comment(selector, name, namelen);
}
if (sels) {
add_to_list(*sels, selector);
}
return selector;
}
struct css_selector *
get_css_selector(struct list_head *sels, enum css_selector_type type,
enum css_selector_relation rel,
unsigned char *name, int namelen)
{
struct css_selector *selector = NULL;
if (sels && name && namelen) {
selector = find_css_selector(sels, type, rel, name, namelen);
if (selector)
return selector;
}
selector = init_css_selector(sels, type, name, namelen);
if (selector) {
selector->relation = rel;
return selector;
}
return NULL;
}
static struct css_selector *
copy_css_selector(struct css_stylesheet *css, struct css_selector *orig)
{
struct css_selector *copy;
assert(css && orig);
copy = init_css_selector(&css->selectors, orig->type,
orig->name, strlen(orig->name));
if (!copy)
return NULL;
return copy;
}
static void
add_selector_property(struct css_selector *selector, struct css_property *prop)
{
struct css_property *newprop = mem_alloc(sizeof(*newprop));
if (newprop) {
copy_struct(newprop, prop);
add_to_list(selector->properties, newprop);
}
}
void
add_selector_properties(struct css_selector *selector,
struct list_head *properties)
{
struct css_property *prop;
foreach (prop, *properties) {
add_selector_property(selector, prop);
}
}
static struct css_selector *
clone_css_selector(struct css_stylesheet *css, struct css_selector *orig)
{
struct css_selector *copy;
assert(css && orig);
copy = copy_css_selector(css, orig);
if (!copy)
return NULL;
add_selector_properties(copy, &orig->properties);
return copy;
}
void
merge_css_selectors(struct css_selector *sel1, struct css_selector *sel2)
{
struct css_property *prop;
foreach (prop, sel2->properties) {
struct css_property *origprop;
foreach (origprop, sel1->properties)
if (origprop->type == prop->type) {
del_from_list(origprop);
mem_free(origprop);
break;
}
/* Not there yet, let's add it. */
add_selector_property(sel1, prop);
}
}
void
done_css_selector(struct css_selector *selector)
{
while (selector->leaves.next != &selector->leaves) {
done_css_selector(selector->leaves.next);
}
if (selector->next) del_from_list(selector);
free_list(selector->properties);
mem_free_if(selector->name);
mem_free(selector);
}
#ifdef DEBUG_CSS
void
dump_css_selector_tree_iter(struct list_head *sels, int level)
{
struct css_selector *sel;
foreach (sel, *sels) {
struct css_property *prop;
fprintf(stderr, "%*s +- [%s] type %d rel %d props",
level * 4, " ",
sel->name, sel->type, sel->relation);
foreach (prop, sel->properties) {
fprintf(stderr, " [%d]", prop->type);
}
fprintf(stderr, "\n");
dump_css_selector_tree_iter(&sel->leaves, level + 1);
}
}
void
dump_css_selector_tree(struct list_head *sels)
{
dump_css_selector_tree_iter(sels, 0);
}
#endif
struct css_stylesheet *
init_css_stylesheet(css_stylesheet_importer_T importer, void *import_data)
{
struct css_stylesheet *css;
css = mem_calloc(1, sizeof(*css));
if (!css)
return NULL;
css->import = importer;
css->import_data = import_data;
init_list(css->selectors);
return css;
}
void
mirror_css_stylesheet(struct css_stylesheet *css1, struct css_stylesheet *css2)
{
struct css_selector *selector;
foreach (selector, css1->selectors) {
clone_css_selector(css2, selector);
}
}
#if 0
struct css_stylesheet *
clone_css_stylesheet(struct css_stylesheet *orig)
{
struct css_stylesheet *copy;
struct css_selector *selector;
copy = init_css_stylesheet(orig->import, orig->import_data);
if (!copy)
return NULL;
mirror_css_stylesheet(orig, copy);
return copy;
}
void
merge_css_stylesheets(struct css_stylesheet *css1,
struct css_stylesheet *css2)
{
struct css_selector *selector;
assert(css1 && css2);
/* This is 100% evil. And gonna be a huge bottleneck. Essentially
* O(N^2) where we could be much smarter (ie. sort it once and then
* always be O(N)). */
foreach (selector, css2->selectors) {
struct css_selector *origsel;
origsel = find_css_selector(&css1->selectors, selector->name,
strlen(selector->name));
if (!origsel) {
clone_css_selector(css1, selector);
} else {
merge_css_selectors(origsel, selector);
}
}
}
#endif
void
done_css_stylesheet(struct css_stylesheet *css)
{
while (!list_empty(css->selectors)) {
done_css_selector(css->selectors.next);
}
}