3 Part of the swftools package.
5 Copyright (c) 2005/2006/2007 Matthias Kramm <kramm@quiss.org>
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
25 #include "../gfxdevice.h"
26 #include "../gfxtools.h"
28 #define PNG_INLINE_EXPORTS
34 typedef gfxcolor_t RGBA;
36 typedef struct _renderpoint
41 typedef struct _renderline
48 typedef struct _internal_result {
50 struct _internal_result*next;
54 typedef struct _clipbuffer {
56 struct _clipbuffer*next;
59 typedef struct _internal {
79 internal_result_t*results;
80 internal_result_t*result_next;
83 typedef enum {filltype_solid,filltype_clip,filltype_bitmap,filltype_gradient} filltype_t;
85 typedef struct _fillinfo {
92 char linear_or_radial;
96 static inline void add_pixel(internal_t*i, float x, int y)
100 if(x >= i->width2 || y >= i->height2 || y<0) return;
102 if(y<i->ymin) i->ymin = y;
103 if(y>i->ymax) i->ymax = y;
105 renderline_t*l = &i->lines[y];
107 if(l->num == l->size) {
109 l->points = (renderpoint_t*)rfx_realloc(l->points, l->size * sizeof(renderpoint_t));
111 l->points[l->num] = p;
115 /* set this to 0.777777 or something if the "both fillstyles set while not inside shape"
116 problem appears to often */
119 #define INT(x) ((int)((x)+16)-16)
121 static void add_line(gfxdevice_t*dev , double x1, double y1, double x2, double y2)
123 internal_t*i = (internal_t*)dev->internal;
125 double ny1, ny2, stepx;
127 int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
128 printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]\n", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
145 ny1 = INT(y1) + 1.0 + CUT;
148 ny2 = INT(y2) - 1.0 + CUT;
155 x1 = x1 + (ny1-y1)*stepx;
156 x2 = x2 + (ny2-y2)*stepx;
165 float xx = (float)(startx + posx);
166 add_pixel(i, xx ,posy);
172 #define PI 3.14159265358979
173 static void add_solidline(gfxdevice_t*dev, double x1, double y1, double x2, double y2, double width)
175 /* TODO: handle cap styles */
177 internal_t*i = (internal_t*)dev->internal;
190 /* Make sure the line is always at least one pixel wide */
192 /* That's what Macromedia's Player does at least at zoom level >= 1. */
195 /* That's what Macromedia's Player seems to do at zoom level 0. */
196 /* TODO: needs testing */
198 /* TODO: how does this interact with scaling? */
199 if(width * i->multiply < 1.0)
200 width = 1.0 / i->multiply;
203 sd = (double)dx*(double)dx+(double)dy*(double)dy;
225 add_line(dev, x1+vx, y1+vy, xx, yy);
228 for(t=1;t<segments;t++) {
229 double s = sin(t*PI/segments);
230 double c = cos(t*PI/segments);
231 xx = (x2 + vx*c - vy*s);
232 yy = (y2 + vx*s + vy*c);
233 add_line(dev, lastx, lasty, xx, yy);
240 add_line(dev, lastx, lasty, xx, yy);
245 add_line(dev, lastx, lasty, xx, yy);
248 for(t=1;t<segments;t++) {
249 double s = sin(t*PI/segments);
250 double c = cos(t*PI/segments);
251 xx = (x1 - vx*c + vy*s);
252 yy = (y1 - vx*s - vy*c);
253 add_line(dev, lastx, lasty, xx, yy);
257 add_line(dev, lastx, lasty, (x1+vx), (y1+vy));
260 static int compare_renderpoints(const void * _a, const void * _b)
262 renderpoint_t*a = (renderpoint_t*)_a;
263 renderpoint_t*b = (renderpoint_t*)_b;
264 if(a->x < b->x) return -1;
265 if(a->x > b->x) return 1;
269 static void fill_line_solid(RGBA*line, U32*z, int y, int x1, int x2, RGBA col)
273 U32 bit = 1<<(x1&31);
274 int bitpos = (x1/32);
277 int ainv = 255-col.a;
278 col.r = (col.r*col.a)>>8;
279 col.g = (col.g*col.a)>>8;
280 col.b = (col.b*col.a)>>8;
283 line[x].r = ((line[x].r*ainv)>>8)+col.r;
284 line[x].g = ((line[x].g*ainv)>>8)+col.g;
285 line[x].b = ((line[x].b*ainv)>>8)+col.b;
287 line[x].a = ((line[x].a*ainv)>>8)+col.a;
307 static void fill_line_bitmap(RGBA*line, U32*z, int y, int x1, int x2, fillinfo_t*info)
311 gfxmatrix_t*m = info->matrix;
312 gfximage_t*b = info->image;
314 if(!b || !b->width || !b->height) {
315 gfxcolor_t red = {255,255,0,0};
316 fill_line_solid(line, z, y, x1, x2, red);
320 double det = m->m00*m->m11 - m->m01*m->m10;
321 if(fabs(det) < 0.0005) {
322 /* x direction equals y direction- the image is invisible */
326 double xx1 = ( (-m->tx) * m->m11 - (y - m->ty) * m->m10) * det;
327 double yy1 = (- (-m->tx) * m->m01 + (y - m->ty) * m->m00) * det;
328 double xinc1 = m->m11 * det;
329 double yinc1 = m->m01 * det;
331 U32 bit = 1<<(x1&31);
332 int bitpos = (x1/32);
337 int xx = (int)(xx1 + x * xinc1);
338 int yy = (int)(yy1 - x * yinc1);
341 if(info->linear_or_radial) {
343 if(xx>=b->width) xx = b->width-1;
345 if(yy>=b->height) yy = b->height-1;
349 if(xx<0) xx += b->width;
350 if(yy<0) yy += b->height;
353 col = b->data[yy*b->width+xx];
356 /* needs bitmap with premultiplied alpha */
357 line[x].r = ((line[x].r*ainv)>>8)+col.r;
358 line[x].g = ((line[x].g*ainv)>>8)+col.g;
359 line[x].b = ((line[x].b*ainv)>>8)+col.b;
369 static void fill_line_gradient(RGBA*line, U32*z, int y, int x1, int x2, fillinfo_t*info)
373 gfxmatrix_t*m = info->matrix;
374 RGBA*g= info->gradient;
376 double det = m->m00*m->m11 - m->m01*m->m10;
377 if(fabs(det) < 0.0005) {
378 /* x direction equals y direction */
383 double xx1 = ( (-m->tx) * m->m11 - (y - m->ty) * m->m10) * det;
384 double yy1 = (- (-m->tx) * m->m01 + (y - m->ty) * m->m00) * det;
385 double xinc1 = m->m11 * det;
386 double yinc1 = m->m01 * det;
388 U32 bit = 1<<(x1&31);
389 int bitpos = (x1/32);
397 if(info->linear_or_radial) {
398 double xx = xx1 + x * xinc1;
399 double yy = yy1 + y * yinc1;
400 double r = sqrt(xx*xx + yy*yy);
402 pos = (int)(r*255.999);
404 double r = xx1 + x * xinc1;
407 pos = (int)((r+1)*127.999);
412 /* needs bitmap with premultiplied alpha */
413 line[x].r = ((line[x].r*ainv)/255)+col.r;
414 line[x].g = ((line[x].g*ainv)/255)+col.g;
415 line[x].b = ((line[x].b*ainv)/255)+col.b;
425 static void fill_line_clip(RGBA*line, U32*z, int y, int x1, int x2)
429 U32 bit = 1<<(x1&31);
430 int bitpos = (x1/32);
441 void fill_line(gfxdevice_t*dev, RGBA*line, U32*zline, int y, int startx, int endx, fillinfo_t*fill)
443 if(fill->type == filltype_solid)
444 fill_line_solid(line, zline, y, startx, endx, *fill->color);
445 else if(fill->type == filltype_clip)
446 fill_line_clip(line, zline, y, startx, endx);
447 else if(fill->type == filltype_bitmap)
448 fill_line_bitmap(line, zline, y, startx, endx, fill);
449 else if(fill->type == filltype_gradient)
450 fill_line_gradient(line, zline, y, startx, endx, fill);
453 void fill(gfxdevice_t*dev, fillinfo_t*fill)
455 internal_t*i = (internal_t*)dev->internal;
458 for(y=i->ymin;y<=i->ymax;y++) {
459 renderpoint_t*points = i->lines[y].points;
460 RGBA*line = &i->img[i->width2*y];
461 U32*zline = &i->clipbuf->data[i->bitwidth*y];
464 int num = i->lines[y].num;
466 qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
469 renderpoint_t*p = &points[n];
470 renderpoint_t*next= n<num-1?&points[n+1]:0;
472 int endx = next?next->x:i->width2;
481 fill_line(dev, line, zline, y, startx, endx, fill);
484 if(endx == i->width2)
487 if(fill->type == filltype_clip) {
488 if(i->clipbuf->next) {
489 U32*line2 = &i->clipbuf->next->data[i->bitwidth*y];
491 for(x=0;x<i->bitwidth;x++)
492 zline[x] &= line2[x];
500 void fill_solid(gfxdevice_t*dev, gfxcolor_t* color)
503 memset(&info, 0, sizeof(info));
504 info.type = filltype_solid;
509 int render_setparameter(struct _gfxdevice*dev, const char*key, const char*value)
511 internal_t*i = (internal_t*)dev->internal;
512 if(!strcmp(key, "antialize") || !strcmp(key, "antialise")) {
513 i->antialize = atoi(value);
514 i->zoom = i->antialize * i->multiply;
516 } else if(!strcmp(key, "multiply")) {
517 i->multiply = atoi(value);
518 i->zoom = i->antialize * i->multiply;
519 fprintf(stderr, "Warning: multiply not implemented yet\n");
521 } else if(!strcmp(key, "fillwhite")) {
522 i->fillwhite = atoi(value);
524 } else if(!strcmp(key, "palette")) {
525 i->palette = atoi(value);
531 void newclip(struct _gfxdevice*dev)
533 internal_t*i = (internal_t*)dev->internal;
535 clipbuffer_t*c = (clipbuffer_t*)rfx_calloc(sizeof(clipbuffer_t));
536 c->data = (U32*)rfx_calloc(sizeof(U32) * i->bitwidth * i->height2);
537 c->next = i->clipbuf;
540 memcpy(c->data, c->next->data, i->bitwidth*i->height2);
542 memset(c->data, 0, sizeof(U32)*i->bitwidth*i->height2);
545 void endclip(struct _gfxdevice*dev, char removelast)
547 internal_t*i = (internal_t*)dev->internal;
549 /* test for at least one cliplevel (the one we created ourselves) */
550 if(!i->clipbuf || (!i->clipbuf->next && !removelast)) {
551 fprintf(stderr, "endclip without any active clip buffers\n");
555 clipbuffer_t*c = i->clipbuf;
556 i->clipbuf = i->clipbuf->next;
558 free(c->data);c->data = 0;
562 void render_stroke(struct _gfxdevice*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit)
564 internal_t*i = (internal_t*)dev->internal;
567 /*if(cap_style != gfx_capRound || joint_style != gfx_joinRound) {
568 fprintf(stderr, "Warning: cap/joint style != round not yet supported\n");
572 if(line->type == gfx_moveTo) {
573 } else if(line->type == gfx_lineTo) {
574 double x1=x*i->zoom,y1=y*i->zoom;
575 double x3=line->x*i->zoom,y3=line->y*i->zoom;
576 add_solidline(dev, x1, y1, x3, y3, width * i->zoom);
577 fill_solid(dev, color);
578 } else if(line->type == gfx_splineTo) {
582 double x1=x*i->zoom,y1=y*i->zoom;
583 double x2=line->sx*i->zoom,y2=line->sy*i->zoom;
584 double x3=line->x*i->zoom,y3=line->y*i->zoom;
586 double c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
590 parts = (int)(sqrt(c)/3);
591 if(!parts) parts = 1;
593 for(t=1;t<=parts;t++) {
594 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
595 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
597 add_solidline(dev, xx, yy, nx, ny, width * i->zoom);
598 fill_solid(dev, color);
609 static void draw_line(gfxdevice_t*dev, gfxline_t*line)
611 internal_t*i = (internal_t*)dev->internal;
616 int x1,y1,x2,y2,x3,y3;
618 if(line->type == gfx_moveTo) {
619 } else if(line->type == gfx_lineTo) {
620 double x1=x*i->zoom,y1=y*i->zoom;
621 double x3=line->x*i->zoom,y3=line->y*i->zoom;
623 add_line(dev, x1, y1, x3, y3);
624 } else if(line->type == gfx_splineTo) {
625 int c,t,parts,qparts;
628 double x1=x*i->zoom,y1=y*i->zoom;
629 double x2=line->sx*i->zoom,y2=line->sy*i->zoom;
630 double x3=line->x*i->zoom,y3=line->y*i->zoom;
632 c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
636 parts = (int)(sqrt(c));
637 if(!parts) parts = 1;
639 for(t=1;t<=parts;t++) {
640 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
641 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
643 add_line(dev, xx, yy, nx, ny);
654 void render_startclip(struct _gfxdevice*dev, gfxline_t*line)
656 internal_t*i = (internal_t*)dev->internal;
658 memset(&info, 0, sizeof(info));
660 info.type = filltype_clip;
661 draw_line(dev, line);
665 void render_endclip(struct _gfxdevice*dev)
667 internal_t*i = (internal_t*)dev->internal;
671 void render_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color)
673 internal_t*i = (internal_t*)dev->internal;
675 draw_line(dev, line);
676 fill_solid(dev, color);
679 void render_fillbitmap(struct _gfxdevice*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
681 internal_t*i = (internal_t*)dev->internal;
683 gfxmatrix_t m2 = *matrix;
685 draw_line(dev, line);
688 memset(&info, 0, sizeof(info));
689 info.type = filltype_bitmap;
692 info.cxform = cxform;
694 m2.m00 *= i->zoom; m2.m01 *= i->zoom; m2.tx *= i->zoom;
695 m2.m10 *= i->zoom; m2.m11 *= i->zoom; m2.ty *= i->zoom;
700 void render_fillgradient(struct _gfxdevice*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
702 internal_t*i = (internal_t*)dev->internal;
704 gfxmatrix_t m2 = *matrix;
706 draw_line(dev, line);
710 memset(&info, 0, sizeof(info));
711 info.type = filltype_gradient;
715 m2.m00 *= i->zoom; m2.m01 *= i->zoom; m2.tx *= i->zoom;
716 m2.m10 *= i->zoom; m2.m11 *= i->zoom; m2.ty *= i->zoom;
718 info.linear_or_radial = type == gfxgradient_radial;
721 gfxcolor_t color = {0,0,0,0};
724 int nextpos = gradient->pos*256;
727 msg("<error> Invalid gradient- contains values > 1.0");
731 gfxcolor_t nextcolor = gradient->color;
735 double step = 1.0/(nextpos-pos);
737 for(t=pos;t<nextpos;t++) {
738 g[t].r = color.r*p0 + nextcolor.r*p1;
739 g[t].g = color.g*p0 + nextcolor.g*p1;
740 g[t].b = color.b*p0 + nextcolor.b*p1;
741 g[t].a = color.a*p0 + nextcolor.a*p1;
749 gradient = gradient->next;
752 msg("<error> Invalid gradient- doesn't end with 1.0");
758 void render_addfont(struct _gfxdevice*dev, gfxfont_t*font)
762 void render_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix)
764 internal_t*i = (internal_t*)dev->internal;
768 /* align characters to whole pixels */
769 matrix->tx = (int)(matrix->tx * i->antialize) / i->antialize;
770 matrix->ty = (int)(matrix->ty * i->antialize) / i->antialize;
772 gfxglyph_t*glyph = &font->glyphs[glyphnr];
773 gfxline_t*line2 = gfxline_clone(glyph->line);
774 gfxline_transform(line2, matrix);
775 draw_line(dev, line2);
776 fill_solid(dev, color);
782 void render_result_write(gfxresult_t*r, int filedesc)
784 internal_result_t*i= (internal_result_t*)r->internal;
786 int render_result_save(gfxresult_t*r, const char*filename)
788 internal_result_t*i= (internal_result_t*)r->internal;
790 return 0; // no pages drawn
794 char filenamebuf[256];
795 char*origname = strdup(filename);
796 int l = strlen(origname);
797 if(l>3 && strchr("gG",origname[l-1]) && strchr("nN",filename[l-2]) &&
798 strchr("pP",origname[l-3]) && filename[l-4]=='.') {
802 sprintf(filenamebuf, "%s.%d.png", origname, nr);
804 writePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
806 writePalettePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
813 writePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
815 writePalettePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
820 char*gfximage_asXPM(gfximage_t*img, int depth)
823 char*str = (char*)malloc(img->width*img->height*4 + 500 + 16*depth*depth*depth);
825 p+= sprintf(p, "static char *noname[] = {\n\"%d %d 262144 3\",\n");
829 for(b=0;b<depth;b++) {
830 p += sprintf(p, "\"%c%c%c c #%02x%02x%02x\",\n", r+32,g+32,b+32, r*d,g*d,b*d);
833 for(y=0;y<img->height;y++) {
835 gfxcolor_t*col = &img->data[y*img->height];
837 for(x=0;x<img->width;x++) {
838 p+=sprintf(p, "%c%c%c", 32+(col->r/d), 32+(col->g/d), 32+(col->b/d));
840 p+=sprintf(p, "\",\n");
845 void*render_result_get(gfxresult_t*r, const char*name)
847 internal_result_t*i= (internal_result_t*)r->internal;
848 if(!strncmp(name,"xpm",3)) {
849 int pagenr = atoi(&name[3]);
858 return gfximage_asXPM(&i->img, 64);
859 } else if(!strncmp(name,"page",4)) {
860 int pagenr = atoi(&name[4]);
873 void render_result_destroy(gfxresult_t*r)
875 internal_result_t*i= (internal_result_t*)r->internal;
878 internal_result_t*next = i->next;
879 free(i->img.data);i->img.data = 0;
882 the following rfx_free causes a segfault on WIN32 machines,
891 gfxresult_t* render_finish(struct _gfxdevice*dev)
893 internal_t*i = (internal_t*)dev->internal;
895 gfxresult_t* res = (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t));
897 res->internal = i->results;i->results = 0;
898 res->write = render_result_write;
899 res->save = render_result_save;
900 res->get = render_result_get;
901 res->destroy = render_result_destroy;
903 free(dev->internal); dev->internal = 0; i = 0;
908 void render_startpage(struct _gfxdevice*dev, int width, int height)
910 internal_t*i = (internal_t*)dev->internal;
913 if(i->width2 || i->height2) {
914 fprintf(stderr, "Error: startpage() called twice (no endpage()?)\n");
918 i->width = width*i->multiply;
919 i->height = height*i->multiply;
920 i->width2 = width*i->zoom;
921 i->height2 = height*i->zoom;
922 i->bitwidth = (i->width2+31)/32;
924 i->lines = (renderline_t*)rfx_alloc(i->height2*sizeof(renderline_t));
925 for(y=0;y<i->height2;y++) {
926 memset(&i->lines[y], 0, sizeof(renderline_t));
927 i->lines[y].points = 0;
930 i->img = (RGBA*)rfx_calloc(sizeof(RGBA)*i->width2*i->height2);
932 memset(i->img, 0xff, sizeof(RGBA)*i->width2*i->height2);
935 i->ymin = 0x7fffffff;
936 i->ymax = -0x80000000;
939 /* initialize initial clipping field, which doesn't clip anything yet */
941 memset(i->clipbuf->data, 255, sizeof(U32)*i->bitwidth*i->height2);
944 static void store_image(internal_t*i, internal_result_t*ir)
946 ir->img.data = (gfxcolor_t*)malloc(i->width*i->height*sizeof(gfxcolor_t));
947 ir->img.width = i->width;
948 ir->img.height = i->height;
950 gfxcolor_t*dest = ir->img.data;
952 if(i->antialize <= 1) /* no antializing */ {
954 for(y=0;y<i->height;y++) {
955 RGBA*line = &i->img[y*i->width];
956 memcpy(&dest[y*i->width], line, sizeof(RGBA)*i->width);
959 RGBA**lines = (RGBA**)rfx_calloc(sizeof(RGBA*)*i->antialize);
960 int q = i->antialize*i->antialize;
964 for(y=0;y<i->height2;y++) {
966 ypos = y % i->antialize;
967 lines[ypos] = &i->img[y*i->width2];
968 if(ypos == i->antialize-1) {
969 RGBA*out = &dest[(y2++)*i->width];
972 for(x=0;x<i->width;x++) {
973 int xpos = x*i->antialize;
976 for(yp=0;yp<i->antialize;yp++) {
977 RGBA*lp = &lines[yp][xpos];
979 for(xp=0;xp<i->antialize;xp++) {
998 void render_endpage(struct _gfxdevice*dev)
1000 internal_t*i = (internal_t*)dev->internal;
1002 if(!i->width2 || !i->height2) {
1003 fprintf(stderr, "Error: endpage() called without corresponding startpage()\n");
1015 fprintf(stderr, "Warning: %d unclosed clip(s) while processing endpage()\n", unclosed);
1018 internal_result_t*ir= (internal_result_t*)rfx_calloc(sizeof(internal_result_t));
1019 ir->palette = i->palette;
1026 if(i->result_next) {
1027 i->result_next->next = ir;
1032 i->result_next = ir;
1034 for(y=0;y<i->height2;y++) {
1035 rfx_free(i->lines[y].points); i->lines[y].points = 0;
1037 rfx_free(i->lines);i->lines=0;
1039 if(i->img) {rfx_free(i->img);i->img = 0;}
1045 void render_drawlink(struct _gfxdevice*dev, gfxline_t*line, const char*action)
1047 /* not supported for this output device */
1050 void gfxdevice_render_init(gfxdevice_t*dev)
1052 internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
1053 memset(dev, 0, sizeof(gfxdevice_t));
1055 dev->name = "render";
1067 dev->setparameter = render_setparameter;
1068 dev->startpage = render_startpage;
1069 dev->startclip = render_startclip;
1070 dev->endclip = render_endclip;
1071 dev->stroke = render_stroke;
1072 dev->fill = render_fill;
1073 dev->fillbitmap = render_fillbitmap;
1074 dev->fillgradient = render_fillgradient;
1075 dev->addfont = render_addfont;
1076 dev->drawchar = render_drawchar;
1077 dev->drawlink = render_drawlink;
1078 dev->endpage = render_endpage;
1079 dev->finish = render_finish;
1083 gfxdevice_t* gfxdevice_render_new()
1085 gfxdevice_t* d = (gfxdevice_t*)malloc(sizeof(gfxdevice_t));
1086 gfxdevice_render_init(d);