Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. #include "fitz.h"
  2.  
  3. static void
  4. fz_trace_matrix(fz_matrix ctm)
  5. {
  6.         printf("matrix=\"%g %g %g %g %g %g\" ",
  7.                 ctm.a, ctm.b, ctm.c, ctm.d, ctm.e, ctm.f);
  8. }
  9.  
  10. static void
  11. fz_trace_color(fz_colorspace *colorspace, float *color, float alpha)
  12. {
  13.         int i;
  14.         printf("colorspace=\"%s\" color=\"", colorspace->name);
  15.         for (i = 0; i < colorspace->n; i++)
  16.                 printf("%s%g", i == 0 ? "" : " ", color[i]);
  17.         printf("\" ");
  18.         if (alpha < 1)
  19.                 printf("alpha=\"%g\" ", alpha);
  20. }
  21.  
  22. static void
  23. fz_trace_path(fz_path *path, int indent)
  24. {
  25.         float x, y;
  26.         int i = 0;
  27.         int n;
  28.         while (i < path->len)
  29.         {
  30.                 for (n = 0; n < indent; n++)
  31.                         putchar(' ');
  32.                 switch (path->items[i++].k)
  33.                 {
  34.                 case FZ_MOVETO:
  35.                         x = path->items[i++].v;
  36.                         y = path->items[i++].v;
  37.                         printf("<moveto x=\"%g\" y=\"%g\" />\n", x, y);
  38.                         break;
  39.                 case FZ_LINETO:
  40.                         x = path->items[i++].v;
  41.                         y = path->items[i++].v;
  42.                         printf("<lineto x=\"%g\" y=\"%g\" />\n", x, y);
  43.                         break;
  44.                 case FZ_CURVETO:
  45.                         x = path->items[i++].v;
  46.                         y = path->items[i++].v;
  47.                         printf("<curveto x1=\"%g\" y1=\"%g\" ", x, y);
  48.                         x = path->items[i++].v;
  49.                         y = path->items[i++].v;
  50.                         printf("x2=\"%g\" y2=\"%g\" ", x, y);
  51.                         x = path->items[i++].v;
  52.                         y = path->items[i++].v;
  53.                         printf("x3=\"%g\" y3=\"%g\" />\n", x, y);
  54.                         break;
  55.                 case FZ_CLOSE_PATH:
  56.                         printf("<closepath />\n");
  57.                         break;
  58.                 }
  59.         }
  60. }
  61.  
  62. static void
  63. fz_trace_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm,
  64.         fz_colorspace *colorspace, float *color, float alpha)
  65. {
  66.         printf("<fill_path ");
  67.         if (even_odd)
  68.                 printf("winding=\"eofill\" ");
  69.         else
  70.                 printf("winding=\"nonzero\" ");
  71.         fz_trace_color(colorspace, color, alpha);
  72.         fz_trace_matrix(ctm);
  73.         printf(">\n");
  74.         fz_trace_path(path, 0);
  75.         printf("</fill_path>\n");
  76. }
  77.  
  78. static void
  79. fz_trace_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
  80.         fz_colorspace *colorspace, float *color, float alpha)
  81. {
  82.         int i;
  83.  
  84.         printf("<stroke_path ");
  85.         printf("linewidth=\"%g\" ", stroke->linewidth);
  86.         printf("miterlimit=\"%g\" ", stroke->miterlimit);
  87.         printf("linecap=\"%d,%d,%d\" ", stroke->start_cap, stroke->dash_cap, stroke->end_cap);
  88.         printf("linejoin=\"%d\" ", stroke->linejoin);
  89.  
  90.         if (stroke->dash_len)
  91.         {
  92.                 printf("dash_phase=\"%g\" dash=\"", stroke->dash_phase);
  93.                 for (i = 0; i < stroke->dash_len; i++)
  94.                         printf("%g ", stroke->dash_list[i]);
  95.                 printf("\"");
  96.         }
  97.  
  98.         fz_trace_color(colorspace, color, alpha);
  99.         fz_trace_matrix(ctm);
  100.         printf(">\n");
  101.  
  102.         fz_trace_path(path, 0);
  103.  
  104.         printf("</stroke_path>\n");
  105. }
  106.  
  107. static void
  108. fz_trace_clip_path(void *user, fz_path *path, fz_rect *rect, int even_odd, fz_matrix ctm)
  109. {
  110.         printf("<clip_path ");
  111.         if (even_odd)
  112.                 printf("winding=\"eofill\" ");
  113.         else
  114.                 printf("winding=\"nonzero\" ");
  115.         fz_trace_matrix(ctm);
  116.         printf("contentbbox=\"%g %g %g %g\">\n",
  117.                 rect->x0, rect->y0, rect->x1, rect->y1);
  118.         fz_trace_path(path, 0);
  119.         printf("</clip_path>\n");
  120. }
  121.  
  122. static void
  123. fz_trace_clip_stroke_path(void *user, fz_path *path, fz_rect *rect, fz_stroke_state *stroke, fz_matrix ctm)
  124. {
  125.         printf("<clip_stroke_path ");
  126.         fz_trace_matrix(ctm);
  127.         printf(">\n");
  128.         fz_trace_path(path, 0);
  129.         printf("</clip_stroke_path>\n");
  130. }
  131.  
  132. static void
  133. fz_trace_fill_text(void *user, fz_text *text, fz_matrix ctm,
  134.         fz_colorspace *colorspace, float *color, float alpha)
  135. {
  136.         printf("<fill_text font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
  137.         fz_trace_color(colorspace, color, alpha);
  138.         fz_trace_matrix(fz_concat(ctm, text->trm));
  139.         printf(">\n");
  140.         fz_debug_text(text, 0);
  141.         printf("</fill_text>\n");
  142. }
  143.  
  144. static void
  145. fz_trace_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
  146.         fz_colorspace *colorspace, float *color, float alpha)
  147. {
  148.         printf("<stroke_text font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
  149.         fz_trace_color(colorspace, color, alpha);
  150.         fz_trace_matrix(fz_concat(ctm, text->trm));
  151.         printf(">\n");
  152.         fz_debug_text(text, 0);
  153.         printf("</stroke_text>\n");
  154. }
  155.  
  156. static void
  157. fz_trace_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate)
  158. {
  159.         printf("<clip_text font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
  160.         printf("accumulate=\"%d\" ", accumulate);
  161.         fz_trace_matrix(fz_concat(ctm, text->trm));
  162.         printf(">\n");
  163.         fz_debug_text(text, 0);
  164.         printf("</clip_text>\n");
  165. }
  166.  
  167. static void
  168. fz_trace_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
  169. {
  170.         printf("<clip_stroke_text font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
  171.         fz_trace_matrix(fz_concat(ctm, text->trm));
  172.         printf(">\n");
  173.         fz_debug_text(text, 0);
  174.         printf("</clip_stroke_text>\n");
  175. }
  176.  
  177. static void
  178. fz_trace_ignore_text(void *user, fz_text *text, fz_matrix ctm)
  179. {
  180.         printf("<ignore_text font=\"%s\" wmode=\"%d\" ", text->font->name, text->wmode);
  181.         fz_trace_matrix(fz_concat(ctm, text->trm));
  182.         printf(">\n");
  183.         fz_debug_text(text, 0);
  184.         printf("</ignore_text>\n");
  185. }
  186.  
  187. static void
  188. fz_trace_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
  189. {
  190.         printf("<fill_image alpha=\"%g\" ", alpha);
  191.         fz_trace_matrix(ctm);
  192.         printf("/>\n");
  193. }
  194.  
  195. static void
  196. fz_trace_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
  197. {
  198.         printf("<fill_shade alpha=\"%g\" ", alpha);
  199.         fz_trace_matrix(ctm);
  200.         printf("/>\n");
  201. }
  202.  
  203. static void
  204. fz_trace_fill_image_mask(void *user, fz_pixmap *image, fz_matrix ctm,
  205. fz_colorspace *colorspace, float *color, float alpha)
  206. {
  207.         printf("<fill_image_mask ");
  208.         fz_trace_matrix(ctm);
  209.         fz_trace_color(colorspace, color, alpha);
  210.         printf("/>\n");
  211. }
  212.  
  213. static void
  214. fz_trace_clip_image_mask(void *user, fz_pixmap *image, fz_rect *rect, fz_matrix ctm)
  215. {
  216.         printf("<clip_image_mask ");
  217.         fz_trace_matrix(ctm);
  218.         printf("/>\n");
  219. }
  220.  
  221. static void
  222. fz_trace_pop_clip(void *user)
  223. {
  224.         printf("<pop_clip />\n");
  225. }
  226.  
  227. static void
  228. fz_trace_begin_mask(void *user, fz_rect bbox, int luminosity, fz_colorspace *colorspace, float *color)
  229. {
  230.         printf("<mask bbox=\"%g %g %g %g\" s=\"%s\" ",
  231.                 bbox.x0, bbox.y0, bbox.x1, bbox.y1,
  232.                 luminosity ? "luminosity" : "alpha");
  233. //      fz_trace_color(colorspace, color, 1);
  234.         printf(">\n");
  235. }
  236.  
  237. static void
  238. fz_trace_end_mask(void *user)
  239. {
  240.         printf("</mask>\n");
  241. }
  242.  
  243. static void
  244. fz_trace_begin_group(void *user, fz_rect bbox, int isolated, int knockout, int blendmode, float alpha)
  245. {
  246.         printf("<group bbox=\"%g %g %g %g\" isolated=\"%d\" knockout=\"%d\" blendmode=\"%s\" alpha=\"%g\">\n",
  247.                 bbox.x0, bbox.y0, bbox.x1, bbox.y1,
  248.                 isolated, knockout, fz_blendmode_name(blendmode), alpha);
  249. }
  250.  
  251. static void
  252. fz_trace_end_group(void *user)
  253. {
  254.         printf("</group>\n");
  255. }
  256.  
  257. static void
  258. fz_trace_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
  259. {
  260.         printf("<tile ");
  261.         printf("area=\"%g %g %g %g\" ", area.x0, area.y0, area.x1, area.y1);
  262.         printf("view=\"%g %g %g %g\" ", view.x0, view.y0, view.x1, view.y1);
  263.         printf("xstep=\"%g\" ystep=\"%g\" ", xstep, ystep);
  264.         fz_trace_matrix(ctm);
  265.         printf(">\n");
  266. }
  267.  
  268. static void
  269. fz_trace_end_tile(void *user)
  270. {
  271.         printf("</tile>\n");
  272. }
  273.  
  274. fz_device *fz_new_trace_device(void)
  275. {
  276.         fz_device *dev = fz_new_device(NULL);
  277.  
  278.         dev->fill_path = fz_trace_fill_path;
  279.         dev->stroke_path = fz_trace_stroke_path;
  280.         dev->clip_path = fz_trace_clip_path;
  281.         dev->clip_stroke_path = fz_trace_clip_stroke_path;
  282.  
  283.         dev->fill_text = fz_trace_fill_text;
  284.         dev->stroke_text = fz_trace_stroke_text;
  285.         dev->clip_text = fz_trace_clip_text;
  286.         dev->clip_stroke_text = fz_trace_clip_stroke_text;
  287.         dev->ignore_text = fz_trace_ignore_text;
  288.  
  289.         dev->fill_shade = fz_trace_fill_shade;
  290.         dev->fill_image = fz_trace_fill_image;
  291.         dev->fill_image_mask = fz_trace_fill_image_mask;
  292.         dev->clip_image_mask = fz_trace_clip_image_mask;
  293.  
  294.         dev->pop_clip = fz_trace_pop_clip;
  295.  
  296.         dev->begin_mask = fz_trace_begin_mask;
  297.         dev->end_mask = fz_trace_end_mask;
  298.         dev->begin_group = fz_trace_begin_group;
  299.         dev->end_group = fz_trace_end_group;
  300.  
  301.         dev->begin_tile = fz_trace_begin_tile;
  302.         dev->end_tile = fz_trace_end_tile;
  303.  
  304.         return dev;
  305. }
  306.