diff options
Diffstat (limited to 'tree')
| -rw-r--r-- | tree/blend.c | 53 | ||||
| -rw-r--r-- | tree/cache.c | 98 | ||||
| -rw-r--r-- | tree/debug.c | 74 | ||||
| -rw-r--r-- | tree/form.c | 30 | ||||
| -rw-r--r-- | tree/image.c | 49 | ||||
| -rw-r--r-- | tree/mask.c | 50 | ||||
| -rw-r--r-- | tree/meta.c | 37 | ||||
| -rw-r--r-- | tree/node.c | 148 | ||||
| -rw-r--r-- | tree/node1.c | 165 | ||||
| -rw-r--r-- | tree/node2.c | 304 | ||||
| -rw-r--r-- | tree/over.c | 50 | ||||
| -rw-r--r-- | tree/path.c | 58 | ||||
| -rw-r--r-- | tree/solid.c | 33 | ||||
| -rw-r--r-- | tree/text.c | 18 | ||||
| -rw-r--r-- | tree/transform.c | 35 | ||||
| -rw-r--r-- | tree/tree.c | 57 |
16 files changed, 572 insertions, 687 deletions
diff --git a/tree/blend.c b/tree/blend.c deleted file mode 100644 index d2154240..00000000 --- a/tree/blend.c +++ /dev/null @@ -1,53 +0,0 @@ -#include <fitz.h> - -fz_error * -fz_newblend(fz_node **nodep, fz_blendkind b, int k, int i) -{ - fz_blend *node; - - node = fz_malloc(sizeof (fz_blend)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NBLEND); - node->child = nil; - node->mode = b; - node->knockout = k; - node->isolated = i; - - return nil; -} - -void -fz_freeblend(fz_blend *node) -{ - if (node->child) - fz_freenode(node->child); - fz_free(node); -} - -fz_rect -fz_boundblend(fz_blend *node, fz_matrix ctm) -{ - fz_node *child; - fz_rect bbox; - fz_rect r; - - bbox = FZ_INFRECT; - - for (child = node->child; child; child = child->next) - { - r = fz_boundnode(child, ctm); - if (r.max.x >= r.min.x) - { - if (bbox.max.x >= bbox.min.x) - bbox = fz_mergerects(r, bbox); - else - bbox = r; - } - } - - return bbox; -} - diff --git a/tree/cache.c b/tree/cache.c deleted file mode 100644 index f4544844..00000000 --- a/tree/cache.c +++ /dev/null @@ -1,98 +0,0 @@ -#include <fitz.h> - -static int -hash(fz_cachekey *k) -{ - int h; - int i; - - h = (int)k->tree ^ (int)k->node ^ k->tag; - - /* http://www.cs.yorku.ca/~oz/hash.html -- sdbm */ - for (i = 0; i < k->len; i++) - h = k->key[i] + (h << 6) + (h << 16) - h; - - return h; -} - -static int -equal(fz_cachekey *a, fz_cachekey *b) -{ - if (a->tree != b->tree) return 0; - if (a->node != b->node) return 0; - if (a->tag != b->tag) return 0; - if (a->len != b->len) return 0; - return memcmp(a->key, b->key, a->len) == 0; -} - -fz_cache * -fz_newcache(int maxentries, int maxdatasize) -{ - fz_cache *cache; - int i; - - cache = fz_malloc(sizeof(fz_cache)); - if (!cache) return nil; - - cache->maxsize = maxdatasize; - cache->cursize = 0; - cache->len = maxentries; - cache->table = fz_malloc(sizeof(fz_cachebucket) * maxentries); - if (!cache->table) { - fz_free(cache); - return nil; - } - - for (i = 0; i < cache->len; i++) { - cache->table[i].val = nil; - } - - return cache; -} - -void * -fz_findincache(fz_cache *cache, fz_cachekey *key) -{ - int h; - int i; - - h = hash(key); - - i = h % cache->len; - if (equal(key, &cache->table[i].key)) - return cache->table[i].val; - return nil; -} - -int -fz_insertincache(fz_cache *cache, fz_cachekey *key, void *data, int size) -{ - int h; - int i; - - h = hash(key); - i = h % cache->len; - - if (cache->table[i].val) - fz_free(cache->table[i].val); - cache->table[i].key = *key; - - return FZ_OKAY; -} - -int -fz_evictfromcache(fz_cache *cache, fz_cachekey *key) -{ - /* TODO */ - return FZ_OKAY; -} - -void -fz_freecache(fz_cache *cache) -{ - /* FIXME evict everything from cache first? */ - if (cache->table) - fz_free(cache->table); - fz_free(cache); -} - diff --git a/tree/debug.c b/tree/debug.c index 2e7cfc4f..8e16c612 100644 --- a/tree/debug.c +++ b/tree/debug.c @@ -8,77 +8,77 @@ static void indent(int level) static void lispnode(fz_node *node, int level); -static void lispmeta(fz_meta *node, int level) +static void lispmeta(fz_metanode *node, int level) { fz_node *child; indent(level); printf("(meta "); fz_debugobj(node->info); printf("\n"); - for (child = node->child; child; child = child->next) + for (child = node->super.child; child; child = child->next) lispnode(child, level + 1); indent(level); printf(")\n"); } -static void lispover(fz_over *node, int level) +static void lispover(fz_overnode *node, int level) { fz_node *child; indent(level); printf("(over\n"); - for (child = node->child; child; child = child->next) + for (child = node->super.child; child; child = child->next) lispnode(child, level + 1); indent(level); printf(")\n"); } -static void lispmask(fz_mask *node, int level) +static void lispmask(fz_masknode *node, int level) { fz_node *child; indent(level); printf("(mask\n"); - for (child = node->child; child; child = child->next) + for (child = node->super.child; child; child = child->next) lispnode(child, level + 1); indent(level); printf(")\n"); } -static void lispblend(fz_blend *node, int level) +static void lispblend(fz_blendnode *node, int level) { fz_node *child; indent(level); printf("(blend-%d\n", node->mode); - for (child = node->child; child; child = child->next) + for (child = node->super.child; child; child = child->next) lispnode(child, level + 1); indent(level); printf(")\n"); } -static void lisptransform(fz_transform *node, int level) +static void lisptransform(fz_transformnode *node, int level) { indent(level); printf("(transform %g %g %g %g %g %g\n", node->m.a, node->m.b, node->m.c, node->m.d, node->m.e, node->m.f); - lispnode(node->child, level + 1); + lispnode(node->super.child, level + 1); indent(level); printf(")\n"); } -static void lispsolid(fz_solid *node, int level) +static void lispcolor(fz_colornode *node, int level) { indent(level); - printf("(solid %g %g %g)\n", node->r, node->g, node->b); + printf("(color %g %g %g)\n", node->r, node->g, node->b); } -static void lispform(fz_form *node, int level) +static void lisplink(fz_linknode *node, int level) { indent(level); - printf("(form %p)\n", node->tree); + printf("(link %p)\n", node->tree); } -static void lisppath(fz_path *node, int level) +static void lisppath(fz_pathnode *node, int level) { int i; @@ -87,10 +87,10 @@ static void lisppath(fz_path *node, int level) if (node->paint == FZ_STROKE) { printf("(path 'stroke %d %d %g %g ", - node->stroke->linecap, - node->stroke->linejoin, - node->stroke->linewidth, - node->stroke->miterlimit); + node->linecap, + node->linejoin, + node->linewidth, + node->miterlimit); if (node->dash) { printf("%g '( ", node->dash->phase); @@ -107,13 +107,13 @@ static void lisppath(fz_path *node, int level) } printf("\n"); - fz_debugpath(node); + fz_debugpathnode(node); indent(level); printf(")\n"); } -static void lisptext(fz_text *node, int level) +static void lisptext(fz_textnode *node, int level) { int i; @@ -131,18 +131,10 @@ static void lisptext(fz_text *node, int level) printf(")\n"); } -static void lispimage(fz_image *node, int level) +static void lispimage(fz_imagenode *node, int level) { indent(level); - printf("(image %d %d %d %d '", node->w, node->h, node->n, node->bpc); - switch (node->cs) - { - case FZ_CSGRAY: printf("gray"); break; - case FZ_CSRGB: printf("rgb"); break; - case FZ_CSCMYK: printf("cmyk"); break; - default: printf("unknown"); break; - } - printf(")\n"); + printf("(image %d %d %d %d)\n", node->w, node->h, node->n, node->a); } static void lispnode(fz_node *node, int level) @@ -156,16 +148,16 @@ static void lispnode(fz_node *node, int level) switch (node->kind) { - case FZ_NMETA: lispmeta((fz_meta*)node, level); break; - case FZ_NOVER: lispover((fz_over*)node, level); break; - case FZ_NMASK: lispmask((fz_mask*)node, level); break; - case FZ_NBLEND: lispblend((fz_blend*)node, level); break; - case FZ_NTRANSFORM: lisptransform((fz_transform*)node, level); break; - case FZ_NSOLID: lispsolid((fz_solid*)node, level); break; - case FZ_NPATH: lisppath((fz_path*)node, level); break; - case FZ_NTEXT: lisptext((fz_text*)node, level); break; - case FZ_NIMAGE: lispimage((fz_image*)node, level); break; - case FZ_NFORM: lispform((fz_form*)node, level); break; + case FZ_NMETA: lispmeta((fz_metanode*)node, level); break; + case FZ_NOVER: lispover((fz_overnode*)node, level); break; + case FZ_NMASK: lispmask((fz_masknode*)node, level); break; + case FZ_NBLEND: lispblend((fz_blendnode*)node, level); break; + case FZ_NTRANSFORM: lisptransform((fz_transformnode*)node, level); break; + case FZ_NCOLOR: lispcolor((fz_colornode*)node, level); break; + case FZ_NPATH: lisppath((fz_pathnode*)node, level); break; + case FZ_NTEXT: lisptext((fz_textnode*)node, level); break; + case FZ_NIMAGE: lispimage((fz_imagenode*)node, level); break; + case FZ_NLINK: lisplink((fz_linknode*)node, level); break; } } diff --git a/tree/form.c b/tree/form.c deleted file mode 100644 index dd45aad9..00000000 --- a/tree/form.c +++ /dev/null @@ -1,30 +0,0 @@ -#include <fitz.h> - -fz_error * -fz_newform(fz_node **nodep, fz_tree *child) -{ - fz_form *node; - - node = fz_malloc(sizeof (fz_form)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NFORM); - node->tree = child; - - return nil; -} - -void -fz_freeform(fz_form *node) -{ - fz_free(node); -} - -fz_rect -fz_boundform(fz_form *node, fz_matrix ctm) -{ - return fz_boundtree(node->tree, ctm); -} - diff --git a/tree/image.c b/tree/image.c deleted file mode 100644 index 7991ded3..00000000 --- a/tree/image.c +++ /dev/null @@ -1,49 +0,0 @@ -#include <fitz.h> - -fz_error * -fz_newimage(fz_node **nodep, int w, int h, int n, int bpc, int cs) -{ - fz_image *node; - - node = fz_malloc(sizeof (fz_image)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NIMAGE); - node->w = w; - node->h = h; - node->n = n; - node->bpc = bpc; - node->cs = cs; - node->data = nil; - - return nil; -} - -void -fz_freeimage(fz_image *node) -{ - fz_free(node->data); - fz_free(node); -} - -fz_rect -fz_boundimage(fz_image *node, fz_matrix ctm) -{ - fz_point ll, lr, ul, ur; - fz_rect r; - - ll = fz_transformpoint(ctm, (fz_point){0,0}); - lr = fz_transformpoint(ctm, (fz_point){1,0}); - ul = fz_transformpoint(ctm, (fz_point){0,1}); - ur = fz_transformpoint(ctm, (fz_point){1,1}); - - r.min.x = MIN4(ll.x, lr.x, ul.x, ur.x); - r.min.y = MIN4(ll.y, lr.y, ul.y, ur.y); - r.max.x = MAX4(ll.x, lr.x, ul.x, ur.x); - r.max.y = MAX4(ll.y, lr.y, ul.y, ur.y); - - return r; -} - diff --git a/tree/mask.c b/tree/mask.c deleted file mode 100644 index 62a469ff..00000000 --- a/tree/mask.c +++ /dev/null @@ -1,50 +0,0 @@ -#include <fitz.h> - -fz_error * -fz_newmask(fz_node **nodep) -{ - fz_mask *node; - - node = fz_malloc(sizeof (fz_mask)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NMASK); - node->child = nil; - - return nil; -} - -void -fz_freemask(fz_mask *node) -{ - if (node->child) - fz_freenode(node->child); - fz_free(node); -} - -fz_rect -fz_boundmask(fz_mask* node, fz_matrix ctm) -{ - fz_node *child; - fz_rect bbox; - fz_rect r; - - bbox = FZ_INFRECT; - - for (child = node->child; child; child = child->next) - { - r = fz_boundnode(child, ctm); - if (r.max.x >= r.min.x) - { - if (bbox.max.x >= bbox.min.x) - bbox = fz_intersectrects(r, bbox); - else - bbox = r; - } - } - - return bbox; -} - diff --git a/tree/meta.c b/tree/meta.c deleted file mode 100644 index 4d3a2a74..00000000 --- a/tree/meta.c +++ /dev/null @@ -1,37 +0,0 @@ -#include <fitz.h> - -fz_error * -fz_newmeta(fz_node **nodep, fz_obj *info) -{ - fz_meta *node; - - node = fz_malloc(sizeof (fz_meta)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NMETA); - node->info = fz_keepobj(info); - node->child = nil; - - return nil; -} - -void -fz_freemeta(fz_meta *node) -{ - if (node->child) - fz_freenode(node->child); - if (node->info) - fz_dropobj(node->info); - fz_free(node); -} - -fz_rect -fz_boundmeta(fz_meta *node, fz_matrix ctm) -{ - if (!node->child) - return FZ_INFRECT; - return fz_boundnode(node->child, ctm); -} - diff --git a/tree/node.c b/tree/node.c deleted file mode 100644 index 8b9d48cc..00000000 --- a/tree/node.c +++ /dev/null @@ -1,148 +0,0 @@ -#include <fitz.h> - -void fz_freeover(fz_over* node); -void fz_freemask(fz_mask* node); -void fz_freeblend(fz_blend* node); -void fz_freetransform(fz_transform* node); -void fz_freeform(fz_form* node); -void fz_freesolid(fz_solid* node); -void fz_freepath(fz_path* node); -void fz_freetext(fz_text* node); -void fz_freeimage(fz_image* node); - -fz_rect fz_boundover(fz_over* node, fz_matrix ctm); -fz_rect fz_boundmask(fz_mask* node, fz_matrix ctm); -fz_rect fz_boundblend(fz_blend* node, fz_matrix ctm); -fz_rect fz_boundtransform(fz_transform* node, fz_matrix ctm); -fz_rect fz_boundform(fz_form* node, fz_matrix ctm); -fz_rect fz_boundsolid(fz_solid* node, fz_matrix ctm); -fz_rect fz_boundpath(fz_path* node, fz_matrix ctm); -fz_rect fz_boundtext(fz_text* node, fz_matrix ctm); -fz_rect fz_boundimage(fz_image* node, fz_matrix ctm); - -void -fz_initnode(fz_node *node, fz_nodekind kind) -{ - node->kind = kind; - node->parent = nil; -} - -void -fz_freenode(fz_node *node) -{ - if (node->next) - fz_freenode(node->next); - - switch (node->kind) - { - case FZ_NOVER: - fz_freeover((fz_over *) node); - break; - case FZ_NMASK: - fz_freemask((fz_mask *) node); - break; - case FZ_NBLEND: - fz_freeblend((fz_blend *) node); - break; - case FZ_NTRANSFORM: - fz_freetransform((fz_transform *) node); - break; - case FZ_NFORM: - fz_freeform((fz_form *) node); - break; - case FZ_NSOLID: - fz_freesolid((fz_solid *) node); - break; - case FZ_NPATH: - fz_freepath((fz_path *) node); - break; - case FZ_NTEXT: - fz_freetext((fz_text *) node); - break; - case FZ_NIMAGE: - fz_freeimage((fz_image *) node); - break; - } -} - -fz_rect -fz_boundnode(fz_node *node, fz_matrix ctm) -{ - switch (node->kind) - { - case FZ_NOVER: - return fz_boundover((fz_over *) node, ctm); - case FZ_NMASK: - return fz_boundmask((fz_mask *) node, ctm); - case FZ_NBLEND: - return fz_boundblend((fz_blend *) node, ctm); - case FZ_NTRANSFORM: - return fz_boundtransform((fz_transform *) node, ctm); - case FZ_NFORM: - return fz_boundform((fz_form *) node, ctm); - case FZ_NSOLID: - return fz_boundsolid((fz_solid *) node, ctm); - case FZ_NPATH: - return fz_boundpath((fz_path *) node, ctm); - case FZ_NTEXT: - return fz_boundtext((fz_text *) node, ctm); - case FZ_NIMAGE: - return fz_boundimage((fz_image *) node, ctm); - } - return FZ_INFRECT; -} - -int -fz_isover(fz_node *node) -{ - return node ? node->kind == FZ_NOVER : 0; -} - -int -fz_ismask(fz_node *node) -{ - return node ? node->kind == FZ_NMASK : 0; -} - -int -fz_isblend(fz_node *node) -{ - return node ? node->kind == FZ_NBLEND : 0; -} - -int -fz_istransform(fz_node *node) -{ - return node ? node->kind == FZ_NTRANSFORM : 0; -} - -int -fz_isform(fz_node *node) -{ - return node ? node->kind == FZ_NFORM : 0; -} - -int -fz_issolid(fz_node *node) -{ - return node ? node->kind == FZ_NSOLID : 0; -} - -int -fz_ispath(fz_node *node) -{ - return node ? node->kind == FZ_NPATH : 0; -} - -int -fz_istext(fz_node *node) -{ - return node ? node->kind == FZ_NTEXT : 0; -} - -int -fz_isimage(fz_node *node) -{ - return node ? node->kind == FZ_NIMAGE : 0; -} - diff --git a/tree/node1.c b/tree/node1.c new file mode 100644 index 00000000..c24b974a --- /dev/null +++ b/tree/node1.c @@ -0,0 +1,165 @@ +#include <fitz.h> + +void fz_freemetanode(fz_metanode* node); +void fz_freelinknode(fz_linknode* node); +void fz_freepathnode(fz_pathnode* node); +void fz_freetextnode(fz_textnode* node); +void fz_freeimagenode(fz_imagenode* node); + +fz_rect fz_boundtransformnode(fz_transformnode* node, fz_matrix ctm); +fz_rect fz_boundovernode(fz_overnode* node, fz_matrix ctm); +fz_rect fz_boundmasknode(fz_masknode* node, fz_matrix ctm); +fz_rect fz_boundblendnode(fz_blendnode* node, fz_matrix ctm); +fz_rect fz_boundcolornode(fz_colornode* node, fz_matrix ctm); +fz_rect fz_boundpathnode(fz_pathnode* node, fz_matrix ctm); +fz_rect fz_boundtextnode(fz_textnode* node, fz_matrix ctm); +fz_rect fz_boundimagenode(fz_imagenode* node, fz_matrix ctm); +fz_rect fz_boundshadenode(fz_shadenode* node, fz_matrix ctm); +fz_rect fz_boundlinknode(fz_linknode* node, fz_matrix ctm); +fz_rect fz_boundmetanode(fz_metanode* node, fz_matrix ctm); + +void +fz_initnode(fz_node *node, fz_nodekind kind) +{ + node->kind = kind; + node->parent = nil; + node->child = nil; + node->next = nil; +} + +void +fz_freenode(fz_node *node) +{ + if (node->child) + fz_freenode(node->child); + if (node->next) + fz_freenode(node->next); + + switch (node->kind) + { + case FZ_NTRANSFORM: + case FZ_NOVER: + case FZ_NMASK: + case FZ_NBLEND: + case FZ_NCOLOR: + break; + case FZ_NPATH: + fz_freepathnode((fz_pathnode *) node); + break; + case FZ_NTEXT: + fz_freetextnode((fz_textnode *) node); + break; + case FZ_NIMAGE: + fz_freeimagenode((fz_imagenode *) node); + break; + case FZ_NSHADE: + // XXX fz_freeshadenode((fz_shadenode *) node); + break; + case FZ_NLINK: + fz_freelinknode((fz_linknode *) node); + break; + case FZ_NMETA: + fz_freemetanode((fz_metanode *) node); + break; + } + + fz_free(node); +} + +fz_rect +fz_boundnode(fz_node *node, fz_matrix ctm) +{ + switch (node->kind) + { + case FZ_NTRANSFORM: + return fz_boundtransformnode((fz_transformnode *) node, ctm); + case FZ_NOVER: + return fz_boundovernode((fz_overnode *) node, ctm); + case FZ_NMASK: + return fz_boundmasknode((fz_masknode *) node, ctm); + case FZ_NBLEND: + return fz_boundblendnode((fz_blendnode *) node, ctm); + case FZ_NCOLOR: + return fz_boundcolornode((fz_colornode *) node, ctm); + case FZ_NPATH: + return fz_boundpathnode((fz_pathnode *) node, ctm); + case FZ_NTEXT: + return fz_boundtextnode((fz_textnode *) node, ctm); + case FZ_NIMAGE: + return fz_boundimagenode((fz_imagenode *) node, ctm); + case FZ_NSHADE: + // XXX return fz_boundshadenode((fz_shadenode *) node, ctm); + case FZ_NLINK: + return fz_boundlinknode((fz_linknode *) node, ctm); + case FZ_NMETA: + return fz_boundmetanode((fz_metanode *) node, ctm); + } + return FZ_INFRECT; +} + +int +fz_istransformnode(fz_node *node) +{ + return node ? node->kind == FZ_NTRANSFORM : 0; +} + +int +fz_isovernode(fz_node *node) +{ + return node ? node->kind == FZ_NOVER : 0; +} + +int +fz_ismasknode(fz_node *node) +{ + return node ? node->kind == FZ_NMASK : 0; +} + +int +fz_isblendnode(fz_node *node) +{ + return node ? node->kind == FZ_NBLEND : 0; +} + +int +fz_iscolornode(fz_node *node) +{ + return node ? node->kind == FZ_NCOLOR : 0; +} + +int +fz_ispathnode(fz_node *node) +{ + return node ? node->kind == FZ_NPATH : 0; +} + +int +fz_istextnode(fz_node *node) +{ + return node ? node->kind == FZ_NTEXT : 0; +} + +int +fz_isimagenode(fz_node *node) +{ + return node ? node->kind == FZ_NIMAGE : 0; +} + +int +fz_isshadenode(fz_node *node) +{ + return node ? node->kind == FZ_NSHADE : 0; +} + +int +fz_islinknode(fz_node *node) +{ + return node ? node->kind == FZ_NLINK : 0; +} + +int +fz_ismetanode(fz_node *node) +{ + return node ? node->kind == FZ_NMETA : 0; +} + diff --git a/tree/node2.c b/tree/node2.c new file mode 100644 index 00000000..dc82265d --- /dev/null +++ b/tree/node2.c @@ -0,0 +1,304 @@ +#include <fitz.h> + +/* + * Over + */ + +fz_error * +fz_newovernode(fz_node **nodep) +{ + fz_node *node; + + node = *nodep = fz_malloc(sizeof (fz_overnode)); + if (!node) + return fz_outofmem; + + fz_initnode(node, FZ_NOVER); + + return nil; +} + +fz_rect +fz_boundovernode(fz_overnode *node, fz_matrix ctm) +{ + fz_node *child; + fz_rect bbox; + fz_rect r; + + bbox = FZ_INFRECT; + + for (child = node->super.child; child; child = child->next) + { + r = fz_boundnode(child, ctm); + if (r.max.x >= r.min.x) + { + if (bbox.max.x >= bbox.min.x) + bbox = fz_mergerects(r, bbox); + else + bbox = r; + } + } + + return bbox; +} + +/* + * Mask + */ + +fz_error * +fz_newmasknode(fz_node **nodep) +{ + fz_node *node; + + node = *nodep = fz_malloc(sizeof (fz_masknode)); + if (!node) + return fz_outofmem; + + fz_initnode(node, FZ_NMASK); + + return nil; +} + +fz_rect +fz_boundmasknode(fz_masknode *node, fz_matrix ctm) +{ + fz_node *child; + fz_rect bbox; + fz_rect r; + + bbox = FZ_INFRECT; + + for (child = node->super.child; child; child = child->next) + { + r = fz_boundnode(child, ctm); + if (r.max.x >= r.min.x) + { + if (bbox.max.x >= bbox.min.x) + bbox = fz_intersectrects(r, bbox); + else + bbox = r; + } + } + + return bbox; +} + +/* + * Blend + */ + +fz_error * +fz_newblendnode(fz_node **nodep, fz_blendkind b, int k, int i) +{ + fz_blendnode *node; + + node = fz_malloc(sizeof (fz_blendnode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NBLEND); + node->mode = b; + node->knockout = k; + node->isolated = i; + + return nil; +} + +fz_rect +fz_boundblendnode(fz_blendnode *node, fz_matrix ctm) +{ + fz_node *child; + fz_rect bbox; + fz_rect r; + + bbox = FZ_INFRECT; + + for (child = node->super.child; child; child = child->next) + { + r = fz_boundnode(child, ctm); + if (r.max.x >= r.min.x) + { + if (bbox.max.x >= bbox.min.x) + bbox = fz_mergerects(r, bbox); + else + bbox = r; + } + } + + return bbox; +} + +/* + * Transform + */ + +fz_error * +fz_newtransformnode(fz_node **nodep, fz_matrix m) +{ + fz_transformnode *node; + + node = fz_malloc(sizeof (fz_transformnode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NTRANSFORM); + node->m = m; + + return nil; +} + +fz_rect +fz_boundtransformnode(fz_transformnode *node, fz_matrix ctm) +{ + if (!node->super.child) + return FZ_INFRECT; + return fz_boundnode(node->super.child, fz_concat(node->m, ctm)); +} + +/* + * Meta info + */ + +fz_error * +fz_newmetanode(fz_node **nodep, fz_obj *info) +{ + fz_metanode *node; + + node = fz_malloc(sizeof (fz_metanode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NMETA); + node->info = fz_keepobj(info); + + return nil; +} + +void +fz_freemetanode(fz_metanode *node) +{ + if (node->info) + fz_dropobj(node->info); +} + +fz_rect +fz_boundmetanode(fz_metanode *node, fz_matrix ctm) +{ + if (!node->super.child) + return FZ_INFRECT; + return fz_boundnode(node->super.child, ctm); +} + +/* + * Link to tree + */ + +fz_error * +fz_newlinknode(fz_node **nodep, fz_tree *subtree) +{ + fz_linknode *node; + + node = fz_malloc(sizeof (fz_linknode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NLINK); + node->tree = fz_keeptree(subtree); + + return nil; +} + +void +fz_freelinknode(fz_linknode *node) +{ + fz_droptree(node->tree); +} + +fz_rect +fz_boundlinknode(fz_linknode *node, fz_matrix ctm) +{ + return fz_boundtree(node->tree, ctm); +} + +/* + * Solid color + */ + +fz_error * +fz_newcolornode(fz_node **nodep, float r, float g, float b) +{ + fz_colornode *node; + + node = fz_malloc(sizeof (fz_colornode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NCOLOR); + node->r = r; + node->g = g; + node->b = b; + + return nil; +} + +fz_rect +fz_boundcolornode(fz_colornode *node, fz_matrix ctm) +{ + /* min > max => no bounds */ + return (fz_rect) { {1,1}, {-1,-1} }; +} + +/* + * Image node + */ + +fz_error * +fz_newimagenode(fz_node **nodep, int w, int h, int n, int a) +{ + fz_imagenode *node; + + node = fz_malloc(sizeof (fz_imagenode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NIMAGE); + node->w = w; + node->h = h; + node->n = n; + node->a = a; + + return nil; +} + +void +fz_freeimagenode(fz_imagenode *node) +{ + // XXX fz_dropimage(node->image); +} + +fz_rect +fz_boundimagenode(fz_imagenode *node, fz_matrix ctm) +{ + fz_point ll, lr, ul, ur; + fz_rect r; + + ll = fz_transformpoint(ctm, (fz_point){0,0}); + lr = fz_transformpoint(ctm, (fz_point){1,0}); + ul = fz_transformpoint(ctm, (fz_point){0,1}); + ur = fz_transformpoint(ctm, (fz_point){1,1}); + + r.min.x = MIN4(ll.x, lr.x, ul.x, ur.x); + r.min.y = MIN4(ll.y, lr.y, ul.y, ur.y); + r.max.x = MAX4(ll.x, lr.x, ul.x, ur.x); + r.max.y = MAX4(ll.y, lr.y, ul.y, ur.y); + + return r; +} + diff --git a/tree/over.c b/tree/over.c deleted file mode 100644 index d55bb297..00000000 --- a/tree/over.c +++ /dev/null @@ -1,50 +0,0 @@ -#include <fitz.h> - -fz_error * -fz_newover(fz_node **nodep) -{ - fz_over *node; - - node = fz_malloc(sizeof (fz_over)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NOVER); - node->child = nil; - - return nil; -} - -void -fz_freeover(fz_over *node) -{ - if (node->child) - fz_freenode(node->child); - fz_free(node); -} - -fz_rect -fz_boundover(fz_over* node, fz_matrix ctm) -{ - fz_node *child; - fz_rect bbox; - fz_rect r; - - bbox = FZ_INFRECT; - - for (child = node->child; child; child = child->next) - { - r = fz_boundnode(child, ctm); - if (r.max.x >= r.min.x) - { - if (bbox.max.x >= bbox.min.x) - bbox = fz_mergerects(r, bbox); - else - bbox = r; - } - } - - return bbox; -} - diff --git a/tree/path.c b/tree/path.c index d21fda56..bab84401 100644 --- a/tree/path.c +++ b/tree/path.c @@ -1,18 +1,21 @@ #include <fitz.h> fz_error * -fz_newpath(fz_path **pathp) +fz_newpathnode(fz_pathnode **pathp) { - fz_path *path; + fz_pathnode *path; - path = *pathp = fz_malloc(sizeof(fz_path)); + path = *pathp = fz_malloc(sizeof(fz_pathnode)); if (!path) return fz_outofmem; fz_initnode((fz_node*)path, FZ_NPATH); path->paint = FZ_FILL; - path->stroke = nil; + path->linecap = 0; + path->linejoin = 0; + path->linewidth = 1.0; + path->miterlimit = 10.0; path->dash = nil; path->len = 0; path->cap = 0; @@ -22,18 +25,21 @@ fz_newpath(fz_path **pathp) } fz_error * -fz_clonepath(fz_path **pathp, fz_path *oldpath) +fz_clonepath(fz_pathnode **pathp, fz_pathnode *oldpath) { - fz_path *path; + fz_pathnode *path; - path = *pathp = fz_malloc(sizeof(fz_path)); + path = *pathp = fz_malloc(sizeof(fz_pathnode)); if (!path) return fz_outofmem; fz_initnode((fz_node*)path, FZ_NPATH); path->paint = FZ_FILL; - path->stroke = nil; + path->linecap = 0; + path->linejoin = 0; + path->linewidth = 1.0; + path->miterlimit = 10.0; path->dash = nil; path->len = oldpath->len; path->cap = oldpath->len; @@ -49,16 +55,14 @@ fz_clonepath(fz_path **pathp, fz_path *oldpath) } void -fz_freepath(fz_path *node) +fz_freepathnode(fz_pathnode *node) { - fz_free(node->stroke); fz_free(node->dash); fz_free(node->els); - fz_free(node); } static fz_error * -growpath(fz_path *path, int n) +growpath(fz_pathnode *path, int n) { int newcap; fz_pathel *newels; @@ -77,7 +81,7 @@ growpath(fz_path *path, int n) } fz_error * -fz_moveto(fz_path *path, float x, float y) +fz_moveto(fz_pathnode *path, float x, float y) { if (growpath(path, 3) != nil) return fz_outofmem; @@ -88,7 +92,7 @@ fz_moveto(fz_path *path, float x, float y) } fz_error * -fz_lineto(fz_path *path, float x, float y) +fz_lineto(fz_pathnode *path, float x, float y) { if (growpath(path, 3) != nil) return fz_outofmem; @@ -99,7 +103,7 @@ fz_lineto(fz_path *path, float x, float y) } fz_error * -fz_curveto(fz_path *path, +fz_curveto(fz_pathnode *path, float x1, float y1, float x2, float y2, float x3, float y3) @@ -117,7 +121,7 @@ fz_curveto(fz_path *path, } fz_error * -fz_curvetov(fz_path *path, float x2, float y2, float x3, float y3) +fz_curvetov(fz_pathnode *path, float x2, float y2, float x3, float y3) { float x1 = path->els[path->len-2].v; float y1 = path->els[path->len-1].v; @@ -125,13 +129,13 @@ fz_curvetov(fz_path *path, float x2, float y2, float x3, float y3) } fz_error * -fz_curvetoy(fz_path *path, float x1, float y1, float x3, float y3) +fz_curvetoy(fz_pathnode *path, float x1, float y1, float x3, float y3) { return fz_curveto(path, x1, y1, x3, y3, x3, y3); } fz_error * -fz_closepath(fz_path *path) +fz_closepath(fz_pathnode *path) { if (growpath(path, 1) != nil) return fz_outofmem; @@ -140,7 +144,7 @@ fz_closepath(fz_path *path) } fz_error * -fz_endpath(fz_path *path, fz_pathkind paint, fz_stroke *stroke, fz_dash *dash) +fz_endpath(fz_pathnode *path, fz_pathkind paint, fz_stroke *stroke, fz_dash *dash) { fz_pathel *newels; @@ -150,8 +154,14 @@ fz_endpath(fz_path *path, fz_pathkind paint, fz_stroke *stroke, fz_dash *dash) path->els = newels; path->paint = paint; - path->stroke = stroke; path->dash = dash; + if (stroke) + { + path->linecap = stroke->linecap; + path->linejoin = stroke->linejoin; + path->linewidth = stroke->linewidth; + path->miterlimit = stroke->miterlimit; + } return nil; } @@ -174,7 +184,7 @@ static inline fz_rect boundexpand(fz_rect r, fz_point p) } fz_rect -fz_boundpath(fz_path *path, fz_matrix ctm) +fz_boundpathnode(fz_pathnode *path, fz_matrix ctm) { fz_point p; fz_rect r = FZ_INFRECT; @@ -204,8 +214,8 @@ fz_boundpath(fz_path *path, fz_matrix ctm) if (path->paint == FZ_STROKE) { - float miterlength = sin(path->stroke->miterlimit / 2.0); - float linewidth = path->stroke->linewidth; + float miterlength = sin(path->miterlimit / 2.0); + float linewidth = path->linewidth; float expand = MAX(miterlength, linewidth) / 2.0; r.min.x -= expand; r.min.y -= expand; @@ -217,7 +227,7 @@ fz_boundpath(fz_path *path, fz_matrix ctm) } void -fz_debugpath(fz_path *path) +fz_debugpathnode(fz_pathnode *path) { float x, y; int i = 0; diff --git a/tree/solid.c b/tree/solid.c deleted file mode 100644 index 37ff55eb..00000000 --- a/tree/solid.c +++ /dev/null @@ -1,33 +0,0 @@ -#include <fitz.h> - -fz_error * -fz_newsolid(fz_node **nodep, float r, float g, float b) -{ - fz_solid *node; - - node = fz_malloc(sizeof (fz_solid)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NSOLID); - node->r = r; - node->g = g; - node->b = b; - - return nil; -} - -void -fz_freesolid(fz_solid *node) -{ - fz_free(node); -} - -fz_rect -fz_boundsolid(fz_solid *node, fz_matrix ctm) -{ - /* min > max => no bounds */ - return (fz_rect) { {1,1}, {-1,-1} }; -} - diff --git a/tree/text.c b/tree/text.c index 312e3bde..f1992ade 100644 --- a/tree/text.c +++ b/tree/text.c @@ -1,11 +1,11 @@ #include <fitz.h> fz_error * -fz_newtext(fz_text **textp, fz_font *font) +fz_newtextnode(fz_textnode **textp, fz_font *font) { - fz_text *text; + fz_textnode *text; - text = *textp = fz_malloc(sizeof(fz_text)); + text = *textp = fz_malloc(sizeof(fz_textnode)); if (!text) return fz_outofmem; @@ -21,21 +21,21 @@ fz_newtext(fz_text **textp, fz_font *font) } void -fz_freetext(fz_text *text) +fz_freetextnode(fz_textnode *text) { fz_free(text->els); - fz_free(text); -}; +} fz_rect -fz_boundtext(fz_text *text, fz_matrix ctm) +fz_boundtextnode(fz_textnode *text, fz_matrix ctm) { + // FIXME convolve font bbox to all glyph x,y pairs /* fz_rect bounds = fz_boundglyph(text->font, text->els[0], ctm); */ return FZ_INFRECT; } static fz_error * -growtext(fz_text *text, int n) +growtext(fz_textnode *text, int n) { int newcap; fz_textel *newels; @@ -54,7 +54,7 @@ growtext(fz_text *text, int n) } fz_error * -fz_addtext(fz_text *text, int g, float x, float y) +fz_addtext(fz_textnode *text, int g, float x, float y) { if (growtext(text, 1) != nil) return fz_outofmem; diff --git a/tree/transform.c b/tree/transform.c deleted file mode 100644 index 18910d6b..00000000 --- a/tree/transform.c +++ /dev/null @@ -1,35 +0,0 @@ -#include <fitz.h> - -fz_error * -fz_newtransform(fz_node **nodep, fz_matrix m) -{ - fz_transform *node; - - node = fz_malloc(sizeof (fz_transform)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NTRANSFORM); - node->child = nil; - node->m = m; - - return nil; -} - -void -fz_freetransform(fz_transform *node) -{ - if (node->child) - fz_freenode(node->child); - fz_free(node); -} - -fz_rect -fz_boundtransform(fz_transform *node, fz_matrix ctm) -{ - if (!node->child) - return FZ_INFRECT; - return fz_boundnode(node->child, fz_concat(node->m, ctm)); -} - diff --git a/tree/tree.c b/tree/tree.c index 1a96ec38..7de88e11 100644 --- a/tree/tree.c +++ b/tree/tree.c @@ -9,18 +9,31 @@ fz_newtree(fz_tree **treep) if (!tree) return fz_outofmem; + tree->refcount = 1; tree->root = nil; tree->head = nil; return nil; } +fz_tree * +fz_keeptree(fz_tree *tree) +{ + tree->refcount ++; + return tree; +} + void -fz_freetree(fz_tree *tree) +fz_droptree(fz_tree *tree) { - if (tree->root) - fz_freenode(tree->root); - fz_free(tree); + tree->refcount --; + + if (tree->refcount == 0) + { + if (tree->root) + fz_freenode(tree->root); + fz_free(tree); + } } fz_rect @@ -32,32 +45,16 @@ fz_boundtree(fz_tree *tree, fz_matrix ctm) } void -fz_insertnode(fz_node *node, fz_node *child) +fz_insertnode(fz_node *parent, fz_node *child) { - child->parent = node; - - if (fz_isover(node)) - { - child->next = ((fz_over*)node)->child; - ((fz_over*)node)->child = child; - } - - if (fz_ismask(node)) - { - child->next = ((fz_mask*)node)->child; - ((fz_mask*)node)->child = child; - } - - if (fz_isblend(node)) - { - child->next = ((fz_blend*)node)->child; - ((fz_blend*)node)->child = child; - } - - if (fz_istransform(node)) - { - child->next = ((fz_transform*)node)->child; - ((fz_transform*)node)->child = child; - } + assert(fz_istransformnode(parent) || + fz_isovernode(parent) || + fz_ismasknode(parent) || + fz_isblendnode(parent) || + fz_ismetanode(parent)); + + child->parent = parent; + child->next = parent->child; + parent->child = child; } |