1/*---------------------------------------------------------------------------* 2 | PDFlib - A library for generating PDF on the fly | 3 +---------------------------------------------------------------------------+ 4 | Copyright (c) 1997-2004 Thomas Merz and PDFlib GmbH. All rights reserved. | 5 +---------------------------------------------------------------------------+ 6 | | 7 | This software is subject to the PDFlib license. It is NOT in the | 8 | public domain. Extended versions and commercial licenses are | 9 | available, please check http://www.pdflib.com. | 10 | | 11 *---------------------------------------------------------------------------*/ 12 13/* $Id: pdflib_py.c 14574 2005-10-29 16:27:43Z bonefish $ 14 * 15 * Wrapper code for the PDFlib Python binding 16 * 17 */ 18 19#include <string.h> 20#include <stdlib.h> 21 22#ifdef __cplusplus 23extern "C" { 24#endif 25#include <Python.h> 26#ifdef __cplusplus 27} 28#endif 29 30/* Compilers which are not strictly ANSI conforming can set PDF_VOLATILE 31 * to an empty value. 32 */ 33#ifndef PDF_VOLATILE 34#define PDF_VOLATILE volatile 35#endif 36 37/* Definitions for Windows/Unix exporting */ 38#if defined(__WIN32__) 39# if defined(_MSC_VER) 40# define SWIGEXPORT(a,b) __declspec(dllexport) a b 41# else 42# if defined(__BORLANDC__) 43# define SWIGEXPORT(a,b) a _export b 44# else 45# define SWIGEXPORT(a,b) a b 46# endif 47# endif 48#else 49# define SWIGEXPORT(a,b) a b 50#endif 51 52#ifdef SWIG_GLOBAL 53#ifdef __cplusplus 54#define SWIGSTATIC extern "C" 55#else 56#define SWIGSTATIC 57#endif 58#endif 59 60#ifndef SWIGSTATIC 61#define SWIGSTATIC static 62#endif 63 64typedef struct { 65 char *name; 66 PyObject *(*get_attr)(void); 67 int (*set_attr)(PyObject *); 68} swig_globalvar; 69 70typedef struct swig_varlinkobject { 71 PyObject_HEAD 72 swig_globalvar **vars; 73 int nvars; 74 int maxvars; 75} swig_varlinkobject; 76 77/* ---------------------------------------------------------------------- 78 swig_varlink_repr() 79 80 Function for python repr method 81 ---------------------------------------------------------------------- */ 82 83static PyObject * 84swig_varlink_repr(swig_varlinkobject *v) 85{ 86 v = v; 87 return PyString_FromString("<Global variables>"); 88} 89 90/* --------------------------------------------------------------------- 91 swig_varlink_print() 92 93 Print out all of the global variable names 94 --------------------------------------------------------------------- */ 95 96static int 97swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) 98{ 99 100 int i = 0; 101 flags = flags; 102 fprintf(fp,"Global variables { "); 103 while (v->vars[i]) { 104 fprintf(fp,"%s", v->vars[i]->name); 105 i++; 106 if (v->vars[i]) fprintf(fp,", "); 107 } 108 fprintf(fp," }\n"); 109 return 0; 110} 111 112/* -------------------------------------------------------------------- 113 swig_varlink_getattr 114 115 This function gets the value of a variable and returns it as a 116 PyObject. In our case, we'll be looking at the datatype and 117 converting into a number or string 118 -------------------------------------------------------------------- */ 119 120static PyObject * 121swig_varlink_getattr(swig_varlinkobject *v, char *n) 122{ 123 int i = 0; 124 char temp[128]; 125 126 while (v->vars[i]) { 127 if (strcmp(v->vars[i]->name,n) == 0) { 128 return (*v->vars[i]->get_attr)(); 129 } 130 i++; 131 } 132 sprintf(temp,"C global variable %s not found.", n); 133 PyErr_SetString(PyExc_NameError,temp); 134 return NULL; 135} 136 137/* ------------------------------------------------------------------- 138 swig_varlink_setattr() 139 140 This function sets the value of a variable. 141 ------------------------------------------------------------------- */ 142 143static int 144swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) 145{ 146 char temp[128]; 147 int i = 0; 148 while (v->vars[i]) { 149 if (strcmp(v->vars[i]->name,n) == 0) { 150 return (*v->vars[i]->set_attr)(p); 151 } 152 i++; 153 } 154 sprintf(temp,"C global variable %s not found.", n); 155 PyErr_SetString(PyExc_NameError,temp); 156 return 1; 157} 158 159statichere PyTypeObject varlinktype = { 160/* PyObject_HEAD_INIT(&PyType_Type) Note : This doesn't work on some machines */ 161 PyObject_HEAD_INIT(0) 162 0, 163 "varlink", /* Type name */ 164 sizeof(swig_varlinkobject), /* Basic size */ 165 0, /* Itemsize */ 166 0, /* Deallocator */ 167 (printfunc) swig_varlink_print, /* Print */ 168 (getattrfunc) swig_varlink_getattr, /* get attr */ 169 (setattrfunc) swig_varlink_setattr, /* Set attr */ 170 0, /* tp_compare */ 171 (reprfunc) swig_varlink_repr, /* tp_repr */ 172 0, /* tp_as_number */ 173 0, /* tp_as_mapping*/ 174 0, /* tp_hash */ 175}; 176 177/* Create a variable linking object for use later */ 178 179SWIGSTATIC PyObject * 180SWIG_newvarlink(void) 181{ 182 swig_varlinkobject *result = 0; 183 result = PyMem_NEW(swig_varlinkobject,1); 184 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */ 185 result->ob_type = &varlinktype; 186 /* _Py_NewReference(result); Does not seem to be necessary */ 187 result->nvars = 0; 188 result->maxvars = 64; 189 result->vars = (swig_globalvar **) malloc(64*sizeof(swig_globalvar *)); 190 result->vars[0] = 0; 191 result->ob_refcnt = 0; 192 Py_XINCREF((PyObject *) result); 193 return ((PyObject*) result); 194} 195 196#ifdef PDFLIB_UNUSED 197SWIGSTATIC void 198SWIG_addvarlink(PyObject *p, char *name, 199 PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) 200{ 201 swig_varlinkobject *v; 202 v= (swig_varlinkobject *) p; 203 204 if (v->nvars >= v->maxvars -1) { 205 v->maxvars = 2*v->maxvars; 206 v->vars = (swig_globalvar **) realloc(v->vars,v->maxvars*sizeof(swig_globalvar *)); 207 if (v->vars == NULL) { 208 fprintf(stderr,"SWIG : Fatal error in initializing Python module.\n"); 209 exit(1); 210 } 211 } 212 v->vars[v->nvars] = (swig_globalvar *) malloc(sizeof(swig_globalvar)); 213 v->vars[v->nvars]->name = (char *) malloc(strlen(name)+1); 214 strcpy(v->vars[v->nvars]->name,name); 215 v->vars[v->nvars]->get_attr = get_attr; 216 v->vars[v->nvars]->set_attr = set_attr; 217 v->nvars++; 218 v->vars[v->nvars] = 0; 219} 220 221#endif /* PDFLIB_UNUSED */ 222 223#include <stdlib.h> 224 225#ifdef SWIG_GLOBAL 226#ifdef __cplusplus 227#define SWIGSTATIC extern "C" 228#else 229#define SWIGSTATIC 230#endif 231#endif 232 233#ifndef SWIGSTATIC 234#define SWIGSTATIC static 235#endif 236 237 238/* SWIG pointer structure */ 239 240typedef struct SwigPtrType { 241 char *name; /* Datatype name */ 242 int len; /* Length (used for optimization) */ 243 void *(*cast)(void *); /* Pointer casting function */ 244 struct SwigPtrType *next; /* Linked list pointer */ 245} SwigPtrType; 246 247/* Pointer cache structure */ 248 249typedef struct { 250 int stat; /* Status (valid) bit */ 251 SwigPtrType *tp; /* Pointer to type structure */ 252 char name[256]; /* Given datatype name */ 253 char mapped[256]; /* Equivalent name */ 254} SwigCacheType; 255 256/* Some variables */ 257 258static int SwigPtrMax = 64; /* Max entries that can be currently held */ 259 /* This value may be adjusted dynamically */ 260static int SwigPtrN = 0; /* Current number of entries */ 261static int SwigPtrSort = 0; /* Status flag indicating sort */ 262static int SwigStart[256]; /* Starting positions of types */ 263 264/* Pointer table */ 265static SwigPtrType *SwigPtrTable = 0; /* Table containing pointer equivalences */ 266 267/* Cached values */ 268 269#define SWIG_CACHESIZE 8 270#define SWIG_CACHEMASK 0x7 271static SwigCacheType SwigCache[SWIG_CACHESIZE]; 272static int SwigCacheIndex = 0; 273static int SwigLastCache = 0; 274 275/* Sort comparison function */ 276static int swigsort(const void *data1, const void *data2) { 277 SwigPtrType *d1 = (SwigPtrType *) data1; 278 SwigPtrType *d2 = (SwigPtrType *) data2; 279 return strcmp(d1->name,d2->name); 280} 281 282/* Binary Search function */ 283static int swigcmp(const void *key, const void *data) { 284 char *k = (char *) key; 285 SwigPtrType *d = (SwigPtrType *) data; 286 return strncmp(k,d->name,d->len); 287} 288 289/* Register a new datatype with the type-checker */ 290 291SWIGSTATIC 292void SWIG_RegisterMapping(char *origtype, char *newtype, void *(*cast)(void *)) { 293 294 int i; 295 SwigPtrType *t = 0,*t1; 296 297 /* Allocate the pointer table if necessary */ 298 299 if (!SwigPtrTable) { 300 SwigPtrTable = (SwigPtrType *) malloc(SwigPtrMax*sizeof(SwigPtrType)); 301 SwigPtrN = 0; 302 } 303 /* Grow the table */ 304 if (SwigPtrN >= SwigPtrMax) { 305 SwigPtrMax = 2*SwigPtrMax; 306 SwigPtrTable = (SwigPtrType *) realloc((char *) SwigPtrTable,SwigPtrMax*sizeof(SwigPtrType)); 307 } 308 for (i = 0; i < SwigPtrN; i++) 309 if (strcmp(SwigPtrTable[i].name,origtype) == 0) { 310 t = &SwigPtrTable[i]; 311 break; 312 } 313 if (!t) { 314 t = &SwigPtrTable[SwigPtrN]; 315 t->name = origtype; 316 t->len = strlen(t->name); 317 t->cast = 0; 318 t->next = 0; 319 SwigPtrN++; 320 } 321 322 /* Check for existing entry */ 323 324 while (t->next) { 325 if ((strcmp(t->name,newtype) == 0)) { 326 if (cast) t->cast = cast; 327 return; 328 } 329 t = t->next; 330 } 331 332 /* Now place entry (in sorted order) */ 333 334 t1 = (SwigPtrType *) malloc(sizeof(SwigPtrType)); 335 t1->name = newtype; 336 t1->len = strlen(t1->name); 337 t1->cast = cast; 338 t1->next = 0; 339 t->next = t1; 340 SwigPtrSort = 0; 341} 342 343/* Make a pointer value string */ 344 345SWIGSTATIC 346void SWIG_MakePtr(char *_c, const void *_ptr, char *type) { 347 static char _hex[16] = 348 {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 349 'a', 'b', 'c', 'd', 'e', 'f'}; 350 unsigned long _p, _s; 351 char _result[20], *_r; /* Note : a 64-bit hex number = 16 digits */ 352 _r = _result; 353 _p = (unsigned long) _ptr; 354 if (_p > 0) { 355 while (_p > 0) { 356 _s = _p & 0xf; 357 *(_r++) = _hex[_s]; 358 _p = _p >> 4; 359 } 360 *_r = '_'; 361 while (_r >= _result) 362 *(_c++) = *(_r--); 363 } else { 364 strcpy (_c, "NULL"); 365 } 366 if (_ptr) 367 strcpy (_c, type); 368} 369 370/* Function for getting a pointer value */ 371 372SWIGSTATIC 373char *SWIG_GetPtr(char *_c, void **ptr, char *_t) 374{ 375 unsigned long _p; 376 char temp_type[256]; 377 char *name; 378 int i, len; 379 SwigPtrType *sp,*tp; 380 SwigCacheType *cache; 381 int start, end; 382 _p = 0; 383 384 /* Pointer values must start with leading underscore */ 385 if (*_c == '_') { 386 _c++; 387 /* Extract hex value from pointer */ 388 while (*_c) { 389 if ((*_c >= '0') && (*_c <= '9')) 390 _p = (_p << 4) + (*_c - '0'); 391 else if ((*_c >= 'a') && (*_c <= 'f')) 392 _p = (_p << 4) + ((*_c - 'a') + 10); 393 else 394 break; 395 _c++; 396 } 397 398 if (_t) { 399 if (strcmp(_t,_c)) { 400 if (!SwigPtrSort) { 401 qsort((void *) SwigPtrTable, SwigPtrN, sizeof(SwigPtrType), swigsort); 402 for (i = 0; i < 256; i++) { 403 SwigStart[i] = SwigPtrN; 404 } 405 for (i = SwigPtrN-1; i >= 0; i--) { 406 SwigStart[(int) (SwigPtrTable[i].name[1])] = i; 407 } 408 for (i = 255; i >= 1; i--) { 409 if (SwigStart[i-1] > SwigStart[i]) 410 SwigStart[i-1] = SwigStart[i]; 411 } 412 SwigPtrSort = 1; 413 for (i = 0; i < SWIG_CACHESIZE; i++) 414 SwigCache[i].stat = 0; 415 } 416 417 /* First check cache for matches. Uses last cache value as starting point */ 418 cache = &SwigCache[SwigLastCache]; 419 for (i = 0; i < SWIG_CACHESIZE; i++) { 420 if (cache->stat) { 421 if (strcmp(_t,cache->name) == 0) { 422 if (strcmp(_c,cache->mapped) == 0) { 423 cache->stat++; 424 *ptr = (void *) _p; 425 if (cache->tp->cast) *ptr = (*(cache->tp->cast))(*ptr); 426 return (char *) 0; 427 } 428 } 429 } 430 SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK; 431 if (!SwigLastCache) cache = SwigCache; 432 else cache++; 433 } 434 /* We have a type mismatch. Will have to look through our type 435 mapping table to figure out whether or not we can accept this datatype */ 436 437 start = SwigStart[(int) _t[1]]; 438 end = SwigStart[(int) _t[1]+1]; 439 sp = &SwigPtrTable[start]; 440 while (start < end) { 441 if (swigcmp(_t,sp) == 0) break; 442 sp++; 443 start++; 444 } 445 if (start >= end) sp = 0; 446 /* Try to find a match for this */ 447 if (sp) { 448 while (swigcmp(_t,sp) == 0) { 449 name = sp->name; 450 len = sp->len; 451 tp = sp->next; 452 /* Try to find entry for our given datatype */ 453 while(tp) { 454 if (tp->len >= 255) { 455 return _c; 456 } 457 strcpy(temp_type,tp->name); 458 strncat(temp_type,_t+len,255-tp->len); 459 if (strcmp(_c,temp_type) == 0) { 460 461 strcpy(SwigCache[SwigCacheIndex].mapped,_c); 462 strcpy(SwigCache[SwigCacheIndex].name,_t); 463 SwigCache[SwigCacheIndex].stat = 1; 464 SwigCache[SwigCacheIndex].tp = tp; 465 SwigCacheIndex = SwigCacheIndex & SWIG_CACHEMASK; 466 467 /* Get pointer value */ 468 *ptr = (void *) _p; 469 if (tp->cast) *ptr = (*(tp->cast))(*ptr); 470 return (char *) 0; 471 } 472 tp = tp->next; 473 } 474 sp++; 475 /* Hmmm. Didn't find it this time */ 476 } 477 } 478 /* Didn't find any sort of match for this data. 479 Get the pointer value and return the received type */ 480 *ptr = (void *) _p; 481 return _c; 482 } else { 483 /* Found a match on the first try. Return pointer value */ 484 *ptr = (void *) _p; 485 return (char *) 0; 486 } 487 } else { 488 /* No type specified. Good luck */ 489 *ptr = (void *) _p; 490 return (char *) 0; 491 } 492 } else { 493 if (strcmp (_c, "NULL") == 0) { 494 *ptr = (void *) 0; 495 return (char *) 0; 496 } 497 *ptr = (void *) 0; 498 return _c; 499 } 500} 501 502#include <setjmp.h> 503 504#include "pdflib.h" 505 506 507/* Exception handling */ 508 509#define try PDF_TRY(p) 510#define catch PDF_CATCH(p) { \ 511 char errmsg[1024];\ 512 sprintf(errmsg, "PDFlib Error [%d] %s: %s", PDF_get_errnum(p),\ 513 PDF_get_apiname(p), PDF_get_errmsg(p));\ 514 PyErr_SetString(PyExc_SystemError,errmsg); \ 515 return NULL; \ 516 } 517 518/* export the PDFlib routines to the shared library */ 519#ifdef __MWERKS__ 520#pragma export on 521#endif 522 523static PyObject *_wrap_PDF_new(PyObject *self, PyObject *args) { 524 PDF *p; 525 char _ptemp[128]; 526 char versionbuf[32]; 527 528 if(!PyArg_ParseTuple(args,":PDF_new")) 529 return NULL; 530 531 p = PDF_new(); 532 533 if (p) { 534#if defined(PY_VERSION) 535 sprintf(versionbuf, "Python %s", PY_VERSION); 536#elif defined(PATCHLEVEL) 537 sprintf(versionbuf, "Python %s", PATCHLEVEL); 538#else 539 sprintf(versionbuf, "Python (unknown)"); 540#endif 541 PDF_set_parameter(p, "binding", versionbuf); 542 } 543 else { 544 PyErr_SetString(PyExc_SystemError, "PDFlib error: in PDF_new()"); 545 return NULL; 546 } 547 548 SWIG_MakePtr(_ptemp, (char *) p,"_PDF_p"); 549 return Py_BuildValue("s",_ptemp); 550} 551 552static PyObject *_wrap_PDF_delete(PyObject *self, PyObject *args) { 553 PDF * p; 554 char * _argc0 = 0; 555 556 if(!PyArg_ParseTuple(args,"s:PDF_delete",&_argc0)) 557 return NULL; 558 if (_argc0) { 559 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 560 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_delete. Expected _PDF_p."); 561 return NULL; 562 } 563 } 564 565 PDF_delete(p); 566 567 Py_INCREF(Py_None); 568 return Py_None; 569} 570 571static PyObject *_wrap_PDF_open_file(PyObject *self, PyObject *args) { 572 int _result; 573 PDF * p; 574 char * _arg1; 575 char * _argc0 = 0; 576 577 if(!PyArg_ParseTuple(args,"ss:PDF_open_file",&_argc0,&_arg1)) 578 return NULL; 579 if (_argc0) { 580 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 581 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_open_file. Expected _PDF_p."); 582 return NULL; 583 } 584 } 585 586 try { _result = (int)PDF_open_file(p,_arg1); 587 } catch; 588 return Py_BuildValue("i",_result); 589} 590 591static PyObject *_wrap_PDF_close(PyObject *self, PyObject *args) { 592 PDF * p; 593 char * _argc0 = 0; 594 595 if(!PyArg_ParseTuple(args,"s:PDF_close",&_argc0)) 596 return NULL; 597 if (_argc0) { 598 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 599 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_close. Expected _PDF_p."); 600 return NULL; 601 } 602 } 603 604 try { PDF_close(p); 605 } catch; 606 Py_INCREF(Py_None); 607 return Py_None; 608} 609 610static PyObject *_wrap_PDF_get_buffer(PyObject *self, PyObject *args) { 611 char * _result; 612 PDF * p; 613 char * _argc0 = 0; 614 long size; 615 616 if(!PyArg_ParseTuple(args,"s:PDF_get_buffer",&_argc0)) 617 return NULL; 618 619 if (_argc0) { 620 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 621 PyErr_SetString(PyExc_TypeError, 622 "Type error in argument 1 of PDF_get_buffer. Expected _PDF_p."); 623 return NULL; 624 } 625 } 626 627 try { _result = (char *)PDF_get_buffer(p, &size); 628 } catch; 629 return Py_BuildValue("s#", _result, (int) size); 630} 631 632static PyObject *_wrap_PDF_begin_page(PyObject *self, PyObject *args) { 633 PDF * p; 634 float _arg1; 635 float _arg2; 636 char * _argc0 = 0; 637 638 if(!PyArg_ParseTuple(args,"sff:PDF_begin_page",&_argc0,&_arg1,&_arg2)) 639 return NULL; 640 if (_argc0) { 641 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 642 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_begin_page. Expected _PDF_p."); 643 return NULL; 644 } 645 } 646 647 try { PDF_begin_page(p,_arg1,_arg2); 648 } catch; 649 Py_INCREF(Py_None); 650 return Py_None; 651} 652 653static PyObject *_wrap_PDF_end_page(PyObject *self, PyObject *args) { 654 PDF * p; 655 char * _argc0 = 0; 656 657 if(!PyArg_ParseTuple(args,"s:PDF_end_page",&_argc0)) 658 return NULL; 659 if (_argc0) { 660 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 661 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_end_page. Expected _PDF_p."); 662 return NULL; 663 } 664 } 665 666 try { PDF_end_page(p); 667 } catch; 668 Py_INCREF(Py_None); 669 return Py_None; 670} 671 672static PyObject *_wrap_PDF_get_errmsg(PyObject *self, PyObject *args) { 673 PyObject * _resultobj; 674 char * _result; 675 PDF * p; 676 char * _argc0 = 0; 677 678 if(!PyArg_ParseTuple(args,"s:PDF_get_errmsg",&_argc0)) 679 return NULL; 680 681 if (_argc0) { 682 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 683 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_get_errmsg. Expected _PDF_p."); 684 return NULL; 685 } 686 } 687 688 try { _result = (char *)PDF_get_errmsg(p); 689 } catch; 690 _resultobj = Py_BuildValue("s", _result); 691 return _resultobj; 692} 693 694static PyObject *_wrap_PDF_get_apiname(PyObject *self, PyObject *args) { 695 PyObject * _resultobj; 696 char * _result; 697 PDF * p; 698 char * _argc0 = 0; 699 700 if(!PyArg_ParseTuple(args,"s:PDF_get_apiname",&_argc0)) 701 return NULL; 702 703 if (_argc0) { 704 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 705 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_get_apiname. Expected _PDF_p."); 706 return NULL; 707 } 708 } 709 710 try { _result = (char *)PDF_get_apiname(p); 711 } catch; 712 _resultobj = Py_BuildValue("s", _result); 713 return _resultobj; 714} 715 716static PyObject *_wrap_PDF_get_errnum(PyObject *self, PyObject *args) { 717 PyObject * _resultobj; 718 int _result; 719 PDF * p; 720 char * _argc0 = 0; 721 722 if(!PyArg_ParseTuple(args,"s:PDF_get_errnum",&_argc0)) 723 return NULL; 724 if (_argc0) { 725 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 726 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_get_errnum. Expected _PDF_p."); 727 return NULL; 728 } 729 } 730 731 try { _result = (int)PDF_get_errnum(p); 732 } catch; 733 _resultobj = Py_BuildValue("i",_result); 734 return _resultobj; 735} 736 737static PyObject *_wrap_PDF_set_parameter(PyObject *self, PyObject *args) { 738 PDF * p; 739 char * _arg1; 740 char * _arg2; 741 char * _argc0 = 0; 742 743 if(!PyArg_ParseTuple(args,"sss:PDF_set_parameter",&_argc0,&_arg1,&_arg2)) 744 return NULL; 745 if (_argc0) { 746 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 747 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_set_parameter. Expected _PDF_p."); 748 return NULL; 749 } 750 } 751 752 try { PDF_set_parameter(p,_arg1,_arg2); 753 } catch; 754 Py_INCREF(Py_None); 755 return Py_None; 756} 757 758static PyObject *_wrap_PDF_get_parameter(PyObject *self, PyObject *args) { 759 PyObject * _resultobj; 760 char * _result; 761 PDF * p; 762 char * _arg1; 763 float _arg2; 764 char * _argc0 = 0; 765 766 if(!PyArg_ParseTuple(args,"ssf:PDF_get_parameter",&_argc0,&_arg1,&_arg2)) 767 return NULL; 768 769 if (_argc0) { 770 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 771 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_get_parameter. Expected _PDF_p."); 772 return NULL; 773 } 774 } 775 776 try { _result = (char *)PDF_get_parameter(p,_arg1,_arg2); 777 } catch; 778 _resultobj = Py_BuildValue("s", _result); 779 return _resultobj; 780} 781 782static PyObject *_wrap_PDF_set_value(PyObject *self, PyObject *args) { 783 PyObject * _resultobj; 784 PDF * p; 785 char * _arg1; 786 float _arg2; 787 char * _argc0 = 0; 788 789 self = self; 790 if(!PyArg_ParseTuple(args,"ssf:PDF_set_value",&_argc0,&_arg1,&_arg2)) 791 return NULL; 792 if (_argc0) { 793 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 794 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_set_value. Expected _PDF_p."); 795 return NULL; 796 } 797 } 798{ 799 try { PDF_set_value(p,_arg1,_arg2); 800 } catch; 801} Py_INCREF(Py_None); 802 _resultobj = Py_None; 803 return _resultobj; 804} 805 806static PyObject *_wrap_PDF_get_value(PyObject *self, PyObject *args) { 807 PyObject * _resultobj; 808 float _result; 809 PDF * p; 810 char * _arg1; 811 float _arg2; 812 char * _argc0 = 0; 813 814 self = self; 815 if(!PyArg_ParseTuple(args,"ssf:PDF_get_value",&_argc0,&_arg1,&_arg2)) 816 return NULL; 817 if (_argc0) { 818 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 819 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_get_value. Expected _PDF_p."); 820 return NULL; 821 } 822 } 823{ 824 try { _result = (float)PDF_get_value(p,_arg1,_arg2); 825 } catch; 826} _resultobj = Py_BuildValue("f",_result); 827 return _resultobj; 828} 829 830static PyObject *_wrap_PDF_findfont(PyObject *self, PyObject *args) { 831 int _result; 832 PDF * p; 833 char * _arg1; 834 char * _arg2; 835 int _arg3; 836 char * _argc0 = 0; 837 838 if(!PyArg_ParseTuple(args,"sssi:PDF_findfont",&_argc0,&_arg1,&_arg2,&_arg3)) 839 return NULL; 840 if (_argc0) { 841 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 842 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_findfont. Expected _PDF_p."); 843 return NULL; 844 } 845 } 846 847 try { _result = (int)PDF_findfont(p,_arg1,_arg2,_arg3); 848 } catch; 849 return Py_BuildValue("i",_result); 850} 851 852static PyObject *_wrap_PDF_setfont(PyObject *self, PyObject *args) { 853 PDF * p; 854 int _arg1; 855 float _arg2; 856 char * _argc0 = 0; 857 858 if(!PyArg_ParseTuple(args,"sif:PDF_setfont",&_argc0,&_arg1,&_arg2)) 859 return NULL; 860 if (_argc0) { 861 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 862 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setfont. Expected _PDF_p."); 863 return NULL; 864 } 865 } 866 867 try { PDF_setfont(p,_arg1,_arg2); 868 } catch; 869 Py_INCREF(Py_None); 870 return Py_None; 871} 872 873static PyObject *_wrap_PDF_show(PyObject *self, PyObject *args) { 874 PDF * p; 875 char * _arg1; 876 char * _argc0 = 0; 877 int len; 878 879 if(!PyArg_ParseTuple(args,"ss:PDF_show",&_argc0,&_arg1)) 880 return NULL; 881 if (_argc0) { 882 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 883 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_show. Expected _PDF_p."); 884 return NULL; 885 } 886 } 887 888 try { 889 len = PyString_Size(PyTuple_GetItem(args, 1)); 890 PDF_show2(p,_arg1, len); 891 } catch; 892 Py_INCREF(Py_None); 893 return Py_None; 894} 895 896static PyObject *_wrap_PDF_show_xy(PyObject *self, PyObject *args) { 897 PDF * p; 898 char * _arg1; 899 float _arg2; 900 float _arg3; 901 char * _argc0 = 0; 902 int len; 903 904 if(!PyArg_ParseTuple(args,"ssff:PDF_show_xy",&_argc0,&_arg1,&_arg2,&_arg3)) 905 return NULL; 906 if (_argc0) { 907 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 908 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_show_xy. Expected _PDF_p."); 909 return NULL; 910 } 911 } 912 913 try { 914 len = PyString_Size(PyTuple_GetItem(args, 1)); 915 PDF_show_xy2(p,_arg1, len, _arg2,_arg3); 916 } catch; 917 Py_INCREF(Py_None); 918 return Py_None; 919} 920 921static PyObject *_wrap_PDF_continue_text(PyObject *self, PyObject *args) { 922 PDF * p; 923 char * _arg1; 924 char * _argc0 = 0; 925 int len; 926 927 if(!PyArg_ParseTuple(args,"ss:PDF_continue_text",&_argc0,&_arg1)) 928 return NULL; 929 930 if (_argc0) { 931 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 932 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_continue_text. Expected _PDF_p."); 933 return NULL; 934 } 935 } 936 937 try { 938 len = PyString_Size(PyTuple_GetItem(args, 1)); 939 PDF_continue_text2(p,_arg1, len); 940 } catch; 941 Py_INCREF(Py_None); 942 return Py_None; 943} 944 945static PyObject *_wrap_PDF_show_boxed(PyObject *self, PyObject *args) { 946 int _result; 947 PDF * p; 948 char * _arg1; 949 float _arg2; 950 float _arg3; 951 float _arg4; 952 float _arg5; 953 char * _arg6; 954 char * _arg7; 955 char * _argc0 = 0; 956 957 if(!PyArg_ParseTuple(args,"ssffffss:PDF_show_boxed",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7)) 958 return NULL; 959 960 if (_argc0) { 961 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 962 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_show_boxed. Expected _PDF_p."); 963 return NULL; 964 } 965 } 966 967 try { _result = (int)PDF_show_boxed(p,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7); 968 } catch; 969 970 return Py_BuildValue("i",_result); 971} 972 973static PyObject *_wrap_PDF_set_text_pos(PyObject *self, PyObject *args) { 974 PDF * p; 975 float _arg1; 976 float _arg2; 977 char * _argc0 = 0; 978 979 if(!PyArg_ParseTuple(args,"sff:PDF_set_text_pos",&_argc0,&_arg1,&_arg2)) 980 return NULL; 981 if (_argc0) { 982 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 983 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_set_text_pos. Expected _PDF_p."); 984 return NULL; 985 } 986 } 987 988 try { PDF_set_text_pos(p,_arg1,_arg2); 989 } catch; 990 Py_INCREF(Py_None); 991 return Py_None; 992} 993 994static PyObject *_wrap_PDF_stringwidth(PyObject *self, PyObject *args) { 995 float _result; 996 PDF * p; 997 char * _arg1; 998 int _arg2; 999 float _arg3; 1000 char * _argc0 = 0; 1001 int len; 1002 1003 if(!PyArg_ParseTuple(args,"ssif:PDF_stringwidth",&_argc0,&_arg1,&_arg2,&_arg3)) 1004 return NULL; 1005 if (_argc0) { 1006 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1007 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_stringwidth. Expected _PDF_p."); 1008 return NULL; 1009 } 1010 } 1011 1012 try { 1013 len = PyString_Size(PyTuple_GetItem(args, 1)); 1014 _result = (float)PDF_stringwidth2(p,_arg1, len, _arg2,_arg3); 1015 } catch; 1016 return Py_BuildValue("f",_result); 1017} 1018 1019static PyObject *_wrap_PDF_setdash(PyObject *self, PyObject *args) { 1020 PDF * p; 1021 float _arg1; 1022 float _arg2; 1023 char * _argc0 = 0; 1024 1025 if(!PyArg_ParseTuple(args,"sff:PDF_setdash",&_argc0,&_arg1,&_arg2)) 1026 return NULL; 1027 if (_argc0) { 1028 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1029 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setdash. Expected _PDF_p."); 1030 return NULL; 1031 } 1032 } 1033 1034 try { PDF_setdash(p,_arg1,_arg2); 1035 } catch; 1036 Py_INCREF(Py_None); 1037 return Py_None; 1038} 1039 1040static PyObject *_wrap_PDF_setpolydash(PyObject *self, PyObject *args) { 1041 PyObject *val; 1042 PDF *p; 1043 float fval, carray[MAX_DASH_LENGTH]; 1044 int PDF_VOLATILE length, i; 1045 char *_argc0 = NULL; 1046 PyObject *_argc1 = NULL; 1047 1048 if(!PyArg_ParseTuple(args, "sO:PDF_setpolydash", &_argc0, &_argc1)) 1049 return NULL; 1050 1051 if (!_argc0 || SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1052 PyErr_SetString(PyExc_TypeError, 1053 "Type error in argument 1 of PDF_setpolydash. Expected _PDF_p."); 1054 return NULL; 1055 } 1056 1057 if (!_argc1 || !PyTuple_Check(_argc1)) { 1058 PyErr_SetString(PyExc_TypeError, 1059 "Type error in argument 2 of PDF_setpolydash. Expected float tuple."); 1060 return NULL; 1061 } 1062 1063 length = PyTuple_Size(_argc1); 1064 1065 if (length > MAX_DASH_LENGTH) 1066 length = MAX_DASH_LENGTH; 1067 1068 for (i = 0; i < length; i++) { 1069 val = PyTuple_GetItem(_argc1, i); 1070 if (!PyArg_Parse(val, "f:PDF_setpolydash", &fval)) { 1071 PyErr_SetString(PyExc_TypeError, 1072 "Type error in argument 2 of PDF_setpolydash. Expected float."); 1073 return NULL; 1074 } 1075 carray[i] = fval; 1076 } 1077 1078 try { PDF_setpolydash(p, carray, length); 1079 } catch; 1080 1081 Py_INCREF(Py_None); 1082 return Py_None; 1083} 1084 1085static PyObject *_wrap_PDF_setflat(PyObject *self, PyObject *args) { 1086 PDF * p; 1087 float _arg1; 1088 char * _argc0 = 0; 1089 1090 if(!PyArg_ParseTuple(args,"sf:PDF_setflat",&_argc0,&_arg1)) 1091 return NULL; 1092 if (_argc0) { 1093 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1094 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setflat. Expected _PDF_p."); 1095 return NULL; 1096 } 1097 } 1098 1099 try { PDF_setflat(p,_arg1); 1100 } catch; 1101 Py_INCREF(Py_None); 1102 return Py_None; 1103} 1104 1105static PyObject *_wrap_PDF_setlinejoin(PyObject *self, PyObject *args) { 1106 PDF * p; 1107 int _arg1; 1108 char * _argc0 = 0; 1109 1110 if(!PyArg_ParseTuple(args,"si:PDF_setlinejoin",&_argc0,&_arg1)) 1111 return NULL; 1112 if (_argc0) { 1113 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1114 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setlinejoin. Expected _PDF_p."); 1115 return NULL; 1116 } 1117 } 1118 1119 try { PDF_setlinejoin(p,_arg1); 1120 } catch; 1121 Py_INCREF(Py_None); 1122 return Py_None; 1123} 1124 1125static PyObject *_wrap_PDF_setlinecap(PyObject *self, PyObject *args) { 1126 PDF * p; 1127 int _arg1; 1128 char * _argc0 = 0; 1129 1130 if(!PyArg_ParseTuple(args,"si:PDF_setlinecap",&_argc0,&_arg1)) 1131 return NULL; 1132 if (_argc0) { 1133 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1134 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setlinecap. Expected _PDF_p."); 1135 return NULL; 1136 } 1137 } 1138 1139 try { PDF_setlinecap(p,_arg1); 1140 } catch; 1141 Py_INCREF(Py_None); 1142 return Py_None; 1143} 1144 1145static PyObject *_wrap_PDF_setmiterlimit(PyObject *self, PyObject *args) { 1146 PDF * p; 1147 float _arg1; 1148 char * _argc0 = 0; 1149 1150 if(!PyArg_ParseTuple(args,"sf:PDF_setmiterlimit",&_argc0,&_arg1)) 1151 return NULL; 1152 if (_argc0) { 1153 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1154 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setmiterlimit. Expected _PDF_p."); 1155 return NULL; 1156 } 1157 } 1158 1159 try { PDF_setmiterlimit(p,_arg1); 1160 } catch; 1161 Py_INCREF(Py_None); 1162 return Py_None; 1163} 1164 1165static PyObject *_wrap_PDF_setlinewidth(PyObject *self, PyObject *args) { 1166 PDF * p; 1167 float _arg1; 1168 char * _argc0 = 0; 1169 1170 if(!PyArg_ParseTuple(args,"sf:PDF_setlinewidth",&_argc0,&_arg1)) 1171 return NULL; 1172 if (_argc0) { 1173 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1174 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setlinewidth. Expected _PDF_p."); 1175 return NULL; 1176 } 1177 } 1178 1179 try { PDF_setlinewidth(p,_arg1); 1180 } catch; 1181 Py_INCREF(Py_None); 1182 return Py_None; 1183} 1184 1185static PyObject *_wrap_PDF_save(PyObject *self, PyObject *args) { 1186 PDF * p; 1187 char * _argc0 = 0; 1188 1189 if(!PyArg_ParseTuple(args,"s:PDF_save",&_argc0)) 1190 return NULL; 1191 if (_argc0) { 1192 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1193 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_save. Expected _PDF_p."); 1194 return NULL; 1195 } 1196 } 1197 1198 try { PDF_save(p); 1199 } catch; 1200 Py_INCREF(Py_None); 1201 return Py_None; 1202} 1203 1204static PyObject *_wrap_PDF_restore(PyObject *self, PyObject *args) { 1205 PDF * p; 1206 char * _argc0 = 0; 1207 1208 if(!PyArg_ParseTuple(args,"s:PDF_restore",&_argc0)) 1209 return NULL; 1210 if (_argc0) { 1211 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1212 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_restore. Expected _PDF_p."); 1213 return NULL; 1214 } 1215 } 1216 1217 try { PDF_restore(p); 1218 } catch; 1219 Py_INCREF(Py_None); 1220 return Py_None; 1221} 1222 1223static PyObject *_wrap_PDF_translate(PyObject *self, PyObject *args) { 1224 PDF * p; 1225 float _arg1; 1226 float _arg2; 1227 char * _argc0 = 0; 1228 1229 if(!PyArg_ParseTuple(args,"sff:PDF_translate",&_argc0,&_arg1,&_arg2)) 1230 return NULL; 1231 if (_argc0) { 1232 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1233 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_translate. Expected _PDF_p."); 1234 return NULL; 1235 } 1236 } 1237 1238 try { PDF_translate(p,_arg1,_arg2); 1239 } catch; 1240 Py_INCREF(Py_None); 1241 return Py_None; 1242} 1243 1244static PyObject *_wrap_PDF_scale(PyObject *self, PyObject *args) { 1245 PDF * p; 1246 float _arg1; 1247 float _arg2; 1248 char * _argc0 = 0; 1249 1250 if(!PyArg_ParseTuple(args,"sff:PDF_scale",&_argc0,&_arg1,&_arg2)) 1251 return NULL; 1252 if (_argc0) { 1253 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1254 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_scale. Expected _PDF_p."); 1255 return NULL; 1256 } 1257 } 1258 1259 try { PDF_scale(p,_arg1,_arg2); 1260 } catch; 1261 Py_INCREF(Py_None); 1262 return Py_None; 1263} 1264 1265static PyObject *_wrap_PDF_rotate(PyObject *self, PyObject *args) { 1266 PDF * p; 1267 float _arg1; 1268 char * _argc0 = 0; 1269 1270 if(!PyArg_ParseTuple(args,"sf:PDF_rotate",&_argc0,&_arg1)) 1271 return NULL; 1272 if (_argc0) { 1273 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1274 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_rotate. Expected _PDF_p."); 1275 return NULL; 1276 } 1277 } 1278 1279 try { PDF_rotate(p,_arg1); 1280 } catch; 1281 Py_INCREF(Py_None); 1282 return Py_None; 1283} 1284 1285static PyObject *_wrap_PDF_skew(PyObject *self, PyObject *args) { 1286 PDF * p; 1287 float _arg1; 1288 float _arg2; 1289 char * _argc0 = 0; 1290 1291 if(!PyArg_ParseTuple(args,"sff:PDF_skew",&_argc0,&_arg1,&_arg2)) 1292 return NULL; 1293 if (_argc0) { 1294 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1295 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_skew. Expected _PDF_p."); 1296 return NULL; 1297 } 1298 } 1299 1300 try { PDF_skew(p,_arg1,_arg2); 1301 } catch; 1302 Py_INCREF(Py_None); 1303 return Py_None; 1304} 1305 1306static PyObject *_wrap_PDF_concat(PyObject *self, PyObject *args) { 1307 PyObject * _resultobj; 1308 PDF * p; 1309 float _arg1; 1310 float _arg2; 1311 float _arg3; 1312 float _arg4; 1313 float _arg5; 1314 float _arg6; 1315 char * _argc0 = 0; 1316 1317 if(!PyArg_ParseTuple(args,"sffffff:PDF_concat", 1318 &_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6)) 1319 return NULL; 1320 1321 if (_argc0) { 1322 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1323 PyErr_SetString(PyExc_TypeError, 1324 "Type error in argument 1 of PDF_concat. Expected _PDF_p."); 1325 return NULL; 1326 } 1327 } 1328 1329 try { PDF_concat(p,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); 1330 } catch; 1331 1332 Py_INCREF(Py_None); 1333 _resultobj = Py_None; 1334 return _resultobj; 1335} 1336 1337static PyObject *_wrap_PDF_moveto(PyObject *self, PyObject *args) { 1338 PDF * p; 1339 float _arg1; 1340 float _arg2; 1341 char * _argc0 = 0; 1342 1343 if(!PyArg_ParseTuple(args,"sff:PDF_moveto",&_argc0,&_arg1,&_arg2)) 1344 return NULL; 1345 if (_argc0) { 1346 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1347 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_moveto. Expected _PDF_p."); 1348 return NULL; 1349 } 1350 } 1351 1352 try { PDF_moveto(p,_arg1,_arg2); 1353 } catch; 1354 Py_INCREF(Py_None); 1355 return Py_None; 1356} 1357 1358static PyObject *_wrap_PDF_lineto(PyObject *self, PyObject *args) { 1359 PDF * p; 1360 float _arg1; 1361 float _arg2; 1362 char * _argc0 = 0; 1363 1364 if(!PyArg_ParseTuple(args,"sff:PDF_lineto",&_argc0,&_arg1,&_arg2)) 1365 return NULL; 1366 if (_argc0) { 1367 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1368 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_lineto. Expected _PDF_p."); 1369 return NULL; 1370 } 1371 } 1372 1373 try { PDF_lineto(p,_arg1,_arg2); 1374 } catch; 1375 Py_INCREF(Py_None); 1376 return Py_None; 1377} 1378 1379static PyObject *_wrap_PDF_curveto(PyObject *self, PyObject *args) { 1380 PDF * p; 1381 float _arg1; 1382 float _arg2; 1383 float _arg3; 1384 float _arg4; 1385 float _arg5; 1386 float _arg6; 1387 char * _argc0 = 0; 1388 1389 if(!PyArg_ParseTuple(args,"sffffff:PDF_curveto",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6)) 1390 return NULL; 1391 if (_argc0) { 1392 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1393 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_curveto. Expected _PDF_p."); 1394 return NULL; 1395 } 1396 } 1397 1398 try { PDF_curveto(p,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); 1399 } catch; 1400 Py_INCREF(Py_None); 1401 return Py_None; 1402} 1403 1404static PyObject *_wrap_PDF_circle(PyObject *self, PyObject *args) { 1405 PDF * p; 1406 float _arg1; 1407 float _arg2; 1408 float _arg3; 1409 char * _argc0 = 0; 1410 1411 if(!PyArg_ParseTuple(args,"sfff:PDF_circle",&_argc0,&_arg1,&_arg2,&_arg3)) 1412 return NULL; 1413 if (_argc0) { 1414 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1415 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_circle. Expected _PDF_p."); 1416 return NULL; 1417 } 1418 } 1419 1420 try { PDF_circle(p,_arg1,_arg2,_arg3); 1421 } catch; 1422 Py_INCREF(Py_None); 1423 return Py_None; 1424} 1425 1426static PyObject *_wrap_PDF_arc(PyObject *self, PyObject *args) { 1427 PDF * p; 1428 float _arg1; 1429 float _arg2; 1430 float _arg3; 1431 float _arg4; 1432 float _arg5; 1433 char * _argc0 = 0; 1434 1435 if(!PyArg_ParseTuple(args,"sfffff:PDF_arc",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) 1436 return NULL; 1437 if (_argc0) { 1438 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1439 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_arc. Expected _PDF_p."); 1440 return NULL; 1441 } 1442 } 1443 1444 try { PDF_arc(p,_arg1,_arg2,_arg3,_arg4,_arg5); 1445 } catch; 1446 Py_INCREF(Py_None); 1447 return Py_None; 1448} 1449 1450static PyObject *_wrap_PDF_rect(PyObject *self, PyObject *args) { 1451 PDF * p; 1452 float _arg1; 1453 float _arg2; 1454 float _arg3; 1455 float _arg4; 1456 char * _argc0 = 0; 1457 1458 if(!PyArg_ParseTuple(args,"sffff:PDF_rect",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4)) 1459 return NULL; 1460 if (_argc0) { 1461 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1462 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_rect. Expected _PDF_p."); 1463 return NULL; 1464 } 1465 } 1466 1467 try { PDF_rect(p,_arg1,_arg2,_arg3,_arg4); 1468 } catch; 1469 Py_INCREF(Py_None); 1470 return Py_None; 1471} 1472 1473static PyObject *_wrap_PDF_closepath(PyObject *self, PyObject *args) { 1474 PDF * p; 1475 char * _argc0 = 0; 1476 1477 if(!PyArg_ParseTuple(args,"s:PDF_closepath",&_argc0)) 1478 return NULL; 1479 if (_argc0) { 1480 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1481 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_closepath. Expected _PDF_p."); 1482 return NULL; 1483 } 1484 } 1485 1486 try { PDF_closepath(p); 1487 } catch; 1488 Py_INCREF(Py_None); 1489 return Py_None; 1490} 1491 1492static PyObject *_wrap_PDF_stroke(PyObject *self, PyObject *args) { 1493 PDF * p; 1494 char * _argc0 = 0; 1495 1496 if(!PyArg_ParseTuple(args,"s:PDF_stroke",&_argc0)) 1497 return NULL; 1498 if (_argc0) { 1499 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1500 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_stroke. Expected _PDF_p."); 1501 return NULL; 1502 } 1503 } 1504 1505 try { PDF_stroke(p); 1506 } catch; 1507 Py_INCREF(Py_None); 1508 return Py_None; 1509} 1510 1511static PyObject *_wrap_PDF_closepath_stroke(PyObject *self, PyObject *args) { 1512 PDF * p; 1513 char * _argc0 = 0; 1514 1515 if(!PyArg_ParseTuple(args,"s:PDF_closepath_stroke",&_argc0)) 1516 return NULL; 1517 if (_argc0) { 1518 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1519 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_closepath_stroke. Expected _PDF_p."); 1520 return NULL; 1521 } 1522 } 1523 1524 try { PDF_closepath_stroke(p); 1525 } catch; 1526 Py_INCREF(Py_None); 1527 return Py_None; 1528} 1529 1530static PyObject *_wrap_PDF_fill(PyObject *self, PyObject *args) { 1531 PDF * p; 1532 char * _argc0 = 0; 1533 1534 if(!PyArg_ParseTuple(args,"s:PDF_fill",&_argc0)) 1535 return NULL; 1536 if (_argc0) { 1537 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1538 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_fill. Expected _PDF_p."); 1539 return NULL; 1540 } 1541 } 1542 1543 try { PDF_fill(p); 1544 } catch; 1545 Py_INCREF(Py_None); 1546 return Py_None; 1547} 1548 1549static PyObject *_wrap_PDF_fill_stroke(PyObject *self, PyObject *args) { 1550 PDF * p; 1551 char * _argc0 = 0; 1552 1553 if(!PyArg_ParseTuple(args,"s:PDF_fill_stroke",&_argc0)) 1554 return NULL; 1555 if (_argc0) { 1556 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1557 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_fill_stroke. Expected _PDF_p."); 1558 return NULL; 1559 } 1560 } 1561 1562 try { PDF_fill_stroke(p); 1563 } catch; 1564 Py_INCREF(Py_None); 1565 return Py_None; 1566} 1567 1568static PyObject *_wrap_PDF_closepath_fill_stroke(PyObject *self, PyObject *args) { 1569 PDF * p; 1570 char * _argc0 = 0; 1571 1572 if(!PyArg_ParseTuple(args,"s:PDF_closepath_fill_stroke",&_argc0)) 1573 return NULL; 1574 if (_argc0) { 1575 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1576 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_closepath_fill_stroke. Expected _PDF_p."); 1577 return NULL; 1578 } 1579 } 1580 1581 try { PDF_closepath_fill_stroke(p); 1582 } catch; 1583 Py_INCREF(Py_None); 1584 return Py_None; 1585} 1586 1587static PyObject *_wrap_PDF_endpath(PyObject *self, PyObject *args) { 1588 PDF * p; 1589 char * _argc0 = 0; 1590 1591 if(!PyArg_ParseTuple(args,"s:PDF_endpath",&_argc0)) 1592 return NULL; 1593 if (_argc0) { 1594 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1595 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_endpath. Expected _PDF_p."); 1596 return NULL; 1597 } 1598 } 1599 1600 try { PDF_endpath(p); 1601 } catch; 1602 Py_INCREF(Py_None); 1603 return Py_None; 1604} 1605 1606static PyObject *_wrap_PDF_clip(PyObject *self, PyObject *args) { 1607 PDF * p; 1608 char * _argc0 = 0; 1609 1610 if(!PyArg_ParseTuple(args,"s:PDF_clip",&_argc0)) 1611 return NULL; 1612 if (_argc0) { 1613 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1614 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_clip. Expected _PDF_p."); 1615 return NULL; 1616 } 1617 } 1618 1619 try { PDF_clip(p); 1620 } catch; 1621 Py_INCREF(Py_None); 1622 return Py_None; 1623} 1624 1625static PyObject *_wrap_PDF_setgray_fill(PyObject *self, PyObject *args) { 1626 PDF * p; 1627 float _arg1; 1628 char * _argc0 = 0; 1629 1630 if(!PyArg_ParseTuple(args,"sf:PDF_setgray_fill",&_argc0,&_arg1)) 1631 return NULL; 1632 if (_argc0) { 1633 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1634 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setgray_fill. Expected _PDF_p."); 1635 return NULL; 1636 } 1637 } 1638 1639 try { PDF_setcolor(p, "fill", "gray", _arg1, 0, 0, 0); 1640 } catch; 1641 Py_INCREF(Py_None); 1642 return Py_None; 1643} 1644 1645static PyObject *_wrap_PDF_setgray_stroke(PyObject *self, PyObject *args) { 1646 PDF * p; 1647 float _arg1; 1648 char * _argc0 = 0; 1649 1650 if(!PyArg_ParseTuple(args,"sf:PDF_setgray_stroke",&_argc0,&_arg1)) 1651 return NULL; 1652 if (_argc0) { 1653 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1654 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setgray_stroke. Expected _PDF_p."); 1655 return NULL; 1656 } 1657 } 1658 1659 try { PDF_setcolor(p, "stroke", "gray", _arg1, 0, 0, 0); 1660 } catch; 1661 Py_INCREF(Py_None); 1662 return Py_None; 1663} 1664 1665static PyObject *_wrap_PDF_setgray(PyObject *self, PyObject *args) { 1666 PDF * p; 1667 float _arg1; 1668 char * _argc0 = 0; 1669 1670 if(!PyArg_ParseTuple(args,"sf:PDF_setgray",&_argc0,&_arg1)) 1671 return NULL; 1672 if (_argc0) { 1673 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1674 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setgray. Expected _PDF_p."); 1675 return NULL; 1676 } 1677 } 1678 1679 try { PDF_setcolor(p, "fillstroke", "gray", _arg1, 0, 0, 0); 1680 } catch; 1681 Py_INCREF(Py_None); 1682 return Py_None; 1683} 1684 1685static PyObject *_wrap_PDF_setrgbcolor_fill(PyObject *self, PyObject *args) { 1686 PDF * p; 1687 float _arg1; 1688 float _arg2; 1689 float _arg3; 1690 char * _argc0 = 0; 1691 1692 if(!PyArg_ParseTuple(args,"sfff:PDF_setrgbcolor_fill",&_argc0,&_arg1,&_arg2,&_arg3)) 1693 return NULL; 1694 if (_argc0) { 1695 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1696 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setrgbcolor_fill. Expected _PDF_p."); 1697 return NULL; 1698 } 1699 } 1700 1701 try { PDF_setcolor(p, "fill", "rgb", _arg1, _arg2, _arg3, 0); 1702 } catch; 1703 Py_INCREF(Py_None); 1704 return Py_None; 1705} 1706 1707static PyObject *_wrap_PDF_setrgbcolor_stroke(PyObject *self, PyObject *args) { 1708 PDF * p; 1709 float _arg1; 1710 float _arg2; 1711 float _arg3; 1712 char * _argc0 = 0; 1713 1714 if(!PyArg_ParseTuple(args,"sfff:PDF_setrgbcolor_stroke",&_argc0,&_arg1,&_arg2,&_arg3)) 1715 return NULL; 1716 if (_argc0) { 1717 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1718 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setrgbcolor_stroke. Expected _PDF_p."); 1719 return NULL; 1720 } 1721 } 1722 1723 try { PDF_setcolor(p, "stroke", "rgb", _arg1, _arg2, _arg3, 0); 1724 } catch; 1725 Py_INCREF(Py_None); 1726 return Py_None; 1727} 1728 1729static PyObject *_wrap_PDF_setrgbcolor(PyObject *self, PyObject *args) { 1730 PDF * p; 1731 float _arg1; 1732 float _arg2; 1733 float _arg3; 1734 char * _argc0 = 0; 1735 1736 if(!PyArg_ParseTuple(args,"sfff:PDF_setrgbcolor",&_argc0,&_arg1,&_arg2,&_arg3)) 1737 return NULL; 1738 if (_argc0) { 1739 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1740 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setrgbcolor. Expected _PDF_p."); 1741 return NULL; 1742 } 1743 } 1744 1745 try { PDF_setcolor(p, "fillstroke", "rgb", _arg1, _arg2, _arg3, 0); 1746 } catch; 1747 Py_INCREF(Py_None); 1748 return Py_None; 1749} 1750 1751static PyObject *_wrap_PDF_place_image(PyObject *self, PyObject *args) { 1752 PDF * p; 1753 int _arg1; 1754 float _arg2; 1755 float _arg3; 1756 float _arg4; 1757 char * _argc0 = 0; 1758 1759 if(!PyArg_ParseTuple(args,"sifff:PDF_place_image",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4)) 1760 return NULL; 1761 if (_argc0) { 1762 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1763 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_place_image. Expected _PDF_p."); 1764 return NULL; 1765 } 1766 } 1767 1768 try { PDF_place_image(p,_arg1,_arg2,_arg3,_arg4); 1769 } catch; 1770 Py_INCREF(Py_None); 1771 return Py_None; 1772} 1773 1774static PyObject *_wrap_PDF_open_image(PyObject *self, PyObject *args) { 1775 int _result; 1776 PDF * p; 1777 char * _arg1; 1778 char * _arg2; 1779 char * _arg3; 1780 long _arg4; 1781 int _arg5; 1782 int _arg6; 1783 int _arg7; 1784 int _arg8; 1785 char * _arg9; 1786 char * _argc0 = 0; 1787 1788 if(!PyArg_ParseTuple(args,"ssssliiiis:PDF_open_image",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7,&_arg8,&_arg9)) 1789 return NULL; 1790 if (_argc0) { 1791 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1792 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_open_image. Expected _PDF_p."); 1793 return NULL; 1794 } 1795 } 1796 1797 try { _result = (int)PDF_open_image(p,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7,_arg8,_arg9); 1798 } catch; 1799 return Py_BuildValue("i",_result); 1800} 1801 1802static PyObject *_wrap_PDF_close_image(PyObject *self, PyObject *args) { 1803 PDF * p; 1804 int _arg1; 1805 char * _argc0 = 0; 1806 1807 if(!PyArg_ParseTuple(args,"si:PDF_close_image",&_argc0,&_arg1)) 1808 return NULL; 1809 if (_argc0) { 1810 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1811 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_close_image. Expected _PDF_p."); 1812 return NULL; 1813 } 1814 } 1815 1816 try { PDF_close_image(p,_arg1); 1817 } catch; 1818 Py_INCREF(Py_None); 1819 return Py_None; 1820} 1821 1822static PyObject *_wrap_PDF_open_image_file(PyObject *self, PyObject *args) { 1823 int _result; 1824 PDF * p; 1825 char * _arg1; 1826 char * _arg2; 1827 char * _arg3; 1828 int _arg4; 1829 char * _argc0 = 0; 1830 1831 if(!PyArg_ParseTuple(args,"ssssi:PDF_open_image_file",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4)) 1832 return NULL; 1833 if (_argc0) { 1834 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1835 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_open_image_file. Expected _PDF_p."); 1836 return NULL; 1837 } 1838 } 1839 1840 try { _result = (int)PDF_open_image_file(p,_arg1,_arg2,_arg3,_arg4); 1841 } catch; 1842 return Py_BuildValue("i",_result); 1843} 1844 1845static PyObject *_wrap_PDF_open_CCITT(PyObject *self, PyObject *args) { 1846 int _result; 1847 PDF * p; 1848 char * _arg1; 1849 int _arg2; 1850 int _arg3; 1851 int _arg4; 1852 int _arg5; 1853 int _arg6; 1854 char * _argc0 = 0; 1855 1856 if(!PyArg_ParseTuple(args,"ssiiiii:PDF_open_CCITT",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6)) 1857 return NULL; 1858 if (_argc0) { 1859 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1860 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_open_CCITT. Expected _PDF_p."); 1861 return NULL; 1862 } 1863 } 1864 1865 try { _result = (int)PDF_open_CCITT(p,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); 1866 } catch; 1867 return Py_BuildValue("i",_result); 1868} 1869 1870static PyObject *_wrap_PDF_add_bookmark(PyObject *self, PyObject *args) { 1871 int _result; 1872 PDF * p; 1873 char * _arg1; 1874 int len; 1875 int _arg2; 1876 int _arg3; 1877 char * _argc0 = 0; 1878 1879 if(!PyArg_ParseTuple(args,"ssii:PDF_add_bookmark",&_argc0,&_arg1,&_arg2,&_arg3)) 1880 return NULL; 1881 if (_argc0) { 1882 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1883 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_add_bookmark. Expected _PDF_p."); 1884 return NULL; 1885 } 1886 } 1887 1888 try { 1889 len = PyString_Size(PyTuple_GetItem(args, 1)); 1890 _result = (int)PDF_add_bookmark2(p,_arg1,len,_arg2,_arg3); 1891 } catch; 1892 return Py_BuildValue("i",_result); 1893} 1894 1895static PyObject *_wrap_PDF_set_info(PyObject *self, PyObject *args) { 1896 PDF * p; 1897 char * _arg1; 1898 char * _arg2; 1899 int len; 1900 char * _argc0 = 0; 1901 1902 if(!PyArg_ParseTuple(args,"sss:PDF_set_info",&_argc0,&_arg1,&_arg2)) 1903 return NULL; 1904 if (_argc0) { 1905 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1906 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_set_info. Expected _PDF_p."); 1907 return NULL; 1908 } 1909 } 1910 1911 try { 1912 len = PyString_Size(PyTuple_GetItem(args, 2)); 1913 PDF_set_info2(p,_arg1,_arg2,len); 1914 } catch; 1915 Py_INCREF(Py_None); 1916 return Py_None; 1917} 1918 1919static PyObject *_wrap_PDF_attach_file(PyObject *self, PyObject *args) { 1920 PDF * p; 1921 float _arg1; 1922 float _arg2; 1923 float _arg3; 1924 float _arg4; 1925 char * _arg5; 1926 char * _arg6; 1927 int len_descr; 1928 char * _arg7; 1929 int len_auth; 1930 char * _arg8; 1931 char * _arg9; 1932 char * _argc0 = 0; 1933 1934 if(!PyArg_ParseTuple(args,"sffffsssss:PDF_attach_file",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7,&_arg8,&_arg9)) 1935 return NULL; 1936 if (_argc0) { 1937 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1938 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_attach_file. Expected _PDF_p."); 1939 return NULL; 1940 } 1941 } 1942 1943 try { 1944 len_descr = PyString_Size(PyTuple_GetItem(args, 6)); 1945 len_auth = PyString_Size(PyTuple_GetItem(args, 7)); 1946 PDF_attach_file2(p,_arg1,_arg2,_arg3,_arg4,_arg5,0, 1947 _arg6,len_descr,_arg7,len_auth,_arg8,_arg9); 1948 } catch; 1949 Py_INCREF(Py_None); 1950 return Py_None; 1951} 1952 1953static PyObject *_wrap_PDF_add_note(PyObject *self, PyObject *args) { 1954 PDF * p; 1955 float _arg1; 1956 float _arg2; 1957 float _arg3; 1958 float _arg4; 1959 char * _arg5; 1960 char * _arg6; 1961 char * _arg7; 1962 int _arg8; 1963 int len_cont; 1964 int len_title; 1965 char * _argc0 = 0; 1966 1967 if(!PyArg_ParseTuple(args,"sffffsssi:PDF_add_note",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7,&_arg8)) 1968 return NULL; 1969 if (_argc0) { 1970 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 1971 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_add_note. Expected _PDF_p."); 1972 return NULL; 1973 } 1974 } 1975 1976 try { 1977 len_cont = PyString_Size(PyTuple_GetItem(args, 5)); 1978 len_title = PyString_Size(PyTuple_GetItem(args, 6)); 1979 PDF_add_note2(p,_arg1,_arg2,_arg3,_arg4,_arg5,len_cont,_arg6,len_title,_arg7,_arg8); 1980 } catch; 1981 Py_INCREF(Py_None); 1982 return Py_None; 1983} 1984 1985static PyObject *_wrap_PDF_add_pdflink(PyObject *self, PyObject *args) { 1986 PDF * p; 1987 float _arg1; 1988 float _arg2; 1989 float _arg3; 1990 float _arg4; 1991 char * _arg5; 1992 int _arg6; 1993 char * _arg7; 1994 char * _argc0 = 0; 1995 1996 if(!PyArg_ParseTuple(args,"sffffsis:PDF_add_pdflink",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6,&_arg7)) 1997 return NULL; 1998 if (_argc0) { 1999 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2000 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_add_pdflink. Expected _PDF_p."); 2001 return NULL; 2002 } 2003 } 2004 2005 try { PDF_add_pdflink(p,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6,_arg7); 2006 } catch; 2007 Py_INCREF(Py_None); 2008 return Py_None; 2009} 2010 2011static PyObject *_wrap_PDF_add_launchlink(PyObject *self, PyObject *args) { 2012 PDF * p; 2013 float _arg1; 2014 float _arg2; 2015 float _arg3; 2016 float _arg4; 2017 char * _arg5; 2018 char * _argc0 = 0; 2019 2020 if(!PyArg_ParseTuple(args,"sffffs:PDF_add_launchlink",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) 2021 return NULL; 2022 if (_argc0) { 2023 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2024 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_add_launchlink. Expected _PDF_p."); 2025 return NULL; 2026 } 2027 } 2028 2029 try { PDF_add_launchlink(p,_arg1,_arg2,_arg3,_arg4,_arg5); 2030 } catch; 2031 Py_INCREF(Py_None); 2032 return Py_None; 2033} 2034 2035static PyObject *_wrap_PDF_add_locallink(PyObject *self, PyObject *args) { 2036 PDF * p; 2037 float _arg1; 2038 float _arg2; 2039 float _arg3; 2040 float _arg4; 2041 int _arg5; 2042 char * _arg6; 2043 char * _argc0 = 0; 2044 2045 if(!PyArg_ParseTuple(args,"sffffis:PDF_add_locallink",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6)) 2046 return NULL; 2047 if (_argc0) { 2048 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2049 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_add_locallink. Expected _PDF_p."); 2050 return NULL; 2051 } 2052 } 2053 2054 try { PDF_add_locallink(p,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); 2055 } catch; 2056 Py_INCREF(Py_None); 2057 return Py_None; 2058} 2059 2060static PyObject *_wrap_PDF_add_weblink(PyObject *self, PyObject *args) { 2061 PDF * p; 2062 float _arg1; 2063 float _arg2; 2064 float _arg3; 2065 float _arg4; 2066 char * _arg5; 2067 char * _argc0 = 0; 2068 2069 if(!PyArg_ParseTuple(args,"sffffs:PDF_add_weblink",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) 2070 return NULL; 2071 if (_argc0) { 2072 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2073 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_add_weblink. Expected _PDF_p."); 2074 return NULL; 2075 } 2076 } 2077 2078 try { PDF_add_weblink(p,_arg1,_arg2,_arg3,_arg4,_arg5); 2079 } catch; 2080 Py_INCREF(Py_None); 2081 return Py_None; 2082} 2083 2084static PyObject *_wrap_PDF_set_border_style(PyObject *self, PyObject *args) { 2085 PDF * p; 2086 char * _arg1; 2087 float _arg2; 2088 char * _argc0 = 0; 2089 2090 if(!PyArg_ParseTuple(args,"ssf:PDF_set_border_style",&_argc0,&_arg1,&_arg2)) 2091 return NULL; 2092 if (_argc0) { 2093 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2094 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_set_border_style. Expected _PDF_p."); 2095 return NULL; 2096 } 2097 } 2098 2099 try { PDF_set_border_style(p,_arg1,_arg2); 2100 } catch; 2101 Py_INCREF(Py_None); 2102 return Py_None; 2103} 2104 2105static PyObject *_wrap_PDF_set_border_color(PyObject *self, PyObject *args) { 2106 PDF * p; 2107 float _arg1; 2108 float _arg2; 2109 float _arg3; 2110 char * _argc0 = 0; 2111 2112 if(!PyArg_ParseTuple(args,"sfff:PDF_set_border_color",&_argc0,&_arg1,&_arg2,&_arg3)) 2113 return NULL; 2114 if (_argc0) { 2115 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2116 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_set_border_color. Expected _PDF_p."); 2117 return NULL; 2118 } 2119 } 2120 2121 try { PDF_set_border_color(p,_arg1,_arg2,_arg3); 2122 } catch; 2123 Py_INCREF(Py_None); 2124 return Py_None; 2125} 2126 2127static PyObject *_wrap_PDF_set_border_dash(PyObject *self, PyObject *args) { 2128 PDF * p; 2129 float _arg1; 2130 float _arg2; 2131 char * _argc0 = 0; 2132 2133 if(!PyArg_ParseTuple(args,"sff:PDF_set_border_dash",&_argc0,&_arg1,&_arg2)) 2134 return NULL; 2135 if (_argc0) { 2136 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2137 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_set_border_dash. Expected _PDF_p."); 2138 return NULL; 2139 } 2140 } 2141 2142 try { PDF_set_border_dash(p,_arg1,_arg2); 2143 } catch; 2144 Py_INCREF(Py_None); 2145 return Py_None; 2146} 2147 2148static PyObject *_wrap_PDF_open_pdi(PyObject *self, PyObject *args) { 2149 PyObject * _resultobj; 2150 int _result; 2151 PDF * p; 2152 char * _arg1; 2153 char * _arg2; 2154 int _arg3; 2155 char * _argc0 = 0; 2156 2157 if(!PyArg_ParseTuple(args,"sssi:PDF_open_pdi",&_argc0,&_arg1,&_arg2,&_arg3)) 2158 return NULL; 2159 if (_argc0) { 2160 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2161 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_open_pdi. Expected _PDF_p."); 2162 return NULL; 2163 } 2164 } 2165 2166 try { _result = (int)PDF_open_pdi(p,_arg1,_arg2,_arg3); 2167 } catch; 2168 _resultobj = Py_BuildValue("i",_result); 2169 return _resultobj; 2170} 2171 2172static PyObject *_wrap_PDF_close_pdi(PyObject *self, PyObject *args) { 2173 PyObject * _resultobj; 2174 PDF * p; 2175 int _arg1; 2176 char * _argc0 = 0; 2177 2178 if(!PyArg_ParseTuple(args,"si:PDF_close_pdi",&_argc0,&_arg1)) 2179 return NULL; 2180 if (_argc0) { 2181 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2182 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_close_pdi. Expected _PDF_p."); 2183 return NULL; 2184 } 2185 } 2186 2187 try { PDF_close_pdi(p,_arg1); 2188 } catch; 2189 Py_INCREF(Py_None); 2190 _resultobj = Py_None; 2191 return _resultobj; 2192} 2193 2194static PyObject *_wrap_PDF_open_pdi_page(PyObject *self, PyObject *args) { 2195 PyObject * _resultobj; 2196 int _result; 2197 PDF * p; 2198 int _arg1; 2199 int _arg2; 2200 char * _arg3; 2201 char * _argc0 = 0; 2202 2203 if(!PyArg_ParseTuple(args,"siis:PDF_open_pdi_page",&_argc0,&_arg1,&_arg2,&_arg3)) 2204 return NULL; 2205 if (_argc0) { 2206 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2207 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_open_pdi_page. Expected _PDF_p."); 2208 return NULL; 2209 } 2210 } 2211 2212 try { _result = (int)PDF_open_pdi_page(p,_arg1,_arg2,_arg3); 2213 } catch; 2214 _resultobj = Py_BuildValue("i",_result); 2215 return _resultobj; 2216} 2217 2218static PyObject *_wrap_PDF_close_pdi_page(PyObject *self, PyObject *args) { 2219 PyObject * _resultobj; 2220 PDF * p; 2221 int _arg1; 2222 char * _argc0 = 0; 2223 2224 if(!PyArg_ParseTuple(args,"si:PDF_close_pdi_page",&_argc0,&_arg1)) 2225 return NULL; 2226 if (_argc0) { 2227 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2228 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_close_pdi_page. Expected _PDF_p."); 2229 return NULL; 2230 } 2231 } 2232 2233 try { PDF_close_pdi_page(p,_arg1); 2234 } catch; 2235 Py_INCREF(Py_None); 2236 _resultobj = Py_None; 2237 return _resultobj; 2238} 2239 2240static PyObject *_wrap_PDF_place_pdi_page(PyObject *self, PyObject *args) { 2241 PDF * p; 2242 int _arg1; 2243 float _arg2; 2244 float _arg3; 2245 float _arg4; 2246 float _arg5; 2247 char * _argc0 = 0; 2248 2249 if(!PyArg_ParseTuple(args,"siffff:PDF_place_pdi_page",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) 2250 return NULL; 2251 if (_argc0) { 2252 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2253 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_place_image. Expected _PDF_p."); 2254 return NULL; 2255 } 2256 } 2257 2258 try { PDF_place_pdi_page(p,_arg1,_arg2,_arg3,_arg4,_arg5); 2259 } catch; 2260 Py_INCREF(Py_None); 2261 return Py_None; 2262} 2263 2264static PyObject *_wrap_PDF_get_pdi_parameter(PyObject *self, PyObject *args) { 2265 char * _result; 2266 PDF * p; 2267 char * _arg1; 2268 int _arg2; 2269 int _arg3; 2270 int _arg4; 2271 int size; 2272 char * _argc0 = 0; 2273 2274 if(!PyArg_ParseTuple(args,"ssiii:PDF_get_pdi_parameter",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4)) 2275 return NULL; 2276 if (_argc0) { 2277 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2278 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_get_pdi_parameter. Expected _PDF_p."); 2279 return NULL; 2280 } 2281 } 2282 2283 try { _result = (char *)PDF_get_pdi_parameter(p,_arg1,_arg2,_arg3,_arg4, &size); 2284 } catch; 2285 return Py_BuildValue("s#", _result, (int) size); 2286} 2287 2288static PyObject *_wrap_PDF_get_pdi_value(PyObject *self, PyObject *args) { 2289 PyObject * _resultobj; 2290 float _result; 2291 PDF * p; 2292 char * _arg1; 2293 int _arg2; 2294 int _arg3; 2295 int _arg4; 2296 char * _argc0 = 0; 2297 2298 if(!PyArg_ParseTuple(args,"ssiii:PDF_get_pdi_value",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4)) 2299 return NULL; 2300 if (_argc0) { 2301 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2302 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_get_pdi_value. Expected _PDF_p."); 2303 return NULL; 2304 } 2305 } 2306 2307 try { _result = (float)PDF_get_pdi_value(p,_arg1,_arg2,_arg3,_arg4); 2308 } catch; 2309 _resultobj = Py_BuildValue("f",_result); 2310 return _resultobj; 2311} 2312 2313static PyObject *_wrap_PDF_makespotcolor(PyObject *self, PyObject *args) { 2314 PyObject * _resultobj; 2315 int _result; 2316 PDF * p; 2317 char * _arg1; 2318 int _arg2; 2319 char * _argc0 = 0; 2320 2321 if(!PyArg_ParseTuple(args,"ssi:PDF_makespotcolor",&_argc0,&_arg1,&_arg2)) 2322 return NULL; 2323 if (_argc0) { 2324 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2325 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_makespotcolor. Expected _PDF_p."); 2326 return NULL; 2327 } 2328 } 2329 2330 try { _result = (int)PDF_makespotcolor(p,_arg1,_arg2); 2331 } catch; 2332 _resultobj = Py_BuildValue("i",_result); 2333 return _resultobj; 2334} 2335 2336static PyObject *_wrap_PDF_setcolor(PyObject *self, PyObject *args) { 2337 PyObject * _resultobj; 2338 PDF * p; 2339 char * _arg1; 2340 char * _arg2; 2341 float _arg3; 2342 float _arg4; 2343 float _arg5; 2344 float _arg6; 2345 char * _argc0 = 0; 2346 2347 if(!PyArg_ParseTuple(args,"sssffff:PDF_setcolor",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6)) 2348 return NULL; 2349 if (_argc0) { 2350 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2351 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setcolor. Expected _PDF_p."); 2352 return NULL; 2353 } 2354 } 2355 2356 try { PDF_setcolor(p,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); 2357 } catch; 2358 Py_INCREF(Py_None); 2359 _resultobj = Py_None; 2360 return _resultobj; 2361} 2362 2363static PyObject *_wrap_PDF_begin_pattern(PyObject *self, PyObject *args) { 2364 PyObject * _resultobj; 2365 int _result; 2366 PDF * p; 2367 float _arg1; 2368 float _arg2; 2369 float _arg3; 2370 float _arg4; 2371 int _arg5; 2372 char * _argc0 = 0; 2373 2374 if(!PyArg_ParseTuple(args,"sffffi:PDF_begin_pattern",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) 2375 return NULL; 2376 if (_argc0) { 2377 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2378 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_begin_pattern. Expected _PDF_p."); 2379 return NULL; 2380 } 2381 } 2382 2383 try { _result = (int)PDF_begin_pattern(p,_arg1,_arg2,_arg3,_arg4,_arg5); 2384 } catch; 2385 _resultobj = Py_BuildValue("i",_result); 2386 return _resultobj; 2387} 2388 2389static PyObject *_wrap_PDF_end_pattern(PyObject *self, PyObject *args) { 2390 PyObject * _resultobj; 2391 PDF * p; 2392 char * _argc0 = 0; 2393 2394 if(!PyArg_ParseTuple(args,"s:PDF_end_pattern",&_argc0)) 2395 return NULL; 2396 if (_argc0) { 2397 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2398 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_end_pattern. Expected _PDF_p."); 2399 return NULL; 2400 } 2401 } 2402 2403 try { PDF_end_pattern(p); 2404 } catch; 2405 Py_INCREF(Py_None); 2406 _resultobj = Py_None; 2407 return _resultobj; 2408} 2409 2410static PyObject *_wrap_PDF_begin_template(PyObject *self, PyObject *args) { 2411 PyObject * _resultobj; 2412 int _result; 2413 PDF * p; 2414 float _arg1; 2415 float _arg2; 2416 char * _argc0 = 0; 2417 2418 if(!PyArg_ParseTuple(args,"sff:PDF_begin_template",&_argc0,&_arg1,&_arg2)) 2419 return NULL; 2420 if (_argc0) { 2421 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2422 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_begin_template. Expected _PDF_p."); 2423 return NULL; 2424 } 2425 } 2426 2427 try { _result = (int)PDF_begin_template(p,_arg1,_arg2); 2428 } catch; 2429 _resultobj = Py_BuildValue("i",_result); 2430 return _resultobj; 2431} 2432 2433static PyObject *_wrap_PDF_end_template(PyObject *self, PyObject *args) { 2434 PyObject * _resultobj; 2435 PDF * p; 2436 char * _argc0 = 0; 2437 2438 if(!PyArg_ParseTuple(args,"s:PDF_end_template",&_argc0)) 2439 return NULL; 2440 if (_argc0) { 2441 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2442 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_end_template. Expected _PDF_p."); 2443 return NULL; 2444 } 2445 } 2446 2447 try { PDF_end_template(p); 2448 } catch; 2449 Py_INCREF(Py_None); 2450 _resultobj = Py_None; 2451 return _resultobj; 2452} 2453 2454static PyObject *_wrap_PDF_arcn(PyObject *self, PyObject *args) { 2455 PyObject * _resultobj; 2456 PDF * p; 2457 float _arg1; 2458 float _arg2; 2459 float _arg3; 2460 float _arg4; 2461 float _arg5; 2462 char * _argc0 = 0; 2463 2464 if(!PyArg_ParseTuple(args,"sfffff:PDF_arcn",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5)) 2465 return NULL; 2466 if (_argc0) { 2467 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2468 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_arcn. Expected _PDF_p."); 2469 return NULL; 2470 } 2471 } 2472 2473 try { PDF_arcn(p,_arg1,_arg2,_arg3,_arg4,_arg5); 2474 } catch; 2475 Py_INCREF(Py_None); 2476 _resultobj = Py_None; 2477 return _resultobj; 2478} 2479 2480static PyObject *_wrap_PDF_add_thumbnail(PyObject *self, PyObject *args) { 2481 PyObject * _resultobj; 2482 PDF * p; 2483 int _arg1; 2484 char * _argc0 = 0; 2485 2486 if(!PyArg_ParseTuple(args,"si:PDF_add_thumbnail",&_argc0,&_arg1)) 2487 return NULL; 2488 if (_argc0) { 2489 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2490 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_add_thumbnail. Expected _PDF_p."); 2491 return NULL; 2492 } 2493 } 2494 2495 try { PDF_add_thumbnail(p,_arg1); 2496 } catch; 2497 Py_INCREF(Py_None); 2498 _resultobj = Py_None; 2499 return _resultobj; 2500} 2501 2502static PyObject *_wrap_PDF_setmatrix(PyObject *self, PyObject *args) { 2503 PyObject * _resultobj; 2504 PDF * p; 2505 float _arg1; 2506 float _arg2; 2507 float _arg3; 2508 float _arg4; 2509 float _arg5; 2510 float _arg6; 2511 char * _argc0 = 0; 2512 2513 if(!PyArg_ParseTuple(args,"sffffff:PDF_setmatrix",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4,&_arg5,&_arg6)) 2514 return NULL; 2515 if (_argc0) { 2516 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2517 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setmatrix. Expected _PDF_p."); 2518 return NULL; 2519 } 2520 } 2521 2522 try { PDF_setmatrix(p,_arg1,_arg2,_arg3,_arg4,_arg5,_arg6); 2523 } catch; 2524 Py_INCREF(Py_None); 2525 _resultobj = Py_None; 2526 return _resultobj; 2527} 2528 2529static PyObject *_wrap_PDF_initgraphics(PyObject *self, PyObject *args) { 2530 PyObject * _resultobj; 2531 PDF * p; 2532 char * _argc0 = 0; 2533 2534 if(!PyArg_ParseTuple(args,"s:PDF_initgraphics",&_argc0)) 2535 return NULL; 2536 if (_argc0) { 2537 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2538 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_initgraphics. Expected _PDF_p."); 2539 return NULL; 2540 } 2541 } 2542 2543 try { PDF_initgraphics(p); 2544 } catch; 2545 Py_INCREF(Py_None); 2546 _resultobj = Py_None; 2547 return _resultobj; 2548} 2549 2550static PyObject *_wrap_PDF_begin_font(PyObject *self, PyObject *args) { 2551 PDF *p; 2552 char *_argc0 = 0; 2553 char *name; 2554 float a, b, c, d, e, f; 2555 char *optlist; 2556 2557 if(!PyArg_ParseTuple(args,"ssffffffs:PDF_begin_font",&_argc0,&name,&a,&b,&c,&d,&e,&f,&optlist)) 2558 return NULL; 2559 if (_argc0) { 2560 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2561 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_begin_font. Expected _PDF_p."); 2562 return NULL; 2563 } 2564 } 2565 2566 try { PDF_begin_font(p, name, 0, a, b, c, d, e, f, optlist); 2567 } catch; 2568 Py_INCREF(Py_None); 2569 return Py_None; 2570} 2571 2572static PyObject *_wrap_PDF_end_font(PyObject *self, PyObject *args) { 2573 PDF *p; 2574 char *_argc0 = 0; 2575 2576 if(!PyArg_ParseTuple(args,"s:PDF_end_font",&_argc0)) 2577 return NULL; 2578 if (_argc0) { 2579 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2580 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_end_font. Expected _PDF_p."); 2581 return NULL; 2582 } 2583 } 2584 2585 try { PDF_end_font(p); 2586 } catch; 2587 Py_INCREF(Py_None); 2588 return Py_None; 2589} 2590 2591static PyObject *_wrap_PDF_begin_glyph(PyObject *self, PyObject *args) { 2592 PDF *p; 2593 char *_argc0 = 0; 2594 char *name; 2595 float wx; 2596 float llx; 2597 float lly; 2598 float urx; 2599 float ury; 2600 2601 if(!PyArg_ParseTuple(args,"ssfffff:PDF_begin_glyph",&_argc0,&name,&wx,&llx,&lly,&urx,&ury)) 2602 return NULL; 2603 if (_argc0) { 2604 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2605 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_begin_glyph. Expected _PDF_p."); 2606 return NULL; 2607 } 2608 } 2609 2610 try { PDF_begin_glyph(p, name, wx, llx, lly, urx, ury); 2611 } catch; 2612 Py_INCREF(Py_None); 2613 return Py_None; 2614} 2615 2616static PyObject *_wrap_PDF_end_glyph(PyObject *self, PyObject *args) { 2617 PDF *p; 2618 char *_argc0 = 0; 2619 2620 if(!PyArg_ParseTuple(args,"s:PDF_end_glyph",&_argc0)) 2621 return NULL; 2622 if (_argc0) { 2623 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2624 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_end_glyph. Expected _PDF_p."); 2625 return NULL; 2626 } 2627 } 2628 2629 try { PDF_end_glyph(p); 2630 } catch; 2631 Py_INCREF(Py_None); 2632 return Py_None; 2633} 2634 2635static PyObject *_wrap_PDF_encoding_set_char(PyObject *self, PyObject *args) { 2636 PDF *p; 2637 char *_argc0 = 0; 2638 char *encoding; 2639 int slot; 2640 char *glyphname; 2641 int uv; 2642 2643 if(!PyArg_ParseTuple(args,"ssisi:PDF_encoding_set_char",&_argc0,&encoding,&slot,&glyphname,&uv)) 2644 return NULL; 2645 if (_argc0) { 2646 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2647 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_encoding_set_char. Expected _PDF_p."); 2648 return NULL; 2649 } 2650 } 2651 2652 try { PDF_encoding_set_char(p, encoding, slot, glyphname, uv); 2653 } catch; 2654 Py_INCREF(Py_None); 2655 return Py_None; 2656} 2657 2658static PyObject *_wrap_PDF_set_gstate(PyObject *self, PyObject *args) { 2659 PDF *p; 2660 char *_argc0 = 0; 2661 int handle; 2662 2663 if(!PyArg_ParseTuple(args,"si:PDF_set_gstate",&_argc0,&handle)) 2664 return NULL; 2665 if (_argc0) { 2666 if (SWIG_GetPtr(_argc0,(void **) &p,"_PDF_p")) { 2667 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_set_gstate. Expected _PDF_p."); 2668 return NULL; 2669 } 2670 } 2671 2672 try { PDF_set_gstate(p, handle); 2673 } catch; 2674 Py_INCREF(Py_None); 2675 return Py_None; 2676} 2677 2678static PyObject *_wrap_PDF_fill_imageblock(PyObject *self, PyObject *args) { 2679 int _result; 2680 PDF *p; 2681 char *py_p = 0; 2682 int page; 2683 char *blockname; 2684 int image; 2685 char *optlist; 2686 2687 if(!PyArg_ParseTuple(args,"sisis:PDF_fill_imageblock",&py_p,&page,&blockname,&image,&optlist)) 2688 return NULL; 2689 if (py_p) { 2690 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2691 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_fill_imageblock. Expected _PDF_p."); 2692 return NULL; 2693 } 2694 } 2695 2696 try { 2697 _result = PDF_fill_imageblock(p, page, blockname, image, optlist); 2698 } catch; 2699 return Py_BuildValue("i",_result); 2700} 2701 2702static PyObject *_wrap_PDF_fill_pdfblock(PyObject *self, PyObject *args) { 2703 int _result; 2704 PDF *p; 2705 char *py_p = 0; 2706 int page; 2707 char *blockname; 2708 int contents; 2709 char *optlist; 2710 2711 if(!PyArg_ParseTuple(args,"sisis:PDF_fill_pdfblock",&py_p,&page,&blockname,&contents,&optlist)) 2712 return NULL; 2713 if (py_p) { 2714 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2715 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_fill_pdfblock. Expected _PDF_p."); 2716 return NULL; 2717 } 2718 } 2719 2720 try { 2721 _result = PDF_fill_pdfblock(p, page, blockname, contents, optlist); 2722 } catch; 2723 return Py_BuildValue("i",_result); 2724} 2725 2726static PyObject *_wrap_PDF_fill_textblock(PyObject *self, PyObject *args) { 2727 int _result; 2728 PDF *p; 2729 char *py_p = 0; 2730 int page; 2731 char *blockname; 2732 char *text; 2733 int len; 2734 char *optlist; 2735 2736 if(!PyArg_ParseTuple(args,"sisss:PDF_fill_textblock",&py_p,&page,&blockname,&text,&optlist)) 2737 return NULL; 2738 if (py_p) { 2739 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2740 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_fill_textblock. Expected _PDF_p."); 2741 return NULL; 2742 } 2743 } 2744 2745 try { 2746 len = PyString_Size(PyTuple_GetItem(args, 3)); 2747 _result = PDF_fill_textblock(p, page, blockname, text, len, optlist); 2748 } catch; 2749 return Py_BuildValue("i",_result); 2750} 2751 2752static PyObject *_wrap_PDF_load_font(PyObject *self, PyObject *args) { 2753 int _result; 2754 PDF *p; 2755 char *py_p = 0; 2756 char *fontname; 2757 char *encoding; 2758 char *optlist; 2759 2760 if(!PyArg_ParseTuple(args,"ssss:PDF_load_font",&py_p,&fontname,&encoding,&optlist)) 2761 return NULL; 2762 if (py_p) { 2763 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2764 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_load_font. Expected _PDF_p."); 2765 return NULL; 2766 } 2767 } 2768 2769 try { 2770 _result = PDF_load_font(p, fontname, 0, encoding, optlist); 2771 } catch; 2772 return Py_BuildValue("i",_result); 2773} 2774 2775static PyObject *_wrap_PDF_setdashpattern(PyObject *self, PyObject *args) { 2776 PDF *p; 2777 char *py_p = 0; 2778 char *optlist; 2779 2780 if(!PyArg_ParseTuple(args,"ss:PDF_setdashpattern",&py_p,&optlist)) 2781 return NULL; 2782 if (py_p) { 2783 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2784 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_setdashpattern. Expected _PDF_p."); 2785 return NULL; 2786 } 2787 } 2788 2789 try { 2790 PDF_setdashpattern(p, optlist); 2791 } catch; 2792 Py_INCREF(Py_None); 2793 return Py_None; 2794} 2795 2796static PyObject *_wrap_PDF_add_nameddest(PyObject *self, PyObject *args) { 2797 PDF *p; 2798 char *py_p = 0; 2799 char *name; 2800 char *optlist; 2801 2802 if(!PyArg_ParseTuple(args,"sss:PDF_add_nameddest",&py_p,&name,&optlist)) 2803 return NULL; 2804 if (py_p) { 2805 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2806 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_add_nameddest. Expected _PDF_p."); 2807 return NULL; 2808 } 2809 } 2810 2811 try { 2812 PDF_add_nameddest(p, name, 0, optlist); 2813 } catch; 2814 Py_INCREF(Py_None); 2815 return Py_None; 2816} 2817 2818static PyObject *_wrap_PDF_load_iccprofile(PyObject *self, PyObject *args) { 2819 int _result; 2820 PDF *p; 2821 char *py_p = 0; 2822 char *profilename; 2823 char *optlist; 2824 2825 if(!PyArg_ParseTuple(args,"sss:PDF_load_iccprofile",&py_p,&profilename,&optlist)) 2826 return NULL; 2827 if (py_p) { 2828 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2829 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_load_iccprofile. Expected _PDF_p."); 2830 return NULL; 2831 } 2832 } 2833 2834 try { 2835 _result = PDF_load_iccprofile(p, profilename, 0, optlist); 2836 } catch; 2837 return Py_BuildValue("i",_result); 2838} 2839 2840static PyObject *_wrap_PDF_fit_image(PyObject *self, PyObject *args) { 2841 PDF *p; 2842 char *py_p = 0; 2843 int image; 2844 float x; 2845 float y; 2846 char *optlist; 2847 2848 if(!PyArg_ParseTuple(args,"siffs:PDF_fit_image",&py_p,&image,&x,&y,&optlist)) 2849 return NULL; 2850 if (py_p) { 2851 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2852 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_fit_image. Expected _PDF_p."); 2853 return NULL; 2854 } 2855 } 2856 2857 try { 2858 PDF_fit_image(p, image, x, y, optlist); 2859 } catch; 2860 Py_INCREF(Py_None); 2861 return Py_None; 2862} 2863 2864static PyObject *_wrap_PDF_load_image(PyObject *self, PyObject *args) { 2865 int _result; 2866 PDF *p; 2867 char *py_p = 0; 2868 char *imagetype; 2869 char *filename; 2870 char *optlist; 2871 2872 if(!PyArg_ParseTuple(args,"ssss:PDF_load_image",&py_p,&imagetype,&filename,&optlist)) 2873 return NULL; 2874 if (py_p) { 2875 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2876 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_load_image. Expected _PDF_p."); 2877 return NULL; 2878 } 2879 } 2880 2881 try { 2882 _result = PDF_load_image(p, imagetype, filename, 0, optlist); 2883 } catch; 2884 return Py_BuildValue("i",_result); 2885} 2886 2887static PyObject *_wrap_PDF_fit_pdi_page(PyObject *self, PyObject *args) { 2888 PDF *p; 2889 char *py_p = 0; 2890 int page; 2891 float x; 2892 float y; 2893 char *optlist; 2894 2895 if(!PyArg_ParseTuple(args,"siffs:PDF_fit_pdi_page",&py_p,&page,&x,&y,&optlist)) 2896 return NULL; 2897 if (py_p) { 2898 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2899 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_fit_pdi_page. Expected _PDF_p."); 2900 return NULL; 2901 } 2902 } 2903 2904 try { 2905 PDF_fit_pdi_page(p, page, x, y, optlist); 2906 } catch; 2907 Py_INCREF(Py_None); 2908 return Py_None; 2909} 2910 2911static PyObject *_wrap_PDF_process_pdi(PyObject *self, PyObject *args) { 2912 int _result; 2913 PDF *p; 2914 char *py_p = 0; 2915 int doc; 2916 int page; 2917 char *optlist; 2918 2919 if(!PyArg_ParseTuple(args,"siis:PDF_process_pdi",&py_p,&doc,&page,&optlist)) 2920 return NULL; 2921 if (py_p) { 2922 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2923 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_process_pdi. Expected _PDF_p."); 2924 return NULL; 2925 } 2926 } 2927 2928 try { 2929 _result = PDF_process_pdi(p, doc, page, optlist); 2930 } catch; 2931 return Py_BuildValue("i",_result); 2932} 2933 2934static PyObject *_wrap_PDF_create_pvf(PyObject *self, PyObject *args) { 2935 PDF *p; 2936 char *py_p = 0; 2937 char *filename; 2938 void *data; 2939 char *optlist; 2940 int size; 2941 2942 if(!PyArg_ParseTuple(args,"sss#s:PDF_create_pvf", &py_p,&filename,&data,&size, &optlist)) 2943 return NULL; 2944 if (py_p) { 2945 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2946 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_create_pvf. Expected _PDF_p."); 2947 return NULL; 2948 } 2949 } 2950 2951 try { 2952 PDF_create_pvf(p, filename, 0, data, size, optlist); 2953 } catch; 2954 Py_INCREF(Py_None); 2955 return Py_None; 2956} 2957 2958static PyObject *_wrap_PDF_delete_pvf(PyObject *self, PyObject *args) { 2959 int _result; 2960 PDF *p; 2961 char *py_p = 0; 2962 char *filename; 2963 2964 if(!PyArg_ParseTuple(args,"ss:PDF_delete_pvf",&py_p,&filename)) 2965 return NULL; 2966 if (py_p) { 2967 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2968 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_delete_pvf. Expected _PDF_p."); 2969 return NULL; 2970 } 2971 } 2972 2973 try { 2974 _result = PDF_delete_pvf(p, filename, 0); 2975 } catch; 2976 return Py_BuildValue("i",_result); 2977} 2978 2979static PyObject *_wrap_PDF_shading(PyObject *self, PyObject *args) { 2980 int _result; 2981 PDF *p; 2982 char *py_p = 0; 2983 char *shtype; 2984 float x0; 2985 float yy0; 2986 float x1; 2987 float yy1; 2988 float c1; 2989 float c2; 2990 float c3; 2991 float c4; 2992 char *optlist; 2993 2994 if(!PyArg_ParseTuple(args,"ssffffffffs:PDF_shading",&py_p,&shtype,&x0,&yy0,&x1,&yy1,&c1,&c2,&c3,&c4,&optlist)) 2995 return NULL; 2996 if (py_p) { 2997 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 2998 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_shading. Expected _PDF_p."); 2999 return NULL; 3000 } 3001 } 3002 3003 try { 3004 _result = PDF_shading(p, shtype, x0, yy0, x1, yy1, c1, c2, c3, c4, optlist); 3005 } catch; 3006 return Py_BuildValue("i",_result); 3007} 3008static PyObject *_wrap_PDF_shading_pattern(PyObject *self, PyObject *args) { 3009 int _result; 3010 PDF *p; 3011 char *py_p = 0; 3012 int shading; 3013 char *optlist; 3014 3015 if(!PyArg_ParseTuple(args,"sis:PDF_shading_pattern",&py_p,&shading,&optlist)) 3016 return NULL; 3017 if (py_p) { 3018 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 3019 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_shading_pattern. Expected _PDF_p."); 3020 return NULL; 3021 } 3022 } 3023 3024 try { 3025 _result = PDF_shading_pattern(p, shading, optlist); 3026 } catch; 3027 return Py_BuildValue("i",_result); 3028} 3029 3030static PyObject *_wrap_PDF_shfill(PyObject *self, PyObject *args) { 3031 PDF *p; 3032 char *py_p = 0; 3033 int shading; 3034 3035 if(!PyArg_ParseTuple(args,"si:PDF_shfill",&py_p,&shading)) 3036 return NULL; 3037 if (py_p) { 3038 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 3039 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_shfill. Expected _PDF_p."); 3040 return NULL; 3041 } 3042 } 3043 3044 try { 3045 PDF_shfill(p, shading); 3046 } catch; 3047 Py_INCREF(Py_None); 3048 return Py_None; 3049} 3050 3051static PyObject *_wrap_PDF_fit_textline(PyObject *self, PyObject *args) { 3052 PDF *p; 3053 char *py_p = 0; 3054 char *text; 3055 int len; 3056 float x; 3057 float y; 3058 char *optlist; 3059 3060 if(!PyArg_ParseTuple(args,"ssffs:PDF_fit_textline",&py_p,&text,&x,&y,&optlist)) 3061 return NULL; 3062 if (py_p) { 3063 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 3064 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_fit_textline. Expected _PDF_p."); 3065 return NULL; 3066 } 3067 } 3068 3069 try { 3070 len = PyString_Size(PyTuple_GetItem(args, 1)); 3071 PDF_fit_textline(p, text, len, x, y, optlist); 3072 } catch; 3073 Py_INCREF(Py_None); 3074 return Py_None; 3075} 3076 3077static PyObject *_wrap_PDF_create_gstate(PyObject *self, PyObject *args) { 3078 int _result; 3079 PDF *p; 3080 char *py_p = 0; 3081 char *optlist; 3082 3083 if(!PyArg_ParseTuple(args,"ss:PDF_create_gstate",&py_p,&optlist)) 3084 return NULL; 3085 if (py_p) { 3086 if (SWIG_GetPtr(py_p,(void **) &p,"_PDF_p")) { 3087 PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of PDF_create_gstate. Expected _PDF_p."); 3088 return NULL; 3089 } 3090 } 3091 3092 try { 3093 _result = PDF_create_gstate(p, optlist); 3094 } catch; 3095 return Py_BuildValue("i",_result); 3096} 3097 3098 3099static PyMethodDef pdflibMethods[] = { 3100 { "PDF_set_border_dash", _wrap_PDF_set_border_dash, 1 }, 3101 { "PDF_set_border_color", _wrap_PDF_set_border_color, 1 }, 3102 { "PDF_set_border_style", _wrap_PDF_set_border_style, 1 }, 3103 { "PDF_add_weblink", _wrap_PDF_add_weblink, 1 }, 3104 { "PDF_add_locallink", _wrap_PDF_add_locallink, 1 }, 3105 { "PDF_add_launchlink", _wrap_PDF_add_launchlink, 1 }, 3106 { "PDF_add_pdflink", _wrap_PDF_add_pdflink, 1 }, 3107 { "PDF_add_note", _wrap_PDF_add_note, 1 }, 3108 { "PDF_attach_file", _wrap_PDF_attach_file, 1 }, 3109 { "PDF_set_info", _wrap_PDF_set_info, 1 }, 3110 { "PDF_add_bookmark", _wrap_PDF_add_bookmark, 1 }, 3111 { "PDF_open_CCITT", _wrap_PDF_open_CCITT, 1 }, 3112 { "PDF_close_image", _wrap_PDF_close_image, 1 }, 3113 { "PDF_open_image", _wrap_PDF_open_image, 1 }, 3114 { "PDF_open_image_file", _wrap_PDF_open_image_file, 1 }, 3115 { "PDF_place_image", _wrap_PDF_place_image, 1 }, 3116 { "PDF_setrgbcolor", _wrap_PDF_setrgbcolor, 1 }, 3117 { "PDF_setrgbcolor_stroke", _wrap_PDF_setrgbcolor_stroke, 1 }, 3118 { "PDF_setrgbcolor_fill", _wrap_PDF_setrgbcolor_fill, 1 }, 3119 { "PDF_setgray", _wrap_PDF_setgray, 1 }, 3120 { "PDF_setgray_stroke", _wrap_PDF_setgray_stroke, 1 }, 3121 { "PDF_setgray_fill", _wrap_PDF_setgray_fill, 1 }, 3122 { "PDF_clip", _wrap_PDF_clip, 1 }, 3123 { "PDF_endpath", _wrap_PDF_endpath, 1 }, 3124 { "PDF_closepath_fill_stroke", _wrap_PDF_closepath_fill_stroke, 1 }, 3125 { "PDF_fill_stroke", _wrap_PDF_fill_stroke, 1 }, 3126 { "PDF_fill", _wrap_PDF_fill, 1 }, 3127 { "PDF_closepath_stroke", _wrap_PDF_closepath_stroke, 1 }, 3128 { "PDF_stroke", _wrap_PDF_stroke, 1 }, 3129 { "PDF_closepath", _wrap_PDF_closepath, 1 }, 3130 { "PDF_rect", _wrap_PDF_rect, 1 }, 3131 { "PDF_arc", _wrap_PDF_arc, 1 }, 3132 { "PDF_circle", _wrap_PDF_circle, 1 }, 3133 { "PDF_curveto", _wrap_PDF_curveto, 1 }, 3134 { "PDF_lineto", _wrap_PDF_lineto, 1 }, 3135 { "PDF_moveto", _wrap_PDF_moveto, 1 }, 3136 { "PDF_skew", _wrap_PDF_skew, 1 }, 3137 { "PDF_concat", _wrap_PDF_concat, 1 }, 3138 { "PDF_rotate", _wrap_PDF_rotate, 1 }, 3139 { "PDF_scale", _wrap_PDF_scale, 1 }, 3140 { "PDF_translate", _wrap_PDF_translate, 1 }, 3141 { "PDF_restore", _wrap_PDF_restore, 1 }, 3142 { "PDF_save", _wrap_PDF_save, 1 }, 3143 { "PDF_setlinewidth", _wrap_PDF_setlinewidth, 1 }, 3144 { "PDF_setmiterlimit", _wrap_PDF_setmiterlimit, 1 }, 3145 { "PDF_setlinecap", _wrap_PDF_setlinecap, 1 }, 3146 { "PDF_setlinejoin", _wrap_PDF_setlinejoin, 1 }, 3147 { "PDF_setflat", _wrap_PDF_setflat, 1 }, 3148 { "PDF_setpolydash", _wrap_PDF_setpolydash, 1 }, 3149 { "PDF_setdash", _wrap_PDF_setdash, 1 }, 3150 { "PDF_stringwidth", _wrap_PDF_stringwidth, 1 }, 3151 { "PDF_set_text_pos", _wrap_PDF_set_text_pos, 1 }, 3152 { "PDF_continue_text", _wrap_PDF_continue_text, 1 }, 3153 { "PDF_show_boxed", _wrap_PDF_show_boxed, 1 }, 3154 { "PDF_show_xy", _wrap_PDF_show_xy, 1 }, 3155 { "PDF_show", _wrap_PDF_show, 1 }, 3156 { "PDF_setfont", _wrap_PDF_setfont, 1 }, 3157 { "PDF_findfont", _wrap_PDF_findfont, 1 }, 3158 { "PDF_set_parameter", _wrap_PDF_set_parameter, 1 }, 3159 { "PDF_get_parameter", _wrap_PDF_get_parameter, 1 }, 3160 { "PDF_get_value", _wrap_PDF_get_value, 1 }, 3161 { "PDF_set_value", _wrap_PDF_set_value, 1 }, 3162 { "PDF_end_page", _wrap_PDF_end_page, 1 }, 3163 { "PDF_begin_page", _wrap_PDF_begin_page, 1 }, 3164 { "PDF_get_buffer", _wrap_PDF_get_buffer, 1 }, 3165 { "PDF_close", _wrap_PDF_close, 1 }, 3166 { "PDF_open_file", _wrap_PDF_open_file, 1 }, 3167 { "PDF_delete", _wrap_PDF_delete, 1 }, 3168 { "PDF_new", _wrap_PDF_new, 1 }, 3169 { "PDF_initgraphics", _wrap_PDF_initgraphics, 1 }, 3170 { "PDF_setmatrix", _wrap_PDF_setmatrix, 1 }, 3171 { "PDF_add_thumbnail", _wrap_PDF_add_thumbnail, 1 }, 3172 { "PDF_arcn", _wrap_PDF_arcn, 1 }, 3173 { "PDF_end_template", _wrap_PDF_end_template, 1 }, 3174 { "PDF_begin_template", _wrap_PDF_begin_template, 1 }, 3175 { "PDF_end_pattern", _wrap_PDF_end_pattern, 1 }, 3176 { "PDF_begin_pattern", _wrap_PDF_begin_pattern, 1 }, 3177 { "PDF_setcolor", _wrap_PDF_setcolor, 1 }, 3178 { "PDF_makespotcolor", _wrap_PDF_makespotcolor, 1 }, 3179 { "PDF_get_pdi_value", _wrap_PDF_get_pdi_value, 1 }, 3180 { "PDF_get_pdi_parameter", _wrap_PDF_get_pdi_parameter, 1 }, 3181 { "PDF_close_pdi_page", _wrap_PDF_close_pdi_page, 1 }, 3182 { "PDF_place_pdi_page", _wrap_PDF_place_pdi_page, 1 }, 3183 { "PDF_open_pdi_page", _wrap_PDF_open_pdi_page, 1 }, 3184 { "PDF_close_pdi", _wrap_PDF_close_pdi, 1 }, 3185 { "PDF_open_pdi", _wrap_PDF_open_pdi, 1 }, 3186 { "PDF_begin_font", _wrap_PDF_begin_font, 1 }, 3187 { "PDF_end_font", _wrap_PDF_end_font, 1 }, 3188 { "PDF_begin_glyph", _wrap_PDF_begin_glyph, 1 }, 3189 { "PDF_end_glyph", _wrap_PDF_end_glyph, 1 }, 3190 { "PDF_encoding_set_char", _wrap_PDF_encoding_set_char, 1 }, 3191 { "PDF_set_gstate", _wrap_PDF_set_gstate, 1 }, 3192 3193 { "PDF_fill_imageblock", _wrap_PDF_fill_imageblock, 1 }, 3194 { "PDF_fill_pdfblock", _wrap_PDF_fill_pdfblock, 1 }, 3195 { "PDF_fill_textblock", _wrap_PDF_fill_textblock, 1 }, 3196 { "PDF_load_font", _wrap_PDF_load_font, 1 }, 3197 { "PDF_setdashpattern", _wrap_PDF_setdashpattern, 1 }, 3198 { "PDF_add_nameddest", _wrap_PDF_add_nameddest, 1 }, 3199 { "PDF_load_iccprofile", _wrap_PDF_load_iccprofile, 1 }, 3200 { "PDF_fit_image", _wrap_PDF_fit_image, 1 }, 3201 { "PDF_load_image", _wrap_PDF_load_image, 1 }, 3202 { "PDF_fit_pdi_page", _wrap_PDF_fit_pdi_page, 1 }, 3203 { "PDF_process_pdi", _wrap_PDF_process_pdi, 1 }, 3204 { "PDF_create_pvf", _wrap_PDF_create_pvf, 1 }, 3205 { "PDF_delete_pvf", _wrap_PDF_delete_pvf, 1 }, 3206 { "PDF_shading", _wrap_PDF_shading, 1 }, 3207 { "PDF_shading_pattern", _wrap_PDF_shading_pattern, 1 }, 3208 { "PDF_shfill", _wrap_PDF_shfill, 1 }, 3209 { "PDF_fit_textline", _wrap_PDF_fit_textline, 1 }, 3210 { "PDF_create_gstate", _wrap_PDF_create_gstate, 1 }, 3211 3212 { "PDF_get_errmsg", _wrap_PDF_get_errmsg, 1 }, 3213 { "PDF_get_apiname", _wrap_PDF_get_apiname, 1 }, 3214 { "PDF_get_errnum", _wrap_PDF_get_errnum, 1 }, 3215 3216 { NULL, NULL } 3217}; 3218static PyObject *SWIG_globals; 3219#ifdef __cplusplus 3220extern "C" 3221#endif 3222SWIGEXPORT(void,initpdflib_py)() { 3223 PyObject *m, *d; 3224 SWIG_globals = SWIG_newvarlink(); 3225 m = Py_InitModule("pdflib_py", pdflibMethods); 3226 d = PyModule_GetDict(m); 3227 3228 /* Boot the PDFlib core */ 3229 PDF_boot(); 3230/* 3231 * These are the pointer type-equivalency mappings. 3232 * (Used by the SWIG pointer type-checker). 3233 */ 3234 SWIG_RegisterMapping("_signed_long","_long",0); 3235 SWIG_RegisterMapping("_struct_PDF_s","_PDF",0); 3236 SWIG_RegisterMapping("_long","_unsigned_long",0); 3237 SWIG_RegisterMapping("_long","_signed_long",0); 3238 SWIG_RegisterMapping("_PDF","_struct_PDF_s",0); 3239 SWIG_RegisterMapping("_unsigned_long","_long",0); 3240 SWIG_RegisterMapping("_signed_int","_int",0); 3241 SWIG_RegisterMapping("_unsigned_short","_short",0); 3242 SWIG_RegisterMapping("_signed_short","_short",0); 3243 SWIG_RegisterMapping("_unsigned_int","_int",0); 3244 SWIG_RegisterMapping("_short","_unsigned_short",0); 3245 SWIG_RegisterMapping("_short","_signed_short",0); 3246 SWIG_RegisterMapping("_int","_unsigned_int",0); 3247 SWIG_RegisterMapping("_int","_signed_int",0); 3248} 3249