Points&Forces (survey)
Software tools facilitating the task of surveying architecture
a_screenTCL8_wrap.cxx
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 4.0.2
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 
12 #ifndef SWIGTCL
13 #define SWIGTCL
14 #endif
15 
16 
17 #ifdef __cplusplus
18 /* SwigValueWrapper is described in swig.swg */
19 template<typename T> class SwigValueWrapper {
20  struct SwigMovePointer {
21  T *ptr;
22  SwigMovePointer(T *p) : ptr(p) { }
23  ~SwigMovePointer() { delete ptr; }
24  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
25  } pointer;
26  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
28 public:
29  SwigValueWrapper() : pointer(0) { }
30  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
31  operator T&() const { return *pointer.ptr; }
32  T *operator&() { return pointer.ptr; }
33 };
34 
35 template <typename T> T SwigValueInit() {
36  return T();
37 }
38 #endif
39 
40 /* -----------------------------------------------------------------------------
41  * This section contains generic SWIG labels for method/variable
42  * declarations/attributes, and other compiler dependent labels.
43  * ----------------------------------------------------------------------------- */
44 
45 /* template workaround for compilers that cannot correctly implement the C++ standard */
46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
48 # define SWIGTEMPLATEDISAMBIGUATOR template
49 # elif defined(__HP_aCC)
50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
52 # define SWIGTEMPLATEDISAMBIGUATOR template
53 # else
54 # define SWIGTEMPLATEDISAMBIGUATOR
55 # endif
56 #endif
57 
58 /* inline attribute */
59 #ifndef SWIGINLINE
60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
61 # define SWIGINLINE inline
62 # else
63 # define SWIGINLINE
64 # endif
65 #endif
66 
67 /* attribute recognised by some compilers to avoid 'unused' warnings */
68 #ifndef SWIGUNUSED
69 # if defined(__GNUC__)
70 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
71 # define SWIGUNUSED __attribute__ ((__unused__))
72 # else
73 # define SWIGUNUSED
74 # endif
75 # elif defined(__ICC)
76 # define SWIGUNUSED __attribute__ ((__unused__))
77 # else
78 # define SWIGUNUSED
79 # endif
80 #endif
81 
82 #ifndef SWIG_MSC_UNSUPPRESS_4505
83 # if defined(_MSC_VER)
84 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
85 # endif
86 #endif
87 
88 #ifndef SWIGUNUSEDPARM
89 # ifdef __cplusplus
90 # define SWIGUNUSEDPARM(p)
91 # else
92 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
93 # endif
94 #endif
95 
96 /* internal SWIG method */
97 #ifndef SWIGINTERN
98 # define SWIGINTERN static SWIGUNUSED
99 #endif
100 
101 /* internal inline SWIG method */
102 #ifndef SWIGINTERNINLINE
103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
104 #endif
105 
106 /* exporting methods */
107 #if defined(__GNUC__)
108 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
109 # ifndef GCC_HASCLASSVISIBILITY
110 # define GCC_HASCLASSVISIBILITY
111 # endif
112 # endif
113 #endif
114 
115 #ifndef SWIGEXPORT
116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
117 # if defined(STATIC_LINKED)
118 # define SWIGEXPORT
119 # else
120 # define SWIGEXPORT __declspec(dllexport)
121 # endif
122 # else
123 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
124 # define SWIGEXPORT __attribute__ ((visibility("default")))
125 # else
126 # define SWIGEXPORT
127 # endif
128 # endif
129 #endif
130 
131 /* calling conventions for Windows */
132 #ifndef SWIGSTDCALL
133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
134 # define SWIGSTDCALL __stdcall
135 # else
136 # define SWIGSTDCALL
137 # endif
138 #endif
139 
140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
142 # define _CRT_SECURE_NO_DEPRECATE
143 #endif
144 
145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
147 # define _SCL_SECURE_NO_DEPRECATE
148 #endif
149 
150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
153 #endif
154 
155 /* Intel's compiler complains if a variable which was never initialised is
156  * cast to void, which is a common idiom which we use to indicate that we
157  * are aware a variable isn't used. So we just silence that warning.
158  * See: https://github.com/swig/swig/issues/192 for more discussion.
159  */
160 #ifdef __INTEL_COMPILER
161 # pragma warning disable 592
162 #endif
163 
164 
165 #include <stdio.h>
166 #include <tcl.h>
167 #include <errno.h>
168 #include <stdlib.h>
169 #include <stdarg.h>
170 #include <ctype.h>
171 
172 /* -----------------------------------------------------------------------------
173  * swigrun.swg
174  *
175  * This file contains generic C API SWIG runtime support for pointer
176  * type checking.
177  * ----------------------------------------------------------------------------- */
178 
179 /* This should only be incremented when either the layout of swig_type_info changes,
180  or for whatever reason, the runtime changes incompatibly */
181 #define SWIG_RUNTIME_VERSION "4"
182 
183 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
184 #ifdef SWIG_TYPE_TABLE
185 # define SWIG_QUOTE_STRING(x) #x
186 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
187 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
188 #else
189 # define SWIG_TYPE_TABLE_NAME
190 #endif
191 
192 /*
193  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
194  creating a static or dynamic library from the SWIG runtime code.
195  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
196 
197  But only do this if strictly necessary, ie, if you have problems
198  with your compiler or suchlike.
199 */
200 
201 #ifndef SWIGRUNTIME
202 # define SWIGRUNTIME SWIGINTERN
203 #endif
204 
205 #ifndef SWIGRUNTIMEINLINE
206 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
207 #endif
208 
209 /* Generic buffer size */
210 #ifndef SWIG_BUFFER_SIZE
211 # define SWIG_BUFFER_SIZE 1024
212 #endif
213 
214 /* Flags for pointer conversions */
215 #define SWIG_POINTER_DISOWN 0x1
216 #define SWIG_CAST_NEW_MEMORY 0x2
217 #define SWIG_POINTER_NO_NULL 0x4
218 
219 /* Flags for new pointer objects */
220 #define SWIG_POINTER_OWN 0x1
221 
222 
223 /*
224  Flags/methods for returning states.
225 
226  The SWIG conversion methods, as ConvertPtr, return an integer
227  that tells if the conversion was successful or not. And if not,
228  an error code can be returned (see swigerrors.swg for the codes).
229 
230  Use the following macros/flags to set or process the returning
231  states.
232 
233  In old versions of SWIG, code such as the following was usually written:
234 
235  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
236  // success code
237  } else {
238  //fail code
239  }
240 
241  Now you can be more explicit:
242 
243  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
244  if (SWIG_IsOK(res)) {
245  // success code
246  } else {
247  // fail code
248  }
249 
250  which is the same really, but now you can also do
251 
252  Type *ptr;
253  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
254  if (SWIG_IsOK(res)) {
255  // success code
256  if (SWIG_IsNewObj(res) {
257  ...
258  delete *ptr;
259  } else {
260  ...
261  }
262  } else {
263  // fail code
264  }
265 
266  I.e., now SWIG_ConvertPtr can return new objects and you can
267  identify the case and take care of the deallocation. Of course that
268  also requires SWIG_ConvertPtr to return new result values, such as
269 
270  int SWIG_ConvertPtr(obj, ptr,...) {
271  if (<obj is ok>) {
272  if (<need new object>) {
273  *ptr = <ptr to new allocated object>;
274  return SWIG_NEWOBJ;
275  } else {
276  *ptr = <ptr to old object>;
277  return SWIG_OLDOBJ;
278  }
279  } else {
280  return SWIG_BADOBJ;
281  }
282  }
283 
284  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
285  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
286  SWIG errors code.
287 
288  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
289  allows to return the 'cast rank', for example, if you have this
290 
291  int food(double)
292  int fooi(int);
293 
294  and you call
295 
296  food(1) // cast rank '1' (1 -> 1.0)
297  fooi(1) // cast rank '0'
298 
299  just use the SWIG_AddCast()/SWIG_CheckState()
300 */
301 
302 #define SWIG_OK (0)
303 #define SWIG_ERROR (-1)
304 #define SWIG_IsOK(r) (r >= 0)
305 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
306 
307 /* The CastRankLimit says how many bits are used for the cast rank */
308 #define SWIG_CASTRANKLIMIT (1 << 8)
309 /* The NewMask denotes the object was created (using new/malloc) */
310 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
311 /* The TmpMask is for in/out typemaps that use temporal objects */
312 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
313 /* Simple returning values */
314 #define SWIG_BADOBJ (SWIG_ERROR)
315 #define SWIG_OLDOBJ (SWIG_OK)
316 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
317 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
318 /* Check, add and del mask methods */
319 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
320 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
321 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
322 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
323 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
324 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
325 
326 /* Cast-Rank Mode */
327 #if defined(SWIG_CASTRANK_MODE)
328 # ifndef SWIG_TypeRank
329 # define SWIG_TypeRank unsigned long
330 # endif
331 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
332 # define SWIG_MAXCASTRANK (2)
333 # endif
334 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
335 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
336 SWIGINTERNINLINE int SWIG_AddCast(int r) {
337  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
338 }
340  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
341 }
342 #else /* no cast-rank mode */
343 # define SWIG_AddCast(r) (r)
344 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
345 #endif
346 
347 
348 #include <string.h>
349 
350 #ifdef __cplusplus
351 extern "C" {
352 #endif
353 
354 typedef void *(*swig_converter_func)(void *, int *);
355 typedef struct swig_type_info *(*swig_dycast_func)(void **);
356 
357 /* Structure to store information on one type */
358 typedef struct swig_type_info {
359  const char *name; /* mangled name of this type */
360  const char *str; /* human readable name of this type */
361  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
362  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
363  void *clientdata; /* language specific type data */
364  int owndata; /* flag if the structure owns the clientdata */
366 
367 /* Structure to store a type and conversion function used for casting */
368 typedef struct swig_cast_info {
369  swig_type_info *type; /* pointer to type that is equivalent to this type */
370  swig_converter_func converter; /* function to cast the void pointers */
371  struct swig_cast_info *next; /* pointer to next cast in linked list */
372  struct swig_cast_info *prev; /* pointer to the previous cast */
374 
375 /* Structure used to store module information
376  * Each module generates one structure like this, and the runtime collects
377  * all of these structures and stores them in a circularly linked list.*/
378 typedef struct swig_module_info {
379  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
380  size_t size; /* Number of types in this module */
381  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
382  swig_type_info **type_initial; /* Array of initially generated type structures */
383  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
384  void *clientdata; /* Language specific module data */
386 
387 /*
388  Compare two type names skipping the space characters, therefore
389  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
390 
391  Return 0 when the two name types are equivalent, as in
392  strncmp, but skipping ' '.
393 */
394 SWIGRUNTIME int
395 SWIG_TypeNameComp(const char *f1, const char *l1,
396  const char *f2, const char *l2) {
397  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
398  while ((*f1 == ' ') && (f1 != l1)) ++f1;
399  while ((*f2 == ' ') && (f2 != l2)) ++f2;
400  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
401  }
402  return (int)((l1 - f1) - (l2 - f2));
403 }
404 
405 /*
406  Check type equivalence in a name list like <name1>|<name2>|...
407  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
408 */
409 SWIGRUNTIME int
410 SWIG_TypeCmp(const char *nb, const char *tb) {
411  int equiv = 1;
412  const char* te = tb + strlen(tb);
413  const char* ne = nb;
414  while (equiv != 0 && *ne) {
415  for (nb = ne; *ne; ++ne) {
416  if (*ne == '|') break;
417  }
418  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
419  if (*ne) ++ne;
420  }
421  return equiv;
422 }
423 
424 /*
425  Check type equivalence in a name list like <name1>|<name2>|...
426  Return 0 if not equal, 1 if equal
427 */
428 SWIGRUNTIME int
429 SWIG_TypeEquiv(const char *nb, const char *tb) {
430  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
431 }
432 
433 /*
434  Check the typename
435 */
437 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
438  if (ty) {
439  swig_cast_info *iter = ty->cast;
440  while (iter) {
441  if (strcmp(iter->type->name, c) == 0) {
442  if (iter == ty->cast)
443  return iter;
444  /* Move iter to the top of the linked list */
445  iter->prev->next = iter->next;
446  if (iter->next)
447  iter->next->prev = iter->prev;
448  iter->next = ty->cast;
449  iter->prev = 0;
450  if (ty->cast) ty->cast->prev = iter;
451  ty->cast = iter;
452  return iter;
453  }
454  iter = iter->next;
455  }
456  }
457  return 0;
458 }
459 
460 /*
461  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
462 */
465  if (ty) {
466  swig_cast_info *iter = ty->cast;
467  while (iter) {
468  if (iter->type == from) {
469  if (iter == ty->cast)
470  return iter;
471  /* Move iter to the top of the linked list */
472  iter->prev->next = iter->next;
473  if (iter->next)
474  iter->next->prev = iter->prev;
475  iter->next = ty->cast;
476  iter->prev = 0;
477  if (ty->cast) ty->cast->prev = iter;
478  ty->cast = iter;
479  return iter;
480  }
481  iter = iter->next;
482  }
483  }
484  return 0;
485 }
486 
487 /*
488  Cast a pointer up an inheritance hierarchy
489 */
490 SWIGRUNTIMEINLINE void *
491 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
492  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
493 }
494 
495 /*
496  Dynamic pointer casting. Down an inheritance hierarchy
497 */
500  swig_type_info *lastty = ty;
501  if (!ty || !ty->dcast) return ty;
502  while (ty && (ty->dcast)) {
503  ty = (*ty->dcast)(ptr);
504  if (ty) lastty = ty;
505  }
506  return lastty;
507 }
508 
509 /*
510  Return the name associated with this type
511 */
512 SWIGRUNTIMEINLINE const char *
514  return ty->name;
515 }
516 
517 /*
518  Return the pretty name associated with this type,
519  that is an unmangled type name in a form presentable to the user.
520 */
521 SWIGRUNTIME const char *
523  /* The "str" field contains the equivalent pretty names of the
524  type, separated by vertical-bar characters. We choose
525  to print the last name, as it is often (?) the most
526  specific. */
527  if (!type) return NULL;
528  if (type->str != NULL) {
529  const char *last_name = type->str;
530  const char *s;
531  for (s = type->str; *s; s++)
532  if (*s == '|') last_name = s+1;
533  return last_name;
534  }
535  else
536  return type->name;
537 }
538 
539 /*
540  Set the clientdata field for a type
541 */
542 SWIGRUNTIME void
544  swig_cast_info *cast = ti->cast;
545  /* if (ti->clientdata == clientdata) return; */
546  ti->clientdata = clientdata;
547 
548  while (cast) {
549  if (!cast->converter) {
550  swig_type_info *tc = cast->type;
551  if (!tc->clientdata) {
553  }
554  }
555  cast = cast->next;
556  }
557 }
558 SWIGRUNTIME void
561  ti->owndata = 1;
562 }
563 
564 /*
565  Search for a swig_type_info structure only by mangled name
566  Search is a O(log #types)
567 
568  We start searching at module start, and finish searching when start == end.
569  Note: if start == end at the beginning of the function, we go all the way around
570  the circular list.
571 */
574  swig_module_info *end,
575  const char *name) {
576  swig_module_info *iter = start;
577  do {
578  if (iter->size) {
579  size_t l = 0;
580  size_t r = iter->size - 1;
581  do {
582  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
583  size_t i = (l + r) >> 1;
584  const char *iname = iter->types[i]->name;
585  if (iname) {
586  int compare = strcmp(name, iname);
587  if (compare == 0) {
588  return iter->types[i];
589  } else if (compare < 0) {
590  if (i) {
591  r = i - 1;
592  } else {
593  break;
594  }
595  } else if (compare > 0) {
596  l = i + 1;
597  }
598  } else {
599  break; /* should never happen */
600  }
601  } while (l <= r);
602  }
603  iter = iter->next;
604  } while (iter != end);
605  return 0;
606 }
607 
608 /*
609  Search for a swig_type_info structure for either a mangled name or a human readable name.
610  It first searches the mangled names of the types, which is a O(log #types)
611  If a type is not found it then searches the human readable names, which is O(#types).
612 
613  We start searching at module start, and finish searching when start == end.
614  Note: if start == end at the beginning of the function, we go all the way around
615  the circular list.
616 */
619  swig_module_info *end,
620  const char *name) {
621  /* STEP 1: Search the name field using binary search */
622  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
623  if (ret) {
624  return ret;
625  } else {
626  /* STEP 2: If the type hasn't been found, do a complete search
627  of the str field (the human readable name) */
628  swig_module_info *iter = start;
629  do {
630  size_t i = 0;
631  for (; i < iter->size; ++i) {
632  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
633  return iter->types[i];
634  }
635  iter = iter->next;
636  } while (iter != end);
637  }
638 
639  /* neither found a match */
640  return 0;
641 }
642 
643 /*
644  Pack binary data into a string
645 */
646 SWIGRUNTIME char *
647 SWIG_PackData(char *c, void *ptr, size_t sz) {
648  static const char hex[17] = "0123456789abcdef";
649  const unsigned char *u = (unsigned char *) ptr;
650  const unsigned char *eu = u + sz;
651  for (; u != eu; ++u) {
652  unsigned char uu = *u;
653  *(c++) = hex[(uu & 0xf0) >> 4];
654  *(c++) = hex[uu & 0xf];
655  }
656  return c;
657 }
658 
659 /*
660  Unpack binary data from a string
661 */
662 SWIGRUNTIME const char *
663 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
664  unsigned char *u = (unsigned char *) ptr;
665  const unsigned char *eu = u + sz;
666  for (; u != eu; ++u) {
667  char d = *(c++);
668  unsigned char uu;
669  if ((d >= '0') && (d <= '9'))
670  uu = (unsigned char)((d - '0') << 4);
671  else if ((d >= 'a') && (d <= 'f'))
672  uu = (unsigned char)((d - ('a'-10)) << 4);
673  else
674  return (char *) 0;
675  d = *(c++);
676  if ((d >= '0') && (d <= '9'))
677  uu |= (unsigned char)(d - '0');
678  else if ((d >= 'a') && (d <= 'f'))
679  uu |= (unsigned char)(d - ('a'-10));
680  else
681  return (char *) 0;
682  *u = uu;
683  }
684  return c;
685 }
686 
687 /*
688  Pack 'void *' into a string buffer.
689 */
690 SWIGRUNTIME char *
691 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
692  char *r = buff;
693  if ((2*sizeof(void *) + 2) > bsz) return 0;
694  *(r++) = '_';
695  r = SWIG_PackData(r,&ptr,sizeof(void *));
696  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
697  strcpy(r,name);
698  return buff;
699 }
700 
701 SWIGRUNTIME const char *
702 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
703  if (*c != '_') {
704  if (strcmp(c,"NULL") == 0) {
705  *ptr = (void *) 0;
706  return name;
707  } else {
708  return 0;
709  }
710  }
711  return SWIG_UnpackData(++c,ptr,sizeof(void *));
712 }
713 
714 SWIGRUNTIME char *
715 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
716  char *r = buff;
717  size_t lname = (name ? strlen(name) : 0);
718  if ((2*sz + 2 + lname) > bsz) return 0;
719  *(r++) = '_';
720  r = SWIG_PackData(r,ptr,sz);
721  if (lname) {
722  strncpy(r,name,lname+1);
723  } else {
724  *r = 0;
725  }
726  return buff;
727 }
728 
729 SWIGRUNTIME const char *
730 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
731  if (*c != '_') {
732  if (strcmp(c,"NULL") == 0) {
733  memset(ptr,0,sz);
734  return name;
735  } else {
736  return 0;
737  }
738  }
739  return SWIG_UnpackData(++c,ptr,sz);
740 }
741 
742 #ifdef __cplusplus
743 }
744 #endif
745 
746 /* Errors in SWIG */
747 #define SWIG_UnknownError -1
748 #define SWIG_IOError -2
749 #define SWIG_RuntimeError -3
750 #define SWIG_IndexError -4
751 #define SWIG_TypeError -5
752 #define SWIG_DivisionByZero -6
753 #define SWIG_OverflowError -7
754 #define SWIG_SyntaxError -8
755 #define SWIG_ValueError -9
756 #define SWIG_SystemError -10
757 #define SWIG_AttributeError -11
758 #define SWIG_MemoryError -12
759 #define SWIG_NullReferenceError -13
760 
761 
762 
763 /* -----------------------------------------------------------------------------
764  * error manipulation
765  * ----------------------------------------------------------------------------- */
766 
767 SWIGINTERN const char*
769  const char* type = 0;
770  switch(code) {
771  case SWIG_MemoryError:
772  type = "MemoryError";
773  break;
774  case SWIG_IOError:
775  type = "IOError";
776  break;
777  case SWIG_RuntimeError:
778  type = "RuntimeError";
779  break;
780  case SWIG_IndexError:
781  type = "IndexError";
782  break;
783  case SWIG_TypeError:
784  type = "TypeError";
785  break;
786  case SWIG_DivisionByZero:
787  type = "ZeroDivisionError";
788  break;
789  case SWIG_OverflowError:
790  type = "OverflowError";
791  break;
792  case SWIG_SyntaxError:
793  type = "SyntaxError";
794  break;
795  case SWIG_ValueError:
796  type = "ValueError";
797  break;
798  case SWIG_SystemError:
799  type = "SystemError";
800  break;
801  case SWIG_AttributeError:
802  type = "AttributeError";
803  break;
804  default:
805  type = "RuntimeError";
806  }
807  return type;
808 }
809 
810 
811 SWIGINTERN void
812 SWIG_Tcl_SetErrorObj(Tcl_Interp *interp, const char *ctype, Tcl_Obj *obj)
813 {
814  Tcl_ResetResult(interp);
815  Tcl_SetObjResult(interp, obj);
816  Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
817 }
818 
819 SWIGINTERN void
820 SWIG_Tcl_SetErrorMsg(Tcl_Interp *interp, const char *ctype, const char *mesg)
821 {
822  Tcl_ResetResult(interp);
823  Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
824  Tcl_AppendResult(interp, ctype, " ", mesg, NULL);
825  /*
826  Tcl_AddErrorInfo(interp, ctype);
827  Tcl_AddErrorInfo(interp, " ");
828  Tcl_AddErrorInfo(interp, mesg);
829  */
830 }
831 
832 SWIGINTERNINLINE void
833 SWIG_Tcl_AddErrorMsg(Tcl_Interp *interp, const char* mesg)
834 {
835  Tcl_AddErrorInfo(interp, mesg);
836 }
837 
838 
839 
840 /* -----------------------------------------------------------------------------
841  * SWIG API. Portion that goes into the runtime
842  * ----------------------------------------------------------------------------- */
843 #ifdef __cplusplus
844 extern "C" {
845 #endif
846 
847 /* -----------------------------------------------------------------------------
848  * Constant declarations
849  * ----------------------------------------------------------------------------- */
850 
851 /* Constant Types */
852 #define SWIG_TCL_POINTER 4
853 #define SWIG_TCL_BINARY 5
854 
855 /* Constant information structure */
856 typedef struct swig_const_info {
857  int type;
858  const char *name;
859  long lvalue;
860  double dvalue;
861  void *pvalue;
864 
865 typedef int (*swig_wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
866 typedef int (*swig_wrapper_func)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
867 typedef char *(*swig_variable_func)(ClientData, Tcl_Interp *, char *, char *, int);
868 typedef void (*swig_delete_func)(ClientData);
869 
870 typedef struct swig_method {
871  const char *name;
874 
875 typedef struct swig_attribute {
876  const char *name;
880 
881 typedef struct swig_class {
882  const char *name;
885  void (*destructor)(void *);
888  struct swig_class **bases;
889  const char **base_names;
891  Tcl_HashTable hashtable;
893 
894 typedef struct swig_instance {
895  Tcl_Obj *thisptr;
896  void *thisvalue;
898  int destroy;
899  Tcl_Command cmdtok;
901 
902 /* Structure for command table */
903 typedef struct {
904  const char *name;
905  int (*wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
906  ClientData clientdata;
908 
909 /* Structure for variable linking table */
910 typedef struct {
911  const char *name;
912  void *addr;
913  char * (*get)(ClientData, Tcl_Interp *, char *, char *, int);
914  char * (*set)(ClientData, Tcl_Interp *, char *, char *, int);
915 } swig_var_info;
916 
917 
918 /* -----------------------------------------------------------------------------*
919  * Install a constant object
920  * -----------------------------------------------------------------------------*/
921 
922 static Tcl_HashTable swigconstTable;
923 static int swigconstTableinit = 0;
924 
925 SWIGINTERN void
926 SWIG_Tcl_SetConstantObj(Tcl_Interp *interp, const char* name, Tcl_Obj *obj) {
927  int newobj;
928  Tcl_ObjSetVar2(interp,Tcl_NewStringObj(name,-1), NULL, obj, TCL_GLOBAL_ONLY);
929  Tcl_SetHashValue(Tcl_CreateHashEntry(&swigconstTable, name, &newobj), (ClientData) obj);
930 }
931 
932 SWIGINTERN Tcl_Obj *
933 SWIG_Tcl_GetConstantObj(const char *key) {
934  Tcl_HashEntry *entryPtr;
935  if (!swigconstTableinit) return 0;
936  entryPtr = Tcl_FindHashEntry(&swigconstTable, key);
937  if (entryPtr) {
938  return (Tcl_Obj *) Tcl_GetHashValue(entryPtr);
939  }
940  return 0;
941 }
942 
943 #ifdef __cplusplus
944 }
945 #endif
946 
947 
948 
949 /* -----------------------------------------------------------------------------
950  * tclrun.swg
951  *
952  * This file contains the runtime support for Tcl modules and includes
953  * code for managing global variables and pointer type checking.
954  * ----------------------------------------------------------------------------- */
955 
956 /* Common SWIG API */
957 
958 /* for raw pointers */
959 #define SWIG_ConvertPtr(oc, ptr, ty, flags) SWIG_Tcl_ConvertPtr(interp, oc, ptr, ty, flags)
960 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Tcl_NewPointerObj(ptr, type, flags)
961 
962 /* for raw packed data */
963 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty)
964 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type)
965 
966 /* for class or struct pointers */
967 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags)
968 #define SWIG_NewInstanceObj(thisvalue, type, flags) SWIG_Tcl_NewInstanceObj(interp, thisvalue, type, flags)
969 
970 /* for C or C++ function pointers */
971 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, 0)
972 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Tcl_NewPointerObj(ptr, type, 0)
973 
974 /* for C++ member pointers, ie, member methods */
975 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty)
976 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type)
977 
978 
979 /* Runtime API */
980 
981 #define SWIG_GetModule(clientdata) SWIG_Tcl_GetModule((Tcl_Interp *) (clientdata))
982 #define SWIG_SetModule(clientdata, pointer) SWIG_Tcl_SetModule((Tcl_Interp *) (clientdata), pointer)
983 
984 
985 /* Error manipulation */
986 
987 #define SWIG_ErrorType(code) SWIG_Tcl_ErrorType(code)
988 #define SWIG_Error(code, msg) SWIG_Tcl_SetErrorMsg(interp, SWIG_Tcl_ErrorType(code), msg)
989 #define SWIG_fail goto fail
990 
991 
992 /* Tcl-specific SWIG API */
993 
994 #define SWIG_Acquire(ptr) SWIG_Tcl_Acquire(ptr)
995 #define SWIG_MethodCommand SWIG_Tcl_MethodCommand
996 #define SWIG_Disown(ptr) SWIG_Tcl_Disown(ptr)
997 #define SWIG_ConvertPtrFromString(c, ptr, ty, flags) SWIG_Tcl_ConvertPtrFromString(interp, c, ptr, ty, flags)
998 #define SWIG_MakePtr(c, ptr, ty, flags) SWIG_Tcl_MakePtr(c, ptr, ty, flags)
999 #define SWIG_PointerTypeFromString(c) SWIG_Tcl_PointerTypeFromString(c)
1000 #define SWIG_GetArgs SWIG_Tcl_GetArgs
1001 #define SWIG_GetConstantObj(key) SWIG_Tcl_GetConstantObj(key)
1002 #define SWIG_ObjectConstructor SWIG_Tcl_ObjectConstructor
1003 #define SWIG_Thisown(ptr) SWIG_Tcl_Thisown(ptr)
1004 #define SWIG_ObjectDelete SWIG_Tcl_ObjectDelete
1005 
1006 
1007 #define SWIG_TCL_DECL_ARGS_2(arg1, arg2) (Tcl_Interp *interp SWIGUNUSED, arg1, arg2)
1008 #define SWIG_TCL_CALL_ARGS_2(arg1, arg2) (interp, arg1, arg2)
1009 /* -----------------------------------------------------------------------------
1010  * pointers/data manipulation
1011  * ----------------------------------------------------------------------------- */
1012 
1013 /* For backward compatibility only */
1014 #define SWIG_POINTER_EXCEPTION 0
1015 #define SWIG_GetConstant SWIG_GetConstantObj
1016 #define SWIG_Tcl_GetConstant SWIG_Tcl_GetConstantObj
1017 
1018 #if TCL_MAJOR_VERSION >= 8 && TCL_MINOR_VERSION >= 5
1019 #define SWIG_TCL_HASHTABLE_INIT {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1020 #else
1021 #define SWIG_TCL_HASHTABLE_INIT {0}
1022 #endif
1023 
1024 #include "assert.h"
1025 
1026 #ifdef __cplusplus
1027 extern "C" {
1028 #endif
1029 
1030 /* Object support */
1031 
1032 SWIGRUNTIME Tcl_HashTable*
1034  static Tcl_HashTable swigobjectTable;
1035  static int swigobjectTableinit = 0;
1036  if (!swigobjectTableinit) {
1037  Tcl_InitHashTable(&swigobjectTable, TCL_ONE_WORD_KEYS);
1038  swigobjectTableinit = 1;
1039  }
1040  return &swigobjectTable;
1041 }
1042 
1043 /* Acquire ownership of a pointer */
1044 SWIGRUNTIME void
1045 SWIG_Tcl_Acquire(void *ptr) {
1046  int newobj;
1047  Tcl_CreateHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr, &newobj);
1048 }
1049 
1050 SWIGRUNTIME int
1051 SWIG_Tcl_Thisown(void *ptr) {
1052  if (Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr)) {
1053  return 1;
1054  }
1055  return 0;
1056 }
1057 
1058 /* Disown a pointer. Returns 1 if we owned it to begin with */
1059 SWIGRUNTIME int
1060 SWIG_Tcl_Disown(void *ptr) {
1061  Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr);
1062  if (entryPtr) {
1063  Tcl_DeleteHashEntry(entryPtr);
1064  return 1;
1065  }
1066  return 0;
1067 }
1068 
1069 /* Convert a pointer value */
1070 SWIGRUNTIME int
1071 SWIG_Tcl_ConvertPtrFromString(Tcl_Interp *interp, const char *c, void **ptr, swig_type_info *ty, int flags) {
1072  swig_cast_info *tc;
1073  /* Pointer values must start with leading underscore */
1074  while (*c != '_') {
1075  *ptr = (void *) 0;
1076  if (strcmp(c,"NULL") == 0)
1078 
1079  /* Empty string: not a pointer */
1080  if (*c == 0) return SWIG_ERROR;
1081 
1082  /* Hmmm. It could be an object name. */
1083 
1084  /* Check if this is a command at all. Prevents <c> cget -this */
1085  /* from being called when c is not a command, firing the unknown proc */
1086  if (Tcl_VarEval(interp,"info commands ", c, (char *) NULL) == TCL_OK) {
1087  Tcl_Obj *result = Tcl_GetObjResult(interp);
1088  if (*(Tcl_GetStringFromObj(result, NULL)) == 0) {
1089  /* It's not a command, so it can't be a pointer */
1090  Tcl_ResetResult(interp);
1091  return SWIG_ERROR;
1092  }
1093  } else {
1094  /* This will only fail if the argument is multiple words. */
1095  /* Multiple words are also not commands. */
1096  Tcl_ResetResult(interp);
1097  return SWIG_ERROR;
1098  }
1099 
1100  /* Check if this is really a SWIG pointer */
1101  if (Tcl_VarEval(interp,c," cget -this", (char *) NULL) != TCL_OK) {
1102  Tcl_ResetResult(interp);
1103  return SWIG_ERROR;
1104  }
1105 
1106  c = Tcl_GetStringFromObj(Tcl_GetObjResult(interp), NULL);
1107  }
1108 
1109  c++;
1110  c = SWIG_UnpackData(c,ptr,sizeof(void *));
1111  if (ty) {
1112  tc = c ? SWIG_TypeCheck(c,ty) : 0;
1113  if (!tc) {
1114  return SWIG_ERROR;
1115  }
1116  if (flags & SWIG_POINTER_DISOWN) {
1117  SWIG_Disown((void *) *ptr);
1118  }
1119  {
1120  int newmemory = 0;
1121  *ptr = SWIG_TypeCast(tc,(void *) *ptr,&newmemory);
1122  assert(!newmemory); /* newmemory handling not yet implemented */
1123  }
1124  }
1125  return SWIG_OK;
1126 }
1127 
1128 /* Convert a pointer value */
1130 SWIG_Tcl_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, swig_type_info *ty, int flags) {
1131  return SWIG_Tcl_ConvertPtrFromString(interp, Tcl_GetStringFromObj(oc,NULL), ptr, ty, flags);
1132 }
1133 
1134 /* Convert a pointer value */
1135 SWIGRUNTIME char *
1137  char d;
1138  /* Pointer values must start with leading underscore. NULL has no type */
1139  if (*c != '_') {
1140  return 0;
1141  }
1142  c++;
1143  /* Extract hex value from pointer */
1144  while ((d = *c)) {
1145  if (!(((d >= '0') && (d <= '9')) || ((d >= 'a') && (d <= 'f')))) break;
1146  c++;
1147  }
1148  return c;
1149 }
1150 
1151 /* Convert a packed pointer value */
1152 SWIGRUNTIME int
1153 SWIG_Tcl_ConvertPacked(Tcl_Interp *SWIGUNUSEDPARM(interp) , Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty) {
1154  swig_cast_info *tc;
1155  const char *c;
1156 
1157  if (!obj) goto type_error;
1158  c = Tcl_GetStringFromObj(obj,NULL);
1159  /* Pointer values must start with leading underscore */
1160  if (*c != '_') goto type_error;
1161  c++;
1162  c = SWIG_UnpackData(c,ptr,sz);
1163  if (ty) {
1164  tc = SWIG_TypeCheck(c,ty);
1165  if (!tc) goto type_error;
1166  }
1167  return SWIG_OK;
1168 
1169  type_error:
1170 
1171  return SWIG_ERROR;
1172 }
1173 
1174 
1175 /* Take a pointer and convert it to a string */
1176 SWIGRUNTIME void
1177 SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int SWIGUNUSEDPARM(flags)) {
1178  if (ptr) {
1179  *(c++) = '_';
1180  c = SWIG_PackData(c,&ptr,sizeof(void *));
1181  strcpy(c,ty->name);
1182  } else {
1183  strcpy(c,"NULL");
1184  }
1185 }
1186 
1187 /* Create a new pointer object */
1188 SWIGRUNTIMEINLINE Tcl_Obj *
1189 SWIG_Tcl_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
1190  Tcl_Obj *robj;
1191  char result[SWIG_BUFFER_SIZE];
1192  SWIG_MakePtr(result,ptr,type,flags);
1193  robj = Tcl_NewStringObj(result,-1);
1194  return robj;
1195 }
1196 
1197 SWIGRUNTIME Tcl_Obj *
1198 SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1199  char result[1024];
1200  char *r = result;
1201  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1202  *(r++) = '_';
1203  r = SWIG_PackData(r,ptr,sz);
1204  strcpy(r,type->name);
1205  return Tcl_NewStringObj(result,-1);
1206 }
1207 
1208 /* -----------------------------------------------------------------------------*
1209  * Get type list
1210  * -----------------------------------------------------------------------------*/
1211 
1213 SWIG_Tcl_GetModule(Tcl_Interp *interp) {
1214  const char *data;
1215  swig_module_info *ret = 0;
1216 
1217  /* first check if pointer already created */
1218  data = Tcl_GetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TCL_GLOBAL_ONLY);
1219  if (data) {
1220  SWIG_UnpackData(data, &ret, sizeof(swig_type_info **));
1221  }
1222 
1223  return ret;
1224 }
1225 
1226 SWIGRUNTIME void
1227 SWIG_Tcl_SetModule(Tcl_Interp *interp, swig_module_info *module) {
1228  char buf[SWIG_BUFFER_SIZE];
1229  char *data;
1230 
1231  /* create a new pointer */
1232  data = SWIG_PackData(buf, &module, sizeof(swig_type_info **));
1233  *data = 0;
1234  Tcl_SetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, buf, TCL_GLOBAL_ONLY);
1235 }
1236 
1237 /* -----------------------------------------------------------------------------*
1238  * Object auxiliaries
1239  * -----------------------------------------------------------------------------*/
1240 
1241 
1242 SWIGRUNTIME void
1243 SWIG_Tcl_ObjectDelete(ClientData clientData) {
1244  swig_instance *si = (swig_instance *) clientData;
1245  if (!si) return;
1246  if (si->destroy && SWIG_Disown(si->thisvalue)) {
1247  if (si->classptr->destructor) {
1248  (si->classptr->destructor)(si->thisvalue);
1249  }
1250  }
1251  Tcl_DecrRefCount(si->thisptr);
1252  free(si);
1253 }
1254 
1255 /* Function to invoke object methods given an instance */
1256 SWIGRUNTIME int
1257 SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST _objv[]) {
1258  char *method, *attrname;
1259  swig_instance *inst = (swig_instance *) clientData;
1260  swig_method *meth;
1261  swig_attribute *attr;
1262  Tcl_Obj *oldarg;
1263  Tcl_Obj **objv;
1264  int rcode;
1265  swig_class *cls;
1266  swig_class *cls_stack[64];
1267  int cls_stack_bi[64];
1268  int cls_stack_top = 0;
1269  int numconf = 2;
1270  int bi;
1271 
1272  objv = (Tcl_Obj **) _objv;
1273  if (objc < 2) {
1274  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1275  return TCL_ERROR;
1276  }
1277  method = Tcl_GetStringFromObj(objv[1],NULL);
1278  if (strcmp(method,"-acquire") == 0) {
1279  inst->destroy = 1;
1280  SWIG_Acquire(inst->thisvalue);
1281  return TCL_OK;
1282  }
1283  if (strcmp(method,"-disown") == 0) {
1284  if (inst->destroy) {
1285  SWIG_Disown(inst->thisvalue);
1286  }
1287  inst->destroy = 0;
1288  return TCL_OK;
1289  }
1290  if (strcmp(method,"-delete") == 0) {
1291  Tcl_DeleteCommandFromToken(interp,inst->cmdtok);
1292  return TCL_OK;
1293  }
1294  cls_stack[cls_stack_top] = inst->classptr;
1295  cls_stack_bi[cls_stack_top] = -1;
1296  while (1) {
1297  Tcl_HashEntry* hashentry;
1298  bi = cls_stack_bi[cls_stack_top];
1299  cls = cls_stack[cls_stack_top];
1300  if (bi != -1) {
1301  if (!cls->bases[bi] && cls->base_names[bi]) {
1302  /* lookup and cache the base class */
1303  swig_type_info *info = SWIG_TypeQueryModule(cls->module, cls->module, cls->base_names[bi]);
1304  if (info) cls->bases[bi] = (swig_class *) info->clientdata;
1305  }
1306  cls = cls->bases[bi];
1307  if (cls) {
1308  cls_stack_bi[cls_stack_top]++;
1309  cls_stack_top++;
1310  cls_stack[cls_stack_top] = cls;
1311  cls_stack_bi[cls_stack_top] = -1;
1312  continue;
1313  }
1314  }
1315  if (!cls) {
1316  cls_stack_top--;
1317  if (cls_stack_top < 0) break;
1318  else continue;
1319  }
1320  cls_stack_bi[cls_stack_top]++;
1321 
1322  hashentry = Tcl_FindHashEntry(&(cls->hashtable), method);
1323  if (hashentry) {
1324  ClientData cd = Tcl_GetHashValue(hashentry);
1325  swig_wrapper method_wrapper = (swig_wrapper)cd;
1326  oldarg = objv[1];
1327  objv[1] = inst->thisptr;
1328  Tcl_IncrRefCount(inst->thisptr);
1329  rcode = (method_wrapper)(clientData,interp,objc,objv);
1330  objv[1] = oldarg;
1331  Tcl_DecrRefCount(inst->thisptr);
1332  return rcode;
1333  }
1334  /* Check class methods for a match */
1335  if (strcmp(method,"cget") == 0) {
1336  if (objc < 3) {
1337  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1338  return TCL_ERROR;
1339  }
1340  attrname = Tcl_GetStringFromObj(objv[2],NULL);
1341  attr = cls->attributes;
1342  while (attr && attr->name) {
1343  if ((strcmp(attr->name, attrname) == 0) && (attr->getmethod)) {
1344  oldarg = objv[1];
1345  objv[1] = inst->thisptr;
1346  Tcl_IncrRefCount(inst->thisptr);
1347  rcode = (*attr->getmethod)(clientData,interp,2, objv);
1348  objv[1] = oldarg;
1349  Tcl_DecrRefCount(inst->thisptr);
1350  return rcode;
1351  }
1352  attr++;
1353  }
1354  if (strcmp(attrname, "-this") == 0) {
1355  Tcl_SetObjResult(interp, Tcl_DuplicateObj(inst->thisptr));
1356  return TCL_OK;
1357  }
1358  if (strcmp(attrname, "-thisown") == 0) {
1359  if (SWIG_Thisown(inst->thisvalue)) {
1360  Tcl_SetResult(interp,(char*)"1",TCL_STATIC);
1361  } else {
1362  Tcl_SetResult(interp,(char*)"0",TCL_STATIC);
1363  }
1364  return TCL_OK;
1365  }
1366  } else if (strcmp(method, "configure") == 0) {
1367  int i;
1368  if (objc < 4) {
1369  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1370  return TCL_ERROR;
1371  }
1372  i = 2;
1373  while (i < objc) {
1374  attrname = Tcl_GetStringFromObj(objv[i],NULL);
1375  attr = cls->attributes;
1376  while (attr && attr->name) {
1377  if ((strcmp(attr->name, attrname) == 0) && (attr->setmethod)) {
1378  oldarg = objv[i];
1379  objv[i] = inst->thisptr;
1380  Tcl_IncrRefCount(inst->thisptr);
1381  rcode = (*attr->setmethod)(clientData,interp,3, &objv[i-1]);
1382  objv[i] = oldarg;
1383  Tcl_DecrRefCount(inst->thisptr);
1384  if (rcode != TCL_OK) return rcode;
1385  numconf += 2;
1386  }
1387  attr++;
1388  }
1389  i+=2;
1390  }
1391  }
1392  }
1393  if (strcmp(method,"configure") == 0) {
1394  if (numconf >= objc) {
1395  return TCL_OK;
1396  } else {
1397  Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
1398  return TCL_ERROR;
1399  }
1400  }
1401  if (strcmp(method,"cget") == 0) {
1402  Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
1403  return TCL_ERROR;
1404  }
1405  Tcl_SetResult(interp, (char *) "Invalid method. Must be one of: configure cget -acquire -disown -delete", TCL_STATIC);
1406  cls = inst->classptr;
1407  bi = 0;
1408  while (cls) {
1409  meth = cls->methods;
1410  while (meth && meth->name) {
1411  char *cr = (char *) Tcl_GetStringResult(interp);
1412  size_t meth_len = strlen(meth->name);
1413  char* where = strchr(cr,':');
1414  while(where) {
1415  where = strstr(where, meth->name);
1416  if(where) {
1417  if(where[-1] == ' ' && (where[meth_len] == ' ' || where[meth_len]==0)) {
1418  break;
1419  } else {
1420  where++;
1421  }
1422  }
1423  }
1424 
1425  if (!where)
1426  Tcl_AppendElement(interp, (char *) meth->name);
1427  meth++;
1428  }
1429  cls = inst->classptr->bases[bi++];
1430  }
1431  return TCL_ERROR;
1432 }
1433 
1434 /* This function takes the current result and turns it into an object command */
1435 SWIGRUNTIME Tcl_Obj *
1436 SWIG_Tcl_NewInstanceObj(Tcl_Interp *interp, void *thisvalue, swig_type_info *type, int flags) {
1437  Tcl_Obj *robj = SWIG_NewPointerObj(thisvalue, type,0);
1438  /* Check to see if this pointer belongs to a class or not */
1439  if (thisvalue && (type->clientdata) && (interp)) {
1440  Tcl_CmdInfo ci;
1441  char *name;
1442  name = Tcl_GetStringFromObj(robj,NULL);
1443  if (!Tcl_GetCommandInfo(interp,name, &ci) || (flags)) {
1444  swig_instance *newinst = (swig_instance *) malloc(sizeof(swig_instance));
1445  newinst->thisptr = Tcl_DuplicateObj(robj);
1446  Tcl_IncrRefCount(newinst->thisptr);
1447  newinst->thisvalue = thisvalue;
1448  newinst->classptr = (swig_class *) type->clientdata;
1449  newinst->destroy = flags;
1450  newinst->cmdtok = Tcl_CreateObjCommand(interp, Tcl_GetStringFromObj(robj,NULL), (swig_wrapper_func) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
1451  if (flags) {
1452  SWIG_Acquire(thisvalue);
1453  }
1454  }
1455  }
1456  return robj;
1457 }
1458 
1459 /* Function to create objects */
1460 SWIGRUNTIME int
1461 SWIG_Tcl_ObjectConstructor(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1462  Tcl_Obj *newObj = 0;
1463  void *thisvalue = 0;
1464  swig_instance *newinst = 0;
1465  swig_class *classptr = (swig_class *) clientData;
1466  swig_wrapper cons = 0;
1467  char *name = 0;
1468  int firstarg = 0;
1469  int thisarg = 0;
1470  int destroy = 1;
1471 
1472  if (!classptr) {
1473  Tcl_SetResult(interp, (char *) "swig: internal runtime error. No class object defined.", TCL_STATIC);
1474  return TCL_ERROR;
1475  }
1476  cons = classptr->constructor;
1477  if (objc > 1) {
1478  char *s = Tcl_GetStringFromObj(objv[1],NULL);
1479  if (strcmp(s,"-this") == 0) {
1480  thisarg = 2;
1481  cons = 0;
1482  } else if (strcmp(s,"-args") == 0) {
1483  firstarg = 1;
1484  } else if (objc == 2) {
1485  firstarg = 1;
1486  name = s;
1487  } else if (objc >= 3) {
1488  char *s1;
1489  name = s;
1490  s1 = Tcl_GetStringFromObj(objv[2],NULL);
1491  if (strcmp(s1,"-this") == 0) {
1492  thisarg = 3;
1493  cons = 0;
1494  } else {
1495  firstarg = 1;
1496  }
1497  }
1498  }
1499  if (cons) {
1500  int result;
1501  result = (*cons)(0, interp, objc-firstarg, &objv[firstarg]);
1502  if (result != TCL_OK) {
1503  return result;
1504  }
1505  newObj = Tcl_DuplicateObj(Tcl_GetObjResult(interp));
1506  if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
1507  } else if (thisarg > 0) {
1508  if (thisarg < objc) {
1509  destroy = 0;
1510  newObj = Tcl_DuplicateObj(objv[thisarg]);
1511  if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
1512  } else {
1513  Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1514  return TCL_ERROR;
1515  }
1516  } else {
1517  Tcl_SetResult(interp, (char *) "No constructor available.", TCL_STATIC);
1518  return TCL_ERROR;
1519  }
1520  if (SWIG_Tcl_ConvertPtr(interp,newObj, (void **) &thisvalue, *(classptr->type), 0) != SWIG_OK) {
1521  Tcl_DecrRefCount(newObj);
1522  return TCL_ERROR;
1523  }
1524  newinst = (swig_instance *) malloc(sizeof(swig_instance));
1525  newinst->thisptr = newObj;
1526  Tcl_IncrRefCount(newObj);
1527  newinst->thisvalue = thisvalue;
1528  newinst->classptr = classptr;
1529  newinst->destroy = destroy;
1530  if (destroy) {
1531  SWIG_Acquire(thisvalue);
1532  }
1533  newinst->cmdtok = Tcl_CreateObjCommand(interp,name, (swig_wrapper) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
1534  return TCL_OK;
1535 }
1536 
1537 /* -----------------------------------------------------------------------------*
1538  * Get arguments
1539  * -----------------------------------------------------------------------------*/
1540 SWIGRUNTIME int
1541 SWIG_Tcl_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...) {
1542  int argno = 0, opt = 0;
1543  long tempi;
1544  double tempd;
1545  const char *c;
1546  va_list ap;
1547  void *vptr;
1548  Tcl_Obj *obj = 0;
1549  swig_type_info *ty;
1550 
1551  va_start(ap,fmt);
1552  for (c = fmt; (*c && (*c != ':') && (*c != ';')); c++,argno++) {
1553  if (*c == '|') {
1554  opt = 1;
1555  c++;
1556  }
1557  if (argno >= (objc-1)) {
1558  if (!opt) {
1559  Tcl_SetResult(interp, (char *) "Wrong number of arguments ", TCL_STATIC);
1560  goto argerror;
1561  } else {
1562  va_end(ap);
1563  return TCL_OK;
1564  }
1565  }
1566 
1567  vptr = va_arg(ap,void *);
1568  if (vptr) {
1569  if (isupper(*c)) {
1570  obj = SWIG_Tcl_GetConstantObj(Tcl_GetStringFromObj(objv[argno+1],0));
1571  if (!obj) obj = objv[argno+1];
1572  } else {
1573  obj = objv[argno+1];
1574  }
1575  switch(*c) {
1576  case 'i': case 'I':
1577  case 'l': case 'L':
1578  case 'h': case 'H':
1579  case 'b': case 'B':
1580  if (Tcl_GetLongFromObj(interp,obj,&tempi) != TCL_OK) goto argerror;
1581  if ((*c == 'i') || (*c == 'I')) *((int *)vptr) = (int)tempi;
1582  else if ((*c == 'l') || (*c == 'L')) *((long *)vptr) = (long)tempi;
1583  else if ((*c == 'h') || (*c == 'H')) *((short*)vptr) = (short)tempi;
1584  else if ((*c == 'b') || (*c == 'B')) *((unsigned char *)vptr) = (unsigned char)tempi;
1585  break;
1586  case 'f': case 'F':
1587  case 'd': case 'D':
1588  if (Tcl_GetDoubleFromObj(interp,obj,&tempd) != TCL_OK) goto argerror;
1589  if ((*c == 'f') || (*c == 'F')) *((float *) vptr) = (float)tempd;
1590  else if ((*c == 'd') || (*c == 'D')) *((double*) vptr) = tempd;
1591  break;
1592  case 's': case 'S':
1593  if (*(c+1) == '#') {
1594  int *vlptr = (int *) va_arg(ap, void *);
1595  *((char **) vptr) = Tcl_GetStringFromObj(obj, vlptr);
1596  c++;
1597  } else {
1598  *((char **)vptr) = Tcl_GetStringFromObj(obj,NULL);
1599  }
1600  break;
1601  case 'c': case 'C':
1602  *((char *)vptr) = *(Tcl_GetStringFromObj(obj,NULL));
1603  break;
1604  case 'p': case 'P':
1605  ty = (swig_type_info *) va_arg(ap, void *);
1606  if (SWIG_Tcl_ConvertPtr(interp, obj, (void **) vptr, ty, 0) != SWIG_OK) goto argerror;
1607  break;
1608  case 'o': case 'O':
1609  *((Tcl_Obj **)vptr) = objv[argno+1];
1610  break;
1611  default:
1612  break;
1613  }
1614  }
1615  }
1616 
1617  if ((*c != ';') && ((objc-1) > argno)) {
1618  Tcl_SetResult(interp, (char *) "Wrong # args.", TCL_STATIC);
1619  goto argerror;
1620  }
1621  va_end(ap);
1622  return TCL_OK;
1623 
1624  argerror:
1625  {
1626  char temp[32];
1627  sprintf(temp,"%d", argno+1);
1628  c = strchr(fmt,':');
1629  if (!c) c = strchr(fmt,';');
1630  if (!c) c = (char *)"";
1631  Tcl_AppendResult(interp,c," argument ", temp, NULL);
1632  va_end(ap);
1633  return TCL_ERROR;
1634  }
1635 }
1636 
1637 #ifdef __cplusplus
1638 }
1639 #endif
1640 
1641 
1642 
1643 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1644 
1645 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1646 
1647 
1648 
1649 /* -------- TYPES TABLE (BEGIN) -------- */
1650 
1651 #define SWIGTYPE_p_a_point swig_types[0]
1652 #define SWIGTYPE_p_a_screen swig_types[1]
1653 #define SWIGTYPE_p_a_text swig_types[2]
1654 #define SWIGTYPE_p_char swig_types[3]
1655 #define SWIGTYPE_p_p_a_screenlayer swig_types[4]
1657 static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};
1658 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1659 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1660 
1661 /* -------- TYPES TABLE (END) -------- */
1662 
1663 #define SWIG_init A_screen_Init
1664 #define SWIG_name "a_screen"
1665 #define SWIG_prefix ""
1666 #define SWIG_version "0.0"
1667 
1668 #define SWIGVERSION 0x040002
1669 #define SWIG_VERSION SWIGVERSION
1670 
1671 
1672 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
1673 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
1674 
1675 
1676 #include <stdexcept>
1677 
1678 
1679 
1680 #ifdef __cplusplus
1681 extern "C" {
1682 #endif
1683 #ifdef MAC_TCL
1684 #pragma export on
1685 #endif
1686 SWIGEXPORT int SWIG_init(Tcl_Interp *);
1687 #ifdef MAC_TCL
1688 #pragma export off
1689 #endif
1690 #ifdef __cplusplus
1691 }
1692 #endif
1693 
1694 /* Compatibility version for TCL stubs */
1695 #ifndef SWIG_TCL_STUBS_VERSION
1696 #define SWIG_TCL_STUBS_VERSION "8.1"
1697 #endif
1698 
1699 
1700 
1701 #include <string>
1702 
1703 
1704 #include "a_screen.h"
1705 #include "a_screenlayer.h"
1706 #include <sstream>
1707 
1708 
1709 #include <limits.h>
1710 #if !defined(SWIG_NO_LLONG_MAX)
1711 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1712 # define LLONG_MAX __LONG_LONG_MAX__
1713 # define LLONG_MIN (-LLONG_MAX - 1LL)
1714 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1715 # endif
1716 #endif
1717 
1718 
1719 SWIGINTERNINLINE Tcl_Obj *
1720 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1721 {
1722  return (size < INT_MAX) ? Tcl_NewStringObj(carray, static_cast< int >(size)) : NULL;
1723 }
1724 
1725 
1726 SWIGINTERNINLINE Tcl_Obj *
1727 SWIG_From_std_string (const std::string& s)
1728 {
1729  return SWIG_FromCharPtrAndSize(s.data(), s.size());
1730 }
1731 
1732 
1733 SWIGINTERN int
1734 SWIG_AsCharPtrAndSize(Tcl_Obj *obj, char** cptr, size_t* psize, int *alloc)
1735 {
1736  int len = 0;
1737  char *cstr = Tcl_GetStringFromObj(obj, &len);
1738  if (cstr) {
1739  if (cptr) *cptr = cstr;
1740  if (psize) *psize = len + 1;
1741  if (alloc) *alloc = SWIG_OLDOBJ;
1742  return SWIG_OK;
1743  }
1744  return SWIG_TypeError;
1745 }
1746 
1747 
1748 SWIGINTERN int
1749 SWIG_AsPtr_std_string SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, std::string **val)
1750 {
1751  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
1752  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
1753  if (buf) {
1754  if (val) *val = new std::string(buf, size - 1);
1755  if (alloc == SWIG_NEWOBJ) delete[] buf;
1756  return SWIG_NEWOBJ;
1757  } else {
1758  if (val) *val = 0;
1759  return SWIG_OLDOBJ;
1760  }
1761  } else {
1762  static int init = 0;
1763  static swig_type_info* descriptor = 0;
1764  if (!init) {
1765  descriptor = SWIG_TypeQuery("std::string" " *");
1766  init = 1;
1767  }
1768  if (descriptor) {
1769  std::string *vptr;
1770  int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
1771  if (SWIG_IsOK(res) && val) *val = vptr;
1772  return res;
1773  }
1774  }
1775  return SWIG_ERROR;
1776 }
1777 
1778 
1779  #define SWIG_From_bool Tcl_NewBooleanObj
1780 
1781 
1782 #include <float.h>
1783 
1784 
1785 #include <math.h>
1786 
1787 
1788 /* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
1789 #ifndef SWIG_isfinite
1790 /* isfinite() is a macro for C99 */
1791 # if defined(isfinite)
1792 # define SWIG_isfinite(X) (isfinite(X))
1793 # elif defined(__cplusplus) && __cplusplus >= 201103L
1794 /* Use a template so that this works whether isfinite() is std::isfinite() or
1795  * in the global namespace. The reality seems to vary between compiler
1796  * versions.
1797  *
1798  * Make sure namespace std exists to avoid compiler warnings.
1799  *
1800  * extern "C++" is required as this fragment can end up inside an extern "C" { } block
1801  */
1802 namespace std { }
1803 extern "C++" template<typename T>
1804 inline int SWIG_isfinite_func(T x) {
1805  using namespace std;
1806  return isfinite(x);
1807 }
1808 # define SWIG_isfinite(X) (SWIG_isfinite_func(X))
1809 # elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
1810 # define SWIG_isfinite(X) (__builtin_isfinite(X))
1811 # elif defined(__clang__) && defined(__has_builtin)
1812 # if __has_builtin(__builtin_isfinite)
1813 # define SWIG_isfinite(X) (__builtin_isfinite(X))
1814 # endif
1815 # elif defined(_MSC_VER)
1816 # define SWIG_isfinite(X) (_finite(X))
1817 # elif defined(__sun) && defined(__SVR4)
1818 # include <ieeefp.h>
1819 # define SWIG_isfinite(X) (finite(X))
1820 # endif
1821 #endif
1822 
1823 
1824 /* Accept infinite as a valid float value unless we are unable to check if a value is finite */
1825 #ifdef SWIG_isfinite
1826 # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
1827 #else
1828 # define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
1829 #endif
1830 
1831 
1832 SWIGINTERN int
1833 SWIG_AsVal_double SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, double *val)
1834 {
1835  double v;
1836  if (Tcl_GetDoubleFromObj(0, obj, &v) == TCL_OK) {
1837  if (val) *val = v;
1838  return SWIG_OK;
1839  }
1840  return SWIG_TypeError;
1841 }
1842 
1843 
1844 SWIGINTERN int
1845 SWIG_AsVal_float SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, float *val)
1846 {
1847  double v;
1848  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(obj, &v);
1849  if (SWIG_IsOK(res)) {
1851  return SWIG_OverflowError;
1852  } else {
1853  if (val) *val = static_cast< float >(v);
1854  }
1855  }
1856  return res;
1857 }
1858 
1859 
1860  #define SWIG_From_double Tcl_NewDoubleObj
1861 
1862 
1863 SWIGINTERN int
1864 SWIG_AsVal_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, long* val)
1865 {
1866  long v;
1867  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1868  if (val) *val = (long) v;
1869  return SWIG_OK;
1870  }
1871  return SWIG_TypeError;
1872 }
1873 
1874 
1875 SWIGINTERN int
1876 SWIG_AsVal_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, int *val)
1877 {
1878  long v;
1879  int res = SWIG_AsVal_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1880  if (SWIG_IsOK(res)) {
1881  if ((v < INT_MIN || v > INT_MAX)) {
1882  return SWIG_OverflowError;
1883  } else {
1884  if (val) *val = static_cast< int >(v);
1885  }
1886  }
1887  return res;
1888 }
1889 
1890 
1891 SWIGINTERNINLINE Tcl_Obj*
1892 SWIG_From_long (long value)
1893 {
1894  if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) {
1895  return Tcl_NewIntObj(static_cast< int >(value));
1896  } else {
1897  return Tcl_NewLongObj(value);
1898  }
1899 }
1900 
1901 
1902 SWIGINTERNINLINE Tcl_Obj *
1903 SWIG_From_int (int value)
1904 {
1905  return SWIG_From_long (value);
1906 }
1907 
1908 
1909 SWIGINTERN int
1910 SWIG_AsVal_bool SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, bool *val)
1911 {
1912  int v;
1913  if (Tcl_GetBooleanFromObj(0, obj, &v) == TCL_OK) {
1914  if (val) *val = v ? true : false;
1915  return SWIG_OK;
1916  }
1917  return SWIG_TypeError;
1918 }
1919 
1920 SWIGINTERN void a_screen_redraw(a_screen *self){self->render();}
1921 SWIGINTERN void a_screen_fit(a_screen *self){self->reset();}
1922 SWIGINTERN void a_screen_outputfile(a_screen *self,a_text &text){self->outputfile(text);}
1923 SWIGINTERN void a_screen_logfile(a_screen *self,a_text &text){self->logfile(text);}
1924 SWIGINTERN std::string const a_screen_layer__SWIG_0(a_screen *self,std::string const &code){
1925  if (code=="list") return self->listlayers();
1926  else if (code=="ls") return self->listlayers();
1927  else if (code=="current") return self->getlayer();
1928  else return "Wrong arg. window_name layer [list ls current]";
1929  }
1930 SWIGINTERN void a_screen_layer__SWIG_1(a_screen *self,std::string const &code,std::string const &name){
1931  if (code=="new") self->newlayer(name);
1932  else if (code=="on") self->setonlayer(name);
1933  else if (code=="off") self->setofflayer(name);
1934  else if (code=="set") self->setlayer(name);
1935  else if (code=="erase") self->eraselayer(name);
1936  else if (code=="rm") self->eraselayer(name);
1937  else if (code=="exist") self->printout(self->existlayer(name));
1938  else self->printout("Wrong arg. window_name layer (new on off set erase) name");
1939  }
1940 SWIGINTERN void a_screen_erase(a_screen *self,std::string const &code){
1941  if (code=="point") self->eraselastpoint();
1942  else if (code=="line") self->eraselastline();
1943  else if (code=="polyline") self->eraselastpolyline();
1944  else self->printout("Wrong arg. window_name erase (point line polyline)");
1945  }
1946 SWIGINTERN void a_screen_fullscreen(a_screen *self,std::string const &code){
1947  if (code=="on") self->fullscreenon();
1948  else if (code=="off") self->fullscreenoff();
1949  else self->printout("Wrong arg. window_name fullscreen code (on off)");
1950  }
1951 SWIGINTERN void a_screen_perspective(a_screen *self,std::string const &code){
1952  if (code=="on") self->perspectia_view();
1953  else if (code=="off") self->parallel_view();
1954  else self->printout("Wrong arg. window_name perspective code (on off)");
1955  }
1956 SWIGINTERN void a_screen_cursor(a_screen *self,std::string const &code){
1957  if (code=="on") self->cursor_show();
1958  else if (code=="off") self->cursor_hide();
1959  else self->printout("Wrong arg. window_name cursor code (on off)");
1960  }
1961 SWIGINTERN void a_screen_light(a_screen *self,std::string const &code){
1962  if (code=="spot") self->spotlight();
1963  else if (code=="sun") self->sunlight();
1964  else self->printout("Wrong arg. window_name light code (spot sun)");
1965  }
1966 SWIGINTERN void a_screen_import(a_screen *self,std::string const &code,std::string const &file){
1967  if (code=="pt") self->ptin(file);
1968  else if (code=="dxf") self->dxfin(file);
1969  else if (code=="vec") self->open(file);
1970  else self->printout("Wrong code. window_name import code (dxf pt vec)");
1971  }
1972 SWIGINTERN void a_screen_save(a_screen *self,std::string const &code,std::string const &file){
1973  if (code=="pt") self->ptout(file);
1974  else if (code=="dxf") self->dxfout(file);
1975  else if (code=="jpeg") self->jpgout(file);
1976  else if (code=="rib") self->ribout(file);
1977  else if (code=="png") self->pngout(file);
1978  else if (code=="vec") self->save(file);
1979  else if (code=="vrml") self->vrmlout(file);
1980  else if (code=="vtk") self->vtkout(file);
1981  else self->printout("Wrong code. window_name export code (jpeg png pt rib tif vec vrml vtk)");
1982  }
1983 SWIGINTERN void a_screen_viewpoint__SWIG_0(a_screen *self,double x,double y,double z){
1984  double pt[3];
1985  pt[0] = x; pt[1] = y; pt[2] = z;
1986  self->viewpoint(pt);
1987  }
1988 SWIGINTERN void a_screen_focalpoint__SWIG_0(a_screen *self,double x,double y,double z){
1989  double pt[3];
1990  pt[0] = x; pt[1] = y; pt[2] = z;
1991  self->focalpoint(pt);
1992  }
1994  a_point vp = self->viewpoint();
1995  std::ostringstream out;
1996  out << vp;
1997  return out.str();
1998  }
2000  a_point fp = self->focalpoint();
2001  std::ostringstream out;
2002  out << fp;
2003  return out.str();
2004  }
2005 SWIGINTERN void a_screen_pan(a_screen *self,double x,double y,double z){
2006  double pt[3];
2007  pt[0] = x; pt[1] = y; pt[2] = z;
2008  self->pan(pt);
2009  }
2010 #ifdef __cplusplus
2011 extern "C" {
2012 #endif
2013 SWIGINTERN int
2014 _wrap_new_a_screen(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2015  a_screen *result = 0 ;
2016 
2017  if (SWIG_GetArgs(interp, objc, objv,":new_a_screen ") == TCL_ERROR) SWIG_fail;
2018  try {
2019  result = (a_screen *)new a_screen();
2020  } catch(...) {
2021  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2022  }
2023  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_screen,0));
2024  return TCL_OK;
2025 fail:
2026  return TCL_ERROR;
2027 }
2028 
2029 
2030 SWIGINTERN int
2031 _wrap_delete_a_screen(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2032  a_screen *arg1 = (a_screen *) 0 ;
2033  void *argp1 = 0 ;
2034  int res1 = 0 ;
2035 
2036  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_screen self ",(void *)0) == TCL_ERROR) SWIG_fail;
2037  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, SWIG_POINTER_DISOWN | 0 );
2038  if (!SWIG_IsOK(res1)) {
2039  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_screen" "', argument " "1"" of type '" "a_screen *""'");
2040  }
2041  arg1 = reinterpret_cast< a_screen * >(argp1);
2042  delete arg1;
2043 
2044  return TCL_OK;
2045 fail:
2046  return TCL_ERROR;
2047 }
2048 
2049 
2050 SWIGINTERN int
2051 _wrap_a_screen_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2052  std::string result;
2053 
2054  if (SWIG_GetArgs(interp, objc, objv,":a_screen_help ") == TCL_ERROR) SWIG_fail;
2055  try {
2056  result = a_screen::help();
2057  } catch(...) {
2058  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2059  }
2060  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
2061  return TCL_OK;
2062 fail:
2063  return TCL_ERROR;
2064 }
2065 
2066 
2067 SWIGINTERN int
2068 _wrap_a_screen_type(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2069  a_screen *arg1 = (a_screen *) 0 ;
2070  void *argp1 = 0 ;
2071  int res1 = 0 ;
2072  std::string result;
2073 
2074  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_type self ",(void *)0) == TCL_ERROR) SWIG_fail;
2075  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2076  if (!SWIG_IsOK(res1)) {
2077  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_type" "', argument " "1"" of type '" "a_screen const *""'");
2078  }
2079  arg1 = reinterpret_cast< a_screen * >(argp1);
2080  try {
2081  result = ((a_screen const *)arg1)->type();
2082  } catch(...) {
2083  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2084  }
2085  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
2086  return TCL_OK;
2087 fail:
2088  return TCL_ERROR;
2089 }
2090 
2091 
2092 SWIGINTERN int
2093 _wrap_a_screen_existlayer__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2094  a_screen *arg1 = (a_screen *) 0 ;
2095  std::string *arg2 = 0 ;
2096  void *argp1 = 0 ;
2097  int res1 = 0 ;
2098  int res2 = SWIG_OLDOBJ ;
2099  bool result;
2100 
2101  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_existlayer self s ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2102  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2103  if (!SWIG_IsOK(res1)) {
2104  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_existlayer" "', argument " "1"" of type '" "a_screen const *""'");
2105  }
2106  arg1 = reinterpret_cast< a_screen * >(argp1);
2107  {
2108  std::string *ptr = (std::string *)0;
2109  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
2110  if (!SWIG_IsOK(res2)) {
2111  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_existlayer" "', argument " "2"" of type '" "std::string const &""'");
2112  }
2113  if (!ptr) {
2114  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_existlayer" "', argument " "2"" of type '" "std::string const &""'");
2115  }
2116  arg2 = ptr;
2117  }
2118  try {
2119  result = (bool)((a_screen const *)arg1)->existlayer((std::string const &)*arg2);
2120  } catch(...) {
2121  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2122  }
2123  Tcl_SetObjResult(interp,SWIG_From_bool(static_cast< bool >(result)));
2124  if (SWIG_IsNewObj(res2)) delete arg2;
2125  return TCL_OK;
2126 fail:
2127  if (SWIG_IsNewObj(res2)) delete arg2;
2128  return TCL_ERROR;
2129 }
2130 
2131 
2132 SWIGINTERN int
2133 _wrap_a_screen_existlayer__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2134  a_screen *arg1 = (a_screen *) 0 ;
2135  std::string *arg2 = 0 ;
2136  a_screenlayer **arg3 = 0 ;
2137  void *argp1 = 0 ;
2138  int res1 = 0 ;
2139  int res2 = SWIG_OLDOBJ ;
2140  void *argp3 = 0 ;
2141  int res3 = 0 ;
2142  bool result;
2143 
2144  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_screen_existlayer self s a_screenlayer *& ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2145  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2146  if (!SWIG_IsOK(res1)) {
2147  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_existlayer" "', argument " "1"" of type '" "a_screen const *""'");
2148  }
2149  arg1 = reinterpret_cast< a_screen * >(argp1);
2150  {
2151  std::string *ptr = (std::string *)0;
2152  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
2153  if (!SWIG_IsOK(res2)) {
2154  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_existlayer" "', argument " "2"" of type '" "std::string const &""'");
2155  }
2156  if (!ptr) {
2157  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_existlayer" "', argument " "2"" of type '" "std::string const &""'");
2158  }
2159  arg2 = ptr;
2160  }
2161  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_p_a_screenlayer, 0 );
2162  if (!SWIG_IsOK(res3)) {
2163  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_screen_existlayer" "', argument " "3"" of type '" "a_screenlayer *&""'");
2164  }
2165  if (!argp3) {
2166  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_existlayer" "', argument " "3"" of type '" "a_screenlayer *&""'");
2167  }
2168  arg3 = reinterpret_cast< a_screenlayer ** >(argp3);
2169  try {
2170  result = (bool)((a_screen const *)arg1)->existlayer((std::string const &)*arg2,*arg3);
2171  } catch(...) {
2172  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2173  }
2174  Tcl_SetObjResult(interp,SWIG_From_bool(static_cast< bool >(result)));
2175  if (SWIG_IsNewObj(res2)) delete arg2;
2176  return TCL_OK;
2177 fail:
2178  if (SWIG_IsNewObj(res2)) delete arg2;
2179  return TCL_ERROR;
2180 }
2181 
2182 
2183 SWIGINTERN int
2184 _wrap_a_screen_existlayer(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2185  Tcl_Obj *CONST *argv = objv+1;
2186  int argc = objc-1;
2187  if (argc == 2) {
2188  int _v;
2189  void *vptr = 0;
2190  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2191  _v = SWIG_CheckState(res);
2192  if (_v) {
2193  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(argv[1], (std::string**)(0));
2194  _v = SWIG_CheckState(res);
2195  if (_v) {
2196  return _wrap_a_screen_existlayer__SWIG_0(clientData, interp, objc, argv - 1);
2197  }
2198  }
2199  }
2200  if (argc == 3) {
2201  int _v;
2202  void *vptr = 0;
2203  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2204  _v = SWIG_CheckState(res);
2205  if (_v) {
2206  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(argv[1], (std::string**)(0));
2207  _v = SWIG_CheckState(res);
2208  if (_v) {
2209  void *vptr = 0;
2211  _v = SWIG_CheckState(res);
2212  if (_v) {
2213  return _wrap_a_screen_existlayer__SWIG_1(clientData, interp, objc, argv - 1);
2214  }
2215  }
2216  }
2217  }
2218 
2219  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_existlayer'.\n"
2220  " Possible C/C++ prototypes are:\n"
2221  " a_screen::existlayer(std::string const &) const\n"
2222  " a_screen::existlayer(std::string const &,a_screenlayer *&) const\n", TCL_STATIC);
2223  return TCL_ERROR;
2224 }
2225 
2226 
2227 SWIGINTERN int
2228 _wrap_a_screen_color(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2229  a_screen *arg1 = (a_screen *) 0 ;
2230  float arg2 ;
2231  float arg3 ;
2232  float arg4 ;
2233  void *argp1 = 0 ;
2234  int res1 = 0 ;
2235  float val2 ;
2236  int ecode2 = 0 ;
2237  float val3 ;
2238  int ecode3 = 0 ;
2239  float val4 ;
2240  int ecode4 = 0 ;
2241 
2242  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_screen_color self r g b ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2243  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2244  if (!SWIG_IsOK(res1)) {
2245  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_color" "', argument " "1"" of type '" "a_screen *""'");
2246  }
2247  arg1 = reinterpret_cast< a_screen * >(argp1);
2248  ecode2 = SWIG_AsVal_float SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2249  if (!SWIG_IsOK(ecode2)) {
2250  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_color" "', argument " "2"" of type '" "float""'");
2251  }
2252  arg2 = static_cast< float >(val2);
2253  ecode3 = SWIG_AsVal_float SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
2254  if (!SWIG_IsOK(ecode3)) {
2255  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_screen_color" "', argument " "3"" of type '" "float""'");
2256  }
2257  arg3 = static_cast< float >(val3);
2258  ecode4 = SWIG_AsVal_float SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
2259  if (!SWIG_IsOK(ecode4)) {
2260  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_screen_color" "', argument " "4"" of type '" "float""'");
2261  }
2262  arg4 = static_cast< float >(val4);
2263  try {
2264  (arg1)->color(arg2,arg3,arg4);
2265  } catch(...) {
2266  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2267  }
2268 
2269  return TCL_OK;
2270 fail:
2271  return TCL_ERROR;
2272 }
2273 
2274 
2275 SWIGINTERN int
2276 _wrap_a_screen_R__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2277  a_screen *arg1 = (a_screen *) 0 ;
2278  double arg2 ;
2279  void *argp1 = 0 ;
2280  int res1 = 0 ;
2281  double val2 ;
2282  int ecode2 = 0 ;
2283 
2284  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_R self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2285  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2286  if (!SWIG_IsOK(res1)) {
2287  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_R" "', argument " "1"" of type '" "a_screen *""'");
2288  }
2289  arg1 = reinterpret_cast< a_screen * >(argp1);
2290  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2291  if (!SWIG_IsOK(ecode2)) {
2292  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_R" "', argument " "2"" of type '" "double""'");
2293  }
2294  arg2 = static_cast< double >(val2);
2295  try {
2296  (arg1)->R(arg2);
2297  } catch(...) {
2298  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2299  }
2300 
2301  return TCL_OK;
2302 fail:
2303  return TCL_ERROR;
2304 }
2305 
2306 
2307 SWIGINTERN int
2308 _wrap_a_screen_G__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2309  a_screen *arg1 = (a_screen *) 0 ;
2310  double arg2 ;
2311  void *argp1 = 0 ;
2312  int res1 = 0 ;
2313  double val2 ;
2314  int ecode2 = 0 ;
2315 
2316  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_G self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2317  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2318  if (!SWIG_IsOK(res1)) {
2319  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_G" "', argument " "1"" of type '" "a_screen *""'");
2320  }
2321  arg1 = reinterpret_cast< a_screen * >(argp1);
2322  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2323  if (!SWIG_IsOK(ecode2)) {
2324  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_G" "', argument " "2"" of type '" "double""'");
2325  }
2326  arg2 = static_cast< double >(val2);
2327  try {
2328  (arg1)->G(arg2);
2329  } catch(...) {
2330  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2331  }
2332 
2333  return TCL_OK;
2334 fail:
2335  return TCL_ERROR;
2336 }
2337 
2338 
2339 SWIGINTERN int
2340 _wrap_a_screen_B__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2341  a_screen *arg1 = (a_screen *) 0 ;
2342  double arg2 ;
2343  void *argp1 = 0 ;
2344  int res1 = 0 ;
2345  double val2 ;
2346  int ecode2 = 0 ;
2347 
2348  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_B self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2349  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2350  if (!SWIG_IsOK(res1)) {
2351  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_B" "', argument " "1"" of type '" "a_screen *""'");
2352  }
2353  arg1 = reinterpret_cast< a_screen * >(argp1);
2354  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2355  if (!SWIG_IsOK(ecode2)) {
2356  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_B" "', argument " "2"" of type '" "double""'");
2357  }
2358  arg2 = static_cast< double >(val2);
2359  try {
2360  (arg1)->B(arg2);
2361  } catch(...) {
2362  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2363  }
2364 
2365  return TCL_OK;
2366 fail:
2367  return TCL_ERROR;
2368 }
2369 
2370 
2371 SWIGINTERN int
2372 _wrap_a_screen_R__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2373  a_screen *arg1 = (a_screen *) 0 ;
2374  void *argp1 = 0 ;
2375  int res1 = 0 ;
2376  double result;
2377 
2378  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_R self ",(void *)0) == TCL_ERROR) SWIG_fail;
2379  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2380  if (!SWIG_IsOK(res1)) {
2381  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_R" "', argument " "1"" of type '" "a_screen const *""'");
2382  }
2383  arg1 = reinterpret_cast< a_screen * >(argp1);
2384  try {
2385  result = (double)((a_screen const *)arg1)->R();
2386  } catch(...) {
2387  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2388  }
2389  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2390  return TCL_OK;
2391 fail:
2392  return TCL_ERROR;
2393 }
2394 
2395 
2396 SWIGINTERN int
2397 _wrap_a_screen_R(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2398  Tcl_Obj *CONST *argv = objv+1;
2399  int argc = objc-1;
2400  if (argc == 1) {
2401  int _v;
2402  void *vptr = 0;
2403  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2404  _v = SWIG_CheckState(res);
2405  if (_v) {
2406  return _wrap_a_screen_R__SWIG_1(clientData, interp, objc, argv - 1);
2407  }
2408  }
2409  if (argc == 2) {
2410  int _v;
2411  void *vptr = 0;
2412  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2413  _v = SWIG_CheckState(res);
2414  if (_v) {
2415  {
2416  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2417  _v = SWIG_CheckState(res);
2418  }
2419  if (_v) {
2420  return _wrap_a_screen_R__SWIG_0(clientData, interp, objc, argv - 1);
2421  }
2422  }
2423  }
2424 
2425  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_R'.\n"
2426  " Possible C/C++ prototypes are:\n"
2427  " a_screen::R(double)\n"
2428  " a_screen::R() const\n", TCL_STATIC);
2429  return TCL_ERROR;
2430 }
2431 
2432 
2433 SWIGINTERN int
2434 _wrap_a_screen_G__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2435  a_screen *arg1 = (a_screen *) 0 ;
2436  void *argp1 = 0 ;
2437  int res1 = 0 ;
2438  double result;
2439 
2440  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_G self ",(void *)0) == TCL_ERROR) SWIG_fail;
2441  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2442  if (!SWIG_IsOK(res1)) {
2443  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_G" "', argument " "1"" of type '" "a_screen const *""'");
2444  }
2445  arg1 = reinterpret_cast< a_screen * >(argp1);
2446  try {
2447  result = (double)((a_screen const *)arg1)->G();
2448  } catch(...) {
2449  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2450  }
2451  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2452  return TCL_OK;
2453 fail:
2454  return TCL_ERROR;
2455 }
2456 
2457 
2458 SWIGINTERN int
2459 _wrap_a_screen_G(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2460  Tcl_Obj *CONST *argv = objv+1;
2461  int argc = objc-1;
2462  if (argc == 1) {
2463  int _v;
2464  void *vptr = 0;
2465  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2466  _v = SWIG_CheckState(res);
2467  if (_v) {
2468  return _wrap_a_screen_G__SWIG_1(clientData, interp, objc, argv - 1);
2469  }
2470  }
2471  if (argc == 2) {
2472  int _v;
2473  void *vptr = 0;
2474  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2475  _v = SWIG_CheckState(res);
2476  if (_v) {
2477  {
2478  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2479  _v = SWIG_CheckState(res);
2480  }
2481  if (_v) {
2482  return _wrap_a_screen_G__SWIG_0(clientData, interp, objc, argv - 1);
2483  }
2484  }
2485  }
2486 
2487  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_G'.\n"
2488  " Possible C/C++ prototypes are:\n"
2489  " a_screen::G(double)\n"
2490  " a_screen::G() const\n", TCL_STATIC);
2491  return TCL_ERROR;
2492 }
2493 
2494 
2495 SWIGINTERN int
2496 _wrap_a_screen_B__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2497  a_screen *arg1 = (a_screen *) 0 ;
2498  void *argp1 = 0 ;
2499  int res1 = 0 ;
2500  double result;
2501 
2502  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_B self ",(void *)0) == TCL_ERROR) SWIG_fail;
2503  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2504  if (!SWIG_IsOK(res1)) {
2505  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_B" "', argument " "1"" of type '" "a_screen const *""'");
2506  }
2507  arg1 = reinterpret_cast< a_screen * >(argp1);
2508  try {
2509  result = (double)((a_screen const *)arg1)->B();
2510  } catch(...) {
2511  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2512  }
2513  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2514  return TCL_OK;
2515 fail:
2516  return TCL_ERROR;
2517 }
2518 
2519 
2520 SWIGINTERN int
2521 _wrap_a_screen_B(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2522  Tcl_Obj *CONST *argv = objv+1;
2523  int argc = objc-1;
2524  if (argc == 1) {
2525  int _v;
2526  void *vptr = 0;
2527  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2528  _v = SWIG_CheckState(res);
2529  if (_v) {
2530  return _wrap_a_screen_B__SWIG_1(clientData, interp, objc, argv - 1);
2531  }
2532  }
2533  if (argc == 2) {
2534  int _v;
2535  void *vptr = 0;
2536  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2537  _v = SWIG_CheckState(res);
2538  if (_v) {
2539  {
2540  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2541  _v = SWIG_CheckState(res);
2542  }
2543  if (_v) {
2544  return _wrap_a_screen_B__SWIG_0(clientData, interp, objc, argv - 1);
2545  }
2546  }
2547  }
2548 
2549  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_B'.\n"
2550  " Possible C/C++ prototypes are:\n"
2551  " a_screen::B(double)\n"
2552  " a_screen::B() const\n", TCL_STATIC);
2553  return TCL_ERROR;
2554 }
2555 
2556 
2557 SWIGINTERN int
2558 _wrap_a_screen_thickness__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2559  a_screen *arg1 = (a_screen *) 0 ;
2560  int arg2 ;
2561  void *argp1 = 0 ;
2562  int res1 = 0 ;
2563  int val2 ;
2564  int ecode2 = 0 ;
2565 
2566  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_thickness self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2567  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2568  if (!SWIG_IsOK(res1)) {
2569  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_thickness" "', argument " "1"" of type '" "a_screen *""'");
2570  }
2571  arg1 = reinterpret_cast< a_screen * >(argp1);
2572  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2573  if (!SWIG_IsOK(ecode2)) {
2574  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_thickness" "', argument " "2"" of type '" "int""'");
2575  }
2576  arg2 = static_cast< int >(val2);
2577  try {
2578  (arg1)->thickness(arg2);
2579  } catch(...) {
2580  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2581  }
2582 
2583  return TCL_OK;
2584 fail:
2585  return TCL_ERROR;
2586 }
2587 
2588 
2589 SWIGINTERN int
2590 _wrap_a_screen_thickness__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2591  a_screen *arg1 = (a_screen *) 0 ;
2592  void *argp1 = 0 ;
2593  int res1 = 0 ;
2594  int result;
2595 
2596  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_thickness self ",(void *)0) == TCL_ERROR) SWIG_fail;
2597  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2598  if (!SWIG_IsOK(res1)) {
2599  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_thickness" "', argument " "1"" of type '" "a_screen const *""'");
2600  }
2601  arg1 = reinterpret_cast< a_screen * >(argp1);
2602  try {
2603  result = (int)((a_screen const *)arg1)->thickness();
2604  } catch(...) {
2605  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2606  }
2607  Tcl_SetObjResult(interp,SWIG_From_int(static_cast< int >(result)));
2608  return TCL_OK;
2609 fail:
2610  return TCL_ERROR;
2611 }
2612 
2613 
2614 SWIGINTERN int
2615 _wrap_a_screen_thickness(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2616  Tcl_Obj *CONST *argv = objv+1;
2617  int argc = objc-1;
2618  if (argc == 1) {
2619  int _v;
2620  void *vptr = 0;
2621  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2622  _v = SWIG_CheckState(res);
2623  if (_v) {
2624  return _wrap_a_screen_thickness__SWIG_1(clientData, interp, objc, argv - 1);
2625  }
2626  }
2627  if (argc == 2) {
2628  int _v;
2629  void *vptr = 0;
2630  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2631  _v = SWIG_CheckState(res);
2632  if (_v) {
2633  {
2634  int res = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2635  _v = SWIG_CheckState(res);
2636  }
2637  if (_v) {
2638  return _wrap_a_screen_thickness__SWIG_0(clientData, interp, objc, argv - 1);
2639  }
2640  }
2641  }
2642 
2643  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_thickness'.\n"
2644  " Possible C/C++ prototypes are:\n"
2645  " a_screen::thickness(int const)\n"
2646  " a_screen::thickness() const\n", TCL_STATIC);
2647  return TCL_ERROR;
2648 }
2649 
2650 
2651 SWIGINTERN int
2652 _wrap_a_screen_empty__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2653  a_screen *arg1 = (a_screen *) 0 ;
2654  void *argp1 = 0 ;
2655  int res1 = 0 ;
2656  bool result;
2657 
2658  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_empty self ",(void *)0) == TCL_ERROR) SWIG_fail;
2659  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2660  if (!SWIG_IsOK(res1)) {
2661  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_empty" "', argument " "1"" of type '" "a_screen const *""'");
2662  }
2663  arg1 = reinterpret_cast< a_screen * >(argp1);
2664  try {
2665  result = (bool)((a_screen const *)arg1)->empty();
2666  } catch(...) {
2667  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2668  }
2669  Tcl_SetObjResult(interp,SWIG_From_bool(static_cast< bool >(result)));
2670  return TCL_OK;
2671 fail:
2672  return TCL_ERROR;
2673 }
2674 
2675 
2676 SWIGINTERN int
2677 _wrap_a_screen_empty__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2678  a_screen *arg1 = (a_screen *) 0 ;
2679  bool arg2 ;
2680  void *argp1 = 0 ;
2681  int res1 = 0 ;
2682  bool val2 ;
2683  int ecode2 = 0 ;
2684 
2685  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_empty self code ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2686  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2687  if (!SWIG_IsOK(res1)) {
2688  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_empty" "', argument " "1"" of type '" "a_screen *""'");
2689  }
2690  arg1 = reinterpret_cast< a_screen * >(argp1);
2691  ecode2 = SWIG_AsVal_bool SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2692  if (!SWIG_IsOK(ecode2)) {
2693  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_empty" "', argument " "2"" of type '" "bool""'");
2694  }
2695  arg2 = static_cast< bool >(val2);
2696  try {
2697  (arg1)->empty(arg2);
2698  } catch(...) {
2699  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2700  }
2701 
2702  return TCL_OK;
2703 fail:
2704  return TCL_ERROR;
2705 }
2706 
2707 
2708 SWIGINTERN int
2709 _wrap_a_screen_empty(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2710  Tcl_Obj *CONST *argv = objv+1;
2711  int argc = objc-1;
2712  if (argc == 1) {
2713  int _v;
2714  void *vptr = 0;
2715  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2716  _v = SWIG_CheckState(res);
2717  if (_v) {
2718  return _wrap_a_screen_empty__SWIG_0(clientData, interp, objc, argv - 1);
2719  }
2720  }
2721  if (argc == 2) {
2722  int _v;
2723  void *vptr = 0;
2724  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2725  _v = SWIG_CheckState(res);
2726  if (_v) {
2727  {
2728  int res = SWIG_AsVal_bool SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2729  _v = SWIG_CheckState(res);
2730  }
2731  if (_v) {
2732  return _wrap_a_screen_empty__SWIG_1(clientData, interp, objc, argv - 1);
2733  }
2734  }
2735  }
2736 
2737  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_empty'.\n"
2738  " Possible C/C++ prototypes are:\n"
2739  " a_screen::empty() const\n"
2740  " a_screen::empty(bool)\n", TCL_STATIC);
2741  return TCL_ERROR;
2742 }
2743 
2744 
2745 SWIGINTERN int
2746 _wrap_a_screen_interact(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2747  a_screen *arg1 = (a_screen *) 0 ;
2748  void *argp1 = 0 ;
2749  int res1 = 0 ;
2750 
2751  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_interact self ",(void *)0) == TCL_ERROR) SWIG_fail;
2752  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2753  if (!SWIG_IsOK(res1)) {
2754  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_interact" "', argument " "1"" of type '" "a_screen *""'");
2755  }
2756  arg1 = reinterpret_cast< a_screen * >(argp1);
2757  try {
2758  (arg1)->interact();
2759  } catch(...) {
2760  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2761  }
2762 
2763  return TCL_OK;
2764 fail:
2765  return TCL_ERROR;
2766 }
2767 
2768 
2769 SWIGINTERN int
2770 _wrap_a_screen_getinteract(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2771  a_screen *arg1 = (a_screen *) 0 ;
2772  void *argp1 = 0 ;
2773  int res1 = 0 ;
2774 
2775  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_getinteract self ",(void *)0) == TCL_ERROR) SWIG_fail;
2776  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2777  if (!SWIG_IsOK(res1)) {
2778  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_getinteract" "', argument " "1"" of type '" "a_screen *""'");
2779  }
2780  arg1 = reinterpret_cast< a_screen * >(argp1);
2781  try {
2782  (arg1)->getinteract();
2783  } catch(...) {
2784  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2785  }
2786 
2787  return TCL_OK;
2788 fail:
2789  return TCL_ERROR;
2790 }
2791 
2792 
2793 SWIGINTERN int
2794 _wrap_a_screen_point__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2795  a_screen *arg1 = (a_screen *) 0 ;
2796  a_point *arg2 = 0 ;
2797  void *argp1 = 0 ;
2798  int res1 = 0 ;
2799  void *argp2 ;
2800  int res2 = 0 ;
2801 
2802  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_point self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2803  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2804  if (!SWIG_IsOK(res1)) {
2805  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_point" "', argument " "1"" of type '" "a_screen *""'");
2806  }
2807  arg1 = reinterpret_cast< a_screen * >(argp1);
2808  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
2809  if (!SWIG_IsOK(res2)) {
2810  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_point" "', argument " "2"" of type '" "a_point const &""'");
2811  }
2812  if (!argp2) {
2813  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_point" "', argument " "2"" of type '" "a_point const &""'");
2814  }
2815  arg2 = reinterpret_cast< a_point * >(argp2);
2816  try {
2817  (arg1)->point((a_point const &)*arg2);
2818  } catch(...) {
2819  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2820  }
2821 
2822  return TCL_OK;
2823 fail:
2824  return TCL_ERROR;
2825 }
2826 
2827 
2828 SWIGINTERN int
2829 _wrap_a_screen_point__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2830  a_screen *arg1 = (a_screen *) 0 ;
2831  double arg2 ;
2832  double arg3 ;
2833  double arg4 ;
2834  void *argp1 = 0 ;
2835  int res1 = 0 ;
2836  double val2 ;
2837  int ecode2 = 0 ;
2838  double val3 ;
2839  int ecode3 = 0 ;
2840  double val4 ;
2841  int ecode4 = 0 ;
2842 
2843  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_screen_point self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2844  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2845  if (!SWIG_IsOK(res1)) {
2846  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_point" "', argument " "1"" of type '" "a_screen *""'");
2847  }
2848  arg1 = reinterpret_cast< a_screen * >(argp1);
2849  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2850  if (!SWIG_IsOK(ecode2)) {
2851  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_point" "', argument " "2"" of type '" "double""'");
2852  }
2853  arg2 = static_cast< double >(val2);
2854  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
2855  if (!SWIG_IsOK(ecode3)) {
2856  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_screen_point" "', argument " "3"" of type '" "double""'");
2857  }
2858  arg3 = static_cast< double >(val3);
2859  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
2860  if (!SWIG_IsOK(ecode4)) {
2861  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_screen_point" "', argument " "4"" of type '" "double""'");
2862  }
2863  arg4 = static_cast< double >(val4);
2864  try {
2865  (arg1)->point(arg2,arg3,arg4);
2866  } catch(...) {
2867  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2868  }
2869 
2870  return TCL_OK;
2871 fail:
2872  return TCL_ERROR;
2873 }
2874 
2875 
2876 SWIGINTERN int
2877 _wrap_a_screen_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2878  Tcl_Obj *CONST *argv = objv+1;
2879  int argc = objc-1;
2880  if (argc == 2) {
2881  int _v;
2882  void *vptr = 0;
2883  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2884  _v = SWIG_CheckState(res);
2885  if (_v) {
2886  void *vptr = 0;
2887  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
2888  _v = SWIG_CheckState(res);
2889  if (_v) {
2890  return _wrap_a_screen_point__SWIG_0(clientData, interp, objc, argv - 1);
2891  }
2892  }
2893  }
2894  if (argc == 4) {
2895  int _v;
2896  void *vptr = 0;
2897  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
2898  _v = SWIG_CheckState(res);
2899  if (_v) {
2900  {
2901  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2902  _v = SWIG_CheckState(res);
2903  }
2904  if (_v) {
2905  {
2906  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
2907  _v = SWIG_CheckState(res);
2908  }
2909  if (_v) {
2910  {
2911  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
2912  _v = SWIG_CheckState(res);
2913  }
2914  if (_v) {
2915  return _wrap_a_screen_point__SWIG_1(clientData, interp, objc, argv - 1);
2916  }
2917  }
2918  }
2919  }
2920  }
2921 
2922  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_point'.\n"
2923  " Possible C/C++ prototypes are:\n"
2924  " a_screen::point(a_point const &)\n"
2925  " a_screen::point(double,double,double)\n", TCL_STATIC);
2926  return TCL_ERROR;
2927 }
2928 
2929 
2930 SWIGINTERN int
2931 _wrap_a_screen_line__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2932  a_screen *arg1 = (a_screen *) 0 ;
2933  a_point *arg2 = 0 ;
2934  a_point *arg3 = 0 ;
2935  void *argp1 = 0 ;
2936  int res1 = 0 ;
2937  void *argp2 ;
2938  int res2 = 0 ;
2939  void *argp3 ;
2940  int res3 = 0 ;
2941 
2942  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_screen_line self p1 p2 ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2943  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
2944  if (!SWIG_IsOK(res1)) {
2945  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_line" "', argument " "1"" of type '" "a_screen *""'");
2946  }
2947  arg1 = reinterpret_cast< a_screen * >(argp1);
2948  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
2949  if (!SWIG_IsOK(res2)) {
2950  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_line" "', argument " "2"" of type '" "a_point const &""'");
2951  }
2952  if (!argp2) {
2953  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_line" "', argument " "2"" of type '" "a_point const &""'");
2954  }
2955  arg2 = reinterpret_cast< a_point * >(argp2);
2956  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_a_point, 0 );
2957  if (!SWIG_IsOK(res3)) {
2958  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_screen_line" "', argument " "3"" of type '" "a_point const &""'");
2959  }
2960  if (!argp3) {
2961  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_line" "', argument " "3"" of type '" "a_point const &""'");
2962  }
2963  arg3 = reinterpret_cast< a_point * >(argp3);
2964  try {
2965  (arg1)->line((a_point const &)*arg2,(a_point const &)*arg3);
2966  } catch(...) {
2967  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
2968  }
2969 
2970  return TCL_OK;
2971 fail:
2972  return TCL_ERROR;
2973 }
2974 
2975 
2976 SWIGINTERN int
2977 _wrap_a_screen_line__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2978  a_screen *arg1 = (a_screen *) 0 ;
2979  double arg2 ;
2980  double arg3 ;
2981  double arg4 ;
2982  double arg5 ;
2983  double arg6 ;
2984  double arg7 ;
2985  void *argp1 = 0 ;
2986  int res1 = 0 ;
2987  double val2 ;
2988  int ecode2 = 0 ;
2989  double val3 ;
2990  int ecode3 = 0 ;
2991  double val4 ;
2992  int ecode4 = 0 ;
2993  double val5 ;
2994  int ecode5 = 0 ;
2995  double val6 ;
2996  int ecode6 = 0 ;
2997  double val7 ;
2998  int ecode7 = 0 ;
2999 
3000  if (SWIG_GetArgs(interp, objc, objv,"ooooooo:a_screen_line self x1 y1 z1 x2 y2 z2 ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3001  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3002  if (!SWIG_IsOK(res1)) {
3003  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_line" "', argument " "1"" of type '" "a_screen *""'");
3004  }
3005  arg1 = reinterpret_cast< a_screen * >(argp1);
3006  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3007  if (!SWIG_IsOK(ecode2)) {
3008  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_line" "', argument " "2"" of type '" "double""'");
3009  }
3010  arg2 = static_cast< double >(val2);
3011  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3012  if (!SWIG_IsOK(ecode3)) {
3013  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_screen_line" "', argument " "3"" of type '" "double""'");
3014  }
3015  arg3 = static_cast< double >(val3);
3016  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3017  if (!SWIG_IsOK(ecode4)) {
3018  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_screen_line" "', argument " "4"" of type '" "double""'");
3019  }
3020  arg4 = static_cast< double >(val4);
3021  ecode5 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[5], &val5);
3022  if (!SWIG_IsOK(ecode5)) {
3023  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "a_screen_line" "', argument " "5"" of type '" "double""'");
3024  }
3025  arg5 = static_cast< double >(val5);
3026  ecode6 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[6], &val6);
3027  if (!SWIG_IsOK(ecode6)) {
3028  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "a_screen_line" "', argument " "6"" of type '" "double""'");
3029  }
3030  arg6 = static_cast< double >(val6);
3031  ecode7 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[7], &val7);
3032  if (!SWIG_IsOK(ecode7)) {
3033  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "a_screen_line" "', argument " "7"" of type '" "double""'");
3034  }
3035  arg7 = static_cast< double >(val7);
3036  try {
3037  (arg1)->line(arg2,arg3,arg4,arg5,arg6,arg7);
3038  } catch(...) {
3039  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3040  }
3041 
3042  return TCL_OK;
3043 fail:
3044  return TCL_ERROR;
3045 }
3046 
3047 
3048 SWIGINTERN int
3049 _wrap_a_screen_line(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3050  Tcl_Obj *CONST *argv = objv+1;
3051  int argc = objc-1;
3052  if (argc == 3) {
3053  int _v;
3054  void *vptr = 0;
3055  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3056  _v = SWIG_CheckState(res);
3057  if (_v) {
3058  void *vptr = 0;
3059  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
3060  _v = SWIG_CheckState(res);
3061  if (_v) {
3062  void *vptr = 0;
3063  int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
3064  _v = SWIG_CheckState(res);
3065  if (_v) {
3066  return _wrap_a_screen_line__SWIG_0(clientData, interp, objc, argv - 1);
3067  }
3068  }
3069  }
3070  }
3071  if (argc == 7) {
3072  int _v;
3073  void *vptr = 0;
3074  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3075  _v = SWIG_CheckState(res);
3076  if (_v) {
3077  {
3078  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3079  _v = SWIG_CheckState(res);
3080  }
3081  if (_v) {
3082  {
3083  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
3084  _v = SWIG_CheckState(res);
3085  }
3086  if (_v) {
3087  {
3088  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
3089  _v = SWIG_CheckState(res);
3090  }
3091  if (_v) {
3092  {
3093  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[4], NULL);
3094  _v = SWIG_CheckState(res);
3095  }
3096  if (_v) {
3097  {
3098  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[5], NULL);
3099  _v = SWIG_CheckState(res);
3100  }
3101  if (_v) {
3102  {
3103  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[6], NULL);
3104  _v = SWIG_CheckState(res);
3105  }
3106  if (_v) {
3107  return _wrap_a_screen_line__SWIG_1(clientData, interp, objc, argv - 1);
3108  }
3109  }
3110  }
3111  }
3112  }
3113  }
3114  }
3115  }
3116 
3117  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_line'.\n"
3118  " Possible C/C++ prototypes are:\n"
3119  " a_screen::line(a_point const &,a_point const &)\n"
3120  " a_screen::line(double,double,double,double,double,double)\n", TCL_STATIC);
3121  return TCL_ERROR;
3122 }
3123 
3124 
3125 SWIGINTERN int
3126 _wrap_a_screen_vertex__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3127  a_screen *arg1 = (a_screen *) 0 ;
3128  a_point *arg2 = 0 ;
3129  void *argp1 = 0 ;
3130  int res1 = 0 ;
3131  void *argp2 ;
3132  int res2 = 0 ;
3133 
3134  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_vertex self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3135  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3136  if (!SWIG_IsOK(res1)) {
3137  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_vertex" "', argument " "1"" of type '" "a_screen *""'");
3138  }
3139  arg1 = reinterpret_cast< a_screen * >(argp1);
3140  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
3141  if (!SWIG_IsOK(res2)) {
3142  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_vertex" "', argument " "2"" of type '" "a_point const &""'");
3143  }
3144  if (!argp2) {
3145  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_vertex" "', argument " "2"" of type '" "a_point const &""'");
3146  }
3147  arg2 = reinterpret_cast< a_point * >(argp2);
3148  try {
3149  (arg1)->vertex((a_point const &)*arg2);
3150  } catch(...) {
3151  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3152  }
3153 
3154  return TCL_OK;
3155 fail:
3156  return TCL_ERROR;
3157 }
3158 
3159 
3160 SWIGINTERN int
3161 _wrap_a_screen_vertex__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3162  a_screen *arg1 = (a_screen *) 0 ;
3163  double arg2 ;
3164  double arg3 ;
3165  double arg4 ;
3166  void *argp1 = 0 ;
3167  int res1 = 0 ;
3168  double val2 ;
3169  int ecode2 = 0 ;
3170  double val3 ;
3171  int ecode3 = 0 ;
3172  double val4 ;
3173  int ecode4 = 0 ;
3174 
3175  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_screen_vertex self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3176  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3177  if (!SWIG_IsOK(res1)) {
3178  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_vertex" "', argument " "1"" of type '" "a_screen *""'");
3179  }
3180  arg1 = reinterpret_cast< a_screen * >(argp1);
3181  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3182  if (!SWIG_IsOK(ecode2)) {
3183  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_vertex" "', argument " "2"" of type '" "double""'");
3184  }
3185  arg2 = static_cast< double >(val2);
3186  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3187  if (!SWIG_IsOK(ecode3)) {
3188  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_screen_vertex" "', argument " "3"" of type '" "double""'");
3189  }
3190  arg3 = static_cast< double >(val3);
3191  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3192  if (!SWIG_IsOK(ecode4)) {
3193  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_screen_vertex" "', argument " "4"" of type '" "double""'");
3194  }
3195  arg4 = static_cast< double >(val4);
3196  try {
3197  (arg1)->vertex(arg2,arg3,arg4);
3198  } catch(...) {
3199  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3200  }
3201 
3202  return TCL_OK;
3203 fail:
3204  return TCL_ERROR;
3205 }
3206 
3207 
3208 SWIGINTERN int
3209 _wrap_a_screen_vertex(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3210  Tcl_Obj *CONST *argv = objv+1;
3211  int argc = objc-1;
3212  if (argc == 2) {
3213  int _v;
3214  void *vptr = 0;
3215  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3216  _v = SWIG_CheckState(res);
3217  if (_v) {
3218  void *vptr = 0;
3219  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
3220  _v = SWIG_CheckState(res);
3221  if (_v) {
3222  return _wrap_a_screen_vertex__SWIG_0(clientData, interp, objc, argv - 1);
3223  }
3224  }
3225  }
3226  if (argc == 4) {
3227  int _v;
3228  void *vptr = 0;
3229  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3230  _v = SWIG_CheckState(res);
3231  if (_v) {
3232  {
3233  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3234  _v = SWIG_CheckState(res);
3235  }
3236  if (_v) {
3237  {
3238  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
3239  _v = SWIG_CheckState(res);
3240  }
3241  if (_v) {
3242  {
3243  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
3244  _v = SWIG_CheckState(res);
3245  }
3246  if (_v) {
3247  return _wrap_a_screen_vertex__SWIG_1(clientData, interp, objc, argv - 1);
3248  }
3249  }
3250  }
3251  }
3252  }
3253 
3254  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_vertex'.\n"
3255  " Possible C/C++ prototypes are:\n"
3256  " a_screen::vertex(a_point const &)\n"
3257  " a_screen::vertex(double,double,double)\n", TCL_STATIC);
3258  return TCL_ERROR;
3259 }
3260 
3261 
3262 SWIGINTERN int
3263 _wrap_a_screen_endpolyline(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3264  a_screen *arg1 = (a_screen *) 0 ;
3265  void *argp1 = 0 ;
3266  int res1 = 0 ;
3267 
3268  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_endpolyline self ",(void *)0) == TCL_ERROR) SWIG_fail;
3269  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3270  if (!SWIG_IsOK(res1)) {
3271  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_endpolyline" "', argument " "1"" of type '" "a_screen *""'");
3272  }
3273  arg1 = reinterpret_cast< a_screen * >(argp1);
3274  try {
3275  (arg1)->endpolyline();
3276  } catch(...) {
3277  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3278  }
3279 
3280  return TCL_OK;
3281 fail:
3282  return TCL_ERROR;
3283 }
3284 
3285 
3286 SWIGINTERN int
3287 _wrap_a_screen_closepolyline(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3288  a_screen *arg1 = (a_screen *) 0 ;
3289  void *argp1 = 0 ;
3290  int res1 = 0 ;
3291 
3292  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_closepolyline self ",(void *)0) == TCL_ERROR) SWIG_fail;
3293  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3294  if (!SWIG_IsOK(res1)) {
3295  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_closepolyline" "', argument " "1"" of type '" "a_screen *""'");
3296  }
3297  arg1 = reinterpret_cast< a_screen * >(argp1);
3298  try {
3299  (arg1)->closepolyline();
3300  } catch(...) {
3301  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3302  }
3303 
3304  return TCL_OK;
3305 fail:
3306  return TCL_ERROR;
3307 }
3308 
3309 
3310 SWIGINTERN int
3311 _wrap_a_screen_vertex0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3312  a_screen *arg1 = (a_screen *) 0 ;
3313  double arg2 ;
3314  double arg3 ;
3315  double arg4 ;
3316  void *argp1 = 0 ;
3317  int res1 = 0 ;
3318  double val2 ;
3319  int ecode2 = 0 ;
3320  double val3 ;
3321  int ecode3 = 0 ;
3322  double val4 ;
3323  int ecode4 = 0 ;
3324 
3325  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_screen_vertex0 self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3326  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3327  if (!SWIG_IsOK(res1)) {
3328  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_vertex0" "', argument " "1"" of type '" "a_screen *""'");
3329  }
3330  arg1 = reinterpret_cast< a_screen * >(argp1);
3331  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3332  if (!SWIG_IsOK(ecode2)) {
3333  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_vertex0" "', argument " "2"" of type '" "double""'");
3334  }
3335  arg2 = static_cast< double >(val2);
3336  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3337  if (!SWIG_IsOK(ecode3)) {
3338  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_screen_vertex0" "', argument " "3"" of type '" "double""'");
3339  }
3340  arg3 = static_cast< double >(val3);
3341  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3342  if (!SWIG_IsOK(ecode4)) {
3343  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_screen_vertex0" "', argument " "4"" of type '" "double""'");
3344  }
3345  arg4 = static_cast< double >(val4);
3346  try {
3347  (arg1)->vertex0(arg2,arg3,arg4);
3348  } catch(...) {
3349  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3350  }
3351 
3352  return TCL_OK;
3353 fail:
3354  return TCL_ERROR;
3355 }
3356 
3357 
3358 SWIGINTERN int
3359 _wrap_a_screen_endpolyline0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3360  a_screen *arg1 = (a_screen *) 0 ;
3361  void *argp1 = 0 ;
3362  int res1 = 0 ;
3363 
3364  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_endpolyline0 self ",(void *)0) == TCL_ERROR) SWIG_fail;
3365  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3366  if (!SWIG_IsOK(res1)) {
3367  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_endpolyline0" "', argument " "1"" of type '" "a_screen *""'");
3368  }
3369  arg1 = reinterpret_cast< a_screen * >(argp1);
3370  try {
3371  (arg1)->endpolyline0();
3372  } catch(...) {
3373  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3374  }
3375 
3376  return TCL_OK;
3377 fail:
3378  return TCL_ERROR;
3379 }
3380 
3381 
3382 SWIGINTERN int
3383 _wrap_a_screen_closepolyline0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3384  a_screen *arg1 = (a_screen *) 0 ;
3385  void *argp1 = 0 ;
3386  int res1 = 0 ;
3387 
3388  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_closepolyline0 self ",(void *)0) == TCL_ERROR) SWIG_fail;
3389  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3390  if (!SWIG_IsOK(res1)) {
3391  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_closepolyline0" "', argument " "1"" of type '" "a_screen *""'");
3392  }
3393  arg1 = reinterpret_cast< a_screen * >(argp1);
3394  try {
3395  (arg1)->closepolyline0();
3396  } catch(...) {
3397  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3398  }
3399 
3400  return TCL_OK;
3401 fail:
3402  return TCL_ERROR;
3403 }
3404 
3405 
3406 SWIGINTERN int
3407 _wrap_a_screen_surfacepoint__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3408  a_screen *arg1 = (a_screen *) 0 ;
3409  a_point *arg2 = 0 ;
3410  void *argp1 = 0 ;
3411  int res1 = 0 ;
3412  void *argp2 ;
3413  int res2 = 0 ;
3414 
3415  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_surfacepoint self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3416  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3417  if (!SWIG_IsOK(res1)) {
3418  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_surfacepoint" "', argument " "1"" of type '" "a_screen *""'");
3419  }
3420  arg1 = reinterpret_cast< a_screen * >(argp1);
3421  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
3422  if (!SWIG_IsOK(res2)) {
3423  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_surfacepoint" "', argument " "2"" of type '" "a_point const &""'");
3424  }
3425  if (!argp2) {
3426  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_surfacepoint" "', argument " "2"" of type '" "a_point const &""'");
3427  }
3428  arg2 = reinterpret_cast< a_point * >(argp2);
3429  try {
3430  (arg1)->surfacepoint((a_point const &)*arg2);
3431  } catch(...) {
3432  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3433  }
3434 
3435  return TCL_OK;
3436 fail:
3437  return TCL_ERROR;
3438 }
3439 
3440 
3441 SWIGINTERN int
3442 _wrap_a_screen_surfacepoint__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3443  a_screen *arg1 = (a_screen *) 0 ;
3444  double arg2 ;
3445  double arg3 ;
3446  double arg4 ;
3447  void *argp1 = 0 ;
3448  int res1 = 0 ;
3449  double val2 ;
3450  int ecode2 = 0 ;
3451  double val3 ;
3452  int ecode3 = 0 ;
3453  double val4 ;
3454  int ecode4 = 0 ;
3455 
3456  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_screen_surfacepoint self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3457  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3458  if (!SWIG_IsOK(res1)) {
3459  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_surfacepoint" "', argument " "1"" of type '" "a_screen *""'");
3460  }
3461  arg1 = reinterpret_cast< a_screen * >(argp1);
3462  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3463  if (!SWIG_IsOK(ecode2)) {
3464  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_surfacepoint" "', argument " "2"" of type '" "double""'");
3465  }
3466  arg2 = static_cast< double >(val2);
3467  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3468  if (!SWIG_IsOK(ecode3)) {
3469  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_screen_surfacepoint" "', argument " "3"" of type '" "double""'");
3470  }
3471  arg3 = static_cast< double >(val3);
3472  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3473  if (!SWIG_IsOK(ecode4)) {
3474  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_screen_surfacepoint" "', argument " "4"" of type '" "double""'");
3475  }
3476  arg4 = static_cast< double >(val4);
3477  try {
3478  (arg1)->surfacepoint(arg2,arg3,arg4);
3479  } catch(...) {
3480  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3481  }
3482 
3483  return TCL_OK;
3484 fail:
3485  return TCL_ERROR;
3486 }
3487 
3488 
3489 SWIGINTERN int
3490 _wrap_a_screen_surfacepoint(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3491  Tcl_Obj *CONST *argv = objv+1;
3492  int argc = objc-1;
3493  if (argc == 2) {
3494  int _v;
3495  void *vptr = 0;
3496  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3497  _v = SWIG_CheckState(res);
3498  if (_v) {
3499  void *vptr = 0;
3500  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
3501  _v = SWIG_CheckState(res);
3502  if (_v) {
3503  return _wrap_a_screen_surfacepoint__SWIG_0(clientData, interp, objc, argv - 1);
3504  }
3505  }
3506  }
3507  if (argc == 4) {
3508  int _v;
3509  void *vptr = 0;
3510  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3511  _v = SWIG_CheckState(res);
3512  if (_v) {
3513  {
3514  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3515  _v = SWIG_CheckState(res);
3516  }
3517  if (_v) {
3518  {
3519  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
3520  _v = SWIG_CheckState(res);
3521  }
3522  if (_v) {
3523  {
3524  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
3525  _v = SWIG_CheckState(res);
3526  }
3527  if (_v) {
3528  return _wrap_a_screen_surfacepoint__SWIG_1(clientData, interp, objc, argv - 1);
3529  }
3530  }
3531  }
3532  }
3533  }
3534 
3535  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_surfacepoint'.\n"
3536  " Possible C/C++ prototypes are:\n"
3537  " a_screen::surfacepoint(a_point const &)\n"
3538  " a_screen::surfacepoint(double,double,double)\n", TCL_STATIC);
3539  return TCL_ERROR;
3540 }
3541 
3542 
3543 SWIGINTERN int
3544 _wrap_a_screen_background(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3545  a_screen *arg1 = (a_screen *) 0 ;
3546  double arg2 ;
3547  double arg3 ;
3548  double arg4 ;
3549  void *argp1 = 0 ;
3550  int res1 = 0 ;
3551  double val2 ;
3552  int ecode2 = 0 ;
3553  double val3 ;
3554  int ecode3 = 0 ;
3555  double val4 ;
3556  int ecode4 = 0 ;
3557 
3558  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_screen_background self R G B ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3559  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3560  if (!SWIG_IsOK(res1)) {
3561  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_background" "', argument " "1"" of type '" "a_screen *""'");
3562  }
3563  arg1 = reinterpret_cast< a_screen * >(argp1);
3564  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3565  if (!SWIG_IsOK(ecode2)) {
3566  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_background" "', argument " "2"" of type '" "double""'");
3567  }
3568  arg2 = static_cast< double >(val2);
3569  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3570  if (!SWIG_IsOK(ecode3)) {
3571  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_screen_background" "', argument " "3"" of type '" "double""'");
3572  }
3573  arg3 = static_cast< double >(val3);
3574  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3575  if (!SWIG_IsOK(ecode4)) {
3576  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_screen_background" "', argument " "4"" of type '" "double""'");
3577  }
3578  arg4 = static_cast< double >(val4);
3579  try {
3580  (arg1)->background(arg2,arg3,arg4);
3581  } catch(...) {
3582  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3583  }
3584 
3585  return TCL_OK;
3586 fail:
3587  return TCL_ERROR;
3588 }
3589 
3590 
3591 SWIGINTERN int
3592 _wrap_a_screen_azimuth__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3593  a_screen *arg1 = (a_screen *) 0 ;
3594  double arg2 ;
3595  void *argp1 = 0 ;
3596  int res1 = 0 ;
3597  double val2 ;
3598  int ecode2 = 0 ;
3599 
3600  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_azimuth self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3601  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3602  if (!SWIG_IsOK(res1)) {
3603  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_azimuth" "', argument " "1"" of type '" "a_screen *""'");
3604  }
3605  arg1 = reinterpret_cast< a_screen * >(argp1);
3606  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3607  if (!SWIG_IsOK(ecode2)) {
3608  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_azimuth" "', argument " "2"" of type '" "double""'");
3609  }
3610  arg2 = static_cast< double >(val2);
3611  try {
3612  (arg1)->azimuth(arg2);
3613  } catch(...) {
3614  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3615  }
3616 
3617  return TCL_OK;
3618 fail:
3619  return TCL_ERROR;
3620 }
3621 
3622 
3623 SWIGINTERN int
3624 _wrap_a_screen_elevation__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3625  a_screen *arg1 = (a_screen *) 0 ;
3626  double arg2 ;
3627  void *argp1 = 0 ;
3628  int res1 = 0 ;
3629  double val2 ;
3630  int ecode2 = 0 ;
3631 
3632  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_elevation self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3633  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3634  if (!SWIG_IsOK(res1)) {
3635  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_elevation" "', argument " "1"" of type '" "a_screen *""'");
3636  }
3637  arg1 = reinterpret_cast< a_screen * >(argp1);
3638  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3639  if (!SWIG_IsOK(ecode2)) {
3640  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_elevation" "', argument " "2"" of type '" "double""'");
3641  }
3642  arg2 = static_cast< double >(val2);
3643  try {
3644  (arg1)->elevation(arg2);
3645  } catch(...) {
3646  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3647  }
3648 
3649  return TCL_OK;
3650 fail:
3651  return TCL_ERROR;
3652 }
3653 
3654 
3655 SWIGINTERN int
3656 _wrap_a_screen_roll__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3657  a_screen *arg1 = (a_screen *) 0 ;
3658  double arg2 ;
3659  void *argp1 = 0 ;
3660  int res1 = 0 ;
3661  double val2 ;
3662  int ecode2 = 0 ;
3663 
3664  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_roll self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3665  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3666  if (!SWIG_IsOK(res1)) {
3667  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_roll" "', argument " "1"" of type '" "a_screen *""'");
3668  }
3669  arg1 = reinterpret_cast< a_screen * >(argp1);
3670  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3671  if (!SWIG_IsOK(ecode2)) {
3672  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_roll" "', argument " "2"" of type '" "double""'");
3673  }
3674  arg2 = static_cast< double >(val2);
3675  try {
3676  (arg1)->roll(arg2);
3677  } catch(...) {
3678  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3679  }
3680 
3681  return TCL_OK;
3682 fail:
3683  return TCL_ERROR;
3684 }
3685 
3686 
3687 SWIGINTERN int
3688 _wrap_a_screen_pitch(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3689  a_screen *arg1 = (a_screen *) 0 ;
3690  double arg2 ;
3691  void *argp1 = 0 ;
3692  int res1 = 0 ;
3693  double val2 ;
3694  int ecode2 = 0 ;
3695 
3696  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_pitch self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3697  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3698  if (!SWIG_IsOK(res1)) {
3699  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_pitch" "', argument " "1"" of type '" "a_screen *""'");
3700  }
3701  arg1 = reinterpret_cast< a_screen * >(argp1);
3702  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3703  if (!SWIG_IsOK(ecode2)) {
3704  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_pitch" "', argument " "2"" of type '" "double""'");
3705  }
3706  arg2 = static_cast< double >(val2);
3707  try {
3708  (arg1)->pitch(arg2);
3709  } catch(...) {
3710  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3711  }
3712 
3713  return TCL_OK;
3714 fail:
3715  return TCL_ERROR;
3716 }
3717 
3718 
3719 SWIGINTERN int
3720 _wrap_a_screen_yaw(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3721  a_screen *arg1 = (a_screen *) 0 ;
3722  double arg2 ;
3723  void *argp1 = 0 ;
3724  int res1 = 0 ;
3725  double val2 ;
3726  int ecode2 = 0 ;
3727 
3728  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_yaw self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3729  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3730  if (!SWIG_IsOK(res1)) {
3731  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_yaw" "', argument " "1"" of type '" "a_screen *""'");
3732  }
3733  arg1 = reinterpret_cast< a_screen * >(argp1);
3734  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3735  if (!SWIG_IsOK(ecode2)) {
3736  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_yaw" "', argument " "2"" of type '" "double""'");
3737  }
3738  arg2 = static_cast< double >(val2);
3739  try {
3740  (arg1)->yaw(arg2);
3741  } catch(...) {
3742  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3743  }
3744 
3745  return TCL_OK;
3746 fail:
3747  return TCL_ERROR;
3748 }
3749 
3750 
3751 SWIGINTERN int
3752 _wrap_a_screen_distance__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3753  a_screen *arg1 = (a_screen *) 0 ;
3754  double arg2 ;
3755  void *argp1 = 0 ;
3756  int res1 = 0 ;
3757  double val2 ;
3758  int ecode2 = 0 ;
3759 
3760  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_distance self d ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3761  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3762  if (!SWIG_IsOK(res1)) {
3763  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_distance" "', argument " "1"" of type '" "a_screen *""'");
3764  }
3765  arg1 = reinterpret_cast< a_screen * >(argp1);
3766  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3767  if (!SWIG_IsOK(ecode2)) {
3768  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_distance" "', argument " "2"" of type '" "double""'");
3769  }
3770  arg2 = static_cast< double >(val2);
3771  try {
3772  (arg1)->distance(arg2);
3773  } catch(...) {
3774  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3775  }
3776 
3777  return TCL_OK;
3778 fail:
3779  return TCL_ERROR;
3780 }
3781 
3782 
3783 SWIGINTERN int
3784 _wrap_a_screen_distance0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3785  a_screen *arg1 = (a_screen *) 0 ;
3786  double arg2 ;
3787  void *argp1 = 0 ;
3788  int res1 = 0 ;
3789  double val2 ;
3790  int ecode2 = 0 ;
3791 
3792  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_distance0 self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3793  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3794  if (!SWIG_IsOK(res1)) {
3795  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_distance0" "', argument " "1"" of type '" "a_screen *""'");
3796  }
3797  arg1 = reinterpret_cast< a_screen * >(argp1);
3798  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3799  if (!SWIG_IsOK(ecode2)) {
3800  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_distance0" "', argument " "2"" of type '" "double""'");
3801  }
3802  arg2 = static_cast< double >(val2);
3803  try {
3804  (arg1)->distance0(arg2);
3805  } catch(...) {
3806  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3807  }
3808 
3809  return TCL_OK;
3810 fail:
3811  return TCL_ERROR;
3812 }
3813 
3814 
3815 SWIGINTERN int
3816 _wrap_a_screen_azimuth__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3817  a_screen *arg1 = (a_screen *) 0 ;
3818  void *argp1 = 0 ;
3819  int res1 = 0 ;
3820  double result;
3821 
3822  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_azimuth self ",(void *)0) == TCL_ERROR) SWIG_fail;
3823  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3824  if (!SWIG_IsOK(res1)) {
3825  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_azimuth" "', argument " "1"" of type '" "a_screen *""'");
3826  }
3827  arg1 = reinterpret_cast< a_screen * >(argp1);
3828  try {
3829  result = (double)(arg1)->azimuth();
3830  } catch(...) {
3831  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3832  }
3833  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3834  return TCL_OK;
3835 fail:
3836  return TCL_ERROR;
3837 }
3838 
3839 
3840 SWIGINTERN int
3841 _wrap_a_screen_azimuth(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3842  Tcl_Obj *CONST *argv = objv+1;
3843  int argc = objc-1;
3844  if (argc == 1) {
3845  int _v;
3846  void *vptr = 0;
3847  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3848  _v = SWIG_CheckState(res);
3849  if (_v) {
3850  return _wrap_a_screen_azimuth__SWIG_1(clientData, interp, objc, argv - 1);
3851  }
3852  }
3853  if (argc == 2) {
3854  int _v;
3855  void *vptr = 0;
3856  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3857  _v = SWIG_CheckState(res);
3858  if (_v) {
3859  {
3860  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3861  _v = SWIG_CheckState(res);
3862  }
3863  if (_v) {
3864  return _wrap_a_screen_azimuth__SWIG_0(clientData, interp, objc, argv - 1);
3865  }
3866  }
3867  }
3868 
3869  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_azimuth'.\n"
3870  " Possible C/C++ prototypes are:\n"
3871  " a_screen::azimuth(double)\n"
3872  " a_screen::azimuth()\n", TCL_STATIC);
3873  return TCL_ERROR;
3874 }
3875 
3876 
3877 SWIGINTERN int
3878 _wrap_a_screen_elevation__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3879  a_screen *arg1 = (a_screen *) 0 ;
3880  void *argp1 = 0 ;
3881  int res1 = 0 ;
3882  double result;
3883 
3884  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_elevation self ",(void *)0) == TCL_ERROR) SWIG_fail;
3885  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3886  if (!SWIG_IsOK(res1)) {
3887  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_elevation" "', argument " "1"" of type '" "a_screen *""'");
3888  }
3889  arg1 = reinterpret_cast< a_screen * >(argp1);
3890  try {
3891  result = (double)(arg1)->elevation();
3892  } catch(...) {
3893  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3894  }
3895  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3896  return TCL_OK;
3897 fail:
3898  return TCL_ERROR;
3899 }
3900 
3901 
3902 SWIGINTERN int
3903 _wrap_a_screen_elevation(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3904  Tcl_Obj *CONST *argv = objv+1;
3905  int argc = objc-1;
3906  if (argc == 1) {
3907  int _v;
3908  void *vptr = 0;
3909  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3910  _v = SWIG_CheckState(res);
3911  if (_v) {
3912  return _wrap_a_screen_elevation__SWIG_1(clientData, interp, objc, argv - 1);
3913  }
3914  }
3915  if (argc == 2) {
3916  int _v;
3917  void *vptr = 0;
3918  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3919  _v = SWIG_CheckState(res);
3920  if (_v) {
3921  {
3922  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3923  _v = SWIG_CheckState(res);
3924  }
3925  if (_v) {
3926  return _wrap_a_screen_elevation__SWIG_0(clientData, interp, objc, argv - 1);
3927  }
3928  }
3929  }
3930 
3931  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_elevation'.\n"
3932  " Possible C/C++ prototypes are:\n"
3933  " a_screen::elevation(double)\n"
3934  " a_screen::elevation()\n", TCL_STATIC);
3935  return TCL_ERROR;
3936 }
3937 
3938 
3939 SWIGINTERN int
3940 _wrap_a_screen_roll__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3941  a_screen *arg1 = (a_screen *) 0 ;
3942  void *argp1 = 0 ;
3943  int res1 = 0 ;
3944  double result;
3945 
3946  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_roll self ",(void *)0) == TCL_ERROR) SWIG_fail;
3947  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
3948  if (!SWIG_IsOK(res1)) {
3949  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_roll" "', argument " "1"" of type '" "a_screen *""'");
3950  }
3951  arg1 = reinterpret_cast< a_screen * >(argp1);
3952  try {
3953  result = (double)(arg1)->roll();
3954  } catch(...) {
3955  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
3956  }
3957  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3958  return TCL_OK;
3959 fail:
3960  return TCL_ERROR;
3961 }
3962 
3963 
3964 SWIGINTERN int
3965 _wrap_a_screen_roll(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3966  Tcl_Obj *CONST *argv = objv+1;
3967  int argc = objc-1;
3968  if (argc == 1) {
3969  int _v;
3970  void *vptr = 0;
3971  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3972  _v = SWIG_CheckState(res);
3973  if (_v) {
3974  return _wrap_a_screen_roll__SWIG_1(clientData, interp, objc, argv - 1);
3975  }
3976  }
3977  if (argc == 2) {
3978  int _v;
3979  void *vptr = 0;
3980  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
3981  _v = SWIG_CheckState(res);
3982  if (_v) {
3983  {
3984  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3985  _v = SWIG_CheckState(res);
3986  }
3987  if (_v) {
3988  return _wrap_a_screen_roll__SWIG_0(clientData, interp, objc, argv - 1);
3989  }
3990  }
3991  }
3992 
3993  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_roll'.\n"
3994  " Possible C/C++ prototypes are:\n"
3995  " a_screen::roll(double)\n"
3996  " a_screen::roll()\n", TCL_STATIC);
3997  return TCL_ERROR;
3998 }
3999 
4000 
4001 SWIGINTERN int
4002 _wrap_a_screen_distance__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4003  a_screen *arg1 = (a_screen *) 0 ;
4004  void *argp1 = 0 ;
4005  int res1 = 0 ;
4006  double result;
4007 
4008  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_distance self ",(void *)0) == TCL_ERROR) SWIG_fail;
4009  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4010  if (!SWIG_IsOK(res1)) {
4011  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_distance" "', argument " "1"" of type '" "a_screen *""'");
4012  }
4013  arg1 = reinterpret_cast< a_screen * >(argp1);
4014  try {
4015  result = (double)(arg1)->distance();
4016  } catch(...) {
4017  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4018  }
4019  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
4020  return TCL_OK;
4021 fail:
4022  return TCL_ERROR;
4023 }
4024 
4025 
4026 SWIGINTERN int
4027 _wrap_a_screen_distance(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4028  Tcl_Obj *CONST *argv = objv+1;
4029  int argc = objc-1;
4030  if (argc == 1) {
4031  int _v;
4032  void *vptr = 0;
4033  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
4034  _v = SWIG_CheckState(res);
4035  if (_v) {
4036  return _wrap_a_screen_distance__SWIG_1(clientData, interp, objc, argv - 1);
4037  }
4038  }
4039  if (argc == 2) {
4040  int _v;
4041  void *vptr = 0;
4042  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
4043  _v = SWIG_CheckState(res);
4044  if (_v) {
4045  {
4046  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4047  _v = SWIG_CheckState(res);
4048  }
4049  if (_v) {
4050  return _wrap_a_screen_distance__SWIG_0(clientData, interp, objc, argv - 1);
4051  }
4052  }
4053  }
4054 
4055  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_distance'.\n"
4056  " Possible C/C++ prototypes are:\n"
4057  " a_screen::distance(double)\n"
4058  " a_screen::distance()\n", TCL_STATIC);
4059  return TCL_ERROR;
4060 }
4061 
4062 
4063 SWIGINTERN int
4064 _wrap_a_screen_render_clip(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4065  a_screen *arg1 = (a_screen *) 0 ;
4066  void *argp1 = 0 ;
4067  int res1 = 0 ;
4068 
4069  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_render_clip self ",(void *)0) == TCL_ERROR) SWIG_fail;
4070  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4071  if (!SWIG_IsOK(res1)) {
4072  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_render_clip" "', argument " "1"" of type '" "a_screen *""'");
4073  }
4074  arg1 = reinterpret_cast< a_screen * >(argp1);
4075  try {
4076  (arg1)->render_clip();
4077  } catch(...) {
4078  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4079  }
4080 
4081  return TCL_OK;
4082 fail:
4083  return TCL_ERROR;
4084 }
4085 
4086 
4087 SWIGINTERN int
4088 _wrap_a_screen_redraw(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4089  a_screen *arg1 = (a_screen *) 0 ;
4090  void *argp1 = 0 ;
4091  int res1 = 0 ;
4092 
4093  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_redraw self ",(void *)0) == TCL_ERROR) SWIG_fail;
4094  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4095  if (!SWIG_IsOK(res1)) {
4096  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_redraw" "', argument " "1"" of type '" "a_screen *""'");
4097  }
4098  arg1 = reinterpret_cast< a_screen * >(argp1);
4099  try {
4100  a_screen_redraw(arg1);
4101  } catch(...) {
4102  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4103  }
4104 
4105  return TCL_OK;
4106 fail:
4107  return TCL_ERROR;
4108 }
4109 
4110 
4111 SWIGINTERN int
4112 _wrap_a_screen_fit(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4113  a_screen *arg1 = (a_screen *) 0 ;
4114  void *argp1 = 0 ;
4115  int res1 = 0 ;
4116 
4117  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_fit self ",(void *)0) == TCL_ERROR) SWIG_fail;
4118  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4119  if (!SWIG_IsOK(res1)) {
4120  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_fit" "', argument " "1"" of type '" "a_screen *""'");
4121  }
4122  arg1 = reinterpret_cast< a_screen * >(argp1);
4123  try {
4124  a_screen_fit(arg1);
4125  } catch(...) {
4126  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4127  }
4128 
4129  return TCL_OK;
4130 fail:
4131  return TCL_ERROR;
4132 }
4133 
4134 
4135 SWIGINTERN int
4136 _wrap_a_screen_outputfile(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4137  a_screen *arg1 = (a_screen *) 0 ;
4138  a_text *arg2 = 0 ;
4139  void *argp1 = 0 ;
4140  int res1 = 0 ;
4141  void *argp2 = 0 ;
4142  int res2 = 0 ;
4143 
4144  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_outputfile self text ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4145  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4146  if (!SWIG_IsOK(res1)) {
4147  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_outputfile" "', argument " "1"" of type '" "a_screen *""'");
4148  }
4149  arg1 = reinterpret_cast< a_screen * >(argp1);
4150  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_text, 0 );
4151  if (!SWIG_IsOK(res2)) {
4152  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_outputfile" "', argument " "2"" of type '" "a_text &""'");
4153  }
4154  if (!argp2) {
4155  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_outputfile" "', argument " "2"" of type '" "a_text &""'");
4156  }
4157  arg2 = reinterpret_cast< a_text * >(argp2);
4158  try {
4159  a_screen_outputfile(arg1,*arg2);
4160  } catch(...) {
4161  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4162  }
4163 
4164  return TCL_OK;
4165 fail:
4166  return TCL_ERROR;
4167 }
4168 
4169 
4170 SWIGINTERN int
4171 _wrap_a_screen_logfile(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4172  a_screen *arg1 = (a_screen *) 0 ;
4173  a_text *arg2 = 0 ;
4174  void *argp1 = 0 ;
4175  int res1 = 0 ;
4176  void *argp2 = 0 ;
4177  int res2 = 0 ;
4178 
4179  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_logfile self text ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4180  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4181  if (!SWIG_IsOK(res1)) {
4182  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_logfile" "', argument " "1"" of type '" "a_screen *""'");
4183  }
4184  arg1 = reinterpret_cast< a_screen * >(argp1);
4185  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_text, 0 );
4186  if (!SWIG_IsOK(res2)) {
4187  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_logfile" "', argument " "2"" of type '" "a_text &""'");
4188  }
4189  if (!argp2) {
4190  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_logfile" "', argument " "2"" of type '" "a_text &""'");
4191  }
4192  arg2 = reinterpret_cast< a_text * >(argp2);
4193  try {
4194  a_screen_logfile(arg1,*arg2);
4195  } catch(...) {
4196  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4197  }
4198 
4199  return TCL_OK;
4200 fail:
4201  return TCL_ERROR;
4202 }
4203 
4204 
4205 SWIGINTERN int
4206 _wrap_a_screen_layer__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4207  a_screen *arg1 = (a_screen *) 0 ;
4208  std::string *arg2 = 0 ;
4209  void *argp1 = 0 ;
4210  int res1 = 0 ;
4211  int res2 = SWIG_OLDOBJ ;
4212  std::string result;
4213 
4214  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_layer self code ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4215  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4216  if (!SWIG_IsOK(res1)) {
4217  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_layer" "', argument " "1"" of type '" "a_screen *""'");
4218  }
4219  arg1 = reinterpret_cast< a_screen * >(argp1);
4220  {
4221  std::string *ptr = (std::string *)0;
4222  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
4223  if (!SWIG_IsOK(res2)) {
4224  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_layer" "', argument " "2"" of type '" "std::string const &""'");
4225  }
4226  if (!ptr) {
4227  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_layer" "', argument " "2"" of type '" "std::string const &""'");
4228  }
4229  arg2 = ptr;
4230  }
4231  try {
4232  result = a_screen_layer__SWIG_0(arg1,(std::string const &)*arg2);
4233  } catch(...) {
4234  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4235  }
4236  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4237  if (SWIG_IsNewObj(res2)) delete arg2;
4238  return TCL_OK;
4239 fail:
4240  if (SWIG_IsNewObj(res2)) delete arg2;
4241  return TCL_ERROR;
4242 }
4243 
4244 
4245 SWIGINTERN int
4246 _wrap_a_screen_layer__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4247  a_screen *arg1 = (a_screen *) 0 ;
4248  std::string *arg2 = 0 ;
4249  std::string *arg3 = 0 ;
4250  void *argp1 = 0 ;
4251  int res1 = 0 ;
4252  int res2 = SWIG_OLDOBJ ;
4253  int res3 = SWIG_OLDOBJ ;
4254 
4255  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_screen_layer self code name ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4256  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4257  if (!SWIG_IsOK(res1)) {
4258  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_layer" "', argument " "1"" of type '" "a_screen *""'");
4259  }
4260  arg1 = reinterpret_cast< a_screen * >(argp1);
4261  {
4262  std::string *ptr = (std::string *)0;
4263  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
4264  if (!SWIG_IsOK(res2)) {
4265  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_layer" "', argument " "2"" of type '" "std::string const &""'");
4266  }
4267  if (!ptr) {
4268  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_layer" "', argument " "2"" of type '" "std::string const &""'");
4269  }
4270  arg2 = ptr;
4271  }
4272  {
4273  std::string *ptr = (std::string *)0;
4274  res3 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[3], &ptr);
4275  if (!SWIG_IsOK(res3)) {
4276  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_screen_layer" "', argument " "3"" of type '" "std::string const &""'");
4277  }
4278  if (!ptr) {
4279  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_layer" "', argument " "3"" of type '" "std::string const &""'");
4280  }
4281  arg3 = ptr;
4282  }
4283  try {
4284  a_screen_layer__SWIG_1(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
4285  } catch(...) {
4286  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4287  }
4288 
4289  if (SWIG_IsNewObj(res2)) delete arg2;
4290  if (SWIG_IsNewObj(res3)) delete arg3;
4291  return TCL_OK;
4292 fail:
4293  if (SWIG_IsNewObj(res2)) delete arg2;
4294  if (SWIG_IsNewObj(res3)) delete arg3;
4295  return TCL_ERROR;
4296 }
4297 
4298 
4299 SWIGINTERN int
4300 _wrap_a_screen_layer(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4301  Tcl_Obj *CONST *argv = objv+1;
4302  int argc = objc-1;
4303  if (argc == 2) {
4304  int _v;
4305  void *vptr = 0;
4306  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
4307  _v = SWIG_CheckState(res);
4308  if (_v) {
4309  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(argv[1], (std::string**)(0));
4310  _v = SWIG_CheckState(res);
4311  if (_v) {
4312  return _wrap_a_screen_layer__SWIG_0(clientData, interp, objc, argv - 1);
4313  }
4314  }
4315  }
4316  if (argc == 3) {
4317  int _v;
4318  void *vptr = 0;
4319  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
4320  _v = SWIG_CheckState(res);
4321  if (_v) {
4322  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(argv[1], (std::string**)(0));
4323  _v = SWIG_CheckState(res);
4324  if (_v) {
4325  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(argv[2], (std::string**)(0));
4326  _v = SWIG_CheckState(res);
4327  if (_v) {
4328  return _wrap_a_screen_layer__SWIG_1(clientData, interp, objc, argv - 1);
4329  }
4330  }
4331  }
4332  }
4333 
4334  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_layer'.\n"
4335  " Possible C/C++ prototypes are:\n"
4336  " a_screen::layer(std::string const &)\n"
4337  " a_screen::layer(std::string const &,std::string const &)\n", TCL_STATIC);
4338  return TCL_ERROR;
4339 }
4340 
4341 
4342 SWIGINTERN int
4343 _wrap_a_screen_erase(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4344  a_screen *arg1 = (a_screen *) 0 ;
4345  std::string *arg2 = 0 ;
4346  void *argp1 = 0 ;
4347  int res1 = 0 ;
4348  int res2 = SWIG_OLDOBJ ;
4349 
4350  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_erase self code ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4351  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4352  if (!SWIG_IsOK(res1)) {
4353  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_erase" "', argument " "1"" of type '" "a_screen *""'");
4354  }
4355  arg1 = reinterpret_cast< a_screen * >(argp1);
4356  {
4357  std::string *ptr = (std::string *)0;
4358  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
4359  if (!SWIG_IsOK(res2)) {
4360  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_erase" "', argument " "2"" of type '" "std::string const &""'");
4361  }
4362  if (!ptr) {
4363  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_erase" "', argument " "2"" of type '" "std::string const &""'");
4364  }
4365  arg2 = ptr;
4366  }
4367  try {
4368  a_screen_erase(arg1,(std::string const &)*arg2);
4369  } catch(...) {
4370  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4371  }
4372 
4373  if (SWIG_IsNewObj(res2)) delete arg2;
4374  return TCL_OK;
4375 fail:
4376  if (SWIG_IsNewObj(res2)) delete arg2;
4377  return TCL_ERROR;
4378 }
4379 
4380 
4381 SWIGINTERN int
4382 _wrap_a_screen_fullscreen(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4383  a_screen *arg1 = (a_screen *) 0 ;
4384  std::string *arg2 = 0 ;
4385  void *argp1 = 0 ;
4386  int res1 = 0 ;
4387  int res2 = SWIG_OLDOBJ ;
4388 
4389  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_fullscreen self code ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4390  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4391  if (!SWIG_IsOK(res1)) {
4392  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_fullscreen" "', argument " "1"" of type '" "a_screen *""'");
4393  }
4394  arg1 = reinterpret_cast< a_screen * >(argp1);
4395  {
4396  std::string *ptr = (std::string *)0;
4397  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
4398  if (!SWIG_IsOK(res2)) {
4399  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_fullscreen" "', argument " "2"" of type '" "std::string const &""'");
4400  }
4401  if (!ptr) {
4402  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_fullscreen" "', argument " "2"" of type '" "std::string const &""'");
4403  }
4404  arg2 = ptr;
4405  }
4406  try {
4407  a_screen_fullscreen(arg1,(std::string const &)*arg2);
4408  } catch(...) {
4409  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4410  }
4411 
4412  if (SWIG_IsNewObj(res2)) delete arg2;
4413  return TCL_OK;
4414 fail:
4415  if (SWIG_IsNewObj(res2)) delete arg2;
4416  return TCL_ERROR;
4417 }
4418 
4419 
4420 SWIGINTERN int
4421 _wrap_a_screen_perspective(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4422  a_screen *arg1 = (a_screen *) 0 ;
4423  std::string *arg2 = 0 ;
4424  void *argp1 = 0 ;
4425  int res1 = 0 ;
4426  int res2 = SWIG_OLDOBJ ;
4427 
4428  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_perspective self code ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4429  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4430  if (!SWIG_IsOK(res1)) {
4431  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_perspective" "', argument " "1"" of type '" "a_screen *""'");
4432  }
4433  arg1 = reinterpret_cast< a_screen * >(argp1);
4434  {
4435  std::string *ptr = (std::string *)0;
4436  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
4437  if (!SWIG_IsOK(res2)) {
4438  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_perspective" "', argument " "2"" of type '" "std::string const &""'");
4439  }
4440  if (!ptr) {
4441  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_perspective" "', argument " "2"" of type '" "std::string const &""'");
4442  }
4443  arg2 = ptr;
4444  }
4445  try {
4446  a_screen_perspective(arg1,(std::string const &)*arg2);
4447  } catch(...) {
4448  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4449  }
4450 
4451  if (SWIG_IsNewObj(res2)) delete arg2;
4452  return TCL_OK;
4453 fail:
4454  if (SWIG_IsNewObj(res2)) delete arg2;
4455  return TCL_ERROR;
4456 }
4457 
4458 
4459 SWIGINTERN int
4460 _wrap_a_screen_cursor(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4461  a_screen *arg1 = (a_screen *) 0 ;
4462  std::string *arg2 = 0 ;
4463  void *argp1 = 0 ;
4464  int res1 = 0 ;
4465  int res2 = SWIG_OLDOBJ ;
4466 
4467  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_cursor self code ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4468  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4469  if (!SWIG_IsOK(res1)) {
4470  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_cursor" "', argument " "1"" of type '" "a_screen *""'");
4471  }
4472  arg1 = reinterpret_cast< a_screen * >(argp1);
4473  {
4474  std::string *ptr = (std::string *)0;
4475  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
4476  if (!SWIG_IsOK(res2)) {
4477  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_cursor" "', argument " "2"" of type '" "std::string const &""'");
4478  }
4479  if (!ptr) {
4480  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_cursor" "', argument " "2"" of type '" "std::string const &""'");
4481  }
4482  arg2 = ptr;
4483  }
4484  try {
4485  a_screen_cursor(arg1,(std::string const &)*arg2);
4486  } catch(...) {
4487  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4488  }
4489 
4490  if (SWIG_IsNewObj(res2)) delete arg2;
4491  return TCL_OK;
4492 fail:
4493  if (SWIG_IsNewObj(res2)) delete arg2;
4494  return TCL_ERROR;
4495 }
4496 
4497 
4498 SWIGINTERN int
4499 _wrap_a_screen_light(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4500  a_screen *arg1 = (a_screen *) 0 ;
4501  std::string *arg2 = 0 ;
4502  void *argp1 = 0 ;
4503  int res1 = 0 ;
4504  int res2 = SWIG_OLDOBJ ;
4505 
4506  if (SWIG_GetArgs(interp, objc, objv,"oo:a_screen_light self code ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4507  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4508  if (!SWIG_IsOK(res1)) {
4509  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_light" "', argument " "1"" of type '" "a_screen *""'");
4510  }
4511  arg1 = reinterpret_cast< a_screen * >(argp1);
4512  {
4513  std::string *ptr = (std::string *)0;
4514  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
4515  if (!SWIG_IsOK(res2)) {
4516  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_light" "', argument " "2"" of type '" "std::string const &""'");
4517  }
4518  if (!ptr) {
4519  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_light" "', argument " "2"" of type '" "std::string const &""'");
4520  }
4521  arg2 = ptr;
4522  }
4523  try {
4524  a_screen_light(arg1,(std::string const &)*arg2);
4525  } catch(...) {
4526  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4527  }
4528 
4529  if (SWIG_IsNewObj(res2)) delete arg2;
4530  return TCL_OK;
4531 fail:
4532  if (SWIG_IsNewObj(res2)) delete arg2;
4533  return TCL_ERROR;
4534 }
4535 
4536 
4537 SWIGINTERN int
4538 _wrap_a_screen_import(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4539  a_screen *arg1 = (a_screen *) 0 ;
4540  std::string *arg2 = 0 ;
4541  std::string *arg3 = 0 ;
4542  void *argp1 = 0 ;
4543  int res1 = 0 ;
4544  int res2 = SWIG_OLDOBJ ;
4545  int res3 = SWIG_OLDOBJ ;
4546 
4547  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_screen_import self code file ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4548  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4549  if (!SWIG_IsOK(res1)) {
4550  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_import" "', argument " "1"" of type '" "a_screen *""'");
4551  }
4552  arg1 = reinterpret_cast< a_screen * >(argp1);
4553  {
4554  std::string *ptr = (std::string *)0;
4555  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
4556  if (!SWIG_IsOK(res2)) {
4557  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_import" "', argument " "2"" of type '" "std::string const &""'");
4558  }
4559  if (!ptr) {
4560  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_import" "', argument " "2"" of type '" "std::string const &""'");
4561  }
4562  arg2 = ptr;
4563  }
4564  {
4565  std::string *ptr = (std::string *)0;
4566  res3 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[3], &ptr);
4567  if (!SWIG_IsOK(res3)) {
4568  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_screen_import" "', argument " "3"" of type '" "std::string const &""'");
4569  }
4570  if (!ptr) {
4571  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_import" "', argument " "3"" of type '" "std::string const &""'");
4572  }
4573  arg3 = ptr;
4574  }
4575  try {
4576  a_screen_import(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
4577  } catch(...) {
4578  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4579  }
4580 
4581  if (SWIG_IsNewObj(res2)) delete arg2;
4582  if (SWIG_IsNewObj(res3)) delete arg3;
4583  return TCL_OK;
4584 fail:
4585  if (SWIG_IsNewObj(res2)) delete arg2;
4586  if (SWIG_IsNewObj(res3)) delete arg3;
4587  return TCL_ERROR;
4588 }
4589 
4590 
4591 SWIGINTERN int
4592 _wrap_a_screen_save(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4593  a_screen *arg1 = (a_screen *) 0 ;
4594  std::string *arg2 = 0 ;
4595  std::string *arg3 = 0 ;
4596  void *argp1 = 0 ;
4597  int res1 = 0 ;
4598  int res2 = SWIG_OLDOBJ ;
4599  int res3 = SWIG_OLDOBJ ;
4600 
4601  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_screen_save self code file ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4602  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4603  if (!SWIG_IsOK(res1)) {
4604  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_save" "', argument " "1"" of type '" "a_screen *""'");
4605  }
4606  arg1 = reinterpret_cast< a_screen * >(argp1);
4607  {
4608  std::string *ptr = (std::string *)0;
4609  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
4610  if (!SWIG_IsOK(res2)) {
4611  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_screen_save" "', argument " "2"" of type '" "std::string const &""'");
4612  }
4613  if (!ptr) {
4614  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_save" "', argument " "2"" of type '" "std::string const &""'");
4615  }
4616  arg2 = ptr;
4617  }
4618  {
4619  std::string *ptr = (std::string *)0;
4620  res3 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[3], &ptr);
4621  if (!SWIG_IsOK(res3)) {
4622  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_screen_save" "', argument " "3"" of type '" "std::string const &""'");
4623  }
4624  if (!ptr) {
4625  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_screen_save" "', argument " "3"" of type '" "std::string const &""'");
4626  }
4627  arg3 = ptr;
4628  }
4629  try {
4630  a_screen_save(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
4631  } catch(...) {
4632  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4633  }
4634 
4635  if (SWIG_IsNewObj(res2)) delete arg2;
4636  if (SWIG_IsNewObj(res3)) delete arg3;
4637  return TCL_OK;
4638 fail:
4639  if (SWIG_IsNewObj(res2)) delete arg2;
4640  if (SWIG_IsNewObj(res3)) delete arg3;
4641  return TCL_ERROR;
4642 }
4643 
4644 
4645 SWIGINTERN int
4646 _wrap_a_screen_viewpoint__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4647  a_screen *arg1 = (a_screen *) 0 ;
4648  double arg2 ;
4649  double arg3 ;
4650  double arg4 ;
4651  void *argp1 = 0 ;
4652  int res1 = 0 ;
4653  double val2 ;
4654  int ecode2 = 0 ;
4655  double val3 ;
4656  int ecode3 = 0 ;
4657  double val4 ;
4658  int ecode4 = 0 ;
4659 
4660  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_screen_viewpoint self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4661  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4662  if (!SWIG_IsOK(res1)) {
4663  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_viewpoint" "', argument " "1"" of type '" "a_screen *""'");
4664  }
4665  arg1 = reinterpret_cast< a_screen * >(argp1);
4666  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
4667  if (!SWIG_IsOK(ecode2)) {
4668  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_viewpoint" "', argument " "2"" of type '" "double""'");
4669  }
4670  arg2 = static_cast< double >(val2);
4671  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4672  if (!SWIG_IsOK(ecode3)) {
4673  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_screen_viewpoint" "', argument " "3"" of type '" "double""'");
4674  }
4675  arg3 = static_cast< double >(val3);
4676  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
4677  if (!SWIG_IsOK(ecode4)) {
4678  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_screen_viewpoint" "', argument " "4"" of type '" "double""'");
4679  }
4680  arg4 = static_cast< double >(val4);
4681  try {
4682  a_screen_viewpoint__SWIG_0(arg1,arg2,arg3,arg4);
4683  } catch(...) {
4684  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4685  }
4686 
4687  return TCL_OK;
4688 fail:
4689  return TCL_ERROR;
4690 }
4691 
4692 
4693 SWIGINTERN int
4694 _wrap_a_screen_focalpoint__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4695  a_screen *arg1 = (a_screen *) 0 ;
4696  double arg2 ;
4697  double arg3 ;
4698  double arg4 ;
4699  void *argp1 = 0 ;
4700  int res1 = 0 ;
4701  double val2 ;
4702  int ecode2 = 0 ;
4703  double val3 ;
4704  int ecode3 = 0 ;
4705  double val4 ;
4706  int ecode4 = 0 ;
4707 
4708  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_screen_focalpoint self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4709  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4710  if (!SWIG_IsOK(res1)) {
4711  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_focalpoint" "', argument " "1"" of type '" "a_screen *""'");
4712  }
4713  arg1 = reinterpret_cast< a_screen * >(argp1);
4714  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
4715  if (!SWIG_IsOK(ecode2)) {
4716  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_focalpoint" "', argument " "2"" of type '" "double""'");
4717  }
4718  arg2 = static_cast< double >(val2);
4719  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4720  if (!SWIG_IsOK(ecode3)) {
4721  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_screen_focalpoint" "', argument " "3"" of type '" "double""'");
4722  }
4723  arg3 = static_cast< double >(val3);
4724  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
4725  if (!SWIG_IsOK(ecode4)) {
4726  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_screen_focalpoint" "', argument " "4"" of type '" "double""'");
4727  }
4728  arg4 = static_cast< double >(val4);
4729  try {
4730  a_screen_focalpoint__SWIG_0(arg1,arg2,arg3,arg4);
4731  } catch(...) {
4732  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4733  }
4734 
4735  return TCL_OK;
4736 fail:
4737  return TCL_ERROR;
4738 }
4739 
4740 
4741 SWIGINTERN int
4742 _wrap_a_screen_viewpoint__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4743  a_screen *arg1 = (a_screen *) 0 ;
4744  void *argp1 = 0 ;
4745  int res1 = 0 ;
4746  std::string result;
4747 
4748  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_viewpoint self ",(void *)0) == TCL_ERROR) SWIG_fail;
4749  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4750  if (!SWIG_IsOK(res1)) {
4751  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_viewpoint" "', argument " "1"" of type '" "a_screen *""'");
4752  }
4753  arg1 = reinterpret_cast< a_screen * >(argp1);
4754  try {
4755  result = a_screen_viewpoint__SWIG_1(arg1);
4756  } catch(...) {
4757  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4758  }
4759  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4760  return TCL_OK;
4761 fail:
4762  return TCL_ERROR;
4763 }
4764 
4765 
4766 SWIGINTERN int
4767 _wrap_a_screen_viewpoint(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4768  Tcl_Obj *CONST *argv = objv+1;
4769  int argc = objc-1;
4770  if (argc == 1) {
4771  int _v;
4772  void *vptr = 0;
4773  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
4774  _v = SWIG_CheckState(res);
4775  if (_v) {
4776  return _wrap_a_screen_viewpoint__SWIG_1(clientData, interp, objc, argv - 1);
4777  }
4778  }
4779  if (argc == 4) {
4780  int _v;
4781  void *vptr = 0;
4782  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
4783  _v = SWIG_CheckState(res);
4784  if (_v) {
4785  {
4786  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4787  _v = SWIG_CheckState(res);
4788  }
4789  if (_v) {
4790  {
4791  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4792  _v = SWIG_CheckState(res);
4793  }
4794  if (_v) {
4795  {
4796  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
4797  _v = SWIG_CheckState(res);
4798  }
4799  if (_v) {
4800  return _wrap_a_screen_viewpoint__SWIG_0(clientData, interp, objc, argv - 1);
4801  }
4802  }
4803  }
4804  }
4805  }
4806 
4807  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_viewpoint'.\n"
4808  " Possible C/C++ prototypes are:\n"
4809  " a_screen::viewpoint(double,double,double)\n"
4810  " a_screen::viewpoint()\n", TCL_STATIC);
4811  return TCL_ERROR;
4812 }
4813 
4814 
4815 SWIGINTERN int
4816 _wrap_a_screen_focalpoint__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4817  a_screen *arg1 = (a_screen *) 0 ;
4818  void *argp1 = 0 ;
4819  int res1 = 0 ;
4820  std::string result;
4821 
4822  if (SWIG_GetArgs(interp, objc, objv,"o:a_screen_focalpoint self ",(void *)0) == TCL_ERROR) SWIG_fail;
4823  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4824  if (!SWIG_IsOK(res1)) {
4825  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_focalpoint" "', argument " "1"" of type '" "a_screen *""'");
4826  }
4827  arg1 = reinterpret_cast< a_screen * >(argp1);
4828  try {
4829  result = a_screen_focalpoint__SWIG_1(arg1);
4830  } catch(...) {
4831  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4832  }
4833  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4834  return TCL_OK;
4835 fail:
4836  return TCL_ERROR;
4837 }
4838 
4839 
4840 SWIGINTERN int
4841 _wrap_a_screen_focalpoint(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4842  Tcl_Obj *CONST *argv = objv+1;
4843  int argc = objc-1;
4844  if (argc == 1) {
4845  int _v;
4846  void *vptr = 0;
4847  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
4848  _v = SWIG_CheckState(res);
4849  if (_v) {
4850  return _wrap_a_screen_focalpoint__SWIG_1(clientData, interp, objc, argv - 1);
4851  }
4852  }
4853  if (argc == 4) {
4854  int _v;
4855  void *vptr = 0;
4856  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_screen, 0);
4857  _v = SWIG_CheckState(res);
4858  if (_v) {
4859  {
4860  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4861  _v = SWIG_CheckState(res);
4862  }
4863  if (_v) {
4864  {
4865  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4866  _v = SWIG_CheckState(res);
4867  }
4868  if (_v) {
4869  {
4870  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
4871  _v = SWIG_CheckState(res);
4872  }
4873  if (_v) {
4874  return _wrap_a_screen_focalpoint__SWIG_0(clientData, interp, objc, argv - 1);
4875  }
4876  }
4877  }
4878  }
4879  }
4880 
4881  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_screen_focalpoint'.\n"
4882  " Possible C/C++ prototypes are:\n"
4883  " a_screen::focalpoint(double,double,double)\n"
4884  " a_screen::focalpoint()\n", TCL_STATIC);
4885  return TCL_ERROR;
4886 }
4887 
4888 
4889 SWIGINTERN int
4890 _wrap_a_screen_pan(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4891  a_screen *arg1 = (a_screen *) 0 ;
4892  double arg2 ;
4893  double arg3 ;
4894  double arg4 ;
4895  void *argp1 = 0 ;
4896  int res1 = 0 ;
4897  double val2 ;
4898  int ecode2 = 0 ;
4899  double val3 ;
4900  int ecode3 = 0 ;
4901  double val4 ;
4902  int ecode4 = 0 ;
4903 
4904  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_screen_pan self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4905  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_screen, 0 | 0 );
4906  if (!SWIG_IsOK(res1)) {
4907  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_screen_pan" "', argument " "1"" of type '" "a_screen *""'");
4908  }
4909  arg1 = reinterpret_cast< a_screen * >(argp1);
4910  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
4911  if (!SWIG_IsOK(ecode2)) {
4912  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_screen_pan" "', argument " "2"" of type '" "double""'");
4913  }
4914  arg2 = static_cast< double >(val2);
4915  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4916  if (!SWIG_IsOK(ecode3)) {
4917  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_screen_pan" "', argument " "3"" of type '" "double""'");
4918  }
4919  arg3 = static_cast< double >(val3);
4920  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
4921  if (!SWIG_IsOK(ecode4)) {
4922  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_screen_pan" "', argument " "4"" of type '" "double""'");
4923  }
4924  arg4 = static_cast< double >(val4);
4925  try {
4926  a_screen_pan(arg1,arg2,arg3,arg4);
4927  } catch(...) {
4928  SWIG_exception_fail(SWIG_RuntimeError,"unknown exception");
4929  }
4930 
4931  return TCL_OK;
4932 fail:
4933  return TCL_ERROR;
4934 }
4935 
4936 
4938 a_screen *arg1 = (a_screen *) obj;
4939 delete arg1;
4940 }
4942  {"type", _wrap_a_screen_type},
4943  {"existlayer", _wrap_a_screen_existlayer},
4944  {"color", _wrap_a_screen_color},
4945  {"R", _wrap_a_screen_R},
4946  {"G", _wrap_a_screen_G},
4947  {"B", _wrap_a_screen_B},
4948  {"thickness", _wrap_a_screen_thickness},
4949  {"empty", _wrap_a_screen_empty},
4950  {"interact", _wrap_a_screen_interact},
4951  {"getinteract", _wrap_a_screen_getinteract},
4952  {"point", _wrap_a_screen_point},
4953  {"line", _wrap_a_screen_line},
4954  {"vertex", _wrap_a_screen_vertex},
4955  {"endpolyline", _wrap_a_screen_endpolyline},
4956  {"closepolyline", _wrap_a_screen_closepolyline},
4957  {"vertex0", _wrap_a_screen_vertex0},
4958  {"endpolyline0", _wrap_a_screen_endpolyline0},
4959  {"closepolyline0", _wrap_a_screen_closepolyline0},
4960  {"surfacepoint", _wrap_a_screen_surfacepoint},
4961  {"background", _wrap_a_screen_background},
4962  {"pitch", _wrap_a_screen_pitch},
4963  {"yaw", _wrap_a_screen_yaw},
4964  {"distance0", _wrap_a_screen_distance0},
4965  {"azimuth", _wrap_a_screen_azimuth},
4966  {"elevation", _wrap_a_screen_elevation},
4967  {"roll", _wrap_a_screen_roll},
4968  {"distance", _wrap_a_screen_distance},
4969  {"render_clip", _wrap_a_screen_render_clip},
4970  {"redraw", _wrap_a_screen_redraw},
4971  {"fit", _wrap_a_screen_fit},
4972  {"outputfile", _wrap_a_screen_outputfile},
4973  {"logfile", _wrap_a_screen_logfile},
4974  {"layer", _wrap_a_screen_layer},
4975  {"erase", _wrap_a_screen_erase},
4976  {"fullscreen", _wrap_a_screen_fullscreen},
4977  {"perspective", _wrap_a_screen_perspective},
4978  {"cursor", _wrap_a_screen_cursor},
4979  {"light", _wrap_a_screen_light},
4980  {"import", _wrap_a_screen_import},
4981  {"save", _wrap_a_screen_save},
4982  {"viewpoint", _wrap_a_screen_viewpoint},
4983  {"focalpoint", _wrap_a_screen_focalpoint},
4984  {"pan", _wrap_a_screen_pan},
4985  {0,0}
4986 };
4988  {0,0,0}
4989 };
4991 static const char * swig_a_screen_base_names[] = {0};
4993 
4995  { SWIG_prefix "new_a_screen", (swig_wrapper_func) _wrap_new_a_screen, NULL},
4996  { SWIG_prefix "delete_a_screen", (swig_wrapper_func) _wrap_delete_a_screen, NULL},
4997  { SWIG_prefix "a_screen_help", (swig_wrapper_func) _wrap_a_screen_help, NULL},
4998  { SWIG_prefix "a_screen_type", (swig_wrapper_func) _wrap_a_screen_type, NULL},
4999  { SWIG_prefix "a_screen_existlayer", (swig_wrapper_func) _wrap_a_screen_existlayer, NULL},
5000  { SWIG_prefix "a_screen_color", (swig_wrapper_func) _wrap_a_screen_color, NULL},
5001  { SWIG_prefix "a_screen_R", (swig_wrapper_func) _wrap_a_screen_R, NULL},
5002  { SWIG_prefix "a_screen_G", (swig_wrapper_func) _wrap_a_screen_G, NULL},
5003  { SWIG_prefix "a_screen_B", (swig_wrapper_func) _wrap_a_screen_B, NULL},
5004  { SWIG_prefix "a_screen_thickness", (swig_wrapper_func) _wrap_a_screen_thickness, NULL},
5005  { SWIG_prefix "a_screen_empty", (swig_wrapper_func) _wrap_a_screen_empty, NULL},
5006  { SWIG_prefix "a_screen_interact", (swig_wrapper_func) _wrap_a_screen_interact, NULL},
5007  { SWIG_prefix "a_screen_getinteract", (swig_wrapper_func) _wrap_a_screen_getinteract, NULL},
5008  { SWIG_prefix "a_screen_point", (swig_wrapper_func) _wrap_a_screen_point, NULL},
5009  { SWIG_prefix "a_screen_line", (swig_wrapper_func) _wrap_a_screen_line, NULL},
5010  { SWIG_prefix "a_screen_vertex", (swig_wrapper_func) _wrap_a_screen_vertex, NULL},
5011  { SWIG_prefix "a_screen_endpolyline", (swig_wrapper_func) _wrap_a_screen_endpolyline, NULL},
5012  { SWIG_prefix "a_screen_closepolyline", (swig_wrapper_func) _wrap_a_screen_closepolyline, NULL},
5013  { SWIG_prefix "a_screen_vertex0", (swig_wrapper_func) _wrap_a_screen_vertex0, NULL},
5014  { SWIG_prefix "a_screen_endpolyline0", (swig_wrapper_func) _wrap_a_screen_endpolyline0, NULL},
5015  { SWIG_prefix "a_screen_closepolyline0", (swig_wrapper_func) _wrap_a_screen_closepolyline0, NULL},
5016  { SWIG_prefix "a_screen_surfacepoint", (swig_wrapper_func) _wrap_a_screen_surfacepoint, NULL},
5017  { SWIG_prefix "a_screen_background", (swig_wrapper_func) _wrap_a_screen_background, NULL},
5018  { SWIG_prefix "a_screen_pitch", (swig_wrapper_func) _wrap_a_screen_pitch, NULL},
5019  { SWIG_prefix "a_screen_yaw", (swig_wrapper_func) _wrap_a_screen_yaw, NULL},
5020  { SWIG_prefix "a_screen_distance0", (swig_wrapper_func) _wrap_a_screen_distance0, NULL},
5021  { SWIG_prefix "a_screen_azimuth", (swig_wrapper_func) _wrap_a_screen_azimuth, NULL},
5022  { SWIG_prefix "a_screen_elevation", (swig_wrapper_func) _wrap_a_screen_elevation, NULL},
5023  { SWIG_prefix "a_screen_roll", (swig_wrapper_func) _wrap_a_screen_roll, NULL},
5024  { SWIG_prefix "a_screen_distance", (swig_wrapper_func) _wrap_a_screen_distance, NULL},
5025  { SWIG_prefix "a_screen_render_clip", (swig_wrapper_func) _wrap_a_screen_render_clip, NULL},
5026  { SWIG_prefix "a_screen_redraw", (swig_wrapper_func) _wrap_a_screen_redraw, NULL},
5027  { SWIG_prefix "a_screen_fit", (swig_wrapper_func) _wrap_a_screen_fit, NULL},
5028  { SWIG_prefix "a_screen_outputfile", (swig_wrapper_func) _wrap_a_screen_outputfile, NULL},
5029  { SWIG_prefix "a_screen_logfile", (swig_wrapper_func) _wrap_a_screen_logfile, NULL},
5030  { SWIG_prefix "a_screen_layer", (swig_wrapper_func) _wrap_a_screen_layer, NULL},
5031  { SWIG_prefix "a_screen_erase", (swig_wrapper_func) _wrap_a_screen_erase, NULL},
5032  { SWIG_prefix "a_screen_fullscreen", (swig_wrapper_func) _wrap_a_screen_fullscreen, NULL},
5033  { SWIG_prefix "a_screen_perspective", (swig_wrapper_func) _wrap_a_screen_perspective, NULL},
5034  { SWIG_prefix "a_screen_cursor", (swig_wrapper_func) _wrap_a_screen_cursor, NULL},
5035  { SWIG_prefix "a_screen_light", (swig_wrapper_func) _wrap_a_screen_light, NULL},
5036  { SWIG_prefix "a_screen_import", (swig_wrapper_func) _wrap_a_screen_import, NULL},
5037  { SWIG_prefix "a_screen_save", (swig_wrapper_func) _wrap_a_screen_save, NULL},
5038  { SWIG_prefix "a_screen_viewpoint", (swig_wrapper_func) _wrap_a_screen_viewpoint, NULL},
5039  { SWIG_prefix "a_screen_focalpoint", (swig_wrapper_func) _wrap_a_screen_focalpoint, NULL},
5040  { SWIG_prefix "a_screen_pan", (swig_wrapper_func) _wrap_a_screen_pan, NULL},
5042  {0, 0, 0}
5043 };
5044 
5046  {0,0,0,0}
5047 };
5048 
5050  {0,0,0,0,0,0}
5051 };
5052 
5053 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5054 
5055 static swig_type_info _swigt__p_a_point = {"_p_a_point", "a_point *", 0, 0, (void*)0, 0};
5056 static swig_type_info _swigt__p_a_screen = {"_p_a_screen", "a_screen *", 0, 0, (void*)&_wrap_class_a_screen, 0};
5057 static swig_type_info _swigt__p_a_text = {"_p_a_text", "a_text *", 0, 0, (void*)0, 0};
5058 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
5059 static swig_type_info _swigt__p_p_a_screenlayer = {"_p_p_a_screenlayer", "a_screenlayer **", 0, 0, (void*)0, 0};
5060 
5065  &_swigt__p_char,
5067 };
5068 
5069 static swig_cast_info _swigc__p_a_point[] = { {&_swigt__p_a_point, 0, 0, 0},{0, 0, 0, 0}};
5070 static swig_cast_info _swigc__p_a_screen[] = { {&_swigt__p_a_screen, 0, 0, 0},{0, 0, 0, 0}};
5071 static swig_cast_info _swigc__p_a_text[] = { {&_swigt__p_a_text, 0, 0, 0},{0, 0, 0, 0}};
5072 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
5074 
5081 };
5082 
5083 
5084 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
5085 
5086 #ifdef __cplusplus
5087 }
5088 #endif
5089 /* -----------------------------------------------------------------------------
5090  * Type initialization:
5091  * This problem is tough by the requirement that no dynamic
5092  * memory is used. Also, since swig_type_info structures store pointers to
5093  * swig_cast_info structures and swig_cast_info structures store pointers back
5094  * to swig_type_info structures, we need some lookup code at initialization.
5095  * The idea is that swig generates all the structures that are needed.
5096  * The runtime then collects these partially filled structures.
5097  * The SWIG_InitializeModule function takes these initial arrays out of
5098  * swig_module, and does all the lookup, filling in the swig_module.types
5099  * array with the correct data and linking the correct swig_cast_info
5100  * structures together.
5101  *
5102  * The generated swig_type_info structures are assigned statically to an initial
5103  * array. We just loop through that array, and handle each type individually.
5104  * First we lookup if this type has been already loaded, and if so, use the
5105  * loaded structure instead of the generated one. Then we have to fill in the
5106  * cast linked list. The cast data is initially stored in something like a
5107  * two-dimensional array. Each row corresponds to a type (there are the same
5108  * number of rows as there are in the swig_type_initial array). Each entry in
5109  * a column is one of the swig_cast_info structures for that type.
5110  * The cast_initial array is actually an array of arrays, because each row has
5111  * a variable number of columns. So to actually build the cast linked list,
5112  * we find the array of casts associated with the type, and loop through it
5113  * adding the casts to the list. The one last trick we need to do is making
5114  * sure the type pointer in the swig_cast_info struct is correct.
5115  *
5116  * First off, we lookup the cast->type name to see if it is already loaded.
5117  * There are three cases to handle:
5118  * 1) If the cast->type has already been loaded AND the type we are adding
5119  * casting info to has not been loaded (it is in this module), THEN we
5120  * replace the cast->type pointer with the type pointer that has already
5121  * been loaded.
5122  * 2) If BOTH types (the one we are adding casting info to, and the
5123  * cast->type) are loaded, THEN the cast info has already been loaded by
5124  * the previous module so we just ignore it.
5125  * 3) Finally, if cast->type has not already been loaded, then we add that
5126  * swig_cast_info to the linked list (because the cast->type) pointer will
5127  * be correct.
5128  * ----------------------------------------------------------------------------- */
5129 
5130 #ifdef __cplusplus
5131 extern "C" {
5132 #if 0
5133 } /* c-mode */
5134 #endif
5135 #endif
5136 
5137 #if 0
5138 #define SWIGRUNTIME_DEBUG
5139 #endif
5140 
5141 
5142 SWIGRUNTIME void
5143 SWIG_InitializeModule(void *clientdata) {
5144  size_t i;
5145  swig_module_info *module_head, *iter;
5146  int init;
5147 
5148  /* check to see if the circular list has been setup, if not, set it up */
5149  if (swig_module.next==0) {
5150  /* Initialize the swig_module */
5154  init = 1;
5155  } else {
5156  init = 0;
5157  }
5158 
5159  /* Try and load any already created modules */
5160  module_head = SWIG_GetModule(clientdata);
5161  if (!module_head) {
5162  /* This is the first module loaded for this interpreter */
5163  /* so set the swig module into the interpreter */
5164  SWIG_SetModule(clientdata, &swig_module);
5165  } else {
5166  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
5167  iter=module_head;
5168  do {
5169  if (iter==&swig_module) {
5170  /* Our module is already in the list, so there's nothing more to do. */
5171  return;
5172  }
5173  iter=iter->next;
5174  } while (iter!= module_head);
5175 
5176  /* otherwise we must add our module into the list */
5177  swig_module.next = module_head->next;
5178  module_head->next = &swig_module;
5179  }
5180 
5181  /* When multiple interpreters are used, a module could have already been initialized in
5182  a different interpreter, but not yet have a pointer in this interpreter.
5183  In this case, we do not want to continue adding types... everything should be
5184  set up already */
5185  if (init == 0) return;
5186 
5187  /* Now work on filling in swig_module.types */
5188 #ifdef SWIGRUNTIME_DEB