Points&Forces (survey)
Software tools facilitating the task of surveying architecture
a_canvasTCL8_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_axes swig_types[0]
1652 #define SWIGTYPE_p_a_canvas swig_types[1]
1653 #define SWIGTYPE_p_a_element swig_types[2]
1654 #define SWIGTYPE_p_a_image swig_types[3]
1655 #define SWIGTYPE_p_a_image__file_error swig_types[4]
1656 #define SWIGTYPE_p_a_linecloud swig_types[5]
1657 #define SWIGTYPE_p_a_point swig_types[6]
1658 #define SWIGTYPE_p_a_pointcloud swig_types[7]
1659 #define SWIGTYPE_p_a_text swig_types[8]
1660 #define SWIGTYPE_p_a_trianglecloud swig_types[9]
1661 #define SWIGTYPE_p_char swig_types[10]
1662 #define SWIGTYPE_p_std__ostream swig_types[11]
1663 #define SWIGTYPE_p_std__vectorT_a_point_t swig_types[12]
1665 static swig_module_info swig_module = {swig_types, 13, 0, 0, 0, 0};
1666 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1667 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1668 
1669 /* -------- TYPES TABLE (END) -------- */
1670 
1671 #define SWIG_init A_canvas_Init
1672 #define SWIG_name "a_canvas"
1673 #define SWIG_prefix ""
1674 #define SWIG_version "0.0"
1675 
1676 #define SWIGVERSION 0x040002
1677 #define SWIG_VERSION SWIGVERSION
1678 
1679 
1680 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
1681 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
1682 
1683 
1684 #include <stdexcept>
1685 
1686 
1687 
1688 #ifdef __cplusplus
1689 extern "C" {
1690 #endif
1691 #ifdef MAC_TCL
1692 #pragma export on
1693 #endif
1694 SWIGEXPORT int SWIG_init(Tcl_Interp *);
1695 #ifdef MAC_TCL
1696 #pragma export off
1697 #endif
1698 #ifdef __cplusplus
1699 }
1700 #endif
1701 
1702 /* Compatibility version for TCL stubs */
1703 #ifndef SWIG_TCL_STUBS_VERSION
1704 #define SWIG_TCL_STUBS_VERSION "8.1"
1705 #endif
1706 
1707 
1708 
1709 #include <string>
1710 
1711 
1712 #include "a_element.h"
1713 #include <sstream>
1714 
1715 
1716 SWIGINTERN int
1717 SWIG_AsCharPtrAndSize(Tcl_Obj *obj, char** cptr, size_t* psize, int *alloc)
1718 {
1719  int len = 0;
1720  char *cstr = Tcl_GetStringFromObj(obj, &len);
1721  if (cstr) {
1722  if (cptr) *cptr = cstr;
1723  if (psize) *psize = len + 1;
1724  if (alloc) *alloc = SWIG_OLDOBJ;
1725  return SWIG_OK;
1726  }
1727  return SWIG_TypeError;
1728 }
1729 
1730 
1731 SWIGINTERN int
1732 SWIG_AsPtr_std_string SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, std::string **val)
1733 {
1734  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
1735  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
1736  if (buf) {
1737  if (val) *val = new std::string(buf, size - 1);
1738  if (alloc == SWIG_NEWOBJ) delete[] buf;
1739  return SWIG_NEWOBJ;
1740  } else {
1741  if (val) *val = 0;
1742  return SWIG_OLDOBJ;
1743  }
1744  } else {
1745  static int init = 0;
1746  static swig_type_info* descriptor = 0;
1747  if (!init) {
1748  descriptor = SWIG_TypeQuery("std::string" " *");
1749  init = 1;
1750  }
1751  if (descriptor) {
1752  std::string *vptr;
1753  int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
1754  if (SWIG_IsOK(res) && val) *val = vptr;
1755  return res;
1756  }
1757  }
1758  return SWIG_ERROR;
1759 }
1760 
1761 
1762 #include <limits.h>
1763 #if !defined(SWIG_NO_LLONG_MAX)
1764 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1765 # define LLONG_MAX __LONG_LONG_MAX__
1766 # define LLONG_MIN (-LLONG_MAX - 1LL)
1767 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1768 # endif
1769 #endif
1770 
1771 
1772 SWIGINTERNINLINE Tcl_Obj *
1773 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1774 {
1775  return (size < INT_MAX) ? Tcl_NewStringObj(carray, static_cast< int >(size)) : NULL;
1776 }
1777 
1778 
1779 SWIGINTERNINLINE Tcl_Obj *
1780 SWIG_From_std_string (const std::string& s)
1781 {
1782  return SWIG_FromCharPtrAndSize(s.data(), s.size());
1783 }
1784 
1785 
1786  #define SWIG_From_bool Tcl_NewBooleanObj
1787 
1788 
1789 SWIGINTERN int
1790 SWIG_AsVal_bool SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, bool *val)
1791 {
1792  int v;
1793  if (Tcl_GetBooleanFromObj(0, obj, &v) == TCL_OK) {
1794  if (val) *val = v ? true : false;
1795  return SWIG_OK;
1796  }
1797  return SWIG_TypeError;
1798 }
1799 
1800 
1801 SWIGINTERN int
1802 SWIG_AsVal_double SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, double *val)
1803 {
1804  double v;
1805  if (Tcl_GetDoubleFromObj(0, obj, &v) == TCL_OK) {
1806  if (val) *val = v;
1807  return SWIG_OK;
1808  }
1809  return SWIG_TypeError;
1810 }
1811 
1812 
1813  #define SWIG_From_double Tcl_NewDoubleObj
1814 
1815 
1816 SWIGINTERN int
1817 SWIG_AsVal_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, long* val)
1818 {
1819  long v;
1820  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1821  if (val) *val = (long) v;
1822  return SWIG_OK;
1823  }
1824  return SWIG_TypeError;
1825 }
1826 
1827 
1828 SWIGINTERN int
1829 SWIG_AsVal_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, int *val)
1830 {
1831  long v;
1832  int res = SWIG_AsVal_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1833  if (SWIG_IsOK(res)) {
1834  if ((v < INT_MIN || v > INT_MAX)) {
1835  return SWIG_OverflowError;
1836  } else {
1837  if (val) *val = static_cast< int >(v);
1838  }
1839  }
1840  return res;
1841 }
1842 
1843 
1844 SWIGINTERNINLINE Tcl_Obj*
1845 SWIG_From_long (long value)
1846 {
1847  if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) {
1848  return Tcl_NewIntObj(static_cast< int >(value));
1849  } else {
1850  return Tcl_NewLongObj(value);
1851  }
1852 }
1853 
1854 
1855 SWIGINTERNINLINE Tcl_Obj *
1856 SWIG_From_int (int value)
1857 {
1858  return SWIG_From_long (value);
1859 }
1860 
1862  std::ostringstream out;
1863  out << self->origin();
1864  return out.str();
1865  }
1867  std::ostringstream out;
1868  out << self->place();
1869  return out.str();
1870  }
1872  std::ostringstream out;
1873  out << self->orient();
1874  return out.str();
1875  }
1877  std::ostringstream out;
1878  out << self->scale();
1879  return out.str();
1880  }
1881 SWIGINTERN std::string a_element_center(a_element const *self){
1882  std::ostringstream out;
1883  out << self->center();
1884  return out.str();
1885  }
1886 SWIGINTERN std::string a_element_bounds(a_element const *self){
1887  std::ostringstream out;
1888  out << self->minx() << " ";
1889  out << self->maxx() << " ";
1890  out << self->miny() << " ";
1891  out << self->maxy() << " ";
1892  out << self->minz() << " ";
1893  out << self->maxz();
1894  return out.str();
1895  }
1896 SWIGINTERN void a_element_relief(a_element *self,double const x1,double const y1,double const z1,double const x2,double const y2,double const z2){
1897  self->relief(a_point(x1,y1,z1),a_point(x2,y2,z2));
1898  }
1899 
1900 #include "a_axes.h"
1901 
1902 
1903 #include "a_pointcloud.h"
1904 
1905 SWIGINTERN void a_pointcloud_point__SWIG_0(a_pointcloud *self,double x,double y,double z){self->point(x,y,z); self->render();}
1906 SWIGINTERN void a_pointcloud_point__SWIG_1(a_pointcloud *self,a_point const &p){self->point(p); self->render();}
1907 
1908 #include "a_linecloud.h"
1909 
1910 SWIGINTERN void a_linecloud_line__SWIG_0(a_linecloud *self,a_point const &p1,a_point const &p2){self->addline(p1,p2); self->render();}
1911 SWIGINTERN void a_linecloud_line__SWIG_1(a_linecloud *self,double x1,double y1,double z1,double x2,double y2,double z2){
1912  self->addline(a_point(x1,y1,z1),a_point(x2,y2,z2));
1913  self->render();
1914  }
1915 
1916 #include "a_trianglecloud.h"
1917 
1918 SWIGINTERN void a_trianglecloud_triangle__SWIG_0(a_trianglecloud *self,a_point const &p1,a_point const &p2,a_point const &p3){self->addtriangle(p1,p2,p3); self->render();}
1919 SWIGINTERN void a_trianglecloud_triangle__SWIG_1(a_trianglecloud *self,double x1,double y1,double z1,double x2,double y2,double z2,double x3,double y3,double z3){
1920  self->addtriangle(a_point(x1,y1,z1),a_point(x2,y2,z2),a_point(x3,y3,z3));
1921  self->render();
1922  }
1923 
1924 #include "a_image.h"
1925 
1926 
1927 #include "a_canvas.h"
1928 #include "a_element.h"
1929 
1930 
1931 SWIGINTERN int
1932 SWIG_AsVal_unsigned_SS_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, unsigned long *val) {
1933  long v;
1934  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1935  if (v >= 0) {
1936  if (val) *val = (unsigned long) v;
1937  return SWIG_OK;
1938  }
1939  /* If v is negative, then this could be a negative number, or an
1940  unsigned value which doesn't fit in a signed long, so try to
1941  get it as a string so we can distinguish these cases. */
1942  }
1943  {
1944  int len = 0;
1945  const char *nptr = Tcl_GetStringFromObj(obj, &len);
1946  if (nptr && len > 0) {
1947  char *endptr;
1948  unsigned long v;
1949  if (*nptr == '-') return SWIG_OverflowError;
1950  errno = 0;
1951  v = strtoul(nptr, &endptr,0);
1952  if (nptr[0] == '\0' || *endptr != '\0')
1953  return SWIG_TypeError;
1954  if (v == ULONG_MAX && errno == ERANGE) {
1955  errno = 0;
1956  return SWIG_OverflowError;
1957  } else {
1958  if (*endptr == '\0') {
1959  if (val) *val = v;
1960  return SWIG_OK;
1961  }
1962  }
1963  }
1964  }
1965 
1966  return SWIG_TypeError;
1967 }
1968 
1969 
1970 SWIGINTERN int
1971 SWIG_AsVal_unsigned_SS_short SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, unsigned short *val)
1972 {
1973  unsigned long v;
1974  int res = SWIG_AsVal_unsigned_SS_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1975  if (SWIG_IsOK(res)) {
1976  if ((v > USHRT_MAX)) {
1977  return SWIG_OverflowError;
1978  } else {
1979  if (val) *val = static_cast< unsigned short >(v);
1980  }
1981  }
1982  return res;
1983 }
1984 
1985 SWIGINTERN void a_canvas_redraw(a_canvas *self){self->render();}
1986 SWIGINTERN void a_canvas_fit(a_canvas *self){self->reset();}
1987 SWIGINTERN void a_canvas_logfile__SWIG_1(a_canvas *self,a_text &text){self->logfile(text);}
1988 SWIGINTERN std::string const a_canvas_object__SWIG_0(a_canvas *self,std::string const &code){
1989  if (code=="name") return self->getelementname();
1990  else if (code=="ls") return self->listelements();
1991  else if (code=="list") return self->listelements();
1992  else return "Wrong arg. window_name object (add list get set unlink) [name]";
1993  }
1994 SWIGINTERN void a_canvas_object__SWIG_1(a_canvas *self,std::string const &code,a_element &l){
1995  if (code=="add") self->addelement(l);
1996  else self->printout("Wrong arg. window_name object (add list get set unlink) [name]");
1997  }
1998 SWIGINTERN void a_canvas_object__SWIG_2(a_canvas *self,std::string const &code,std::string const &name){
1999  if (code=="unlink") self->unlinkelement(name);
2000  else if (code=="exist") self->printout(self->existelement(name));
2001  else if (code=="set") self->setelement(name);
2002  else self->printout("Wrong arg. window_name object (add list get set unlink) [name]");
2003  }
2004 SWIGINTERN void a_canvas_object__SWIG_3(a_canvas *self,std::string const &code,std::string const &mesh,std::string const &points){
2005  if (code=="fit") self->fitelements(mesh,points);
2006  else self->printout("Wrong arg. window_name object (add list get set unlink) [name]");
2007  }
2008 SWIGINTERN void a_canvas_interact__SWIG_1(a_canvas *self,std::string const &code){
2009  if (code=="normal") self->interact();
2010  else if (code=="fit") self->fit_interact();
2011  else if (code=="deform") self->fit_deform_interact();
2012  else if (code=="cut") self->cut_interact();
2013  else self->printout("Wrong arg. window_name interact (normal fit deform cut)");
2014  }
2016  std::ostringstream out;
2017  out << self->width() << " " << self->height();
2018  return out.str();
2019  }
2020 SWIGINTERN void a_canvas_fullscreen(a_canvas *self,std::string const &code){
2021  if (code=="on") self->fullscreenon();
2022  else if (code=="off") self->fullscreenoff();
2023  else self->printout("Wrong arg. window_name fullscreen code (on off)");
2024  }
2025 SWIGINTERN void a_canvas_perspective(a_canvas *self,std::string const &code){
2026  if (code=="on") self->perspectia_view();
2027  else if (code=="off") self->parallel_view();
2028  else self->printout("Wrong arg. window_name perspective code (on off)");
2029  }
2030 SWIGINTERN void a_canvas_cursor(a_canvas *self,std::string const &code){
2031  if (code=="on") self->cursor_show();
2032  else if (code=="off") self->cursor_hide();
2033  else self->printout("Wrong arg. window_name cursor code (on off)");
2034  }
2035 SWIGINTERN void a_canvas_light(a_canvas *self,std::string const &code){
2036  if (code=="spot") self->spotlight();
2037  else if (code=="sun") self->sunlight();
2038  else self->printout("Wrong arg. window_name light code (spot sun)");
2039  }
2040 SWIGINTERN void a_canvas_save(a_canvas *self,std::string const &code,std::string const &file){
2041  if (code=="jpeg") self->jpgout(file);
2042  else if (code=="png") self->pngout(file);
2043  else if (code=="rib") self->ribout(file);
2044  else if (code=="vec") self->save(file);
2045  else if (code=="vrml") self->vrmlout(file);
2046  else if (code=="vtk") self->vtkout(file);
2047  else self->printout("Wrong code. window_name export code (jpeg pt rib tif vec vrml vtk)");
2048  }
2049 SWIGINTERN void a_canvas_camerapoint__SWIG_0(a_canvas *self,double x,double y,double z){
2050  double pt[3];
2051  pt[0] = x; pt[1] = y; pt[2] = z;
2052  self->viewpoint(pt);
2053  }
2054 SWIGINTERN void a_canvas_focalpoint__SWIG_0(a_canvas *self,double x,double y,double z){
2055  double pt[3];
2056  pt[0] = x; pt[1] = y; pt[2] = z;
2057  self->focalpoint(pt);
2058  }
2059 SWIGINTERN void a_canvas_up__SWIG_0(a_canvas *self,double x,double y,double z){
2060  double pt[3];
2061  pt[0] = x; pt[1] = y; pt[2] = z;
2062  self->up(pt);
2063  }
2065  a_point vp = self->viewpoint();
2066  std::ostringstream out;
2067  out << vp;
2068  return out.str();
2069  }
2071  a_point fp = self->focalpoint();
2072  std::ostringstream out;
2073  out << fp;
2074  return out.str();
2075  }
2077  a_point fp = self->up();
2078  std::ostringstream out;
2079  out << fp;
2080  return out.str();
2081  }
2082 SWIGINTERN void a_canvas_pan(a_canvas *self,double x,double y,double z){
2083  double pt[3];
2084  pt[0] = x; pt[1] = y; pt[2] = z;
2085  self->pan(pt);
2086  }
2087 #ifdef __cplusplus
2088 extern "C" {
2089 #endif
2090 SWIGINTERN int
2091 _wrap_new_a_element(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2092  a_element *result = 0 ;
2093 
2094  if (SWIG_GetArgs(interp, objc, objv,":new_a_element ") == TCL_ERROR) SWIG_fail;
2095  result = (a_element *)new a_element();
2096  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_element,0));
2097  return TCL_OK;
2098 fail:
2099  return TCL_ERROR;
2100 }
2101 
2102 
2103 SWIGINTERN int
2104 _wrap_delete_a_element(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2105  a_element *arg1 = (a_element *) 0 ;
2106  void *argp1 = 0 ;
2107  int res1 = 0 ;
2108 
2109  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_element self ",(void *)0) == TCL_ERROR) SWIG_fail;
2110  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, SWIG_POINTER_DISOWN | 0 );
2111  if (!SWIG_IsOK(res1)) {
2112  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_element" "', argument " "1"" of type '" "a_element *""'");
2113  }
2114  arg1 = reinterpret_cast< a_element * >(argp1);
2115  delete arg1;
2116 
2117  return TCL_OK;
2118 fail:
2119  return TCL_ERROR;
2120 }
2121 
2122 
2123 SWIGINTERN int
2124 _wrap_a_element_reset(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2125  a_element *arg1 = (a_element *) 0 ;
2126  void *argp1 = 0 ;
2127  int res1 = 0 ;
2128 
2129  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_reset self ",(void *)0) == TCL_ERROR) SWIG_fail;
2130  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2131  if (!SWIG_IsOK(res1)) {
2132  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_reset" "', argument " "1"" of type '" "a_element *""'");
2133  }
2134  arg1 = reinterpret_cast< a_element * >(argp1);
2135  (arg1)->reset();
2136 
2137  return TCL_OK;
2138 fail:
2139  return TCL_ERROR;
2140 }
2141 
2142 
2143 SWIGINTERN int
2144 _wrap_a_element_name__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2145  a_element *arg1 = (a_element *) 0 ;
2146  std::string arg2 ;
2147  void *argp1 = 0 ;
2148  int res1 = 0 ;
2149 
2150  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_name self aname ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2151  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2152  if (!SWIG_IsOK(res1)) {
2153  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_name" "', argument " "1"" of type '" "a_element *""'");
2154  }
2155  arg1 = reinterpret_cast< a_element * >(argp1);
2156  {
2157  std::string *ptr = (std::string *)0;
2158  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
2159  if (!SWIG_IsOK(res) || !ptr) {
2160  SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "a_element_name" "', argument " "2"" of type '" "std::string""'");
2161  }
2162  arg2 = *ptr;
2163  if (SWIG_IsNewObj(res)) delete ptr;
2164  }
2165  (arg1)->name(arg2);
2166 
2167  return TCL_OK;
2168 fail:
2169  return TCL_ERROR;
2170 }
2171 
2172 
2173 SWIGINTERN int
2174 _wrap_a_element_name__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2175  a_element *arg1 = (a_element *) 0 ;
2176  void *argp1 = 0 ;
2177  int res1 = 0 ;
2178  std::string result;
2179 
2180  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_name self ",(void *)0) == TCL_ERROR) SWIG_fail;
2181  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2182  if (!SWIG_IsOK(res1)) {
2183  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_name" "', argument " "1"" of type '" "a_element const *""'");
2184  }
2185  arg1 = reinterpret_cast< a_element * >(argp1);
2186  result = ((a_element const *)arg1)->name();
2187  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
2188  return TCL_OK;
2189 fail:
2190  return TCL_ERROR;
2191 }
2192 
2193 
2194 SWIGINTERN int
2195 _wrap_a_element_name(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2196  Tcl_Obj *CONST *argv = objv+1;
2197  int argc = objc-1;
2198  if (argc == 1) {
2199  int _v;
2200  void *vptr = 0;
2201  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2202  _v = SWIG_CheckState(res);
2203  if (_v) {
2204  return _wrap_a_element_name__SWIG_1(clientData, interp, objc, argv - 1);
2205  }
2206  }
2207  if (argc == 2) {
2208  int _v;
2209  void *vptr = 0;
2210  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2211  _v = SWIG_CheckState(res);
2212  if (_v) {
2213  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(argv[1], (std::string**)(0));
2214  _v = SWIG_CheckState(res);
2215  if (_v) {
2216  return _wrap_a_element_name__SWIG_0(clientData, interp, objc, argv - 1);
2217  }
2218  }
2219  }
2220 
2221  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_name'.\n"
2222  " Possible C/C++ prototypes are:\n"
2223  " a_element::name(std::string)\n"
2224  " a_element::name() const\n", TCL_STATIC);
2225  return TCL_ERROR;
2226 }
2227 
2228 
2229 SWIGINTERN int
2230 _wrap_a_element_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2231  std::string result;
2232 
2233  if (SWIG_GetArgs(interp, objc, objv,":a_element_help ") == TCL_ERROR) SWIG_fail;
2234  result = a_element::help();
2235  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
2236  return TCL_OK;
2237 fail:
2238  return TCL_ERROR;
2239 }
2240 
2241 
2242 SWIGINTERN int
2243 _wrap_a_element_empty__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2244  a_element *arg1 = (a_element *) 0 ;
2245  void *argp1 = 0 ;
2246  int res1 = 0 ;
2247  bool result;
2248 
2249  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_empty self ",(void *)0) == TCL_ERROR) SWIG_fail;
2250  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2251  if (!SWIG_IsOK(res1)) {
2252  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_empty" "', argument " "1"" of type '" "a_element const *""'");
2253  }
2254  arg1 = reinterpret_cast< a_element * >(argp1);
2255  result = (bool)((a_element const *)arg1)->empty();
2256  Tcl_SetObjResult(interp,SWIG_From_bool(static_cast< bool >(result)));
2257  return TCL_OK;
2258 fail:
2259  return TCL_ERROR;
2260 }
2261 
2262 
2263 SWIGINTERN int
2264 _wrap_a_element_empty__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2265  a_element *arg1 = (a_element *) 0 ;
2266  bool arg2 ;
2267  void *argp1 = 0 ;
2268  int res1 = 0 ;
2269  bool val2 ;
2270  int ecode2 = 0 ;
2271 
2272  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_empty self code ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2273  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2274  if (!SWIG_IsOK(res1)) {
2275  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_empty" "', argument " "1"" of type '" "a_element *""'");
2276  }
2277  arg1 = reinterpret_cast< a_element * >(argp1);
2278  ecode2 = SWIG_AsVal_bool SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2279  if (!SWIG_IsOK(ecode2)) {
2280  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_empty" "', argument " "2"" of type '" "bool""'");
2281  }
2282  arg2 = static_cast< bool >(val2);
2283  (arg1)->empty(arg2);
2284 
2285  return TCL_OK;
2286 fail:
2287  return TCL_ERROR;
2288 }
2289 
2290 
2291 SWIGINTERN int
2292 _wrap_a_element_empty(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2293  Tcl_Obj *CONST *argv = objv+1;
2294  int argc = objc-1;
2295  if (argc == 1) {
2296  int _v;
2297  void *vptr = 0;
2298  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2299  _v = SWIG_CheckState(res);
2300  if (_v) {
2301  return _wrap_a_element_empty__SWIG_0(clientData, interp, objc, argv - 1);
2302  }
2303  }
2304  if (argc == 2) {
2305  int _v;
2306  void *vptr = 0;
2307  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2308  _v = SWIG_CheckState(res);
2309  if (_v) {
2310  {
2311  int res = SWIG_AsVal_bool SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2312  _v = SWIG_CheckState(res);
2313  }
2314  if (_v) {
2315  return _wrap_a_element_empty__SWIG_1(clientData, interp, objc, argv - 1);
2316  }
2317  }
2318  }
2319 
2320  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_empty'.\n"
2321  " Possible C/C++ prototypes are:\n"
2322  " a_element::empty() const\n"
2323  " a_element::empty(bool)\n", TCL_STATIC);
2324  return TCL_ERROR;
2325 }
2326 
2327 
2328 SWIGINTERN int
2329 _wrap_a_element_color(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2330  a_element *arg1 = (a_element *) 0 ;
2331  double arg2 ;
2332  double arg3 ;
2333  double arg4 ;
2334  void *argp1 = 0 ;
2335  int res1 = 0 ;
2336  double val2 ;
2337  int ecode2 = 0 ;
2338  double val3 ;
2339  int ecode3 = 0 ;
2340  double val4 ;
2341  int ecode4 = 0 ;
2342 
2343  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_element_color self r g b ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2344  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2345  if (!SWIG_IsOK(res1)) {
2346  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_color" "', argument " "1"" of type '" "a_element *""'");
2347  }
2348  arg1 = reinterpret_cast< a_element * >(argp1);
2349  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2350  if (!SWIG_IsOK(ecode2)) {
2351  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_color" "', argument " "2"" of type '" "double""'");
2352  }
2353  arg2 = static_cast< double >(val2);
2354  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
2355  if (!SWIG_IsOK(ecode3)) {
2356  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_element_color" "', argument " "3"" of type '" "double""'");
2357  }
2358  arg3 = static_cast< double >(val3);
2359  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
2360  if (!SWIG_IsOK(ecode4)) {
2361  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_element_color" "', argument " "4"" of type '" "double""'");
2362  }
2363  arg4 = static_cast< double >(val4);
2364  (arg1)->color(arg2,arg3,arg4);
2365 
2366  return TCL_OK;
2367 fail:
2368  return TCL_ERROR;
2369 }
2370 
2371 
2372 SWIGINTERN int
2373 _wrap_a_element_R__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2374  a_element *arg1 = (a_element *) 0 ;
2375  double arg2 ;
2376  void *argp1 = 0 ;
2377  int res1 = 0 ;
2378  double val2 ;
2379  int ecode2 = 0 ;
2380 
2381  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_R self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2382  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2383  if (!SWIG_IsOK(res1)) {
2384  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_R" "', argument " "1"" of type '" "a_element *""'");
2385  }
2386  arg1 = reinterpret_cast< a_element * >(argp1);
2387  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2388  if (!SWIG_IsOK(ecode2)) {
2389  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_R" "', argument " "2"" of type '" "double""'");
2390  }
2391  arg2 = static_cast< double >(val2);
2392  (arg1)->R(arg2);
2393 
2394  return TCL_OK;
2395 fail:
2396  return TCL_ERROR;
2397 }
2398 
2399 
2400 SWIGINTERN int
2401 _wrap_a_element_G__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2402  a_element *arg1 = (a_element *) 0 ;
2403  double arg2 ;
2404  void *argp1 = 0 ;
2405  int res1 = 0 ;
2406  double val2 ;
2407  int ecode2 = 0 ;
2408 
2409  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_G self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2410  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2411  if (!SWIG_IsOK(res1)) {
2412  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_G" "', argument " "1"" of type '" "a_element *""'");
2413  }
2414  arg1 = reinterpret_cast< a_element * >(argp1);
2415  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2416  if (!SWIG_IsOK(ecode2)) {
2417  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_G" "', argument " "2"" of type '" "double""'");
2418  }
2419  arg2 = static_cast< double >(val2);
2420  (arg1)->G(arg2);
2421 
2422  return TCL_OK;
2423 fail:
2424  return TCL_ERROR;
2425 }
2426 
2427 
2428 SWIGINTERN int
2429 _wrap_a_element_B__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2430  a_element *arg1 = (a_element *) 0 ;
2431  double arg2 ;
2432  void *argp1 = 0 ;
2433  int res1 = 0 ;
2434  double val2 ;
2435  int ecode2 = 0 ;
2436 
2437  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_B self v ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2438  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2439  if (!SWIG_IsOK(res1)) {
2440  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_B" "', argument " "1"" of type '" "a_element *""'");
2441  }
2442  arg1 = reinterpret_cast< a_element * >(argp1);
2443  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2444  if (!SWIG_IsOK(ecode2)) {
2445  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_B" "', argument " "2"" of type '" "double""'");
2446  }
2447  arg2 = static_cast< double >(val2);
2448  (arg1)->B(arg2);
2449 
2450  return TCL_OK;
2451 fail:
2452  return TCL_ERROR;
2453 }
2454 
2455 
2456 SWIGINTERN int
2457 _wrap_a_element_R__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2458  a_element *arg1 = (a_element *) 0 ;
2459  void *argp1 = 0 ;
2460  int res1 = 0 ;
2461  double result;
2462 
2463  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_R self ",(void *)0) == TCL_ERROR) SWIG_fail;
2464  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2465  if (!SWIG_IsOK(res1)) {
2466  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_R" "', argument " "1"" of type '" "a_element const *""'");
2467  }
2468  arg1 = reinterpret_cast< a_element * >(argp1);
2469  result = (double)((a_element const *)arg1)->R();
2470  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2471  return TCL_OK;
2472 fail:
2473  return TCL_ERROR;
2474 }
2475 
2476 
2477 SWIGINTERN int
2478 _wrap_a_element_R(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2479  Tcl_Obj *CONST *argv = objv+1;
2480  int argc = objc-1;
2481  if (argc == 1) {
2482  int _v;
2483  void *vptr = 0;
2484  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2485  _v = SWIG_CheckState(res);
2486  if (_v) {
2487  return _wrap_a_element_R__SWIG_1(clientData, interp, objc, argv - 1);
2488  }
2489  }
2490  if (argc == 2) {
2491  int _v;
2492  void *vptr = 0;
2493  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2494  _v = SWIG_CheckState(res);
2495  if (_v) {
2496  {
2497  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2498  _v = SWIG_CheckState(res);
2499  }
2500  if (_v) {
2501  return _wrap_a_element_R__SWIG_0(clientData, interp, objc, argv - 1);
2502  }
2503  }
2504  }
2505 
2506  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_R'.\n"
2507  " Possible C/C++ prototypes are:\n"
2508  " a_element::R(double)\n"
2509  " a_element::R() const\n", TCL_STATIC);
2510  return TCL_ERROR;
2511 }
2512 
2513 
2514 SWIGINTERN int
2515 _wrap_a_element_G__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2516  a_element *arg1 = (a_element *) 0 ;
2517  void *argp1 = 0 ;
2518  int res1 = 0 ;
2519  double result;
2520 
2521  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_G self ",(void *)0) == TCL_ERROR) SWIG_fail;
2522  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2523  if (!SWIG_IsOK(res1)) {
2524  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_G" "', argument " "1"" of type '" "a_element const *""'");
2525  }
2526  arg1 = reinterpret_cast< a_element * >(argp1);
2527  result = (double)((a_element const *)arg1)->G();
2528  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2529  return TCL_OK;
2530 fail:
2531  return TCL_ERROR;
2532 }
2533 
2534 
2535 SWIGINTERN int
2536 _wrap_a_element_G(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2537  Tcl_Obj *CONST *argv = objv+1;
2538  int argc = objc-1;
2539  if (argc == 1) {
2540  int _v;
2541  void *vptr = 0;
2542  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2543  _v = SWIG_CheckState(res);
2544  if (_v) {
2545  return _wrap_a_element_G__SWIG_1(clientData, interp, objc, argv - 1);
2546  }
2547  }
2548  if (argc == 2) {
2549  int _v;
2550  void *vptr = 0;
2551  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2552  _v = SWIG_CheckState(res);
2553  if (_v) {
2554  {
2555  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2556  _v = SWIG_CheckState(res);
2557  }
2558  if (_v) {
2559  return _wrap_a_element_G__SWIG_0(clientData, interp, objc, argv - 1);
2560  }
2561  }
2562  }
2563 
2564  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_G'.\n"
2565  " Possible C/C++ prototypes are:\n"
2566  " a_element::G(double)\n"
2567  " a_element::G() const\n", TCL_STATIC);
2568  return TCL_ERROR;
2569 }
2570 
2571 
2572 SWIGINTERN int
2573 _wrap_a_element_B__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2574  a_element *arg1 = (a_element *) 0 ;
2575  void *argp1 = 0 ;
2576  int res1 = 0 ;
2577  double result;
2578 
2579  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_B self ",(void *)0) == TCL_ERROR) SWIG_fail;
2580  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2581  if (!SWIG_IsOK(res1)) {
2582  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_B" "', argument " "1"" of type '" "a_element const *""'");
2583  }
2584  arg1 = reinterpret_cast< a_element * >(argp1);
2585  result = (double)((a_element const *)arg1)->B();
2586  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
2587  return TCL_OK;
2588 fail:
2589  return TCL_ERROR;
2590 }
2591 
2592 
2593 SWIGINTERN int
2594 _wrap_a_element_B(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2595  Tcl_Obj *CONST *argv = objv+1;
2596  int argc = objc-1;
2597  if (argc == 1) {
2598  int _v;
2599  void *vptr = 0;
2600  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2601  _v = SWIG_CheckState(res);
2602  if (_v) {
2603  return _wrap_a_element_B__SWIG_1(clientData, interp, objc, argv - 1);
2604  }
2605  }
2606  if (argc == 2) {
2607  int _v;
2608  void *vptr = 0;
2609  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2610  _v = SWIG_CheckState(res);
2611  if (_v) {
2612  {
2613  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2614  _v = SWIG_CheckState(res);
2615  }
2616  if (_v) {
2617  return _wrap_a_element_B__SWIG_0(clientData, interp, objc, argv - 1);
2618  }
2619  }
2620  }
2621 
2622  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_B'.\n"
2623  " Possible C/C++ prototypes are:\n"
2624  " a_element::B(double)\n"
2625  " a_element::B() const\n", TCL_STATIC);
2626  return TCL_ERROR;
2627 }
2628 
2629 
2630 SWIGINTERN int
2631 _wrap_a_element_greyscale__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2632  a_element *arg1 = (a_element *) 0 ;
2633  bool arg2 ;
2634  void *argp1 = 0 ;
2635  int res1 = 0 ;
2636  bool val2 ;
2637  int ecode2 = 0 ;
2638 
2639  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_greyscale self bool ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2640  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2641  if (!SWIG_IsOK(res1)) {
2642  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_greyscale" "', argument " "1"" of type '" "a_element *""'");
2643  }
2644  arg1 = reinterpret_cast< a_element * >(argp1);
2645  ecode2 = SWIG_AsVal_bool SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2646  if (!SWIG_IsOK(ecode2)) {
2647  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_greyscale" "', argument " "2"" of type '" "bool""'");
2648  }
2649  arg2 = static_cast< bool >(val2);
2650  (arg1)->greyscale(arg2);
2651 
2652  return TCL_OK;
2653 fail:
2654  return TCL_ERROR;
2655 }
2656 
2657 
2658 SWIGINTERN int
2659 _wrap_a_element_zebra(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2660  a_element *arg1 = (a_element *) 0 ;
2661  bool arg2 ;
2662  void *argp1 = 0 ;
2663  int res1 = 0 ;
2664  bool val2 ;
2665  int ecode2 = 0 ;
2666 
2667  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_zebra self bool ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2668  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2669  if (!SWIG_IsOK(res1)) {
2670  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_zebra" "', argument " "1"" of type '" "a_element *""'");
2671  }
2672  arg1 = reinterpret_cast< a_element * >(argp1);
2673  ecode2 = SWIG_AsVal_bool SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2674  if (!SWIG_IsOK(ecode2)) {
2675  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_zebra" "', argument " "2"" of type '" "bool""'");
2676  }
2677  arg2 = static_cast< bool >(val2);
2678  (arg1)->zebra(arg2);
2679 
2680  return TCL_OK;
2681 fail:
2682  return TCL_ERROR;
2683 }
2684 
2685 
2686 SWIGINTERN int
2687 _wrap_a_element_greyscale__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2688  a_element *arg1 = (a_element *) 0 ;
2689  void *argp1 = 0 ;
2690  int res1 = 0 ;
2691  bool result;
2692 
2693  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_greyscale self ",(void *)0) == TCL_ERROR) SWIG_fail;
2694  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2695  if (!SWIG_IsOK(res1)) {
2696  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_greyscale" "', argument " "1"" of type '" "a_element const *""'");
2697  }
2698  arg1 = reinterpret_cast< a_element * >(argp1);
2699  result = (bool)((a_element const *)arg1)->greyscale();
2700  Tcl_SetObjResult(interp,SWIG_From_bool(static_cast< bool >(result)));
2701  return TCL_OK;
2702 fail:
2703  return TCL_ERROR;
2704 }
2705 
2706 
2707 SWIGINTERN int
2708 _wrap_a_element_greyscale(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2709  Tcl_Obj *CONST *argv = objv+1;
2710  int argc = objc-1;
2711  if (argc == 1) {
2712  int _v;
2713  void *vptr = 0;
2714  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2715  _v = SWIG_CheckState(res);
2716  if (_v) {
2717  return _wrap_a_element_greyscale__SWIG_1(clientData, interp, objc, argv - 1);
2718  }
2719  }
2720  if (argc == 2) {
2721  int _v;
2722  void *vptr = 0;
2723  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2724  _v = SWIG_CheckState(res);
2725  if (_v) {
2726  {
2727  int res = SWIG_AsVal_bool SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2728  _v = SWIG_CheckState(res);
2729  }
2730  if (_v) {
2731  return _wrap_a_element_greyscale__SWIG_0(clientData, interp, objc, argv - 1);
2732  }
2733  }
2734  }
2735 
2736  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_greyscale'.\n"
2737  " Possible C/C++ prototypes are:\n"
2738  " a_element::greyscale(bool)\n"
2739  " a_element::greyscale() const\n", TCL_STATIC);
2740  return TCL_ERROR;
2741 }
2742 
2743 
2744 SWIGINTERN int
2745 _wrap_a_element_steps__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2746  a_element *arg1 = (a_element *) 0 ;
2747  int arg2 ;
2748  void *argp1 = 0 ;
2749  int res1 = 0 ;
2750  int val2 ;
2751  int ecode2 = 0 ;
2752 
2753  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_steps self int const ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2754  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2755  if (!SWIG_IsOK(res1)) {
2756  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_steps" "', argument " "1"" of type '" "a_element *""'");
2757  }
2758  arg1 = reinterpret_cast< a_element * >(argp1);
2759  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2760  if (!SWIG_IsOK(ecode2)) {
2761  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_steps" "', argument " "2"" of type '" "int""'");
2762  }
2763  arg2 = static_cast< int >(val2);
2764  (arg1)->steps(arg2);
2765 
2766  return TCL_OK;
2767 fail:
2768  return TCL_ERROR;
2769 }
2770 
2771 
2772 SWIGINTERN int
2773 _wrap_a_element_steps__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2774  a_element *arg1 = (a_element *) 0 ;
2775  void *argp1 = 0 ;
2776  int res1 = 0 ;
2777  int result;
2778 
2779  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_steps self ",(void *)0) == TCL_ERROR) SWIG_fail;
2780  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2781  if (!SWIG_IsOK(res1)) {
2782  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_steps" "', argument " "1"" of type '" "a_element const *""'");
2783  }
2784  arg1 = reinterpret_cast< a_element * >(argp1);
2785  result = (int)((a_element const *)arg1)->steps();
2786  Tcl_SetObjResult(interp,SWIG_From_int(static_cast< int >(result)));
2787  return TCL_OK;
2788 fail:
2789  return TCL_ERROR;
2790 }
2791 
2792 
2793 SWIGINTERN int
2794 _wrap_a_element_steps(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2795  Tcl_Obj *CONST *argv = objv+1;
2796  int argc = objc-1;
2797  if (argc == 1) {
2798  int _v;
2799  void *vptr = 0;
2800  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2801  _v = SWIG_CheckState(res);
2802  if (_v) {
2803  return _wrap_a_element_steps__SWIG_1(clientData, interp, objc, argv - 1);
2804  }
2805  }
2806  if (argc == 2) {
2807  int _v;
2808  void *vptr = 0;
2809  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2810  _v = SWIG_CheckState(res);
2811  if (_v) {
2812  {
2813  int res = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2814  _v = SWIG_CheckState(res);
2815  }
2816  if (_v) {
2817  return _wrap_a_element_steps__SWIG_0(clientData, interp, objc, argv - 1);
2818  }
2819  }
2820  }
2821 
2822  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_steps'.\n"
2823  " Possible C/C++ prototypes are:\n"
2824  " a_element::steps(int const)\n"
2825  " a_element::steps() const\n", TCL_STATIC);
2826  return TCL_ERROR;
2827 }
2828 
2829 
2830 SWIGINTERN int
2831 _wrap_a_element_thickness__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2832  a_element *arg1 = (a_element *) 0 ;
2833  int arg2 ;
2834  void *argp1 = 0 ;
2835  int res1 = 0 ;
2836  int val2 ;
2837  int ecode2 = 0 ;
2838 
2839  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_thickness self int const ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2840  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2841  if (!SWIG_IsOK(res1)) {
2842  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_thickness" "', argument " "1"" of type '" "a_element *""'");
2843  }
2844  arg1 = reinterpret_cast< a_element * >(argp1);
2845  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2846  if (!SWIG_IsOK(ecode2)) {
2847  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_thickness" "', argument " "2"" of type '" "int""'");
2848  }
2849  arg2 = static_cast< int >(val2);
2850  (arg1)->thickness(arg2);
2851 
2852  return TCL_OK;
2853 fail:
2854  return TCL_ERROR;
2855 }
2856 
2857 
2858 SWIGINTERN int
2859 _wrap_a_element_thickness__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2860  a_element *arg1 = (a_element *) 0 ;
2861  void *argp1 = 0 ;
2862  int res1 = 0 ;
2863  int result;
2864 
2865  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_thickness self ",(void *)0) == TCL_ERROR) SWIG_fail;
2866  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2867  if (!SWIG_IsOK(res1)) {
2868  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_thickness" "', argument " "1"" of type '" "a_element const *""'");
2869  }
2870  arg1 = reinterpret_cast< a_element * >(argp1);
2871  result = (int)((a_element const *)arg1)->thickness();
2872  Tcl_SetObjResult(interp,SWIG_From_int(static_cast< int >(result)));
2873  return TCL_OK;
2874 fail:
2875  return TCL_ERROR;
2876 }
2877 
2878 
2879 SWIGINTERN int
2880 _wrap_a_element_thickness(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2881  Tcl_Obj *CONST *argv = objv+1;
2882  int argc = objc-1;
2883  if (argc == 1) {
2884  int _v;
2885  void *vptr = 0;
2886  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2887  _v = SWIG_CheckState(res);
2888  if (_v) {
2889  return _wrap_a_element_thickness__SWIG_1(clientData, interp, objc, argv - 1);
2890  }
2891  }
2892  if (argc == 2) {
2893  int _v;
2894  void *vptr = 0;
2895  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
2896  _v = SWIG_CheckState(res);
2897  if (_v) {
2898  {
2899  int res = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
2900  _v = SWIG_CheckState(res);
2901  }
2902  if (_v) {
2903  return _wrap_a_element_thickness__SWIG_0(clientData, interp, objc, argv - 1);
2904  }
2905  }
2906  }
2907 
2908  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_thickness'.\n"
2909  " Possible C/C++ prototypes are:\n"
2910  " a_element::thickness(int const)\n"
2911  " a_element::thickness() const\n", TCL_STATIC);
2912  return TCL_ERROR;
2913 }
2914 
2915 
2916 SWIGINTERN int
2917 _wrap_a_element_dxfout(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2918  a_element *arg1 = (a_element *) 0 ;
2919  std::ostream *arg2 = 0 ;
2920  void *argp1 = 0 ;
2921  int res1 = 0 ;
2922  void *argp2 = 0 ;
2923  int res2 = 0 ;
2924 
2925  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_dxfout self o ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2926  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2927  if (!SWIG_IsOK(res1)) {
2928  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_dxfout" "', argument " "1"" of type '" "a_element const *""'");
2929  }
2930  arg1 = reinterpret_cast< a_element * >(argp1);
2931  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__ostream, 0 );
2932  if (!SWIG_IsOK(res2)) {
2933  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_element_dxfout" "', argument " "2"" of type '" "std::ostream &""'");
2934  }
2935  if (!argp2) {
2936  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_element_dxfout" "', argument " "2"" of type '" "std::ostream &""'");
2937  }
2938  arg2 = reinterpret_cast< std::ostream * >(argp2);
2939  ((a_element const *)arg1)->dxfout(*arg2);
2940 
2941  return TCL_OK;
2942 fail:
2943  return TCL_ERROR;
2944 }
2945 
2946 
2947 SWIGINTERN int
2948 _wrap_a_element_visibility(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2949  a_element *arg1 = (a_element *) 0 ;
2950  int arg2 ;
2951  void *argp1 = 0 ;
2952  int res1 = 0 ;
2953  int val2 ;
2954  int ecode2 = 0 ;
2955 
2956  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_visibility self code ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2957  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2958  if (!SWIG_IsOK(res1)) {
2959  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_visibility" "', argument " "1"" of type '" "a_element *""'");
2960  }
2961  arg1 = reinterpret_cast< a_element * >(argp1);
2962  ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
2963  if (!SWIG_IsOK(ecode2)) {
2964  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_visibility" "', argument " "2"" of type '" "int""'");
2965  }
2966  arg2 = static_cast< int >(val2);
2967  (arg1)->visibility(arg2);
2968 
2969  return TCL_OK;
2970 fail:
2971  return TCL_ERROR;
2972 }
2973 
2974 
2975 SWIGINTERN int
2976 _wrap_a_element_isvisible(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2977  a_element *arg1 = (a_element *) 0 ;
2978  void *argp1 = 0 ;
2979  int res1 = 0 ;
2980  bool result;
2981 
2982  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_isvisible self ",(void *)0) == TCL_ERROR) SWIG_fail;
2983  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
2984  if (!SWIG_IsOK(res1)) {
2985  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_isvisible" "', argument " "1"" of type '" "a_element const *""'");
2986  }
2987  arg1 = reinterpret_cast< a_element * >(argp1);
2988  result = (bool)((a_element const *)arg1)->isvisible();
2989  Tcl_SetObjResult(interp,SWIG_From_bool(static_cast< bool >(result)));
2990  return TCL_OK;
2991 fail:
2992  return TCL_ERROR;
2993 }
2994 
2995 
2996 SWIGINTERN int
2997 _wrap_a_element_isnotvisible(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2998  a_element *arg1 = (a_element *) 0 ;
2999  void *argp1 = 0 ;
3000  int res1 = 0 ;
3001  bool result;
3002 
3003  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_isnotvisible self ",(void *)0) == TCL_ERROR) SWIG_fail;
3004  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3005  if (!SWIG_IsOK(res1)) {
3006  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_isnotvisible" "', argument " "1"" of type '" "a_element const *""'");
3007  }
3008  arg1 = reinterpret_cast< a_element * >(argp1);
3009  result = (bool)((a_element const *)arg1)->isnotvisible();
3010  Tcl_SetObjResult(interp,SWIG_From_bool(static_cast< bool >(result)));
3011  return TCL_OK;
3012 fail:
3013  return TCL_ERROR;
3014 }
3015 
3016 
3017 SWIGINTERN int
3018 _wrap_a_element_opacity(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3019  a_element *arg1 = (a_element *) 0 ;
3020  double arg2 ;
3021  void *argp1 = 0 ;
3022  int res1 = 0 ;
3023  double val2 ;
3024  int ecode2 = 0 ;
3025 
3026  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_opacity self val ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3027  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3028  if (!SWIG_IsOK(res1)) {
3029  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_opacity" "', argument " "1"" of type '" "a_element *""'");
3030  }
3031  arg1 = reinterpret_cast< a_element * >(argp1);
3032  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3033  if (!SWIG_IsOK(ecode2)) {
3034  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_opacity" "', argument " "2"" of type '" "double""'");
3035  }
3036  arg2 = static_cast< double >(val2);
3037  (arg1)->opacity(arg2);
3038 
3039  return TCL_OK;
3040 fail:
3041  return TCL_ERROR;
3042 }
3043 
3044 
3045 SWIGINTERN int
3046 _wrap_a_element_edges(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3047  a_element *arg1 = (a_element *) 0 ;
3048  bool arg2 ;
3049  void *argp1 = 0 ;
3050  int res1 = 0 ;
3051  bool val2 ;
3052  int ecode2 = 0 ;
3053 
3054  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_edges self val ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3055  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3056  if (!SWIG_IsOK(res1)) {
3057  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_edges" "', argument " "1"" of type '" "a_element *""'");
3058  }
3059  arg1 = reinterpret_cast< a_element * >(argp1);
3060  ecode2 = SWIG_AsVal_bool SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3061  if (!SWIG_IsOK(ecode2)) {
3062  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_edges" "', argument " "2"" of type '" "bool""'");
3063  }
3064  arg2 = static_cast< bool >(val2);
3065  (arg1)->edges(arg2);
3066 
3067  return TCL_OK;
3068 fail:
3069  return TCL_ERROR;
3070 }
3071 
3072 
3073 SWIGINTERN int
3074 _wrap_a_element_smooth(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3075  a_element *arg1 = (a_element *) 0 ;
3076  bool arg2 ;
3077  void *argp1 = 0 ;
3078  int res1 = 0 ;
3079  bool val2 ;
3080  int ecode2 = 0 ;
3081 
3082  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_smooth self val ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3083  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3084  if (!SWIG_IsOK(res1)) {
3085  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_smooth" "', argument " "1"" of type '" "a_element *""'");
3086  }
3087  arg1 = reinterpret_cast< a_element * >(argp1);
3088  ecode2 = SWIG_AsVal_bool SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3089  if (!SWIG_IsOK(ecode2)) {
3090  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_smooth" "', argument " "2"" of type '" "bool""'");
3091  }
3092  arg2 = static_cast< bool >(val2);
3093  (arg1)->smooth(arg2);
3094 
3095  return TCL_OK;
3096 fail:
3097  return TCL_ERROR;
3098 }
3099 
3100 
3101 SWIGINTERN int
3102 _wrap_a_element_image(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3103  a_element *arg1 = (a_element *) 0 ;
3104  a_image *arg2 = 0 ;
3105  void *argp1 = 0 ;
3106  int res1 = 0 ;
3107  void *argp2 = 0 ;
3108  int res2 = 0 ;
3109 
3110  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_image self image ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3111  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3112  if (!SWIG_IsOK(res1)) {
3113  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_image" "', argument " "1"" of type '" "a_element *""'");
3114  }
3115  arg1 = reinterpret_cast< a_element * >(argp1);
3116  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_image, 0 );
3117  if (!SWIG_IsOK(res2)) {
3118  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_element_image" "', argument " "2"" of type '" "a_image &""'");
3119  }
3120  if (!argp2) {
3121  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_element_image" "', argument " "2"" of type '" "a_image &""'");
3122  }
3123  arg2 = reinterpret_cast< a_image * >(argp2);
3124  (arg1)->image(*arg2);
3125 
3126  return TCL_OK;
3127 fail:
3128  return TCL_ERROR;
3129 }
3130 
3131 
3132 SWIGINTERN int
3133 _wrap_a_element_imageon(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3134  a_element *arg1 = (a_element *) 0 ;
3135  void *argp1 = 0 ;
3136  int res1 = 0 ;
3137 
3138  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_imageon self ",(void *)0) == TCL_ERROR) SWIG_fail;
3139  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3140  if (!SWIG_IsOK(res1)) {
3141  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_imageon" "', argument " "1"" of type '" "a_element *""'");
3142  }
3143  arg1 = reinterpret_cast< a_element * >(argp1);
3144  (arg1)->imageon();
3145 
3146  return TCL_OK;
3147 fail:
3148  return TCL_ERROR;
3149 }
3150 
3151 
3152 SWIGINTERN int
3153 _wrap_a_element_imageoff(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3154  a_element *arg1 = (a_element *) 0 ;
3155  void *argp1 = 0 ;
3156  int res1 = 0 ;
3157 
3158  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_imageoff self ",(void *)0) == TCL_ERROR) SWIG_fail;
3159  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3160  if (!SWIG_IsOK(res1)) {
3161  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_imageoff" "', argument " "1"" of type '" "a_element *""'");
3162  }
3163  arg1 = reinterpret_cast< a_element * >(argp1);
3164  (arg1)->imageoff();
3165 
3166  return TCL_OK;
3167 fail:
3168  return TCL_ERROR;
3169 }
3170 
3171 
3172 SWIGINTERN int
3173 _wrap_a_element_open(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3174  a_element *arg1 = (a_element *) 0 ;
3175  std::string arg2 ;
3176  void *argp1 = 0 ;
3177  int res1 = 0 ;
3178 
3179  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_open self file ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3180  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3181  if (!SWIG_IsOK(res1)) {
3182  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_open" "', argument " "1"" of type '" "a_element *""'");
3183  }
3184  arg1 = reinterpret_cast< a_element * >(argp1);
3185  {
3186  std::string *ptr = (std::string *)0;
3187  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
3188  if (!SWIG_IsOK(res) || !ptr) {
3189  SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "a_element_open" "', argument " "2"" of type '" "std::string const""'");
3190  }
3191  arg2 = *ptr;
3192  if (SWIG_IsNewObj(res)) delete ptr;
3193  }
3194  (arg1)->open(arg2);
3195 
3196  return TCL_OK;
3197 fail:
3198  return TCL_ERROR;
3199 }
3200 
3201 
3202 SWIGINTERN int
3203 _wrap_a_element_save(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3204  a_element *arg1 = (a_element *) 0 ;
3205  std::string arg2 ;
3206  void *argp1 = 0 ;
3207  int res1 = 0 ;
3208 
3209  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_save self file ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3210  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3211  if (!SWIG_IsOK(res1)) {
3212  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_save" "', argument " "1"" of type '" "a_element *""'");
3213  }
3214  arg1 = reinterpret_cast< a_element * >(argp1);
3215  {
3216  std::string *ptr = (std::string *)0;
3217  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
3218  if (!SWIG_IsOK(res) || !ptr) {
3219  SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "a_element_save" "', argument " "2"" of type '" "std::string const""'");
3220  }
3221  arg2 = *ptr;
3222  if (SWIG_IsNewObj(res)) delete ptr;
3223  }
3224  (arg1)->save(arg2);
3225 
3226  return TCL_OK;
3227 fail:
3228  return TCL_ERROR;
3229 }
3230 
3231 
3232 SWIGINTERN int
3233 _wrap_a_element_save_transform(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3234  a_element *arg1 = (a_element *) 0 ;
3235  std::string arg2 ;
3236  void *argp1 = 0 ;
3237  int res1 = 0 ;
3238 
3239  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_save_transform self file ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3240  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3241  if (!SWIG_IsOK(res1)) {
3242  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_save_transform" "', argument " "1"" of type '" "a_element *""'");
3243  }
3244  arg1 = reinterpret_cast< a_element * >(argp1);
3245  {
3246  std::string *ptr = (std::string *)0;
3247  int res = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
3248  if (!SWIG_IsOK(res) || !ptr) {
3249  SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "a_element_save_transform" "', argument " "2"" of type '" "std::string const""'");
3250  }
3251  arg2 = *ptr;
3252  if (SWIG_IsNewObj(res)) delete ptr;
3253  }
3254  (arg1)->save_transform(arg2);
3255 
3256  return TCL_OK;
3257 fail:
3258  return TCL_ERROR;
3259 }
3260 
3261 
3262 SWIGINTERN int
3263 _wrap_a_element_open_scalars(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3264  a_element *arg1 = (a_element *) 0 ;
3265  std::string *arg2 = 0 ;
3266  void *argp1 = 0 ;
3267  int res1 = 0 ;
3268  int res2 = SWIG_OLDOBJ ;
3269 
3270  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_open_scalars self file ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3271  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3272  if (!SWIG_IsOK(res1)) {
3273  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_open_scalars" "', argument " "1"" of type '" "a_element *""'");
3274  }
3275  arg1 = reinterpret_cast< a_element * >(argp1);
3276  {
3277  std::string *ptr = (std::string *)0;
3278  res2 = SWIG_AsPtr_std_string SWIG_TCL_CALL_ARGS_2(objv[2], &ptr);
3279  if (!SWIG_IsOK(res2)) {
3280  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_element_open_scalars" "', argument " "2"" of type '" "std::string const &""'");
3281  }
3282  if (!ptr) {
3283  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_element_open_scalars" "', argument " "2"" of type '" "std::string const &""'");
3284  }
3285  arg2 = ptr;
3286  }
3287  (arg1)->open_scalars((std::string const &)*arg2);
3288 
3289  if (SWIG_IsNewObj(res2)) delete arg2;
3290  return TCL_OK;
3291 fail:
3292  if (SWIG_IsNewObj(res2)) delete arg2;
3293  return TCL_ERROR;
3294 }
3295 
3296 
3297 SWIGINTERN int
3298 _wrap_a_element_reset_mapper_clipping(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3299  a_element *arg1 = (a_element *) 0 ;
3300  void *argp1 = 0 ;
3301  int res1 = 0 ;
3302 
3303  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_reset_mapper_clipping self ",(void *)0) == TCL_ERROR) SWIG_fail;
3304  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3305  if (!SWIG_IsOK(res1)) {
3306  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_reset_mapper_clipping" "', argument " "1"" of type '" "a_element *""'");
3307  }
3308  arg1 = reinterpret_cast< a_element * >(argp1);
3309  (arg1)->reset_mapper_clipping();
3310 
3311  return TCL_OK;
3312 fail:
3313  return TCL_ERROR;
3314 }
3315 
3316 
3317 SWIGINTERN int
3318 _wrap_a_element_place__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3319  a_element *arg1 = (a_element *) 0 ;
3320  double arg2 ;
3321  double arg3 ;
3322  double arg4 ;
3323  void *argp1 = 0 ;
3324  int res1 = 0 ;
3325  double val2 ;
3326  int ecode2 = 0 ;
3327  double val3 ;
3328  int ecode3 = 0 ;
3329  double val4 ;
3330  int ecode4 = 0 ;
3331 
3332  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_element_place self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3333  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3334  if (!SWIG_IsOK(res1)) {
3335  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_place" "', argument " "1"" of type '" "a_element *""'");
3336  }
3337  arg1 = reinterpret_cast< a_element * >(argp1);
3338  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3339  if (!SWIG_IsOK(ecode2)) {
3340  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_place" "', argument " "2"" of type '" "double""'");
3341  }
3342  arg2 = static_cast< double >(val2);
3343  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3344  if (!SWIG_IsOK(ecode3)) {
3345  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_element_place" "', argument " "3"" of type '" "double""'");
3346  }
3347  arg3 = static_cast< double >(val3);
3348  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3349  if (!SWIG_IsOK(ecode4)) {
3350  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_element_place" "', argument " "4"" of type '" "double""'");
3351  }
3352  arg4 = static_cast< double >(val4);
3353  (arg1)->place(arg2,arg3,arg4);
3354 
3355  return TCL_OK;
3356 fail:
3357  return TCL_ERROR;
3358 }
3359 
3360 
3361 SWIGINTERN int
3362 _wrap_a_element_translate(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3363  a_element *arg1 = (a_element *) 0 ;
3364  double arg2 ;
3365  double arg3 ;
3366  double arg4 ;
3367  void *argp1 = 0 ;
3368  int res1 = 0 ;
3369  double val2 ;
3370  int ecode2 = 0 ;
3371  double val3 ;
3372  int ecode3 = 0 ;
3373  double val4 ;
3374  int ecode4 = 0 ;
3375 
3376  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_element_translate self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3377  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3378  if (!SWIG_IsOK(res1)) {
3379  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_translate" "', argument " "1"" of type '" "a_element *""'");
3380  }
3381  arg1 = reinterpret_cast< a_element * >(argp1);
3382  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3383  if (!SWIG_IsOK(ecode2)) {
3384  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_translate" "', argument " "2"" of type '" "double""'");
3385  }
3386  arg2 = static_cast< double >(val2);
3387  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3388  if (!SWIG_IsOK(ecode3)) {
3389  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_element_translate" "', argument " "3"" of type '" "double""'");
3390  }
3391  arg3 = static_cast< double >(val3);
3392  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3393  if (!SWIG_IsOK(ecode4)) {
3394  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_element_translate" "', argument " "4"" of type '" "double""'");
3395  }
3396  arg4 = static_cast< double >(val4);
3397  (arg1)->translate(arg2,arg3,arg4);
3398 
3399  return TCL_OK;
3400 fail:
3401  return TCL_ERROR;
3402 }
3403 
3404 
3405 SWIGINTERN int
3406 _wrap_a_element_origin__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3407  a_element *arg1 = (a_element *) 0 ;
3408  double arg2 ;
3409  double arg3 ;
3410  double arg4 ;
3411  void *argp1 = 0 ;
3412  int res1 = 0 ;
3413  double val2 ;
3414  int ecode2 = 0 ;
3415  double val3 ;
3416  int ecode3 = 0 ;
3417  double val4 ;
3418  int ecode4 = 0 ;
3419 
3420  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_element_origin self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3421  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3422  if (!SWIG_IsOK(res1)) {
3423  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_origin" "', argument " "1"" of type '" "a_element *""'");
3424  }
3425  arg1 = reinterpret_cast< a_element * >(argp1);
3426  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3427  if (!SWIG_IsOK(ecode2)) {
3428  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_origin" "', argument " "2"" of type '" "double""'");
3429  }
3430  arg2 = static_cast< double >(val2);
3431  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3432  if (!SWIG_IsOK(ecode3)) {
3433  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_element_origin" "', argument " "3"" of type '" "double""'");
3434  }
3435  arg3 = static_cast< double >(val3);
3436  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3437  if (!SWIG_IsOK(ecode4)) {
3438  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_element_origin" "', argument " "4"" of type '" "double""'");
3439  }
3440  arg4 = static_cast< double >(val4);
3441  (arg1)->origin(arg2,arg3,arg4);
3442 
3443  return TCL_OK;
3444 fail:
3445  return TCL_ERROR;
3446 }
3447 
3448 
3449 SWIGINTERN int
3450 _wrap_a_element_orient__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3451  a_element *arg1 = (a_element *) 0 ;
3452  double arg2 ;
3453  double arg3 ;
3454  double arg4 ;
3455  void *argp1 = 0 ;
3456  int res1 = 0 ;
3457  double val2 ;
3458  int ecode2 = 0 ;
3459  double val3 ;
3460  int ecode3 = 0 ;
3461  double val4 ;
3462  int ecode4 = 0 ;
3463 
3464  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_element_orient self pitch roll yaw ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3465  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3466  if (!SWIG_IsOK(res1)) {
3467  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_orient" "', argument " "1"" of type '" "a_element *""'");
3468  }
3469  arg1 = reinterpret_cast< a_element * >(argp1);
3470  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3471  if (!SWIG_IsOK(ecode2)) {
3472  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_orient" "', argument " "2"" of type '" "double""'");
3473  }
3474  arg2 = static_cast< double >(val2);
3475  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3476  if (!SWIG_IsOK(ecode3)) {
3477  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_element_orient" "', argument " "3"" of type '" "double""'");
3478  }
3479  arg3 = static_cast< double >(val3);
3480  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3481  if (!SWIG_IsOK(ecode4)) {
3482  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_element_orient" "', argument " "4"" of type '" "double""'");
3483  }
3484  arg4 = static_cast< double >(val4);
3485  (arg1)->orient(arg2,arg3,arg4);
3486 
3487  return TCL_OK;
3488 fail:
3489  return TCL_ERROR;
3490 }
3491 
3492 
3493 SWIGINTERN int
3494 _wrap_a_element_rotate(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3495  a_element *arg1 = (a_element *) 0 ;
3496  double arg2 ;
3497  double arg3 ;
3498  double arg4 ;
3499  void *argp1 = 0 ;
3500  int res1 = 0 ;
3501  double val2 ;
3502  int ecode2 = 0 ;
3503  double val3 ;
3504  int ecode3 = 0 ;
3505  double val4 ;
3506  int ecode4 = 0 ;
3507 
3508  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_element_rotate self pitch roll yaw ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3509  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3510  if (!SWIG_IsOK(res1)) {
3511  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_rotate" "', argument " "1"" of type '" "a_element *""'");
3512  }
3513  arg1 = reinterpret_cast< a_element * >(argp1);
3514  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3515  if (!SWIG_IsOK(ecode2)) {
3516  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_rotate" "', argument " "2"" of type '" "double""'");
3517  }
3518  arg2 = static_cast< double >(val2);
3519  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3520  if (!SWIG_IsOK(ecode3)) {
3521  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_element_rotate" "', argument " "3"" of type '" "double""'");
3522  }
3523  arg3 = static_cast< double >(val3);
3524  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3525  if (!SWIG_IsOK(ecode4)) {
3526  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_element_rotate" "', argument " "4"" of type '" "double""'");
3527  }
3528  arg4 = static_cast< double >(val4);
3529  (arg1)->rotate(arg2,arg3,arg4);
3530 
3531  return TCL_OK;
3532 fail:
3533  return TCL_ERROR;
3534 }
3535 
3536 
3537 SWIGINTERN int
3538 _wrap_a_element_scale__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3539  a_element *arg1 = (a_element *) 0 ;
3540  double arg2 ;
3541  void *argp1 = 0 ;
3542  int res1 = 0 ;
3543  double val2 ;
3544  int ecode2 = 0 ;
3545 
3546  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_scale self s ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3547  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3548  if (!SWIG_IsOK(res1)) {
3549  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_scale" "', argument " "1"" of type '" "a_element *""'");
3550  }
3551  arg1 = reinterpret_cast< a_element * >(argp1);
3552  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3553  if (!SWIG_IsOK(ecode2)) {
3554  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_scale" "', argument " "2"" of type '" "double""'");
3555  }
3556  arg2 = static_cast< double >(val2);
3557  (arg1)->scale(arg2);
3558 
3559  return TCL_OK;
3560 fail:
3561  return TCL_ERROR;
3562 }
3563 
3564 
3565 SWIGINTERN int
3566 _wrap_a_element_scale__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3567  a_element *arg1 = (a_element *) 0 ;
3568  double arg2 ;
3569  double arg3 ;
3570  double arg4 ;
3571  void *argp1 = 0 ;
3572  int res1 = 0 ;
3573  double val2 ;
3574  int ecode2 = 0 ;
3575  double val3 ;
3576  int ecode3 = 0 ;
3577  double val4 ;
3578  int ecode4 = 0 ;
3579 
3580  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_element_scale self s1 s2 s3 ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3581  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3582  if (!SWIG_IsOK(res1)) {
3583  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_scale" "', argument " "1"" of type '" "a_element *""'");
3584  }
3585  arg1 = reinterpret_cast< a_element * >(argp1);
3586  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3587  if (!SWIG_IsOK(ecode2)) {
3588  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_scale" "', argument " "2"" of type '" "double""'");
3589  }
3590  arg2 = static_cast< double >(val2);
3591  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3592  if (!SWIG_IsOK(ecode3)) {
3593  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_element_scale" "', argument " "3"" of type '" "double""'");
3594  }
3595  arg3 = static_cast< double >(val3);
3596  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3597  if (!SWIG_IsOK(ecode4)) {
3598  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_element_scale" "', argument " "4"" of type '" "double""'");
3599  }
3600  arg4 = static_cast< double >(val4);
3601  (arg1)->scale(arg2,arg3,arg4);
3602 
3603  return TCL_OK;
3604 fail:
3605  return TCL_ERROR;
3606 }
3607 
3608 
3609 SWIGINTERN int
3610 _wrap_a_element_small__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3611  a_element *arg1 = (a_element *) 0 ;
3612  void *argp1 = 0 ;
3613  int res1 = 0 ;
3614  double result;
3615 
3616  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_small self ",(void *)0) == TCL_ERROR) SWIG_fail;
3617  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3618  if (!SWIG_IsOK(res1)) {
3619  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_small" "', argument " "1"" of type '" "a_element const *""'");
3620  }
3621  arg1 = reinterpret_cast< a_element * >(argp1);
3622  result = (double)((a_element const *)arg1)->small();
3623  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3624  return TCL_OK;
3625 fail:
3626  return TCL_ERROR;
3627 }
3628 
3629 
3630 SWIGINTERN int
3631 _wrap_a_element_small__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3632  a_element *arg1 = (a_element *) 0 ;
3633  double arg2 ;
3634  void *argp1 = 0 ;
3635  int res1 = 0 ;
3636  double val2 ;
3637  int ecode2 = 0 ;
3638 
3639  if (SWIG_GetArgs(interp, objc, objv,"oo:a_element_small self s ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3640  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3641  if (!SWIG_IsOK(res1)) {
3642  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_small" "', argument " "1"" of type '" "a_element *""'");
3643  }
3644  arg1 = reinterpret_cast< a_element * >(argp1);
3645  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
3646  if (!SWIG_IsOK(ecode2)) {
3647  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_small" "', argument " "2"" of type '" "double""'");
3648  }
3649  arg2 = static_cast< double >(val2);
3650  (arg1)->small(arg2);
3651 
3652  return TCL_OK;
3653 fail:
3654  return TCL_ERROR;
3655 }
3656 
3657 
3658 SWIGINTERN int
3659 _wrap_a_element_small(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3660  Tcl_Obj *CONST *argv = objv+1;
3661  int argc = objc-1;
3662  if (argc == 1) {
3663  int _v;
3664  void *vptr = 0;
3665  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
3666  _v = SWIG_CheckState(res);
3667  if (_v) {
3668  return _wrap_a_element_small__SWIG_0(clientData, interp, objc, argv - 1);
3669  }
3670  }
3671  if (argc == 2) {
3672  int _v;
3673  void *vptr = 0;
3674  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
3675  _v = SWIG_CheckState(res);
3676  if (_v) {
3677  {
3678  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3679  _v = SWIG_CheckState(res);
3680  }
3681  if (_v) {
3682  return _wrap_a_element_small__SWIG_1(clientData, interp, objc, argv - 1);
3683  }
3684  }
3685  }
3686 
3687  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_small'.\n"
3688  " Possible C/C++ prototypes are:\n"
3689  " a_element::small() const\n"
3690  " a_element::small(double const)\n", TCL_STATIC);
3691  return TCL_ERROR;
3692 }
3693 
3694 
3695 SWIGINTERN int
3696 _wrap_a_element_size(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3697  a_element *arg1 = (a_element *) 0 ;
3698  void *argp1 = 0 ;
3699  int res1 = 0 ;
3700  double result;
3701 
3702  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_size self ",(void *)0) == TCL_ERROR) SWIG_fail;
3703  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3704  if (!SWIG_IsOK(res1)) {
3705  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_size" "', argument " "1"" of type '" "a_element const *""'");
3706  }
3707  arg1 = reinterpret_cast< a_element * >(argp1);
3708  result = (double)((a_element const *)arg1)->size();
3709  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3710  return TCL_OK;
3711 fail:
3712  return TCL_ERROR;
3713 }
3714 
3715 
3716 SWIGINTERN int
3717 _wrap_a_element_minx(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3718  a_element *arg1 = (a_element *) 0 ;
3719  void *argp1 = 0 ;
3720  int res1 = 0 ;
3721  double result;
3722 
3723  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_minx self ",(void *)0) == TCL_ERROR) SWIG_fail;
3724  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3725  if (!SWIG_IsOK(res1)) {
3726  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_minx" "', argument " "1"" of type '" "a_element const *""'");
3727  }
3728  arg1 = reinterpret_cast< a_element * >(argp1);
3729  result = (double)((a_element const *)arg1)->minx();
3730  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3731  return TCL_OK;
3732 fail:
3733  return TCL_ERROR;
3734 }
3735 
3736 
3737 SWIGINTERN int
3738 _wrap_a_element_maxx(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3739  a_element *arg1 = (a_element *) 0 ;
3740  void *argp1 = 0 ;
3741  int res1 = 0 ;
3742  double result;
3743 
3744  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_maxx self ",(void *)0) == TCL_ERROR) SWIG_fail;
3745  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3746  if (!SWIG_IsOK(res1)) {
3747  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_maxx" "', argument " "1"" of type '" "a_element const *""'");
3748  }
3749  arg1 = reinterpret_cast< a_element * >(argp1);
3750  result = (double)((a_element const *)arg1)->maxx();
3751  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3752  return TCL_OK;
3753 fail:
3754  return TCL_ERROR;
3755 }
3756 
3757 
3758 SWIGINTERN int
3759 _wrap_a_element_miny(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3760  a_element *arg1 = (a_element *) 0 ;
3761  void *argp1 = 0 ;
3762  int res1 = 0 ;
3763  double result;
3764 
3765  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_miny self ",(void *)0) == TCL_ERROR) SWIG_fail;
3766  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3767  if (!SWIG_IsOK(res1)) {
3768  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_miny" "', argument " "1"" of type '" "a_element const *""'");
3769  }
3770  arg1 = reinterpret_cast< a_element * >(argp1);
3771  result = (double)((a_element const *)arg1)->miny();
3772  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3773  return TCL_OK;
3774 fail:
3775  return TCL_ERROR;
3776 }
3777 
3778 
3779 SWIGINTERN int
3780 _wrap_a_element_maxy(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3781  a_element *arg1 = (a_element *) 0 ;
3782  void *argp1 = 0 ;
3783  int res1 = 0 ;
3784  double result;
3785 
3786  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_maxy self ",(void *)0) == TCL_ERROR) SWIG_fail;
3787  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3788  if (!SWIG_IsOK(res1)) {
3789  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_maxy" "', argument " "1"" of type '" "a_element const *""'");
3790  }
3791  arg1 = reinterpret_cast< a_element * >(argp1);
3792  result = (double)((a_element const *)arg1)->maxy();
3793  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3794  return TCL_OK;
3795 fail:
3796  return TCL_ERROR;
3797 }
3798 
3799 
3800 SWIGINTERN int
3801 _wrap_a_element_minz(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3802  a_element *arg1 = (a_element *) 0 ;
3803  void *argp1 = 0 ;
3804  int res1 = 0 ;
3805  double result;
3806 
3807  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_minz self ",(void *)0) == TCL_ERROR) SWIG_fail;
3808  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3809  if (!SWIG_IsOK(res1)) {
3810  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_minz" "', argument " "1"" of type '" "a_element const *""'");
3811  }
3812  arg1 = reinterpret_cast< a_element * >(argp1);
3813  result = (double)((a_element const *)arg1)->minz();
3814  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3815  return TCL_OK;
3816 fail:
3817  return TCL_ERROR;
3818 }
3819 
3820 
3821 SWIGINTERN int
3822 _wrap_a_element_maxz(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3823  a_element *arg1 = (a_element *) 0 ;
3824  void *argp1 = 0 ;
3825  int res1 = 0 ;
3826  double result;
3827 
3828  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_maxz self ",(void *)0) == TCL_ERROR) SWIG_fail;
3829  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3830  if (!SWIG_IsOK(res1)) {
3831  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_maxz" "', argument " "1"" of type '" "a_element const *""'");
3832  }
3833  arg1 = reinterpret_cast< a_element * >(argp1);
3834  result = (double)((a_element const *)arg1)->maxz();
3835  Tcl_SetObjResult(interp,SWIG_From_double(static_cast< double >(result)));
3836  return TCL_OK;
3837 fail:
3838  return TCL_ERROR;
3839 }
3840 
3841 
3842 SWIGINTERN int
3843 _wrap_a_element_origin__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3844  a_element *arg1 = (a_element *) 0 ;
3845  void *argp1 = 0 ;
3846  int res1 = 0 ;
3847  std::string result;
3848 
3849  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_origin self ",(void *)0) == TCL_ERROR) SWIG_fail;
3850  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3851  if (!SWIG_IsOK(res1)) {
3852  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_origin" "', argument " "1"" of type '" "a_element const *""'");
3853  }
3854  arg1 = reinterpret_cast< a_element * >(argp1);
3855  result = a_element_origin__SWIG_1((a_element const *)arg1);
3856  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
3857  return TCL_OK;
3858 fail:
3859  return TCL_ERROR;
3860 }
3861 
3862 
3863 SWIGINTERN int
3864 _wrap_a_element_origin(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3865  Tcl_Obj *CONST *argv = objv+1;
3866  int argc = objc-1;
3867  if (argc == 1) {
3868  int _v;
3869  void *vptr = 0;
3870  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
3871  _v = SWIG_CheckState(res);
3872  if (_v) {
3873  return _wrap_a_element_origin__SWIG_1(clientData, interp, objc, argv - 1);
3874  }
3875  }
3876  if (argc == 4) {
3877  int _v;
3878  void *vptr = 0;
3879  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
3880  _v = SWIG_CheckState(res);
3881  if (_v) {
3882  {
3883  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3884  _v = SWIG_CheckState(res);
3885  }
3886  if (_v) {
3887  {
3888  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
3889  _v = SWIG_CheckState(res);
3890  }
3891  if (_v) {
3892  {
3893  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
3894  _v = SWIG_CheckState(res);
3895  }
3896  if (_v) {
3897  return _wrap_a_element_origin__SWIG_0(clientData, interp, objc, argv - 1);
3898  }
3899  }
3900  }
3901  }
3902  }
3903 
3904  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_origin'.\n"
3905  " Possible C/C++ prototypes are:\n"
3906  " a_element::origin(double const,double const,double const)\n"
3907  " a_element::origin() const\n", TCL_STATIC);
3908  return TCL_ERROR;
3909 }
3910 
3911 
3912 SWIGINTERN int
3913 _wrap_a_element_place__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3914  a_element *arg1 = (a_element *) 0 ;
3915  void *argp1 = 0 ;
3916  int res1 = 0 ;
3917  std::string result;
3918 
3919  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_place self ",(void *)0) == TCL_ERROR) SWIG_fail;
3920  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3921  if (!SWIG_IsOK(res1)) {
3922  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_place" "', argument " "1"" of type '" "a_element const *""'");
3923  }
3924  arg1 = reinterpret_cast< a_element * >(argp1);
3925  result = a_element_place__SWIG_1((a_element const *)arg1);
3926  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
3927  return TCL_OK;
3928 fail:
3929  return TCL_ERROR;
3930 }
3931 
3932 
3933 SWIGINTERN int
3934 _wrap_a_element_place(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3935  Tcl_Obj *CONST *argv = objv+1;
3936  int argc = objc-1;
3937  if (argc == 1) {
3938  int _v;
3939  void *vptr = 0;
3940  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
3941  _v = SWIG_CheckState(res);
3942  if (_v) {
3943  return _wrap_a_element_place__SWIG_1(clientData, interp, objc, argv - 1);
3944  }
3945  }
3946  if (argc == 4) {
3947  int _v;
3948  void *vptr = 0;
3949  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
3950  _v = SWIG_CheckState(res);
3951  if (_v) {
3952  {
3953  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
3954  _v = SWIG_CheckState(res);
3955  }
3956  if (_v) {
3957  {
3958  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
3959  _v = SWIG_CheckState(res);
3960  }
3961  if (_v) {
3962  {
3963  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
3964  _v = SWIG_CheckState(res);
3965  }
3966  if (_v) {
3967  return _wrap_a_element_place__SWIG_0(clientData, interp, objc, argv - 1);
3968  }
3969  }
3970  }
3971  }
3972  }
3973 
3974  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_place'.\n"
3975  " Possible C/C++ prototypes are:\n"
3976  " a_element::place(double const,double const,double const)\n"
3977  " a_element::place() const\n", TCL_STATIC);
3978  return TCL_ERROR;
3979 }
3980 
3981 
3982 SWIGINTERN int
3983 _wrap_a_element_orient__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3984  a_element *arg1 = (a_element *) 0 ;
3985  void *argp1 = 0 ;
3986  int res1 = 0 ;
3987  std::string result;
3988 
3989  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_orient self ",(void *)0) == TCL_ERROR) SWIG_fail;
3990  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
3991  if (!SWIG_IsOK(res1)) {
3992  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_orient" "', argument " "1"" of type '" "a_element const *""'");
3993  }
3994  arg1 = reinterpret_cast< a_element * >(argp1);
3995  result = a_element_orient__SWIG_1((a_element const *)arg1);
3996  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
3997  return TCL_OK;
3998 fail:
3999  return TCL_ERROR;
4000 }
4001 
4002 
4003 SWIGINTERN int
4004 _wrap_a_element_orient(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4005  Tcl_Obj *CONST *argv = objv+1;
4006  int argc = objc-1;
4007  if (argc == 1) {
4008  int _v;
4009  void *vptr = 0;
4010  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
4011  _v = SWIG_CheckState(res);
4012  if (_v) {
4013  return _wrap_a_element_orient__SWIG_1(clientData, interp, objc, argv - 1);
4014  }
4015  }
4016  if (argc == 4) {
4017  int _v;
4018  void *vptr = 0;
4019  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
4020  _v = SWIG_CheckState(res);
4021  if (_v) {
4022  {
4023  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4024  _v = SWIG_CheckState(res);
4025  }
4026  if (_v) {
4027  {
4028  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4029  _v = SWIG_CheckState(res);
4030  }
4031  if (_v) {
4032  {
4033  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
4034  _v = SWIG_CheckState(res);
4035  }
4036  if (_v) {
4037  return _wrap_a_element_orient__SWIG_0(clientData, interp, objc, argv - 1);
4038  }
4039  }
4040  }
4041  }
4042  }
4043 
4044  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_orient'.\n"
4045  " Possible C/C++ prototypes are:\n"
4046  " a_element::orient(double const,double const,double const)\n"
4047  " a_element::orient() const\n", TCL_STATIC);
4048  return TCL_ERROR;
4049 }
4050 
4051 
4052 SWIGINTERN int
4053 _wrap_a_element_scale__SWIG_2(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4054  a_element *arg1 = (a_element *) 0 ;
4055  void *argp1 = 0 ;
4056  int res1 = 0 ;
4057  std::string result;
4058 
4059  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_scale self ",(void *)0) == TCL_ERROR) SWIG_fail;
4060  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
4061  if (!SWIG_IsOK(res1)) {
4062  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_scale" "', argument " "1"" of type '" "a_element const *""'");
4063  }
4064  arg1 = reinterpret_cast< a_element * >(argp1);
4065  result = a_element_scale__SWIG_2((a_element const *)arg1);
4066  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4067  return TCL_OK;
4068 fail:
4069  return TCL_ERROR;
4070 }
4071 
4072 
4073 SWIGINTERN int
4074 _wrap_a_element_scale(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4075  Tcl_Obj *CONST *argv = objv+1;
4076  int argc = objc-1;
4077  if (argc == 1) {
4078  int _v;
4079  void *vptr = 0;
4080  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
4081  _v = SWIG_CheckState(res);
4082  if (_v) {
4083  return _wrap_a_element_scale__SWIG_2(clientData, interp, objc, argv - 1);
4084  }
4085  }
4086  if (argc == 2) {
4087  int _v;
4088  void *vptr = 0;
4089  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
4090  _v = SWIG_CheckState(res);
4091  if (_v) {
4092  {
4093  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4094  _v = SWIG_CheckState(res);
4095  }
4096  if (_v) {
4097  return _wrap_a_element_scale__SWIG_0(clientData, interp, objc, argv - 1);
4098  }
4099  }
4100  }
4101  if (argc == 4) {
4102  int _v;
4103  void *vptr = 0;
4104  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_element, 0);
4105  _v = SWIG_CheckState(res);
4106  if (_v) {
4107  {
4108  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4109  _v = SWIG_CheckState(res);
4110  }
4111  if (_v) {
4112  {
4113  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4114  _v = SWIG_CheckState(res);
4115  }
4116  if (_v) {
4117  {
4118  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
4119  _v = SWIG_CheckState(res);
4120  }
4121  if (_v) {
4122  return _wrap_a_element_scale__SWIG_1(clientData, interp, objc, argv - 1);
4123  }
4124  }
4125  }
4126  }
4127  }
4128 
4129  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_element_scale'.\n"
4130  " Possible C/C++ prototypes are:\n"
4131  " a_element::scale(double)\n"
4132  " a_element::scale(double,double,double)\n"
4133  " a_element::scale() const\n", TCL_STATIC);
4134  return TCL_ERROR;
4135 }
4136 
4137 
4138 SWIGINTERN int
4139 _wrap_a_element_center(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4140  a_element *arg1 = (a_element *) 0 ;
4141  void *argp1 = 0 ;
4142  int res1 = 0 ;
4143  std::string result;
4144 
4145  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_center self ",(void *)0) == TCL_ERROR) SWIG_fail;
4146  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
4147  if (!SWIG_IsOK(res1)) {
4148  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_center" "', argument " "1"" of type '" "a_element const *""'");
4149  }
4150  arg1 = reinterpret_cast< a_element * >(argp1);
4151  result = a_element_center((a_element const *)arg1);
4152  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4153  return TCL_OK;
4154 fail:
4155  return TCL_ERROR;
4156 }
4157 
4158 
4159 SWIGINTERN int
4160 _wrap_a_element_bounds(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4161  a_element *arg1 = (a_element *) 0 ;
4162  void *argp1 = 0 ;
4163  int res1 = 0 ;
4164  std::string result;
4165 
4166  if (SWIG_GetArgs(interp, objc, objv,"o:a_element_bounds self ",(void *)0) == TCL_ERROR) SWIG_fail;
4167  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
4168  if (!SWIG_IsOK(res1)) {
4169  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_bounds" "', argument " "1"" of type '" "a_element const *""'");
4170  }
4171  arg1 = reinterpret_cast< a_element * >(argp1);
4172  result = a_element_bounds((a_element const *)arg1);
4173  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4174  return TCL_OK;
4175 fail:
4176  return TCL_ERROR;
4177 }
4178 
4179 
4180 SWIGINTERN int
4181 _wrap_a_element_relief(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4182  a_element *arg1 = (a_element *) 0 ;
4183  double arg2 ;
4184  double arg3 ;
4185  double arg4 ;
4186  double arg5 ;
4187  double arg6 ;
4188  double arg7 ;
4189  void *argp1 = 0 ;
4190  int res1 = 0 ;
4191  double val2 ;
4192  int ecode2 = 0 ;
4193  double val3 ;
4194  int ecode3 = 0 ;
4195  double val4 ;
4196  int ecode4 = 0 ;
4197  double val5 ;
4198  int ecode5 = 0 ;
4199  double val6 ;
4200  int ecode6 = 0 ;
4201  double val7 ;
4202  int ecode7 = 0 ;
4203 
4204  if (SWIG_GetArgs(interp, objc, objv,"ooooooo:a_element_relief 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;
4205  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_element, 0 | 0 );
4206  if (!SWIG_IsOK(res1)) {
4207  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_element_relief" "', argument " "1"" of type '" "a_element *""'");
4208  }
4209  arg1 = reinterpret_cast< a_element * >(argp1);
4210  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
4211  if (!SWIG_IsOK(ecode2)) {
4212  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_element_relief" "', argument " "2"" of type '" "double""'");
4213  }
4214  arg2 = static_cast< double >(val2);
4215  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4216  if (!SWIG_IsOK(ecode3)) {
4217  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_element_relief" "', argument " "3"" of type '" "double""'");
4218  }
4219  arg3 = static_cast< double >(val3);
4220  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
4221  if (!SWIG_IsOK(ecode4)) {
4222  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_element_relief" "', argument " "4"" of type '" "double""'");
4223  }
4224  arg4 = static_cast< double >(val4);
4225  ecode5 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[5], &val5);
4226  if (!SWIG_IsOK(ecode5)) {
4227  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "a_element_relief" "', argument " "5"" of type '" "double""'");
4228  }
4229  arg5 = static_cast< double >(val5);
4230  ecode6 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[6], &val6);
4231  if (!SWIG_IsOK(ecode6)) {
4232  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "a_element_relief" "', argument " "6"" of type '" "double""'");
4233  }
4234  arg6 = static_cast< double >(val6);
4235  ecode7 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[7], &val7);
4236  if (!SWIG_IsOK(ecode7)) {
4237  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "a_element_relief" "', argument " "7"" of type '" "double""'");
4238  }
4239  arg7 = static_cast< double >(val7);
4240  a_element_relief(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
4241 
4242  return TCL_OK;
4243 fail:
4244  return TCL_ERROR;
4245 }
4246 
4247 
4249 a_element *arg1 = (a_element *) obj;
4250 delete arg1;
4251 }
4253  {"reset", _wrap_a_element_reset},
4254  {"name", _wrap_a_element_name},
4255  {"empty", _wrap_a_element_empty},
4256  {"color", _wrap_a_element_color},
4257  {"R", _wrap_a_element_R},
4258  {"G", _wrap_a_element_G},
4259  {"B", _wrap_a_element_B},
4260  {"zebra", _wrap_a_element_zebra},
4261  {"greyscale", _wrap_a_element_greyscale},
4262  {"steps", _wrap_a_element_steps},
4263  {"thickness", _wrap_a_element_thickness},
4264  {"dxfout", _wrap_a_element_dxfout},
4265  {"visibility", _wrap_a_element_visibility},
4266  {"isvisible", _wrap_a_element_isvisible},
4267  {"isnotvisible", _wrap_a_element_isnotvisible},
4268  {"opacity", _wrap_a_element_opacity},
4269  {"edges", _wrap_a_element_edges},
4270  {"smooth", _wrap_a_element_smooth},
4271  {"image", _wrap_a_element_image},
4272  {"imageon", _wrap_a_element_imageon},
4273  {"imageoff", _wrap_a_element_imageoff},
4274  {"open", _wrap_a_element_open},
4275  {"save", _wrap_a_element_save},
4276  {"save_transform", _wrap_a_element_save_transform},
4277  {"open_scalars", _wrap_a_element_open_scalars},
4278  {"reset_mapper_clipping", _wrap_a_element_reset_mapper_clipping},
4279  {"translate", _wrap_a_element_translate},
4280  {"rotate", _wrap_a_element_rotate},
4281  {"small", _wrap_a_element_small},
4282  {"size", _wrap_a_element_size},
4283  {"minx", _wrap_a_element_minx},
4284  {"maxx", _wrap_a_element_maxx},
4285  {"miny", _wrap_a_element_miny},
4286  {"maxy", _wrap_a_element_maxy},
4287  {"minz", _wrap_a_element_minz},
4288  {"maxz", _wrap_a_element_maxz},
4289  {"origin", _wrap_a_element_origin},
4290  {"place", _wrap_a_element_place},
4291  {"orient", _wrap_a_element_orient},
4292  {"scale", _wrap_a_element_scale},
4293  {"center", _wrap_a_element_center},
4294  {"bounds", _wrap_a_element_bounds},
4295  {"relief", _wrap_a_element_relief},
4296  {0,0}
4297 };
4299  {0,0,0}
4300 };
4302 static const char * swig_a_element_base_names[] = {0};
4304 SWIGINTERN int
4305 _wrap_new_a_axes(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4306  a_axes *result = 0 ;
4307 
4308  if (SWIG_GetArgs(interp, objc, objv,":new_a_axes ") == TCL_ERROR) SWIG_fail;
4309  result = (a_axes *)new a_axes();
4310  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_axes,0));
4311  return TCL_OK;
4312 fail:
4313  return TCL_ERROR;
4314 }
4315 
4316 
4317 SWIGINTERN int
4318 _wrap_delete_a_axes(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4319  a_axes *arg1 = (a_axes *) 0 ;
4320  void *argp1 = 0 ;
4321  int res1 = 0 ;
4322 
4323  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_axes self ",(void *)0) == TCL_ERROR) SWIG_fail;
4324  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_axes, SWIG_POINTER_DISOWN | 0 );
4325  if (!SWIG_IsOK(res1)) {
4326  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_axes" "', argument " "1"" of type '" "a_axes *""'");
4327  }
4328  arg1 = reinterpret_cast< a_axes * >(argp1);
4329  delete arg1;
4330 
4331  return TCL_OK;
4332 fail:
4333  return TCL_ERROR;
4334 }
4335 
4336 
4337 SWIGINTERN int
4338 _wrap_a_axes_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4339  std::string result;
4340 
4341  if (SWIG_GetArgs(interp, objc, objv,":a_axes_help ") == TCL_ERROR) SWIG_fail;
4342  result = a_axes::help();
4343  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4344  return TCL_OK;
4345 fail:
4346  return TCL_ERROR;
4347 }
4348 
4349 
4351 a_axes *arg1 = (a_axes *) obj;
4352 delete arg1;
4353 }
4355  {0,0}
4356 };
4358  {0,0,0}
4359 };
4360 static swig_class *swig_a_axes_bases[] = {0,0};
4361 static const char * swig_a_axes_base_names[] = {"a_element *",0};
4363 SWIGINTERN int
4364 _wrap_new_a_pointcloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4365  a_pointcloud *result = 0 ;
4366 
4367  if (SWIG_GetArgs(interp, objc, objv,":new_a_pointcloud ") == TCL_ERROR) SWIG_fail;
4368  result = (a_pointcloud *)new a_pointcloud();
4369  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_pointcloud,0));
4370  return TCL_OK;
4371 fail:
4372  return TCL_ERROR;
4373 }
4374 
4375 
4376 SWIGINTERN int
4377 _wrap_delete_a_pointcloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4378  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4379  void *argp1 = 0 ;
4380  int res1 = 0 ;
4381 
4382  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_pointcloud self ",(void *)0) == TCL_ERROR) SWIG_fail;
4383  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, SWIG_POINTER_DISOWN | 0 );
4384  if (!SWIG_IsOK(res1)) {
4385  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_pointcloud" "', argument " "1"" of type '" "a_pointcloud *""'");
4386  }
4387  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4388  delete arg1;
4389 
4390  return TCL_OK;
4391 fail:
4392  return TCL_ERROR;
4393 }
4394 
4395 
4396 SWIGINTERN int
4397 _wrap_a_pointcloud_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4398  std::string result;
4399 
4400  if (SWIG_GetArgs(interp, objc, objv,":a_pointcloud_help ") == TCL_ERROR) SWIG_fail;
4401  result = a_pointcloud::help();
4402  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4403  return TCL_OK;
4404 fail:
4405  return TCL_ERROR;
4406 }
4407 
4408 
4409 SWIGINTERN int
4410 _wrap_a_pointcloud_type(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4411  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4412  void *argp1 = 0 ;
4413  int res1 = 0 ;
4414  std::string result;
4415 
4416  if (SWIG_GetArgs(interp, objc, objv,"o:a_pointcloud_type self ",(void *)0) == TCL_ERROR) SWIG_fail;
4417  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, 0 | 0 );
4418  if (!SWIG_IsOK(res1)) {
4419  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_pointcloud_type" "', argument " "1"" of type '" "a_pointcloud const *""'");
4420  }
4421  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4422  result = ((a_pointcloud const *)arg1)->type();
4423  Tcl_SetObjResult(interp,SWIG_From_std_string(static_cast< std::string >(result)));
4424  return TCL_OK;
4425 fail:
4426  return TCL_ERROR;
4427 }
4428 
4429 
4430 SWIGINTERN int
4431 _wrap_a_pointcloud_np(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4432  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4433  void *argp1 = 0 ;
4434  int res1 = 0 ;
4435  int result;
4436 
4437  if (SWIG_GetArgs(interp, objc, objv,"o:a_pointcloud_np self ",(void *)0) == TCL_ERROR) SWIG_fail;
4438  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, 0 | 0 );
4439  if (!SWIG_IsOK(res1)) {
4440  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_pointcloud_np" "', argument " "1"" of type '" "a_pointcloud const *""'");
4441  }
4442  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4443  result = (int)((a_pointcloud const *)arg1)->np();
4444  Tcl_SetObjResult(interp,SWIG_From_int(static_cast< int >(result)));
4445  return TCL_OK;
4446 fail:
4447  return TCL_ERROR;
4448 }
4449 
4450 
4451 SWIGINTERN int
4452 _wrap_a_pointcloud_clear(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4453  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4454  void *argp1 = 0 ;
4455  int res1 = 0 ;
4456 
4457  if (SWIG_GetArgs(interp, objc, objv,"o:a_pointcloud_clear self ",(void *)0) == TCL_ERROR) SWIG_fail;
4458  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, 0 | 0 );
4459  if (!SWIG_IsOK(res1)) {
4460  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_pointcloud_clear" "', argument " "1"" of type '" "a_pointcloud *""'");
4461  }
4462  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4463  (arg1)->clear();
4464 
4465  return TCL_OK;
4466 fail:
4467  return TCL_ERROR;
4468 }
4469 
4470 
4471 SWIGINTERN int
4472 _wrap_a_pointcloud_eraselastpoint(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4473  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4474  void *argp1 = 0 ;
4475  int res1 = 0 ;
4476 
4477  if (SWIG_GetArgs(interp, objc, objv,"o:a_pointcloud_eraselastpoint self ",(void *)0) == TCL_ERROR) SWIG_fail;
4478  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, 0 | 0 );
4479  if (!SWIG_IsOK(res1)) {
4480  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_pointcloud_eraselastpoint" "', argument " "1"" of type '" "a_pointcloud *""'");
4481  }
4482  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4483  (arg1)->eraselastpoint();
4484 
4485  return TCL_OK;
4486 fail:
4487  return TCL_ERROR;
4488 }
4489 
4490 
4491 SWIGINTERN int
4492 _wrap_a_pointcloud_dxfout(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4493  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4494  std::ostream *arg2 = 0 ;
4495  void *argp1 = 0 ;
4496  int res1 = 0 ;
4497  void *argp2 = 0 ;
4498  int res2 = 0 ;
4499 
4500  if (SWIG_GetArgs(interp, objc, objv,"oo:a_pointcloud_dxfout self o ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4501  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, 0 | 0 );
4502  if (!SWIG_IsOK(res1)) {
4503  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_pointcloud_dxfout" "', argument " "1"" of type '" "a_pointcloud const *""'");
4504  }
4505  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4506  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_std__ostream, 0 );
4507  if (!SWIG_IsOK(res2)) {
4508  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_pointcloud_dxfout" "', argument " "2"" of type '" "std::ostream &""'");
4509  }
4510  if (!argp2) {
4511  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_pointcloud_dxfout" "', argument " "2"" of type '" "std::ostream &""'");
4512  }
4513  arg2 = reinterpret_cast< std::ostream * >(argp2);
4514  ((a_pointcloud const *)arg1)->dxfout(*arg2);
4515 
4516  return TCL_OK;
4517 fail:
4518  return TCL_ERROR;
4519 }
4520 
4521 
4522 SWIGINTERN int
4523 _wrap_a_pointcloud_append(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4524  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4525  a_pointcloud *arg2 = 0 ;
4526  void *argp1 = 0 ;
4527  int res1 = 0 ;
4528  void *argp2 ;
4529  int res2 = 0 ;
4530 
4531  if (SWIG_GetArgs(interp, objc, objv,"oo:a_pointcloud_append self a_pointcloud const & ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4532  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, 0 | 0 );
4533  if (!SWIG_IsOK(res1)) {
4534  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_pointcloud_append" "', argument " "1"" of type '" "a_pointcloud *""'");
4535  }
4536  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4537  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_pointcloud, 0 );
4538  if (!SWIG_IsOK(res2)) {
4539  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_pointcloud_append" "', argument " "2"" of type '" "a_pointcloud const &""'");
4540  }
4541  if (!argp2) {
4542  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_pointcloud_append" "', argument " "2"" of type '" "a_pointcloud const &""'");
4543  }
4544  arg2 = reinterpret_cast< a_pointcloud * >(argp2);
4545  (arg1)->append((a_pointcloud const &)*arg2);
4546 
4547  return TCL_OK;
4548 fail:
4549  return TCL_ERROR;
4550 }
4551 
4552 
4553 SWIGINTERN int
4554 _wrap_a_pointcloud_reset_mapper_clipping(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4555  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4556  void *argp1 = 0 ;
4557  int res1 = 0 ;
4558 
4559  if (SWIG_GetArgs(interp, objc, objv,"o:a_pointcloud_reset_mapper_clipping self ",(void *)0) == TCL_ERROR) SWIG_fail;
4560  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, 0 | 0 );
4561  if (!SWIG_IsOK(res1)) {
4562  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_pointcloud_reset_mapper_clipping" "', argument " "1"" of type '" "a_pointcloud *""'");
4563  }
4564  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4565  (arg1)->reset_mapper_clipping();
4566 
4567  return TCL_OK;
4568 fail:
4569  return TCL_ERROR;
4570 }
4571 
4572 
4573 SWIGINTERN int
4574 _wrap_a_pointcloud_cloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4575  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4576  void *argp1 = 0 ;
4577  int res1 = 0 ;
4578  std::vector< a_point > result;
4579 
4580  if (SWIG_GetArgs(interp, objc, objv,"o:a_pointcloud_cloud self ",(void *)0) == TCL_ERROR) SWIG_fail;
4581  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, 0 | 0 );
4582  if (!SWIG_IsOK(res1)) {
4583  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_pointcloud_cloud" "', argument " "1"" of type '" "a_pointcloud const *""'");
4584  }
4585  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4586  result = ((a_pointcloud const *)arg1)->cloud();
4587  Tcl_SetObjResult(interp,SWIG_NewInstanceObj((new std::vector< a_point >(static_cast< const std::vector< a_point >& >(result))), SWIGTYPE_p_std__vectorT_a_point_t, SWIG_POINTER_OWN | 0 ));
4588  return TCL_OK;
4589 fail:
4590  return TCL_ERROR;
4591 }
4592 
4593 
4594 SWIGINTERN int
4595 _wrap_a_pointcloud_point__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4596  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4597  double arg2 ;
4598  double arg3 ;
4599  double arg4 ;
4600  void *argp1 = 0 ;
4601  int res1 = 0 ;
4602  double val2 ;
4603  int ecode2 = 0 ;
4604  double val3 ;
4605  int ecode3 = 0 ;
4606  double val4 ;
4607  int ecode4 = 0 ;
4608 
4609  if (SWIG_GetArgs(interp, objc, objv,"oooo:a_pointcloud_point self x y z ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4610  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, 0 | 0 );
4611  if (!SWIG_IsOK(res1)) {
4612  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_pointcloud_point" "', argument " "1"" of type '" "a_pointcloud *""'");
4613  }
4614  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4615  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
4616  if (!SWIG_IsOK(ecode2)) {
4617  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_pointcloud_point" "', argument " "2"" of type '" "double""'");
4618  }
4619  arg2 = static_cast< double >(val2);
4620  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
4621  if (!SWIG_IsOK(ecode3)) {
4622  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_pointcloud_point" "', argument " "3"" of type '" "double""'");
4623  }
4624  arg3 = static_cast< double >(val3);
4625  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
4626  if (!SWIG_IsOK(ecode4)) {
4627  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_pointcloud_point" "', argument " "4"" of type '" "double""'");
4628  }
4629  arg4 = static_cast< double >(val4);
4630  a_pointcloud_point__SWIG_0(arg1,arg2,arg3,arg4);
4631 
4632  return TCL_OK;
4633 fail:
4634  return TCL_ERROR;
4635 }
4636 
4637 
4638 SWIGINTERN int
4639 _wrap_a_pointcloud_point__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4640  a_pointcloud *arg1 = (a_pointcloud *) 0 ;
4641  a_point *arg2 = 0 ;
4642  void *argp1 = 0 ;
4643  int res1 = 0 ;
4644  void *argp2 ;
4645  int res2 = 0 ;
4646 
4647  if (SWIG_GetArgs(interp, objc, objv,"oo:a_pointcloud_point self p ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4648  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_pointcloud, 0 | 0 );
4649  if (!SWIG_IsOK(res1)) {
4650  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_pointcloud_point" "', argument " "1"" of type '" "a_pointcloud *""'");
4651  }
4652  arg1 = reinterpret_cast< a_pointcloud * >(argp1);
4653  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4654  if (!SWIG_IsOK(res2)) {
4655  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_pointcloud_point" "', argument " "2"" of type '" "a_point const &""'");
4656  }
4657  if (!argp2) {
4658  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_pointcloud_point" "', argument " "2"" of type '" "a_point const &""'");
4659  }
4660  arg2 = reinterpret_cast< a_point * >(argp2);
4661  a_pointcloud_point__SWIG_1(arg1,(a_point const &)*arg2);
4662 
4663  return TCL_OK;
4664 fail:
4665  return TCL_ERROR;
4666 }
4667 
4668 
4669 SWIGINTERN int
4670 _wrap_a_pointcloud_point(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4671  Tcl_Obj *CONST *argv = objv+1;
4672  int argc = objc-1;
4673  if (argc == 2) {
4674  int _v;
4675  void *vptr = 0;
4676  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_pointcloud, 0);
4677  _v = SWIG_CheckState(res);
4678  if (_v) {
4679  void *vptr = 0;
4680  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
4681  _v = SWIG_CheckState(res);
4682  if (_v) {
4683  return _wrap_a_pointcloud_point__SWIG_1(clientData, interp, objc, argv - 1);
4684  }
4685  }
4686  }
4687  if (argc == 4) {
4688  int _v;
4689  void *vptr = 0;
4690  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_pointcloud, 0);
4691  _v = SWIG_CheckState(res);
4692  if (_v) {
4693  {
4694  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
4695  _v = SWIG_CheckState(res);
4696  }
4697  if (_v) {
4698  {
4699  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
4700  _v = SWIG_CheckState(res);
4701  }
4702  if (_v) {
4703  {
4704  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
4705  _v = SWIG_CheckState(res);
4706  }
4707  if (_v) {
4708  return _wrap_a_pointcloud_point__SWIG_0(clientData, interp, objc, argv - 1);
4709  }
4710  }
4711  }
4712  }
4713  }
4714 
4715  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_pointcloud_point'.\n"
4716  " Possible C/C++ prototypes are:\n"
4717  " a_pointcloud::point(double,double,double)\n"
4718  " a_pointcloud::point(a_point const &)\n", TCL_STATIC);
4719  return TCL_ERROR;
4720 }
4721 
4722 
4724 a_pointcloud *arg1 = (a_pointcloud *) obj;
4725 delete arg1;
4726 }
4728  {"type", _wrap_a_pointcloud_type},
4729  {"np", _wrap_a_pointcloud_np},
4730  {"clear", _wrap_a_pointcloud_clear},
4731  {"eraselastpoint", _wrap_a_pointcloud_eraselastpoint},
4732  {"dxfout", _wrap_a_pointcloud_dxfout},
4733  {"append", _wrap_a_pointcloud_append},
4734  {"reset_mapper_clipping", _wrap_a_pointcloud_reset_mapper_clipping},
4735  {"cloud", _wrap_a_pointcloud_cloud},
4736  {"point", _wrap_a_pointcloud_point},
4737  {0,0}
4738 };
4740  {0,0,0}
4741 };
4743 static const char * swig_a_pointcloud_base_names[] = {"a_element *",0};
4745 SWIGINTERN int
4746 _wrap_new_a_linecloud__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4747  a_linecloud *result = 0 ;
4748 
4749  if (SWIG_GetArgs(interp, objc, objv,":new_a_linecloud ") == TCL_ERROR) SWIG_fail;
4750  result = (a_linecloud *)new a_linecloud();
4751  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_linecloud,0));
4752  return TCL_OK;
4753 fail:
4754  return TCL_ERROR;
4755 }
4756 
4757 
4758 SWIGINTERN int
4759 _wrap_new_a_linecloud__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4760  a_linecloud *arg1 = 0 ;
4761  void *argp1 ;
4762  int res1 = 0 ;
4763  a_linecloud *result = 0 ;
4764 
4765  if (SWIG_GetArgs(interp, objc, objv,"o:new_a_linecloud c ",(void *)0) == TCL_ERROR) SWIG_fail;
4766  res1 = SWIG_ConvertPtr(objv[1], &argp1, SWIGTYPE_p_a_linecloud, 0 );
4767  if (!SWIG_IsOK(res1)) {
4768  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_a_linecloud" "', argument " "1"" of type '" "a_linecloud const &""'");
4769  }
4770  if (!argp1) {
4771  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_a_linecloud" "', argument " "1"" of type '" "a_linecloud const &""'");
4772  }
4773  arg1 = reinterpret_cast< a_linecloud * >(argp1);
4774  result = (a_linecloud *)new a_linecloud((a_linecloud const &)*arg1);
4775  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_linecloud,0));
4776  return TCL_OK;
4777 fail:
4778  return TCL_ERROR;
4779 }
4780 
4781 
4782 SWIGINTERN int
4783 _wrap_new_a_linecloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4784  Tcl_Obj *CONST *argv = objv+1;
4785  int argc = objc-1;
4786  if (argc == 0) {
4787  return _wrap_new_a_linecloud__SWIG_0(clientData, interp, objc, argv - 1);
4788  }
4789  if (argc == 1) {
4790  int _v;
4791  void *vptr = 0;
4792  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_linecloud, SWIG_POINTER_NO_NULL);
4793  _v = SWIG_CheckState(res);
4794  if (_v) {
4795  return _wrap_new_a_linecloud__SWIG_1(clientData, interp, objc, argv - 1);
4796  }
4797  }
4798 
4799  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'new_a_linecloud'.\n"
4800  " Possible C/C++ prototypes are:\n"
4801  " a_linecloud::a_linecloud()\n"
4802  " a_linecloud::a_linecloud(a_linecloud const &)\n", TCL_STATIC);
4803  return TCL_ERROR;
4804 }
4805 
4806 
4807 SWIGINTERN int
4808 _wrap_delete_a_linecloud(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4809  a_linecloud *arg1 = (a_linecloud *) 0 ;
4810  void *argp1 = 0 ;
4811  int res1 = 0 ;
4812 
4813  if (SWIG_GetArgs(interp, objc, objv,"o:delete_a_linecloud self ",(void *)0) == TCL_ERROR) SWIG_fail;
4814  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_linecloud, SWIG_POINTER_DISOWN | 0 );
4815  if (!SWIG_IsOK(res1)) {
4816  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_a_linecloud" "', argument " "1"" of type '" "a_linecloud *""'");
4817  }
4818  arg1 = reinterpret_cast< a_linecloud * >(argp1);
4819  delete arg1;
4820 
4821  return TCL_OK;
4822 fail:
4823  return TCL_ERROR;
4824 }
4825 
4826 
4827 SWIGINTERN int
4828 _wrap_a_linecloud_help(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4829  std::string result;
4830 
4831  if (SWIG_GetArgs(interp, objc, objv,":a_linecloud_help ") == TCL_ERROR) SWIG_fail;
4832  result = a_linecloud::help();
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_linecloud_clear(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4842  a_linecloud *arg1 = (a_linecloud *) 0 ;
4843  void *argp1 = 0 ;
4844  int res1 = 0 ;
4845 
4846  if (SWIG_GetArgs(interp, objc, objv,"o:a_linecloud_clear self ",(void *)0) == TCL_ERROR) SWIG_fail;
4847  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_linecloud, 0 | 0 );
4848  if (!SWIG_IsOK(res1)) {
4849  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_linecloud_clear" "', argument " "1"" of type '" "a_linecloud *""'");
4850  }
4851  arg1 = reinterpret_cast< a_linecloud * >(argp1);
4852  (arg1)->clear();
4853 
4854  return TCL_OK;
4855 fail:
4856  return TCL_ERROR;
4857 }
4858 
4859 
4860 SWIGINTERN int
4861 _wrap_a_linecloud_add(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4862  a_linecloud *arg1 = (a_linecloud *) 0 ;
4863  a_linecloud *arg2 = 0 ;
4864  void *argp1 = 0 ;
4865  int res1 = 0 ;
4866  void *argp2 ;
4867  int res2 = 0 ;
4868  a_linecloud *result = 0 ;
4869 
4870  if (SWIG_GetArgs(interp, objc, objv,"oo:a_linecloud_add self c ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4871  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_linecloud, 0 | 0 );
4872  if (!SWIG_IsOK(res1)) {
4873  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_linecloud_add" "', argument " "1"" of type '" "a_linecloud *""'");
4874  }
4875  arg1 = reinterpret_cast< a_linecloud * >(argp1);
4876  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_linecloud, 0 );
4877  if (!SWIG_IsOK(res2)) {
4878  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_linecloud_add" "', argument " "2"" of type '" "a_linecloud const &""'");
4879  }
4880  if (!argp2) {
4881  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_linecloud_add" "', argument " "2"" of type '" "a_linecloud const &""'");
4882  }
4883  arg2 = reinterpret_cast< a_linecloud * >(argp2);
4884  result = (a_linecloud *) &(arg1)->operator +=((a_linecloud const &)*arg2);
4885  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_a_linecloud,0));
4886  return TCL_OK;
4887 fail:
4888  return TCL_ERROR;
4889 }
4890 
4891 
4892 SWIGINTERN int
4893 _wrap_a_linecloud_nl(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4894  a_linecloud *arg1 = (a_linecloud *) 0 ;
4895  void *argp1 = 0 ;
4896  int res1 = 0 ;
4897  int result;
4898 
4899  if (SWIG_GetArgs(interp, objc, objv,"o:a_linecloud_nl self ",(void *)0) == TCL_ERROR) SWIG_fail;
4900  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_linecloud, 0 | 0 );
4901  if (!SWIG_IsOK(res1)) {
4902  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_linecloud_nl" "', argument " "1"" of type '" "a_linecloud const *""'");
4903  }
4904  arg1 = reinterpret_cast< a_linecloud * >(argp1);
4905  result = (int)((a_linecloud const *)arg1)->nl();
4906  Tcl_SetObjResult(interp,SWIG_From_int(static_cast< int >(result)));
4907  return TCL_OK;
4908 fail:
4909  return TCL_ERROR;
4910 }
4911 
4912 
4913 SWIGINTERN int
4914 _wrap_a_linecloud_append(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4915  a_linecloud *arg1 = (a_linecloud *) 0 ;
4916  a_linecloud *arg2 = 0 ;
4917  void *argp1 = 0 ;
4918  int res1 = 0 ;
4919  void *argp2 ;
4920  int res2 = 0 ;
4921 
4922  if (SWIG_GetArgs(interp, objc, objv,"oo:a_linecloud_append self a_linecloud const & ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4923  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_linecloud, 0 | 0 );
4924  if (!SWIG_IsOK(res1)) {
4925  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_linecloud_append" "', argument " "1"" of type '" "a_linecloud *""'");
4926  }
4927  arg1 = reinterpret_cast< a_linecloud * >(argp1);
4928  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_linecloud, 0 );
4929  if (!SWIG_IsOK(res2)) {
4930  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_linecloud_append" "', argument " "2"" of type '" "a_linecloud const &""'");
4931  }
4932  if (!argp2) {
4933  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_linecloud_append" "', argument " "2"" of type '" "a_linecloud const &""'");
4934  }
4935  arg2 = reinterpret_cast< a_linecloud * >(argp2);
4936  (arg1)->append((a_linecloud const &)*arg2);
4937 
4938  return TCL_OK;
4939 fail:
4940  return TCL_ERROR;
4941 }
4942 
4943 
4944 SWIGINTERN int
4945 _wrap_a_linecloud_line__SWIG_0(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4946  a_linecloud *arg1 = (a_linecloud *) 0 ;
4947  a_point *arg2 = 0 ;
4948  a_point *arg3 = 0 ;
4949  void *argp1 = 0 ;
4950  int res1 = 0 ;
4951  void *argp2 ;
4952  int res2 = 0 ;
4953  void *argp3 ;
4954  int res3 = 0 ;
4955 
4956  if (SWIG_GetArgs(interp, objc, objv,"ooo:a_linecloud_line self p1 p2 ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
4957  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_linecloud, 0 | 0 );
4958  if (!SWIG_IsOK(res1)) {
4959  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_linecloud_line" "', argument " "1"" of type '" "a_linecloud *""'");
4960  }
4961  arg1 = reinterpret_cast< a_linecloud * >(argp1);
4962  res2 = SWIG_ConvertPtr(objv[2], &argp2, SWIGTYPE_p_a_point, 0 );
4963  if (!SWIG_IsOK(res2)) {
4964  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "a_linecloud_line" "', argument " "2"" of type '" "a_point const &""'");
4965  }
4966  if (!argp2) {
4967  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_linecloud_line" "', argument " "2"" of type '" "a_point const &""'");
4968  }
4969  arg2 = reinterpret_cast< a_point * >(argp2);
4970  res3 = SWIG_ConvertPtr(objv[3], &argp3, SWIGTYPE_p_a_point, 0 );
4971  if (!SWIG_IsOK(res3)) {
4972  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "a_linecloud_line" "', argument " "3"" of type '" "a_point const &""'");
4973  }
4974  if (!argp3) {
4975  SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "a_linecloud_line" "', argument " "3"" of type '" "a_point const &""'");
4976  }
4977  arg3 = reinterpret_cast< a_point * >(argp3);
4978  a_linecloud_line__SWIG_0(arg1,(a_point const &)*arg2,(a_point const &)*arg3);
4979 
4980  return TCL_OK;
4981 fail:
4982  return TCL_ERROR;
4983 }
4984 
4985 
4986 SWIGINTERN int
4987 _wrap_a_linecloud_line__SWIG_1(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
4988  a_linecloud *arg1 = (a_linecloud *) 0 ;
4989  double arg2 ;
4990  double arg3 ;
4991  double arg4 ;
4992  double arg5 ;
4993  double arg6 ;
4994  double arg7 ;
4995  void *argp1 = 0 ;
4996  int res1 = 0 ;
4997  double val2 ;
4998  int ecode2 = 0 ;
4999  double val3 ;
5000  int ecode3 = 0 ;
5001  double val4 ;
5002  int ecode4 = 0 ;
5003  double val5 ;
5004  int ecode5 = 0 ;
5005  double val6 ;
5006  int ecode6 = 0 ;
5007  double val7 ;
5008  int ecode7 = 0 ;
5009 
5010  if (SWIG_GetArgs(interp, objc, objv,"ooooooo:a_linecloud_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;
5011  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_a_linecloud, 0 | 0 );
5012  if (!SWIG_IsOK(res1)) {
5013  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "a_linecloud_line" "', argument " "1"" of type '" "a_linecloud *""'");
5014  }
5015  arg1 = reinterpret_cast< a_linecloud * >(argp1);
5016  ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
5017  if (!SWIG_IsOK(ecode2)) {
5018  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "a_linecloud_line" "', argument " "2"" of type '" "double""'");
5019  }
5020  arg2 = static_cast< double >(val2);
5021  ecode3 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
5022  if (!SWIG_IsOK(ecode3)) {
5023  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "a_linecloud_line" "', argument " "3"" of type '" "double""'");
5024  }
5025  arg3 = static_cast< double >(val3);
5026  ecode4 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
5027  if (!SWIG_IsOK(ecode4)) {
5028  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "a_linecloud_line" "', argument " "4"" of type '" "double""'");
5029  }
5030  arg4 = static_cast< double >(val4);
5031  ecode5 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[5], &val5);
5032  if (!SWIG_IsOK(ecode5)) {
5033  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "a_linecloud_line" "', argument " "5"" of type '" "double""'");
5034  }
5035  arg5 = static_cast< double >(val5);
5036  ecode6 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[6], &val6);
5037  if (!SWIG_IsOK(ecode6)) {
5038  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "a_linecloud_line" "', argument " "6"" of type '" "double""'");
5039  }
5040  arg6 = static_cast< double >(val6);
5041  ecode7 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[7], &val7);
5042  if (!SWIG_IsOK(ecode7)) {
5043  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "a_linecloud_line" "', argument " "7"" of type '" "double""'");
5044  }
5045  arg7 = static_cast< double >(val7);
5046  a_linecloud_line__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
5047 
5048  return TCL_OK;
5049 fail:
5050  return TCL_ERROR;
5051 }
5052 
5053 
5054 SWIGINTERN int
5055 _wrap_a_linecloud_line(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
5056  Tcl_Obj *CONST *argv = objv+1;
5057  int argc = objc-1;
5058  if (argc == 3) {
5059  int _v;
5060  void *vptr = 0;
5061  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_linecloud, 0);
5062  _v = SWIG_CheckState(res);
5063  if (_v) {
5064  void *vptr = 0;
5065  int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
5066  _v = SWIG_CheckState(res);
5067  if (_v) {
5068  void *vptr = 0;
5069  int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_a_point, SWIG_POINTER_NO_NULL);
5070  _v = SWIG_CheckState(res);
5071  if (_v) {
5072  return _wrap_a_linecloud_line__SWIG_0(clientData, interp, objc, argv - 1);
5073  }
5074  }
5075  }
5076  }
5077  if (argc == 7) {
5078  int _v;
5079  void *vptr = 0;
5080  int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_linecloud, 0);
5081  _v = SWIG_CheckState(res);
5082  if (_v) {
5083  {
5084  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[1], NULL);
5085  _v = SWIG_CheckState(res);
5086  }
5087  if (_v) {
5088  {
5089  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[2], NULL);
5090  _v = SWIG_CheckState(res);
5091  }
5092  if (_v) {
5093  {
5094  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[3], NULL);
5095  _v = SWIG_CheckState(res);
5096  }
5097  if (_v) {
5098  {
5099  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[4], NULL);
5100  _v = SWIG_CheckState(res);
5101  }
5102  if (_v) {
5103  {
5104  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[5], NULL);
5105  _v = SWIG_CheckState(res);
5106  }
5107  if (_v) {
5108  {
5109  int res = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(argv[6], NULL);
5110  _v = SWIG_CheckState(res);
5111  }
5112  if (_v) {
5113  return _wrap_a_linecloud_line__SWIG_1(clientData, interp, objc, argv - 1);
5114  }
5115  }
5116  }
5117  }
5118  }
5119  }
5120  }
5121  }
5122 
5123  Tcl_SetResult(interp,(char *) "Wrong number or type of arguments for overloaded function 'a_linecloud_line'.\n"
5124  " Possible C/C++ prototypes are:\n"
5125  " a_linecloud::line(a_point const &,a_point const &)\n"
5126  " a_linecloud::line(double,double,double,double,double,double)\n", TCL_STATIC);
5127  return TCL_ERROR;
5128 }
5129 
5130 
5132 a_linecloud *arg1 = (a_linecloud *) obj;
5133 delete arg1;
5134 }
5136  {"clear", _wrap_a_linecloud_clear},
5137  {"add", _wrap_a_linecloud_add},
5138  {"nl", _wrap_a_linecloud_nl},
5139  {"append", _wrap_a_linecloud_append},
5140  {"line", _wrap_a_linecloud_line},
5141  {0,0}
5142 };
5144  {0,0,0}
5145 };
5147 static const char * swig_a_linecloud_base_names[] = {"a_element *",0};