]> gitweb.michael.orlitzky.com - libsvgtiny.git/blob - examples/svgtiny_display_x11.c
src/svgtiny_css.c: use our userdata handler in set_libcss_node_data()
[libsvgtiny.git] / examples / svgtiny_display_x11.c
1 /*
2 * This file is part of Libsvgtiny
3 * Licensed under the MIT License,
4 * http://opensource.org/licenses/mit-license.php
5 * Copyright 2009-2010 James Bursa <james@semichrome.net>
6 */
7
8 /*
9 * This example loads an SVG using libsvgtiny and then displays it in an X11
10 * window using cairo.
11 *
12 * Functions of interest for libsvgtiny use are:
13 * main() - loads an SVG using svgtiny_create() and svgtiny_parse()
14 * event_diagram_expose() - renders the SVG by stepping through the shapes
15 *
16 * Compile using:
17 * gcc -g -W -Wall -o svgtiny_display_x11 svgtiny_display_x11.c \
18 * `pkg-config --cflags --libs libsvgtiny cairo` -lX11
19 */
20
21
22 #include <libgen.h>
23 #include <math.h>
24 #include <stdbool.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <unistd.h>
31 #include <X11/Xlib.h>
32 #include <X11/keysym.h>
33 #include <cairo.h>
34 #include <cairo-xlib.h>
35 #include <svgtiny.h>
36
37
38 struct svgtiny_diagram *diagram;
39 Display *display;
40 Window diagram_window;
41 Atom wm_protocols_atom, wm_delete_window_atom;
42 char *svg_path;
43 float scale = 1.0;
44 bool quit = false;
45
46
47 void gui_init(void);
48 void gui_quit(void);
49 void update_window_title(void);
50 void gui_poll(void);
51 void event_diagram_key_press(XKeyEvent *key_event);
52 void event_diagram_expose(const XExposeEvent *expose_event);
53 void render_path(cairo_t *cr, float scale, struct svgtiny_shape *path);
54 void die(const char *message);
55
56
57 /**
58 * Main program.
59 */
60 int main(int argc, char *argv[])
61 {
62 FILE *fd;
63 struct stat sb;
64 char *buffer;
65 size_t size;
66 size_t n;
67 svgtiny_code code;
68
69 if (argc != 2) {
70 fprintf(stderr, "Usage: %s FILE\n", argv[0]);
71 return 1;
72 }
73 svg_path = argv[1];
74
75 /* load file into memory buffer */
76 fd = fopen(svg_path, "rb");
77 if (!fd) {
78 perror(svg_path);
79 return 1;
80 }
81
82 if (stat(svg_path, &sb)) {
83 perror(svg_path);
84 return 1;
85 }
86 size = sb.st_size;
87
88 buffer = malloc(size);
89 if (!buffer) {
90 fprintf(stderr, "Unable to allocate %lld bytes\n",
91 (long long) size);
92 return 1;
93 }
94
95 n = fread(buffer, 1, size, fd);
96 if (n != size) {
97 perror(svg_path);
98 return 1;
99 }
100
101 fclose(fd);
102
103 /* create svgtiny object */
104 diagram = svgtiny_create();
105 if (!diagram) {
106 fprintf(stderr, "svgtiny_create failed\n");
107 return 1;
108 }
109
110 /* parse */
111 code = svgtiny_parse(diagram, buffer, size, svg_path, 1000, 1000);
112 if (code != svgtiny_OK) {
113 fprintf(stderr, "svgtiny_parse failed: ");
114 switch (code) {
115 case svgtiny_OUT_OF_MEMORY:
116 fprintf(stderr, "svgtiny_OUT_OF_MEMORY");
117 break;
118 case svgtiny_LIBDOM_ERROR:
119 fprintf(stderr, "svgtiny_LIBDOM_ERROR");
120 break;
121 case svgtiny_NOT_SVG:
122 fprintf(stderr, "svgtiny_NOT_SVG");
123 break;
124 case svgtiny_SVG_ERROR:
125 fprintf(stderr, "svgtiny_SVG_ERROR: line %i: %s",
126 diagram->error_line,
127 diagram->error_message);
128 break;
129 default:
130 fprintf(stderr, "unknown svgtiny_code %i", code);
131 break;
132 }
133 fprintf(stderr, "\n");
134 }
135
136 free(buffer);
137
138 /*printf("viewbox 0 0 %u %u\n",
139 diagram->width, diagram->height);*/
140
141 gui_init();
142
143 while (!quit) {
144 gui_poll();
145 }
146
147 gui_quit();
148 svgtiny_free(diagram);
149
150 return 0;
151 }
152
153
154 /**
155 * Initialize X11 interface.
156 */
157 void gui_init(void)
158 {
159 display = XOpenDisplay(NULL);
160 if (!display)
161 die("XOpenDisplay failed: is DISPLAY set?");
162
163 diagram_window = XCreateSimpleWindow(display,
164 DefaultRootWindow(display),
165 0, 0, diagram->width, diagram->height, 0, 0, 0);
166
167 update_window_title();
168
169 XMapWindow(display, diagram_window);
170 XSelectInput(display, diagram_window,
171 KeyPressMask |
172 ButtonPressMask |
173 ExposureMask |
174 StructureNotifyMask);
175
176 wm_protocols_atom = XInternAtom(display, "WM_PROTOCOLS", False);
177 wm_delete_window_atom = XInternAtom(display, "WM_DELETE_WINDOW", False);
178 XSetWMProtocols(display, diagram_window, &wm_delete_window_atom, 1);
179 }
180
181
182 /**
183 * Free X11 interface.
184 */
185 void gui_quit(void)
186 {
187 XCloseDisplay(display);
188 }
189
190
191 /**
192 * Update window title to show current state.
193 */
194 void update_window_title(void)
195 {
196 char title[100];
197 char *svg_path_copy;
198 char *base_name;
199
200 svg_path_copy = strdup(svg_path);
201 if (!svg_path_copy) {
202 fprintf(stderr, "out of memory\n");
203 return;
204 }
205
206 base_name = basename(svg_path_copy);
207
208 snprintf(title, sizeof title, "%s (%i%%) - svgtiny",
209 base_name, (int) roundf(scale * 100.0));
210
211 XStoreName(display, diagram_window, title);
212
213 free(svg_path_copy);
214 }
215
216
217 /**
218 * Handle an X11 event.
219 */
220 void gui_poll(void)
221 {
222 XEvent event;
223 XNextEvent(display, &event);
224
225 switch (event.type) {
226 case KeyPress:
227 if (event.xkey.window == diagram_window) {
228 event_diagram_key_press(&event.xkey);
229 }
230 break;
231 case Expose:
232 if (event.xexpose.window == diagram_window) {
233 event_diagram_expose(&event.xexpose);
234 }
235 break;
236 case ClientMessage:
237 if (event.xclient.message_type == wm_protocols_atom &&
238 event.xclient.format == 32 &&
239 (Atom) event.xclient.data.l[0] ==
240 wm_delete_window_atom)
241 quit = true;
242 break;
243 default:
244 /*printf("unknown event %i\n", event.type);*/
245 break;
246 }
247 }
248
249
250 /**
251 * Handle an X11 KeyPress event in the diagram window.
252 */
253 void event_diagram_key_press(XKeyEvent *key_event)
254 {
255 KeySym key_sym;
256 float new_scale = scale;
257 unsigned int width, height;
258
259 key_sym = XLookupKeysym(key_event, 0);
260
261 switch (key_sym) {
262 case XK_q:
263 case XK_Escape:
264 quit = true;
265 break;
266
267 case XK_minus:
268 case XK_KP_Subtract:
269 new_scale -= 0.1;
270 break;
271
272 case XK_equal:
273 case XK_plus:
274 case XK_KP_Add:
275 new_scale += 0.1;
276 break;
277
278 case XK_1:
279 case XK_KP_Multiply:
280 case XK_KP_1:
281 new_scale = 1;
282 break;
283
284 case XK_2:
285 case XK_KP_2:
286 new_scale = 2;
287 break;
288
289 default:
290 break;
291 }
292
293 if (new_scale < 0.1)
294 new_scale = 0.1;
295 else if (5 < new_scale)
296 new_scale = 5;
297
298 if (new_scale == scale)
299 return;
300
301 scale = new_scale;
302 width = diagram->width * scale;
303 height = diagram->height * scale;
304 if (width < 400)
305 width = 400;
306 if (height < 400)
307 height = 400;
308 XResizeWindow(display, diagram_window, width, height);
309 XClearArea(display, diagram_window, 0, 0, 0, 0, True);
310 update_window_title();
311 }
312
313
314 /**
315 * Handle an X11 Expose event of the diagram window.
316 */
317 void event_diagram_expose(const XExposeEvent *expose_event)
318 {
319 cairo_surface_t *surface;
320 cairo_t *cr;
321 cairo_status_t status;
322 unsigned int i;
323
324 if (expose_event->count != 0)
325 return;
326
327 surface = cairo_xlib_surface_create(display, diagram_window,
328 DefaultVisual(display, DefaultScreen(display)),
329 diagram->width * scale, diagram->height * scale);
330 if (!surface) {
331 fprintf(stderr, "cairo_xlib_surface_create failed\n");
332 return;
333 }
334
335 cr = cairo_create(surface);
336 status = cairo_status(cr);
337 if (status != CAIRO_STATUS_SUCCESS) {
338 fprintf(stderr, "cairo_create failed: %s\n",
339 cairo_status_to_string(status));
340 cairo_destroy(cr);
341 cairo_surface_destroy(surface);
342 return;
343 }
344
345 cairo_set_source_rgb(cr, 1, 1, 1);
346 cairo_paint(cr);
347
348 for (i = 0; i != diagram->shape_count; i++) {
349 if (diagram->shape[i].path) {
350 render_path(cr, scale, &diagram->shape[i]);
351
352 } else if (diagram->shape[i].text) {
353 cairo_set_source_rgb(cr,
354 svgtiny_RED(diagram->shape[i].stroke) / 255.0,
355 svgtiny_GREEN(diagram->shape[i].stroke) / 255.0,
356 svgtiny_BLUE(diagram->shape[i].stroke) / 255.0);
357 cairo_move_to(cr,
358 scale * diagram->shape[i].text_x,
359 scale * diagram->shape[i].text_y);
360 cairo_show_text(cr, diagram->shape[i].text);
361 }
362 }
363
364 status = cairo_status(cr);
365 if (status != CAIRO_STATUS_SUCCESS) {
366 fprintf(stderr, "cairo error: %s\n",
367 cairo_status_to_string(status));
368 cairo_destroy(cr);
369 cairo_surface_destroy(surface);
370 return;
371 }
372
373 cairo_destroy(cr);
374 cairo_surface_destroy(surface);
375 }
376
377
378 /**
379 * Render an svgtiny path using cairo.
380 */
381 void render_path(cairo_t *cr, float scale, struct svgtiny_shape *path)
382 {
383 unsigned int j;
384
385 cairo_new_path(cr);
386 for (j = 0; j != path->path_length; ) {
387 switch ((int) path->path[j]) {
388 case svgtiny_PATH_MOVE:
389 cairo_move_to(cr,
390 scale * path->path[j + 1],
391 scale * path->path[j + 2]);
392 j += 3;
393 break;
394 case svgtiny_PATH_CLOSE:
395 cairo_close_path(cr);
396 j += 1;
397 break;
398 case svgtiny_PATH_LINE:
399 cairo_line_to(cr,
400 scale * path->path[j + 1],
401 scale * path->path[j + 2]);
402 j += 3;
403 break;
404 case svgtiny_PATH_BEZIER:
405 cairo_curve_to(cr,
406 scale * path->path[j + 1],
407 scale * path->path[j + 2],
408 scale * path->path[j + 3],
409 scale * path->path[j + 4],
410 scale * path->path[j + 5],
411 scale * path->path[j + 6]);
412 j += 7;
413 break;
414 default:
415 printf("error ");
416 j += 1;
417 }
418 }
419 if (path->fill != svgtiny_TRANSPARENT) {
420 cairo_set_source_rgb(cr,
421 svgtiny_RED(path->fill) / 255.0,
422 svgtiny_GREEN(path->fill) / 255.0,
423 svgtiny_BLUE(path->fill) / 255.0);
424 cairo_fill_preserve(cr);
425 }
426 if (path->stroke != svgtiny_TRANSPARENT) {
427 cairo_set_source_rgb(cr,
428 svgtiny_RED(path->stroke) / 255.0,
429 svgtiny_GREEN(path->stroke) / 255.0,
430 svgtiny_BLUE(path->stroke) / 255.0);
431 cairo_set_line_width(cr, scale * path->stroke_width);
432 cairo_stroke_preserve(cr);
433 }
434 }
435
436
437 /**
438 * Exit with fatal error.
439 */
440 void die(const char *message)
441 {
442 fprintf(stderr, "%s\n", message);
443 exit(1);
444 }
445