summary refs log blame commit diff stats
path: root/src/gtk2-prefs/main.h
blob: ab4e5cbd3f2a0ef47595a8aa422afada463ba369 (plain) (tree)































                                                                             
/***************************************************************************
                          main.cpp  -  description
                             -------------------
    begin                : Wed Jan  1 2003
    copyright            : (C) 2003 - 2005 by Alex Shaduri
    email                : ashaduri '@' gmail.com
 ***************************************************************************/

#ifndef _MAIN_H_
#define _MAIN_H_


#include <string>


std::string& get_orig_theme();
std::string& get_orig_font();

std::string get_current_theme();
std::string get_current_font();

std::string get_selected_theme();
std::string get_selected_font();

void set_theme(const std::string& theme_name, const std::string& font);
void apply_theme(const std::string& theme_name, const std::string& font);
bool save_current_theme();

void program_shutdown();


#endif
n321' href='#n321'>321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
diff -ruN --strip-trailing-cr pixman-0.26.2.orig/pixman/pixman.h pixman-0.26.2/pixman/pixman.h
--- pixman-0.26.2.orig/pixman/pixman.h	2012-06-29 18:25:17 +0000
+++ pixman-0.26.2/pixman/pixman.h	2012-02-22 10:01:16 +0000
@@ -69,6 +69,16 @@
 #ifndef PIXMAN_H__
 #define PIXMAN_H__
 
+#if (defined(_MSC_VER) && !defined(PIXMAN_STATIC))
+#ifdef BUILDING_PIXMAN
+#define PIXMAN_EXP __declspec(dllexport)
+#else
+#define PIXMAN_EXP __declspec(dllimport)
+#endif
+#else
+#define PIXMAN_EXP
+#endif
+
 #include <pixman-version.h>
 
 #ifdef  __cplusplus
@@ -184,43 +194,43 @@
 struct pixman_box16;
 typedef  union pixman_image		pixman_image_t;
 
-void          pixman_transform_init_identity    (struct pixman_transform       *matrix);
-pixman_bool_t pixman_transform_point_3d         (const struct pixman_transform *transform,
+PIXMAN_EXP void          pixman_transform_init_identity    (struct pixman_transform       *matrix);
+PIXMAN_EXP pixman_bool_t pixman_transform_point_3d         (const struct pixman_transform *transform,
 						 struct pixman_vector          *vector);
-pixman_bool_t pixman_transform_point            (const struct pixman_transform *transform,
+PIXMAN_EXP pixman_bool_t pixman_transform_point            (const struct pixman_transform *transform,
 						 struct pixman_vector          *vector);
-pixman_bool_t pixman_transform_multiply         (struct pixman_transform       *dst,
+PIXMAN_EXP pixman_bool_t pixman_transform_multiply         (struct pixman_transform       *dst,
 						 const struct pixman_transform *l,
 						 const struct pixman_transform *r);
-void          pixman_transform_init_scale       (struct pixman_transform       *t,
+PIXMAN_EXP void          pixman_transform_init_scale       (struct pixman_transform       *t,
 						 pixman_fixed_t                 sx,
 						 pixman_fixed_t                 sy);
-pixman_bool_t pixman_transform_scale            (struct pixman_transform       *forward,
+PIXMAN_EXP pixman_bool_t pixman_transform_scale            (struct pixman_transform       *forward,
 						 struct pixman_transform       *reverse,
 						 pixman_fixed_t                 sx,
 						 pixman_fixed_t                 sy);
-void          pixman_transform_init_rotate      (struct pixman_transform       *t,
+PIXMAN_EXP void          pixman_transform_init_rotate      (struct pixman_transform       *t,
 						 pixman_fixed_t                 cos,
 						 pixman_fixed_t                 sin);
-pixman_bool_t pixman_transform_rotate           (struct pixman_transform       *forward,
+PIXMAN_EXP pixman_bool_t pixman_transform_rotate           (struct pixman_transform       *forward,
 						 struct pixman_transform       *reverse,
 						 pixman_fixed_t                 c,
 						 pixman_fixed_t                 s);
-void          pixman_transform_init_translate   (struct pixman_transform       *t,
+PIXMAN_EXP void          pixman_transform_init_translate   (struct pixman_transform       *t,
 						 pixman_fixed_t                 tx,
 						 pixman_fixed_t                 ty);
-pixman_bool_t pixman_transform_translate        (struct pixman_transform       *forward,
+PIXMAN_EXP pixman_bool_t pixman_transform_translate        (struct pixman_transform       *forward,
 						 struct pixman_transform       *reverse,
 						 pixman_fixed_t                 tx,
 						 pixman_fixed_t                 ty);
-pixman_bool_t pixman_transform_bounds           (const struct pixman_transform *matrix,
+PIXMAN_EXP pixman_bool_t pixman_transform_bounds           (const struct pixman_transform *matrix,
 						 struct pixman_box16           *b);
-pixman_bool_t pixman_transform_invert           (struct pixman_transform       *dst,
+PIXMAN_EXP pixman_bool_t pixman_transform_invert           (struct pixman_transform       *dst,
 						 const struct pixman_transform *src);
-pixman_bool_t pixman_transform_is_identity      (const struct pixman_transform *t);
-pixman_bool_t pixman_transform_is_scale         (const struct pixman_transform *t);
-pixman_bool_t pixman_transform_is_int_translate (const struct pixman_transform *t);
-pixman_bool_t pixman_transform_is_inverse       (const struct pixman_transform *a,
+PIXMAN_EXP pixman_bool_t pixman_transform_is_identity      (const struct pixman_transform *t);
+PIXMAN_EXP pixman_bool_t pixman_transform_is_scale         (const struct pixman_transform *t);
+PIXMAN_EXP pixman_bool_t pixman_transform_is_int_translate (const struct pixman_transform *t);
+PIXMAN_EXP pixman_bool_t pixman_transform_is_inverse       (const struct pixman_transform *a,
 						 const struct pixman_transform *b);
 
 /*
@@ -236,43 +246,43 @@
     double  m[3][3];
 };
 
-pixman_bool_t pixman_transform_from_pixman_f_transform (struct pixman_transform         *t,
+PIXMAN_EXP pixman_bool_t pixman_transform_from_pixman_f_transform (struct pixman_transform         *t,
 							const struct pixman_f_transform *ft);
-void          pixman_f_transform_from_pixman_transform (struct pixman_f_transform       *ft,
+PIXMAN_EXP void          pixman_f_transform_from_pixman_transform (struct pixman_f_transform       *ft,
 							const struct pixman_transform   *t);
-pixman_bool_t pixman_f_transform_invert                (struct pixman_f_transform       *dst,
+PIXMAN_EXP pixman_bool_t pixman_f_transform_invert                (struct pixman_f_transform       *dst,
 							const struct pixman_f_transform *src);
-pixman_bool_t pixman_f_transform_point                 (const struct pixman_f_transform *t,
+PIXMAN_EXP pixman_bool_t pixman_f_transform_point                 (const struct pixman_f_transform *t,
 							struct pixman_f_vector          *v);
-void          pixman_f_transform_point_3d              (const struct pixman_f_transform *t,
+PIXMAN_EXP void          pixman_f_transform_point_3d              (const struct pixman_f_transform *t,
 							struct pixman_f_vector          *v);
-void          pixman_f_transform_multiply              (struct pixman_f_transform       *dst,
+PIXMAN_EXP void          pixman_f_transform_multiply              (struct pixman_f_transform       *dst,
 							const struct pixman_f_transform *l,
 							const struct pixman_f_transform *r);
-void          pixman_f_transform_init_scale            (struct pixman_f_transform       *t,
+PIXMAN_EXP void          pixman_f_transform_init_scale            (struct pixman_f_transform       *t,
 							double                           sx,
 							double                           sy);
-pixman_bool_t pixman_f_transform_scale                 (struct pixman_f_transform       *forward,
+PIXMAN_EXP pixman_bool_t pixman_f_transform_scale                 (struct pixman_f_transform       *forward,
 							struct pixman_f_transform       *reverse,
 							double                           sx,
 							double                           sy);
-void          pixman_f_transform_init_rotate           (struct pixman_f_transform       *t,
+PIXMAN_EXP void          pixman_f_transform_init_rotate           (struct pixman_f_transform       *t,
 							double                           cos,
 							double                           sin);
-pixman_bool_t pixman_f_transform_rotate                (struct pixman_f_transform       *forward,
+PIXMAN_EXP pixman_bool_t pixman_f_transform_rotate                (struct pixman_f_transform       *forward,
 							struct pixman_f_transform       *reverse,
 							double                           c,
 							double                           s);
-void          pixman_f_transform_init_translate        (struct pixman_f_transform       *t,
+PIXMAN_EXP void          pixman_f_transform_init_translate        (struct pixman_f_transform       *t,
 							double                           tx,
 							double                           ty);
-pixman_bool_t pixman_f_transform_translate             (struct pixman_f_transform       *forward,
+PIXMAN_EXP pixman_bool_t pixman_f_transform_translate             (struct pixman_f_transform       *forward,
 							struct pixman_f_transform       *reverse,
 							double                           tx,
 							double                           ty);
-pixman_bool_t pixman_f_transform_bounds                (const struct pixman_f_transform *t,
+PIXMAN_EXP pixman_bool_t pixman_f_transform_bounds                (const struct pixman_f_transform *t,
 							struct pixman_box16             *b);
-void          pixman_f_transform_init_identity         (struct pixman_f_transform       *t);
+PIXMAN_EXP void          pixman_f_transform_init_identity         (struct pixman_f_transform       *t);
 
 typedef enum
 {
@@ -399,74 +409,73 @@
 /* This function exists only to make it possible to preserve
  * the X ABI - it should go away at first opportunity.
  */
-void pixman_region_set_static_pointers (pixman_box16_t         *empty_box,
+PIXMAN_EXP void pixman_region_set_static_pointers (pixman_box16_t         *empty_box,
 					pixman_region16_data_t *empty_data,
 					pixman_region16_data_t *broken_data);
 
 /* creation/destruction */
-void                    pixman_region_init               (pixman_region16_t *region);
-void                    pixman_region_init_rect          (pixman_region16_t *region,
+PIXMAN_EXP void                    pixman_region_init               (pixman_region16_t *region);
+PIXMAN_EXP void                    pixman_region_init_rect          (pixman_region16_t *region,
 							  int                x,
 							  int                y,
 							  unsigned int       width,
 							  unsigned int       height);
-pixman_bool_t           pixman_region_init_rects         (pixman_region16_t *region,
+PIXMAN_EXP pixman_bool_t           pixman_region_init_rects         (pixman_region16_t *region,
 							  const pixman_box16_t *boxes,
 							  int                count);
-void                    pixman_region_init_with_extents  (pixman_region16_t *region,
+PIXMAN_EXP void                    pixman_region_init_with_extents  (pixman_region16_t *region,
 							  pixman_box16_t    *extents);
-void                    pixman_region_init_from_image    (pixman_region16_t *region,
+PIXMAN_EXP void                    pixman_region_init_from_image    (pixman_region16_t *region,
 							  pixman_image_t    *image);
-void                    pixman_region_fini               (pixman_region16_t *region);
+PIXMAN_EXP void                    pixman_region_fini               (pixman_region16_t *region);
 
 
 /* manipulation */
-void                    pixman_region_translate          (pixman_region16_t *region,
+PIXMAN_EXP void                    pixman_region_translate          (pixman_region16_t *region,
 							  int                x,
 							  int                y);
-pixman_bool_t           pixman_region_copy               (pixman_region16_t *dest,
+PIXMAN_EXP pixman_bool_t           pixman_region_copy               (pixman_region16_t *dest,
 							  pixman_region16_t *source);
-pixman_bool_t           pixman_region_intersect          (pixman_region16_t *new_reg,
+PIXMAN_EXP pixman_bool_t           pixman_region_intersect          (pixman_region16_t *new_reg,
 							  pixman_region16_t *reg1,
 							  pixman_region16_t *reg2);
-pixman_bool_t           pixman_region_union              (pixman_region16_t *new_reg,
+PIXMAN_EXP pixman_bool_t           pixman_region_union              (pixman_region16_t *new_reg,
 							  pixman_region16_t *reg1,
 							  pixman_region16_t *reg2);
-pixman_bool_t           pixman_region_union_rect         (pixman_region16_t *dest,
+PIXMAN_EXP pixman_bool_t           pixman_region_union_rect         (pixman_region16_t *dest,
 							  pixman_region16_t *source,
 							  int                x,
 							  int                y,
 							  unsigned int       width,
 							  unsigned int       height);
-pixman_bool_t		pixman_region_intersect_rect     (pixman_region16_t *dest,
+PIXMAN_EXP pixman_bool_t		pixman_region_intersect_rect     (pixman_region16_t *dest,
 							  pixman_region16_t *source,
 							  int                x,
 							  int                y,
 							  unsigned int       width,
 							  unsigned int       height);
-pixman_bool_t           pixman_region_subtract           (pixman_region16_t *reg_d,
+PIXMAN_EXP pixman_bool_t           pixman_region_subtract           (pixman_region16_t *reg_d,
 							  pixman_region16_t *reg_m,
 							  pixman_region16_t *reg_s);
-pixman_bool_t           pixman_region_inverse            (pixman_region16_t *new_reg,
+PIXMAN_EXP pixman_bool_t           pixman_region_inverse            (pixman_region16_t *new_reg,
 							  pixman_region16_t *reg1,
 							  pixman_box16_t    *inv_rect);
-pixman_bool_t           pixman_region_contains_point     (pixman_region16_t *region,
+PIXMAN_EXP pixman_bool_t           pixman_region_contains_point     (pixman_region16_t *region,
 							  int                x,
 							  int                y,
 							  pixman_box16_t    *box);
-pixman_region_overlap_t pixman_region_contains_rectangle (pixman_region16_t *region,
+PIXMAN_EXP pixman_region_overlap_t pixman_region_contains_rectangle (pixman_region16_t *region,
 							  pixman_box16_t    *prect);
-pixman_bool_t           pixman_region_not_empty          (pixman_region16_t *region);
-pixman_box16_t *        pixman_region_extents            (pixman_region16_t *region);
-int                     pixman_region_n_rects            (pixman_region16_t *region);
-pixman_box16_t *        pixman_region_rectangles         (pixman_region16_t *region,
+PIXMAN_EXP pixman_bool_t           pixman_region_not_empty          (pixman_region16_t *region);
+PIXMAN_EXP pixman_box16_t *        pixman_region_extents            (pixman_region16_t *region);
+PIXMAN_EXP int                     pixman_region_n_rects            (pixman_region16_t *region);
+PIXMAN_EXP pixman_box16_t *        pixman_region_rectangles         (pixman_region16_t *region,
 							  int               *n_rects);
-pixman_bool_t           pixman_region_equal              (pixman_region16_t *region1,
+PIXMAN_EXP pixman_bool_t           pixman_region_equal              (pixman_region16_t *region1,
 							  pixman_region16_t *region2);
-pixman_bool_t           pixman_region_selfcheck          (pixman_region16_t *region);
-void                    pixman_region_reset              (pixman_region16_t *region,
+PIXMAN_EXP pixman_bool_t           pixman_region_selfcheck          (pixman_region16_t *region);
+PIXMAN_EXP void                    pixman_region_reset              (pixman_region16_t *region,
 							  pixman_box16_t    *box);
-void			pixman_region_clear		 (pixman_region16_t *region);
 /*
  * 32 bit regions
  */
@@ -499,73 +508,72 @@
 };
 
 /* creation/destruction */
-void                    pixman_region32_init               (pixman_region32_t *region);
-void                    pixman_region32_init_rect          (pixman_region32_t *region,
+PIXMAN_EXP void                    pixman_region32_init               (pixman_region32_t *region);
+PIXMAN_EXP void                    pixman_region32_init_rect          (pixman_region32_t *region,
 							    int                x,
 							    int                y,
 							    unsigned int       width,
 							    unsigned int       height);
-pixman_bool_t           pixman_region32_init_rects         (pixman_region32_t *region,
+PIXMAN_EXP pixman_bool_t           pixman_region32_init_rects         (pixman_region32_t *region,
 							    const pixman_box32_t *boxes,
 							    int                count);
-void                    pixman_region32_init_with_extents  (pixman_region32_t *region,
+PIXMAN_EXP void                    pixman_region32_init_with_extents  (pixman_region32_t *region,
 							    pixman_box32_t    *extents);
-void                    pixman_region32_init_from_image    (pixman_region32_t *region,
+PIXMAN_EXP void                    pixman_region32_init_from_image    (pixman_region32_t *region,
 							    pixman_image_t    *image);
-void                    pixman_region32_fini               (pixman_region32_t *region);
+PIXMAN_EXP void                    pixman_region32_fini               (pixman_region32_t *region);
 
 
 /* manipulation */
-void                    pixman_region32_translate          (pixman_region32_t *region,
+PIXMAN_EXP void                    pixman_region32_translate          (pixman_region32_t *region,
 							    int                x,
 							    int                y);
-pixman_bool_t           pixman_region32_copy               (pixman_region32_t *dest,
+PIXMAN_EXP pixman_bool_t           pixman_region32_copy               (pixman_region32_t *dest,
 							    pixman_region32_t *source);
-pixman_bool_t           pixman_region32_intersect          (pixman_region32_t *new_reg,
+PIXMAN_EXP pixman_bool_t           pixman_region32_intersect          (pixman_region32_t *new_reg,
 							    pixman_region32_t *reg1,
 							    pixman_region32_t *reg2);
-pixman_bool_t           pixman_region32_union              (pixman_region32_t *new_reg,
+PIXMAN_EXP pixman_bool_t           pixman_region32_union              (pixman_region32_t *new_reg,
 							    pixman_region32_t *reg1,
 							    pixman_region32_t *reg2);
-pixman_bool_t		pixman_region32_intersect_rect     (pixman_region32_t *dest,
+PIXMAN_EXP pixman_bool_t		pixman_region32_intersect_rect     (pixman_region32_t *dest,
 							    pixman_region32_t *source,
 							    int                x,
 							    int                y,
 							    unsigned int       width,
 							    unsigned int       height);
-pixman_bool_t           pixman_region32_union_rect         (pixman_region32_t *dest,
+PIXMAN_EXP pixman_bool_t           pixman_region32_union_rect         (pixman_region32_t *dest,
 							    pixman_region32_t *source,
 							    int                x,
 							    int                y,
 							    unsigned int       width,
 							    unsigned int       height);
-pixman_bool_t           pixman_region32_subtract           (pixman_region32_t *reg_d,
+PIXMAN_EXP pixman_bool_t           pixman_region32_subtract           (pixman_region32_t *reg_d,
 							    pixman_region32_t *reg_m,
 							    pixman_region32_t *reg_s);
-pixman_bool_t           pixman_region32_inverse            (pixman_region32_t *new_reg,
+PIXMAN_EXP pixman_bool_t           pixman_region32_inverse            (pixman_region32_t *new_reg,
 							    pixman_region32_t *reg1,
 							    pixman_box32_t    *inv_rect);
-pixman_bool_t           pixman_region32_contains_point     (pixman_region32_t *region,
+PIXMAN_EXP pixman_bool_t           pixman_region32_contains_point     (pixman_region32_t *region,
 							    int                x,
 							    int                y,
 							    pixman_box32_t    *box);
-pixman_region_overlap_t pixman_region32_contains_rectangle (pixman_region32_t *region,
+PIXMAN_EXP pixman_region_overlap_t pixman_region32_contains_rectangle (pixman_region32_t *region,
 							    pixman_box32_t    *prect);
-pixman_bool_t           pixman_region32_not_empty          (pixman_region32_t *region);
-pixman_box32_t *        pixman_region32_extents            (pixman_region32_t *region);
-int                     pixman_region32_n_rects            (pixman_region32_t *region);
-pixman_box32_t *        pixman_region32_rectangles         (pixman_region32_t *region,
+PIXMAN_EXP pixman_bool_t           pixman_region32_not_empty          (pixman_region32_t *region);
+PIXMAN_EXP pixman_box32_t *        pixman_region32_extents            (pixman_region32_t *region);
+PIXMAN_EXP int                     pixman_region32_n_rects            (pixman_region32_t *region);
+PIXMAN_EXP pixman_box32_t *        pixman_region32_rectangles         (pixman_region32_t *region,
 							    int               *n_rects);
-pixman_bool_t           pixman_region32_equal              (pixman_region32_t *region1,
+PIXMAN_EXP pixman_bool_t           pixman_region32_equal              (pixman_region32_t *region1,
 							    pixman_region32_t *region2);
-pixman_bool_t           pixman_region32_selfcheck          (pixman_region32_t *region);
-void                    pixman_region32_reset              (pixman_region32_t *region,
+PIXMAN_EXP pixman_bool_t           pixman_region32_selfcheck          (pixman_region32_t *region);
+PIXMAN_EXP void                    pixman_region32_reset              (pixman_region32_t *region,
 							    pixman_box32_t    *box);
-void			pixman_region32_clear		   (pixman_region32_t *region);
 
 
 /* Copy / Fill / Misc */
-pixman_bool_t pixman_blt                (uint32_t           *src_bits,
+PIXMAN_EXP pixman_bool_t pixman_blt                (uint32_t           *src_bits,
 					 uint32_t           *dst_bits,
 					 int                 src_stride,
 					 int                 dst_stride,
@@ -577,7 +585,7 @@
 					 int                 dest_y,
 					 int                 width,
 					 int                 height);
-pixman_bool_t pixman_fill               (uint32_t           *bits,
+PIXMAN_EXP pixman_bool_t pixman_fill               (uint32_t           *bits,
 					 int                 stride,
 					 int                 bpp,
 					 int                 x,
@@ -586,8 +594,8 @@
 					 int                 height,
 					 uint32_t            _xor);
 
-int           pixman_version            (void);
-const char*   pixman_version_string     (void);
+PIXMAN_EXP int           pixman_version            (void);
+PIXMAN_EXP const char*   pixman_version_string     (void);
 
 /*
  * Images
@@ -729,88 +737,88 @@
 } pixman_format_code_t;
 
 /* Querying supported format values. */
-pixman_bool_t pixman_format_supported_destination (pixman_format_code_t format);
-pixman_bool_t pixman_format_supported_source      (pixman_format_code_t format);
+PIXMAN_EXP pixman_bool_t pixman_format_supported_destination (pixman_format_code_t format);
+PIXMAN_EXP pixman_bool_t pixman_format_supported_source      (pixman_format_code_t format);
 
 /* Constructors */
-pixman_image_t *pixman_image_create_solid_fill       (pixman_color_t               *color);
-pixman_image_t *pixman_image_create_linear_gradient  (pixman_point_fixed_t         *p1,
+PIXMAN_EXP pixman_image_t *pixman_image_create_solid_fill       (pixman_color_t               *color);
+PIXMAN_EXP pixman_image_t *pixman_image_create_linear_gradient  (pixman_point_fixed_t         *p1,
 						      pixman_point_fixed_t         *p2,
 						      const pixman_gradient_stop_t *stops,
 						      int                           n_stops);
-pixman_image_t *pixman_image_create_radial_gradient  (pixman_point_fixed_t         *inner,
+PIXMAN_EXP pixman_image_t *pixman_image_create_radial_gradient  (pixman_point_fixed_t         *inner,
 						      pixman_point_fixed_t         *outer,
 						      pixman_fixed_t                inner_radius,
 						      pixman_fixed_t                outer_radius,
 						      const pixman_gradient_stop_t *stops,
 						      int                           n_stops);
-pixman_image_t *pixman_image_create_conical_gradient (pixman_point_fixed_t         *center,
+PIXMAN_EXP pixman_image_t *pixman_image_create_conical_gradient (pixman_point_fixed_t         *center,
 						      pixman_fixed_t                angle,
 						      const pixman_gradient_stop_t *stops,
 						      int                           n_stops);
-pixman_image_t *pixman_image_create_bits             (pixman_format_code_t          format,
+PIXMAN_EXP pixman_image_t *pixman_image_create_bits             (pixman_format_code_t          format,
 						      int                           width,
 						      int                           height,
 						      uint32_t                     *bits,
 						      int                           rowstride_bytes);
 
 /* Destructor */
-pixman_image_t *pixman_image_ref                     (pixman_image_t               *image);
-pixman_bool_t   pixman_image_unref                   (pixman_image_t               *image);
+PIXMAN_EXP pixman_image_t *pixman_image_ref                     (pixman_image_t               *image);
+PIXMAN_EXP pixman_bool_t   pixman_image_unref                   (pixman_image_t               *image);
 
-void		pixman_image_set_destroy_function    (pixman_image_t		   *image,
+PIXMAN_EXP void		pixman_image_set_destroy_function    (pixman_image_t		   *image,
 						      pixman_image_destroy_func_t   function,
 						      void			   *data);
-void *		pixman_image_get_destroy_data        (pixman_image_t		   *image);
+PIXMAN_EXP void *		pixman_image_get_destroy_data        (pixman_image_t		   *image);
 
 /* Set properties */
-pixman_bool_t   pixman_image_set_clip_region         (pixman_image_t               *image,
+PIXMAN_EXP pixman_bool_t   pixman_image_set_clip_region         (pixman_image_t               *image,
 						      pixman_region16_t            *region);
-pixman_bool_t   pixman_image_set_clip_region32       (pixman_image_t               *image,
+PIXMAN_EXP pixman_bool_t   pixman_image_set_clip_region32       (pixman_image_t               *image,
 						      pixman_region32_t            *region);
-void		pixman_image_set_has_client_clip     (pixman_image_t               *image,
+PIXMAN_EXP void		pixman_image_set_has_client_clip     (pixman_image_t               *image,
 						      pixman_bool_t		    clien_clip);
-pixman_bool_t   pixman_image_set_transform           (pixman_image_t               *image,
+PIXMAN_EXP pixman_bool_t   pixman_image_set_transform           (pixman_image_t               *image,
 						      const pixman_transform_t     *transform);
-void            pixman_image_set_repeat              (pixman_image_t               *image,
+PIXMAN_EXP void            pixman_image_set_repeat              (pixman_image_t               *image,
 						      pixman_repeat_t               repeat);
-pixman_bool_t   pixman_image_set_filter              (pixman_image_t               *image,
+PIXMAN_EXP pixman_bool_t   pixman_image_set_filter              (pixman_image_t               *image,
 						      pixman_filter_t               filter,
 						      const pixman_fixed_t         *filter_params,
 						      int                           n_filter_params);
-void		pixman_image_set_source_clipping     (pixman_image_t		   *image,
+PIXMAN_EXP void		pixman_image_set_source_clipping     (pixman_image_t		   *image,
 						      pixman_bool_t                 source_clipping);
-void            pixman_image_set_alpha_map           (pixman_image_t               *image,
+PIXMAN_EXP void            pixman_image_set_alpha_map           (pixman_image_t               *image,
 						      pixman_image_t               *alpha_map,
 						      int16_t                       x,
 						      int16_t                       y);
-void            pixman_image_set_component_alpha     (pixman_image_t               *image,
+PIXMAN_EXP void            pixman_image_set_component_alpha     (pixman_image_t               *image,
 						      pixman_bool_t                 component_alpha);
-pixman_bool_t   pixman_image_get_component_alpha     (pixman_image_t               *image);
-void		pixman_image_set_accessors	     (pixman_image_t		   *image,
+PIXMAN_EXP pixman_bool_t   pixman_image_get_component_alpha     (pixman_image_t               *image);
+PIXMAN_EXP void		pixman_image_set_accessors	     (pixman_image_t		   *image,
 						      pixman_read_memory_func_t	    read_func,
 						      pixman_write_memory_func_t    write_func);
-void		pixman_image_set_indexed	     (pixman_image_t		   *image,
+PIXMAN_EXP void		pixman_image_set_indexed	     (pixman_image_t		   *image,
 						      const pixman_indexed_t	   *indexed);
-uint32_t       *pixman_image_get_data                (pixman_image_t               *image);
-int		pixman_image_get_width               (pixman_image_t               *image);
-int             pixman_image_get_height              (pixman_image_t               *image);
-int		pixman_image_get_stride              (pixman_image_t               *image); /* in bytes */
-int		pixman_image_get_depth               (pixman_image_t		   *image);
-pixman_format_code_t pixman_image_get_format	     (pixman_image_t		   *image);
-pixman_bool_t	pixman_image_fill_rectangles	     (pixman_op_t		    op,
+PIXMAN_EXP uint32_t       *pixman_image_get_data                (pixman_image_t               *image);
+PIXMAN_EXP int		pixman_image_get_width               (pixman_image_t               *image);
+PIXMAN_EXP int             pixman_image_get_height              (pixman_image_t               *image);
+PIXMAN_EXP int		pixman_image_get_stride              (pixman_image_t               *image); /* in bytes */
+PIXMAN_EXP int		pixman_image_get_depth               (pixman_image_t		   *image);
+PIXMAN_EXP pixman_format_code_t pixman_image_get_format	     (pixman_image_t		   *image);
+PIXMAN_EXP pixman_bool_t	pixman_image_fill_rectangles	     (pixman_op_t		    op,
 						      pixman_image_t		   *image,
 						      pixman_color_t		   *color,
 						      int			    n_rects,
 						      const pixman_rectangle16_t   *rects);
-pixman_bool_t   pixman_image_fill_boxes              (pixman_op_t                   op,
+PIXMAN_EXP pixman_bool_t   pixman_image_fill_boxes              (pixman_op_t                   op,
                                                       pixman_image_t               *dest,
                                                       pixman_color_t               *color,
                                                       int                           n_boxes,
                                                       const pixman_box32_t         *boxes);
 
 /* Composite */
-pixman_bool_t pixman_compute_composite_region (pixman_region16_t *region,
+PIXMAN_EXP pixman_bool_t pixman_compute_composite_region (pixman_region16_t *region,
 					       pixman_image_t    *src_image,
 					       pixman_image_t    *mask_image,
 					       pixman_image_t    *dest_image,
@@ -822,7 +830,7 @@
 					       int16_t            dest_y,
 					       uint16_t           width,
 					       uint16_t           height);
-void          pixman_image_composite          (pixman_op_t        op,
+PIXMAN_EXP void          pixman_image_composite          (pixman_op_t        op,
 					       pixman_image_t    *src,
 					       pixman_image_t    *mask,
 					       pixman_image_t    *dest,
@@ -834,7 +842,7 @@
 					       int16_t            dest_y,
 					       uint16_t           width,
 					       uint16_t           height);
-void          pixman_image_composite32        (pixman_op_t        op,
+PIXMAN_EXP void          pixman_image_composite32        (pixman_op_t        op,
 					       pixman_image_t    *src,
 					       pixman_image_t    *mask,
 					       pixman_image_t    *dest,
@@ -865,7 +873,7 @@
  * Since 0.21.2, pixman doesn't do these workarounds anymore, so now this
  * function is a no-op.
  */
-void pixman_disable_out_of_bounds_workaround (void);
+PIXMAN_EXP void pixman_disable_out_of_bounds_workaround (void);
 
 /*
  * Trapezoids
@@ -923,45 +931,45 @@
     pixman_span_fix_t	top, bot;
 };
 
-pixman_fixed_t pixman_sample_ceil_y        (pixman_fixed_t             y,
+PIXMAN_EXP pixman_fixed_t pixman_sample_ceil_y        (pixman_fixed_t             y,
 					    int                        bpp);
-pixman_fixed_t pixman_sample_floor_y       (pixman_fixed_t             y,
+PIXMAN_EXP pixman_fixed_t pixman_sample_floor_y       (pixman_fixed_t             y,
 					    int                        bpp);
-void           pixman_edge_step            (pixman_edge_t             *e,
+PIXMAN_EXP void           pixman_edge_step            (pixman_edge_t             *e,
 					    int                        n);
-void           pixman_edge_init            (pixman_edge_t             *e,
+PIXMAN_EXP void           pixman_edge_init            (pixman_edge_t             *e,
 					    int                        bpp,
 					    pixman_fixed_t             y_start,
 					    pixman_fixed_t             x_top,
 					    pixman_fixed_t             y_top,
 					    pixman_fixed_t             x_bot,
 					    pixman_fixed_t             y_bot);
-void           pixman_line_fixed_edge_init (pixman_edge_t             *e,
+PIXMAN_EXP void           pixman_line_fixed_edge_init (pixman_edge_t             *e,
 					    int                        bpp,
 					    pixman_fixed_t             y,
 					    const pixman_line_fixed_t *line,
 					    int                        x_off,
 					    int                        y_off);
-void           pixman_rasterize_edges      (pixman_image_t            *image,
+PIXMAN_EXP void           pixman_rasterize_edges      (pixman_image_t            *image,
 					    pixman_edge_t             *l,
 					    pixman_edge_t             *r,
 					    pixman_fixed_t             t,
 					    pixman_fixed_t             b);
-void           pixman_add_traps            (pixman_image_t            *image,
+PIXMAN_EXP void           pixman_add_traps            (pixman_image_t            *image,
 					    int16_t                    x_off,
 					    int16_t                    y_off,
 					    int                        ntrap,
 					    pixman_trap_t             *traps);
-void           pixman_add_trapezoids       (pixman_image_t            *image,
+PIXMAN_EXP void           pixman_add_trapezoids       (pixman_image_t            *image,
 					    int16_t                    x_off,
 					    int                        y_off,
 					    int                        ntraps,
 					    const pixman_trapezoid_t  *traps);
-void           pixman_rasterize_trapezoid  (pixman_image_t            *image,
+PIXMAN_EXP void           pixman_rasterize_trapezoid  (pixman_image_t            *image,
 					    const pixman_trapezoid_t  *trap,
 					    int                        x_off,
 					    int                        y_off);
-void          pixman_composite_trapezoids (pixman_op_t		       op,
+PIXMAN_EXP void          pixman_composite_trapezoids (pixman_op_t		       op,
 					   pixman_image_t *	       src,
 					   pixman_image_t *	       dst,
 					   pixman_format_code_t	       mask_format,
@@ -971,7 +979,7 @@
 					   int			       y_dst,
 					   int			       n_traps,
 					   const pixman_trapezoid_t *  traps);
-void          pixman_composite_triangles (pixman_op_t		       op,
+PIXMAN_EXP void          pixman_composite_triangles (pixman_op_t		       op,
 					  pixman_image_t *	       src,
 					  pixman_image_t *	       dst,
 					  pixman_format_code_t	       mask_format,
@@ -981,7 +989,7 @@
 					  int			       y_dst,
 					  int			       n_tris,
 					  const pixman_triangle_t *    tris);
-void	      pixman_add_triangles       (pixman_image_t              *image,
+PIXMAN_EXP void	      pixman_add_triangles       (pixman_image_t              *image,
 					  int32_t	               x_off,
 					  int32_t	               y_off,
 					  int	                       n_tris,